Bisakah saya merangkai semua kabel dan adaptor saya menjadi satu?


30

Misalkan suatu hari Anda menggali melalui kotak besar kabel dan adaptor komputer yang tidak digunakan (USB ke USB mini, VGA ke DVI, dll.). Ada kabel kusut di mana-mana membuat berantakan, dan Anda bertanya-tanya apakah Anda bisa menyederhanakan hal-hal dengan menyatukan semua kabel dalam satu untaian panjang, dan kemudian menggulungnya.

Pertanyaannya adalah, mungkinkah menghubungkan semua kabel dan adaptor Anda dalam satu garis panjang seperti ini? Jelas tidak selalu mungkin, misalnya jika Anda hanya memiliki dua kabel dengan colokan yang sama sekali berbeda, mereka tidak dapat dihubungkan bersama. Tetapi jika Anda memiliki kabel ketiga yang dapat terhubung ke keduanya, maka Anda dapat merangkai semua kabel Anda.

Anda tidak peduli tentang jenis colokan yang ada di ujung untai semua kabel. Mereka tidak perlu saling menyambungkan untuk membentuk lingkaran. Anda hanya ingin tahu apakah membuat untai semua kabel itu mungkin, dan jika ya, bagaimana cara melakukannya.

Tantangan

Tulis program atau fungsi yang menggunakan string multiline di mana setiap baris menggambarkan salah satu kabel yang Anda miliki. Kabel terdiri dari satu atau lebih garis putus-putus ( -), dengan colokan di kedua ujungnya. Sebuah plug selalu merupakan salah satu dari 8 karakter ()[]{}<>.

Jadi ini beberapa kabel yang valid:

>->
(--[
}-{
<-----]
(---)

Tapi ini bukan:

-->
(--
)--
[{
---

Saat menghubungkan kabel, hanya colokan dengan tipe braket yang sama persis yang dapat dihubungkan bersamaan.

Jadi ini beberapa koneksi kabel yang valid:

...---((---...
...---))---...
...---]]---...
...---{{---...
...---<<---...

Dan ini tidak valid:

...---()---...
...---)(---...
...---{]---...
...---{[---...
...---><---...
...--->)---...

Jika semua kabel dalam input dapat disusun ulang dan dilampirkan bersama dalam satu untai panjang, maka hasilkan untai itu ke stdout pada satu baris (dengan baris tambahan opsional). Ketika ada beberapa solusi, Anda dapat memilih salah satu dari mereka untuk dihasilkan. Jika membuat untai tunggal tidak dimungkinkan, maka tidak menghasilkan apa-apa (atau mengeluarkan string kosong dengan baris baru tambahan opsional).


Misalnya, jika inputnya adalah

[-->
{---]
>----{

outputnya bisa

[-->>----{{---]

di mana semua kabel dirangkai.

Namun jika inputnya adalah

[-->
{---]

kabel tidak dapat dihubungkan sehingga tidak akan ada output.


Perhatikan bahwa kabel dapat dibalik sebanyak yang diperlukan untuk membuat koneksi. mis [-->dan <--]secara efektif kabel yang sama karena mereka dapat membuat jenis koneksi yang sama. Beberapa output mungkin bergantung pada membalik kabel input.


Sebagai contoh

(-[
}--]

bisa memiliki output

(-[[--{

di mana kabel kedua dibalik, atau

}--]]-)

di mana kabel pertama dibalik.

(Perhatikan bahwa secara umum membalik seluruh output valid karena sama seperti membalikkan setiap kabel secara individual.)


Panjang kabel dalam output tentu saja harus sesuai dengan panjang kabel input yang sesuai. Tetapi kabel dapat disusun ulang dan diputar sebanyak yang Anda inginkan untuk membuat untai semua kabel. Input akan selalu mengandung setidaknya satu kabel.

Kode terpendek dalam byte menang.

Uji Kasus

Kasus dengan output:

[-->
{---]
>----{
gives
[-->>----{{---]
or
[---}}----<<--]

(-[
}--]
gives
(-[[--{
or
}--]]-)

(-)
gives
(-)

[--{
gives
[--{
or
}--]

[-]
]-[
gives
[-]]-[
or
]-[[-]

[----->
)------------[
{--<
}---)
could give
[----->>--}}---))------------[
or
>--}}---))------------[[----->
or
}---))------------[[----->>--}
or
{--<<-----]]------------((---{
etc.

>-->
>->
>--->
could give
>-->>->>--->
or
>--->>-->>->
or
>->>-->>--->
or
<--<<---<<-<
etc.

(-]
]->
>-}
}-)
)-[
[-<
<-{
{-(
could give
(-]]->>-}}-))-[[-<<-{{-(
or
{-((-]]->>-}}-))-[[-<<-{
or
<-{{-((-]]->>-}}-))-[[->
etc.

Kasing tanpa keluaran:

[-->
{---]

[-]
[-]

(-]
]->
}-)

>->
>-->
]---]

[-------------------]
]-------------------[
[-----------------]
[-----------------]

{--[
]--}

6
sekotak besar kabel dan adaptor komputer yang tidak digunakan. Itu membuat saya merasa lebih baik - saya bukan satu-satunya. Sebenarnya saya punya beberapa kotak ini.
Trauma Digital

tetapi bagaimana jika Anda mencolokkan kabelnya sendiri?
anOKsquirrel

Apakah kabel dijamin semua valid?
R. Kap

@ R.Kap Ya mereka
Calvin Hobbies

Jawaban:


10

Tidak dapat dibaca , 3924 byte

Ini adalah pertama kalinya saya menerapkan struktur mirip panggilan-tumpukan di Unreadable.

(Versi pertama ini adalah lebih dari 5300 byte, hanya untuk memberikan gambaran tentang seberapa banyak saya bermain golf ini.)

'"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ '"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "'" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "'"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" '"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" '"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "'" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" '"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" '"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" '"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" '"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "'" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" '"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" '"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "'"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" '"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "'"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " '"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ""'" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" '"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " '"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "'"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" '"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " '"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "'" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "'" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ""'"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "'" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ""'"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" '"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ""'"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "'"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "

Penjelasan

Pertimbangkan contoh input ini:

>--{
[---}

Sepanjang sebagian besar eksekusi, rekaman itu ditata sebagai berikut:

  • Sel 0 hingga 5 adalah lokasi untuk berbagai variabel.

  • Sel 6 dan seterusnya berisi semua informasi tentang set kabel di kotak Anda:

    contoh tata letak kaset

  • Sel-sel yang tersisa setelah "zero terminator" berisi tumpukan. Setiap "stackframe" adalah sel tunggal yang menunjuk ke sel pertama kabel (sel "steker awal"). Dalam contoh di atas, ketika program memutuskan telah menemukan solusi, tumpukan akan berisi 6 (mengacu pada >--{, kabel pertama) dan 21 (merujuk ke {---], cermin dari kabel kedua).

Program ini berlangsung dalam tiga tahap utama:

  1. Baca seluruh input dan hasilkan struktur di atas, termasuk semua kabel cermin.
  2. Coba semua kombinasi (tetapi hentikan jika solusi ditemukan).
  3. Jika solusi ditemukan, output itu.

Tahap pertama (baca input dan buat struktur kabel) hanya menggunakan sel # 1 (yang akan saya panggil p) dan # 2 (yang akan saya panggil ch) dan beroperasi dalam loop sementara sebagai berikut:

  • Sementara kondisi: bertambah p6, baca karakter berikutnya (mulai plug) ke dalam sel *p, dan periksa tidak -1(EOF).

  • Baca karakter selanjutnya *(p+2), dan hitung *(p+1), sampai kita menemukan apa pun selain -(tanda hubung). Pada titik itu, *(p+1)akan berisi jumlah tanda hubung (panjang kabel) dan *(p+2)karakter non-tanda hubung terakhir (steker akhir). (Kami juga menyalin karakter tanda hubung ke sel # 5 sehingga kami dapat mengakses kode ASCII ini nanti pada tahap output.)

  • Dalam loop sementara, cari steker cermin dan simpan di *(p+3), lalu tambahkan p2, hingga *pnol. Loopnya terlihat seperti ini di pseudocode:

    while (ch = *p) {
        *(p+3) = (ch -= 40) ? (ch -= 1) ? (ch -= 19) ? (ch -= 31) ? ch-32 ? *p-2 : *p+2 : *p+2 : *p+2 : *p-1 : *p+1
        p += 2
    }
    
  • Loop ini akan selalu melakukan dua iterasi (steker awal dan steker akhir) dan menyimpan hasilnya di sel keempat dan keenam kabel ini. Sekarang, jika Anda memperhatikan, Anda menyadari bahwa sel keenam memang lokasi yang benar untuk steker ujung cermin, tetapi steker awal cermin ada di sel yang berlabel "boolean menunjukkan kabel asli". Ini OK karena kita hanya perlu sel ini menjadi nilai bukan nol.

  • Karena pbaru saja bertambah total 4, sekarang menunjuk ke sel berlabel "kabel penunjuk boolean sedang digunakan". Setel *(p+3)ke nilai *(p-1). Ini menempatkan plug awal cermin di tempat yang tepat.

  • Baca (dan buang) satu karakter lagi (yang kami harapkan menjadi baris baru, tetapi program tidak memeriksanya).

pawalnya dimulai pada 0 tetapi bertambah 6 di dalam kondisi while, dengan demikian data kabel dimulai pada sel # 6. pbertambah 4 di dalam badan loop, dan dengan demikian total 10 untuk setiap kabel, yang persis apa yang kita butuhkan.

Selama tahap kedua, sel # 0-4 ditempati oleh variabel yang saya akan menelepon a, p, q, m, dan notdone. (Sel # 5 masih mengingat kode ASCII dari tanda hubung.)

Untuk bersiap-siap untuk tahap 2, kita perlu mengatur *pkembali ke 0 (sel berlabel "zero terminator") sehingga dapat bertindak sebagai terminator untuk daftar kabel; kami juga mengatur q(yang merupakan penunjuk tumpukan kami) ke p+1(yaitu sel setelah "nol terminator"; ini adalah tempat tumpukan dimulai); *qke 1 (item pertama di stack; mengapa 1 akan terlihat kemudian); dan notdoneke 1. Semua ini dilakukan dalam satu pernyataan:

*p = (notdone = *(q = p+1) = 1)-1

Tahap kedua juga loop sementara. Kondisinya sederhana notdone. Dalam setiap iterasi loop sementara itu, salah satu dari empat hal berikut ini dapat terjadi:

  1. Kami menemukan bahwa semua kabel ditandai "sedang digunakan". Ini berarti kami telah menemukan solusi (yang diwakili oleh konten tumpukan saat ini).
  2. Kita dapat maju *qke kabel lain yang memenuhi syarat (yang kami segera tandai sebagai "sedang digunakan" bersama dengan kembarannya) dan kemudian berulang (yaitu membuat susunan kerangka baru).
  3. Kami tidak dapat maju *qkarena tidak ada kabel yang memenuhi syarat lebih lanjut, jadi kami perlu melacak kembali (menghapus stackframe dan menandai kabel sebelumnya dan kembarannya sebagai tidak lagi "digunakan").
  4. Kami tidak dapat maju *qkarena tidak ada kabel yang memenuhi syarat lebih lanjut dan kami tidak dapat mundur karena kami telah mencapai bagian bawah tumpukan. Ini berarti tidak ada solusi.

Badan loop memeriksa masing-masing dari empat kondisi ini dalam urutan ini. Berikut detailnya:

  1. Atur mdan pke 1 dan dalam satu loop sementara, bertambah p5 (sehingga iterasi melalui kabel) dan periksa apakah *(p+4)("digunakan") diatur. Jika tidak, setel mke 0. Pada akhir lingkaran itu, mberi tahu kami jika semua kabel sedang digunakan. Jika demikian, atur notdoneke 0 untuk mengakhiri loop utama. Jika tidak, lanjutkan pada langkah 2 di bawah ini.

  2. Setel pke *q(kabel di bagian atas tumpukan) dan dalam beberapa saat mirip dengan yang di atas, tambahkan p5 untuk beralih melalui kabel. Mulai dari *qmemastikan kami hanya mempertimbangkan yang belum kami pertimbangkan sebelumnya; Namun, ingat bahwa nilai awal untuk stackframe baru adalah 1, jadi kabel pertama yang dilihat adalah yang ada di sel 6, yang memang merupakan kabel pertama.

    Untuk setiap kabel, kita perlu memeriksa *(p+4)untuk memastikan bahwa itu belum digunakan, dan juga apakah *(q-1) nol (artinya kita berada di bagian bawah tumpukan, sehingga tidak ada kendala pada steker start), atau *p (kabel mulai steker) sama dengan *(*(q-1)+2)(steker ujung kabel tepat di bawah di atas tumpukan). Kami memeriksa kesetaraan dengan mengatur ake *(*(q-1)+2)dan mke *p+1dan kemudian menurunkan keduanya dalam loop sementara. Itu +1karena mdikurangi di dalam kondisi sementara, sehingga dikurangi sekali lagi a. Jika anol di akhir ini, kedua colokan sama.

    Dengan demikian, jika salah satu dari *(q-1)nol atau perbandingan kesetaraan berhasil, kabel memenuhi syarat. Atur *quntuk pmengganti kabel di bagian atas tumpukan dengan yang baru; setel mke yang sama untuk menunjukkan bahwa kami menemukan kabel yang cocok; dan kemudian penurunan p. Penurunan itu adalah sedikit trik untuk menyebabkan loop sementara (iterasi melalui kabel) berakhir lebih awal; ia akan bertambah p5 lagi, sehingga membawanya ke sel yang berisi bendera "sedang digunakan" kabel ini, dan kami tahu itu nol karena kami baru saja memeriksanya. Akhirnya, setelah perulangan kabel sementara loop, kami memeriksa apakah mtidak nol. Jika demikian, kami menemukan kabel yang cocok dan pmenunjuk pada bendera "sedang digunakan" untuk kabel yang cocok itu. Setel ke 1 untuk menandainya sebagai sedang digunakan. Juga diatur*(*(p-1) ? p+5 : p-5)ke 1 untuk menandai kembarannya seperti yang digunakan. Akhirnya, tambahkan qdan atur yang baru *qke 1 untuk membuat bingkai stack baru.

  3. Jika, setelah perulangan kabel sementara loop, kami temukan mmenjadi nol, tidak ada lagi kabel yang cocok, jadi kami perlu mundur. Pengurangan quntuk turun ke tumpukan dan memeriksa apakah masih menunjuk pada kabel (nilai bukan nol). Jika demikian, tandai kabel dan kembarannya karena tidak lagi digunakan. (Kami menyimpan nilai *qdalam puntuk membuat ekspresi ini lebih pendek dalam kode.)

  4. Jika, setelah decrementing q, kami menemukan bahwa itu menunjuk pada nilai nol, maka itu adalah "terminator nol", yang berarti kami telah menurunkan tumpukan. Kami menyimpulkan bahwa tidak ada solusi. Kami menetapkan notdoneke 0 untuk mengakhiri loop utama.

Tahap ketiga adalah tahap keluaran. Ada dua hal yang bisa terjadi:

  • loop utama menemukan solusi yang perlu kita hasilkan, atau
  • loop utama menyimpulkan tidak ada solusi dan kami tidak menghasilkan apa-apa.

Mudahnya, jika tidak ada solusi, padalah nol karena kami menyetelnya ke nilai *qsebelum memeriksa nol; dan jika ada adalah solusi, pmenunjuk pada “nol terminator” karena hanya mengulangi melalui kabel, sehingga kita sekarang dapat menggunakan puntuk iterate melalui stack. Jadi cukup lakukan iterate melalui stack, mengeluarkan untuk setiap kabel plug start ( *(*p)), tanda hubung (dengan mengurangi *(*p+1)dalam loop sementara; dan menggunakan kode ASCII tanda hubung yang disimpan dalam sel # 5), dan plug akhir ( *(*p+2)). Tidak masalah bahwa ini menghancurkan informasi panjang kabel; kita tidak membutuhkan itu lagi.


3

CJam, 67

qN%e!{_,2,m*\f{.{_{"()[]{}<>--"_@#1^=}%W%?}_2ew{~\W=#}%0-{;}&}~}%1<

Cobalah online

Catatan: tautan menggunakan kode terbaru dari repositori (didorong tetapi belum dirilis), karena berisi perbaikan bug.

Penjelasan:

Program hanya mencoba semua permutasi dan semua orientasi kabel.

qN%             read the input and split into lines
e!              generate all permutations
{…}%            map each permutation of cords
  _,            get the number of cords (n)
  2,m*          generate all patterns of n bits (cartesian power of [0 1])
  \f{…}         for each bit pattern and the cord permutation
    .{…}        apply the block to each bit and cord (flipping cords for bit 0)
      _         duplicate the cord
      {…}%      map each character of the cord
        "…"_    push the string of all the plugs (and 2 dashes) and duplicate it
        @#      get the index of the character in the string
        1^      XOR with 1
        =       get the character at this new index (plugs get toggled)
      W%        reverse the cord
                 the stack now has the bit, the original cord and the flipped cord
      ?         if the bit is 1, use the original cord, else use the flipped one
    _           duplicate the array of cords
    2ew         get all pairs of adjacent cords
    {…}%        map each pair of cords
      ~\        dump the 2 cords on the stack and swap them
      W=        get the right plug of the first cord
      #         find its position in the second cord (if 0, we have a match)
    0-          remove all the zeros
    {…}&        if the array is not empty (i.e. we have a mismatch)
      ;         pop the array of cords
  ~             dump all the results for this permutation on the stack
                 (to avoid nested arrays)
1<              get the first result (if any) from the array of all results

Mungkin penjelasan tentang cara kerjanya tepatnya?
Timwi

@ Timwi ok, saya juga
bermain golf

Solusi ini tidak valid karena tidak menghasilkan output apa pun untuk input (-] ]-> >-} }-) )-[ [-< <-{ {-(.
R. Kap

@ R.Kap itu menyelesaikan input itu, tetapi penerjemah online tertentu itu memiliki batas waktu (dan sangat diam tentang hal itu). Anda dapat mencobanya di sini sebagai gantinya (dan memberikan beberapa menit) atau menggunakan penerjemah java (tercepat)
aditsu

Sebenarnya, juru bahasa yang saya tautkan di atas mungkin akan membutuhkan waktu lama untuk menyelesaikan input itu. The java interpreter memecahkan dalam waktu kurang dari 1,5 menit di komputer saya.
aditsu

2

JavaScript (ES6), 206

Fungsi rekursif

f=(l,a=l.pop(),x=x=>(z='<>[]{}()')[z.indexOf(x)^1])=>l[0]?l.some((b,i)=>r=[b,x([...b].pop())+b.slice(1,-1)+x(b[0])] .some(b=>r=a[0]==[...b].pop()?b+a:b[0]==[...a].pop()?a+b:0)&&(l=[...l],l[i]=r,f(l)))?r:'':a

Lebih mudah dibaca

f=(l,a=l.pop(),x=x=>(z='<>[]{}()')[z.indexOf(x)^1])=>
  l[0]?
  l.some((b,i)=>
     r=[b,x([...b].pop())+b.slice(1,-1)+x(b[0])]
     .some(b=>r=a[0]==[...b].pop()?b+a:b[0]==[...a].pop()?a+b:0)
     &&(l=[...l],l[i]=r,f(l))
    )?r:''
 :a

Uji

f=(l,a=l.pop(),x=x=>(z='<>[]{}()')[z.indexOf(x)^1])=>l[0]?l.some((b,i)=>r=[b,x([...b].pop())+b.slice(1,-1)+x(b[0])] .some(b=>r=a[0]==[...b].pop()?b+a:b[0]==[...a].pop()?a+b:0)&&(l=[...l],l[i]=r,f(l)))?r:'':a

console.log=(...x)=>O.textContent+=x+'\n'

;[
 //OK
 ['[-->','{---]','>----{']
,['(-[','}--]']
,['(-)']
,['[--{']
,['[-]',']-[']
,['[----->',')------------[','{--<','}---)']
,['>-->','>->','>--->']
,['(-]',']->','>-}','}-)',')-[','[-<','<-{','{-(']
 //KO
,['[-->','{---]']
,['[-]','[-]']
,['(-]',']->','}-)']
,['>->','>-->',']---]']
,['[-------]',']-------[','[-------]','[---------]'] // shortened a little,
,['{--[',']--}']
].forEach(t=>{
  console.log(t+' : "'+f(t)+'"\n')
})
<pre id=O></pre>


1

Javascript, 800 Bytes

Jauh dari solusi yang dioptimalkan, tapi inilah hack cepat bersama-sama dalam javascript (tidak ada ecma5 mewah atau apa pun, karena saya tidak mengetahuinya).

function a(r){function t(r,t){var n=r.slice();return n.splice(t,1),n}function n(r){var t,n={"[":"]","]":"[",">":"<","<":">","(":")",")":"(","{":"}","}":"{"},e=r.split("").reverse();for(t=0;t<e.length;t++)n.hasOwnProperty(e[t])&&(e[t]=n[e[t]]);return e.join("")}function e(r,t){return r.unshift(t),r}var h,u,f=[];if(1==r.length)return r[0];for(h=0;h<r.length;h++){var l=r[h],i=t(r,h),c=l.charAt(0),g=l.charAt(l.length-1);for(u=0;u<i.length;u++){var o=i[u],s=o.charAt(0),p=o.charAt(o.length-1);c==p&&f.push(e(t(i,u),o+l)),g==s&&f.push(e(t(i,u),l+o)),o=n(o),s=o.charAt(0),p=o.charAt(o.length-1),c==p&&f.push(e(t(i,u),o+l)),g==s&&f.push(e(t(i,u),l+o))}}if(f.length<1)return!1;for(h=0;h<f.length;h++){if(1===f[h].length)return f[h][0];f[h]=a(f[h])}for(h=0;h<f.length;h++)if(f[h]!==!1)return f[h];return!1}

Tidak digabungkan, ini dia ... Saya yakin paling tidak 2 untuk loop tidak perlu di sini dan memeriksa untuk input elemen tunggal di bagian atas dan satu elemen yang cocok di bagian bawah adalah stanky ... tetapi tampaknya berfungsi dan memproses input uji.

function a(inputs)
{
	var i, ii, matches = [];
	if (inputs.length == 1) {
		return inputs[0];
	}
	// For each of the elements in inputs (e1)
	for (i = 0; i < inputs.length; i++) {
		var e1 = inputs[i],
			others = except(inputs,i),
			e1s = e1.charAt(0),
			e1e = e1.charAt(e1.length-1);
		// Compare to each of the other elements in inputs (e2)
		for (ii = 0; ii < others.length; ii++) {
			// get the start and end of the elements to compare (e1s,e1e,e2s,e2e)
			var e2 = others[ii],
				e2s = e2.charAt(0),
				e2e = e2.charAt(e2.length-1);
			// if any of them match up (e1s == e2e || e1s == e2s || e1e == e2s || e1e = e2e)
			// Make a new array of inputs containing the joined elements (as a single element) and all other elements which might join with them
			if (e1s == e2e) {
				matches.push(addTo(except(others,ii),e2+e1));
			}
			if (e1e == e2s) {
				matches.push(addTo(except(others,ii),e1+e2));
			}
			e2 = flip(e2);
			e2s = e2.charAt(0);
			e2e = e2.charAt(e2.length-1);
			if (e1s == e2e) {
				matches.push(addTo(except(others,ii),e2+e1));
			}
			if (e1e == e2s) {
				matches.push(addTo(except(others,ii),e1+e2));
			}
		}
	}

	if (matches.length < 1) {
		return false;
	}

	for (i = 0; i < matches.length; i++) {
		if (matches[i].length  === 1) {
			return matches[i][0];
		} else {
			matches[i] = a(matches[i]);
		}
	};

	for (i = 0; i < matches.length; i++) {
		if (matches[i] !== false) {
			return matches[i];
		}
	};

	return false;

	function except(list,idx)
	{
		var newList = list.slice();
		newList.splice(idx,1);
		return newList;
	}
	function flip(s) {
		var replacements = {
			'[':']',
			']':'[',
			'>':'<',
			'<':'>',
			'(':')',
			')':'(',
			'{':'}',
			'}':'{'
		}, i, a = s.split('').reverse();
		for (i = 0; i < a.length; i++) {
			if (replacements.hasOwnProperty(a[i])) {
				a[i] = replacements[a[i]];
			}
		}

		return a.join('');
	}
	function addTo(arr,newEl)
	{
		arr.unshift(newEl);
		return arr;
	}
}


1
Anda dapat mengubah nama fungsi untuk menyimpan beberapa byte. stackoverflow.com/questions/6156319/…
noɥʇʎԀʎzɐɹƆ

1
hindari .charT di versi JavaScript apa pun. s.charAt(x)===s[x]
edc65

1

Python 3, 217 byte

from itertools import*
a='()[]{}<>'
all(any(c[-1]!=d[0]for c,d in zip(q,q[1:]))or print(''.join(q))for p in permutations(open(0))for q in product(*[(c[:-1],a[a.find(c[-2])^1]+c[-3:0:-1]+a[a.find(c[0])^1])for c in p]))

( Demo pada Ideone )


Bagaimana ini mengambil input?
R. Kap

@ R.Kap Di stdin, satu kabel per baris.
Anders Kaseorg

Sepertinya tidak, setidaknya ketika saya menjalankannya.
R. Kap

Juga, seberapa cepat ia dapat menemukan jawaban yang benar (-] ]-> >-} }-) )-[ [-< <-{ {-(?
R. Kap

@ R.Kap Lihat demo pada Ideone untuk contoh mengambil input dan menghasilkan output. (Ini mungkin tidak bekerja pada Windows, jika itu yang Anda coba lakukan?) Ini berjalan ~ langsung pada test case Anda. Tentu saja ada kasus-kasus yang membutuhkan waktu yang eksponensial.
Anders Kaseorg

0

Lua, 477 byte

function r(s)return s:reverse():gsub("[()%[%]{}<>]",{["("]=")",[")"]="(",["["]="]",["]"]="[",["{"]="}",["}"]="{",["<"]=">",[">"]="<"})end
function a(c,b)for i, v in next,b do
m=c:sub(-1,-1)n=v:sub(1,1)o=r(c):sub(-1,-1)p=r(v):sub(1,1)l=table.remove(b,i)if m==n then
return a(c..v,b)elseif o==n then
return a(r(c)..v,b)elseif m==p then
return a(c..r(v),b)elseif o==p then
return a(r(c)..r(v),b)end
table.insert(b,i,l)end
return#b>0 and""or c
end
print(a(table.remove(arg,1),arg))

Menerima tali sebagai argumen baris perintah


0

Python 3.5, 448 432 427 424 286 311 byte:

( +25 karena ada bug di mana output mungkin lebih lama dari seharusnya untuk beberapa input )

def g3(z):
 B=z.split();M='i[::-1].translate({41:40,40:41,125:123,123:125,62:60,60:62,93:91,91:93})';f=B+[eval(M)for i in B if eval(M)not in B];d=[f.pop(0)]
 for h in d:
  try:[d.append([f.pop(f.index(c))for c in f if h[-1]==c[0]][0])if len(d)<len(B)else E]
  except:break
 return''.join(d)if len(d)>=len(B)else''

Bekerja dengan sempurna! kecuali input dengan 7 atau lebih nilai. Butuh waktu lama bagi mereka, kemungkinan besar karena itu harus melalui semua permutasi input ditambah input terbalik . Saya akan mencoba untuk memperbaikinya jika dan ketika saya bisa, tetapi untuk sekarang, ini tampaknya cukup baik. Semuanya baik sekarang! Kalau saja saya entah bagaimana bisa menggunakan try-exceptblok itu dalam pemahaman daftar, itu bisa sedikit lebih pendek, dan terlihat jauh lebih bagus. Meskipun demikian, sekarang bekerja untuk semua kasus uji, dan, terbaik dari semua, ia menggunakan tidak ada impor! :)

Cobalah online! (Ideone) (284 byte di sini)

(Kiat: Untuk mencobanya, cukup pilih "garpu", lalu masukkan pilihan Anda, pisahkan spasi , dan pilih "jalankan")

Penjelasan

Pada dasarnya, yang terjadi adalah ...

  1. Daftar,, Bdibuat dari input dengan membaginya di spasi putih menjadi "kabel" komponennya.
  2. Madalah string yang saya buat yang, ketika dievaluasi, mengembalikan daftar berdasarkan Byang berisi semua kabel, tapi kali ini mundur .
  3. Daftar yang dibuat Mpada akhirnya disatukan dengan Bdirinya sendiri untuk membuat daftar f,, dengan semua orientasi yang mungkin dari "kabel".
  4. Daftar lain, ddibuat, yang akan diinisialisasi dengan nilai pertama (nilai f[0]) dari f.
  5. Akhirnya, semua nilai di diterasi melalui, dan karakter terakhir setiap nilai dibandingkan dengan karakter pertama dari setiap elemen f, dan ketika kecocokan ditemukan, karakter itu muncul (atau dihapus) dan dikembalikan dari daftar f. Ini terjadi sampai a IndexErrordinaikkan, atau panjang daftar dmelebihi Bdan a NameErrordinaikkan setelah panggilan ke E, keduanya ditangani, dan kemudian disi daftar digabungkan ke dalam string dan dikembalikan selama panjang daftar dlebih dari atau sama dengan panjang daftar B. Jika tidak, string kosong dikembalikan ( ''), karena dtidak sama panjang dengan Bmenandakan bahwa semua "kabel" dalam daftarB tidak bisa digabung menjadi satu "kabel" panjang.

@ KennyLau Apa yang Anda ubah? Dari apa yang saya lihat, Anda baru saja menambahkan <!-- language: lang-python -->. Apa yang berubah?
R. Kap

Itu dapat mengaktifkan penyorotan sintaks untuk kode Anda.
Leaky Nun

@ KennyLau Wow, itu keren. Saya bertanya-tanya bagaimana saya akan melakukannya di PPCG. Sekarang saya tahu! Terima kasih! :)
R. Kap
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.