El crupier ha sido descuidado y ha perdido la noción de qué cartas contiene su mazo y qué cartas faltan, ¿puede ayudarlo?

Una baraja completa consta de 52 cartas, a saber:

Cada color en el mazo (corazones, diamantes, picas, tréboles) contiene:

• Los números [2 - 10]
• Un enchufe
• Una reina
• Un rey
• Un as

Tarea

Su programa leerá el contenido de la plataforma de STDIN hasta que se lea una nueva línea. Puede suponer que la entrada tendrá la forma de "nX nX nX nX", etc., donde:

• n - cualquier número entre [2 - 10] o 'J', 'Q', 'K' o 'A'. (Puede asumir mayúsculas solo para caracteres no numéricos)
• X: cualquiera de los siguientes: 'H', 'D', 'S', 'C' (puede asumir solo mayúsculas)

Dónde:

• 'J' = Tomas
• 'Q' = Reina
• 'K' = Rey
• 'A' = As

Y

• 'H' = Corazones
• 'D' = Diamantes
• 'S' = Picas
• 'C' = Clubes

Puede suponer que no habrá duplicados en la entrada.

Su programa debe imprimir las cartas que faltan en el mazo en STDOUT de la misma manera que la entrada ("nX nX nX") o imprimir 'No faltan cartas' si se suministran las 52 cartas. No hay restricciones en el orden de salida de las tarjetas.

Entrada de ejemplo:

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

Salida:

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

¡Feliz golf!

De Windows por lotes (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%

Recorre los trajes y clasifica la construcción de un mazo completo, luego elimina las tarjetas de entrada. Ahorre 1 byte si Testá permitido en lugar de 10. Ahorre 11 bytes si los argumentos de la línea de comandos son entradas aceptables. Editar: Guardado 1 byte gracias a @ user202729.

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

Obtiene todas las tarjetas posibles como un conjunto y resta las tarjetas de entrada.

-1 byte gracias a mbomb007 que señala un espacio extra en mi código.
-1 bytes gracias a mbomb007 para señalar algunas de golf que se pueden hacer con Python 2 (-5 bytes y +4 bytes para raw_en raw_input)
-7 bytes por el cambio a utilizando conjuntos y conjunto de la resta en lugar de listas por comprensión
-7 bytes gracias a ValueInk por señalar que no necesito listlas suites
-2 bytes gracias a Datastream por señalar que solo escribir todos los valores es más eficaz en bytes que lo extraño que tenía anteriormente
-2 bytes gracias a ValueInk por señalar que los conjuntos pueden tomar generadores, así que no necesito ponerlo en una lista de comprensión
-2 bytes gracias a Datastream por señalar que puedo jugar golf aún más si cambio a Python 3 nuevamente ... (+2 para parens después para imprimir, -4 para raw_)
-5 bytes gracias a Lulhum y a mí mismo por señalar que cambiar de nuevo a Python 2 (!!!) puede ayudarme a guardar bytes (usando el rango nuevamente, usando backticks en lugar de str(, y +4 debido a raw_)

05AB1E , 39 bytes

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

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

Explicación

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)

Jalea , 39 bytes

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

Pruébalo en línea!

¿Cómo?

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

La primera vez que publico uno de mis campos de golf, no es un muy buen contendiente. Estoy seguro de que puedo reducir esto más.

La idea detrás de esto es una matriz dispersa que almacena las ocurrencias de las tarjetas, con índices calculados por los valores ASCII de los diferentes valores y trajes multiplicados entre sí (por ejemplo, un as de espadas (AS) se almacenaría en el área en el índice (65 * 83 = 5395)). De esta manera, cada tipo de tarjeta obtiene un índice único que puede verificarse posteriormente para determinar si existe en la matriz "mapa".

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 bytes

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

Pruébalo en línea!

Toma la entrada $ncomo una cadena delimitada por espacios o delimitada por una nueva línea. Construye una matriz a partir del rango 2..10concatenado con JQKA(indexado [0..3]para convertirlo en una charmatriz). Esa matriz se alimenta en un bucle |%{}que establece ayudante y $iluego recorre los trajes para concatenar los resultados junto con $i$_. Al final de este ciclo, tenemos una serie de cadenas como ("2C", "2S", "2H", ... "AH", "AD"). Esa matriz se alimenta a Where-Object( |?{}) con el filtro como aquellos elementos $_que regexifican -notmatchla entrada $n. El resultado de ese filtrado se almacena en $a.

Luego, usamos un pseudoternario ( , )[]para seleccionar si emitimos 'No missing cards'o $a, en función de si se !!$aconvierte en booleano $falseo $true. Si $aestá vacío (lo que significa que cada carta en el mazo está en la entrada), entonces !!$aestá 0, entonces "No missing cards"se selecciona. Viceversa para $aser seleccionado. En cualquier caso, eso queda en la tubería, y la salida es implícita.

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 como una lista delimitada por nueva línea.

Explicación

• sort lee la entrada delimitada por nueva línea de STDIN y la ordena
• Esto se canaliza a comm
• printf %s\\n {10,{2..9},A,J,K,Q}{C,D,H,S}es una expansión de llaves para generar el mazo completo de cartas. El printfcopias de cada tarjeta en su propia línea. El orden se da de tal manera que la salida es la misma que si se hubiera canalizado asort
• commcompara la plataforma completa con la entrada ordenada y genera la diferencia. -3suprime la salida de la columna 3 (las comunes)
• Toda la salida de commse canaliza a grep .. Si no hubo salida de comm(es decir, todas las tarjetas estaban en la entrada), entonces la ||cláusula "o" emite el mensaje requerido. De lo contrario, grep .coincide con todas las líneas de salida comm.

Pruébalo en línea .

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'

Pruébalo en línea!

• -10 bytes con codificación de la lista en lugar de usar rango!
• +37 bytes - impresión perdida '¡No faltan tarjetas' si todas las tarjetas están presentes en la entrada!
• -16 bytes modificando el código en una lista de comprensión!

Ruby, 108 + 1 = 109 bytes

Usa la -pbandera.

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 ( -rflag) = 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.+//

Pruébalo en línea!

Esto genera todas las tarjetas posibles y luego elimina cada tarjeta en la entrada de las tarjetas generadas.

C # , 282 bytes

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

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

Legible sin golf

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

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

Lanzamientos

• v1.0 - 282 bytes- Solución inicial.

Notas

Nada que añadir

JavaScript (ES6), 117 114 111 bytes

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

Esto aprovecha el hecho de que las entradas indefinidas en la matriz generada por map()se convierten en cadenas vacías cuando join()'d.

Manifestación

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 bytes

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

Entrada / salida es una lista de tarjetas separadas por espacios. La salida tiene un espacio principal.

Pruébalo en línea!

Explicación

La mayor parte del código trata de construir la lista completa de cartas que deberían estar en el mazo:

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

Primero, anteponemos una nueva línea a la entrada, con todos los valores posibles de las tarjetas, luego para cada personaje de esta línea (o el par de caracteres 10) construimos la lista de todos los posibles palos de esa tarjeta.

Dr` \S+

Esta es una etapa de deduplicación, divide la cadena en fragmentos que consisten en un espacio más algunos no espacios y mantiene solo una aparición de cada fragmento. El modificador rhace que esto funcione de derecha a izquierda, manteniendo la última aparición de cada fragmento.

G1`

Mantenemos solo la primera línea, que ahora contiene las cartas que faltan.

^$
No missing cards

Si el resultado está vacío, lo reemplazamos con "No faltan cartas"

Python 3, 106 bytes

Combinación de las dos respuestas anteriores de Python mezcladas con algunas travesuras de desempaque de cadenas.

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

Pruébalo en línea!

Muy similar a la solución de pitón Kyle Gullions. Sin embargo, Setdiff en lugar de - y la lambda para probar la cadena vacía lo empeoran.

Japt, 39 bytes

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

Intentalo

Tcl , 270 228 caracteres

(Acortado con ayuda 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

Pruébalo en línea!

Explicación:

Esta implementación crea un diccionario que consiste en una bandera booleana para cada una de las tarjetas representadas por el producto cartesiano de HDSC y 2-a-A. Lee la línea de stdin, que si se proporciona como la especificación solicitada, en realidad es una lista Tcl bien formada. A medida que se lee cada tarjeta, se ingresa un verdadero booleano en el diccionario para esa tarjeta.

Al final, un analizador recorre el diccionario y agrega cualquier tarjeta que no tenía un verdadero en el diccionario a una lista de tarjetas faltantes. Si la longitud de la lista de tarjetas faltantes es cero, escriba "No hay tarjetas faltantes", de lo contrario, envíe la lista de tarjetas faltantes.

PHP , 138 bytes

Corrió con -ny-d error_reporting=0

Reutilizo un código de una submisión antigua que hice que pedía crear una baraja de cartas

Código

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

Pruébalo en línea!

Explicación

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

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

Pruébalo en línea!

Perl 6 , 73 bytes

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

Pruébalo en línea!

Algunas restas bastante simples entre el mazo de cartas y la entrada.

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'

Pruébalo en línea!