^{Thử thách này hoàn toàn bị xé toạc lấy cảm hứng từ All Light , được phát triển bởi Soulgit Games.}

Thử thách

Bạn là một thợ điện, và công việc của bạn là kết nối tất cả các đèn với pin.

• Các đèn và pin được đặt trong một lưới.
• Bạn có thể kết nối đèn hoặc pin với đèn hoặc pin gần nhất ở phía bắc, nam, đông và tây.
• Pin có thể có bất kỳ số lượng kết nối.
• Mỗi ánh sáng chỉ định có bao nhiêu kết nối cần thiết. Bạn phải thực hiện chính xác nhiều kết nối với ánh sáng đó.
• Bạn có thể tạo các kết nối đơn hoặc kết nối kép giữa hai đèn (hoặc đèn và pin).
• Dây không thể xuyên qua.
• Phải có một đường dẫn từ mỗi đèn đến pin.
• Ít nhất một giải pháp hợp lệ được đảm bảo tồn tại.

Dựa vào vị trí của pin và từng ánh sáng, và số lượng kết nối mà mỗi đèn yêu cầu, hãy xuất ra các kết nối giữa chúng thừa nhận các tính chất này.

Điều kiện thắng

Đây là môn đánh gôn , vì vậy mã ngắn nhất trong mỗi ngôn ngữ sẽ thắng.

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

I / O linh hoạt như bình thường.

Đối với đầu vào, tôi sẽ sử dụng một mảng 2d kích thước của lưới lưu trữ các số nguyên dương cho đèn, số không cho khoảng trống và -1 cho pin. Một lựa chọn tốt khác có thể là một danh sách các đèn, trong đó ánh sáng là một tuple chứa vị trí và số lượng kết nối cần thiết của ánh sáng.

Đối với đầu ra, tôi sẽ sử dụng một danh sách các kết nối, trong đó kết nối là một tuple chứa vị trí bắt đầu và vị trí kết thúc. Nếu một kết nối được nhân đôi thì tôi sẽ có 2 trong số chúng trong danh sách (tùy chọn khác là đưa tham số này vào bộ dữ liệu). Một lựa chọn tốt khác có thể là một số loại bố trí lưới.

Nếu bạn đang sử dụng một hệ tọa độ, bạn có thể chỉ định chỉ mục bắt đầu và nơi bạn lập chỉ mục từ đó. Các ví dụ của tôi sẽ được lập chỉ mục 0 và sử dụng (0, 0) làm góc trên cùng bên trái (hàng, cột). (Tôi đang sử dụng {} chỉ đơn giản là để giới thiệu một loại dấu phân cách khác để dễ đọc hơn, không phải vì chúng là các tập hợp.)

Dưới đây là chế độ xem đồ họa của các trường hợp thử nghiệm: Các thử nghiệm 1-12

Kiểm tra 1:

[-1 | 0 | 1 ] => [{(0, 0), (0, 2)}]

Bài kiểm tra 2:

[-1 | 0 | 2 ] => [{(0, 0), (0, 2)}, {(0, 0), (0, 2)}]

Bài kiểm tra 3:

[-1 ] [ 0 ] => [{(0, 0), (2, 0)), ((0, 0), (2, 0)}] [ 2 ]

Bài kiểm tra 4:

[ 1 | 0 |-1 | 0 | 2 ] => [{(0, 0), (0, 2)}, {(0, 2), (0, 4)}, {(0, 2), (0, 4)}]

Bài kiểm tra 5:

[ 2 ] [ 0 ] [-1 ] => [{(0, 0), (2, 0)}, {(0, 0), (2, 0)}, {(2, 0), (4, 0)}] [ 0 ] [ 1 ]

Bài kiểm tra 6:

[ 1 | 0 | 0 ] [ 0 | 0 | 0 ] => [{(0, 0), (2, 0)}, {(2, 0), (2, 2)}] [ 2 | 0 |-1 ]

Bài kiểm tra 7:

[ 4 | 0 | 0 |-1 ] [ 0 | 0 | 0 | 0 ] => [{(0, 0), (0, 3)}, {(0, 0), (0, 3)}, [ 2 | 0 | 0 | 0 ] {(0, 0), (3, 0)}, {(0, 0), (3, 0)}]

Bài kiểm tra 8:

[ 2 | 0 |-1 | 0 | 2 ] [{(0, 0), (0, 2)}, {(0, 0), (0, 2)}, [ 0 | 0 | 0 | 0 | 0 ] => {(0, 2), (0, 4)}, {(0, 2), (0, 4)}, [ 0 | 0 | 1 | 0 | 0 ] {(0, 2), (2, 2)}]

Bài kiểm tra 9:

[ 0 | 0 | 2 | 0 | 0 ] [ 0 | 0 | 0 | 0 | 0 ] [ 1 | 0 |-1 | 0 | 1 ] => [{(0, 2), (2, 2)}, {(0, 2), (2, 2)}, {(2, 0), (2, 2)}, [ 0 | 0 | 0 | 0 | 0 ] {(4, 2), (2, 2)}, {(2, 4), (2, 2)}, {(2, 4), (2, 2)}] [ 0 | 0 | 2 | 0 | 0 ]

Bài kiểm tra 10:

[-1 | 2 | 3 | 2 ] => [{(0, 0), (0, 3)}, {(0, 0), (0, 3)}, {(0, 0), (0, 3)}, {(0, 0), (0, 3)}]

Bài kiểm tra 11:

[-1 | 0 | 0 | 0 ] [ 3 | 0 | 0 | 0 ] [ 3 | 0 | 0 | 3 ] => [{(0, 0), (1, 0)}, {(1, 0), (2, 0)}, {(1, 0), (2, 0)}, [ 0 | 0 | 0 | 0 ] {(2, 0), (2, 3)}, {(2, 3), (4, 3)}, {(2, 3), (4, 3)}] [ 0 | 0 | 0 | 2 ]

Bài kiểm tra 12:

[ 2 | 0 | 0 ] [{(0, 0), (1, 0)}, {(0, 0), (1, 0)}, {(1, 0), (1, 1)}, [ 3 |-1 | 0 ] => {(1, 1), (2, 1)}, {(1, 1), (2, 1)}, {(2, 0), (2, 1)}, [ 2 | 5 | 1 ] {(2, 0), (2, 1)}, {(2, 1), (2, 2)}]

JavaScript (Node.js) , 393 391 378 byte

a=>(R=[],f=(a,[x,...y],z,Y)=>x?f(a.map(t=>[...t]),y,z,Y)||f(a,y,[...z,x],Y.map(p=>p.map(q=>q-Y[x[0]][x[1]]?q:Y[x[2]][x[3]])),--a[x[0]][x[1]],--a[x[2]][x[3]]):/[1-9]/.test(a)|Y.some(t=>t.some(u=>u-Y[I][J]&&u))?0:z)(a=a.map(A=(b,i)=>b.map((x,j)=>x&&(A[i]+1&&R.push([i,A[i],i,j]),f[j]+1&&R.push([f[j],j,i,j]),A[I=i]=j,f[J=j]=i,x/=x>0))),[...R,...R],C=[],a.map(p=>p.map(q=>q&&++C)))

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

a=>(
    a=a.map(
        A=(b,i)=>
            b.map(
                (x,j)=>
                    x&&(                                  // A[i]+1 <==> A[i] is NOT NaN
                        A[i]+1&&R.push([i,A[i],i,j]),     // Use A and f to store last
                        f[j]+1&&R.push([f[j],j,i,j]),     // existance of row and column
                        A[I=i]=j,f[J=j]=i,x/=x>0          // -1 => -Inf, +n => n
                    )
            ),
            R=[],
            f=([x,...y],z,Y)=>
                x?
                    f(
                        y,[...z,x],
                        Y.map(p=>p.map(q=>q-Y[x[0]][x[1]]?q:Y[x[2]][x[3]])), // merge
                        --a[x[0]][x[1]],--a[x[2]][x[3]]
                    )||
                    f(y,z,Y,++a[x[0]][x[1]],++a[x[2]][x[3]])
                :
                    /[1-9]/.test(a)|
                    Y.some(t=>t.some(u=>u-Y[I][J]&&u)) // not totally merged
                    ?0:z
    ),f)([...R,...R],[],a.map(p=>p.map(q=>q&&++C),C=0)
)