Đưa ra một câu đố Sudoku, tìm tất cả các dấu có thể có thể được điền vào từng ô trống.

Trường hợp thử nghiệm

Đầu vào:

[
    [
        // Top left:
        [
            0, 0, 0,
            3, 4, 0,
            0, 0, 2
        ],
        // Top middle:
        [
            7, 4, 0,
            0, 0, 0,
            0, 0, 3
        ],
        // Top right:
        [
            8, 0, 0,
            1, 7, 0,
            0, 0, 0
        ]
    ],
    [
        // Middle left:
        [
            9, 0, 4,
            7, 0, 0,
            1, 0, 3
        ],
        // Center:
        [
            0, 5, 0,
            0, 0, 0,
            0, 7, 0
        ],
        // Middle right:
        [
            0, 0, 0,
            6, 4, 0,
            0, 0, 0
        ]
    ],
    [
        // Bottom left:
        [
            0, 0, 7,
            6, 3, 0,
            0, 0, 0
        ],
        // Bottom middle:
        [
            0, 0, 5,
            0, 0, 0,
            9, 1, 0
        ],
        // Bottom right:
        [
            0, 0, 0,
            5, 2, 0,
            7, 0, 0
        ]
    ]
]

Đầu ra:

[
    [
        // Top left:
        [
            [5], [1, 5, 6, 9], [1, 5, 6, 9],
            [], [], [5, 6, 8, 9],
            [5, 8], [1, 5, 6, 7, 8, 9], []
        ],
        // Top middle:
        [
            [], [], [1, 2, 6, 9],
            [2, 5, 6, 8], [2, 6, 8, 9], [2, 6, 8, 9],
            [1, 5, 6, 8], [6, 8, 9], []
        ],
        // Top right:
        [
            [], [3, 5, 6, 9], [2, 3, 5, 6, 9],
            [], [], [2, 5, 6, 9],
            [4, 9], [5, 6, 9], [4, 5, 6, 9]
        ]
    ],
    [
        // Middle left:
        [
            [], [2, 6, 8], [],
            [], [2, 5, 8], [5, 8],
            [], [2, 5, 6, 8], []
        ],
        // Center:
        [
            [1, 2, 3, 6, 8], [], [1, 2, 6, 8],
            [1, 2, 3, 8], [2, 3, 8, 9], [1, 2, 8, 9],
            [2, 4, 6, 8], [], [2, 4, 6, 8, 9]
        ],
        // Middle right:
        [
            [2, 3], [1, 3, 8], [1, 2, 3, 7, 8],
            [], [], [1, 2, 3, 5, 8, 9],
            [2, 9], [5, 8, 9], [2, 5, 8, 9]
        ]
    ],
    [
        // Bottom left:
        [
            [2, 4, 8], [1, 2, 8, 9], [],
            [], [], [1, 8, 9],
            [2, 4, 5, 8], [2, 5, 8], [5, 8]
        ],
        // Bottom middle:
        [
            [2, 3, 4, 6, 8], [2, 3, 6, 8], [],
            [4, 8], [8], [4, 7, 8],
            [], [], [2, 4, 6, 8]
        ],
        // Bottom right:
        [
            [3, 4, 9], [1, 3, 6, 8, 9], [1, 3, 4, 6, 8, 9],
            [], [], [1, 4, 8, 9],
            [], [3, 6, 8], [3, 4, 6, 8]
        ]
    ]
]

Hình dung đầu ra; những con số nhỏ

Quy tắc

• Đây là một mã golf . Câu trả lời ngắn nhất tính bằng byte (hoặc tương đương) sẽ thắng.
• Đầu vào có thể ở định dạng mảng hoặc chuỗi.
• Đầu vào phải theo thứ tự được trình bày ở trên (trên cùng bên trái, trên cùng giữa, trên cùng bên phải, v.v ...)
• Đầu ra có thể ở định dạng mảng hoặc chuỗi, miễn là đầu ra có thể biểu diễn một cách hợp lý kết quả mong đợi.
• Đầu ra phải theo cùng thứ tự với đầu vào (trên cùng bên trái, trên cùng giữa, trên cùng bên phải, v.v ...)
• Đầu ra không cần phải được chỉnh sửa.
• Mã phải được áp dụng cho bất kỳ lưới Sudoku không đầy đủ hợp lệ.
• Quy tắc chơi golf tiêu chuẩn được áp dụng.

Ghi chú bổ sung:

Bạn nhận được thêm các điểm internet giả nếu chương trình hoặc chức năng của bạn sử dụng kết quả để giải câu đố Sudoku đến điểm mà các giá trị ô không còn có thể được giải quyết một cách hợp lý. Ví dụ, ô đầu tiên trong trường hợp thử nghiệm chỉ có thể chứa số 5, vì vậy nó cần được xem xét khi điền vào các giá trị khác. Đây chỉ là cho niềm vui và thử thách bổ sung, nếu không, câu trả lời ngắn nhất sẽ thắng bất kể tiêu chí này có được đáp ứng hay không.

C (gcc), 193 byte

#define F(x)for(x=0;x<9;++x)
char s[99];main(k,r,c){gets(s);F(r)F(c){
int d[99]={};F(k)d[s[r*9+k]]=d[s[k*9+c]]=d[s[r/3*27+k/3*9+c/3*3+k%3]]=1;
F(k)s[r*9+c]<48&&!d[49+k]&&putchar(49+k);puts("");}}

Giả sử đầu vào ở định dạng sau (cùng sudoku như trên):

..74.8..34....17...2..3...9.4.5....7.....64.1.3.7......7..5...63....52....91.7..

Và đầu ra ở định dạng sau:

5
1569
1569


1269

3569
23569


5689
etc

Python 2, 178 byte

lambda s,R=range(9):[[[(s[Y][X][i]<1)*[q+1for q in R if~-(q+1in sum([[s[j/3][X][j%3*3+i%3],s[Y][j/3][j%3+i/3*3]]for j in R],[])+s[Y][X])]for i in R]for X in R[:3]]for Y in R[:3]]

Một hàm ẩn danh nhận một mảng ints 3 chiều và trả về một mảng ints 4 chiều.

JavaScript (ES6), 208 196 190 188 186 byte

g=>g.map((B,i)=>[...B].map((s,x)=>+s||[..."123456789"].filter(n=>(t=i=>(k=g[i].search(n)%m)<a|k>b)(j=i%3,m=3,a=b=x%3)&t(j+3)&t(j+6)&t(j=i-j,m=9,a=x-a,b=a+2)&t(j+1)&t(j+2)&t(i,a=0,b=8))))

Đầu vào :
Một mảng gồm 9 chuỗi (một chuỗi trên mỗi hộp, từ trên cùng bên trái đến dưới cùng bên phải).

Đầu ra :
Một mảng gồm 9 mảng, trong đó mỗi mục bao gồm số gốc ở vị trí này hoặc một mảng các ký tự đại diện cho các chữ số có thể.

Định dạng và nhận xét

g => g.map((B, i) =>              // for each box B at position i in the grid:
  [...B].map((s, x) =>            // for each cell s at position x in this box:
    +s ||                         // if there already is a number at this position, use it
    [..."123456789"].filter(n =>  // else, for each digit n in [1 .. 9]:
      (t = i =>                   // t() = helper function that looks for the digit n inside
        (k = g[i].search(n) % m)  // a given box i and returns a truthy value if its
        < a | k > b               // position modulo m is not in the range [a .. b]
      )(                          //
        j = i % 3,                // test the top box in the current column, using:
        m = 3,                    // modulo = 3 and
        a = b = x % 3             // range = [x % 3 .. x % 3]
      ) &                         //
      t(j + 3) &                  // test the middle box in the current column
      t(j + 6) &                  // test the bottom box in the current column
      t(                          //
        j = i - j,                // test the left box in the current row, using:
        m = 9,                    // modulo = 9 and
        a = x - a, b = a + 2      // range = [floor(x / 3) .. floor(x / 3) + 2]
      ) &                         //
      t(j + 1) &                  // test the middle box in the current row
      t(j + 2) &                  // test the right box in the current row
      t(i, a = 0, b = 8)          // finally test the current box, using:
    )                             // modulo = 9 (unchanged) and
  )                               // range = [0 .. 8] (thus testing the entire box)
)                                 //

Bản giới thiệu

let f =

g=>g.map((B,i)=>[...B].map((s,x)=>+s||[..."123456789"].filter(n=>(t=i=>(k=g[i].search(n)%m)<a|k>b)(j=i%3,m=3,a=b=x%3)&t(j+3)&t(j+6)&t(j=i-j,m=9,a=x-a,b=a+2)&t(j+1)&t(j+2)&t(i,a=0,b=8))))

console.log(f([
  "000340002",
  "740000003",
  "800170000",
  "904700103",
  "050000070",
  "000640000",
  "007630000",
  "005000910",
  "000520700"
]));

Haskell, 135 byte

(%)=mod
x!y=x-x%y
f a=[[j|j<-[1..9],and[a!!k/=j|k<-[i!3-i!9%27+p%3+p!3*3|p<-[0..8]]++[i!9..i!9+8]++[i%9,i%9+9..80]],a!!i<1]|i<-[0..80]]

Xác định hàm ftừ danh sách 81 Ints đến danh sách danh sách Ints;

IO giống như câu trả lời của orlp , ngoại trừ nó sử dụng [0,1,2,3,4,5,6,7,8,9]thay vì ".123456789".

dianne đã lưu một vài byte.

JavaScript (ES6), 185 byte

a=>a.map((b,r)=>b.map((d,c)=>d.map((e,i)=>e.map((g,j)=>[1,2,3,4,5,6,7,8,9].filter(v=>a.every(b=>b[c].every(e=>e[j]-v))&b.every(d=>d[i].every(g=>g-v))&d.every(e=>e.every(g=>g-v))&!g)))))

Lấy đầu vào là một mảng gồm ba hàng của một mảng gồm ba cột của ba bởi ba mảng của các số nguyên và trả về một mảng năm chiều trong đó tất cả các số nguyên đã được thay thế bằng các mảng.