Как перебрать все комбинации, например. 48 выбрать 5

(отказ от ответственности: я написал очень быстрый анализатор покерных рук)

Я хочу перечислить/перебрать все 48, выбрать 5 возможных комбинаций досок и подсчитать, сколько раз выигрывает игрок А, сколько раз выигрывает игрок Б и когда они связывают.

Вы не хотите оценивать руки C(48,5) (1 712 304) каждый раз, когда у вас есть матч между двумя игроками на префлопе: большинство программ просто используют предварительно вычисленную справочную таблицу между всеми возможными матчами между двумя игроками на префлопе.

Например, скажем, у вас есть «Ac Ad» против «7c 6c», вы просто ищете в таблице поиска, которая содержит: 1 333 573, 371 831, 6900 (где 1 333 573 — это количество раз, когда «Ac Ad» выигрывает, 371 831 — это количество раз, когда Выигрывает "7c 6c" и 6 900 - это количество ничьих (в сумме они составляют 1 712 304). Чтобы получить место, вы можете отбросить 6 900, зная, что количество ничьих всегда должно быть C(48,5 ) - (выигрыш 1 + выигрыш 2).

(подробнее о таблице поиска в конце этого ответа)

Но чтобы ответить на ваш вопрос:

Я не уверен, как я могу систематически перебирать каждую комбинацию из 5 карт.

Если вы действительно хотите перебрать каждую комбинацию, вы должны знать, что программы для оценки покерных комбинаций, как правило, должны быть очень-очень быстрыми. Эти программы обычно могут оценивать сотни миллионов раздач в секунду (вы правильно прочитали: сотни миллионов).

Когда вам нужна такая высокопроизводительная «обработка чисел», вы можете забыть о «шаблонах проектирования» и «ОО». То, что вы хотите, это чистая скорость.

Например, следующий код будет проходить через самый внутренний цикл C(48,5) раз, и это довольно быстро:

    for ( int i = 0; i < n; i++ ) {
        for ( int j = i + 1; j < n; j++ ) {
            for ( int k = j + 1; k < n; k++ ) {
                for (int l = k + 1; l < n; l++) {
                    for (int m = l + 1; m < n; m++) {
                        ...
                    }
                }
            }
        }
    }

Опять же, для двух игроков на префлопе это, вероятно, очень плохая идея: вы будете намного быстрее, используя справочную таблицу.

Но для трех игроков на префлопе (где нецелесообразно использовать столы на префлопе, слишком много матч-апов) вы можете зациклиться таким образом, по C(46,5) рукам, используя пять вложенных циклов (конечно, вам нужно используйте i,j,k,l,m, чтобы получить правильные 5 карт из 46 оставшихся карт). Затем, когда у вас есть 5 карт, вы используете быстрый оценщик рук, который дает вам лучшее из 7 (5 карт на столе + по две карты каждого игрока).

Относительно таблицы поиска:

Большинство людей используют приблизительную справочную таблицу 169 против 169 («Ac Kd», «As Kh», «Ad Ks» и т. д., все они становятся «AK разномастными», а возможные стартовые руки C (52,2) группируются в тип 169. стартовых рук). Статья в Википедии объясняет, как получить 169 неэквивалентных стартовых рук:

http://en.wikipedia.org/wiki/Texas_hold_%27em_starting_hands

Они не эквивалентны, если принять во внимание одну руку, но как только вы сравниваете руку 1 и руку 2, "169 против 169" является приблизительным (довольно хорошо что сказал).

Конечно, вы можете стать более любознательным. Есть только C(52,2) (что дает 1326) реальных разных стартовых рук в Холдеме, а это означает, что очень практично построить идеальную справочную таблицу (вообще без приближений) на современных компьютерах (C(1326,2) в не такой большой), если вам действительно нужны идеальные числа. Если вы можете жить с приближением, перейдите к таблице 169 против 169 (для этого потребуется C (169,2) или 14 196 записей).

1. Инициализируйте массив (A) первыми 5 индексами. (0,1,2,3,4)
2. Переместите последний возможный индекс в A на следующую позицию. A[k]++
3. Переместите следующие индексы на следующие последовательные позиции. (A[k+1] = A[k] + 1, ...). Если какой-то индекс станет слишком большим, попробуйте использовать более ранний индекс на шаге 2.
4. Выдать элементы с текущими индексами в A.
5. Если возможно, повторите с шага 2.

Реализовано как итератор:

public class CombinationIterator<T>
        implements Iterable<List<T>>,
                   Iterator<List<T>> {
    private List<T> items;
    private int choose;
    private boolean started;
    private boolean finished;
    private int[] current;

    public CombinationIterator(List<T> items, int choose) {
        if (items == null || items.size() == 0) {
            throw new IllegalArgumentException("items");
        }
        if (choose <= 0 || choose > items.size()) {
            throw new IllegalArgumentException("choose");
        }
        this.items = items;
        this.choose = choose;
        this.finished = false;
    }

    public Iterator<List<T>> iterator() {
        return this;
    }

    public boolean hasNext() {
        return !finished;
    }

    public List<T> next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }

        if (current == null) {
            current = new int[choose];
            for (int i = 0; i < choose; i++) {
                current[i] = i;
            }
        }

        List<T> result = new ArrayList<T>(choose);
        for (int i = 0; i < choose; i++) {
            result.add(items.get(current[i]));
        }

        int n = items.size();
        finished = true;
        for (int i = choose - 1; i >= 0; i--) {
            if (current[i] < n - choose + i) {
                current[i]++;
                for (int j = i + 1; j < choose; j++) {
                    current[j] = current[i] - i + j;
                }
                finished = false;
                break;
            }
        }

        return result;
    }

    public void remove() {
        throw new UnsupportedOperationException();
    }
}

Эквивалентно в C# с использованием метода Iterator:

public IEnumerable<IList<T>> Combinations<T>(IEnumerable<T> items, int choose)
{
    if (items == null) throw new ArgumentNullException("items");

    var itemsList = items.ToList();
    int n = itemsList.Count;

    if (n < 1) throw new ArgumentException("Must contain at least one item.", "items");
    if (choose <= 0 || choose >= n) throw new ArgumentOutOfRangeException("choose");

    var indices = Enumerable.Range(0, choose).ToArray();

    bool moreWork = true;
    while (moreWork)
    {
        yield return indices.Select(i => itemsList[i]).ToList();

        moreWork = false;
        for (int i = choose - 1; i >= 0; i--)
        {
            if (indices[i] < n - choose + i)
            {
                indices[i]++;
                for (int j = i + 1; j < choose; j++)
                {
                    indices[j] = indices[i] - i + j;
                }
                moreWork = true;
                break;
            }
        }
    }
}