Angenommen, Sie stöbern eines Tages in Ihrer großen Kiste mit nicht verwendeten Computerkabeln und -adaptern (USB-zu-USB-Mini, VGA-zu-DVI usw.). Es gibt überall verwirrte Schnüre, die ein ziemliches Durcheinander verursachen, und Sie fragen sich, ob Sie die Dinge vereinfachen könnten, indem Sie alle Schnüre zu einer langen Litze zusammenfügen und sie dann einfach aufrollen.

Die Frage ist, ist es möglich, alle Ihre Kabel und Adapter in einer langen Reihe so zu verbinden? Es ist natürlich nicht immer möglich, zB wenn Sie nur zwei Kabel mit völlig unterschiedlichen Steckern hatten, konnten diese nicht miteinander verbunden werden. Aber wenn Sie ein drittes Kabel hätten, das an beide angeschlossen werden kann, könnten Sie alle Ihre Kabel aneinander reihen.

Es ist Ihnen egal, welche Art von Steckern sich an den Enden des Kabels befinden. Sie müssen sich nicht verbinden, um eine Schleife zu bilden. Sie möchten nur wissen, ob es möglich ist, eine reine Kordel herzustellen, und wenn ja, wie.

Herausforderung

Schreiben Sie ein Programm oder eine Funktion, die eine mehrzeilige Zeichenfolge enthält, in der jede Zeile eines der Kabel darstellt, die Sie besitzen. Ein Kabel besteht aus einem oder mehreren Strichen ( -) mit einem Stecker an beiden Enden. Ein Plug ist immer eines der 8 Zeichen ()[]{}<>.

Das sind also einige gültige Kabel:

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

Das sind aber nicht:

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

Beim Anschließen von Kabeln können nur Stecker mit genau demselben Halterungstyp miteinander verbunden werden.

Das sind also einige gültige Kabelverbindungen:

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

Und diese sind ungültig:

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

Wenn alle Kabel im Eingang neu angeordnet und in einem langen Strang verbunden werden können, geben Sie diesen Strang in einer Zeile auf Standardausgabe aus (mit einem optionalen nachgestellten Zeilenumbruch). Wenn es mehrere Lösungen gibt, können Sie eine davon für die Ausgabe auswählen. Wenn es nicht möglich ist, einen einzelnen Strang zu erstellen, geben Sie nichts aus (oder geben Sie eine leere Zeichenfolge mit einem optionalen abschließenden Zeilenumbruch aus).

Zum Beispiel, wenn die Eingabe ist

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

die Ausgabe könnte sein

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

wo alle Schnüre aneinandergereiht sind.

Allerdings wenn die Eingabe wäre

[-->
{---]

Die Kabel können nicht angeschlossen werden, sodass keine Ausgabe erfolgt.

Beachten Sie, dass die Kabel so oft umgedreht werden können, bis die Verbindungen hergestellt sind. ZB [-->und <--]sind effektiv das gleiche Kabel, weil sie die gleiche Art von Verbindungen herstellen können. Einige Ausgänge hängen möglicherweise vom Umdrehen der Eingangskabel ab.

Beispielsweise

(-[
}--]

hätte ausgeben können

(-[[--{

wo die zweite Schnur umgedreht ist, oder

}--]]-)

wo die erste Schnur umgedreht wird.

(Beachten Sie, dass im Allgemeinen das Spiegeln der gesamten Ausgabe gültig ist, da es das gleiche ist, als würde jedes Kabel einzeln gespiegelt.)

Die Länge der Kabel im Ausgang sollte natürlich mit der Länge der entsprechenden Eingangskabel übereinstimmen. Die Schnüre können jedoch so oft nachbestellt und gewendet werden, wie Sie möchten, um die reine Schnur zu erhalten. Der Eingang enthält immer mindestens ein Kabel.

Der kürzeste Code in Bytes gewinnt.

Testfälle

Fälle mit Ausgabe:

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

Fälle ohne Ausgabe:

[-->
{---]

[-]
[-]

(-]
]->
}-)

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

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

{--[
]--}

Nicht lesbar , 3924 Bytes

Dies ist das erste Mal, dass ich eine Call-Stack-ähnliche Struktur in Unreadable implementiert habe.

(Die erste Version davon war über 5300 Bytes, nur um eine Vorstellung davon zu geben, wie sehr ich das gespielt habe.)

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

Erläuterung

Betrachten Sie diese Beispieleingabe:

>--{
[---}

Während des größten Teils der Ausführung ist das Band wie folgt angeordnet:

• Die Zellen 0 bis 5 sind Speicherorte für verschiedene Variablen.

• Ab Zelle 6 finden Sie alle Informationen zum Kabelsatz in Ihrer Box:

  

• Die verbleibenden Zellen nach dem „Nullterminator“ enthalten den Stapel. Jeder "Stackframe" ist eine einzelne Zelle, die auf die erste Zelle eines Kabels zeigt (die "Start Plug" -Zelle). Wenn das Programm im obigen Beispiel feststellt, dass es eine Lösung gefunden hat, enthält der Stapel 6 ( >--{das erste Kabel) und 21 ( {---]den Spiegel des zweiten Kabels).

Das Programm besteht aus drei Hauptschritten:

1. Lesen Sie die gesamte Eingabe und generieren Sie die obige Struktur, einschließlich aller gespiegelten Kabel.
2. Probieren Sie alle Kombinationen aus (aber hören Sie auf, wenn eine Lösung gefunden wird).
3. Wenn eine Lösung gefunden wurde, geben Sie diese aus.

Die erste Stufe (Eingabe lesen und Kabelstruktur erzeugen) verwendet nur die Zellen 1 (die ich aufrufen werde p) und 2 (die ich aufrufen werde ch) und arbeitet in einer while-Schleife wie folgt:

• While-Bedingung: Inkrementiere pum 6, lies das nächste Zeichen (Start-Plug) in die Zelle *pund überprüfe, ob es nicht -1(EOF) ist.

• Lesen Sie nachfolgende Zeichen ein *(p+2)und zählen Sie sie ein *(p+1), bis wir auf etwas anderes als -(Bindestrich) stoßen . An dieser Stelle *(p+1)wird die Anzahl der Bindestriche (Kabellänge) und *(p+2)das letzte Nicht-Bindestrichen-Zeichen (der Endstopfen) enthalten. (Wir kopieren auch die Bindestriche in Zelle 5, damit wir später in der Ausgabestufe auf diesen ASCII-Code zugreifen können.)

• Suchen Sie in einer while-Schleife den Spiegelstecker und speichern Sie ihn bei und erhöhen Sie ihn *(p+3)dann pum 2, bis er *pNull ist. Die Schleife sieht im Pseudocode so aus:

  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
  }
  

• Diese Schleife führt immer zwei Iterationen durch (den Start-Stecker und den End-Stecker) und speichert die Ergebnisse in der vierten und sechsten Zelle dieses Kabels. Wenn Sie jetzt genau hinschauen, stellen Sie fest, dass die sechste Zelle tatsächlich die richtige Position für den gespiegelten Endstecker ist, der gespiegelte Startstecker sich jedoch in der Zelle befindet, die mit „Boolean“ (Boolescher Wert für Originalkabel) beschriftet ist. Dies ist in Ordnung, da diese Zelle nur ein Wert ungleich Null sein muss.

• Da pgerade 4 inkrementiert wurden, zeigt es jetzt auf die Zelle mit der Bezeichnung „Boolesches Anzeigekabel wird verwendet“. Auf *(p+3)den Wert von setzen *(p-1). Dies bringt den gespiegelten Startstecker an die richtige Stelle.

• Lesen (und verwerfen) Sie ein weiteres Zeichen (was wir als Zeilenumbruch erwarten, aber das Programm prüft dies nicht).

pBeginnt anfangs bei 0, wird jedoch im while-Zustand um 6 erhöht, sodass die Kabeldaten bei Zelle 6 beginnen. pwird innerhalb des Schleifenkörpers um 4 erhöht, und somit insgesamt 10 für jedes Kabel, was genau das ist, was wir brauchen.

Während der zweiten Stufe, Zellen # 0-4 werden von Variablen belegt , dass ich nennen werde a, p, q, m, und notdone. (Zelle 5 speichert weiterhin den ASCII-Code des Bindestrichs.)

Um sich auf Stufe 2 vorzubereiten, müssen wir den Wert *pauf 0 zurücksetzen (die Zelle mit der Bezeichnung „Nullterminator“), damit sie als Terminator für die Liste der Kabel fungieren kann. wir setzen q(das ist unser Stapelzeiger) auch auf p+1(dh die Zelle nach dem „Nullterminator“; hier beginnt der Stapel); *qzu 1 (der erste Gegenstand auf dem Stapel; warum 1 später auftaucht); und notdonezu 1. All dies geschieht in einer einzigen Anweisung:

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

Die zweite Stufe ist ebenfalls eine while-Schleife. Sein Zustand ist einfach notdone. In jeder Iteration dieser while-Schleife kann eines der folgenden vier Dinge passieren:

1. Wir stellen fest, dass alle Kabel als "in Verwendung" gekennzeichnet sind. Dies bedeutet, dass wir eine Lösung gefunden haben (die durch den aktuellen Stapelinhalt dargestellt wird).
2. Wir können *qzu einem anderen geeigneten Kabel übergehen (das wir zusammen mit seinem Zwilling umgehend als "in Verwendung" markieren) und es dann erneut verwenden (dh einen neuen Stackframe erstellen).
3. Wir können nicht weiterkommen, *qda kein weiteres berechtigtes Kabel vorhanden ist. Daher müssen wir zurückverfolgen (einen Stackframe entfernen und das vorherige Kabel und seinen Zwilling als nicht mehr "in Verwendung" markieren).
4. Wir können nicht weiterkommen, *qda kein weiteres Kabel verfügbar ist, und wir können nicht zurückverfolgen, weil wir den Boden des Stapels erreicht haben. Das heißt, es gibt keine Lösung.

Der Schleifenkörper prüft jede dieser vier Bedingungen in dieser Reihenfolge. Hier sind die Details:

1. Stellen Sie mund pauf 1 und in einer while-Schleife inkrementieren Sie pum 5 (und durchlaufen Sie so die Kabel) und überprüfen Sie, ob *(p+4)(„in use“) eingestellt ist. Ist dies nicht mder Fall , setzen Sie den Wert auf 0. mTeilen Sie uns am Ende dieser Schleife mit, ob alle Kabel belegt sind. In diesem Fall setzen Sie notdoneden Wert auf 0, um die Hauptschleife zu beenden. Fahren Sie andernfalls mit Schritt 2 fort.

2. Stellen Sie pauf *q(das Kabel oben im Stapel) und erhöhen Sie in einer While-Schleife, die der obigen ähnelt, den Wert pum 5, um die Kabel zu durchlaufen. Ab wird *qsichergestellt, dass nur diejenigen berücksichtigt werden, die wir zuvor noch nicht berücksichtigt haben. Denken Sie jedoch daran, dass der Anfangswert für einen neuen Stackframe 1 ist. Das erste Kabel ist also das in Zelle 6, bei dem es sich in der Tat um das erste Kabel handelt.

   Wir müssen für jedes Kabel überprüfen *(p+4), ob es nicht bereits verwendet wird und ob es entweder *(q-1) Null ist (dh, wir befinden uns am unteren Ende des Stapels, sodass der Startstecker nicht eingeschränkt ist) oder *p (der Start des Kabels) Stecker) ist gleich *(*(q-1)+2)(der Endstecker des Kabels direkt unter dem Stapel). Wir überprüfen die Gleichheit, indem wir in einer while-Schleife aauf *(*(q-1)+2)und mauf setzen *p+1und dann beide dekrementieren. Das +1ist, weil mes innerhalb der while-Bedingung dekrementiert wird, also wird es noch einmal dekrementiert als a. Wenn aam Ende Null ist, sind die beiden Stecker gleich.

   Wenn also entweder *(q-1)Null war oder der Gleichheitsvergleich erfolgreich war, ist das Kabel zulässig. Stellen Sie dies ein *q, pum das Kabel oben im Stapel durch das neue zu ersetzen. Stellen Sie mdenselben Wert ein, um anzuzeigen, dass wir ein passendes Kabel gefunden haben. und dann dekrementieren p. Diese Dekrementierung ist ein kleiner Trick, um die while-Schleife (die durch die Kabel iteriert) vorzeitig zu beenden. Der Wert pwird erneut um 5 erhöht , sodass er in die Zelle mit dem Flag „In Use“ dieses Kabels übertragen wird. Wir wissen, dass dies Null ist, weil wir das gerade überprüft haben. Schließlich überprüfen wir nach der Kabeliterations-While-Schleife, ob der Wert mungleich Null ist. In diesem Fall haben wir ein passendes Kabel gefunden und pzeigen auf die Markierung „in use“ für dieses passende Kabel. Setzen Sie ihn auf 1, um ihn als verwendet zu markieren. Auch eingestellt*(*(p-1) ? p+5 : p-5)bis 1, um seinen Zwilling als belegt zu markieren. Inkrementieren Sie qund setzen Sie das Neue *qauf 1, um einen neuen Stackframe zu erstellen.

3. Wenn wir nach der kabeliterierenden while-Schleife feststellen m, dass sie Null ist, gibt es keine passenden Kabel mehr, sodass wir zurückverfolgen müssen. Verringern qSie den Wert, um den Stapel nach unten zu verschieben, und prüfen Sie, ob er immer noch auf ein Kabel zeigt (ein Wert ungleich Null). Wenn ja, kennzeichnen Sie das Kabel und seinen Zwilling als nicht mehr verwendet. (Wir speichern den Wert von *qin p, um diesen Ausdruck im Code zu verkürzen.)

4. Wenn qwir nach dem Dekrementieren feststellen, dass es auf einen Nullwert zeigt, dann ist dies der „Nullterminator“, was bedeutet, dass wir den Stapel unterschritten haben. Wir kommen zu dem Schluss, dass es keine Lösung gibt. Wir setzen notdoneauf 0, um die Hauptschleife zu beenden.

Die dritte Stufe ist die Ausgangsstufe. Es gibt zwei Dinge, die passieren können:

• die Hauptschleife hat eine Lösung gefunden, die wir ausgeben müssen, oder
• Die Hauptschleife hat ergeben, dass es keine Lösung gibt, und wir geben nichts aus.

Wenn es keine Lösung gibt, pist sie günstigerweise Null, da wir sie auf den Wert von setzen, *qbevor wir sie auf Null prüfen. und wenn es war eine Lösung, pist auf dem „Null - Terminator“ , weil es nur durch die Kabel durchlaufen, so dass wir jetzt nutzen können , pum Iterierte durch den Stapel. Durchlaufen Sie den Stapel, und geben Sie für jedes Kabel den Start-Plug ( *(*p)), die Bindestriche (durch Dekrementieren *(*p+1)in einer while-Schleife) und den in Zelle 5 gespeicherten Bindestrichen-ASCII-Code sowie den End-Plug ( *(*p+2)) aus. Es ist egal, dass dadurch die Kabellängeninformationen zerstört werden. das brauchen wir nicht mehr.

CJam, 67

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

Probieren Sie es online aus

Hinweis: Der Link verwendet den neuesten Code aus dem Repository (gepusht, aber noch nicht veröffentlicht), da er eine Fehlerbehebung enthält.

Erläuterung:

Das Programm versucht einfach alle Permutationen und alle Ausrichtungen der Schnüre.

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

JavaScript (ES6), 206

Rekursive Funktion

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

Mehr lesbar

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

Prüfung

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>

Javascript, 800 Bytes

Weit entfernt von einer optimierten Lösung, aber hier ist ein kurzer gemeinsamer Hack in Javascript (kein schickes Ecma5 oder so, weil ich es nicht kenne).

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, hier ist es ... Ich bin sicher, dass mindestens 2 for-Schleifen hier unnötig sind und dass das Überprüfen auf einen einzelnen Elementeingang oben und eine einzelne Elementübereinstimmung unten stankig ist ... aber es scheint zu funktionieren und verarbeitet die Testeingaben.

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;
	}
}

Python 3, 217 Bytes

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

Lua, 477 Bytes

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

Akzeptiert Cords als Befehlszeilenargumente

Python 3.5, 448 432 427 424 286 311 Bytes:

( +25, da es einen Fehler gab, bei dem die Ausgabe länger sein kann als für einige Eingaben )

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

Funktioniert perfekt! mit Ausnahme von Eingaben mit 7 oder mehr Werten. Für diese dauert es sehr lange , am wahrscheinlichsten, weil alle diese Permutationen der Eingabe plus der umgekehrten Eingabe durchlaufen werden müssen . Ich werde versuchen, dies zu beheben, wenn und wann ich kann, aber im Moment scheint dies gut genug zu sein. Alles ist gut jetzt! Wenn ich diesen Block nur irgendwie für das try-exceptListenverständnis verwenden könnte, könnte er etwas kürzer sein und viel besser aussehen . Trotzdem funktioniert es jetzt für alle Testfälle und am besten ohne Importe! :)

Probieren Sie es online! (Ideone) (284 Byte hier)

(Tipp: Um es zu versuchen, wählen Sie einfach "fork" und geben Sie dann Ihre Auswahl ein, durch Leerzeichen getrennt , und wählen Sie "run".)

Erläuterung

Grundsätzlich ist was passiert ...

1. BAus der Eingabe wird eine Liste erstellt, indem sie am Leerzeichen in ihre Komponente "cords" aufgeteilt wird.
2. Mist eine Zeichenfolge, die ich erstellt habe und die bei der Auswertung eine Liste zurückgibt, Bdie alle Kabel enthält, diesmal jedoch rückwärts .
3. Die aus erstellte Liste Mwird schließlich mit sich Bselbst verkettet , um eine Liste fmit allen möglichen Ausrichtungen der "Schnüre" zu erstellen .
4. Es wird eine weitere Liste derstellt, die mit dem ersten Wert (value f[0]) von initialisiert wird f.
5. Schließlich werden alle Werte in ddurchlaufen, und das letzte Zeichen jedes Werts wird mit dem ersten Zeichen jedes Elements in verglichen. fWenn eine Übereinstimmung gefunden wird, wird dieses Zeichen entfernt und aus der Liste zurückgegeben f. Dies geschieht so lange, bis a IndexErrorausgelöst wird oder die Länge der Liste düberschritten wird Bund a NameErrornach dem Aufruf von ausgelöst wird. EBeide werden verarbeitet, und dann wird dder Inhalt der Liste zu einer Zeichenfolge zusammengefügt und zurückgegeben, solange die Länge der Liste dgrößer ist als oder gleich der Länge der Liste B. Andernfalls wird eine leere Zeichenfolge zurückgegeben ( ''), da eine dAbweichung von der angegebenen Länge Bbedeutet, dass alle "Kabel" in der Liste aufgeführt sindB kann nicht zu einer langen "Schnur" verbunden werden.