Quali domino mancano?

34

Un set domino standard ha 28 pezzi unici:

inserisci qui la descrizione dell'immagine

Dato un elenco di 28 o meno domino univoci, genera l'elenco richiesto per creare un set completo.

Ingresso e uscita domino sono specificate da due cifre - il numero di punti su ciascun lato del domino, ad esempio 00, 34, 40, 66.

Le cifre possono essere fornite in qualsiasi ordine, quindi 34lo stesso domino di43

Ingressi di esempio

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>

Output di esempio corrispondenti

<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 
— Trauma digitale
fonte
2
Quali formati di input sono ammessi? Elenchi di stringhe? Elenchi di elenchi di numeri interi?
— Martin Ender,
1
@Martin Supponevo che avessimo un meta consenso da qualche parte sulla falsariga di "qualunque sia l'elenco, la matrice, il set, la raccolta, il vettore, la matrice, ... È appropriato per la tua lingua. I membri possono essere numeri o stringhe"
— Digital Trauma,
Ciò significa che possiamo richiedere ogni domino come una coppia di numeri interi, ad esempio 03 16= [0, 3], [1, 6]?
— FlipTack,
1
@FlipTack Sì, certo
— Digital Trauma

Risposte:

10

CJam, 11 byte

{:$7Ym*:$^}

Un blocco (funzione) senza nome con I / O come elenco di coppie di numeri interi.

Provalo qui.

Spiegazione

:$   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
fonte
Perché hai bisogno delle {}parentesi?
— Chromium,
6

Pyth, 12 10 byte

-.CU7 2SMQ

Input e output in formato [[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

Provalo qui.

Grazie a @ MartinBüttner per aver salvato 2 byte con un formato di input / output diverso!

— Maniglia
fonte
4

JavaScript (ES7 proposto), 80 76 byte

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

Accetta l'input come stringa separata da spazio e restituisce una matrice di stringhe. Le comprensioni dell'array fanno davvero il loro peso per questo.

— Neil
fonte
3

Ruby 74 byte

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

Accetta una matrice di stringhe, restituisce una matrice di stringhe.

Commentato nel programma di test

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

Produzione

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

Nell'ultimo esempio (input elenco vuoto) annotare l'ordine di generazione dell'elenco completo dei domino utilizzando l'aritmetica modulare. Vengono generati 7 doppi, quindi 7 domino con una differenza di 1 (o 6) pips tra i lati, quindi 7 domino con una differenza di 2 (o 5) pips, e infine 7 domino con una differenza di 3 (o 4) pips.

— Level River St
fonte
3

Julia 0.6 , 47 byte

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

Provalo online!

(Inizio intervallo corretto grazie a JayCe.)

48 byte

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

Provalo online!

— Sundar - Ripristina Monica
fonte
Penso che i domino zero sembrano mancare dal tuo terzo caso di test TIO. Per i = 0: 6 forse?
— JayCe
Questo è quello che ottengo provando a postare mezzo addormentato alle 3 del mattino! Sì, risolto ora (si spera), grazie.
— Sundar - Ripristina Monica il
2

Perl, 48 + 1 = 49 byte

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

Richiede la -nbandiera e il -M5.010| | gratuito -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

Nel complesso una risposta piuttosto noiosa, ma ecco una versione ungolfed:

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

R , 111 byte

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

Provalo online!

Non molto orgoglioso di questo, ma R non è molto "goloso" nel dividere / concatenare le stringhe ...

— digEmAll
fonte
2

05AB1E , 12 11 byte

6Ýã€{JI€{KÙ

-1 byte grazie a @Emigna .

Provalo online.

Spiegazione:

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
fonte
1

Mathematica, 49 byte

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

L'input è un elenco di numeri interi.

— CalculatorFeline
fonte
3
Errore nell'ultimo caso di test; ricorda, questi sono set non ordinati.
— LegionMammal978,
Concordo con @ LegionMammal978; questa risposta sembra non essere valida.
— Jonathan Frech,
1

Java 8, 105 byte

Un vuoto lambda che accetta un mutevole 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);}

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

Ringraziamenti

  • -1 byte grazie a Jonathan Frech
— Jakob
fonte
1
int i=0,a,b;while(i<49può essere for(int i=0,a,b;i<49;.
— Jonathan Frech,
1

Gelatina , 8 byte

Ṣ€7ḶŒċ¤ḟ

Provalo online!

L'argomento è un elenco di elenchi di numeri interi di lunghezza 2. Il piè di pagina trasforma l'input dal formato nei casi di test nel formato accettato da questa soluzione.

— Erik the Outgolfer
fonte
1

J, 26 , 24 byte

-2 byte grazie a FrownyFrog

(;(,.i.,])&.>i.7)-.\:~"1
  • (;(,.i.,])&.>i.7) calcola il set completo (questa parte potrebbe essere ulteriormente giocata a golf, credo. E per favore, se vedi come ...)
  • -. è "set meno"
  • /:~"1 ordina ciascuno degli ingressi

Provalo online!

Originale

Provalo online!

((#~<:/"1)>,{;~i.7)-./:~"1
— Giona
fonte
(;(,.i.,])&.>i.7)salva 2 (inverte l'ordine)
— FrownyFrog
@FrownyFrog grazie, aggiornato.
— Giona,
1

Python 2, 89 86 byte

Risparmio di pochi byte semplificando la generazione del set domino.

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}

Provalo online!

Prende un elenco di stringhe come ["00", "10", "02] come argomento per i domino. Restituisce oggetti set python, che sono elenchi distinti non ordinati.

Spiegazione

# 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
fonte
0

Haskell, 65 byte

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

Esempio di utilizzo:

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

Iterate ain un ciclo esterno su tutte le cifre da 0a 6e bin un ciclo interno su tutte le cifre da aa 6e mantenere quelli abdove né abné basi trovano nella stringa di input.

— Nome del modello
fonte
0

Scherzi a parte, 16 byte

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

Prende l'input come un elenco di stringhe, genera un elenco di stringhe

Provalo online!

Spiegazione:

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

In realtà , 13 byte (non concorrenti)

♂S7r;∙`εjS`M-

Questo è identico alla risposta Seriamente (ad eccezione dell'input implicito e ♂Sessendo un modo più breve per abbreviare ogni stringa di input).

Provalo online!

— Mego
fonte
1
Hai dei duplicati nell'output
— Digital Trauma,
@DigitalTrauma Ciò è dovuto a modifiche incompatibili all'indietro effettuate dal momento della pubblicazione.
— Mego
0

racchetta

(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
fonte
2
Bello vedere la gente giocare a golf nella racchetta! Questa è una domanda di code-golf, quindi probabilmente dovresti includere il tuo byte nella tua risposta. Puoi anche rimuovere un bel po 'di spazio da questa risposta.
— Wheat Wizard
Concordo con @WW in quanto questa risposta non sembra essere sufficientemente giocata per essere valida.
— Jonathan Frech,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.