帮助经销商重建甲板

19

发牌人已经草率，不知道他/她的卡座中包含哪些卡以及缺少哪些卡，您能帮助他/她吗？

一个完整的牌组由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

打高尔夫球快乐！

code-golf 
— 草帽鸡
source
3
我们可以T代替使用10吗？
— Arnauld
@Arnauld恐怕这是经销商给我的所有信息，因此您必须坚持使用“ 10”，否则他会情绪低落。
— 草帽鸡肉鸡
@GillBates J不代表10吗？
— Okx
@Okx 2 3 4 5 6 7 8 9 10 J Q K A。J代表11。
— HyperNeutrino
@Okx J是字母表的第10个字母，但这不是这个意思。:)
— mbomb007 '04

Answers:

8

Windows Batch（CMD），205 204字节

@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个字节。

— 尼尔
source
我数了200个字节。
— HyperNeutrino
@HyperNeutrino在Windows上时，我使用记事本保存文件，这意味着换行要花2个字节而不是一个字节。我懒得使用其他编辑器来保存字节。
— 尼尔
呵呵，好吧。我使用Sublime Text获得了200个字节。
— HyperNeutrino
@Neil在Windows上，可以使用LF而不是CR LF，它可以保存5个字节（上面的HyperNeutrino注释），并且仍然有效。
— user202729 '17
另外，您可以将/vCMD（+3个字节？）传递给for EnableDelayedExpansion，call在for循环中消除。/似乎您(%c%)和之间有多余的空格do？
— user202729 '17
8

Python中，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')

获取所有可能的卡作为集合并减去输入卡。

-1个字节感谢mbomb007指出了我的代码中的额外空间。
-1字节感谢mbomb007指出可以使用Python 2（-5字节和raw_in的+4字节raw_input）可以打高尔夫球，可以
切换到使用集和集减法而不是列表理解而不是列表理解
-7字节-7字节，这归功于ValueInk指出我不需要list套件
-2个字节，这要感谢Datastream指出，写出所有值比起我之前拥有
-2字节的怪异事物要有效得多，这要归功于ValueInk指出该集合可以使用生成器，所以我不需要将其放在列表理解中
-2个字节感谢Datastream指出，如果我再次切换到Python 3，我可以将其击倒更多...（+2表示打印后的parens，-4表示raw_）
-5个字节感谢Lulhum和我自己指出通过切换回Python 2（!!!）可以帮助我节省字节（再次使用range，使用反引号代替str(，和+4归因于raw_）

— 超中微子
source
1
除了删除的括号外，您还有多余的空间可以删除，并且可以使用`d`代替str(d)Python 2 print。
— mbomb007 '04
@ mbomb007谢谢！
— HyperNeutrino
for y in 'HDSC'也可以让所有角色都在那里。（不过，您仍然需要list('JQKA')其他部分。）
— Value Ink
1
'1 2 3 4 5 6 7 8 9 10 J Q K A'.split()可能节省一些字节，而不是您正在进行的[d for d in range(2,11)]+list('JQKA')操作。
— Datastream
同意，由于1不需要添加，因此似乎可以节省2个字节。同样，您可以删除第一个列表理解的外括号，因为set构造函数可以很好地接收生成器对象。
— 价值墨水
7

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
— 艾米尼亚
source
5

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)
— 商务猫
source
5

果冻，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
— 乔纳森·艾伦
source
5

C＃，343字节

第一次发布我的一个高尔夫球，虽然不是一个很好的竞争者。我敢肯定我可以减少更多。

其背后的思想是一个稀疏的数组，用于存储纸牌的出现，其索引由不同值的ASCII值计算得出，并且适合度彼此相乘（例如，一张王牌（AS）将存储在索引为（65 * 83 = 5395））。这样，每种类型的卡都会获得一个唯一的索引，以后可以检查该索引是否在“地图”数组中。

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");}
— 帕特里克·贝尔
source
4

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。无论哪种情况，它都留在管道上，并且输出是隐式的。

— AdmBorkBork
source
4

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作为以换行符分隔的列表。

说明

  • 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（即所有卡都在输入中），则||“或”子句输出所需的消息。否则，grep .匹配从中输出的所有行comm。

在线尝试。

— 数字创伤
source
4

Python 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个字节！
— Keerthana Prabhakaran
source
1
不打印“没有丢失的卡”
— L3viathan '17
1
@ L3viathan感谢您指出这一点。我已经编辑了答案！
— Keerthana Prabhakaran'4
该list('23456789JQKA')+['10']是聪明的。我10竭尽全力寻找一个更好的方法来从另一个python答案中的单个字符列表中分离出来，但是效果很好。
— Datastream
2

Ruby，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*' '
— 价值墨水
source
2

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";
— 约格·赫尔瑟曼
source
2

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

发布

  • 1.0 - 282 bytes-初始溶液。

笔记

没有补充

— 奥马
source
1
这是您的答案+1的一种非常不错的格式。
— Rɪᴋᴇʀ
2

的JavaScript（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()。

演示版

显示代码段

— Arnauld
source
2

视网膜，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

如果结果为空，我们将其替换为“无失卡”

— 狮子座
source
1

Python 3，106个字节

前面两个python答案的组合，加上一些字符串解包的恶作剧。

print(' '.join({x+y for x in[*'23456789JQKA','10']for y in'HDSC'}-{*input().split()})or'No missing cards')
— 凯尔·古利翁
source
1

朱莉娅 116字节

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

在线尝试！

与Kyle Gullions python解决方案非常相似。但是，使用Setdiff而不是-以及用于测试空字符串的lambda会使情况变得更糟。

— 路加
source
1

TCL，270 228个字符

（在WîtWisarhd的帮助下缩短了）

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至A的笛卡尔积表示的卡建立一个由布尔标志组成的字典。它从stdin读取行，如果按要求提供它，它实际上是格式正确的Tcl列表。读取每张卡时，会将布尔true值输入该卡的字典中。

最后，解析器遍历字典，并将字典中没有真值的所有卡片添加到缺失卡片列表中。如果缺失卡列表长度为零，则输出“无缺失卡”，否则输出缺失卡列表。

— 肖恩·伍兹（Sean Woods）
source
1
— 小麦巫师
1

的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])));
— 弗朗西斯科·哈恩
source
您可以通过一些调整将其降低到120。1）以？>结尾的第一行以<？=代替'echo'2）在常规命令行中用空格输入卡将$ argv填充为数组，每个数组作为元素，因此可以删除explode（ ）完全。尝试
— 640KB
我没有线索$argv可以像那样工作，谢谢@gwaugh
— Francisco Hahn
呵呵btw @gwaugh这个问题说这个参数是一个用空格隔开的字符串，可以一个一个地设置参数。
— 弗朗西斯科·哈恩
如果您在命令行上运行它，例如：'php deck.php 2S 5H JC'，则就像您将其视为空格分隔的字符串一样。您只是让PHP为您解析它。只有TIO的UI才能将它们分开放置。
— 640KB
哦，我懂了。将进行编辑，感谢-bytes：D
— Francisco Hahn
1

C＃（.NET Core），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;};

在线尝试！

— 毁灭性
source
1

Perl 6，73个字节

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

在线尝试！

卡组和输入之间的一些非常简单的设置减法。

— 乔·金
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.