Le croupier a été bâclé et a perdu la trace des cartes que contient son deck et quelles cartes manquent, pouvez-vous l'aider?

Un jeu complet se compose de 52 cartes à jouer, à savoir:

Chaque couleur du jeu (cœurs, diamants, piques, massues) contient:

• Les chiffres [2 - 10]
• Une prise
• Une reine
• Un roi
• Un as

Tâche

Votre programme lira le contenu du jeu depuis STDIN jusqu'à ce qu'une nouvelle ligne soit lue. Vous pouvez supposer que l'entrée sera sous la forme de "nX nX nX nX" etc. où:

• n - tout nombre compris entre [2 - 10] ou «J», «Q», «K» ou «A». (Vous ne pouvez utiliser les majuscules que pour les caractères non numériques)
• X - l'un des éléments suivants: «H», «D», «S», «C» (vous pouvez uniquement supposer les majuscules)

Où:

• «J» = Jacks
• 'Q' = Reine
• «K» = Roi
• «A» = Ace

Et

• «H» = coeurs
• «D» = diamants
• «S» = pique
• 'C' = Clubs

Vous pouvez supposer qu'il n'y aura pas de doublons dans l'entrée.

Votre programme doit ensuite imprimer les cartes manquantes dans le jeu sur STDOUT de la même manière que l'entrée ("nX nX nX") ou imprimer "Aucune carte manquante" si les 52 cartes sont fournies. Il n'y a pas de contrainte sur l'ordre de sortie des cartes.

Exemple d'entrée:

9H AH 7C 3S 10S KD JS 9C 2H 8H 8C AC AS AD 7D 4D 2C JD 6S

Production:

3H 4H 5H 6H 7H 10H JH QH KH 2D 3D 5D 6D 8D 9D 10D QD 2S 4S 5S 7S 8S 9S QS KS 3C 4C 5C 6C 10C JC QC HC

Bon golf!

Windows Batch (CMD), 205 204 octets

@set/pc=
@set d=
@for %%s in (H D S C)do @for %%r in (2 3 4 5 6 7 8 9 10 J Q K A)do @call set d=%%d%% %%r%%s
@for %%c in (%c%)do @call set d=%%d: %%c=%%
@if "%d%"=="" set d= No missing cards
@echo%d%

Boucle sur les combinaisons et les rangs pour construire un jeu complet, puis supprime les cartes d'entrée. Enregistrez 1 octet si Test autorisé à la place de 10. Enregistrez 11 octets si les arguments de ligne de commande sont des entrées acceptables. Edit: 1 octet enregistré grâce à @ user202729.

Python, 147 146 145 138 131 129 129 127 125 120 octets

print(' '.join(set(`x`+y for x in range(2,11)+list('JQKA')for y in'HDSC')-set(raw_input().split()))or'No missing cards')

Obtient toutes les cartes possibles en tant qu'ensemble et soustrait les cartes d'entrée.

-1 octet grâce à mbomb007 soulignant un espace supplémentaire dans mon code.
-1 octet grâce à mbomb007 pour avoir souligné le golf qui peut être fait avec Python 2 (-5 octets et +4 octets pour raw_in raw_input)
-7 octets en passant à l'utilisation des ensembles et à la soustraction des ensembles au lieu des listes de compréhension
-7 octets grâce à ValueInk pour avoir souligné que je n'ai pas besoin listdes suites
-2 octets grâce à Datastream pour avoir souligné que l'écriture de toutes les valeurs est plus efficace en octets que la chose étrange que j'avais auparavant
-2 octets grâce à ValueInk pour avoir souligné que les ensembles peuvent prendre des générateurs donc je n'ai pas besoin de le mettre dans une liste de compréhension
-2 octets grâce à Datastream pour avoir souligné que je peux jouer au golf encore plus si je passe à nouveau à Python 3 ... (+2 pour les parens après pour l'impression, -4 pour raw_)
-5 octets grâce à Lulhum et moi-même pour avoir pointé que le fait de revenir à Python 2 (!!!) peut m'aider à économiser des octets (en utilisant à nouveau la plage, en utilisant des raccourcis au lieu de str(, et +4 en raison de raw_)

05AB1E , 39 octets

ðIð¡YTŸ"JQKA"S«"CDHS"SâJsKðýDg>i“Noœ¶‡¶

Essayez-le en ligne!

Explication

ðI                                       # push space and input
  ð¡                                     # split on spaces
    YTŸ                                  # push the range [2 ... 10]
       "JQKA"S«                          # append ['J','Q','K','A']
               "CDHS"Sâ                  # cartesian product with suits
                       J                 # join each card with its suit
                        sK               # remove any cards in input from the list of all cards
                          ðýDg>i         # if the length of the resulting list is 0
                                “Noœ¶‡¶  # push the string "No missing cards"
                                         # output top of stack

CJam , 49 47 octets

B,2>"JQKA"+"HDSC"m*:slS/-S*"No missing cards"e|

Essayez-le en ligne!

Explication

B,                    e# The range from 0 to 10
2>                    e# Slice after the first two elements, giving the range from 2 to 10
"JQKA"+               e# Concatenate with "JQKA", giving the array containing all ranks
"HDSC"                e# The string containing all suits
m*                    e# Take the Cartesian product
:s                    e# And cast each pair to a string. Now a full deck has been constructed
l                     e# Read a line of input
S/                    e# Split it on spaces
-                     e# Remove all cards from the deck that were in the input
S*                    e# Join the result with spaces
"No missing cards"    e# Push the string "No missing cards"
e|                    e# Take the logical OR of the result and the string, returning the
                      e#   first truthy value between the two. (empty arrays are falsy)

Gelée , 39 octets

9R‘Ṿ€;“JQKA”p“CDHS”F€œ-ɠḲ¤Kȯ“¡¢ıḍĖ9ṭƥw»

Essayez-le en ligne!

Comment?

9R‘Ṿ€;“JQKA”p“CDHS”F€œ-ɠḲ¤Kȯ“¡¢ıḍĖ9ṭƥw» - Main link: no arguments
9R                                      - range(1,9)    [1,2,3,4,5,6,7,8,9]
  ‘                                     - increment     [2,3,4,5,6,7,8,9,10]
   Ṿ€                                   - uneval each  [['2'],['3'],['4'],['5'],['6'],['7'],['8'],['9'],['10']]
     ;“JQKA”                            - concatenate with char-list "JQKA" [['2'],['3'],['4'],['5'],['6'],['7'],['8'],['9'],['10'],['J'],['Q'],['K'],['A']]
            p“CDHS”                     - Cartesian product with char-list "CDHS" [[['2'],['C']],[['2'],['D']],...]
                   F€                   - flatten each [['2','C'],['2','S'],...]
                         ¤              - nilad followed by link(s) as a nilad
                       ɠ                -     read a line from STDIN
                        Ḳ               -     split on spaces
                     œ-                 - multi-set difference
                          K             - join with spaces
                            “¡¢ıḍĖ9ṭƥw» - compressed string "No missing cards"
                           ȯ            - logical or
                                        - implicit print

C #, 343 octets

La première fois que je poste un de mes golfs, ce n'est pas un très bon candidat. Je suis sûr que je peux réduire davantage cela.

L'idée derrière cela est un tableau clairsemé stockant les occurrences de cartes, avec des index calculés par les valeurs ASCII des différentes valeurs et combinaisons multipliées les unes contre les autres (par exemple, un as de pique (AS) serait stocké dans la zone à l'index (65 * 83 = 5395)). De cette façon, chaque type de carte obtient un index unique qui peut être vérifié ultérieurement pour l'existence dans le tableau "map".

void M(string[]a){var c=new int[]
{50,51,52,53,54,55,56,57,49,74,81,75,65,72,68,83,67};var e=new 
int[9999];int i=0;int j=0;foreach(var s in a) e[s[0]*s[s.Length-
1]]++;int f=0;for(i=0;i<13;i++)for(j=13;j<17;j++)if(e[c[i]*c[j]]==0)
{f=1;Console.Write(((i<9)?(i+2)+"":(char)c[i]+"")+(char)c[j]+" 
");}if(f==0) Console.WriteLine("No missing cards");}

PowerShell , 114 111 110 octets

param($n)('No missing cards',($a=(2..10+'JQKA'[0..3]|%{$i=$_;"CSHD"[0..3]|%{"$i$_"}}|?{$n-notmatch$_})))[!!$a]

Essayez-le en ligne!

Prend l'entrée en $ntant que chaîne délimitée par des espaces ou délimitée par des sauts de ligne. Construit un tableau à partir de la plage 2..10concaténée avec JQKA(indexé avec [0..3]pour en faire un chartableau). Ce tableau est introduit dans une boucle |%{}qui définit l'assistant, $ipuis boucle sur les combinaisons pour concaténer les résultats avec $i$_. À la fin de cette boucle, nous avons un tableau de chaînes comme ("2C", "2S", "2H", ... "AH", "AD"). Ce tableau est introduit dans un Where-Object(|?{} ) avec le filtre comme ces éléments $_qui regexent -notmatchl'entrée $n. Le résultat de ce filtrage est stocké dans $a.

Ensuite, nous utilisons un pseudo-ternaire ( , )[]pour sélectionner si nous produisons 'No missing cards'ou $a, selon qu'il !!$ase transforme en booléen $falseou $true. Si $aest vide (ce qui signifie que chaque carte du paquet est dans l'entrée), alors l' !!$aest 0, donc le "No missing cards"est sélectionné. Vice versa pour $aêtre sélectionné. Dans les deux cas, cela reste sur le pipeline et la sortie est implicite.

Bash + coreutils, 89

sort|comm -3 <(printf %s\\n {10,{2..9},A,J,K,Q}{C,D,H,S}) -|grep .||echo No missing cards

E / S en tant que liste délimitée par des sauts de ligne.

Explication

• sort lit les entrées délimitées par des sauts de ligne de STDIN et les trie
• Ceci est canalisé vers comm
• printf %s\\n {10,{2..9},A,J,K,Q}{C,D,H,S}est une extension d'accolade pour générer le jeu complet de cartes. Le printfimprime chaque carte sur sa propre ligne. L'ordre est donné de telle sorte que la sortie est la même que si elle avait été canalisée verssort
• comm compare la platine complète à l'entrée triée et génère la différence. -3supprime la sortie de la colonne 3 (les plus courantes)
• L'ensemble de la sortie de commest canalisé vers grep .. S'il n'y a pas eu de sortie comm(c'est-à-dire que toutes les cartes étaient en entrée), la ||clause "ou" renvoie le message requis. Sinon, le grep .correspond à toutes les lignes issues de comm.

Essayez-le en ligne .

Python 2 , 104,93,130 , 114 octets

r=input()
print' '.join(n+x for n in list('23456789JQKA')+['10']for x in'HDSC'if n+x not in r)or'No missing cards'

Essayez-le en ligne!

• -10 octets avec codage en dur de la liste au lieu d'utiliser la plage!
• +37 octets - impression manquée «Aucune carte manquante» si toutes les cartes sont présentes en entrée!
• -16 octets en modifiant le code en une liste de compréhension!

Ruby, 108 + 1 = 109 octets

Utilise le -pdrapeau.

a=[*?2..'10',?J,?Q,?K,?A].map{|i|%w"H D S C".map{|c|i+c}}.flatten-$_.split;$_=a==[]?"No missing cards":a*' '

PHP, 143 octets

foreach([H,D,S,C]as$c)foreach([2,3,4,5,6,7,8,9,10,J,Q,K,A]as$v)$r[]=$v.$c;echo join(" ",array_diff($r,explode(" ",$argn)))?:"No missing cards";

sed , 157 + 1 ( -rflag) = 170 158 octets

x
s/$/;A2345678910JQK/
s/.+/&H&D&S&C;No missing cards/
:
s/(10|\w)(\w+)(.);/\1\3 \2\3;/
t
G
:s
s/(10.|[^ ;1]{2})(.*\n.*)\1/\2/
ts
s/[ ;]+/ /g
s/^ //
s/ N.+//

Essayez-le en ligne!

Cela génère toutes les cartes possibles, puis supprime chaque carte de l'entrée des cartes générées.

C # , 282 octets

Golfé

i=>{var o=new System.Collections.Generic.List<string>();string[] S={"H","D","S","C"},N="A 2 3 4 5 6 7 8 9 10 J Q K".Split(' ');foreach(var s in S){foreach(var n in N){if(!System.Linq.Enumerable.Contains(i,n+s)){o.Add(n+s);}}}return o.Count>0?string.Join(" ",o):"No missing cards";};

Non golfé

i => {
    var o = new System.Collections.Generic.List<string>();
    string[] S = { "H", "D", "S", "C" }, N = "A 2 3 4 5 6 7 8 9 10 J Q K".Split(' ');

    foreach( var s in S ) {
        foreach( var n in N ) {
            if( !System.Linq.Enumerable.Contains( i, n + s ) ) {
                o.Add( n + s );
            }
        }
    }

    return o.Count > 0
        ? string.Join( " ", o )
        : "No missing cards";
};

Non lisible non lisible

i => {
    // Initialize a list to contain the list of cards missing
    var o = new System.Collections.Generic.List<string>();

    // Initialize the list of suits and numbers of cards
    string[] S = { "H", "D", "S", "C" }, N = "A 2 3 4 5 6 7 8 9 10 J Q K".Split(' ');

    // Cycle through the suits...
    foreach( var s in S ) {
        // ... and the numbers ...
        foreach( var n in N ) {
            // ... and check it the combo number + suite is missing
            if( !System.Linq.Enumerable.Contains( i, n + s ) ) {
                // If it's missing, add it to the list of missing cards
                o.Add( n + s );
            }
        }
    }

    // If the count of missing cards is greater than 0...
    return o.Count > 0
        // Build a 'space' separated string with the missing cards
        ? string.Join( " ", o )
        // Or output the missing cards string
        : "No missing cards";
};

Code complet

using System;
using System.Collections.Generic;
using System.Linq;

namespace Namespace {
   class Program {
      static void Main( String[] args ) {
         Func<String, Int32> f = i => {
            var o = new List<string>();
            string[] S = { "H", "D", "S", "C" }, N = "A 2 3 4 5 6 7 8 9 10 J Q K".Split(' ');

            foreach( var s in S ) {
               foreach( var n in N ) {
                  if( !i.Contains( n + s ) ) {
                     o.Add( n + s );
                  }
               }
            }

            return o.Count > 0
               ? string.Join( " ", o )
               : "No missing cards";
         };

         List<String>
            testCases = new List<String>() {
                "9H AH 7C 3S 10S KD JS 9C 2H 8H 8C AC AS AD 7D 4D 2C JD 6S"
            };

         foreach( String testCase in testCases ) {
            Console.WriteLine( $"{test}\n{f( test.Split( ' ' ) )}" );
         }

         Console.ReadLine();
      }
   }
}

Communiqués

• v1.0 - 282 bytes- Solution initiale.

Remarques

Rien à ajouter

JavaScript (ES6), 117 114 111 octets

s=>[...Array(52)].map((_,i)=>~s.search(c=('JQKA'[v=i>>2]||v-2)+'CDHS'[i&3])?_:c+' ').join``||'No missing cards'

Cela tire parti du fait que les entrées non définies dans le tableau généré par map()sont contraintes à des chaînes vides lorsquejoin() 'd.

Démo

let f =

s=>[...Array(52)].map((_,i)=>~s.search(c=('JQKA'[v=i>>2]||v-2)+'CDHS'[i&3])?_:c+' ').join``||'No missing cards'

console.log(f('9H AH 7C 3S 10S KD JS 9C 2H 8H 8C AC AS AD 7D 4D 2C JD 6S'))

Rétine , 76 octets

^
A2345678910JQK¶ 
\G(10|.)
 $&H $&D $&S $&C
Dr` \S+
G1`
^$
No missing cards

L'entrée / sortie est une liste de cartes séparées par des espaces. La sortie a un espace de tête.

Essayez-le en ligne!

Explication

La plupart du code traite de la construction de la liste complète des cartes qui devraient être dans le jeu:

^
A2345678910JQK¶ 
\G(10|.)
 $&H $&D $&S $&C

D'abord, nous ajoutons une nouvelle ligne à l'entrée, avec toutes les valeurs possibles des cartes, puis pour chaque personnage de cette ligne (ou le couple de caractères 10) nous construisons la liste de toutes les combinaisons possibles de cette carte.

Dr` \S+

Il s'agit d'une étape de déduplication, elle divise la chaîne en morceaux constitués d'un espace plus quelques non-espaces et ne conserve qu'une seule occurrence de chaque bloc. Le modificateur le rfait fonctionner de droite à gauche, en gardant alors la dernière occurrence de chaque morceau.

G1`

Nous ne conservons que la première ligne, qui contient désormais les cartes manquantes.

^$
No missing cards

Si le résultat est vide, nous le remplaçons par "Aucune carte manquante"

Python 3, 106 octets

Combinaison des deux réponses python précédentes mélangées à des manigances de déballage de chaînes.

print(' '.join({x+y for x in[*'23456789JQKA','10']for y in'HDSC'}-{*input().split()})or'No missing cards')

Julia , 116 octets

print(join(setdiff(["$x$y"for x=∪(2:10,"JQKA")for y="HDSC"],readline()|>split),' ')|>s->s>""?s:"No missing cards")

Essayez-le en ligne!

Très similaire à la solution de python Kyle Gullions. Setdiff au lieu de - et le lambda pour tester la chaîne vide aggravent cependant.

Japt, 39 octets

"JQKA"¬c9õÄ)ï+"CHSD"q)kU ¸ª`No ÚÍg Ößs

Essayez-le

Tcl , 270 228 caractères

(Raccourci avec l'aide de Wît Wisarhd)

foreach s {H D S C} {foreach c {2 3 4 5 6 7 8 9 J Q K A} {dict set d $c$s 0}}
gets stdin l
foreach c $l {dict set d $c 1}
set m {}
dict for {c h} $d {if {!$h} {lappend m $c}}
if {![llength $m]} {set m "No missing cards"}
puts $m

Essayez-le en ligne!

Explication:

Cette implémentation construit un dictionnaire composé d'un drapeau booléen pour chacune des cartes représentées par le produit cartésien de HDSC et 2-through-A. Il lit la ligne de stdin, qui, si elle est indiquée comme spécifiée, est en fait une liste Tcl bien formée. Au fur et à mesure que chaque carte est lue, un booléen true est entré dans le dictionnaire pour cette carte.

À la fin, un analyseur parcourt le dictionnaire et ajoute toute carte qui n'avait pas de vrai dans le dictionnaire à une liste de cartes manquantes. Si la longueur de la liste des cartes manquantes est nulle, affichez «Aucune carte manquante», sinon affichez la liste des cartes manquantes.

PHP , 138 octets

Ran avec -net-d error_reporting=0

Je réutilise du code d'une ancienne soumission que j'ai faite qui demandait de créer un jeu de cartes

Code

<?$r=[];foreach([A,J,Q,K,2,3,4,5,6,7,8,9,10]as$t)array_push($r,$t.H,$t.S,$t.D,$t.C);
echo join(" ", array_diff($r,explode(" ",$argv[1])));

Essayez-le en ligne!

Explication

<?$r=[];   # Declare the array that will contain the full deck
# the next line will generate the arry with the full deck  
foreach([A,J,Q,K,2,3,4,5,6,7,8,9,10]as$t)array_push($r,$t.H,$t.S,$t.D,$t.C);
# explode the input string on each blank space and using array_diff to get the
# different elements withing both arrays. (and "echo" of course) 
echo join(" ", array_diff($r,explode(" ",$argv[1])));

C # (.NET Core) , 197 octets

Sans LINQ.

s=>{var w="";for(var j=0;j<52;){var u="";int t=j%13;u=t<1?"K":t<2?"A":t<11?t+"":t<12?"J":"Q";t=j++/13;u+=t<1?"H":t<2?"D":t<3?"S":"C";w+=s.IndexOf(u)<0?u+" ":"";}return w==""?"No missing cards":w;};

Essayez-le en ligne!

Perl 6 , 73 octets

put keys((<<{^9+2}J Q K A>>X~ <C S D H>)∖get.words)||"No missing cards"

Essayez-le en ligne!

Une soustraction d'ensemble assez simple entre le jeu de cartes et l'entrée.

Python 3 , 102 octets

lambda s:' '.join(i+j for i in[*'A23456789JQK','10']for j in'HDSC'if(i+j)not in s)or'No missing cards'

Essayez-le en ligne!