Talvez você conheça o jogo de Set (um jogo maravilhoso para crianças), um jogo de cartas com 81 cartas, onde cada carta tem uma figura com 4 atributos diferentes (forma, número, cor e preenchimento). Cada atributo possui 3 valores diferentes:

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

12 cartas são abertas na mesa e agora o desafio é indicar sets. Um conjunto consiste em três cartas em que cada valor de atributo ocorre 0, 1 ou 3 vezes. Ter 2 cartas com figuras vermelhas, opacas ou 1 número não é bom. Veja o link fornecido para uma explicação mais visual.

Eu imagino um código para um cartão em que todos os atributos sejam codificados para

"WP2N"

apoia

2 Purple Waves with No fill

Juntamente com, por exemplo, OR1NeDG3N

e

é um conjunto (3 formas diferentes, 3 cores diferentes, 3 números diferentes, 1 preenchimento).

A entrada é uma sequência delimitada por espaço de códigos exclusivos (escolhidos aleatoriamente dentre os 81 códigos possíveis) que representam cartões.

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

A solução deve indicar todos os conjuntos possíveis dentro da coleção fornecida. então

OR1N, WP2N, DG3N

deve fazer parte da solução junto com todos os outros conjuntos.

Ruby, 104 98 81 80 caracteres

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

Exemplo de execução (usando seus dados de exemplo):

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

Ele sai WP2N,DR1D,OG3Oduas vezes porque você tem dois DR1Ds nos dados da amostra.

Explicação:

$*.combination(3).map{|c|- cada combinação de 3 cartões
puts c*?,if- gera o conjunto, se ...
(0..3).all?{|i|- se todos os números de 0 a 3 (os indeces das propriedades da string) forem avaliados truequando passados ​​para este bloco
c.map{|x|x[i]}- pegue o ith index de cada string
.uniq.size!=2}- se a quantidade de propriedades únicas (forma, cor etc.) não for 2 (portanto, 1 ou 3)

Mathematica 93 92 93 82 76 73

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

A lógica

StringSplit@#~Subsets~{3}produz uma lista de subconjuntos de 3 placas. Cada triplo, como:

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

ou

é então transposto,

e Tally/@(Characters@#^T)registra o número de itens distintos em cada linha.

{3,1,1,3}

3 corresponde a "todos diferentes"; 1 corresponde a "todos iguais".

FreeQ[...,2]determina se 2 cartas do mesmo tipo ou no triplo. Se 2 não estiver entre as notas, as três cartas serão um "set", de acordo com as regras do Jogo de 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 "}}

Braquilog , 12 bytes

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

Experimente online!

Leva a entrada através da variável de entrada e gera a saída através da variável de saída.

Segundo caso de teste extraído de uma duplicata fechada recentemente em sua codificação, já que esta solução não se importa com o que realmente significa.

                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 caracteres

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

A entrada deve ser fornecida no STDIN, exemplo 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"]

Código comentado:

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

é uma função que pega uma matriz de objetos e retorna uma matriz de objetos.

DEMO violino (com arrumar).

APL (IBM), 76

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

Não tenho o IBM APL, mas acredito que isso funcionará.

Execução de amostra (emulando o IBM APL no 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 

Sage, 71

Se Cfor uma sequência, digamos "OR1N WP2N DG3N DR1D WG3S WG1N WR2D WP3N DR2O DR1D OG3O OR2D", execute

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

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

E aqui está uma abordagem muito diferente usando a interpretação de que um conjunto é uma linha projetiva em GF(3)^4:

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

Fiquei um pouco irritado por ter Dsido usado duas vezes ... até descobrir como abusar disso. Mas, melhor ainda, também abuso do findmétodo. str.findretorna -1 se uma letra não for encontrada. Desde então -1 = 2 mod 3, a carta Sé tratada adequadamente porque não ocorre em 'WODRPG123N'.

Python 2 , 99 bytes

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

Experimente online!