^{ความท้าทายนี้จะฉีกสมบูรณ์ออกอย่างหนักแรงบันดาลใจจาก ทั้งหมดแสงที่พัฒนาโดย Soulgit เกมส์}

ท้าทาย

คุณเป็นช่างไฟฟ้าและเป็นงานของคุณที่จะต่อสายไฟทั้งหมดเข้ากับแบตเตอรี่

• ไฟและแบตเตอรี่ถูกวางในตาราง
• คุณสามารถเชื่อมต่อแสงหรือแบตเตอรี่กับแสงหรือแบตเตอรี่ที่ใกล้ที่สุดกับทิศเหนือทิศใต้ทิศตะวันออกและทิศตะวันตก
• แบตเตอรี่สามารถเชื่อมต่อได้ไม่ จำกัด จำนวน
• แสงแต่ละดวงระบุจำนวนการเชื่อมต่อที่ต้องการ คุณต้องให้ตรงกับการเชื่อมต่อที่หลายต่อแสงที่
• คุณสามารถสร้างการเชื่อมต่อเดี่ยวหรือการเชื่อมต่อสองครั้งระหว่างสองไฟ (หรือแสงและแบตเตอรี่)
• สายไม่สามารถข้ามได้
• จะต้องมีเส้นทางจากแต่ละแสงไปยังแบตเตอรี่
• มีโซลูชันที่ถูกต้องอย่างน้อยหนึ่งรายการที่รับประกันว่ามีอยู่

เมื่อระบุตำแหน่งของแบตเตอรี่และแสงแต่ละครั้งและจำนวนการเชื่อมต่อที่แต่ละแสงต้องใช้ให้เชื่อมต่อระหว่างกันที่ยอมรับคุณสมบัติเหล่านี้

เงื่อนไขการชนะ

นี่คือรหัสกอล์ฟดังนั้นรหัสที่สั้นที่สุดในแต่ละภาษาจะชนะ

กรณีทดสอบ

I / O ยืดหยุ่นตามปกติ

สำหรับอินพุตฉันจะใช้อาร์เรย์ 2d ขนาดของกริดที่เก็บจำนวนเต็มบวกสำหรับไฟศูนย์สำหรับพื้นที่ว่างและ -1 สำหรับแบตเตอรี่ อีกทางเลือกที่ดีอาจเป็นรายการของแสงที่แสงเป็น tuple ที่มีตำแหน่งของแสงและจำนวนการเชื่อมต่อที่จำเป็น

สำหรับผลลัพธ์ฉันจะใช้รายการการเชื่อมต่อที่การเชื่อมต่อเป็น tuple ที่มีตำแหน่งเริ่มต้นและตำแหน่งสิ้นสุด หากการเชื่อมต่อเป็นสองเท่าฉันจะมี 2 รายการในรายการ (ตัวเลือกอื่นคือการรวมพารามิเตอร์นี้ใน tuple) อีกตัวเลือกที่ดีอาจเป็นรูปแบบกริด

หากคุณกำลังใช้ระบบพิกัดคุณอาจระบุดัชนีเริ่มต้นและตำแหน่งที่คุณจัดทำดัชนี ตัวอย่างของฉันจะได้รับการจัดทำดัชนี 0 และใช้ (0, 0) เป็นมุมบนซ้าย (แถว, คอลัมน์) (ฉันใช้ {} เพียงเพื่อแนะนำตัวคั่นประเภทอื่นดังนั้นจึงง่ายต่อการอ่านไม่ใช่เพราะมีการตั้งค่าไว้)

นี่คือมุมมองกราฟิกของกรณีทดสอบ: การทดสอบ 1-12

ทดสอบ 1:

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

ทดสอบ 2:

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

ทดสอบ 3:

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

ทดสอบ 4:

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

ทดสอบ 5:

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

การทดสอบ 6:

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

ทดสอบ 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)}]

การทดสอบ 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)}]

การทดสอบ 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 ]

การทดสอบ 10:

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

ทดสอบ 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 ]

ทดสอบ 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 ไบต์

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

ลองออนไลน์!

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