Cheat es un juego de cartas en el que intentas deshacerte de tu mano. Un giro se ve más o menos así:

1. Determina qué rango de cartas tienes para jugar ese turno. En la mayoría de las variantes, este es un rango más alto que el turno anterior.
2. Juega 1-4 cartas, boca abajo. Estos no tienen que coincidir con el rango válido. Si no lo hacen, se considera un truco . En este punto, cualquier jugador puede desafiarte .
   • Si nadie te reta, el juego continúa con el siguiente jugador.
   • Si alguien te reta y no hiciste trampa, tienen que tomar todas las cartas jugadas.
   • Si alguien te reta y hiciste trampa, debes tomar todas las cartas jugadas.

La estrategia es principalmente una mezcla de faroles y conteo de cartas. Sin embargo, soy malo en matemáticas, así que voy a engañar a Cheat y traer un bot conmigo.

Entrada

La entrada será, en cualquier orden o formato que desee:

1. La mano del jugador. Si sé que deben tener tarjetas (por ejemplo, las he visto recogerlas), se enumerarán en orden ascendente. Cualquier incógnita se enumerará después como ?. Por ejemplo, si tienen seis cartas y sé que dos son 1 y uno es un 4, es una representación válida de la mano 114???. ? siempre se enumerarán después de las tarjetas conocidas. 141???y 11???4son entradas no válidas y su código no necesita manejarlas.
2. Las cartas que definitivamente conozco no son parte de su mano (las tengo, vi a alguien más recogerlas, etc.). La lista estará en orden ascendente de rango. La lista puede estar vacía.
3. Las cartas que el jugador afirmó jugar. Si afirmaran jugar 3 7's, una posible entrada aquí sería 777. Las cartas siempre serán del mismo rango.

El número de cartas jugadas siempre será 1-4 y los rangos siempre serán 0-9. Un rango nunca aparecerá más de cuatro veces en su mano + no en su mano.

Este es un ejemplo de entrada válida:

33577??
01555688
55

Este es un ejemplo de entrada no válida:

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

Salida

Un valor verdadero si definitivamente debemos desafiar. Un valor falso si no queremos desafiar.

Siempre desafiamos si sabemos que hicieron trampa. Sabemos que hicieron trampa si jugaban cartas que posiblemente no podrían tener:

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

La otra vez que desafiamos es si juegan sus últimas cartas. Incluso si el juego es legítimo, terminaría el juego, por lo que podríamos desafiarlo.

1

1 # They'd win, so challenge anyway

Más casos de prueba

Verdad (debería desafiar)

11445678?

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

9

Falsey (no debe desafiar)

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

1111

Puntuación

El código más corto gana.

Pyth, 22 bytes

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

Pruébalo en línea.

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

Acepta tres cadenas de cartas (caracteres 0- 9o ?); vuelve 1para el desafío, de lo 0contrario. Explicación:

(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: en línea con el ejemplo de OP, esta respuesta devuelve falso incluso si el oponente tiene más de una carta y está jugando toda su mano. En términos de estrategia, esto debería ser verdadero).

Explicación:

a: Mano del jugador
b: Cartas que definitivamente sé ...
c: Cartas reclamadas para jugar

Sin golf:

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;}

Explicación:

Pruébalo aquí.

(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-1da la cantidad de veces que el carácter cocurre en String s. Entonces, los comentarios en la explicación anterior son correctos, pero el código puede parecer diferente debido a eso. El (a+0).split(x+"|\\?",-1).length-1<Ccampo de golf (a+0).split(x+"|\\?",-1).length<=Cy el 4-(b+0).split(""+x,-1).length-1<Ccampo de golf 5-(b+0).split(""+x,-1).length<C.