Il mazziere è stato sciatto e ha perso la cognizione di quali carte contiene il suo mazzo e quali carte mancano, puoi aiutarlo?

Un mazzo completo è composto da 52 carte da gioco, vale a dire:

Ogni colore nel mazzo (cuori, quadri, picche, fiori) contiene:

• I numeri [2 - 10]
• Un jack
• Una regina
• Un re
• Un asso

Compito

Il programma leggerà i contenuti del deck da STDIN fino a quando non verrà letta una nuova riga. Si può presumere che l'ingresso sarà nella forma di "nX nX nX nX" ecc. Dove:

• n - qualsiasi numero compreso tra [2 - 10] o "J", "Q", "K" o "A". (Puoi assumere lettere maiuscole solo per caratteri non numerici)
• X: una delle seguenti opzioni: "H", "D", "S", "C" (puoi assumere solo lettere maiuscole)

Dove:

• 'J' = Jack
• 'Q' = Regina
• 'K' = Re
• 'A' = Asso

E

• 'H' = Cuori
• 'D' = Diamanti
• 'S' = Picche
• 'C' = Club

Puoi presumere che non ci saranno duplicati nell'input.

Il programma deve quindi stampare su STDOUT le carte mancanti nel mazzo allo stesso modo dell'input ("nX nX nX") o stampare "Nessuna carta mancante" se vengono fornite tutte le 52 carte. Non vi è alcun vincolo sull'ordine di uscita delle carte.

Esempio di input:

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

Produzione:

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

Buon golf!

Windows Batch (CMD), 205 204 byte

@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%

Passa sopra i semi e le fila costruendo un mazzo completo, quindi elimina le carte di input. Salva 1 byte se Tconsentito invece di 10. Salva 11 byte se gli argomenti della riga di comando sono input accettabili. Modifica: salvato 1 byte grazie a @ user202729.

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

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')

Ottiene tutte le carte possibili come set e sottrae le carte di input.

-1 byte grazie a mbomb007 sottolineando uno spazio aggiuntivo nel mio codice.
-1 byte grazie a mbomb007 per indicare alcuni campi da golf che possono essere fatti con Python 2 (-5 byte e +4 byte per raw_in raw_input)
-7 byte passando all'utilizzo dei set e impostando la sottrazione invece della comprensione dell'elenco
-7 byte grazie a ValueInk per aver sottolineato che non ho bisogno listdelle suite
-2 byte grazie a Datastream per aver sottolineato che scrivere tutti i valori è più efficace per i byte rispetto alla cosa strana che avevo in precedenza
-2 byte grazie a ValueInk per aver sottolineato che set possono prendere generatori, quindi non ho bisogno di metterlo in una lista di comprensione
-2 byte grazie a Datastream per aver sottolineato che posso spostarlo ancora di più se passo di nuovo a Python 3 ... (+2 per i genitori dopo la stampa, -4 per raw_)
-5 byte grazie a Lulhum e a me stesso per indicare tornare indietro a Python 2 (!!!) può aiutarmi a salvare byte (usando di nuovo range, usando backtick invece di str(, e +4 a causa di raw_)

05AB1E , 39 byte

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

Provalo online!

Spiegazione

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

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

Provalo online!

Spiegazione

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)

Gelatina , 39 byte

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

Provalo online!

Come?

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 byte

Pubblicando per la prima volta uno dei miei campi da golf, non è un ottimo concorrente. Sono sicuro di poterlo ridurre di più.

L'idea alla base è una matrice sparsa che memorizza le occorrenze delle carte, con gli indici calcolati dai valori ASCII dei diversi valori e semi moltiplicati l'uno contro l'altro (ad esempio un asso di picche (AS) sarebbe memorizzato nell'area in corrispondenza dell'indice (65 * 83 = 5395)). In questo modo, ogni tipo di carta ottiene un indice univoco che può essere verificato in seguito per l'esistenza nell'array "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 byte

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

Provalo online!

Accetta l'input $ncome stringa delimitata da spazi o delimitata da newline. Costruisce un array dall'intervallo 2..10concatenato con JQKA(indicizzato con [0..3]per renderlo un chararray). Quell'array viene immesso in un loop |%{}che imposta helper, $iquindi passa sopra le tute per concatenare i risultati insieme $i$_. Alla fine di questo ciclo, abbiamo una serie di stringhe come ("2C", "2S", "2H", ... "AH", "AD"). Quell'array viene inserito in a Where-Object( |?{}) con il filtro come quegli elementi $_che regex -notmatchl'input $n. Il risultato di quel filtro viene archiviato in $a.

Quindi, usiamo uno pseudo-ternario ( , )[]per selezionare se produrre 'No missing cards'o $a, in base al fatto che !!$asi trasforma in un valore booleano $falseo $true. Se $aè vuoto (significa che ogni carta nel mazzo è nell'input), allora lo !!$aè 0, quindi "No missing cards"è selezionato. Viceversa per $aessere selezionato. In entrambi i casi, rimane sulla pipeline e l'output è implicito.

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

I / O come elenco delimitato da nuova riga.

Spiegazione

• sort legge l'input delimitato da nuova riga da STDIN e lo ordina
• Questo è indirizzato a comm
• printf %s\\n {10,{2..9},A,J,K,Q}{C,D,H,S}è un'espansione per generare l'intero mazzo di carte. La printfstampa ogni carta sulla propria riga. L'ordine è dato in modo tale che l'output sia lo stesso come se fosse stato reindirizzatosort
• commconfronta l'intero deck con l'input ordinato e genera la differenza. -3sopprime l'output della colonna 3 (quelli comuni)
• L'intero output da commviene reindirizzato a grep .. Se non è stato emesso alcun output da comm(ovvero tutte le schede erano nell'input), la ||clausola "o" genera il messaggio richiesto. In caso contrario, grep .corrisponde a tutte le linee in uscita da comm.

Provalo online .

Python 2 , 104,93,130 , 114 byte

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'

Provalo online!

• -10 byte con hardcoding l'elenco invece di usare range!
• +37 byte - Stampa mancata 'Nessuna carta mancante' se tutte le carte sono presenti nell'input!
• -16 byte modificando il codice in una comprensione di lista!

Rubino, 108 + 1 = 109 byte

Usa la -pbandiera.

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 byte

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 byte

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.+//

Provalo online!

Questo genera tutte le carte possibili e quindi rimuove ogni carta nell'input dalle carte generate.

C # , 282 byte

golfed

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

Ungolfed

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

Leggibile non golfato

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

Codice completo

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

Uscite

• v1.0 - 282 bytes- Soluzione iniziale.

Appunti

Niente da aggiungere

JavaScript (ES6), 117 114 111 byte

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

Questo sfrutta il fatto che le voci indefinite nell'array generato da map()sono costrette a stringhe vuote quando join()'d.

dimostrazione

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'))

Retina , 76 byte

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

Input / output è un elenco di carte separate da spazi. L'output ha uno spazio iniziale.

Provalo online!

Spiegazione

La maggior parte del codice riguarda la costruzione dell'elenco completo delle carte che dovrebbero essere nel mazzo:

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

Innanzitutto, anteponiamo una nuova riga all'input, con tutti i possibili valori di carte, quindi per ogni personaggio di questa linea (o la coppia di personaggi 10) costruiamo l'elenco di tutti i semi possibili di quella carta.

Dr` \S+

Questa è una fase di deduplicazione, divide la stringa in blocchi costituiti da uno spazio più alcuni non-spazi e mantiene solo una ricorrenza di ciascun blocco. Il modificatore rfa funzionare questo da destra a sinistra, mantenendo quindi l' ultima occorrenza di ogni blocco.

G1`

Manteniamo solo la prima riga, che ora contiene le carte mancanti.

^$
No missing cards

Se il risultato è vuoto lo sostituiamo con "Nessuna carta mancante"

Python 3, 106 byte

Combinazione delle due precedenti risposte in pitone mescolate con alcune stringhe che disimballano gli shenanigans.

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

Julia , 116 byte

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

Provalo online!

Molto simile alla soluzione Python di Kyle Gullions. Setdiff invece di - e il lambda per testare la stringa vuota lo rende peggio.

Japt, 39 byte

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

Provalo

Tcl , 270 228 caratteri

(Accorciato con l'aiuto di 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

Provalo online!

Spiegazione:

Questa implementazione crea un dizionario costituito da una bandiera booleana per ciascuna delle carte rappresentate dal prodotto cartesiano di HDSC e da 2 a A. Legge la riga dallo stdin, che se indicato come specifica come richiesto, è in realtà un elenco Tcl ben formato. Mentre ogni carta viene letta, un vero valore booleano viene inserito nel dizionario per quella carta.

Alla fine un parser scorre il dizionario e aggiunge qualsiasi carta che non aveva un valore vero nel dizionario a un elenco di carte mancanti. Se la lunghezza dell'elenco delle carte mancanti è zero, genera "Nessuna carta mancante", altrimenti visualizza l'elenco delle carte mancanti.

PHP , 138 byte

Ho corso con -ne-d error_reporting=0

Riutilizzo un po 'di codice da una vecchia presentazione che ho chiesto di creare un mazzo di carte

Codice

<?$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])));

Provalo online!

Spiegazione

<?$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 byte

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

Provalo online!

Perl 6 , 73 byte

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

Provalo online!

Qualche sottrazione piuttosto semplice tra il mazzo di carte e l'input.

Python 3 , 102 byte

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

Provalo online!