Nel gioco del sudoku, molti giocatori amano "inserire" possibili numeri che possono andare in ogni casella:

La riga sopra può essere rappresentata come un array:

[[1,2,9], [6], [5], [7], [1,2,9], [1,2,9], [3], [1,2,4], [8]]

Ora, nota che c'è solo 1 posto dove si 4può andare. Questo ci consente efficacemente di semplificare l'elenco sopra per:

[[1,2,9], [6], [5], [7], [1,2,9], [1,2,9], [3], [4], [8]]

L'obiettivo di questa sfida è quello di prendere un elenco di possibili numeri in una permutazione e dedurre quali possibilità possono essere eliminate .

Come altro esempio, supponiamo che tu abbia la seguente gamma di possibilità:

[[0,1,3], [0,2,3], [1,2], [1,2]]

Gli ultimi due posti devono essere riempiti con 1 e 2. Pertanto, possiamo rimuovere quelle possibilità dai primi due elementi dell'array:

[[0,3], [0,3], [1,2], [1,2]]

Come altro esempio:

[[0,1,2,3], [0,2], [0,2], [0,2]]

È impossibile costruire una permutazione dalle possibilità sopra, poiché c'è solo 1 posizione per entrambi 1e 3, e si vorrebbe restituire un array vuoto.

È necessario inserire un elenco di possibilità e produrre le rimanenti possibilità dopo l'eliminazione del numero massimo di possibilità.

• Se un determinato array è impossibile, è necessario restituire un array vuoto o un array in cui uno dei sottoarray è vuoto.
• Puoi supporre che l'array sia ben formato e abbia almeno 1 elemento.
• Data una matrice di dimensioni N, si può presumere che i numeri nel sottoarray siano sempre nell'intervallo [0:N)e quelloN <= 10
• Non puoi presumere che tutti i numeri da 0a N-1saranno presenti
• Si può presumere che i numeri all'interno di un singolo subarray siano univoci.
• Se un subarray contiene solo una singola possibilità, è possibile rappresentare la possibilità in un array o da solo. [[1],[2],[0]], [1,2,0], [[1,2],0,[1,2]]Sono tutti validi.
• È possibile accettare l'array in un formato stringa ragionevole o in formato elenco / array.
• I subarrays possono essere in qualsiasi ordine.
• Invece di gestire array irregolari, puoi riempire i posti vuoti con -1.

Casi test

[[0]]                                         -> [[0]]
[[1],[0]]                                     -> [[1],[0]]
[[1],[1]]                                     -> []
[[1],[0,1]]                                   -> [[1],[0]]
[[0,1,2],[1,2],[1,2]]                         -> [[0],[1,2],[1,2]]
[[0,1],[1,2],[0,2]]                           -> [[0,1],[1,2],[0,2]]
[[2,1],[1,2],[1,2]]                           -> []
[[0,3],[2,1],[3,0],[3,2]]                     -> [[0,3],[1],[0,3],[2]]
[[0,1],[0,1],[2,3],[2,3,0]]                   -> [[0,1],[0,1],[2,3],[2,3]]
[[0,1],[0,3],[3,2],[0]]                       -> [[1],[3],[2],[0]]
[[3,5,2],[0,2,4],[4,0],[0,1,3,5],[2,1],[2,4]] -> [[3,5],[0,2,4],[4,0],[3,5],[1],[2,4]]
[[6,9,8,4],[4,5],[5,3,6],[3,8,6,1,4],[3,1,9,6],[3,7,0,2,4,5],[9,5,6,8],[6,5,8,1,3,7],[8],[8,0,6,2,5,6,3]] -> [[6,9,4],[4,5],[5,3,6],[3,6,1,4],[3,1,9,6],[0,2],[9,5,6],[7],[8],[0,2]]
[[3,5,0],[5,7],[5,1,2],[1,3,0],[5,3],[5,0],[5,3,7,8,0,6],[7,5,0,1,8],[1,0,8],[0,6]] -> []
[[9,0,2,3,7],[0,7,6,5],[6,9,4,7],[9,1,2,3,0,5],[2,8,5,7,4,6],[6,5,7,1],[5,9,4],[5,9,3,8,1],[5,0,6,4],[0,7,2,1,3,4,8]] -> [[9,0,2,3,7],[0,7,6,5],[6,9,4,7],[9,1,2,3,0,5],[2,8,5,7,4,6],[6,5,7,1],[5,9,4],[5,9,3,8,1],[5,0,6,4],[0,7,2,1,3,4,8]]
[[2,6,0],[0,4,3],[0,6,2],[0,7],[0,9,2,3,6,1,4],[1,7,2],[2,7,8],[8,6,7],[6,5,2,8,0],[5,8,1,4]] -> [[2,6,0],[3],[0,6,2],[0,7],[9],[1],[2,7,8],[8,6,7],[5],[4]]
[[8],[8,0,6,5,7,2,4,1],[8,6,9,3,5,0,7],[3,9,1,0],[9],[9,2,6],[2,8,3],[3,1,6,8,2],[6],[6,4,5,3,0,7]] -> [[8],[5,7,4],[5,7],[0],[9],[2],[3],[1],[6],[4,5,7]]
[[8,1,0],[5,8,7,6,2,0],[6,8,2],[2,4,0,9],[4,1,7,3,6,8],[8,1],[8,0,3],[0,8,2],[0,8,3],[1,8,0]] -> []

Questo è un codice-golf, quindi fai in modo che le tue risposte siano le più brevi possibili!

Brachylog , 21 byte

:1fz:da|,[]
:2a#d
:Am

Provalo online!

Provalo online!

Predicato 0 (predicato principale)

:1fz:da|,[]
:1f            Find all solutions of Predicate 1 using Input as Input.
   z           Transpose
    :da        Deduplicate each.
       |,[]    If there is no solution, return [] instead.

Predicato 1 (predicato ausiliario 1)

:2a#d
:2a     Each element of Output satisfies Predicate 2 with each element of Input as Input
   #d   Each element is different

Predicato 2 (predicato ausiliario 2)

:Am     Output is member of Input

Gelatina , 10 byte

Œp⁼Q$ÐfZQ€

Provalo online!

Œp⁼Q$ÐfZQ€   Main chain, argument: z

Œp           Cartesian product
  ⁼Q$Ðf      Filter for those that remain unchanged when uniquified
       Z     Transpose
        Q€   Uniquify each subarray

Pyth , 11 byte

{MC{I#.nM*F

Provalo online!

{MC{I#.nM*F
         *F  reduce by Cartesian product
             produces nested arrays
      .nM    flatten each
   {I#       filter for invariant under deduplication
  C          transpose
{M           deduplicate each

Haskell, 100 byte

import Data.List
p z=map nub$transpose$filter(and.(flip$zipWith elem)z)$permutations[0..length z-1]

In realtà , 27 byte

Rd╗R`╜∙"♂i"£M╗`MX╜`;╔=`░┬♂╔

Provalo online!

Python 3, 101 99 byte

Grazie a @TLW per -2 byte

from itertools import*
lambda x:list(map(set,zip(*[i for i in product(*x)if len(i)==len(set(i))])))

Una funzione anonima che accetta input tramite argomento di un elenco di elenchi e restituisce un elenco di insiemi.

Come funziona

from itertools import*        Import Python's library for iterator generation
lambda x                      Anonymous function with input possibilities x as a
                              list of lists
...for i in product(*x)...    For i in the Cartesian product of x, ie all candidate
                              arrangements:
[...if len(i)==len(set(i))]    Filter into list by non-duplicity (set removes
                               duplicates, so there are no duplicates if the length
                               of i is the same as the length of the set of
                               the elements of i)
zip(*...)                     Unpack and take the transpose, leaving the modified
                              possibilities with duplicates
map(set,...)                  Remove duplicates
:list(...)                    Return the modified possibilities as a list of sets

Provalo su Ideone

Mathematica, 46 byte

Union/@Thread@Select[Tuples@#,DuplicateFreeQ]&

PHP, 245 231 byte

131 117 per la funzione prodotto cartesiano, 114 per le altre cose

function c($a){if ($a){if($u=array_pop($a))foreach(c($a)as$p)foreach($u as$v)yield $p+[count($p)=>$v];}else yield[];}
function p($a){foreach(c($a)as$i)if(max(array_count_values($i))<2)foreach($i as$k=>$v)$r[$k][$v]=$v;return$r?:[];}

Ho riscontrato problemi di memoria in alcuni casi di test, con una funzione ricorsiva per il prodotto cartesiano. Ha funzionato meglio con questa classe di generatori e function c($a){$b=[];foreach($a as$i)$b[]=new \ArrayIterator($i);return new CartesianProductIterator($b);}.
Ma il mio generatore è più corto e fa lo stesso lavoro.

Gli esempi più grandi, tuttavia, causano un errore interno del server (sia con l'iteratore che con il generatore) dopo un po 'sulla mia macchina. Purtroppo non c'è tempo per controllare i registri del server.