^{Bu meydan okuma olduğu tamamen yırtık ağır esinlenerek Tüm Light Soulgit Games tarafından geliştirilen.}

Meydan okuma

Sen bir elektrikçisin ve tüm ışıkları aküye bağlamak senin işin.

• Işıklar ve pil bir ızgaraya yerleştirilmiştir.
• Bir ışığı veya pili en yakın ışığa veya pili kuzey, güney, doğu ve batısına bağlayabilirsiniz.
• Pilin herhangi bir sayıda bağlantısı olabilir.
• Her ışık kaç bağlantı gerektirdiğini belirtir. Bu ışığa tam olarak o kadar çok bağlantı yapmalısınız .
• İki ışık (veya ışık ve pil) arasında tekli bağlantılar veya çift bağlantılar oluşturabilirsiniz.
• Kablolar geçemez.
• Her ışıktan aküye giden bir yol olmalıdır.
• En az bir geçerli çözümün mevcut olduğu garanti edilmektedir.

Pilin ve her ışığın konumu ve her ışığın gerektirdiği bağlantı sayısı göz önüne alındığında, aralarındaki bu özellikleri kabul eden bağlantıları çıkarın.

Kazanma Koşulu

Bu kod golf , bu yüzden her dilde en kısa kod kazanır.

Test Durumları

G / Ç her zamanki gibi esnektir.

Giriş için 2d dizisi, ışıklar için pozitif tamsayılar, boş alanlar için sıfırlar ve pil için -1 depolayan ızgara boyutunu kullanacaktır. Başka bir iyi seçenek, bir ışığın ışığın konumunu ve gerekli bağlantı sayısını içeren bir demet olduğu ışıkların bir listesi olabilir.

Çıkış için, bir bağlantının başlangıç ​​ve bitiş konumlarını içeren bir demet olduğu bir bağlantı listesi kullanacağım. Bir bağlantı iki katına çıkarsa, listede 2 tane olacak (başka bir seçenek bu parametreyi gruba dahil etmektir). Başka bir iyi seçenek de bir çeşit ızgara düzeni olabilir.

Bir koordinat sistemi kullanıyorsanız, başlangıç ​​dizinini ve nereden endekslediğinizi belirtebilirsiniz. Örneklerim 0 dizinli olacak ve sol üst köşe (satır, sütun) olarak (0, 0) kullanılacak. (Ben, okumak daha kolaydır böylece sadece sınırlayıcı başka tür tanıtmak} {kullanıyorum değil onlar setleri çünkü.)

İşte test senaryolarının grafik görünümü: 1-12 Testleri

Test 1:

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

Test 2:

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

Test 3:

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

Test 4:

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

Test 5:

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

Test 6:

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

Test 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)}]

Test 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)}]

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

Test 10:

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

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

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

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)))

Çevrimiçi deneyin!

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)
)