एक मानक डोमिनोज़ सेट में 28 अद्वितीय टुकड़े होते हैं:

28 या उससे कम अद्वितीय डोमिनोज़ की सूची को देखते हुए, एक पूर्ण सेट बनाने के लिए आवश्यक सूची को आउटपुट करें।

इनपुट और आउटपुट डोमिनो दो अंकों द्वारा निर्दिष्ट कर रहे हैं - डोमिनो के प्रत्येक पक्ष पर पिप्स की संख्या, जैसे 00, 34, 40, 66।

अंक किसी भी क्रम में दिए जा सकते हैं, इसलिए 34जैसा डोमिनोज़ होता है43

उदाहरण इनपुट

00 01 02 03 04 05 06 11 12 13 14 15 16 22 23 24 25 26 33 34 35 36 44 45 46 55 56 66
00 10 11 20 21 22 30 31 32 33 40 41 42 43 44 50 51 52 53 54 55 60 61 62 63 64 65 66
00 01 02 03 04 05 06 11 12 13 14 15 16 22 23 24 25 26 34 35 36 44 45 46 55 56 66
00 02 03 04 05 06 11 13 14 15 16 22 24 25 26 33 35 36 44 46 55 66
<empty list>

उदाहरण आउटपुट के अनुरूप

<empty list>
<empty list>
33
01 12 23 34 45 56
00 01 02 03 04 05 06 11 12 13 14 15 16 22 23 24 25 26 33 34 35 36 44 45 46 55 56 66

code-golf dominoes

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

2

क्या इनपुट स्वरूपों की अनुमति है? तार की सूची? पूर्णांकों की सूचियों की सूची?

— मार्टिन एंडर

1

@ मैं यह मान रहा था कि हमारे पास "जो भी सूची, सरणी, सेट, संग्रह, वेक्टर, मैट्रिक्स, ..." की तर्ज पर एक मेटा सर्वसम्मति है ... आपकी भाषा के लिए उपयुक्त है। सदस्य संख्या या तार हो सकते हैं "

— डिजिटल ट्रामा

क्या इसका मतलब है कि हम प्रत्येक डोमिनोज़ को पूर्णांक की एक जोड़ी के रूप में अनुरोध कर सकते हैं, उदाहरण के लिए 03 16= [0, 3], [1, 6]?

— पलटें

1

@FlipTack हां, बेशक

— डिजिटल ट्रॉमा

10

सीजेएम, 11 बाइट्स

{:$7Ym*:$^}

पूर्णांक के जोड़े की सूची के रूप में I / O के साथ एक अनाम ब्लॉक (फ़ंक्शन)।

इसका परीक्षण यहां करें।

व्याख्या

:$   e# Sort each pair in the input.
7Ym* e# Get all pairs with elements in range [0 .. 6] using a Cartesian product.
:$   e# Sort each pair.
^    e# Symmetric set-difference. This will remove all pairs that are in the input
     e# and also remove duplicates, because it's a set operation.

— मार्टिन एंडर
स्रोत

आपको {}कोष्ठक की आवश्यकता क्यों है ?

— क्रोमियम

6

पायथ, 12 10 बाइट्स

-.CU7 2SMQ

प्रारूप में इनपुट और आउटपुट [[0, 0], [0, 1], ...]।

   U7       generate range [0, 1, ..., 6]
 .C   2     all combinations-with-replacement of 2, generates [[0,0],[0,1],...]
         Q  get the input
       SM   sort each domino (turns ex. [1,0] into [0,1])
-           remove the map-sort'd input from the full array

इसे यहाँ आज़माएँ।

एक अलग इनपुट / आउटपुट प्रारूप के साथ 2 बाइट्स बचाने के लिए @ MartinButner का धन्यवाद !

— Doorknob
स्रोत

4

जावास्क्रिप्ट (ईएस 7 प्रस्तावित), 80 76 बाइट्स

s=>[for(n of d="0123456")for(o of d.slice(n))if(s.search(n+o+'|'+o+n)<0)n+o]

एक अंतरिक्ष-पृथक स्ट्रिंग के रूप में इनपुट लेता है और स्ट्रिंग की एक सरणी देता है। सरणी की समझ वास्तव में इस एक के लिए अपना वजन खींचती है।

— नील
स्रोत

3

रूबी 74 बाइट्स

->b{a=(0..27).map{|i|"%d%d"%[i%7,(i+i/7)%7]}
b.map{|e|a-=[e,e.reverse]}
a}

तार की एक सरणी लेता है, तार की एक सरणी देता है।

परीक्षण कार्यक्रम में टिप्पणी की

f=->b{a=(0..27).map{|i|"%d%d"%[i%7,(i+i/7)%7]} #generate complete set of dominos (each domino once) and store in a
b.map{|e|a-=[e,e.reverse]}                     #remove provided dominos (check both forward and reverse representations)
a}                                             #return a

p f[%w{00 01 02 03 04 05 06 11 12 13 14 15 16 22 23 24 25 26 33 34 35 36 44 45 46 55 56 66}]
p f[%w{00 10 11 20 21 22 30 31 32 33 40 41 42 43 44 50 51 52 53 54 55 60 61 62 63 64 65 66}]
p f[%w{00 01 02 03 04 05 06 11 12 13 14 15 16 22 23 24 25 26 34 35 36 44 45 46 55 56 66}]
p f[%w{00 02 03 04 05 06 11 13 14 15 16 22 24 25 26 33 35 36 44 46 55 66}]
p f[[]]

उत्पादन

[]
[]
["33"]
["01", "12", "23", "34", "45", "56"]
["00", "11", "22", "33", "44", "55", "66", "01", "12", "23", "34", "45", "56", "60", "02", "13", "24", "35", "46", "50", "61", "03", "14", "25","36", "40", "51", "62"]

अंतिम उदाहरण में (इनपुट खाली सूची) मॉड्यूलर अंकगणित का उपयोग करके डोमिनोज की पूरी सूची की पीढ़ी के आदेश पर ध्यान दें। 7 डबल्स पहले उत्पन्न होते हैं, फिर प्रत्येक पक्ष के बीच 1 (या 6) पिप्स के अंतर के साथ 7 डोमिनोज़, फिर 2 (या 5) पिप्स के अंतर के साथ 7 डोमिनोइज़, और अंत में 3 (या 4) के अंतर के साथ 7 डोमिनोज़। पिप्स।

— स्तर नदी सेंट
स्रोत

3

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

A->setdiff([[i,j]for i=0:6 for j=i:6],sort.(A))

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

(सही सीमा शुरू करने के लिए धन्यवाद JayCe

48 बाइट्स

A->[(i,j)for i=0:6 for j=i:6 if[i,j]∉sort.(A)]

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

— sundar - मोनिका को बहाल करना
स्रोत

मुझे लगता है कि जीरो डोमिनोज आपके तीसरे टीआईओ टेस्ट केस से गायब लग रहे हैं। के लिए मैं = 0: 6 हो सकता है?

— JayCe

यही कारण है कि मैं 3:00 पर आधा सो जाने की कोशिश कर रहा हूं! हां, अभी तय है (उम्मीद है), धन्यवाद।

— सूंदर -

2

पर्ल, 48 + 1 = 49 बाइट्स

for$=(0..6){for$.($=..6){/$=$.|$.$=/||say$=.$.}}

-nध्वज की आवश्यकता है , और मुक्त -M5.010| -E:

$ perl -nE'for$=(0..6){for$.($=..6){/$=$.|$.$=/||say$=.$.}}' <<< '00 02 03 04 05 06 11 13 14 15 16 22 24 25 26 33 35 36 44 46 55 66'                      
01
12
23
34
45
56

समग्र रूप से सुंदर उबाऊ उत्तर, लेकिन यहाँ एक अनगढ़ संस्करण के साथ जाता है:

# '-n' auto reads first line into `$_`:
# $_ = <>;
foreach $a (0..6) {
  foreach $b ($a..6) {
    say $a . $b unless $_ =~ /$a$b|$b$a/;
  }
}

— andlrc
स्रोत

2

पायथन 2 , 91 बाइट्स

lambda A,S="0123456":sum([[i+j for j in S[int(i):]if(i+j in A)+(j+i in A)<1]for i in S],[])

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

— FlipTack
स्रोत

2

जावास्क्रिप्ट (स्पाइडरमोनी) , 69 बाइट्स

s=>[for(n of d="0123456")for(o of d)if(n<o<!s.match(n+o+'|'+o+n))n+o]

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

नील के से अनुकूलित है

— l4m2
स्रोत

2

आर , 111 बाइट्स

function(s,p=paste0,L=lapply)setdiff(p(sequence(1:7)-1,rep(0:6,t=1:7)),L(L(strsplit(s,''),sort),p,collapse=''))

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

वास्तव में इस पर गर्व नहीं है, लेकिन आर स्ट्रेटिंग / कॉन्टेनेटिंग स्ट्रिंग्स में बहुत "गोल्फ" नहीं है ...

— digEmAll
स्रोत

2

05AB1E , 12 11 बाइट्स

6Ýã€{JI€{KÙ

-1 बाइट @ @ मिग्ना के लिए धन्यवाद ।

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

स्पष्टीकरण:

6Ý         # [0,1,2,3,4,5,6]
  ã        # Duplicate and take the cartesian product (pair up each)
   €{      # Sort each pair
     J     # Join them together to strings
I€{        # Sort each pair-string of the input
K          # Remove all pairs from the input from the cartesian list
Ù          # Only leave unique values

— केविन क्रूज़सेन
स्रोत

1

गणितज्ञ, 49 बाइट्स

Complement[Join@@Table[{x,y},{x,0,6},{y,0,6}],#]&

इनपुट पूर्णांकों की सूची की सूची है।

— CalculatorFeline
स्रोत

3

अंतिम परीक्षण मामले में विफल रहता है; याद रखें, ये अनियंत्रित सेट हैं।

— लीजनमोनमल 978

मैं @ LegionMammal978 के साथ सहमत हूँ; यह उत्तर अमान्य प्रतीत होता है।

— जोनाथन फ्रेच

1

जावा 8, 105 बाइट्स

एक उत्परिवर्ती लम्बडा एक उत्परिवर्ती को स्वीकार करता है java.util.Set<String>।

s->{for(int i=0,a,b;i<49;)if(s.add(""+(a=i/7)+(b=i++%7))&(s.add(""+b+a)|a==b))System.out.print(" "+a+b);}

यह ऑनलाइन की कोशिश करो

Ungolfed

s -> {
    for (int i = 0, a, b; i < 49;)
        if (
            s.add("" + (a = i / 7) + (b = i++ % 7))
            & (
                s.add("" + b + a)
                | a == b
            )
        )
            System.out.print(" " + a + b);
}

स्वीकृतियाँ

-1 जोनाथन फ्रेच को धन्यवाद

— जेकब
स्रोत

1

int i=0,a,b;while(i<49हो सकता है for(int i=0,a,b;i<49;।

— जोनाथन फ्रीच

1

जेली , 8 बाइट्स

Ṣ€7ḶŒċ¤ḟ

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

तर्क पूर्णांक की लंबाई -2 सूची की एक सूची है। पाद लेख परीक्षण मामलों में प्रारूप से इनपुट को रूपांतरित करता है प्रारूप इस समाधान को स्वीकार करता है।

— आउटगोल्फर को एरिक करें
स्रोत

1

जे, 26 , 24 बाइट्स

-2 बाइट्स FrownyFrog की बदौलत

(;(,.i.,])&.>i.7)-.\:~"1

(;(,.i.,])&.>i.7) पूर्ण सेट की गणना करता है (यह हिस्सा आगे गोल्फ हो सकता है, मुझे विश्वास है। और कृपया देखें कि आप कैसे ...
-. "सेट माइनस" है
/:~"1 प्रत्येक इनपुट का आदेश देता है

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

मूल

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

((#~<:/"1)>,{;~i.7)-./:~"1

— जोनाह
स्रोत

(;(,.i.,])&.>i.7)2 बचाता है (आदेश को उलट देता है)

— FrownyFrog

@FrownyFrog धन्यवाद, अद्यतन।

— योना

1

पायथन 2, 89 86 बाइट्स

डोमिनोज़ सेट जनरेशन को सरल करके कुछ बाइट्स बचाए।

lambda z,s="0123456":{x+y for x in s for y in s[int(x):]}-{(a+b,b+a)[a>b]for a,b in z}

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

डोमिनोज़ के लिए एक तर्क के रूप में ["00", "10", "02] स्ट्रिंग्स की एक सूची लेता है। अजगर ने वस्तुओं को सेट किया, जो कि अलग-अलग सूचियाँ हैं।

व्याख्या

# anonymous function, s should always have its default value
lambda z,s="0123456":
                     # contents are a set
                     {                                  }
                          # iterate over characters in string
                          for x in s
                                     # for each x, iterate over x from index of current item forward
                                     for y in s[int(x):]
                     # add characters together for domino string
                     x+y
                                                         # contents are a set, return the difference between these two sets 
                                                         -{                          }
                                                             # iterate over items in input list, split strings into two characters
                                                                         for a,b in z
                                                             # sort strings in input list (so that i.e. "10" => "01")
                                                             # essentially, "ab" if a<b, otherwise "ba"
                                                             (a+b,b+a)[a>b]

— Triggernometry
स्रोत

0

हास्केल, 65 बाइट्स

f x=[[a,b]|a<-"0123456",b<-[a..'6'],notElem[a,b]x&&notElem[b,a]x]

उपयोग उदाहरण:

*Main> f ["00","02","03","04","05","06","11","13","14","15","16","22","24","25","26","33","35","36","44","46","55","66"]
["01","12","23","34","45","56"]

दोहराएं aसे सभी अंक से अधिक एक बाहरी पाश में 0करने के लिए 6और bसे सभी अंक से अधिक एक आंतरिक पाश में aकरने के लिए 6और उन रखना abजहां न तो abहै और न ही baइनपुट स्ट्रिंग में पाए जाते हैं।

— nimi
स्रोत

0

गंभीरता से, 16 बाइट्स

,`S`M7r;∙`εjS`M-

इनपुट को स्ट्रिंग्स की सूची के रूप में लेता है, स्ट्रिंग्स की सूची को आउटपुट करता है

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

स्पष्टीकरण:

,`S`M7r;∙`εjS`M-
,`S`M             map: sort each input string
     7r;∙         cartesian product of range(0,7) ([0,1,2,3,4,5,6]) with itself
         `εjS`M   map: join on empty string, sort (results in all valid dominoes with some duplicates)
               -  set difference (all values present in valid dominoes set not present in input, with duplicates removed)

दरअसल , 13 बाइट्स (गैर-प्रतिस्पर्धात्मक)

♂S7r;∙`εjS`M-

यह सीरियसली उत्तर के समान है (निहित इनपुट के अपवाद के साथ और ♂Sप्रत्येक इनपुट स्ट्रिंग को छोटा करने का तरीका है)।

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

— मेगो
स्रोत

1

आपके पास आउटपुट में डुप्लिकेट है

— डिजिटल ट्रॉमा

@DigitalTrauma यह पोस्टिंग के समय से किए गए पिछड़े-असंगत परिवर्तनों के कारण है।

— मेगो

0

रैकेट

(define (missing-dominoes input)
  (filter
   (lambda (n)
     (not (member n (map
                     (lambda (n)
                       (let ((x (quotient n 10)) (y (remainder n 10)))
                         (if (<= x y) n (+ (* y 10) x))))
                     input))))
   (for*/list ([i (in-range 7)] [j (in-range i 7)])
     (+ (* 10 i) j))))

— केविन
स्रोत

2

रैकेट में शामिल लोगों को देखकर अच्छा लगा! यह एक कोड-गोल्फ प्रश्न है, इसलिए आपको अपने उत्तर में अपने बायटेकाउंट को शामिल करना चाहिए। आप निश्चित रूप से इस जवाब से काफी व्हाट्सएप को हटा सकते हैं।

— गेहूं जादूगर

मैं @WW से सहमत हूं कि यह उत्तर मान्य होने के लिए पर्याप्त रूप से गोल्फ नहीं लगता है।

— जोनाथन फ्रेच

कौन से डोमिनोज़ गायब हैं?

उदाहरण इनपुट

उदाहरण आउटपुट के अनुरूप

सीजेएम, 11 बाइट्स

व्याख्या

पायथ, 12 10 बाइट्स

जावास्क्रिप्ट (ईएस 7 प्रस्तावित), 80 76 बाइट्स

रूबी 74 बाइट्स

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

48 बाइट्स

पर्ल, 48 + 1 = 49 बाइट्स

पायथन 2 , 91 बाइट्स

जावास्क्रिप्ट (स्पाइडरमोनी) , 69 बाइट्स

आर , 111 बाइट्स

05AB1E , 12 11 बाइट्स

गणितज्ञ, 49 बाइट्स

जावा 8, 105 बाइट्स

Ungolfed

स्वीकृतियाँ

जेली , 8 बाइट्स

जे, 26 , 24 बाइट्स

मूल

पायथन 2, 89 86 बाइट्स

हास्केल, 65 बाइट्स

गंभीरता से, 16 बाइट्स

दरअसल , 13 बाइट्स (गैर-प्रतिस्पर्धात्मक)

रैकेट