Sudoku oyununda, birçok oyuncu her kareye girebilecek muhtemel sayıları "yazmayı" sever:

Yukarıdaki satır bir dizi olarak gösterilebilir:

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

Şimdi, 4gidebileceğiniz tek bir yer olduğuna dikkat edin . Bu, yukarıdaki listeyi şu şekilde basitleştirmemizi sağlar:

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

Bu zorluğun amacı, bir permütasyondaki olası sayıların bir listesini almak ve hangi olasılıkların ortadan kaldırılabileceğini belirlemektir .

Başka bir örnek olarak, aşağıdaki olasılıklara sahip olduğunuzu varsayalım:

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

Son iki yer gerekir 1 ve Dolayısıyla 2 ile doldurulması, biz dizideki ilk iki elemanlardan Bu olasılıklar kaldırabilir:

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

Başka bir örnek olarak:

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

Onun imkansız ikisi için sadece 1 konum var gibi yukarıdaki olasılıklar bir permütasyon inşa etmek 1ve 3ve boş bir dizi döndürür isteyeyim.

Bir olasılık listesi girmeniz ve maksimum olasılık ortadan kaldırıldıktan sonra kalan olanakları çıkarmanız gerekir.

• Belirli bir dizi imkansızsa, ya boş bir dizi ya da alt dizilerden birinin boş olduğu bir dizi döndürmeniz gerekir.
• Dizinin iyi biçimlendirileceğini ve en az 1 öğeye sahip olduğunu varsayabilirsiniz.
• Bir boyut dizisi verildiğinde, alt dizideki Nsayıların her zaman aralıkta olacağını [0:N)veN <= 10
• Sen her sayı farz olmayabilir 0için N-1hazır bulunacak
• Tek bir alt dizilimdeki sayıların benzersiz olduğunu varsayabilirsiniz.
• Bir alt dizi yalnızca tek bir olasılık içeriyorsa, olasılığı bir dizide veya kendi başına temsil edebilirsiniz. [[1],[2],[0]], [1,2,0], [[1,2],0,[1,2]]Tüm geçerlidir.
• Diziyi makul bir dize biçiminde veya liste / dizi biçiminde kabul edebilirsiniz.
• Subarrays herhangi bir sırayla olabilir.
• Düzensiz dizilerle uğraşmak yerine, boş yerleri doldurabilirsiniz -1.

Test durumları

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

Bu bir kod golfüdür, bu nedenle cevaplarınızı mümkün olduğunca kısa tutun!

Brachylog , 21 bayt

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

Çevrimiçi deneyin!

Çevrimiçi deneyin!

Tahmini 0 (ana tahmini)

: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.

Tahmini 1 (yardımcı tahmini 1)

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

Tahmini 2 (yardımcı tahmini 2)

:Am     Output is member of Input

Jöle , 10 bayt

Œp⁼Q$ÐfZQ€

Çevrimiçi deneyin!

Œ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 bayt

{MC{I#.nM*F

Çevrimiçi deneyin!

{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 bayt

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

Aslında , 27 bayt

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

Çevrimiçi deneyin!

Python 3, 101 99 bayt

-2 baytlık @TLW sayesinde

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

Bir liste listesi argümanı ile girdi alan ve bir takım listesi döndüren adsız bir işlev.

Nasıl çalışır

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

Ideone'da dene

Mathematica, 46 bayt

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

PHP, 245 231 bayt

Kartezyen ürün fonksiyonu için 131 117, diğer şeyler için 114

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?:[];}

Kartezyen ürün için özyinelemeli bir fonksiyonla bazı test durumlarında hafıza sorunları ile karşılaştım. Daha çalıştı bu jeneratör sınıfına ve function c($a){$b=[];foreach($a as$i)$b[]=new \ArrayIterator($i);return new CartesianProductIterator($b);}.
Ancak jeneratörüm daha kısa ve aynı işi yapıyor.

Bununla birlikte, daha büyük örnekler, makinemde bir süre sonra bir Dahili Sunucu Hatası (hem yineleyici hem de jeneratör ile) sonuçlanır. Şu anda ne yazık ki, sunucu günlüklerini kontrol etmek için zaman yok.