This is the kind of strategy that I expected would be needed to win against my computerHand. I noted that no matter what strategy is picked by the computer there is almost always a strategy that will win by humanHand. So, playing against an omniscient player would guarantee a landslide.

Your code does the best to be that omniscient player by generating all possible hands and figuring a strategy based on that. There is hidden knowledge as to what cards are available and what the computer strategy is, so your 55% is very respectable, and the best I have seen.

The computer strategy that finally got used was this:
Make the best possible one card hand, then the best possible two card hand.

There are six possible “simple, greedy” strategies, basically make the best N card hand, then the best possible M card hand. Of these six “simple greedy” strategies, [1 2 3] is the best against the others. [2 1 3] is the second best. I started the contest with [2 1 3] and then moved to [1 2 3] once DanK bested me.

-Thanks for playing!
Doug

Any thoughts? I think this (55.1 – 55.2%) may be the best you can do. Thanks.

Here’s the last function, which keeps on getting chopped off. The 3 functions used to determine the score for high, medium, and low are also needed.

function Total = genAllHands(hand)
%Total -> n x 6 of High,Middle,Low
%all unique combinations with the card game rules i.e 2 2 2 3 4 4
%is the same as 2 2 2 4 3 4 but not as 2 2 3 2 4 4
    persistent perm5
    if isempty(perm5)
        perm5 = perms(1:5);
    end
    uniqNums = unique(hand);
    count = 0;
    for i = 1:length(uniqNums)
        tempHand = hand;
        I = find(hand == uniqNums(i),1);
        tempHand(I) = [];
        for j = 1:120
            count = count + 1;
            H(count,:) = sort(tempHand(perm5(j,1:3)));
            M(count,:) = sort(tempHand(perm5(j,4:5)));
            L(count,:) = uniqNums(i);
        end
    end
        Total = unique([H M L],'rows');

Oops, sorry for the second long attachment, I correctly implemented the probability model to get about 55.1 – 55.2%, also some code at the end was cut off.

function [high, middle, low] = humanHand(hand)
persistent strategy
handInput = hand; %a bit sloppy, I overwrote this in the persistent code
if isempty(strategy)
    %Generation of all possible hands
    %===================================
    numCardsInDeck = 16;
    uniqueFound = 0;
        possHands = [];
    while uniqueFound ~= 68
        runSize = 1000;
        tempPossHands = zeros(runSize,6);
        for i = 1:runSize %Not sure what the best way of dividing this up is
            deck = ceil(randperm(numCardsInDeck)/4);
            tempPossHands(i,:) = sort(deck(1:6));
        end
        tempPossHands = unique(tempPossHands,'rows');
        possHands = [possHands; tempPossHands]; %#ok
        possHands = unique(possHands,'rows');
        uniqueFound = size(possHands,1);
    end

    %The computer strategy, I think
    %========================================
    cS = possHands; %cs -> computer Strategy
    totalCS = zeros(size(cS,1),12);
    for i = 1:size(cS,1)
       hand = cS(i,:); %Note these values are already sorted
       L = hand(end);
       hand(end) = [];
       N = hist(hand,[1 2 3 4]);
       I = find(N >= 2); %You'll always get a pair by the nature of the game
       I = I(end); %Grab the highest valued set
       M = [I I]; %Note, there will always be at least 2 pairs, so this always works
       I = find(hand == I,2); %find 2 of these values and delete them
       hand(I) = [];
       H = hand;
       totalCS(i,:) = [cS(i,:) H M L]; %Note going back to cS because we've deleted from hand
    end

    %AT THIS POINT WE HAVE THE FULL STRATEGY OF THE OPPONENT NOW TO SEE WHAT WE SHOULD DO
    %======================================================================
    allCount = 0;
    for i = 1:size(possHands,1)
        for j = 1:size(possHands,1)
            BothHands = [possHands(i,:) possHands(j,:)];
            N = hist(BothHands,[1 2 3 4]);
            if isempty(find(N > 4,1))

                %His hand -> possHands(i,:)
                %My hand -> possHands(j,:)
                %with my cards removed, what is his probability of getting his hand
                counts = [4 4 4 4];
                mH = possHands(j,:);
                counts = counts - hist(mH,[1 2 3 4]);
                counts2 = hist(possHands(i,:),[1 2 3 4]);

                p = 1;
                for k = 1:4
                    if counts(k) == 0 && counts2(k) ~= 0
                        p = 0; %This should never occur with if statement above
                    else
                        p = p*nchoosek(counts(k),counts2(k));
                    end
                end

                [Total] = genAllHands(possHands(j,:));
                for k = 1:size(Total,1)
                    wins = determineWin(Total(k,1:3),Total(k,4:5),Total(k,6),totalCS(i,7:9),totalCS(i,10:11),totalCS(i,12));
                    allCount = allCount + 1;
                    allPossible(allCount,:) = [possHands(i,:) possHands(j,:) Total(k,:) wins(4) p];   %#ok
                end
            end
        end
    end

    %Form of allPossible
    %==========================================================================
    %cols 1-6 -> his cards, 7-12 -> my cards,  13-18 -> an approach with my cards H M L
    %19 whether or not I would win,lose,tie
    %20 -> probability of that hand (really ways to get hand with my hand being what it is)

    %NOW, KNOWING EVERYTHING I CAN PLAY AGAINST THE COMPUTER I DETERMINE THE BEST STRATEGY, FOR WHATEVER HAND I GET
    strategy = zeros(size(possHands,1),12);
    for i = 1:length(possHands)
        hand = possHands(i,:);
        badRows = ismember(allPossible(:,1:6),hand,'rows'); %The computer won't have my hand!
        rowsMine = ismember(allPossible(:,7:12),hand,'rows');
        rowsMine(badRows == 1) = 0;
        remainder = allPossible(rowsMine,13:end);

        %This was some combining of code from different files
        %I had possHands here originally, but not I have possHands from above
        %so I made this one possHands2
        [possHands2,I,J] = unique(remainder(:,1:6),'rows'); %get all the computers hands & what I can play against them

        scoresTot = zeros(size(possHands2,1),1);
        scoresTot2 = zeros(size(possHands2,1),1);
        for j = 1:size(possHands2,1)
            temp = remainder(J == j,7);
            p = remainder(J == j,8);
            scoresTot(j) = sum(temp.*p);
            scoresTot2(j) = scoresTot(j)/length(temp);
        end
        [junk,I] = max(scoresTot);
        [junk2,I2] = max(scoresTot2);
        if I ~= I2
            keyboard
        end

        high   = possHands2(I,1:3);
        middle = possHands2(I,4:5);
        low    = possHands2(I,6);
        strategy(i,:) = [hand high middle low];
    end

end %if isempty (strategy)

    %=========================================
    %The code that runs every trial
    %=========================================
    I = ismember(strategy(:,1:6),handInput,'rows');
    rowToUse = strategy(I,7:12);

    high   = rowToUse(1:3);
    middle = rowToUse(4:5);
    low    = rowToUse(6);

%=======================================================================
%EXTRA FUNCTIONS
%=====================================================================

function wins = determineWin(highH,middleH,lowH,highC,middleC,lowC)
    humanScore(3) = compareHigh  (  highH ,   highC);
    humanScore(2) = compareMiddle(middleH , middleC);
    humanScore(1) = compareLow   (   lowH ,    lowC);
    win = compareLow(sum(humanScore), 1.5);
    wins = [humanScore(3),humanScore(2),humanScore(1),win];

function score = compareHigh(H, C)
    if sum(H) > sum(C)
        score = 1;
    elseif sum(H)  C
        score = 1;
    elseif H  n x 6 of High,Middle,Low
%all unique combinations with the card game rules i.e 2 2 2 3 4 4
%is the same as 2 2 2 4 3 4 but not as 2 2 3 2 4 4
    persistent perm5
    if isempty(perm5)
        perm5 = perms(1:5);
    end
    uniqNums = unique(hand);
    count = 0;
    for i = 1:length(uniqNums)
        tempHand = hand;
        I = find(hand == uniqNums(i),1);
        tempHand(I) = [];
        for j = 1:120
            count = count + 1;
            H(count,:) = sort(tempHand(perm5(j,1:3)));
            M(count,:) = sort(tempHand(perm5(j,4:5)));
            L(count,:) = uniqNums(i);
        end
    end
        Total = unique([H M L],'rows');

Here’s my approach. It is a brute force method as well. Using the computers input (knowing their hand) about the best one can expect to do is 65%. I replicate the computer strategy in creating the persistent variable (the look up table). Then I figure out for every possible hand of mine (68 total) what high, middle, and low to play that will beat the computer most often. In the end the code that runs every time just looks up what hand I got, then plays the one most likely to win.

On average I get between 54 to 55% correct. I tried for a few hours to consistently get above 55% but it just wasn’t happening. The only idea which I didn’t implement as it would mean losing a lot of the up front calculations would have been to build some history into my hands so that whatever hands I’ve had recently, I figure the computer won’t have. Although even that is tricky as there are so many ways to get the same hand. My attempt at building in a probability as to which hands were more or less likely for the current hand like 111144 being less likely then 112233 ended up hurting my predictions.

function [high, middle, low] = humanHand(hand)

persistent strategy
handInput = hand; %a bit sloppy, I overwrote this in the persistent code

if isempty(strategy)
    %Generation of all possible hands
    %===================================
    numCardsInDeck = 16;
    uniqueFound = 0;
        possHands = [];
    while uniqueFound ~= 68
        runSize = 1000;
        tempPossHands = zeros(runSize,6);
        for i = 1:runSize %Not sure what the best way of dividing this up is
            deck = ceil(randperm(numCardsInDeck)/4);
            tempPossHands(i,:) = sort(deck(1:6));
        end
        tempPossHands = unique(tempPossHands,'rows');
        possHands = [possHands; tempPossHands]; %#ok
        possHands = unique(possHands,'rows');
        uniqueFound = size(possHands,1);
    end

    %calculating the probability -> I didn't actually use this
    %========================================
    totalP = zeros(1,size(possHands,1));
    for i = 1:size(possHands,1)
       count = [4 4 4 4];
       p = 1;
       for j = 1:6
           index = possHands(i,j);
           p = p*count(index)/sum(count);
           count(index) = count(index) - 1;
       end
       totalP(i) = p;
    end

    %The computer strategy, I think
    %========================================
    cS = possHands; %cs -> computer Strategy
    totalCS = zeros(size(cS,1),12);
    for i = 1:size(cS,1)
       hand = cS(i,:); %Note these values are already sorted
       L = hand(end);
       hand(end) = [];
       N = hist(hand,[1 2 3 4]);
       I = find(N >= 2); %You'll always get a pair by the nature of the game
       I = I(end); %Grab the highest valued set
       M = [I I]; %Note, there will always be at least 2 pairs, so this always works
       I = find(hand == I,2); %find 2 of these values and delete them
       hand(I) = [];
       H = hand;
       totalCS(i,:) = [cS(i,:) H M L]; %Note going back to cS because we've deleted from hand
    end

    %AT THIS POINT WE HAVE THE FULL STRATEGY OF THE OPPONENT NOW TO SEE WHAT WE SHOULD DO
    %==========================================================================

    allCount = 0;
    for i = 1:size(possHands,1)
        for j = 1:size(possHands,1)
            BothHands = [possHands(i,:) possHands(j,:)];
            N = hist(BothHands,[1 2 3 4]);
            if isempty(find(N > 4,1))
                [Total] = genAllHands(possHands(j,:));
                for k = 1:size(Total,1)
                    wins = determineWin(Total(k,1:3),Total(k,4:5),Total(k,6),totalCS(i,7:9),totalCS(i,10:11),totalCS(i,12));
                    allCount = allCount + 1;
                    allPossible(allCount,:) = [possHands(i,:) possHands(j,:) Total(k,:) wins(4) totalP(i)];   %#ok
                end

            end
        end
    end

    %Form of allPossible
    %==========================================================================
    %cols 1-6 -> his cards, 7-12 -> my cards,  13-18 -> an approach with my cards H M L
    %19 whether or not I would win,lose,tie
    %20 -> probability of that hand

    %NOW, KNOWING EVERYTHING I CAN PLAY AGAINST THE COMPUTER
    %I DETERMINE THE BEST STRATEGY, FOR WHATEVER HAND I GET

    strategy = zeros(size(possHands,1),12);
    for i = 1:length(possHands)
        hand = possHands(i,:);
        badRows = ismember(allPossible(:,1:6),hand,'rows'); %The computer won't have my hand!
        rowsMine = ismember(allPossible(:,7:12),hand,'rows');
        rowsMine(badRows == 1) = 0;
        remainder = allPossible(rowsMine,13:end);

        %This was some combining of code from different files
        %I had possHands here originally, but not I have possHands from above
        %so I made this one possHands2
        [possHands2,I,J] = unique(remainder(:,1:6),'rows'); %get all the computers hands & what I can play against them

        scoresTot = zeros(size(possHands2,1),1);
        scoresTot2 = zeros(size(possHands2,1),1);
        for j = 1:size(possHands2,1)
            temp = remainder(J == j,7);
            scoresTot(j) = sum(temp);
            scoresTot2(j) = scoresTot(j)/length(temp);
        end
        [junk,I] = max(scoresTot);
        [junk2,I2] = max(scoresTot2);
        if I ~= I2
            keyboard
        end

        high   = possHands2(I,1:3);
        middle = possHands2(I,4:5);
        low    = possHands2(I,6);
        strategy(i,:) = [hand high middle low];
    end

end %if isempty (strategy)

    %=========================================
    %The code that runs every trial
    %=========================================
    I = ismember(strategy(:,1:6),handInput,'rows');
    rowToUse = strategy(I,7:12);

    high   = rowToUse(1:3);
    middle = rowToUse(4:5);
    low    = rowToUse(6);

%=======================================================================
%EXTRA FUNCTIONS
%=====================================================================

function wins = determineWin(highH,middleH,lowH,highC,middleC,lowC)
    humanScore(3) = compareHigh  (  highH ,   highC);
    humanScore(2) = compareMiddle(middleH , middleC);
    humanScore(1) = compareLow   (   lowH ,    lowC);
    win = compareLow(sum(humanScore), 1.5);
    wins = [humanScore(3),humanScore(2),humanScore(1),win];

function score = compareHigh(H, C)
    if sum(H) > sum(C)
        score = 1;
    elseif sum(H)  C
        score = 1;
    elseif H  n x 6 of High,Middle,Low
%all unique combinations with the rules i.e 2 2 2 3 4 4
%is the same as 2 2 2 4 3 4
    persistent perm5
    if isempty(perm5)
        perm5 = perms(1:5);
    end

    uniqNums = unique(hand);

    count = 0;
    for i = 1:length(uniqNums)
        tempHand = hand;
        I = find(hand == uniqNums(i),1);
        tempHand(I) = [];
        for j = 1:120
            count = count + 1;
            H(count,:) = sort(tempHand(perm5(j,1:3)));
            M(count,:) = sort(tempHand(perm5(j,4:5)));
            L(count,:) = uniqNums(i);
        end
    end
        Total = unique([H M L],'rows');

Yes, I should have pre-allocated that array. Pre-allocation does help speed when you can do it. The effects are most noticeable on larger vectors and arrays.

Good catch,
Doug

If I can ever do better than 45% I’ll post a result :-/

Thank you for that. I have updated all the files and confirmed they work from 2007a forward.

Doug

People without 2008A can’t seem to run the p-code. Any chance of a 2007-compatible computerHand.p?