La triche est un jeu de cartes où vous essayez de vous débarrasser de votre main. Un virage ressemble à peu près à ceci:

1. Déterminez quel rang de carte vous devez jouer ce tour-ci. Dans la plupart des variantes, c'est un rang de plus que le tour précédent.
2. Jouez 1 à 4 cartes, face cachée. Ceux-ci n'ont pas à correspondre au rang valide. S'ils ne le font pas, c'est considéré comme une triche . À ce stade, n'importe quel joueur peut vous défier .
   • Si personne ne vous défie, le jeu continue jusqu'au joueur suivant.
   • Si quelqu'un vous met au défi et que vous n'avez pas triché, il doit prendre toutes les cartes jouées.
   • Si quelqu'un vous défie et que vous avez triché, vous devez prendre toutes les cartes jouées.

La stratégie est principalement un mélange de bluff et de comptage de cartes. Je suis mauvais en mathématiques, cependant, je vais donc tricher à Cheat et apporter un bot avec moi.

Contribution

L'entrée sera, dans n'importe quel ordre ou format que vous souhaitez:

1. La main du joueur. Si je sais qu'ils doivent avoir des cartes (par exemple, je les ai vues les récupérer), celles-ci seront répertoriées par ordre croissant. Toutes les inconnues seront ensuite répertoriées comme ?. Par exemple, s'ils ont six cartes et je sais que deux sont des 1 et un est un 4, une représentation valide de la main est 114???. Les? seront toujours répertoriés après les cartes connues. 141???et 11???4sont à la fois des entrées non valides et votre code n'a pas besoin de les gérer.
2. Les cartes que je connais définitivement ne font pas partie de leur main (je les ai, j'ai vu quelqu'un d'autre les ramasser, etc.). La liste sera par ordre croissant de rang. La liste est peut-être vide.
3. Les cartes que le joueur prétendait jouer. S'ils prétendaient jouer 3 7, une entrée possible ici serait 777. Les cartes auront toujours le même rang.

Le nombre de cartes jouées sera toujours de 1 à 4 et les rangs seront toujours de 0 à 9. Un rang n'apparaîtra jamais plus de quatre fois dans sa main + pas dans sa main.

Ceci est un exemple d'entrée valide:

33577??
01555688
55

Ceci est un exemple d'entrée non valide:

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

Production

Une valeur honnête si nous devons définitivement contester. Une valeur de falsey si nous ne voulons pas contester.

Nous contestons toujours si nous savons qu'ils ont triché. Nous savons qu'ils ont triché s'ils jouaient aux cartes qu'ils ne pouvaient pas avoir:

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'autre fois que nous contestons, c'est s'ils jouent leurs dernières cartes. Même si le jeu est légitime, il mettrait fin au jeu, alors nous pourrions aussi bien le défier.

1

1 # They'd win, so challenge anyway

Plus de cas de test

Truthy (devrait contester)

11445678?

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

9

Falsey (ne devrait pas contester)

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

1111

Notation

Le code le plus court gagne.

Pyth, 22 octets

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

Essayez-le en ligne.

JavaScript (ES6), 93 octets

(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

Accepte trois chaînes de cartes (caractères 0- 9ou ?); revient 1pour le défi, 0sinon. Explication:

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

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;

(Remarque: conformément à l'exemple de OP, cette réponse est fausse même si l'adversaire a plus d'une carte et joue toute sa main. En termes de stratégie, cela devrait retourner vrai.)

Explication:

a: Main du joueur
b: Cartes que je connais vraiment ...
c : Cartes prétendant jouer

Non 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 octets

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

Explication:

Essayez-le ici.

(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

REMARQUE: (s+0).split("c",-1).length-1donne le nombre de fois où le caractère capparaît dans la chaîne s. Les commentaires dans l'explication ci-dessus sont donc corrects, mais le code peut sembler différent à cause de cela. Le (a+0).split(x+"|\\?",-1).length-1<Cest joué au (a+0).split(x+"|\\?",-1).length<=Cet le 4-(b+0).split(""+x,-1).length-1<Cest joué au 5-(b+0).split(""+x,-1).length<C.