Der Dealer war schlampig und hat den Überblick verloren, welche Karten sein Deck enthält und welche Karten fehlen. Können Sie ihm helfen?

Ein komplettes Deck besteht aus 52 Spielkarten, nämlich:

Jede Farbe im Deck (Herzen, Diamanten, Pik, Keulen) enthält:

• Die Zahlen [2 - 10]
• Ein Jack
• Eine Königin
• Ein König
• Ein Ass

Aufgabe

Ihr Programm liest den Inhalt des Decks von STDIN, bis eine neue Zeile gelesen wird. Sie können davon ausgehen, dass die Eingabe in Form von "nX nX nX nX" usw. erfolgt, wobei:

• n - eine beliebige Zahl zwischen [2 - 10] oder entweder "J", "Q", "K" oder "A". (Sie können nur Großbuchstaben für nicht numerische Zeichen annehmen.)
• X - eine der folgenden Angaben: 'H', 'D', 'S', 'C' (nur Großbuchstaben möglich)

Woher:

• 'J' = Jacks
• 'Q' = Königin
• 'K' = König
• 'A' = Ass

Und

• 'H' = Herzen
• 'D' = Diamanten
• 'S' = Pik
• 'C' = Vereine

Sie können davon ausgehen, dass die Eingabe keine Duplikate enthält.

Ihr Programm muss dann die fehlenden Karten im Deck auf die gleiche Weise wie die Eingabe ("nX nX nX") auf STDOUT drucken oder "Keine fehlenden Karten" drucken, wenn alle 52 Karten geliefert werden. Die Reihenfolge der Kartenausgabe unterliegt keiner Einschränkung.

Beispiel Eingabe:

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

Ausgabe:

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

Viel Spaß beim Golfen!

Windows Batch (CMD), 205 204 Bytes

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

Durchlaufen Sie die Farben und Ränge, um ein vollständiges Deck zu erstellen, und löschen Sie dann die Eingabekarten. Speichern Sie 1 Byte, wenn dies Tanstelle von zulässig ist 10. Speichern Sie 11 Byte, wenn Befehlszeilenargumente als Eingabe zulässig sind. Bearbeiten: 1 Byte dank @ user202729 gespeichert.

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

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

Erhält alle möglichen Karten als Set und subtrahiert die Eingangskarten.

-1 Byte dank mbomb007, das auf einen zusätzlichen Platz in meinem Code hinweist.
-1 Byte dank mbomb007 für Hinweise zum Golfen mit Python 2 (-5 Bytes und +4 Bytes für raw_In raw_input)
-7 Bytes durch Umschalten auf Sets und Set-Subtraktion anstelle von Listenverständnissen
-7 Bytes dank ValueInk um darauf hinzuweisen, dass ich dank Datastream nicht auf listdie Suites
-2 Bytes
angewiesen bin, um darauf hinzuweisen, dass das einfache Ausschreiben aller Werte byteeffektiver ist als das seltsame, was ich vorher dank ValueInk -2 Bytes hatte, um darauf hinzuweisen Diese Mengen können Generatoren benötigen, sodass ich sie nicht in ein Listenverständnis aufnehmen muss
-2 Bytes danke an Datastream für den Hinweis, dass ich noch mehr Golf spielen kann, wenn ich wieder auf Python 3 umsteige ... (+2 für parens after for print, -4 für raw_)
-5 Bytes danke an Lulhum und mir für den Hinweis herauszufinden, dass ein Wechsel zurück zu Python 2 (!!!) mir helfen kann, Bytes zu sparen (Bereich wieder verwenden, Backticks anstelle von str(und +4 aufgrund von raw_)

05AB1E , 39 Bytes

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

Probieren Sie es online!

Erläuterung

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

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

Probieren Sie es online!

Erläuterung

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)

Jelly , 39 Bytes

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

Probieren Sie es online!

Wie?

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 Bytes

Ich habe zum ersten Mal einen meiner Golfplätze gepostet, aber kein sehr guter Anwärter. Ich bin mir sicher, dass ich das noch weiter reduzieren kann.

Die Idee dahinter ist ein spärliches Array, in dem Kartenvorkommen gespeichert werden, wobei die Indizes aus den ASCII-Werten der verschiedenen Werte und Farben multipliziert werden (z. B. würde ein Pik-Ass (AS) im Bereich bei Index (65 *) gespeichert werden. 83 = 5395)). Auf diese Weise erhält jeder Kartentyp einen eindeutigen Index, der später im Array "map" auf Existenz überprüft werden kann.

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]

Probieren Sie es online!

Nimmt Eingaben $nals durch Leerzeichen oder Zeilenumbrüche getrennte Zeichenfolge an. Erstellt ein Array aus dem Bereich, 2..10mit dem es verknüpft ist JQKA(indiziert mit [0..3], um es zu einem charArray zu machen ). Dieses Array wird in eine Schleife eingespeist |%{}, die Helfer setzt und $idann über die Farben führt, um die Ergebnisse zusammen mit zu verketten $i$_. Am Ende dieser Schleife haben wir eine Reihe von Zeichenfolgen wie ("2C", "2S", "2H", ... "AH", "AD"). Dieses Array wird in ein Where-Object( |?{}) mit dem Filter als den Elementen eingespeist $_, -notmatchdie die Eingabe regulieren $n. Das Ergebnis dieser Filterung wird in gespeichert $a.

Dann verwenden wir ein Pseudoternär, ( , )[]um auszuwählen, ob wir ausgeben 'No missing cards'oder $a, basierend darauf, ob wir !!$azu einem Booleschen Wert $falseoder wechseln $true. Wenn $aleer ist (dh, jede Karte im Stapel befindet sich in der Eingabe), !!$aist 0dies der "No missing cards"Fall , und das ist ausgewählt. Umgekehrt zur $aAuswahl. In beiden Fällen verbleibt dies in der Pipeline, und die Ausgabe ist implizit.

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 / A als Liste mit Zeilenumbrüchen.

Erläuterung

• sort Liest durch Zeilenumbrüche getrennte Eingaben aus STDIN und sortiert sie
• Dies wird zu geleitet comm
• printf %s\\n {10,{2..9},A,J,K,Q}{C,D,H,S}ist eine Klammer-Erweiterung, um das gesamte Kartenspiel zu generieren. Das printfdruckt jede Karte in einer eigenen Zeile. Die Reihenfolge wird so angegeben, dass die Ausgabe dieselbe ist, als wäre sie weitergeleitet wordensort
• commvergleicht das vollständige Deck mit der sortierten Eingabe und gibt die Differenz aus. -3unterdrückt die Ausgabe von Spalte 3 (die üblichen)
• Die gesamte Ausgabe von commwird zu geleitet grep .. Wenn es keine Ausgabe von gab comm(dh alle Karten waren in der Eingabe), gibt die ||"oder" -Klausel die erforderliche Nachricht aus. Ansonsten grep .stimmt das mit allen Zeilen überein, die von ausgegeben werden comm.

Probieren Sie es online aus .

Python 2 , 104 , 93 , 130 , 114 Bytes

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'

Probieren Sie es online!

• -10 Bytes mit Hardcodierung der Liste anstelle von range!
• +37 Bytes - fehlender Ausdruck 'Keine fehlenden Karten', wenn alle Karten in der Eingabe vorhanden sind!
• -16 Bytes durch Modifizieren des Codes in ein Listenverständnis!

Ruby, 108 + 1 = 109 Bytes

Verwendet die -pFlagge.

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 Bytes

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 ( -rFlagge) = 170 158 Bytes

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

Probieren Sie es online!

Dies generiert alle möglichen Karten und entfernt dann jede Karte in der Eingabe von den generierten Karten.

C # , 282 Bytes

Golf gespielt

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

Ungolfed lesbar

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

Vollständiger Code

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

Releases

• v1.0 - 282 bytes- Anfangslösung.

Anmerkungen

Nichts hinzuzufügen

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'

Dies nutzt die Tatsache aus, dass undefinierte Einträge im Array von generiert werdenmap() zu leeren Zeichenfolgen gezwungen werden, wenn join()'d.

Demo

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

Netzhaut , 76 Bytes

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

Eingabe / Ausgabe ist eine Liste von durch Leerzeichen getrennten Karten. Die Ausgabe hat ein führendes Leerzeichen.

Probieren Sie es online!

Erläuterung

Der Großteil des Codes befasst sich mit der Erstellung der vollständigen Liste der Karten, die sich im Deck befinden sollten:

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

Zuerst stellen wir der Eingabe eine neue Zeile mit allen möglichen Kartenwerten voran, und dann erstellen wir für jedes Zeichen dieser Zeile (oder für jedes Zeichenpaar 10) die Liste aller möglichen Farben dieser Karte.

Dr` \S+

Dies ist eine Deduplizierungsphase, bei der die Zeichenfolge in Blöcke aufgeteilt wird, die aus einem Leerzeichen und einigen Nicht-Leerzeichen bestehen, und von jedem Block nur ein Vorkommen beibehalten wird. Der Modifikator bewirkt, rdass diese Funktion von rechts nach links ausgeführt wird, wobei das letzte Vorkommen jedes Blocks beibehalten wird.

G1`

Wir behalten nur die erste Zeile, die jetzt die fehlenden Karten enthält.

^$
No missing cards

Wenn das Ergebnis leer ist, ersetzen wir es durch "Keine fehlenden Karten".

Python 3, 106 Bytes

Kombination der beiden vorherigen Python-Antworten gemischt mit einigem String-Entpacken.

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

Julia , 116 Bytes

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

Probieren Sie es online!

Sehr ähnlich zu Kyle Gullions Python-Lösung. Setdiff statt - und das Lambda zum Testen der leeren Zeichenfolge machen es jedoch noch schlimmer.

Japt, 39 Bytes

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

Versuch es

Tcl , 270 228 Zeichen

(Mit etwas Hilfe von Wît Wisarhd gekürzt)

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

Probieren Sie es online!

Erläuterung:

Diese Implementierung erstellt ein Wörterbuch, das aus einem Booleschen Flag für jede der Karten besteht, die durch das kartesische Produkt von HDSC und 2-durch-A dargestellt werden. Es liest die Zeile von stdin, die, wenn sie als die Spezifikation angegeben wird, tatsächlich eine wohlgeformte Tcl-Liste ist. Beim Lesen jeder Karte wird ein boolescher Wert true in das Wörterbuch für diese Karte eingegeben.

Am Ende durchläuft ein Parser das Wörterbuch und fügt einer Liste fehlender Karten eine Karte hinzu, die im Wörterbuch nicht wahr ist. Wenn die Länge der Liste der fehlenden Karten Null ist, geben Sie "Keine fehlenden Karten" aus, andernfalls geben Sie die Liste der fehlenden Karten aus.

PHP , 138 Bytes

Lief mit -nund-d error_reporting=0

Ich verwende wieder Code von einer alten Übermittlung, die ich gemacht habe und die darum gebeten hat, ein Kartenspiel zu erstellen

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

Probieren Sie es online!

Erläuterung

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

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

Probieren Sie es online!

Perl 6 , 73 Bytes

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

Probieren Sie es online!

Eine ziemlich einfache Mengensubtraktion zwischen dem Kartenspiel und der Eingabe.

Python 3 , 102 Bytes

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

Probieren Sie es online!