Tüm kablolarımı ve adaptörleri bir araya getirebilir miyim?


30

Bir gün kullanılmamış bilgisayar kabloları ve adaptörleri (USB - USB mini, VGA - DVI, vb.) Kutucuğunuzu kazdığınızı varsayalım. Her yerde karışıklık yaratan karışık kablolar var ve tüm kabloları tek bir uzun telin içine birleştirerek işleri basitleştirip birleştiremeyeceğinizi ve ardından sadece kabloları toplayıp toplayamayacağınızı merak ediyorsunuz.

Mesele şu ki, tüm kablolarınızı ve adaptörlerinizi bu kadar uzun bir hatta bağlamak mümkün mü? Açıkçası her zaman mümkün olmuyor, örneğin tamamen farklı fişe sahip sadece iki kabloya sahipseniz, birbirlerine bağlanamadılar. Ancak, her ikisine de bağlanabilecek üçüncü bir kablo varsa, tüm kablolarınızı birbirine bağlayabilirsiniz.

Tüm kordonun ucunda ne tür fişlerin bulunduğunu umursamıyorsunuz. Bir döngü oluşturmak için birbirlerine bağlanmaları gerekmez. Sadece tüm tel şeridi yapmanın mümkün olup olmadığını ve eğer öyleyse, nasıl yapılacağını bilmek istersiniz.

Meydan okuma

Her satırın sahip olduğunuz kablolardan birini gösterdiği çok satırlı bir dizgede geçen bir program veya işlev yazın. Bir kablo, -her iki ucunda fiş bulunan bir veya daha fazla çizgiden ( ) oluşur. Bir fiş her zaman 8 karakterden biridir ()[]{}<>.

Yani bunlar bazı geçerli kablolar:

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

Ancak bunlar değil:

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

Kabloları bağlarken, yalnızca aynı braket tipine sahip fişler birlikte bağlanabilir.

Yani bunlar bazı geçerli kablo bağlantıları:

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

Ve bunlar geçersiz:

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

Girişteki tüm kablolar uzun bir iplikçikte yeniden düzenlenebilir ve eklenebilirse, o zaman bu ipliği bir sıradaki kıtlığa (isteğe bağlı izleyen bir yeni satır ile) çıkartın. Birden fazla çözüm olduğunda, bunlardan herhangi birini çıktı olarak seçebilirsiniz. Tek bir iplikçik yapmak mümkün değilse, o zaman hiçbir şey çıktı (veya isteğe bağlı izleyen bir yeni satır ile boş bir dize çıktı).


Örneğin, giriş

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

çıktı olabilir

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

tüm kabloların bir araya getirildiği yer.

Ancak giriş olsaydı

[-->
{---]

kablolar bağlanamaz, bu yüzden çıkış olmaz.


Bağlantıların yapılması için kabloların gerektiği kadar çevrilebileceğini unutmayın. örn. [-->ve <--]aynı kordlardır çünkü aynı tipte bağlantıları yapabilirler. Bazı çıkışlar giriş kablolarını çevirmeye bağlı olabilir.


Örneğin

(-[
}--]

çıktı olabilir

(-[[--{

ikinci kordonun çevrildiği yer veya

}--]]-)

ilk kordonun çevrildiği yer.

(Genel olarak tüm çıktının çevrilmesinin geçerli olduğunu unutmayın, çünkü başlangıçta her kordonun ayrı ayrı çevrilmesiyle aynıdır.)


Çıkıştaki kabloların uzunlukları elbette karşılık gelen giriş kablolarının uzunluklarıyla eşleşmelidir. Ancak tüm kabloyu yapmak için kablolar istediğiniz kadar yeniden sıralanabilir ve çevrilebilir. Giriş her zaman en az bir kablo içerecektir.

Bayt cinsinden en kısa kod kazanır.

Test Kılıfları

Çıkışlı durumlar:

[-->
{---]
>----{
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.

Çıktısız durumlar:

[-->
{---]

[-]
[-]

(-]
]->
}-)

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

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

{--[
]--}

6
kullanılmamış bilgisayar kabloları ve adaptörleri büyük bir kutu Bu beni daha iyi hissettiriyor - tek kişi ben değilim. Aslında bu kutulardan birkaçım var.
Dijital Travma

ama ya kendine bir kablo taktıysanız?
anOKsquirrel

Kabloları Are garanti herkese geçerli olacak?
R. Kap,

@ R.Kap Evet onlar
Calvin'in Hobileri

Yanıtlar:


10

Okunamıyor , 3924 bayt

Bu, Unreadable'da bir çağrı-yığma-benzeri yapıyı ilk kez uygulamam.

(Bunun ilk versiyonu 5300 bayttan fazlaydı, sadece ne kadar golf oynadığımı görmek için.)

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

açıklama

Bu örnek girişi göz önünde bulundurun:

>--{
[---}

Yürütmenin çoğu boyunca, bant şu şekilde düzenlenir:

  • 0 ila 5 hücreleri, çeşitli değişkenlerin yerleridir.

  • Hücre 6'dan sonra, kutunuzdaki kablo setiyle ilgili tüm bilgileri içerir:

    kaset düzeni örneği

  • “Sıfır sonlandırıcı” dan sonra kalan hücreler yığını içerir. Her "yığın kare", bir kablonun ilk hücresini (“başlangıç ​​fişi” hücresi) gösteren tek bir hücredir. Yukarıdaki örnekte, program bir çözüm bulduğuna karar verdiğinde, istif 6 ( >--{ilk kabloya atıfta bulunacak ) ve 21 ( {---]ikinci kablonun aynasına atıfta bulunarak) içerecektir .

Program üç ana aşamada ilerler:

  1. Girişin tamamını okuyun ve tüm yansıtılmış kablolar da dahil olmak üzere yukarıdaki yapıyı oluşturun.
  2. Tüm kombinasyonları deneyin (ancak bir çözüm bulunursa durun).
  3. Bir çözüm bulunursa, çıktı verin.

İlk aşama (giriş oku ve kablo yapısını oluştur) yalnızca # 1 (arayacağım p) ve # 2 ( arayacağım ) hücrelerini kullanır chve aşağıdaki gibi bir süre döngüsü içinde çalışır:

  • Koşulu: p6'ya kadar artırırken , sonraki karakteri (fişi başlat) hücreye oku ve *pbunun -1(EOF) olmadığını kontrol et .

  • Sonraki karakterleri okuyunuz *(p+2)ve (tire) *(p+1)dışında herhangi bir şeyle karşılaşana kadar bunları sayınız -. Bu noktada, *(p+1)kısa çizgi sayısını (kablo uzunluğu) ve *(p+2)kısa çizgi olmayan karakteri (son tıkacı) içerecektir . (Ayrıca, tire karakterlerini 5 numaralı hücreye kopyalarız, böylece bu ASCII koduna daha sonra çıkış aşamasında erişebiliriz.)

  • Bir süre döngü içinde, ayna fişini bulun ve saklayın *(p+3), sonra sıfır polana kadar 2 *parttırın. Döngü sözde kodunda şöyle görünür:

    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
    }
    
  • Bu döngü her zaman iki yineleme gerçekleştirir (başlangıç ​​fişi ve bitiş fişi) ve sonuçları bu kablonun dördüncü ve altıncı hücrelerinde saklar. Şimdi, dikkat ederseniz, altıncı hücrenin gerçekten yansıtılmış uç fişi için doğru konum olduğunun farkındasınız, ancak yansıtılmış başlangıç ​​fişi “orijinal kabloyu gösteren boolean” etiketli hücrede. Bu tamam, çünkü bu hücreye yalnızca sıfır olmayan bir değer olarak ihtiyacımız var.

  • Yana psadece 4 toplam artırılır edilmiş, artık etiketli “boole belirten kablo kullanılıyor” hücrenin işaret ediyor. Set *(p+3)değerine *(p-1). Bu, yansıtılmış başlatma fişini doğru yere yerleştirir.

  • Bir karakter daha okuyun (ve atın) (yeni bir satır olmasını bekliyoruz, ancak program bunu kontrol etmiyor).

pbaşlangıçta 0'da başlar, ancak süre içinde 6 ile artar, böylece kablo verileri # 6 hücresinde başlar. pDöngü gövdesi içinde 4 arttırılmıştır ve bu nedenle her bir kablo için toplamda 10 olan tam ihtiyacımız olan şeydir.

İkinci aşamada, hücreler # 0-4 arayacağım o değişkenler tarafından işgal edilmiştir a, p, q, m, ve notdone. (Hücre # 5, hala tirenin ASCII kodunu hatırlar.)

Aşama 2'ye hazır olmak için, *p0'a (“sıfır sonlandırıcı” etiketli hücre) geri dönmemiz gerekir, böylece kablo listesine sonlandırıcı olarak davranabilir; Biz de q(yığın göstericimiz olan) p+1(yani “sıfır sonlandırıcısından” sonraki hücreye; yığının başladığı yere) ayarladık ; *q1'e (yığındaki ilk öğe; neden 1 daha sonra görünecek); ve notdone1. Tüm bunlar tek bir açıklamada yapılır:

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

İkinci aşama aynı zamanda bir süre döngüsüdür. Durumu basit notdone. Döngü sırasında bunun her yinelemesinde, aşağıdaki dört şeyden herhangi biri olabilir:

  1. Tüm kabloların “kullanımda” olarak işaretlendiğini görüyoruz. Bu, (mevcut yığın içeriği tarafından temsil edilen) bir çözüm bulduğumuzu gösterir.
  2. Bir *qbaşka uygun kabloya geçebiliriz (derhal ikiziyle birlikte “kullanımda” olarak işaretleriz) ve sonra tekrar bağlar (yani yeni bir yığın çerçevesi oluşturur).
  3. Biz ilerleyemez *qbaşka uygun kablo bulunduğundan, biz dönüş yolu gerek böylece ( “kullanımda” artık önceki kablo ve onun ikiz bir StackFrame çıkarıp işaretlemek).
  4. İlerleyemeyiz *qçünkü başka uygun kablo mevcut değildir ve yığının dibine ulaştığımız için geriye gidemiyoruz. Bu, çözüm olmadığı anlamına gelir.

Döngü gövdesi bu dört koşulun her birini bu sıraya göre kontrol eder. İşte detaylar:

  1. Ayar mve p1 ve bir süre döngüsü, artışında p5 ile (böylece kablolar yineleme) ve kontrol *(p+4)( “kullanımda”) olarak ayarlanır. Değilse, m0 olarak ayarlayın . Bu döngünün sonunda, mtüm kabloların kullanımda olup olmadığını bize bildirir. Öyleyse notdone, ana çevrimi sonlandırmak için 0'a ayarlayın . Aksi takdirde, aşağıdaki 2. adımda devam edin.

  2. Set piçin *qartışı, (yığının üst kablo) ve yukandakine benzer bir süre döngü pkablolar üzerinden yineleme için 5 ile. Başlamak, *qyalnızca daha önce göz önünde bulundurmadığımız şeyleri dikkate almamızı sağlar; bununla birlikte, yeni bir yığın kare için başlangıç ​​değerinin 1 olduğunu unutmayın; bu nedenle ilk bakılan kablo, aslında ilk kablo olan hücre 6'daki değerdir.

    Her kablo için, kontrol etmeniz gerekir *(p+4)zaten kullanımda değil ve ayrıca bu sağlamak için ya *(q-1) sıfırdır, (biz yığının altındaki konum anlamına hiçbir başlangıç fişindeki kısıtlama yoktur) ya da *p (kablonun başlangıç fiş) eşittir *(*(q-1)+2)(kablonun hemen altındaki kablonun uç fişi). Biz ayarlayarak eşitlik için kontrol aetmek *(*(q-1)+2)ve mkarşı *p+1ve daha sonra bir süre döngüde hem eksiltim. +1Çünkü mo birden çok kez indirildiği, böylece iken koşulu içine indirildiği a. Bunun asonunda sıfır ise, iki fiş eşittir.

    Bu nedenle, eğer *(q-1)sıfır ya da eşitlik karşılaştırması başarılı olursa, kablo uygun olur. Set *qiçin pyenisi ile yığının üst kablo yerine; meşleşen bir kablo bulduğumuzu belirtmek için aynı olarak ayarlayın ; ve sonra azaltma p. Bu azalma, bir süre döngüsünün (kabloları tekrarlayarak) erken bitmesine neden olmak için küçük bir numaradır; ptekrar 5 artacaktır , bu yüzden bu kablonun “kullanımda” bayrağını içeren hücreye götürülür ve bunun sıfır olduğunu biliyoruz çünkü bunu kontrol ettik. Son olarak, döngü sırasındaki kablo tekrarlama işleminden sonra msıfır olup olmadığını kontrol ederiz . Öyleyse, eşleşen bir kablo bulduk ve eşleşen kablo piçin “kullanımda” bayrağını gösteriyor. Kullanımda olduğu gibi işaretlemek için 1 olarak ayarlayın. Ayrıca ayarlandı*(*(p-1) ? p+5 : p-5)kullanımda olduğu gibi ikizini işaretlemek için 1'e. Son olarak, arttırma qve ayar yeni *q1'e yeni StackFrame oluşturmak için kullanılır.

  3. Döngü sırasındaki kablo yinelemeden sonra msıfır olduğunu tespit edersek , artık eşleşen kablolar olmaz, bu nedenle geriye doğru ilerlememiz gerekir. Azaltma qhala bir kablo (sıfır olmayan bir değer) işaret eğer yığın taşıyın ve kontrol etmek için. Eğer öyleyse, bu kabloyu ve ikizi kullanımda değil olarak işaretleyin. (Biz değerini depolamak *qin pkodunda bu ifade daha kısa hale getirmek için.)

  4. Azalttıktan sonra qsıfır değerinde olduğunu tespit edersek, o zaman bu “sıfır sonlandırıcı” dır, bu da yığının altına düştüğümüz anlamına gelir. Çözüm olmadığı sonucuna vardık. notdoneAna döngüyü sonlandırmak için 0 olarak ayarladık .

Üçüncü aşama, çıktı aşamasıdır. Olabilecek iki şey var:

  • ana döngü, çıkmamız gereken bir çözüm buldu ya da
  • ana döngü, çözüm olmadığı ve hiçbir şey çıkmadığı sonucuna vardı.

Olsaydı elverişli, hiçbir çözüm, pbiz değerine ayarlayın çünkü sıfırdır *qsıfır için bu kontrol etmeden önce; ve eğer bir çözüm olsaydı , “sıfır sonlandırıcı” yı işaret ediyordup çünkü sadece kablolar arasında yineleniyordu, bu yüzden şimdi pyığının içinde yineleme yapmak için kullanabiliriz . Bu nedenle, sadece her bir kablo için başlangıç ​​fişini ( *(*p)), kısa çizgileri ( *(*p+1)bir süre döngüsünde azaltarak ve hücre # 5'de depolanan kısa çizgi ASCII kodunu ve son fişini kullanarak ) çıkaran yığın boyunca yineleyin *(*p+2). Bunun kablo uzunluğu bilgisini mahvettiğini unutmayın; artık buna ihtiyacımız yok.


3

CJam, 67

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

Çevrimiçi deneyin

Not: Bağlantı, bir hata düzeltmesi içerdiğinden, depodaki en son kodu (itti ancak henüz yayınlanmadı) kullanıyor.

Açıklama:

Program sadece tüm permütasyonları ve kabloların tüm yönlerini dener.

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

Belki de tam olarak nasıl çalıştığını bir açıklama?
Timwi

@Timwi tamam, ayrıca biraz daha
golf oynadım

Bu çözüm giriş için herhangi bir çıktı üretmediğinden geçersiz (-] ]-> >-} }-) )-[ [-< <-{ {-(.
R. Kap

@ R.Kap bu girişi çözer, ancak söz konusu çevrimiçi tercümanın zaman aşımı süresi vardır (ve bu konuda oldukça sessizdir). Bunun yerine burada deneyebilirsiniz (ve birkaç dakika verin) veya java tercümanını kullanın (en hızlı)
aditsu

Aslında, yukarıda bağladığım tercümanın muhtemelen bu girişi çözmesi uzun zaman alacaktır. Java yorumlayıcı bilgisayarımda az 1,5 dakika içinde çözer onu.
aditsu

2

JavaScript (ES6), 206

Özyinelemeli fonksiyonu

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

Daha okunabilir

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

Ölçek

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 Bayt

En iyi duruma getirilmiş bir çözüm olmaktan uzak, ancak işte javascript'te birlikte hızlıca kesmek (fantezi ecma5 veya başka bir şey değil, çünkü bilmiyorum).

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}

Ungolfed, işte burada… Eminim burada ilmek için en az 2 tane gereksizdir ve en üstte tek bir eleman girişi ve en altta tek bir eleman eşleşmesinin kontrol edilmesi risklidir ... Test girişlerini işler.

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
İşlevleri bir kaç bayttan tasarruf etmek için yeniden adlandırabilirsiniz. stackoverflow.com/questions/6156319/…
noɥʇʎԀʎzɐɹƆ

1
JavaScript'in herhangi bir sürümünde .charAt kullanmaktan kaçının. s.charAt(x)===s[x]
edc65

1

Python 3, 217 bayt

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

( İdeone Demo )


Bu nasıl girdi alıyor?
R. Kap

@ R.Kap Stdin'de hat başına bir kablo.
Anders Kaseorg

En azından koştuğum zaman gibi görünmüyor.
R. Kap

Ayrıca, doğru cevabı ne kadar hızlı bulabilir (-] ]-> >-} }-) )-[ [-< <-{ {-(?
R. Kap

@ R.Kap Girdi alan ve çıktı üreten bir örnek için Ideone'daki demosuna bakın. (Yapmaya çalıştığınız şey buysa, Windows'da çalışmayabilir?) Test vakanızda hemen çalışır. Tabii ki, üstel zaman alacağı durumlar da var.
Anders Kaseorg

0

Lua, 477 bayt

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

Kabloları komut satırı argümanları olarak kabul eder


0

Python 3.5, 448 432 427 424 286 311 bayt:

( +25, çıktının bazı girdilerde olması gerekenden daha uzun olabileceği bir hata olduğundan )

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

Mükemmel çalışıyor! 7 veya daha fazla değerli girişler hariç . Bu olanlar için uzun zaman alıyor , çünkü büyük olasılıkla girişin tüm girişleri artı girişin tersine gitmesi gerekiyor . Bunu ve ne zaman yapabilirsem düzeltmeye çalışacağım, ama şimdilik, bu yeterince iyi görünüyor. Şimdi her şey yolunda! Eğer sadece ben bir şekilde kullanabilirsin try-exceptliste anlama bloğu, biraz daha kısa olacak ve görünebilir çok daha güzel. Bununla birlikte, şimdilik çalışır tüm test durumları ve hepsinden iyi, kullandığı hiçbir ithalat! :)

Çevrimiçi deneyin! (İdeone) (buradaki 284 bayt)

(İpucu: Denemek için, sadece "çatal" ı seçin ve ardından seçeneklerinizi boşlukla ayrılmış olarak girin ve "çalıştır" ı seçin)

açıklama

Temel olarak, olan şey ...

  1. BGirişten, boşluktaki "kabloları" bileşenine bölerek bir liste oluşturulur.
  2. MDeğerlendirildiğinde, Btüm kabloları içeren bir liste döndüren , ancak bu sefer geriye dönük olan bir dizedir .
  3. Oluşturulan liste Mnihayetinde "kordonların" tüm yönelimleri olan Bbir liste oluşturmak için kendisiyle birleştirilir f.
  4. dİlk değeri (değeri f[0]) ile başlatılacak olan başka bir liste oluşturulur f.
  5. Son olarak, içindeki tüm değerler dyinelenir ve her değerin son karakteri, her bir öğenin ilk karakteri ile karşılaştırılır fve bir eşleşme bulunduğunda, bu karakter açılır (veya kaldırılır) ve listeden döndürülür f. Bu IndexError, a yükseltilinceye veya listenin uzunluğu daşılıp , her ikisinin de işlendiği çağrıdan sonra Ba yükseltilinceye kadar olur ve ardından listenin içeriği bir dizeye birleştirilir ve listenin uzunluğu daha fazla olduğu sürece döndürülür. listenin uzunluğuna eşit veya ona eşittir . Aksi takdirde, boş bir dize döndürülür ( ), çünkü listede yer alan tüm "kordonların" aynı olduğunu belirtir.NameErrorEddB''dBB bir uzun "kordon" ile birleştirilemez.

@KennyLau Neyi değiştirdiniz? <!-- language: lang-python -->Görebildiğim kadarıyla , siz yeni eklediniz. Bu ne değişiyor?
R. Kap,

Bu, kodunuz için sözdizimi vurgulamasını etkinleştirebilir.
Sızdıran Rahibe,

@KennyLau Vay, bu harika. Bunu PPCG'de nasıl yapacağımı merak ediyordum. Şimdi biliyorum! Teşekkür ederim! :)
R. Kap
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.