Forse conosci il gioco di Set (un meraviglioso gioco per bambini tra l'altro) un gioco di carte con 81 carte, in cui ogni carta ha una figura con 4 attributi diversi (forma, numero, colore e riempimento). Ogni attributo ha 3 valori diversi:

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

12 carte sono aperte sul tavolo e ora la sfida è quella di indicare i set. Un set è composto da tre carte in cui ogni valore di attributo ricorre 0, 1 o 3 volte. avere 2 carte con figure rosse o opache o 1 numero non va bene. Vedi il link fornito per una spiegazione più visiva.

Immagino un codice per una carta in cui tutti gli attributi sono codificati così

"WP2N"

sta per

2 Purple Waves with No fill

Insieme ad esempio OR1NeDG3N

e

è un insieme (3 forme diverse, 3 colori diversi, 3 numeri diversi, 1 riempimento).

L'input è una stringa delimitata da spazi di codici univoci (scelti casualmente su 81 possibili codici) che rappresentano le carte.

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

La soluzione deve indicare tutti i set possibili all'interno della raccolta indicata. Così

OR1N, WP2N, DG3N

deve essere parte della soluzione insieme a tutti gli altri set.

Rubino, 104 98 81 80 caratteri

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

Esecuzione di esempio (utilizzando i dati di esempio):

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

Emette WP2N,DR1D,OG3Odue volte perché hai due DR1Ds nei tuoi dati di esempio.

Spiegazione:

$*.combination(3).map{|c|- ogni combinazione di 3 carte
puts c*?,if- genera il set, se ...
(0..3).all?{|i|- se tutti i numeri da 0 a 3 (gli indizi delle proprietà nella stringa) valutano truequando passati in questo blocco
c.map{|x|x[i]}- prendi l' iindice th di ogni stringa
.uniq.size!=2}- se la quantità di proprietà uniche (forma, colore, ecc.) non è 2 (quindi 1 o 3)

Mathematica 93 92 93 82 76 73

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

La logica

StringSplit@#~Subsets~{3}produce un elenco di sottoinsiemi di 3 carte. Ogni tripla come:

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

o

viene quindi trasposto,

e Tally/@(Characters@#^T)indica il numero di elementi distinti in ciascuna riga.

{3,1,1,3}

3 corrisponde a "tutti diversi"; 1 corrisponde a "tutti uguali".

FreeQ[...,2]determina se 2 carte dello stesso tipo o nel triplo. Se 2 non è tra i conteggi, le tre carte sono un "set", secondo le regole del Gioco del set.

uso

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

uso

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 byte

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

Provalo online!

Accetta l'input tramite la variabile di input e genera l'output tramite la variabile di output.

Secondo caso di test preso da un duplicato recentemente chiuso nella sua codifica, poiché questa soluzione non importa davvero cosa significhi effettivamente qualcosa.

                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 caratteri

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

L'input deve essere fornito su STDIN, esempio online :

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

Codice commentato:

" "/: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]}}}}}}

è una funzione che accetta una matrice di oggetti e restituisce una matrice di oggetti.

DEMO violino (con riordino).

APL (IBM), 76

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

Non ho IBM APL, ma credo che funzionerà.

Esempio di esecuzione (emulazione di IBM APL in 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 

Salvia, 71

Se Cè una stringa, diciamo "OR1N WP2N DG3N DR1D WG3S WG1N WR2D WP3N DR2O DR1D OG3O OR2D", esegui

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

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

Ed ecco un approccio molto diverso usando l'interpretazione secondo cui un Set è una linea proiettiva in GF(3)^4:

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

Ero un po 'seccato che Dfosse usato due volte ... fino a quando non ho capito come abusarne. Ma ancora meglio, abuso anche del findmetodo. str.findrestituisce -1 se non viene trovata una lettera. Da allora -1 = 2 mod 3, la lettera Sviene gestita in modo appropriato perché non compare in 'WODRPG123N'.

Python 2 , 99 byte

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

Provalo online!