Предположим, однажды вы копаете большую коробку неиспользуемых компьютерных шнуров и адаптеров (USB-USB mini, VGA-DVI и т. Д.). Повсюду запутанные шнуры создают беспорядок, и вы задаетесь вопросом, не могли бы вы упростить вещи, соединив все шнуры в одну длинную прядь, а затем просто свернув ее.

Вопрос в том, возможно ли соединить все ваши шнуры и адаптеры в одну длинную линию, как это? Очевидно, это не всегда возможно, например, если у вас было только два шнура с совершенно разными разъемами, их нельзя было соединить вместе. Но если бы у вас был третий шнур, который можно подключить к ним обоим, то вы могли бы связать все свои шнуры вместе.

Вам не важно, какие вилки находятся на концах жилы. Им не нужно подключаться друг к другу, чтобы образовать петлю. Вам нужно только знать, возможно ли сделать прядь из шнура, и если да, то как это сделать.

Вызов

Напишите программу или функцию, которая принимает многострочную строку, где каждая строка изображает один из ваших шнуров. Шнур состоит из одной или нескольких черточек ( -) с вилкой на каждом конце. Штекер всегда является одним из 8 символов ()[]{}<>.

Итак, вот некоторые допустимые шнуры:

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

Но это не так:

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

При подключении шнуров только штекеры с одинаковым типом кронштейна могут быть соединены вместе.

Итак, вот некоторые действительные кабельные соединения:

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

И это недействительно:

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

Если все шнуры на входе можно переставить и соединить вместе в одну длинную цепь, то выведите эту цепь в стандартный вывод на одной строке (с дополнительным завершающим символом новой строки). При наличии нескольких решений вы можете выбрать любое из них для вывода. Если создание одной цепи невозможно, ничего не выводится (или выводится пустая строка с необязательным завершающим символом новой строки).

Например, если вход

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

выход может быть

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

где все шнуры связаны вместе.

Однако, если вход был

[-->
{---]

Шнуры не могут быть подключены, поэтому не будет никакого выхода.

Обратите внимание, что шнуры могут быть перевернуты столько, сколько необходимо для создания соединений. например, [-->и <--]фактически являются одним и тем же шнуром, потому что они могут выполнять соединения одного типа. Некоторые выходы могут зависеть от переворачивания входных шнуров.

Например

(-[
}--]

может иметь выход

(-[[--{

где перевернут второй шнур, или

}--]]-)

где первый шнур перевернут.

(Обратите внимание, что в целом перелистывание всего выхода допустимо, потому что это то же самое, что изначально переворачивание каждого шнура в отдельности.)

Длина шнуров в выходных данных должна, конечно, соответствовать длинам соответствующих входных шнуров. Но шнуры могут быть переупорядочены и перевернуты столько, сколько вы хотите, чтобы сделать весь шнур. На входе всегда будет хотя бы один шнур.

Самый короткий код в байтах побеждает.

Тестовые случаи

Случаи с выходом:

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

Случаи без выхода:

[-->
{---]

[-]
[-]

(-]
]->
}-)

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

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

{--[
]--}

Не читается , 3924 байта

Это первый раз, когда я реализовал что-то вроде структуры стека вызовов в Unreadable.

(Первая версия этого была более 5300 байтов, просто чтобы дать представление о том, как много я играл в гольф.)

«" „“ „„„“““ „“ „“ „„„“ „“ „“““ „“»«»«„“»«»«„“»«»«„“»«»«» «» «" „“ „„„“ „“ „“““»«„“ „„„“ „“ „“ „“ „“““ „“ „„„“ „“““ „“ "» „“ «» «» «„“» «» «„“» «» «„“» «» «„“„“„“"»„“«"„“„“» "„“„“„“"«» «„“„“„“„“» «» «» «» «» «„“„“„“„“» «» «» «» «» «„“„“„“„“» «» «» «» «» «„“„“„“„“» «» «» «» «» «„“„“„“„“» «» «» «» «» "„“„“„“» «„„“ „“ „“ „““» «» «» «» «„„“ „“ „“ „““» «» «» «» "" „“ „“ „“ „“«" „“ „“ „“»«»«»«»«»«„“ „“ „“ „“»«»«»«»«»«„“ „“ „“ „“»«»«» «» «» «„“„“„“„“» «» «» «» «» «„“„“„“„“» «» «» «» «» «„“„“„“„“» «» «» «» «» «„“„“„“„“» «» «» «» «» «„“„“„“„“» «» «» «» «» "»«» «» «» «„„“ „“ „“ „““» «» «» «» «„„“ „“ „“ „““» «» «» «» "" „“ „“ „“ «» «„“„“„“„“» «» «» «» «» «„“„“„“„“» «» «» «» «» «„“„“„“„“» «» «» «» «» «„“„“„“„“» «» «» «» «„“» «» «„“„“„“"»„“«"„“„“»«» «» «„„“ „“ „“ „““» «» «„“„„„“„“““„“„“„„„“““„„„“““"»„“" «" „“ „“ „„„“““ "» „“ „“ „“ «" „“ „„„“ „“ „“““»«„“ „“ „“ "» „“ «"» «„„“ „“ „“ „„„“““ „“ „“ „““» «» «„“„“„„„“„“„“““"»„“«"„“»«» «» «„“„“„“„„„“„„„“„“““„“„“„„„“““„„„“““„“„“„“““„“» «» «» «» «» «„„“ „“ „““» «" „“ „„„“ „“ „“ „“““ „“ „“ „“»" „“ „“ „“ „“ «" „“ „“ „“»«»«»«»«»«„“ „“ „“ „“»«»«»«»«»«„“ „“ „“ „“»»«» «» «» «„„“ „“ „“ „““» «» «» «» «„„“ „“ „“ „““» «» «» «» "" „“ „“ „“ «» «„“„“„“„“» «» «» «» «» «„“„“„“„“» «» «» «» «» «„“„“„“„“» «» «» «» «» «„“„“„“„“» «» «» «» «» «„“„“„“„“» «» «» «» «» "„“»«» «» «„„“ „“ „“ „““» «» «» «» «„„“ „“ „“ „““» «» «» «» "" „“ „“ „“ „“ «" „“ „“ „“»«»«»«»«»«„“ „“ „“ „“»«»«»«»«»«„“ „“ „“ „“»«»«» «» «» «„“„“„“„“» «» «» «» «» «„“„“„“„“» «» «» «» «» "„“„“»«» «„“» «» «" „“ „“ „“ „“ „„„“ „“ „“““»" „“ „„„“ „“ „“ „“““ „“ „“ „“ «"»«»«"„“„“„“„“„„„“„“„“““» «„“„„„“„“„“„“““„“„“„“"» «» «» «» «» «„“„“„“„“» «» «» «» «» «„“„“„“„“» «» «» «» «» "„“«» «» «» «„“„“„“„“» «» «» «» «» «„“„“„“„“» «» «» «» «» "„“„“„“» «„„“ „“ „“ „““» «» «» «» «„„“ „“ „“ „““» «» «» «» «„„“ „“ „“ „““» «» «» «» «„„“ „“ „“ „„„“““ „““» «» «» «» «» «„“„“„“» «» «„“"»"«» «» «» «„„“ „“ „“ „““» «» «» «» «„„“ „“ „“ „““» «» «» «» "" „“ „“ „“ «» «„“„“„“„“» «» «» «» «» «„“„“„“„“» «» «» «» «» «„“„“„“„“» «» «» «» «» «„“„“„“„“» «» «» «» «» «„“„“„“„“» «» «» «» «» "„“»«» «» «„„“ „“ „“ „““» «» «» «» «„„“ „“ „“ „““» «» «» «» "" „“ „“ „“ „“ «" „“ „“ „“»«»«»«»«»«„“ „“ „“ „“»«»«»«»«»«„“ „“ „“ „“»«»«» «» «» «„“„“„“„“» «» «» «» «» «„“„“„“„“» «» «» «» «„„““» «»«" „“ „“ „“ „„„“ „“ „“ „“““ „“ „“ „“ „„„“ „“ „“ „“““ „“ „“ „“ "» „“ " «» «» «„„“ „“ „“ „““» «» «» «» «„„“ „“ „“ „““» «» «» «» "" „“ „“ „“ „“ «" „“ „“ „“»«»«»«»«»«„“ „“ „“ „“»«»«»«»«»«„“ „“ „“ „“»«» «» «» «» «„“„“„“„“» «» «» «» «» «„“„“„“„“» «» «» «» «» "„“„“» «» «„„“ „“ „“ „““» «» «» «» «„„“ „“ „“ „““» «» «» «» «„„“ „“ „“ „““» «» «» «» «„„“ „“ „“ „““» «» «» «» «„„“ „“ „“ „““» «» «» «» "" „“«» «» «» «„“„“„“„„„“““„“» «» «» «» «» «„“„“„“„“» «» «» «» "" „“ «» «» «" „“ „„„“““»«„“ „“ „“ "» „“ „“ „“ «" „“ „„„“““»«„“ „“ „“ "» «» «» «» «" „“ „„„“““»«„“ „“ „“ "» „“ „“ „“ «" „“»„„“ „“ „“ „““«» «» «» «„„“ „“ „“ „„„“ „„„“““ „“ „“ „“““ „“ „“ „““» «» «„“„“„“» «» «„„““» «" „“ „“ „“»«„“ „„„“ „“ „“““ „„„“““ "» „“ „“ „“ «" „“»" «» «» «» «„„“ „“ „“ „““» «» «» «» «„“„„„“„“„“„“„“““„“„“"»«» «» «» «„„“ „„„“ „“ „“ „“““ „“ „“ „„„“““ „„„“““ „““» «» «» "" „“ «» «» «„“» «» «„„““» «» «» «» «„“"»„“«"„“„“» "„“„“„“„„„“““" «"»«»«„„“„““»«»«„„“„“„““»«„„““»«»«„“ „“ „“»«»" "„“«" „“ „“ „„„“ „“ „“ „„„“ „“ „“““ „“““ „„„“““ „„„“““»«„“ „“ „“ "» «» «" „“ „“ „“ „“»«„“ „“ „“ „„„“““ „„„“““ "» „“ „“ „“ «" „“»«„“ "» «» «» «» «„“» «» «„“„„„“„“„“„“““„“» «» «» «» «» «" „“ „“ „“»"«» «„“» «» «„„“ „“ „““» «„„““» «„„“ „„„“ „“ „“ „“““ „““» «» "" „“ «» «„“„“„“» «» «„„“ „“ „“ „„„“ „“ „“ „„„“““ „“““ „“ „““» «» «» «» «" „“ „“»«»«„„““»«„„““»«„„““»«»«»«»«„“ "» „“ „“ „“ „“ "«" „“ „“ „„„“““ „„„“““ "» „“ „“ „“ «" „“»«„“ "» „“ „“ „“ „“ «" „“» «» «» «» «„“„“„“„„„“„“„“„“““„“„“„“» «» «„“„„„“„“““„“"»" «» «» «„„“ „“ „“ „““» «» «„“„“„“„„„“““"»„“„“„“" "„“„“„“«» «„“„“„“„„„“““„“» «» «» «» «„“» «» «„“„„„“““„“„“„“» «» «» «» «" „“»«„“ „“ „“ „“ „„„“ „“ „„„“ „“ „“““ „„„“““ „“““ „“ „“ „“ "» «» «» «» «„„““» «" „“ „„„“ „“ „“““ „“ „“ „“»" „“ "„„“ „“ „“ „““«» «» «» «„„“ „“ „“ „““» «» «„“„“„“„“» «» «" „“»" „“ „„„“ „“ „“““ «» «„“„“„“„“» «» «» «» «„“» «» «„“„„„“„“„“““„“„“„“» «» "„“» «" „“ „“ "» „“ «" „“»«„“ „“ „“ „“ "» „“ „“ „“ „„„“““ «" „“»" „“«» «» «„“„“„“» «» «„“„„„“““„“„“„“» «» "„“„„„“„“„“““„“„“» «„„“ „„„“ „“ „“““ „“ „“ „“ „““» «» «» «» «„“„“„“„“» «» «» «» "" „“ «„„““» «„„““» «„„““» «» «» «» «„“„„„“„“„“„“““„“„“„“"»«» «» «» «» «„“„“„“„“» «» «» «» «» «„“„“„“"»„“«"„“» "„“„“„“" «» «„“„“„“» «» «" „“ „“ „“ „„„“ „“ „“““»" „“ „„„“ „“ „“ „“““ „“ „“ «» «„“» «» «„„“ „“ „““» «„„““» «„„““» «» «» «» «„“"»„“„“„“«" „“ „“ „“ „„„“ „“ „“ „„„“““ „„„“““ „“ „“ „“““ „“»«»«„“»«»"» «„„““» «„„““» «„„““» «» «» «» «„“„„„“„“„“„“““„“„“„“» «» "» «» «» «» «» "„“„„„“„“„“““„„„“““„„„“„„„“„“„“„“““„“““»«» «» «» «" „“ „“ „“»«„“ „„„“ „“ „„„“ „“ „“ „“““ „“ „“ „“““ „“ „“ "» «» «„„““» «» «» «» «„“„„„“„“““„“"»«"„“„“„“» «„“„“„“"»„“" «» «» «„“„„„“„“„„„“““„“„“„„„“““„“„“„“““„“„“„“» «»»«" „“ „“ „“»«»«»«»«„„““»«»«»«»«„“ „“ „“ "» „“ «"»" „“ „“ „“ " «"»«»«„“»«»«„“ "» «" „“ „“ „“ „„„“““»«„“ „“ „“ "» „“ „“ „“ «"» «» "„“»«" „“ „“ „„„“““ „„„“““ "» „“ «"»«„“ „“ „“ „„„“““ "» „“ „“ „“ «"» «» «» «» «„“"»„“"«" „“ „“ „„„“““ „„„“““ "» „“ «"»«„“ „“ „“ „„„“““ "» „“ „“ „“ «"» «» «» «» «„“"»„“"

объяснение

Рассмотрим этот пример ввода:

>--{
[---}

На протяжении большей части исполнения лента выкладывается следующим образом:

• Ячейки с 0 по 5 являются местоположениями для различных переменных.

• Ячейка 6 и далее содержит всю информацию о наборе кабелей в вашей коробке:

  

• Оставшиеся ячейки после «нулевого терминатора» содержат стек. Каждый «стековый фрейм» представляет собой отдельную ячейку, которая указывает на первую ячейку кабеля (ячейка «начальная вилка»). В приведенном выше примере, когда программа решит, что она нашла решение, стек будет содержать 6 (ссылаясь >--{на первый кабель) и 21 (ссылаясь {---]на зеркало второго кабеля).

Программа проходит в три основных этапа:

1. Прочитайте весь ввод и создайте вышеупомянутую структуру, включая все зеркальные кабели.
2. Попробуйте все комбинации (но остановитесь, если решение найдено).
3. Если решение найдено, выведите его.

Первый этап (чтение входных данных и создание структуры кабелей) использует только ячейки № 1 (которые я назову p) и № 2 (которые я назову ch) и работает в цикле while следующим образом:

• В то время как условие: увеличьте pна 6, прочитайте следующий символ (стартовый плагин) в ячейку *pи убедитесь, что это не так -1(EOF).

• Читайте последующие символы *(p+2)и считайте их *(p+1)до тех пор, пока мы не встретим что-либо, кроме -(дефис). В этот момент *(p+1)будет содержаться количество дефисов (длина кабеля) и *(p+2)последний не дефисный символ (концевая заглушка). (Мы также копируем дефисные символы в ячейку # 5, чтобы мы могли получить доступ к этому ASCII-коду позже на этапе вывода.)

• В цикле while найдите зеркальный штекер и сохраните его в точке *(p+3), затем увеличивайте pна 2, пока *pне достигнете нуля. Цикл выглядит так в псевдокоде:

  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
  }
  

• Этот цикл всегда будет выполнять две итерации (начальный и конечный разъем) и сохранять результаты в четвертой и шестой ячейке этого кабеля. Теперь, если вы обратили внимание, вы поймете, что шестая ячейка действительно является правильным местом для зеркальной концевой заглушки, но зеркальная стартовая заглушка находится в ячейке с надписью «логическое значение, указывающее оригинальный кабель». Это нормально, потому что нам нужно, чтобы эта ячейка была ненулевым значением.

• Поскольку pтолько что было увеличено всего 4, теперь он указывает на ячейку, помеченную как «логическое значение, указывающее, что кабель используется». Установите *(p+3)значение *(p-1). Это ставит зеркальный стартовый разъем в нужное место.

• Прочитайте (и отбросьте) еще один символ (который, как мы ожидаем, будет новой строкой, но программа не проверяет это).

pизначально начинается с 0, но увеличивается на 6 внутри условия while, поэтому данные кабеля начинаются с ячейки # 6. pувеличивается на 4 внутри тела петли, и, таким образом, всего 10 для каждого кабеля, что именно то, что нам нужно.

На втором этапе, клетки # 0-4 заняты переменные , которые я буду называть a, p, q, m, и notdone. (Ячейка № 5 все еще помнит ASCII-код дефиса.)

Чтобы подготовиться к этапу 2, нам нужно установить *pзначение 0 (ячейка, помеченная как «нулевой терминатор»), чтобы она могла действовать как терминатор для списка кабелей; мы также устанавливаем q(который является указателем нашего стека) на p+1(то есть ячейку после «нулевого терминатора»; именно здесь начинается стек); *q1 (первый элемент в стеке; почему 1 станет очевидным позже); и notdoneдо 1. Все это делается в одном утверждении:

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

Второй этап - это также цикл while. Его состояние просто notdone. На каждой итерации этого цикла while может произойти любая из следующих четырех вещей:

1. Мы находим, что все кабели помечены как «используемые». Это означает, что мы нашли решение (которое представлено текущим содержимым стека).
2. Мы можем заранее *q к другому подходящему кабелю (который мы быстро помечаем как «используемый» вместе с его близнецом), а затем выполнить рекурсию (т.е. создать новый стековый кадр).
3. Мы не можем продвинуться, *qпотому что больше не существует подходящего кабеля, поэтому нам нужно вернуться назад (удалите стековый фрейм и пометьте предыдущий кабель и его двойник как «больше не используемые»).
4. Мы не можем продвинуться, *qпотому что больше нет подходящего кабеля, и мы не можем вернуться, потому что мы достигли дна стека. Это означает, что нет решения.

Тело цикла проверяет каждое из этих четырех условий в указанном порядке. Вот подробности:

1. Установите mи pравным 1, а в цикле while увеличивайте pна 5 (таким образом итерируя по кабелям) и проверяйте, установлено ли *(p+4)(«используется»). Если это не так, установите mзначение 0. В конце этого цикла mсообщите нам, все ли кабели используются. Если это так, установите notdone0, чтобы завершить основной цикл. В противном случае перейдите к шагу 2 ниже.

2. Установите pзначение *q(кабель в верхней части стека) и в цикле while, аналогичном описанному выше, увеличьте pна 5 для итерации по кабелям. Начиная с того, что *qмы рассматриваем только те, которые мы еще не рассматривали; однако помните, что начальное значение для нового стекового кадра равно 1, поэтому первый рассматриваемый кабель - это тот, который находится в ячейке 6, который действительно является первым кабелем.

   Для каждого кабеля нам нужно *(p+4)убедиться, что он еще не используется, а также, что либо он *(q-1) равен нулю (это означает, что мы находимся в нижней части стека, поэтому нет никаких ограничений на пусковую вилку), либо *p (начало кабеля plug) равно *(*(q-1)+2)(концевой разъем кабеля чуть ниже стека). Мы проверяем равенство, установив aв *(*(q-1)+2)и mк *p+1а затем декремента как в то время как цикл. Это +1потому, что mуменьшается внутри условия while, поэтому он уменьшается еще раз больше, чем a. Если aв конце это ноль, два штекера равны.

   Таким образом, если либо *(q-1)был равен нулю, либо сравнение на равенство выполнено успешно, кабель подходит. Установите, *qчтобы pзаменить кабель в верхней части стека новым; установите mна то же самое, чтобы указать, что мы нашли соответствующий кабель; а затем уменьшить p. Этот декремент - небольшая хитрость, заставляющая цикл while (итерацию по кабелям) завершаться рано; он снова увеличится pна 5, перенеся его в ячейку, содержащую флаг «используется» этого кабеля, и мы знаем, что это ноль, потому что мы только что проверили это. Наконец, после итерации по кабелю цикла while мы проверяем, не mявляется ли он ненулевым. Если это так, мы нашли соответствующий кабель и pуказываем на флаг «в использовании» для этого соответствующего кабеля. Установите 1, чтобы пометить его как используемый. Также установлено*(*(p-1) ? p+5 : p-5) 1, чтобы отметить его близнец, как в использовании. Наконец, увеличьте qи установите новый *qв 1, чтобы создать новый стек стека.

3. Если после итерации по кабелю цикла while мы обнаружим, mчто он равен нулю, подходящих кабелей больше нет, поэтому нам нужно вернуться назад. Уменьшите значение qдля перемещения вниз по стеку и проверьте, что он все еще указывает на кабель (ненулевое значение). Если это так, пометьте этот кабель и его двойник как неиспользуемые. (Мы сохраняем значение *qin, pчтобы сделать это выражение короче в коде.)

4. Если после уменьшения qмы обнаруживаем, что он указывает на нулевое значение, то это «нулевой терминатор», что означает, что мы опустошаем стек. Мы заключаем, что нет решения. Мы устанавливаем notdone0, чтобы завершить основной цикл.

Третий этап - выходной. Есть две вещи, которые могут произойти:

• основной цикл нашел решение, которое нам нужно вывести, или
• основной цикл заключил, что нет решения, и мы ничего не выводим.

Удобно, если бы не было не решение, pравно нулю , потому что мы устанавливаем его к значению *qперед проверкой , что на ноль; и если было решение, pоно указывает на «нулевой терминатор», потому что он просто перебирает кабели, поэтому теперь мы можем использовать его pдля перебора стека. Так что просто итерируйте по стеку, выводя для каждого кабеля начальный плагин ( *(*p)), дефисы (уменьшая *(*p+1)в цикле while; используя код ASCII дефиса, хранящийся в ячейке # 5) и концевой плагин ( *(*p+2)). Не берите в голову, что это разрушает информацию о длине кабеля; нам это больше не нужно.

CJam, 67

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

Попробуйте онлайн

Примечание: ссылка использует последний код из хранилища (отправлено, но еще не выпущено), так как содержит исправление ошибки.

Объяснение:

Программа просто пробует все перестановки и все ориентации шнуров.

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

Рекурсивная функция

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

Более читаемый

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

Тест

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 байт

Это далеко не оптимизированное решение, но вот быстрый взлом вместе в javascript (никакой необычной ecma5 или чего-то еще, потому что я этого не знаю).

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}

Недооценено, вот оно ... Я уверен, что по крайней мере 2 для циклов здесь не нужны, и что проверка на вход одного элемента в верхней части и совпадение одного элемента в нижней части является вонючей ... но, похоже, работает и обрабатывает входные данные теста.

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 байт

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

( Демонстрация на Ideone )

Луа, 477 байт

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

Принимает шнуры в качестве аргументов командной строки

Python 3.5, 448 432 427 424 286 311 байт:

( +25, так как была ошибка, когда вывод может быть длиннее, чем должен быть для некоторых входов )

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

Работает отлично! за исключением входов с 7 или более значениями. Это занимает много времени, скорее всего, потому что он должен пройти через все эти перестановки ввода плюс обратный ввод . Я постараюсь это исправить, если и когда смогу, но сейчас это кажется достаточно хорошим. Теперь все хорошо! Если только я мог каким-то образом использовать этот try-exceptблок в понимании списка, он мог бы быть немного короче и выглядеть намного лучше. Тем не менее, в настоящее время работает для всех тестовых случаев, и, лучше всего, он не использует ни одного импорта! :)

Попробуйте онлайн! (Ideone) (284 байта здесь)

(Совет: чтобы попробовать это, просто выберите «fork», а затем введите ваши варианты, разделенные пробелами , и выберите «run»)

объяснение

В основном, что происходит ...

1. Список, Bсоздается из входных данных, разбивая его на пустом месте на составляющие его «шнуры».
2. Mэто созданная мной строка, которая при оценке возвращает список, в Bкотором содержатся все шнуры, но на этот раз обратном направлении .
3. Список, созданный из, Mв конечном итоге объединяется сB самим собой для создания списка fсо всеми возможными ориентациями «шнуров».
4. Создается еще один список, dкоторый будет инициализирован первым значением (значением).f[0] ) из f.
5. Наконец, все значения в dитерируются, и последний символ каждого значения сравнивается с первым символом каждого элемента в f, и когда совпадение найдено, этот символ выталкивается (или удаляется) и возвращается из списка f. Это происходит до тех пор, пока значение a не IndexErrorбудет увеличено или длина списка не dпревысит, Bа значение a не NameErrorбудет поднято после вызова E, оба из которых обрабатываются, а затем dсодержимое списка объединяется в строку и возвращается до тех пор, пока длина списка dбольше чем или равно длине списка B. В противном случае возвращается пустая строка ( ''), поскольку dдлина не совпадает со значением, Bозначающим, что все «шнуры» в спискеB не может быть объединен в один длинный "шнур".