Écrivez le code pour déterminer qui remporte un tour de quatre cartes dans un jeu de pique . Le moins d'octets gagne.

L'entrée est une chaîne qui répertorie les quatre cartes jouées en séquence comme TH QC JH 2H(Ten of Hearts, Queen of Clubs, Jack of Hearts, Two of Hearts). Une carte est donnée par deux personnages: une couleur de CDHSet une valeur de 23456789TJQKA. Vous êtes assuré que l'entrée est valide et que les cartes sont distinctes.

Vous devez sortir un nombre 1, 2, 3 ou 4 pour le vainqueur de l'astuce. Dans l'exemple TH QC JH 2H, la prise de cœur remporte le tour, vous devez donc sortir 3.

Vos entrées et sorties doivent être exactement comme décrites, sauf que les retours à la ligne de fin sont facultatifs.

Voici les règles de Spades pour gagner un tour. La carte gagnante est la carte la plus élevée des quatre, avec quelques mises en garde. La pique est le costume d'atout , donc toute bêche surpasse tout non-pique. La couleur de la première carte jouée est la couleur principale , et seules les cartes de cette couleur ou des piques sont éligibles pour remporter le tour. Les cartes de la même couleur sont comparées par leurs valeurs, qui sont données en ordre croissant au fur et à mesure 23456789TJQKA.

Cas de test:

TH QC JH 2H
3
KC 5S QS 9C
3
QD 2D TD 5D
1
9S 5D AD QS
4
3D 4C 3H JH
1
9S 4S TS JS
4
5H 9H 2C AD
2
5S 4C 3H QD
1
2H 2S KH AH
2

Pyth, 28 27 25 octets

J"KTAZ"hxcz)eo_XN+@z1JJcz

Essayez-le en ligne: démonstration ou suite de tests (les 4 premiers caractères sont la construction de la suite de tests)

Merci à @isaacg pour une astuce qui a sauvé 2 caractères.

L'idée principale est de modifier les caractères de chaque main de manière à ce que la main gagnante ait la valeur maximale.

Les valeurs des mains 23456789TJQKAsont déjà presque triées. Je dois juste remplacer Tpar A, Kavec Tet Aavec Z, résultant avec 23456789AJQSZ.

L'ordre des costumes CDHSn'est pour la plupart pas vraiment important. S, la combinaison la plus puissante, qui est déjà la valeur maximale. L'important est de donner à la combinaison de première main la deuxième valeur la plus puissante. Donc je traduis ce costume en K.

Toutes les mains doivent également être lues à l'envers, car la combinaison est plus puissante que la valeur.

                           implicit: z = input string
J"KTAZ"                    J = "KTAZ"
             o         cz  orders the hands N of split(z) by:
              _              the reversed of 
               XN+@z1JJ      N, where the values z[1]+J are replaced by J
            e              last element (winning hand)
        xcz)               index of the winning hand in split(z)
       h                   + 1

CJam, 34 33 octets

lS/_{)2$0='S+\#\"TQKA"_$er+}$W>#)

Algorithme

La logique est simple. J'ai un tri personnalisé en cours, dans lequel je donne d'abord la priorité au deuxième personnage représentant la combinaison. En cela, Spades obtient la priorité la plus élevée, puis la première suite lancée. Reste tous -1. Ensuite, je trie le premier caractère en échangeant Tavec Aet Qavec Kpour avoir un tri lexical.

Explication du code

Tout d'abord, voyons quel est l'ordre lexical des valeurs faciales des cartes:

"23456789TJQKA"$

23456789AJKQT

Ainsi, tous les nombres sont à la bonne position. Jest également à la bonne position. Nous devons échanger Ket Qet Jet Apour obtenir l'ordre lexical.

lS/_{)2$0='S+\#\"TQKA"_$er+}$W>#)
lS/                                 "Read an input line and split on spaces";
   _{                      }$       "Copy the array and sort it using this custom logic";
     )                              "Take off the last character of each hand.";
      2$0=                          "Get the suit of the first hand";
          'S+                       "Add Spades suit to it";
             \#                     "Get the index of the current hand suit.
                                     1 for Spades, 0 for first hand suit, -1 otherwise";
               \                    "Put face value of this hand on top of stack";
                "TQKA"              "Put string TQKA on stack";
                      _$            "Copy and sort. This essentially reverses the string
                                     TQKA to form AKQT. This is 1 byte shorter than _W%";
                        er+         "Swap T with A and K with Q and add to the
                                     suit index calculated previously";
                                    "After the above tuple, sorting will automatically
                                     convert the tuple to string and sort lexically";
                             W>     "Get the array containing only the last element";
                               #)   "Get the index of this hand in original set and
                                     increment to convert it to 1 based";

Essayez-le en ligne ici

JavaScript (ES6), 112

Parcourez la liste et renvoyez la position de la valeur la plus élevée trouvée.

Exécutez l'extrait de code pour tester (dans Firefox)

F=t=>t.split(' ').map((c,i)=>(n='23456789TJQKA'.search(c[0])+(c[1]>'H'?40:c[1]==t[1]&&20))>m&&(m=n,r=i+1),m=0)|r

C.innerHTML=['TH QC JH 2H','KC 5S QS 9C','QD 2D TD 5D','9S 5D AD QS','3D 4C 3H JH','9S 4S TS JS','5H 9H 2C AD','5S 4C 3H QD'].map(h=>h+' -> '+F(h)).join('\n')

<pre id=C></pre>

Perl, 73 octets

#!perl -pl
/\B./;s/$&/P/g;y/TKA/IRT/;$_=reverse;@a=sort split;/$a[-1]/;$_=4-"@-"/3

Essayez moi .

Convertit les noms de cartes afin que l'ordre des valeurs du jeu suive l'ordre alphabétique, puis sélectionne le plus élevé par tri et le recherche dans la chaîne d'origine pour la position.

Rubis, 59 + 2 = 61

Avec des drapeaux de ligne de commande na, exécutez

p (1..4).max_by{|i|$F[i-1].tr($_[1]+'SJQKA','a-z').reverse}

J, 47 octets

1+[:(i.>./)_3+/\16!@-]i.~'SXAKQJT9876543'1}~1&{

Usage:

   (1+[:(i.>./)_3+/\16!@-]i.~'SXAKQJT9876543'1}~1&{) 'TH QC 9S 8S'
3

Méthode:

• Pour chaque caractère d'entrée, nous attribuons une valeur basée sur sa position dans la 'S[second char of input]AKQJT9876543'chaîne. Les caractères non trouvés obtiennent last position + 1implicitement la valeur . Les autres caractères ont beaucoup moins de valeur ( value=(16-position)!).
• Calculez la somme des 3 triplets de caractères d'entrée et d'un doublon (par exemple, TH_ QC_ 9S_et 8S).
• Choisissez l'index basé sur 1 de la valeur maximale.

(J ne peut malheureusement pas comparer directement les caractères ou les chaînes. Il ne peut que vérifier leur égalité, ce qui a exclu d'autres approches pour ce défi.)

Essayez-le en ligne ici.

C #, 237

using System;namespace S{class P{static void Main(string[] a){var V="23456789TJQKA";int x=0;int y=0;var z=a[0][1];for(int i=0;i<4;i++){int q=V.IndexOf(a[i][0])+2;var w=a[i][1];q*=w==z?1:w=='S'?9:0;if(q>y){x=i;y=q;}}Console.Write(x+1);}}}

Comment ça marche: Itérer chaque main pour calculer la "valeur" de la carte .. stocker l'indice le plus valorisé. Une valeur de cartes est déterminée comme le rang de la carte multiplié par 0 si ce n'est pas une bêche ou la couleur d'ouverture, 1 si c'est la couleur d'ouverture et 9 si c'est une bêche mais pas la couleur d'ouverture. (9 choisi b / c 2 * 9 = 18> A = 14 & 9 est un seul caractère)

Pyth, 36 33 octets

KczdhxKeo,x,ehK\SeNXhN"TKA""AYZ"K

Approche assez simple, utilise le tri avec une fonction de clé personnalisée, puis trouve l'index de la valeur la plus élevée.

Pyth, 31 octets

hxczdeo}\SNo}@z1Zox"TJQKA"hNScz

Essayez-le ici.

Comment ça fonctionne:

La bonne façon de lire cette procédure est de l'arrière vers l'avant. La procédure trie la carte souhaitée à la fin de la liste, puis la retire et trouve son index dans la liste d'origine.

• cz: Cela génère la liste des chaînes de cartes. c, chop, est normalement une fonction binaire (arité 2), mais lorsqu'il est appelé sur une seule entrée, sert de .split()méthode de chaîne.

• S: Ceci applique le comportement de tri normal, qui trie les cartes numérotées inférieures avant les cartes supérieures.

• ox"TJQKA"hN: Ceci trie les cartes par l'index ( x) dans la chaîne "TJQKA"de la première lettre de la carte ( hN). Pour les cartes avec des chiffres, la première lettre est introuvable, donnant le résultat -1. La fonction de tri de Pyth étant stable, l'ordre des cartes numérotées n'est pas affecté.

• o}@z1Z: Ensuite, nous ordonnons si la couleur de la première carte jouée ( @z1) est dans la carte en question. Puisque Truetrie derrière False, cela envoie les cartes de la couleur principale à l'arrière.

• o}\SN: C'est le même que le tri précédent, mais il trie si la lettre Sest dans la carte, envoyant des piques à l'arrière.

• hxczde: Ceci extrait la dernière carte triée de cette façon ( e), trouve son index dans la liste des cartes ( xczd) et incrémente de 1 ( h), donnant l'emplacement du joueur souhaité.