Quels dominos sont manquants?

34

Un ensemble domino standard comprend 28 pièces uniques:

entrez la description de l'image ici

Avec une liste de 28 dominos uniques ou moins, indiquez la liste requise pour créer un jeu complet.

Dominos d'entrée et de sortie sont spécifiés par deux chiffres - le nombre de pépins de chaque côté du domino, par exemple 00, 34, 40, 66.

Les chiffres peuvent être donnés dans n’importe quel ordre. 34Le même domino que43

Exemple d'entrées

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>

Exemples de sorties correspondants

<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 numérique
source
2
Quels formats d'entrée sont autorisés? Des listes de chaînes? Listes de listes d'entiers?
— Martin Ender
1
@Martin Je supposais que nous avions un méta-consensus quelque part dans les termes de "liste quelconque, tableau, ensemble, collection, vecteur, matrice, ... Convient à votre langue. Les membres peuvent être des nombres ou des chaînes"
— Digital Trauma
Est-ce que cela signifie que nous pouvons demander chaque domino sous la forme d'une paire d'entiers, par exemple 03 16= [0, 3], [1, 6]?
— FlipTack
1
@FlipTack Oui, bien sûr
— Digital Trauma, le

Réponses:

10

CJam, 11 octets

{:$7Ym*:$^}

Un bloc non nommé (fonction) avec I / O sous forme de liste de paires d'entiers.

Testez-le ici.

Explication

:$   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
source
Pourquoi avez-vous besoin des {}crochets?
— Chromium
6

Pyth, 12 à 10 octets

-.CU7 2SMQ

Entrée et sortie au 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

Essayez ici.

Merci à @ MartinBüttner pour la sauvegarde de 2 octets avec un format d’entrée / sortie différent!

— Poignée de porte
source
4

JavaScript (ES7 proposé), 80 76 octets

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

Prend l'entrée en tant que chaîne séparée par des espaces et renvoie un tableau de chaînes. Les compréhensions de tableaux tirent vraiment leur poids pour celui-ci.

— Neil
source
3

Ruby 74 octets

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

Prend un tableau de chaînes, retourne un tableau de chaînes.

Commenté dans le programme de 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[[]]

Sortie

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

Dans le dernier exemple (liste vide d'entrée), notez l'ordre de génération de la liste complète des dominos à l'aide de l'arithmétique modulaire. 7 doubles sont générés en premier, puis 7 dominos avec une différence de 1 (ou 6) pips entre chaque côté, puis 7 dominos avec une différence de 2 (ou 5) pips, et enfin 7 dominos avec une différence de 3 (ou 4) pépins.

— Level River St
source
3

Julia 0.6 , 47 bytes

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

Essayez-le en ligne!

(Début de la plage corrigée grâce à JayCe.)

48 octets

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

Essayez-le en ligne!

— sundar - Rétablir Monica
source
Je pense que les dominos zéro semblent être absents de votre troisième cas de test TIO. Pour i = 0: 6 peut-être?
— JayCe
C'est ce que je reçois en essayant de rester à moitié endormi à 3 heures du matin! Oui, corrigé maintenant (espérons-le), merci.
— dimanche
2

Perl, 48 + 1 = 49 octets

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

Nécessite le -ndrapeau et le gratuit -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

Réponse plutôt ennuyeuse dans l'ensemble, mais voici une version non-golfée:

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

R , 111 octets

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

Essayez-le en ligne!

Pas vraiment fier de ça, mais R n’est pas très "golfy" dans la division / concaténation de chaînes ...

— digEmAll
source
2

05AB1E , 12 à 11 octets

6Ýã€{JI€{KÙ

-1 octet grâce à @Emigna .

Essayez-le en ligne.

Explication:

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

Mathematica, 49 octets

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

L'entrée est la liste de la liste des entiers.

— CalculatriceFeline
source
3
Échoue sur le dernier cas de test; rappelez-vous, ce sont des ensembles non ordonnés.
— LegionMammal978
Je serais d'accord avec @ LegionMammal978; cette réponse semble être invalide.
— Jonathan Frech
1

Java 8, 105 octets

Un vide lambda acceptant un mutable 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);}

Essayez-le en ligne

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

Remerciements

  • -1 octet grâce à Jonathan Frech
— Jakob
source
1
int i=0,a,b;while(i<49peut être for(int i=0,a,b;i<49;.
— Jonathan Frech
1

Gelée , 8 octets

Ṣ€7ḶŒċ¤ḟ

Essayez-le en ligne!

L'argument est une liste de listes d'entiers de longueur 2. Le pied de page transforme l'entrée du format dans les scénarios de test au format accepté par cette solution.

— Erik le golfeur
source
1

J, 26 , 24 octets

-2 octets grâce à FrownyFrog

(;(,.i.,])&.>i.7)-.\:~"1
  • (;(,.i.,])&.>i.7) calcule l'ensemble complet (cette partie pourrait être complétée, je crois. Et s'il vous plaît faites-le si vous voyez comment ...)
  • -. est "réglé moins"
  • /:~"1 ordonne chacune des entrées

Essayez-le en ligne!

Original

Essayez-le en ligne!

((#~<:/"1)>,{;~i.7)-./:~"1
— Jonas
source
(;(,.i.,])&.>i.7)sauve 2 (inverse l'ordre)
— FrownyFrog
@FrownyFrog merci, mis à jour.
— Jonah
1

Python 2, 89 86 octets

Sauvegardé quelques octets en simplifiant la génération de jeux de dominos.

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}

Essayez-le en ligne!

Prend une liste de chaînes comme ["00", "10", "02] en tant qu'argument pour les dominos. Renvoie des objets de jeu python, qui sont des listes distinctes non ordonnées.

Explication

# 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]
— Triggernométrie
source
0

Haskell, 65 octets

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

Exemple d'utilisation:

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

Itérer adans une boucle extérieure sur tous les chiffres de 0la 6et bdans une boucle intérieure sur tous les chiffres de ala 6et de garder ceux aboù ni abne base trouvent dans la chaîne d'entrée.

— nimi
source
0

Sérieusement, 16 octets

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

Prend les entrées sous forme de liste de chaînes, génère une liste de chaînes

Essayez-le en ligne!

Explication:

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

En fait , 13 octets (non concurrents)

♂S7r;∙`εjS`M-

Ceci est identique à la réponse Sérieusement (à l'exception de l'entrée implicite et ♂Sétant un moyen plus court de raccourcir chaque chaîne d'entrée).

Essayez-le en ligne!

— Mego
source
1
Vous avez des doublons dans la sortie
— Digital Trauma
@DigitalTrauma Cela est dû aux modifications incompatibles avec les versions antérieures apportées depuis le moment de la publication.
— Mego
0

raquette

(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
source
2
Sympa de voir des gens jouer au golf en raquette! Ceci est une question de code-golf, vous devriez donc probablement inclure votre compte indirect dans votre réponse. Vous pouvez aussi certainement supprimer un peu d’espace de cette réponse.
— Wheat Wizard
Je suis d’accord avec @WW en ce que cette réponse ne semble pas suffisamment jouée pour être valable.
— Jonathan Frech
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.