딜러가 느슨하고 자신의 덱에 포함 된 카드와 누락 된 카드를 추적하지 못했습니다. 도와 드릴까요?

완전한 데크는 52 장의 카드로 구성됩니다.

데크의 각 색상 (하트, 다이아몬드, 스페이드, 클럽)에는 다음이 포함됩니다.

• 숫자 [2-10]
• 잭
• 여왕
• 왕
• 에이스

직무

프로그램은 줄 바꾸기를 읽을 때까지 STDIN에서 데크 내용을 읽습니다. 입력이 "nX nX nX nX"등의 형식이라고 가정 할 수 있습니다.

• n-[2-10] 또는 'J', 'Q', 'K'또는 'A' 사이의 숫자 (숫자가 아닌 문자에 대해서만 대문자로 가정 할 수 있음)
• X-다음 중 하나 : 'H', 'D', 'S', 'C'(대문자 만 사용할 수 있음)

어디:

• 'J'= 잭
• 'Q'= 여왕
• 'K'= 왕
• 'A'= 에이스

과

• 'H'= 하트
• 'D'= ​​다이아몬드
• 'S'= 스페이드
• 'C'= 클럽

입력에 중복이 없다고 가정 할 수 있습니다.

그런 다음 프로그램은 입력 ( "nX nX nX")과 같은 방식으로 데크에서 누락 된 카드를 STDOUT으로 인쇄하거나 52 개의 카드가 모두 제공된 경우 '누락 된 카드 없음'을 인쇄해야합니다. 카드 출력 순서에는 제한이 없습니다.

입력 예 :

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

산출:

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

행복한 골프!

Windows 배치 (CMD), 205204 바이트

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

슈트를 반복하고 완전한 데크를 구축 한 다음 입력 카드를 삭제합니다. T대신에 1 바이트를 저장하십시오 10. 명령 행 인수가 허용 가능한 경우 11 바이트를 저장하십시오. 편집 : @ user202729 덕분에 1 바이트가 절약되었습니다.

파이썬 147 146 145 138 131 129 127 125 120 바이트

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

가능한 모든 카드를 세트로 가져 와서 입력 카드를 뺍니다.

내 코드에서 여분의 공간을 가리키는 mbomb007 덕분에 -1 바이트.
파이썬 2로 수행 할 수있는 일부 골프를 지적 해준 mbomb007 덕분에 -1 바이트 (-5 바이트 및 raw_in에서 +4 바이트 raw_input)
-7 바이트는 값을 사용하여 목록 이해 대신 세트 및 세트 빼기를 사용하여 -7 바이트로 전환하여
-7 바이트 Datastream 덕분에 list스위트
-2 바이트 가 필요하지 않다는 것을 지적했기 때문에 모든 값을 쓰는 것이
ValueInk 덕분에 이전 -2 바이트 의 이상한 것보다 바이트 효과가 뛰어납니다. 그 세트는 생성기를 사용할 수 있으므로 목록 이해에 넣을 필요가 없습니다.
파이썬 3으로 다시 전환하면 더 다운 할 수 있다고 Datastream 덕분에 -2 바이트 덕분에 ... (인쇄 후 parens의 경우 +2, 인쇄의 경우 -4 raw_)
-Lulhum 덕분에 -5 바이트 파이썬 2 (!!!)로 다시 전환하면 바이트를 절약 할 수 있습니다 (범위를 다시 사용하고 대신 백틱을 사용 str(하고으로 인해 +4 raw_)

05AB1E , 39 바이트

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

온라인으로 사용해보십시오!

설명

ð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 바이트

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

온라인으로 사용해보십시오!

설명

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)

젤리 , 39 바이트

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

온라인으로 사용해보십시오!

어떻게?

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 바이트

내 골프 중 하나를 처음 게시하는 것은 좋지 않은 경쟁자가 아닙니다. 나는 이것을 더 줄일 수 있다고 확신한다.

그 뒤에 아이디어는 카드의 발생을 저장하는 희소 배열입니다. 다른 값과 ASCII의 ASCII 값으로 계산 된 인덱스는 서로 곱한 것입니다 (예 : 스페이드 에이스 (AS)는 인덱스 영역에 저장됩니다 (65 * 83 = 5395)). 이런 식으로, 각 유형의 카드는 "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 바이트

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

온라인으로 사용해보십시오!

입력을 취 $n하거나 공백으로 구분 또는 줄 바꿈으로 구분 된 문자열로. 2..10연결된 범위에서 배열을 구성합니다 JQKA(인덱스로 배열 [0..3]하여 char배열). 이 배열은 |%{}도우미 $i를 설정 하는 루프에 공급 된 다음 슈트를 반복하여와 결과를 연결합니다 $i$_. 이 루프의 끝에는 다음과 같은 문자열 배열이 있습니다 ("2C", "2S", "2H", ... "AH", "AD"). 해당 배열은 입력 을 정규화 하는 요소로 필터와 함께 Where-Object( |?{}) 로 공급됩니다 . 해당 필터링 결과는에 저장됩니다 .$_-notmatch$n$a

그런 다음, 우리는 의사 원을 사용하여 ( , )[]선택 여부를 우리 출력 'No missing cards'또는 $a여부에 따라, !!$a부울에 회전 $false또는 $true. $a비어있는 경우 (갑판의 모든 카드가 입력에 있음을 의미) !!$a가 0이므로 "No missing cards"가 선택됩니다. $a선택에 대한 반대의 경우도 마찬가지입니다 . 두 경우 모두 파이프 라인에 남아 있으며 출력은 암시 적입니다.

배쉬 + 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.

설명

• sort STDIN에서 줄 바꿈으로 구분 된 입력을 읽고 정렬합니다.
• 이것은 파이프 comm
• printf %s\\n {10,{2..9},A,J,K,Q}{C,D,H,S}카드의 전체 데크를 생성하는 중괄호 확장입니다. 은 printf한 줄에 각 카드를 인쇄합니다. 순서는 출력이 파이프에 연결된 것과 동일하도록 지정됩니다.sort
• comm전체 데크를 정렬 된 입력과 비교하고 차이를 출력합니다. -3열 3 (공통 항목)의 출력을 억제합니다.
• 의 전체 출력은 comm로 파이프됩니다 grep .. 출력이없는 경우 comm(즉, 모든 카드가 입력 된 경우) ||"or"절은 필요한 메시지를 출력합니다. 그렇지 않으면에서 grep .출력 된 모든 행과 일치합니다 comm.

온라인으로 사용해보십시오 .

파이썬 2 , 104,93,130,114 바이트

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'

온라인으로 사용해보십시오!

• 범위를 사용하는 대신 목록을 하드 코딩 한 -10 바이트!
• +37 바이트-모든 카드가 입력 된 경우 '누락 된 카드 없음'인쇄 누락!
• 코드를 목록 이해로 수정하여 -16 바이트!

루비, 108 + 1 = 109 바이트

-p플래그를 사용합니다 .

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 바이트

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

나오지 157 + 1 ( -r플래그) = 170 158 바이트

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

온라인으로 사용해보십시오!

이렇게하면 가능한 모든 카드가 생성되고 생성 된 카드에서 입력의 각 카드가 제거됩니다.

C # , 282 바이트

골프

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

언 골프

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

언 골프 가능

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

전체 코드

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

자료

• V1.0 - 282 bytes- 초기 솔루션입니다.

노트

추가 할 사항이 없습니다

자바 스크립트 (ES6) 117 114 111 바이트

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

이것은에 의해 생성 된 배열의 정의되지 않은 항목이 'd'일 map()때 빈 문자열로 강제 변환 된다는 사실을 이용 합니다 join().

데모

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

레티 나 , 76 바이트

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

입 / 출력은 공백으로 구분 된 카드 목록입니다. 출력에는 선행 공간이 있습니다.

온라인으로 사용해보십시오!

설명

대부분의 코드는 덱에 있어야 할 카드의 전체 목록을 작성합니다.

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

먼저, 가능한 모든 카드 값을 사용하여 입력에 줄 바꿈을 추가 한 다음이 줄의 각 문자 (또는 두 문자 10)에 대해 해당 카드의 가능한 모든 정장 목록을 작성합니다.

Dr` \S+

중복 제거 단계로, 문자열을 공백과 비 공백으로 구성된 청크로 분할하고 각 청크의 발생을 한 번만 유지합니다. 개질제 r이 유지 후, 오른쪽에서 왼쪽으로 동작하게 지난 각 청크의 발생.

G1`

우리는 지금 누락 된 카드가 들어 첫 번째 라인을 유지한다.

^$
No missing cards

결과가 비어 있으면 우리는 "누락 된 카드"로 교체

파이썬 3, 106 바이트

두 개의 이전 파이썬 답변의 조합은 일부 압축 풀기 shenanigans와 혼합되었습니다.

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

줄리아 116 바이트

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

온라인으로 사용해보십시오!

카일 Gullions 파이썬 솔루션 매우 유사. 빈 문자열을 테스트하는 람다는-대신 Setdiff를 사용하면 더 나빠집니다.

JAPT, 39 바이트

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

시도 해봐

티클 , 270 개 (228) 문자

(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

온라인으로 사용해보십시오!

설명:

이 구현은 HDSC 및 2-through-A의 데카르트 곱으로 표시되는 각 카드에 대한 부울 플래그로 구성된 사전을 빌드합니다. stdin에서 행을 읽습니다. 요구 된 스펙으로 제공된 경우 실제로 잘 구성된 Tcl 목록입니다. 각 카드를 읽을 때 해당 카드의 사전에 부울 true가 입력됩니다.

마지막으로 파서는 사전을 반복하고 사전에 참이없는 카드를 누락 된 카드 목록에 추가합니다. 누락 된 카드 목록 길이가 0이면 "누락 된 카드 없음"을 출력하고, 그렇지 않으면 누락 된 카드 목록을 출력하십시오.

PHP , 138 바이트

에 란 -n과-d error_reporting=0

카드 한 벌을 만들도록 요청한 이전 제출의 일부 코드를 재사용 합니다.

암호

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

온라인으로 사용해보십시오!

설명

<?$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 코어) , 197 바이트

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

온라인으로 사용해보십시오!

펄 6 , 73 바이트

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

온라인으로 사용해보십시오!

카드 데크와 입력 사이에 아주 간단한 세트 빼기.

파이썬 3 , 102 바이트

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

온라인으로 사용해보십시오!