Cheat è un gioco di carte in cui stai cercando di sbarazzarti della tua mano. Una svolta sembra più o meno così:

1. Determina quale rango di carte devi giocare in quel turno. Nella maggior parte delle varianti questo è un rango superiore rispetto al turno precedente.
2. Gioca 1-4 carte a faccia in giù. Questi non devono corrispondere al grado valido. In caso contrario, è considerato un imbroglione . A questo punto qualsiasi giocatore può sfidarti .
   • Se nessuno ti sfida, il gioco continua al giocatore successivo.
   • Se qualcuno ti sfida e non hai imbrogliato, devono prendere tutte le carte giocate.
   • Se qualcuno ti sfida e hai imbrogliato, devi prendere tutte le carte giocate.

La strategia è principalmente un mix di bluff e conteggio delle carte. Sono cattivo in matematica, però, quindi ho intenzione di tradire Cheat e portare un robot con me.

Ingresso

L'input sarà, nell'ordine o nel formato desiderato:

1. La mano del giocatore. Se so che devono avere delle carte (per esempio, le ho viste raccoglierle), quelle saranno elencate in ordine crescente. Eventuali incognite verranno elencate in seguito come ?. Ad esempio, se hanno sei carte e so che due sono 1 e uno è 4, una valida rappresentazione della mano è 114???. ? saranno sempre elencati dopo le carte conosciute. 141???e 11???4sono entrambi input non validi e il tuo codice non deve gestirli.
2. Le carte che sicuramente conosco non fanno parte della loro mano (le ho, ho visto qualcun altro prenderle, ecc.). L'elenco sarà in ordine crescente di rango. L'elenco potrebbe essere vuoto.
3. Le carte che il giocatore ha affermato di giocare. Se affermassero di giocare a 3 7, un possibile input qui sarebbe 777. Le carte avranno sempre lo stesso valore.

Il numero di carte giocate sarà sempre 1-4 e i ranghi saranno sempre 0-9. Un rango non apparirà mai più di quattro volte nella loro mano + non nella loro mano.

Questo è un input valido di esempio:

33577??
01555688
55

Questo è un esempio di input non valido:

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

Produzione

Un valore veritiero se dovessimo assolutamente sfidare. Un valore falso se potremmo non voler sfidare.

Sfidiamo sempre se sappiamo che hanno imbrogliato. Sappiamo che hanno imbrogliato se giocavano a carte che non avrebbero potuto avere:

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

L'altra volta che sfidiamo è se giocano le loro ultime carte. Anche se il gioco è legittimo, finirebbe il gioco, quindi potremmo anche sfidarlo.

1

1 # They'd win, so challenge anyway

Altri casi di test

Verità (dovrebbe sfidare)

11445678?

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

9

Falsey (non dovrebbe sfidare)

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

1111

punteggio

Il codice più corto vince.

Pyth, 22 byte

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

Provalo online.

JavaScript (ES6), 93 byte

(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

Accetta tre stringhe di carte (caratteri 0- 9o ?); ritorna 1per sfida, 0altrimenti. Spiegazione:

(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 byte

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: in linea con l'esempio di OP, questa risposta restituisce falso anche se l'avversario ha più di una carta e sta giocando tutta la sua mano. In termini di strategia questo dovrebbe restituire vero.)

Spiegazione:

a: Mano del giocatore
b: Carte che sicuramente conosco ...
c: Carte dichiarate di giocare

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 byte

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

Spiegazione:

Provalo qui.

(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-1indica il numero di volte in cui il carattere si cpresenta in String s. Quindi i commenti nella spiegazione sopra sono corretti, ma il codice potrebbe sembrare diverso a causa di ciò. Si (a+0).split(x+"|\\?",-1).length-1<Cgioca a golf (a+0).split(x+"|\\?",-1).length<=Ce 4-(b+0).split(""+x,-1).length-1<Csi gioca a 5-(b+0).split(""+x,-1).length<C.