डीलर को डेक के पुनर्निर्माण में मदद करें

19

डीलर मैला और ट्रैक खो गया है कि उसके डेक में क्या कार्ड हैं और क्या कार्ड गायब हैं, क्या आप उसकी मदद कर सकते हैं?

एक पूर्ण डेक में 52 प्लेइंग कार्ड होते हैं, अर्थात्:

डेक में प्रत्येक रंग (दिल, हीरे, हुकुम, क्लब) शामिल हैं:

  • संख्या [2 - 10]
  • गाड़ी उठाने का उपकरण
  • एक रानी
  • एक राजा
  • एक ऐस

कार्य

आपका कार्यक्रम STDIN से डेक की सामग्री को तब तक पढ़ेगा जब तक कि एक नई पंक्ति नहीं पढ़ी जाती। आप मान सकते हैं कि इनपुट "एनएक्स एनएक्स एनएक्स एनएक्स" आदि के रूप में होगा जहां आदि।

  • n - [2 - 10] या 'J', 'Q', 'K' या 'A' के बीच की कोई संख्या । (आप केवल गैर-संख्यात्मक वर्णों के लिए ऊपरी मामला मान सकते हैं)
  • X - निम्न में से कोई भी: 'H', 'D', 'S', 'C' (आप केवल ऊपरी स्थिति मान सकते हैं)

कहाँ पे:

  • 'जे' = जैक
  • 'क्यू' = रानी
  • 'के' = राजा
  • 'ए' = ऐस

तथा

  • 'ह' = दिल
  • 'डी' = हीरे
  • 'S' = हुकुम
  • 'सी' = क्लब

आप मान सकते हैं कि इनपुट में कोई डुप्लिकेट नहीं होगा।

आपके प्रोग्राम को तब डेक में गुम कार्डों को इनपुट ("nX nX nX") के समान ही प्रिंट करना होगा या सभी 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 
— सोम्ब्रेरो चिकन
स्रोत
3
क्या हम Tइसके बजाय उपयोग कर सकते हैं 10?
— अरनुलद
@Arnauld मुझे डर है कि यह सब जानकारी डीलर ने मुझे दी है इसलिए आपको '10' के साथ रहना होगा या वह मूडी हो जाएगा।
— सोमब्रेरो चिकन
@GillBates , हालांकि Jप्रतिनिधित्व नहीं करता है 10?
— ओकेक्स
@ ऑक्स 2 3 4 5 6 7 8 9 10 J Q K A। Jका प्रतिनिधित्व करता है 11।
— हाइपरन्यूट्रिनो
@ ऑक्स Jवर्णमाला का 10 वां अक्षर है, लेकिन यह ऐसा नहीं है। :)
— mbomb007

जवाबों:

8

विंडोज बैच (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%

सूट और रैंकों पर लूप्स एक पूर्ण डेक का निर्माण करते हैं, फिर इनपुट कार्ड को हटाते हैं। 1 बाइट सहेजें यदि Tइसके बजाय अनुमति दी गई है 10। यदि कमांड-लाइन तर्क स्वीकार्य इनपुट हैं, तो 11 बाइट्स सहेजें। संपादित करें: @ उपयोगकर्ता 202729 पर 1 बाइट का धन्यवाद सहेजा गया।

— नील
स्रोत
मैं 200 बाइट्स गिनता हूं।
— हाइपरनेत्रिनो
@HyperNeutrino जैसा कि मैं विंडोज पर हूं, मैं फाइल को बचाने के लिए नोटपैड का उपयोग करता हूं, जिसका अर्थ है कि नईलाइनों में एक के बजाय 2 बाइट खर्च होती हैं। मैं बाइट्स को बचाने के लिए एक अलग संपादक का उपयोग करने के लिए बहुत आलसी हूं।
— नील
ओह लोल ओके। मुझे Sublime Text का उपयोग करके 200 बाइट मिलते हैं।
— हाइपरनेत्रिनो
@ विंडोज पर आप सीआर एलएफ के बजाय एलएफ का उपयोग कर सकते हैं, 5 बाइट्स बचाता है (ऊपर हाइपरनेट्रिनो टिप्पणी) और यह अभी भी काम करता है।
— user202729
इसके अलावा, आप पास कर सकते हैं /vअध्यक्ष एवं प्रबंध निदेशक के लिए (+3 बाइट?) करने के लिए EnableDelayedExpansion, को खत्म callपाश के लिए में। / लगता है कि आपके पास (%c%)और के बीच एक अतिरिक्त जगह है do?
— user202729
8

पायथन, 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 कि अजगर 2 के साथ किया जा सकता है (-5 बाइट्स और के लिए 4 बाइट्स बाइट धन्यवाद raw_में raw_input)
-7 सेट और सूची comprehensions के बजाय सेट घटाव का उपयोग कर का उपयोग करने जा द्वारा बाइट्स
-7 बाइट्स ValueInk करने के लिए धन्यवाद इंगित करने के लिए कि मुझे listसूट आवश्यकता नहीं है ,
डेटास्रीम के लिए -2 बाइट्स के लिए -2 बाइट्स की इंगित करने के लिए कि सभी मानों को लिखना अजीब बात की तुलना में अधिक बाइट-प्रभावी है, जो पहले
-2 बाइट्स के लिए धन्यवाद था। यह सेट जेनरेटर ले सकता है, इसलिए मुझे इसे एक सूची समझने की आवश्यकता नहीं है
-2 बाइट्स डेटास्ट्रीम के लिए धन्यवाद इंगित करने के लिए कि मैं इसे और भी नीचे गिरा सकता हूं अगर मैं फिर से पायथन 3 पर जाऊं ... (+2 प्रिंट के लिए पार्न्स के लिए, -4 के लिए raw_)
-5 बाइट्स लल्हुम और खुद को इंगित करने के लिए धन्यवाद पायथन 2 (!!!) पर वापस जाने से मुझे बाइट्स बचाने में मदद मिल सकती है (रेंज को फिर से उपयोग करने के बजाय str(, और इसके बजाय +4 का उपयोग करके raw_)

— HyperNeutrino
स्रोत
1
आपके पास एक अतिरिक्त स्थान है जिसे आप निकाल सकते हैं, और यदि आप पाइथन 2 `d`का उपयोग करते हैं, str(d)तो आप इसके बजाय का उपयोग कर सकते हैं , इसके लिए परन्स को हटाने के अलावा print।
— mbomb007
@ mbomb007 धन्यवाद!
— हाइपरनेत्रिनो
for y in 'HDSC'वहाँ सभी पात्रों को पाने के लिए भी काम करता है। (आपको अभी भी list('JQKA')दूसरे भाग की आवश्यकता है ।)
— मूल्य इंक
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')हेरफेर के बजाय कुछ बाइट्स बचा सकता है ।
— डेटास्ट्रीम
सहमत, ऐसा लगता है कि यह 2 बाइट्स को इस तथ्य के कारण बचाएगा कि 1उन्हें जोड़ने की आवश्यकता नहीं है। इसके अलावा, आप अपनी पहली सूची की समझ के लिए बाहरी कोष्ठक को हटा सकते हैं क्योंकि 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
— Emigna
स्रोत
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)
— बिजनेस कैट
स्रोत
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
— जोनाथन एलन
स्रोत
5

सी #, 343 बाइट्स

पहली बार मेरे एक गोल्फ पोस्टिंग, हालांकि एक बहुत अच्छा दावेदार नहीं। मुझे यकीन है कि मैं इसे और कम कर सकता हूं।

इसके पीछे विचार यह है कि कार्ड का एक विरल सरणी संचय होता है, जिसमें विभिन्न मूल्यों के ASCII मूल्यों और एक-दूसरे के खिलाफ गुणा किए गए अनुक्रमणिकाओं (जैसे कि हुकुम (एएस) के सूचकांक द्वारा गणना की जाती है) सूचकांक (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");}
— पैट्रिक बेल
स्रोत
4

पॉवरशेल , 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साथ concatenated JQKA(साथ अनुक्रमित [0..3]यह एक बनाने के लिए charसरणी)। उस सरणी को एक लूप में खिलाया जाता है |%{}जो सहायक सेट करता है और $iफिर परिणामों को एक साथ करने के लिए सूट के ऊपर लूप करता है $i$_। इस लूप के अंत में, हमारे पास स्ट्रिंग्स की एक सरणी होती है जैसे ("2C", "2S", "2H", ... "AH", "AD")। यही कारण है कि सरणी एक में खिलाया जाता है Where-Object( |?{}उन तत्वों के रूप में फिल्टर के साथ) $_कि regex -notmatchइनपुट $n। उस फ़िल्टरिंग के परिणाम में संग्रहीत किया जाता है $a।

फिर, हम बूलियन की ओर मुड़ते हैं या नहीं , ( , )[]यह चुनने के लिए कि हम आउटपुट का चयन करते हैं या नहीं । यदि रिक्त है (मतलब डेक में प्रत्येक कार्ड इनपुट में है), तो है , इसलिए चुना गया है। चुने जाने के लिए इसके विपरीत । या तो मामले में, कि पाइपलाइन पर छोड़ दिया गया है, और आउटपुट निहित है।'No missing cards'$a!!$a$false$true$a!!$a0"No missing cards"$a

— AdmBorkBork
स्रोत
4

बैश + कोरुटिल्स, 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।

इसे ऑनलाइन आज़माएं ।

— डिजिटल आघात
स्रोत
4

पायथन 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 बाइट्स!
— कीर्तन प्रभाकरं
स्रोत
1
"कोई लापता कार्ड नहीं" प्रिंट नहीं करता है
— L3viathan
1
@ L3viathan ने इशारा किया कि इसके लिए धन्यवाद। मैंने अपना उत्तर संपादित कर लिया है!
— कीर्तन प्रभाकरन
list('23456789JQKA')+['10']चालाक है। मैं अपने दिमाग 10को दूसरे अजगर के उत्तर में एकल वर्णों की सूची से अलग करने के लिए बेहतर तरीके से मिटा रहा था , लेकिन यह खूबसूरती से काम करता है।
— डेटास्ट्रीम
2

रूबी, 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*' '
— मूल्य स्याही
स्रोत
2

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

इसे ऑनलाइन आज़माएं!

यह सभी संभव कार्डों को उत्पन्न करता है और फिर उत्पन्न कार्डों में से प्रत्येक कार्ड को हटा देता है।

— क्रिक्टी लिथोस
स्रोत
"कोई लापता कार्ड नहीं" प्रिंट नहीं करता है
— L3viathan
@ L3viathan फिक्स्ड
— कृति लिथोस
2

सी # , 282 बाइट्स

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

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

पढ़ने योग्य अनगढ़

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- प्रारंभिक समाधान।

टिप्पणियाँ

कुछ भी जोड़ने के लिए नहीं है

— auhmaan
स्रोत
1
यह आपके उत्तर के लिए एक बहुत अच्छा प्रारूप है, +1।
— R
2

जावास्क्रिप्ट (ईएस 6), 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
स्रोत
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

यदि परिणाम खाली है, तो हम इसे "कोई लापता कार्ड नहीं" से बदल देते हैं

— सिंह
स्रोत
1

पायथन 3, 106 बाइट्स

दो पिछले अजगर जवाबों का संयोजन कुछ स्ट्रिंग अनपैकिंग शेंनिगन्स के साथ मिलाया गया।

print(' '.join({x+y for x in[*'23456789JQKA','10']for y in'HDSC'}-{*input().split()})or'No missing cards')
— काइल गुलिऑन
स्रोत
1

जूलिया , 116 बाइट्स

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

इसे ऑनलाइन आज़माएं!

काइल गुलिअन अजगर समाधान के समान। के बजाय Setdiff - और खाली स्ट्रिंग के लिए परीक्षण करने के लिए लैम्ब्डा हालांकि यह बदतर बना।

— Lukes
स्रोत
1

Tcl , 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

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

यह कार्यान्वयन एचडीएससी के कार्टेशियन उत्पाद और 2-थ्रू-ए द्वारा प्रतिनिधित्व किए गए प्रत्येक कार्ड के लिए एक बूलियन ध्वज से युक्त एक शब्दकोश बनाता है। यह स्टड से लाइन को पढ़ता है, जिसे अगर कल्पना के रूप में दिया जाता है, तो वास्तव में एक अच्छी तरह से बनाई गई Tcl सूची है। जैसा कि प्रत्येक कार्ड पढ़ा जाता है, उस कार्ड के लिए शब्दकोश में एक बूलियन ट्रू इनपुट है।

अंत में एक पार्सर डिक्शनरी के माध्यम से लूप करता है, और किसी भी कार्ड को जोड़ता है जो डिक्शनरी में एक सच नहीं है जो लापता कार्ड की सूची में है। यदि गुम कार्ड की सूची की लंबाई शून्य है, तो "नो मिसिंग कार्ड" आउटपुट, अन्यथा लापता कार्ड की सूची को आउटपुट करें।

— सीन वुड्स
स्रोत
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])));
— फ्रांसिस्को हैन
स्रोत
आप इसे कुछ ट्विक्स के साथ 120 से नीचे ला सकते हैं। 1) पहली पंक्ति को a के साथ समाप्त करें?> 'Echo' को प्रतिस्थापित करें <? = 2) के साथ नियमित कमांड लाइन पर कार्ड डालकर रिक्त स्थान के साथ $ argv को एक एलीमेंट के रूप में एक तत्व के रूप में पॉप्युलेट करेंगे, जिससे आप विस्फोट को हटा सकते हैं () ) पूरी तरह से। इसे आज़माएं
— 640KB
मेरे पास ऐसा कोई सुराग नहीं था जो $argvइस तरह काम कर सके, धन्यवाद @gwaugh
— फ्रांसिस्को हैन
ओह btw @gwaugh ने सवाल दागा कि तर्क एक स्ट्रिंग है जो रिक्त स्थान द्वारा अलग किया गया है, एक-एक करके तर्क निर्धारित कर सकते हैं।
— फ्रांसिस्को हैन
यदि आप इसे कमांड लाइन पर चलाते हैं जैसे: 'php deck.php 2S 5H JC' तो यह उसी तरह का उपयोग है जैसे कि आप इसे अंतरिक्ष सीमांकित स्ट्रिंग के रूप में सोचते थे। आप बस PHP पार्स इसे आप के लिए बाहर दे रहे हैं। यह केवल TIO का UI है जो आपको अलग से डालता है।
— 640KB
ओह मैं समझा। संपादित करेंगे, -बाइट्स के लिए धन्यवाद: D
— फ्रांसिस्को हैन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.