Welche Dominosteine ​​fehlen?

34

Ein Standard-Domino-Set besteht aus 28 Einzelstücken:

Bildbeschreibung hier eingeben

Geben Sie bei einer Liste von 28 oder weniger eindeutigen Dominosteinen die Liste aus, die für die Erstellung eines vollständigen Satzes erforderlich ist.

Eingangs- und Ausgangsdomino werden durch zwei Ziffern angegeben - die Anzahl der Zacken auf jeder Seite des Domino, zB 00, 34, 40, 66.

Die Ziffern können in beliebiger Reihenfolge angegeben werden, es handelt sich also 34um das gleiche Domino wie43

Beispieleingaben

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>

Entsprechende Beispielausgaben

<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
Digitales Trauma
quelle
2
Welche Eingabeformate sind erlaubt? Listen von Streichern? Listen von Listen von ganzen Zahlen?
Martin Ender
1
@Martin Ich habe angenommen, wir haben irgendwo einen Metakonsens in der Art von "Welche Liste, Array, Menge, Sammlung, Vektor, Matrix, ... auch immer für Ihre Sprache geeignet ist. Mitglieder können Zahlen oder Zeichenketten sein"
Digitales Trauma
Bedeutet das, dass wir jeden Domino als ein Paar von ganzen Zahlen anfordern können, zum Beispiel 03 16= [0, 3], [1, 6]?
FlipTack
1
@FlipTack Ja, natürlich
Digital Trauma

Antworten:

10

CJam, 11 Bytes

{:$7Ym*:$^}

Ein unbenannter Block (Funktion) mit E / A als Liste von Ganzzahlpaaren.

Teste es hier.

Erläuterung

:$   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.
Martin Ender
quelle
Warum brauchst du die {}Klammern?
Chrom
6

Pyth, 12 10 Bytes

-.CU7 2SMQ

Ein- und Ausgabe im Format [[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

Probieren Sie es hier aus.

Vielen Dank an @ MartinBüttner für das Speichern von 2 Bytes mit einem anderen Eingabe- / Ausgabeformat!

Türknauf
quelle
4

JavaScript (ES7 vorgeschlagen), 80 bis 76 Byte

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

Nimmt Eingaben als durch Leerzeichen getrennte Zeichenfolge und gibt ein Array von Zeichenfolgen zurück. Das Array-Verständnis spielt für dieses wirklich eine große Rolle.

Neil
quelle
3

Ruby 74 Bytes

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

Nimmt ein Array von Zeichenfolgen und gibt ein Array von Zeichenfolgen zurück.

Kommentiert im Testprogramm

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[[]]

Ausgabe

[]
[]
["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"]

Beachten Sie im letzten Beispiel (leere Liste eingeben) die Reihenfolge der Generierung der vollständigen Dominoliste mit modularer Arithmetik. Es werden zuerst 7 Doppel generiert, dann 7 Dominosteine ​​mit einem Unterschied von 1 (oder 6) Pips zwischen jeder Seite, dann 7 Dominosteine ​​mit einem Unterschied von 2 (oder 5) Pips und schließlich 7 Dominosteine ​​mit einem Unterschied von 3 (oder 4). pips.

Level River St
quelle
3

Julia 0,6 , 47 Bytes

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

Probieren Sie es online!

(Der Start der Reichweite wurde dank JayCe korrigiert.)


48 Bytes

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

Probieren Sie es online!

Sundar - Setzen Sie Monica wieder ein
quelle
Ich denke, die Null-Dominosteine ​​scheinen in Ihrem dritten TIO-Testfall zu fehlen. Für i = 0: 6 vielleicht?
JayCe
Das ist es, was ich bekomme, wenn ich versuche, um 3 Uhr morgens halb eingeschlafen zu sein! Ja, jetzt behoben (hoffentlich), danke.
Sundar - Wiedereinsetzung von Monica
2

Perl, 48 + 1 = 49 Bytes

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

Benötigt die -nFlagge und die freie -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

Ziemlich langweilige Antwort insgesamt, aber hier geht es mit einer ungolfed Version:

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

R , 111 Bytes

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

Probieren Sie es online!

Nicht wirklich stolz darauf, aber R ist nicht sehr "golfen" beim Teilen / Verketten von Saiten ...

digEmAll
quelle
2

05AB1E , 12 11 Bytes

6Ýã€{JI€{KÙ

-1 Byte dank @Emigna .

Probieren Sie es online aus.

Erläuterung:

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
Kevin Cruijssen
quelle
1

Mathematica, 49 Bytes

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

Die Eingabe ist eine Liste mit ganzen Zahlen.

CalculatorFeline
quelle
3
Schlägt im letzten Testfall fehl; Denken Sie daran, dies sind ungeordnete Mengen.
LegionMammal978
Ich würde @ LegionMammal978 zustimmen; Diese Antwort scheint ungültig zu sein.
Jonathan Frech
1

Java 8, 105 Bytes

Ein leeres Lambda, das einen veränderlichen annimmt 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);}

Probieren Sie es online

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

Danksagung

  • -1 Byte Danke an Jonathan Frech
Jakob
quelle
1
int i=0,a,b;while(i<49kann sein for(int i=0,a,b;i<49;.
Jonathan Frech
1

Gelee , 8 Bytes

Ṣ€7ḶŒċ¤ḟ

Probieren Sie es online!

Argument ist eine Liste von Länge-2-Listen von ganzen Zahlen. Die Fußzeile transformiert die Eingabe aus dem Format in den Testfällen in das von dieser Lösung akzeptierte Format.

Erik der Outgolfer
quelle
1

J, 26 , 24 Bytes

-2 Bytes dank FrownyFrog

(;(,.i.,])&.>i.7)-.\:~"1
  • (;(,.i.,])&.>i.7) berechnet den vollen Satz (dieser Teil könnte, glaube ich, weiter golfen werden. Und bitte tun Sie, wenn Sie sehen, wie ...)
  • -. ist "set minus"
  • /:~"1 bestellt jeden der Eingänge

Probieren Sie es online!

Original

Probieren Sie es online!

((#~<:/"1)>,{;~i.7)-./:~"1
Jona
quelle
(;(,.i.,])&.>i.7)speichert 2 (kehrt die Reihenfolge um)
FrownyFrog
@FrownyFrog danke, aktualisiert.
Jonah
1

Python 2, 89 86 Bytes

Ein paar Bytes gespart, indem die Generierung von Domino-Sets vereinfacht wurde.

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}

Probieren Sie es online!

Verwendet eine Liste von Zeichenfolgen wie ["00", "10", "02] als Argument für die Dominosteine. Gibt Python-Set-Objekte zurück, bei denen es sich um ungeordnete unterschiedliche Listen handelt.

Erläuterung

# 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]
Triggernometrie
quelle
0

Haskell, 65 Bytes

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

Anwendungsbeispiel:

*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"]

Iterieren Sie ain einer äußeren Schleife über alle Ziffern von 0bis 6und bin einer inneren Schleife über alle Ziffern von abis 6und behalten Sie diejenigen abbei, die weder in der Eingabezeichenfolge abnoch bain der Eingabezeichenfolge enthalten sind.

nimi
quelle
0

Im Ernst, 16 Bytes

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

Übernimmt die Eingabe als Liste von Zeichenfolgen und gibt eine Liste von Zeichenfolgen aus

Probieren Sie es online!

Erläuterung:

,`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)

Eigentlich 13 Bytes (nicht konkurrierend)

♂S7r;∙`εjS`M-

Dies ist identisch mit der Antwort "Ernsthaft" (mit Ausnahme der impliziten Eingabe und ♂Seiner kürzeren Methode zum Kurzschließen der einzelnen Eingabezeichenfolgen).

Probieren Sie es online!

Mego
quelle
1
Sie haben Duplikate in der Ausgabe
Digital Trauma
@DigitalTrauma Dies ist auf inkompatible Änderungen zurückzuführen, die seit dem Zeitpunkt der Veröffentlichung vorgenommen wurden.
Mego
0

Schläger

(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))))
Kevin
quelle
2
Schön zu sehen, wie Leute im Schläger Golf spielen! Da es sich um eine Code-Golf-Frage handelt, sollten Sie Ihren Bytecount in Ihre Antwort einbeziehen. Sie können auch definitiv einiges an Leerzeichen aus dieser Antwort entfernen.
Weizen-Assistent
Ich stimme mit @WW darin überein, dass diese Antwort nicht ausreichend Golf zu spielen scheint, um gültig zu sein.
Jonathan Frech