Trong trò chơi sudoku, nhiều người chơi thích "bút chì" những con số có thể có trong mỗi ô vuông:

Hàng trên có thể được biểu diễn dưới dạng một mảng:

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

Bây giờ, lưu ý rằng chỉ có 1 nơi mà a 4có thể đi. Điều này có hiệu quả cho phép chúng tôi đơn giản hóa danh sách trên để:

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

Mục tiêu của thử thách này là lấy một danh sách các số có thể có trong một hoán vị và suy ra những khả năng nào có thể được loại bỏ .

Một ví dụ khác, giả sử bạn có các khả năng sau:

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

Hai vị trí cuối cùng phải được điền 1 và 2. Do đó, chúng ta có thể loại bỏ các khả năng đó khỏi hai phần tử đầu tiên trong mảng:

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

Một ví dụ khác:

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

Nó không thể để xây dựng một hoán vị từ các khả năng trên, như chỉ có 1 vị trí cho cả hai 1và 3, và bạn sẽ muốn quay trở lại một mảng trống.

Bạn cần nhập một danh sách các khả năng và đưa ra các khả năng còn lại sau khi số lượng khả năng tối đa đã bị loại bỏ.

• Nếu một mảng cụ thể là không thể, bạn cần phải trả về một mảng trống hoặc một mảng trong đó một trong các chuỗi con trống.
• Bạn có thể giả định rằng mảng sẽ được định dạng tốt và có ít nhất 1 phần tử.
• Đưa ra một mảng kích thước N, bạn có thể giả sử các số trong phân đoạn sẽ luôn nằm trong phạm vi [0:N)và điều đóN <= 10
• Bạn không thể cho rằng mọi số từ 0đến N-1sẽ có mặt
• Bạn có thể cho rằng các số trong một phân đoạn đơn là duy nhất.
• Nếu một phân đoạn chỉ chứa một khả năng duy nhất, bạn có thể biểu diễn khả năng đó trong một mảng hoặc bằng chính nó. [[1],[2],[0]], [1,2,0], [[1,2],0,[1,2]]Tất cả đều hợp lệ.
• Bạn có thể chấp nhận mảng ở định dạng chuỗi hợp lý hoặc ở định dạng danh sách / mảng.
• Các đoạn con có thể theo thứ tự bất kỳ.
• Thay vì xử lý các mảng rách rưới, bạn có thể đệm những chỗ trống -1.

Các trường hợp thử nghiệm

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

Đây là một môn đánh gôn, vì vậy hãy trả lời ngắn gọn nhất có thể!

Brachylog , 21 byte

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

Hãy thử trực tuyến!

Hãy thử trực tuyến!

Vị ngữ 0 (vị ngữ chính)

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

Vị ngữ 1 (vị ngữ phụ 1)

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

Vị ngữ 2 (vị ngữ phụ 2)

:Am     Output is member of Input

Thạch , 10 byte

Œp⁼Q$ÐfZQ€

Hãy thử trực tuyến!

Œ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

Bình thường , 11 byte

{MC{I#.nM*F

Hãy thử trực tuyến!

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

Trên thực tế , 27 byte

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

Hãy thử trực tuyến!

Python 3, 101 99 byte

Cảm ơn @TLW cho -2 byte

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

Một hàm ẩn danh nhận đầu vào thông qua đối số của danh sách các danh sách và trả về danh sách các bộ.

Làm thế nào nó hoạt động

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

Hãy thử nó trên Ideone

Toán học, 46 byte

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

PHP, 245 231 byte

131 117 cho chức năng sản phẩm cartesian, 114 cho các thứ khác

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

Tôi gặp vấn đề về bộ nhớ trong một số trường hợp thử nghiệm, với chức năng đệ quy cho sản phẩm cartesian. Làm việc tốt hơn với lớp máy phát điện này và function c($a){$b=[];foreach($a as$i)$b[]=new \ArrayIterator($i);return new CartesianProductIterator($b);}.
Nhưng máy phát điện của tôi ngắn hơn và làm công việc tương tự.

Tuy nhiên, các ví dụ lớn hơn dẫn đến Lỗi Máy chủ Nội bộ (cả với trình lặp và trình tạo) sau một thời gian trên máy của tôi. Hiện tại không có thời gian để kiểm tra nhật ký máy chủ, thật không may.