В этой статье я расскажу про мой способ расчета приоритета комбинаций в техасском холдеме (покере с 2 карманными картами и 5 общими). Условно разделю статью на 6 частей: Создание массива карт, Расчет Стрита, Расчет Флеша и Стрит Флеша, Расчет Парных комбинаций, Окончательный расчет, Вывод на экран. Код пишу в процедурном стиле.

Цель: получить на выходе программы удобочитаемый результат, доступный для дебаггинга и отладки еще на стадии написания кода. Для достижения поставленной цели делаю разницу между комбинациями в 1e+2 (100) раз.

Примерный вид того, что должно получиться в итоге, где 2 последние карты считаю карманными, а первые 5 общими:

Создание массива карт

В колоде 4 масти и 13 достоинств, поэтому массив из 7 чисел буду формировать в диапазоне [2 — 14, 102 — 114, 202 — 214, 302 — 314], а далее оперировать остатками от деления на 100 (%100) этих чисел. Можно, конечно, формировать массив из чисел в диапазоне [2 — 14, 22 — 34, 42 — 54, 62 — 74], а затем сравнивать остатками от деления на 20 (%20). Но удобочитаемость первого варианта по-моему на лицо, поэтому остановлюсь на нем.

function cardsCreation()
{
    $arrayCards = [];
    for ($i = 0; $i < 7; $i++) {
        $card = mt_rand(2, 14); // создаю случайное число в диапозоне от 2 до 14
        $multiplier = mt_rand(0, 3); //формирую случайным образом множитель
        if (1 == $multiplier) { //если множитель равен 1, добавляю к числу 100
            $card = $card + 100;
        } else if (2 == $multiplier) { //если множитель равен 2, добавляю к числу 200
            $card = $card + 200;
        } else if (3 == $multiplier) { //если множитель равен 3, добавляю к числу 300
            $card = $card + 300;
        }

        if (!in_array($card, $arrayCards)) { //проверяю, есть ли в массиве такое число, если нет добавляю его в массив
            $arrayCards = array_merge($arrayCards, [$card]);
        } else { // если число есть в массиве, откатываю цикл, чтобы сформировать новое число
            $i--;
        }
    }
    return $arrayCards;
}

Определение и расчет комбинации Стрит

Стрит — это комбинация, где достоинства карт идут по порядку. Поэтому нет смысла учитывать при расчете все карты, составляющие данную комбинацию, достаточно лишь первой по старшинству карты.

Существует несколько вариантов определения и расчета комбинации Стрит. Думаю, большинство из них сводится к задаче отсортировать остатки от деления членов исходного массива в порядке убывания, а затем каким-либо образом выделить элементы, которые составляю комбинацию (в случае, когда более 5 карт составляют стрит, нужно выбрать наибольший).

Суть моего метода определения стрита сводится к тому, что после сортировки я буду проверять сначала первые пять карт на стрит, затем вторые и третьи. Также не забываю что туз, двойка, тройка, четверка и пятерка тоже составляю стрит. Поэтому, если в наборе есть туз (значение 14), к массиву добавляю восьмой элемент — 1. И следовательно в этом случае нужно проверить четвертую пятерку карт.

function straight(array $arrayCards) {
    $newArrayCards = [];
    $ace = false;
    foreach ($arrayCards as $arrayCard) {
        $newArrayCards = array_merge($newArrayCards, [$arrayCard % 100]);  //создаю массив с остатками от деления на 100
        if(14 == $arrayCard % 100) { //проверка на туз для комбинации А, 2, 3, 4, 5
            $ace = true;
        }

    }
    if($ace == true) {
        $newArrayCards = array_merge($newArrayCards, [1]); //если в массиве присутствует туз, добавляю к массиву 1
    }
    rsort($newArrayCards); //сортирую массив с числами в порядке убывания

    $count = 0; //счетчик, к которому добавляется 1 в случае, если разница между текущим элементом цикла и предыдущим = 1
    $length = 4; //число, показывает до какого элемента массива проверять
    $result = 0; //окончательный результат
    $begin = 0; //число показывает, с какого элемента массива проверять
    for($i = 1; $i <= $length; $i++) {
        if (-1 == ($newArrayCards[$i] - $newArrayCards[$i - 1])) {
            $count++;
        }
        if($length == $i) {
            if(4 == $count) { //$count == 4, когда стрит
                $result = $newArrayCards[$begin] * 1e+8;
            }
            else if($length < 6 or (6 == $length and $ace == true)) {//если стрита нет, идем еще на один круг
                $length++; //увеличиваем число, до которого будем проверять
                $begin++; //увеличиваем число, с которого будем проверять
                $i = $begin; //при попадании в for к $i автоматически добавится 1 ($i++ в for)
                $count = 0; //обнуляю счетчик
            }
        }
    }
    return $result;
}

Определение и расчет комбинаций Флеш и Стрит Флеш

Флеш — комбинация из карт одной масти. При расчете нужно учитывать все карты, составляющие комбинацию.

При расчете стрит флеша, как и при расчете стрита, можно учитывать только старшую карту комбинации.

Чтобы определить флеш, пробегусь циклом по массиву. В цикле создам 4 вспомогательных массива (по количеству мастей). В перый массив положу все карты первой масти, во второй — второй и т.д. Если какой-то масти нет, соответствующий массив будет пустой. Если количество элементов массива больше либо равно 5, значит данная масть образовала флеш.

Флеш более приоритетен, чем стрит, поэтому именно в функции флеша логично проверить не образовала ли комбинация стрит флеш. Также, думаю, понятно, что неудобно писать отдельную функцию, которая проверяет и стрит, и флеш. Лучше написать функцию, которая проверяет массив на флеш, и в ней же вызвать функцию, которая проверяет флеш на стрит.

Если флеш не образует стрит флеш, отсортирую остатки от деления на 100 (%100) исходного массива. Далее умножу первые пять членов полученного массива на 1е+10, 1е+8, 1е+6, 1е+4, 1е+2 соответственно.

Функцию по определению стрит флеша построю на основе функции по определению стрита, с той лишь разницей, что нужно учесть, что в функцию может прийти массив с количеством элементов меньше 7 (я ведь туда отправляю только те карты, которые образуют флеш).

Функция для определения Флеша:

function pokerFlush(array $arrayCards) {
    $suit1 = []; //первая масть
    $suit2 = []; //вторая масть
    $suit3 = []; //третья масть
    $suit4 = []; //четвертая масть
    foreach ($arrayCards as $arrayCard) { //создаю 4 массива, содержащих разные масти исходного массива
        if($arrayCard >= 2 and $arrayCard <= 14) {
            $suit1 = array_merge($suit1, [$arrayCard]);
        } else if($arrayCard >= 102 and $arrayCard <= 114) {
            $suit2 = array_merge($suit2, [$arrayCard]);
        } else if($arrayCard >= 202 and $arrayCard <= 214) {
            $suit3 = array_merge($suit3, [$arrayCard]);
        } else {
            $suit4 = array_merge($suit4, [$arrayCard]);
        }}
    if(count($suit1) >= 5) {  //если количество карт первой масти больше или равно 5
        $result = straightFlush($suit1); //проверяю не образует ли данная комбинация стрит флеш
        if(0 == $result) {//если стрит флеша нет
            foreach ($suit1 as $key1 => $s1) {//выбираю остатки от деления на 100
                $suit1[$key1] = $s1 % 100;
            }
            rsort($suit1); //сортирую массив по убыванию
            $result = $suit1[0] * 1e+10 + $suit1[1] * 1e+8 + $suit1[2] * 1e+6 + $suit1[3] * 1e+4 + $suit1[4] * 1e+2;
        }
    } else if (count($suit2) >= 5) {   //если количество карт второй масти больше или равно 5
        $result = straightFlush($suit2);
        if(0 == $result) {
            foreach ($suit2 as $key2 => $s2) {
                $suit2[$key2] = $s2 % 100;
            }
            rsort($suit2);
            $result = $suit2[0] * 1e+10 + $suit2[1] * 1e+8 + $suit2[2] * 1e+6 + $suit2[3] * 1e+4 + $suit2[4] * 1e+2;
        }
    } else if (count($suit3) >= 5) { //если количество карт третьей масти больше или равно 5
        $result = straightFlush($suit3);
        if(0 == $result) {
            foreach ($suit3 as $key3 => $s3) {
                $suit3[$key3] = $s3 % 100;
            }
            rsort($suit3);
            $result = $suit3[0] * 1e+10 + $suit3[1] * 1e+8 + $suit3[2] * 1e+6 + $suit3[3] * 1e+4 + $suit3[4] * 1e+2;
        }
    } else if (count($suit4) >= 5) {     //если количество карт четвертой масти больше или равно 5
        $result = straightFlush($suit4);
        if(0 == $result) {
            foreach ($suit4 as $key4 => $s4) {
                $suit4[$key4] = $s4 % 100;
            }
            rsort($suit4);
            $result = $suit4[0] * 1e+10 + $suit4[1] * 1e+8 + $suit4[2] * 1e+6 + $suit4[3] * 1e+4 + $suit4[4] * 1e+2;
        }
    } else {
        $result = 0;
    }
    return $result;
}

Функция для определения Стрит Флеша (аналогична Стриту, только нужно учесть, что количество элементов массива может быть не только 7, но еще и 5, и 6, и что возвращаемый результат этой функции должен быть больше):

function straightFlush(array $arrayCards) {
    $newArrayCards = [];
    $ace = false;
    foreach ($arrayCards as $arrayCard) {
        $newArrayCards = array_merge($newArrayCards, [$arrayCard % 100]);  
        if (14 == $arrayCard % 100) {
            $ace = true;
        }
    }
    if ($ace == true) {
        $newArrayCards = array_merge($newArrayCards, [1]);
    }
    rsort($newArrayCards); 
    $count = 0; 
    $length = 4; 
    $result = 0; 
    $begin = 0; 
    for ($i = 1; $i <= $length; $i++) {
        if (-1 == ($newArrayCards[$i] - $newArrayCards[$i - 1])) {
            $count++;
        }
        if ($length == $i) {
            if (4 == $count) { 
                $result = $newArrayCards[$begin] * 1e+16;
            } else if ((7 == count($arrayCards) and ($length < 6 or (6 == $length and $ace == true))) or
                (6 == count($arrayCards) and ($length < 5 or (5 == $length and $ace == true))) or //если число элементов исходного массива = 6
                (5 == count($arrayCards) and (5 == $length and $ace == true))) { //если число элементов исходного массива = 5
                $length++; 
                $begin++; 
                $i = $begin;
                $count = 0;
            }
        }
    }
    return $result;
}

Определение и расчет парных комбинаций

Существует пять парных комбинаций: каре (4 карты одного достоинства), фулл хаус (3 карты одного достоинства и 2 карты другого достоинства), тройка (3 карты одного достоинства), две пары (2 карты одного достоинства и 2 карты другого достоинства), пара (2 карты одного достоинства).

Важно при расчете помнить, что в комбинации фулл хаус главным является сочетание из трех карт, а из двух второстепенным, т.е., например, комбинацию из 3-х двоек и 2-х десяток будем считать, как 3*1e+12 + 10*1e+10, а не по достоинству карт.

А также при расчете парных комбинаций нужно учитывать проблемы:

1. То, что более 5 карт образуют комбинацию.
2. То, что у нас может возникнуть ситуация, при которой комбинаций более одной.

Для подсчета совпадения карт буду использовать три счетчика, которые будут считать парные карты в колоде. Там, где счетчик равен 1 — участвуют 2 карты в комбинации, где счетчик 2 — 3 карты, где 3 — 4 карты.

Рассмотрим все возможные варианты сочетания счетчиков:

100 — пара
110 — 2 пары
111 — 3 пары (нужно преобразовать к виду 110 (две пары))
200 — тройка
210 — фулл хаус
120 — фулл хаус (нужно преобразовать к виду 210 (фулл хаус))
211 (121, 112) — фулл хаус + пара (нужно преобразовать к виду 210 (фулл хаус))
220 — 2 тройки или фулл хаус + 1 карта (нужно преобразовать к виду 210 (фулл хаус))
300 — каре
310 (130) — каре + пара (нужно преобразовать к виду 300 (каре))
320 (230) — каре + тройка (нужно преобразовать к виду 300 (каре))
Далее произведу окончательный расчет парных комбинаций.

function couple(array  $arrayCards) {
    $newArrayCards = [];
    foreach ($arrayCards as $arrayCard) {
        $newArrayCards = array_merge($newArrayCards, [$arrayCard % 100]); //создаю массив с остатками от деления на 100
    }
    rsort($newArrayCards); //сортирую массив с числами в порядке убывания

    $count1 = 0; //счетчик для первой пары
    $count2 = 0; //счетчик для второй пары
    $count3 = 0; //счетчик для третьей пары

    $match1 = 0; //сюда положу значение первой пары
    $match2 = 0; //сюда положу значение второй пары
    $match3 = 0; //сюда положу значение третьей пары


    for($i = 1; $i < count($newArrayCards); $i++) {

        if ($newArrayCards[$i] == $match1 or $match1 == 0) { //первое парное сочетание
            if ($newArrayCards[$i] == $newArrayCards[$i - 1]) {
                $match1 = $newArrayCards[$i];
                $count1++;
            }
        } else if ($newArrayCards[$i] == $match2 or $match2 == 0) { //второе парное сочетание
            if ($newArrayCards[$i] == $newArrayCards[$i - 1]) {
                $match2 = $newArrayCards[$i];
                $count2++;
            }
        } else if ($newArrayCards[$i] == $match3 or $match3 == 0) { //третье парное сочетание
            if ($newArrayCards[$i] == $newArrayCards[$i - 1]) {
                $match3 = $newArrayCards[$i];
                $count3++;
            }
        }
    }

    //здесь я преобразую 111 к 110 (2 пары) и 211 к 210 (фулл хаус)
    if(($count1 == 1 or $count1 == 2) and $count2 == 1 and $count3 == 1) {
        $count3 = 0;
    }
    //здесь я преобразую 121 сначала к 211 для простоты вычислений, а затем к 210 (фулл хаус)
    else if($count2 == 2 and $count1 == 1 and $count3 == 1) {
        $support = $match2;
        $match2 = $match1;
        $match1 = $support;
        $count1 = 2;
        $count2 = 1;
        $count3 = 0;
    }
    //здесь я преобразую 112 сначала к 211 для простоты вычислений, а затем к 210 (фулл хаус)
    else if($count3 == 2 and $count1 == 1 and $count2 == 1) {
        $support = $match3;
        $match2 = $match1;
        $match1 = $support;
        $count1 = 2;
        $count3 = 0;
    }
    //здесь я преобразую 220 к 210 (фулл хаус)
    else if($count1 == 2 and $count2 == 2 and $count3 == 0) {
        $count2 = 1;
    }
    //здесь я преобразую 120 к 210 (фулл хаус)
    else if ($count1 == 1 and $count2 == 2 and $count3 == 0) {
        $support = $match1;
        $match1 = $match2;
        $match2 = $support;
        $count1 = 2;
        $count2 = 1;
    }
    //320 к 300 и 310 к 300
    else if($count1 == 3 and ($count2 == 2 or $count2 == 1)) {
        $count2 = 0;
    }
    //230 к 320 и затем к 300 и 130 к 310 и затем к 300
    else if($count2 == 3 and($count1 == 2 or $count1 == 1)) {
        $support = $match2;
        $match2 = $match1;
        $match1 = $support;
        $count1 = 3;
        $count2 = 0;
    }

    //каре
    if ($count1 == 3) {
        $count1 = 1e+14;
    }
    //фулл хаус
    else if ($count1 == 2 and $count2 == 1) {
        $count1 = 1e+12;
        $count2 = 1e+10;
    }
    //тройка
    else if ($count1 == 2 and $count2 == 0) {
        $count1 = 1e+6;
    }
    //2 пары
    else if ($count1 == 1 and $count2 == 1) {
        $count1 = 1e+4;
        $count2 = 1e+2;
    }
    //пара
    else if ($count1 == 1 and $count2 == 0) {
        $count1 = 1e+2;
    }

    $result = $match1 * $count1 + $match2 * $count2;// $match1 и $match2 будут равны 0, если совпадений не было
    return $result;
}

Окончательный расчет

Теперь у нас имеются функции, которые проверяют массив карт на стрит, флеш, стрит флеш и парные комбинации. Вызову их вместе и посчитаю окончательный результат, не забываю также и про расчет старшей карты.

Расчет старшей карты:

1. Определю наибольшую и наименьшие по приоритетности карманные карты. Для этого сравню их остатками от деления на 100 (%100).
2. К наибольшей по приоритетности карте добавлю наименьшую по приоритетности деленную на 100.

function priority(array  $arrayCards) {
    //здесь я определяю старшую карту
    if($arrayCards[5] % 100 > $arrayCards[6] % 100) { //условились, что две последние карты массива - карманные
        $highCard1 = $arrayCards[5] % 100;
        $highCard2 = $arrayCards[6] % 100;
    } else {
        $highCard1 = $arrayCards[6] % 100;
        $highCard2 = $arrayCards[5] % 100;
    }


    $flush = pokerFlush($arrayCards); //вызываю функцию для расчета флеша
    $straight = straight($arrayCards); //вызываю функцию для расчета стрита
    $couple = couple($arrayCards); //вызываю функцию для расчета пар

    //далее определяю результат согласно приоритету комбинаций
    if($flush >= 1e+16) {
        $result = $flush; //стрит флеш
    } else if($couple >= 1e+14 and $couple < 1e+16) {
        $result = $couple; //каре
    } else if($couple >= 1e+12 and $couple < 1e+14) {
        $result = $couple; //фулл хаус
    } else if($flush >= 1e+10) {
        $result = $flush; //флеш
    } else if($straight >= 1e+8 and $straight < 1e+10) {
        $result = $straight; //стрит
    } else if($couple >= 1e+6 and $couple < 1e+8) {
        $result = $couple; //тройка
    } else if($couple >= 1e+4 and $couple < 1e+6) {
        $result = $couple; //две пары
    } else if($couple >= 1e+2 and $couple < 1e+4) {
        $result = $couple; //пара
    } else {
        $result = $highCard1 + $highCard2 * 1e-2; //старшая карта
    }
    return $result;
}

О выводе на экран

Выводила я результат в браузер, используя вот такой спрайт (брала картинку с сайта: fondhristianin.ru/?p=2941), как background-image для div.



Ширину и высоту для div задавала равными размеру одной карты, т.е. если размер изображения 572px*328px (как в данном случае), а в ширину количество карт равно 13, в высоту — 5, ширину и высоту задавала 44px*65.6px. Далее меняла background-position с учетом ранее сформированного массива карта.

Расчет background-position для любого из divов по оси х:

100/12 * ($arrayCards[$i] % 100 - 2)

где $arrayCards — ранее сформированный массив.
$i — порядковый номер карты.

Пояснения к расчету:
В ряду 13 карт, начало 1-ой карты — 0%, начало 13-ой карты — 100%, поэтому разница позиций — 100% / 12 (а не 13). Приводим числа карт из вида [2-14, 102-114, 202-214, 302-314] к [0-12]. Для этого возьмет остаток от числа карты и отнимем от остатка 2. Умножим полученное число на разницу позиций.

Расчет background-position для любого из divов по оси y:

100/4 * floor($arrayCards[$i] / 100)

Пояснение к расчету:
В ряду 5 карт, начало 1-ой карты — 0%, начало 5-ой карты — 100%, поэтому разница позиций — 100% / 4 (а не 5). Приводим числа карт из вида [2-14, 102-114, 202-214, 302-314] к [0-3]. Для этого разделим число карты на 100 и округлим в меньшую сторону (можно использовать и простую операцию округления, она сработает аналогичным образом). Умножим полученное число на разницу позиций.

https://habrahabr.ru/post/335540/