Cheat é um jogo de cartas em que você está tentando se livrar da sua mão. Um turno é algo mais ou menos assim:

1. Determine qual ranking de cartas você tem para jogar nesse turno. Na maioria das variantes, esse é um ranking mais alto que o turno anterior.
2. Jogue 1-4 cartas, com a face para baixo. Eles não precisam corresponder à classificação válida. Se não, é considerado uma trapaça . Neste ponto, qualquer jogador pode desafiá- lo.
   • Se ninguém te desafiar, o jogo continua para o próximo jogador.
   • Se alguém o desafia e você não trapaceia, eles precisam pegar todas as cartas jogadas.
   • Se alguém desafia você e você trapaceou, você deve pegar todas as cartas jogadas.

A estratégia é principalmente uma mistura de blefes e contagem de cartas. Eu sou ruim em matemática, então vou trapacear no Cheat e trazer um bot comigo.

Entrada

A entrada será, em qualquer ordem ou formato que você desejar:

1. A mão do jogador. Se eu souber que eles devem ter cartões (por exemplo, eu os vi pegá-los), eles serão listados em ordem crescente. Quaisquer incógnitas serão listadas posteriormente como ?. Por exemplo, se eles têm seis cartas e eu sei que duas são 1 e 1 é 4, uma representação válida da mão é 114???. ? sempre serão listados após os cartões conhecidos. 141???e 11???4são entradas inválidas e seu código não precisa lidar com elas.
2. As cartas que eu conheço definitivamente não fazem parte da mão delas (eu as tenho, vi alguém pegá-las, etc.). A lista estará em ordem crescente de classificação. A lista pode estar vazia.
3. As cartas que o jogador alegou jogar. Se eles alegassem jogar 3 7, uma possível entrada aqui seria 777. As cartas sempre terão o mesmo valor.

O número de cartas jogadas sempre será de 1 a 4 e as fileiras sempre serão de 0 a 9. Uma classificação nunca aparecerá mais de quatro vezes na mão + não na mão.

Este é um exemplo de entrada válida:

33577??
01555688
55

Este é um exemplo de entrada inválida:

35377?? # Out of order
7779    # Five 7's in total
23      # Two separate ranks played

Resultado

Um valor verdadeiro, se deveríamos definitivamente desafiar. Um valor falsey, se não quisermos desafiar.

Sempre desafiamos se sabemos que eles trapacearam. Sabemos que eles trapacearam se jogassem cartas que não poderiam ter:

12

3  # They don't have any 3's or ?'s    
-------------
12?

33 # Fewer ?'s than played cards
-------------
123?
333
33 # Since we have three 3's they can't have two

A outra vez que desafiamos é se eles jogam suas últimas cartas. Mesmo que o jogo seja legítimo, ele terminaria o jogo, para que possamos desafiá-lo.

1

1 # They'd win, so challenge anyway

Mais casos de teste

Verdade (deve desafiar)

11445678?

22
-------------
????????
4
4444
-------------
12345678

9

Falsey (não deve desafiar)

1?
222
2
-------------
12?
22
22
-------------
?????

1111

Pontuação

O menor código vence.

Pitão, 22 bytes

!}zS+*hzhS,/Q\?-4l@z+w

Experimente online.

JavaScript (ES6), 93 bytes

(h,s,c,g=(a,z=c[0])=>a.split(z).length-1)=>h.length==g(c)|g(h,'?')+g(h)<g(c)|g(h)+g(s)+g(c)>4

Aceita três séries de cartas (caracteres 0- 9ou ?); retorna 1para o desafio, 0caso contrário. Explicação:

(h,s,c,                 Input parameters
 g=(a,z=c[0])=>         Helper function defaults to claimed card
  a.split(z).length-1   Count cards matching (g(c) == c.length)
)=>h.length==g(c)       Does hand length equal claim length
  |g(h,'?')+g(h)<g(c)   Could hand not contain claimed cards
  |g(h)+g(s)+g(c)>4     Are there too many claimed cards

C # 6, 134 bytes

using System.Linq;
bool f(string a,string b,string c)=>a.Length==1|a.Count(x=>x==c[0]|x=='?')<c.Length|b.Count(x=>x==c[0])+c.Length>4;

(Nota: De acordo com o exemplo do OP, essa resposta retorna falsa, mesmo que o oponente tenha mais de uma carta e esteja jogando toda a sua mão. Em termos de estratégia, isso deve retornar verdadeiro.)

Explicação:

a: Mão do jogador
b: Cartões que eu definitivamente conheço ...
c : Cartões que alegam jogar

Ungolfed:

bool f(string a, string b, string c) => 
    a.Length == 1                               // Last card played
    | a.Count(x => x == c[0] | x == '?' )       // Count no. of cards that surely/may match claimed cards
                                                // Assuming all claimed cards are the same, just compare with c[0]
        < c.Length                              // I'm sure you don't have that many cards...
    | b.Count(x => x == c[0]) + c.Length > 4;   // ... Or that there can't be that many cards in play

Java 8, 169 135 bytes

(a,b,c)->{int C=c.length();char x=c.charAt(0);return a.length()==C|(a+0).split(x+"|\\?",-1).length<=C|5-(b+0).split(""+x,-1).length<C;}

Explicação:

Experimente aqui.

(a,b,c)->{            // Method with three String parameters and boolean return-type
  int C=c.length();   //  The amount of cards played by your opponent this turn
  char x=c.charAt(0); //  The card played by your opponent this turn
  return a.length()==C//  Return true if your opponent played his entire hand (final round)
    |(a+0).split(x+"|\\?",-1).length
                      //   Or the amount of the played card and '?' in your opponent's hand
      <=C             //   is smaller than the amount of cards played
    |5-(b+0).split(""+x,-1).length
                      //   Or if 4 minus the amount of the played card are part of the
                      //   cards you definitely know, 
     <C;              //   is smaller than the amount of cards played
}                     // End of method

NOTA: (s+0).split("c",-1).length-1fornece a quantidade de vezes que o caractere cocorre em String s. Portanto, os comentários na explicação acima estão corretos, mas o código pode parecer diferente por causa disso. O (a+0).split(x+"|\\?",-1).length-1<Cé jogado (a+0).split(x+"|\\?",-1).length<=Ce o 4-(b+0).split(""+x,-1).length-1<Cé jogado para 5-(b+0).split(""+x,-1).length<C.