O revendedor foi desleixado e perdeu a noção de quais cards seu baralho contém e quais estão faltando. Você pode ajudá-lo?

Um baralho completo consiste em 52 cartas de baralho, a saber:

Cada cor no baralho (copas, diamantes, espadas, paus) contém:

• Os números [2 - 10]
• A Jack
• Rainha
• Um rei
• Um ás

Tarefa

Seu programa lerá o conteúdo do baralho do STDIN até que uma nova linha seja lida. Você pode assumir que a entrada estará na forma de "nX nX nX nX" etc. onde:

• n - qualquer número entre [2 - 10] ou 'J', 'Q', 'K' ou 'A'. (Você pode assumir maiúsculas apenas para caracteres não numéricos)
• X - qualquer um dos seguintes: 'H', 'D', 'S', 'C' (Você pode assumir apenas maiúsculas)

Onde:

• «J» = Macacos
• 'Q' = rainha
• 'K' = rei
• 'A' = Ás

E

• 'H' = Corações
• «D» = diamantes
• 'S' = Espadas
• 'C' = Clubes

Você pode assumir que não haverá duplicatas na entrada.

Seu programa deve imprimir os cartões ausentes no baralho para STDOUT da mesma maneira que a entrada ("nX nX nX") ou imprimir 'Nenhum cartão ausente' se todos os 52 cartões forem fornecidos. Não há restrições na ordem de saída dos cartões.

Exemplo de entrada:

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

Resultado:

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 golfe!

Lote do Windows (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%

Faz um loop sobre os naipes e classifica a construção de um baralho completo e exclui os cartões de entrada. Salve 1 byte se Tfor permitido em vez de 10. Salve 11 bytes se os argumentos da linha de comando forem uma entrada aceitável. Editar: salvou 1 byte graças a @ user202729.

Python, 147 146 145 138 131 131 127 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')

Obtém todos os cartões possíveis como um conjunto e subtrai os cartões de entrada.

-1 byte graças a mbomb007 apontando um espaço extra no meu código.
-1 byte graças a mbomb007 por apontar alguns tipos de golfe que podem ser feitos com Python 2 (-5 bytes e +4 bytes por raw_in raw_input)
-7 bytes, passando a usar sets e subtração de conjuntos em vez de compreensão de lista
-7 bytes graças a ValueInk por apontar que não preciso listdos suítes
-2 bytes, graças ao Datastream, por apontar que apenas escrever todos os valores é mais eficaz em bytes do que a coisa estranha que eu tinha anteriormente
-2 bytes, graças ao ValueInk por apontar que conjuntos podem levar geradores, então eu não preciso colocá-lo em uma lista de compreensão
-2 bytes graças ao Datastream por apontar que eu posso melhorar ainda mais se eu mudar para o Python 3 novamente ... (+2 para parens depois para impressão, -4 pararaw_ )
-5 bytes graças a Lulhum e a mim mesmo por apontar que retornar ao Python 2 (!!!) pode me ajudar a salvar bytes (usando o range novamente, usando backticks em vez de str(+4 devido a raw_)

05AB1E , 39 bytes

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

Experimente online!

Explicação

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

Experimente online!

Explicação

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éia , 39 bytes

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

Experimente online!

Quão?

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

Publicando pela primeira vez um dos meus campos de golfe, não é um candidato muito bom. Tenho certeza de que posso reduzir isso ainda mais.

A ideia subjacente é uma matriz esparsa que armazena ocorrências de cartões, com índices calculados pelos valores ASCII dos diferentes valores e naipes multiplicados um contra o outro (por exemplo, um ás de espadas (AS) seria armazenado na área no índice (65 * 83 = 5395)). Dessa forma, cada tipo de cartão obtém um índice exclusivo que pode ser verificado posteriormente quanto à existência no 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 bytes

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

Experimente online!

Recebe a entrada $ncomo uma string delimitada por espaço ou delimitada por nova linha. Constrói uma matriz do intervalo 2..10concatenado com JQKA(indexado com [0..3]para torná-lo uma charmatriz). Essa matriz é inserida em um loop |%{}que ajusta o auxiliar e, em $iseguida, passa pelos trajes para concatenar os resultados $i$_. No final desse loop, temos uma série de strings como ("2C", "2S", "2H", ... "AH", "AD"). Essa matriz é alimentada em um Where-Object( |?{}) com o filtro como aqueles elementos $_que regexam -notmatcha entrada $n. O resultado dessa filtragem é armazenado em$a .

Então, usamos um pseudo-ternário ( , )[]para selecionar se produzimos 'No missing cards'ou $a, com base em se !!$atransforma em um booleano $falseou $true. Se $aestiver vazio (ou seja, todas as cartas do baralho estão na entrada), então !!$aé 0, então o "No missing cards"está selecionado. Vice-versa por $aser selecionado. Em ambos os casos, isso é deixado no pipeline e a saída está 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 uma lista delimitada por nova linha.

Explicação

• sort lê entradas delimitadas por nova linha do STDIN e as classifica
• Isso é canalizado para comm
• printf %s\\n {10,{2..9},A,J,K,Q}{C,D,H,S}é uma expansão de chaves para gerar o baralho completo de cartas. O printfimprime cada cartão em sua própria linha. A ordem é dada de forma que a saída seja a mesma que se tivesse sido canalizada parasort
• commcompara o baralho completo com a entrada classificada e gera a diferença. -3suprime a saída da coluna 3 (as comuns)
• Toda a saída de commé canalizada para grep .. Se não houver saída de comm(ou seja, todos os cartões estavam na entrada), a ||cláusula "ou" gera a mensagem necessária. Caso contrário, grep .corresponde a todas as linhas de saída comm.

Experimente online .

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'

Experimente online!

• -10 bytes codificando a lista em vez de usar range!
• +37 bytes - impressão perdida 'Sem cartões ausentes' se todos os cartões estiverem presentes na entrada!
• -16 bytes, modificando o código em uma lista de compreensão!

Ruby, 108 + 1 = 109 bytes

Usa a -pbandeira.

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

Experimente online!

Isso gera todos os cartões possíveis e, em seguida, remova cada cartão da entrada dos cartões gerados.

C # , 282 bytes

Golfe

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 legible

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

Lançamentos

• v1.0 - 282 bytes- Solução inicial.

Notas

Nada para adicionar

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'

Isso tira proveito do fato de que entradas indefinidas na matriz gerada por map()são forçadas a seqüências de caracteres vazias quando 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'))

Retina , 76 bytes

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

Entrada / saída é uma lista de cartões separados por espaço. A saída tem um espaço à esquerda.

Experimente online!

Explicação

A maior parte do código trata da criação da lista completa de cartas que devem estar no baralho:

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

Primeiro, acrescentamos uma nova linha à entrada, com todos os valores possíveis de cartões, depois, para cada caractere desta linha (ou o par de caracteres 10), construímos a lista de todos os naipes possíveis desse cartão.

Dr` \S+

Este é um estágio de desduplicação, ele divide a cadeia em pedaços que consistem em um espaço mais alguns não-espaços e mantém apenas uma ocorrência de cada pedaço. O modificador rfaz com que isso funcione da direita para a esquerda, mantendo a última ocorrência de cada pedaço.

G1`

Mantemos apenas a primeira linha, que agora contém os cartões ausentes.

^$
No missing cards

Se o resultado estiver vazio, substituí-lo por "Sem cartões ausentes"

Python 3, 106 bytes

Combinação das duas respostas python anteriores misturadas com algumas travessuras de desempacotamento de strings.

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

Experimente online!

Muito semelhante à solução python de Kyle Gullions. Setdiff em vez de - e o lambda para testar a cadeia vazia piora ainda mais.

Japonês, 39 bytes

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

Tente

Tcl , 270 228 caracteres

(Encurtado com alguma ajuda 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

Experimente online!

Explicação:

Essa implementação cria um dicionário que consiste em um sinalizador booleano para cada um dos cartões representados pelo produto cartesiano do HDSC e 2-a-A. Ele lê a linha de stdin, que se fornecida como a especificação solicitada, é na verdade uma lista de Tcl bem formada. À medida que cada cartão é lido, um valor booleano verdadeiro é inserido no dicionário desse cartão.

No final, um analisador percorre o dicionário e adiciona qualquer cartão que não seja verdadeiro no dicionário a uma lista de cartões ausentes. Se o comprimento da lista de cartões ausentes for zero, digite "Sem cartões ausentes"; caso contrário, imprima a lista de cartões ausentes.

PHP , 138 bytes

Funcionou com -ne-d error_reporting=0

Eu reutilizo algum código de uma submissão antiga que eu pedi para criar um baralho 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])));

Experimente online!

Explicação

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

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

Experimente online!

Perl 6 , 73 bytes

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

Experimente online!

Uma subtração bastante simples entre o baralho de cartas e a 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'

Experimente online!