Peut-être connaissez-vous le jeu de Set (un jeu merveilleux pour les enfants) un jeu de cartes avec 81 cartes, où chaque carte a une figure avec 4 attributs différents (forme, nombre, couleur et remplissage). Chaque attribut a 3 valeurs différentes:

form: wave, oval, diamond
colour: red, purple, and green
number: 1, 2, 3
fill: none, dashed, opaque.

12 cartes sont posées sur la table et le défi consiste maintenant à indiquer les sets. Un ensemble se compose de trois cartes où chaque valeur d'attribut se produit 0, 1 ou 3 fois. avoir 2 cartes avec des chiffres rouges, ou opaques, ou 1 numéro n'est pas bon. Voir le lien fourni pour une explication plus visuelle.

J'envisage un code pour une carte où tous les attributs sont encodés de manière

"WP2N"

signifie

2 Purple Waves with No fill

Avec par exemple OR1NetDG3N

et

c'est un ensemble (3 formes différentes, 3 couleurs différentes, 3 numéros différents, 1 remplissage).

L'entrée est une chaîne délimitée par des espaces de codes uniques (choisis au hasard parmi 81 codes possibles) représentant des cartes.

"OR1N WP2N DG3N DR1D WG3S WG1N WR2D WP3N DR2O DR2D OG3O OR2D"

La solution doit indiquer tous les ensembles possibles dans la collection donnée. Donc

OR1N, WP2N, DG3N

doit faire partie de la solution avec tous les autres ensembles.

Ruby, 104 98 81 80 caractères

$*.combination(3).map{|c|puts c*?,if(0..3).all?{|i|c.map{|x|x[i]}.uniq.size!=2}}

Exemple d'exécution (en utilisant vos données d'exemple):

c:\a\ruby>set.rb OR1N WP2N DG3N DR1D WG3S WG1N WR2D WP3N DR2O DR1D OG3O OR2D
OR1N,WP2N,DG3N
WP2N,DR1D,OG3O
WP2N,DR1D,OG3O
DG3N,WG3S,OG3O

Il sort WP2N,DR1D,OG3Odeux fois parce que vous avez deux DR1Ds dans vos données d'échantillon.

Explication:

$*.combination(3).map{|c|- chaque combinaison de 3 cartes
puts c*?,if- sortez l'ensemble, si ...
(0..3).all?{|i|- si tous les nombres de 0 à 3 (les indécis des propriétés dans la chaîne) évaluent truequand ils sont passés dans ce bloc
c.map{|x|x[i]}- prenez l' iindex e de chaque chaîne
.uniq.size!=2}- si le nombre de propriétés uniques (forme, couleur, etc.) n'est pas 2 (donc 1 ou 3)

Mathematica 93 92 93 82 76 73

f={}⋃Select[StringSplit@#~Subsets~{3}, FreeQ[Tally/@(Characters@#^T),2]&]&

La logique

StringSplit@#~Subsets~{3}produit une liste de sous-ensembles de 3 cartes. Chaque triple tel que:

{{"D", "G", "3", "N"}, {"W", "G", "3", "S"}, {"O", "G", "3", "O"}}

ou

est ensuite transposé,

et Tally/@(Characters@#^T)correspond au nombre d'éléments distincts dans chaque ligne.

{3,1,1,3}

3 correspond à "tous différents"; 1 correspond à "tout de même".

FreeQ[...,2]détermine si 2 cartes du même type ou dans le triple. Si 2 ne fait pas partie des décomptes, alors les trois cartes sont un "set", selon les règles du Game of Set.

Usage

f["OR1N WP2N DG3N DR1D WG3S WG1N WR2D WP3N DR2O DR1D OG3O OR2D"]

{{"DG3N", "WG3S", "OG3O"}, {"OR1N", "WP2N", "DG3N"}, {"WP2N", "DR1D", "OG3O"}}

Mathematica 73

f = Select[StringSplit@#~Subsets~{3}, FreeQ[Tally /@ Thread@Characters@#, 2] &] &

Usage

f["OR1N WP2N DG3N DR1D WG3S WG1N WR2D WP3N DR2O DR1D OG3O OR2D"]

{{"OR1N", "WP2N", "DG3N"}, {"WP2N", "DR1D", "OG3O"}, {"WP2N", "DR1D", "OG3O"}, {"DG3N", "WG3S "," OG3O "}}

Brachylog , 12 octets

ṇ₁⊇Ṫz{=|≠}ᵐz

Essayez-le en ligne!

Prend l'entrée via la variable d'entrée et génère la sortie via la variable de sortie.

Deuxième cas de test tiré d'un doublon récemment fermé dans son encodage, car cette solution ne se soucie pas vraiment de ce que signifie réellement.

                The output variable is
  ⊇             a subsequence
   Ṫ            of length 3
ṇ₁              of the input split on spaces,
    z      z    the columns of which
     {   }ᵐ     are all
       |        either
      =         the same element repeated,
        ≠       or entirely free of duplicates.

GolfScript, 53 caractères

" "/:w,,{:a,{:^,{a^]{w=}%.0\zip{.&,2=|}/!{.p}*;}/}/}/

L'entrée doit être fournie sur STDIN, par exemple en ligne :

> OR1N WP2N DG3N DR1D WG3S WG1N WR2D WP3N DR2O DR2D OG3O OR2D
["OR1N" "DG3N" "WP2N"]
["WP2N" "OG3O" "DR1D"]
["DG3N" "OG3O" "WG3S"]
["WR2D" "OR2D" "DR2D"]

Code commenté:

" "/:w          # split the input at spaces and assign it to variable w
,,              # create the array [0..n-1] (n being the length of w)
{:a,{:^,{       # three nested loops: a=0..n-1, ^=0..a-1, _=0..b-1 
                # (third loop has no variable assigned but just pushes on stack)
    a^]         # make an array [a,^,_] of the three loop variables
    {w=}%       # take the corresponding list items, i.e. [w[a],w[^],w[_]]
    .0\         # push zero, add duplicate of the the array
    zip         # zip transposes the array, thus [OR1N WP2N DG3N] -> [OWD RPG 123 NNN]
    {           # loop over those entries
      .&        # unique
      ,2=       # length equals 2?
      |         # "or" with top of stack (two zero pushed before)
    }/          # end of loop, on stack remains the results of the "or"s
    !{.p}*      # if no length of 2 is there, make a copy of the set and print it
    ;           # discard stack item
}/}/}/          # closing the three nested loops

javascript 323 313

function a(b){d=h=[];c=e=f=0;for(i in b){for(j in b){for(k in b[i]){if(b[i][k]==b[j][k]){if(c+f<4)c++;else if(c==4){h+=b[j];if(h.length=3)return h}}else{for(l in d){for(m in d[l]){g=f;if(d[l][2]==i){if(d[l][3]==k)if(b[j][k]!=d[l][0]&&b[j][k]!=d[l][1])f++;}else{continue}}if(g==f)d[e++]=[b[i][k],b[j][k],j,k]}}}}}}

c'est une fonction qui prend un tableau d'objets et renvoie un tableau d'objets.

DEMO violon (avec rangement).

APL (IBM), 76

⍉¨x/⍨{{⍵≡1⌽⍵}⍵=1⌽⍵}¨x←⊃¨(∘.,/3⍴⊂⍪¨(' '≠y)⊂y←⍞)⌷⍨¨z/⍨∧/¨2</¨z←,⍳3⍴12

Je n'ai pas IBM APL, mais je pense que cela fonctionnera.

Exemple d'exécution (émulation d'IBM APL dans Dyalog APL)

OR1N WP2N DG3N DR1D WG3S WG1N WR2D WP3N DR2O DR1D OG3O OR2D
 OR1N  WP2N  WP2N  DG3N 
 WP2N  DR1D  DR1D  WG3S 
 DG3N  OG3O  OG3O  OG3O 

Sauge, 71

Si Cest une chaîne, par exemple "OR1N WP2N DG3N DR1D WG3S WG1N WR2D WP3N DR2O DR1D OG3O OR2D", exécutez

[c for c in Subsets(C.split(),3)if{1,3}>={len(set(x))for x in zip(*c)}]

obtenir [{'DR1D', 'OG3O', 'WP2N'}, {'DR2D', 'WR2D', 'OR2D'}, {'WG3S', 'OG3O', 'DG3N'}, {'DG3N', 'WP2N', 'OR1N'}]

Et voici une approche très différente utilisant l'interprétation selon laquelle un ensemble est une ligne projective GF(3)^4:

[c for c in Subsets(C.split(),3)if sum(matrix(3,map('WODRPG123N'.find,''.join(c))))%3==0]

J'étais un peu ennuyé d'avoir Dété utilisé deux fois ... jusqu'à ce que je comprenne comment abuser de ça. Mais encore mieux, j'abuse aussi de la findméthode. str.findrenvoie -1 si aucune lettre n'est trouvée. Depuis -1 = 2 mod 3, la lettre Sest traitée correctement car elle ne se produit pas dans 'WODRPG123N'.

Python 2 , 99 octets

lambda A:[a for a in combinations(A,3)if all(len(set(t))-2for t in zip(*a))]
from itertools import*

Essayez-le en ligne!