我可以将所有的电线和适配器绑在一起吗?


30

假设有一天,您正在翻阅一大盒未使用的计算机线和适配器(USB到USB mini,VGA到DVI等)。到处都有缠结的电线,使情况变得一团糟,您想知道是否可以通过将所有电线绑成一长串然后将其卷起来来简化事情。

问题是,是否可以像这样将所有电线和适配器连接成一条长线?显然并非总是可能的,例如,如果您只有两条完全不同的插头的电线,则它们无法连接在一起。但是,如果您有第三条可以同时连接到它们的电线,则可以将所有电线捆扎在一起。

您不必担心全绳线末端的插头类型。他们不需要互相插入就可以形成一个循环。您只想知道是否可以制作全绳缆绳,如果可以,如何做。

挑战

编写一个包含多行字符串的程序或函数,其中每行都描述您拥有的一根电线。电线由一个或多个破折号(-)组成,两端均带有插头。插头始终是8个字符之一()[]{}<>

因此,以下是一些有效的方法:

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

但是这些不是:

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

连接电线时,只能将支架类型完全相同的插头连接在一起。

因此,以下是一些有效的电线连接:

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

这些是无效的:

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

如果输入中的所有软线都可以重新排列并连接成一长串,则将其输出到一行上的stdout(带有可选的尾随换行符)。如果有多种解决方案,则可以选择其中一种进行输出。如果无法制作单条链,则不输出任何内容(或输出带有可选尾随换行符的空字符串)。


例如,如果输入是

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

输出可能是

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

所有的电线都缠绕在一起。

但是如果输入是

[-->
{---]

电源线无法连接,因此没有输出。


请注意,电线可以尽可能多地翻转以进行连接。例如[--><--]并且实际上是同一根电线,因为它们可以进行相同类型的连接。某些输出可能取决于翻转输入线。


例如

(-[
}--]

可能有输出

(-[[--{

第二根线被翻转的地方,或者

}--]]-)

第一根线被翻转的位置。

(请注意,一般而言,翻转整个输出是有效的,因为这与最初单独翻转每条电源线相同。)


当然,输出中线的长度应与相应输入线的长度匹配。但是,可以将绳索重新排序,并根据需要进行任意翻转,以制作全帘线。输入将始终包含至少一根电源线。

以字节为单位的最短代码获胜。

测试用例

输出案例:

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

没有输出的情况:

[-->
{---]

[-]
[-]

(-]
]->
}-)

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

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

{--[
]--}

6
大盒未使用的计算机线和适配器 让我感觉更好-我不是唯一的人。实际上,我有几个这样的盒子。
Digital Trauma 2015年

但是,如果您自己插入电源线怎么办?
anOKsquirrel 2015年

是线保证所有有效吗?
R. Kap

@ R.Kap是的
卡尔文的爱好

Answers:


10

无法读取,3924字节

这是我第一次在《不可读》中实现某种类似于调用栈的结构。

(此版本的第一个版本超过5300字节,只是为了说明我打了多少高尔夫球。)

'“”“”“”“”“”“”“”“”“”“”“”“”“”“”'“”“”“”“”“”“”“”“” “”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “'”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”'“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “”“”'“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” '“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “'”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”'“”“”“”“”“”“”“”“”“”“”“”“”“'”“”“”“”“”“”“”“”“”“” “”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” '“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” '“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “”“”'“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” '“”'“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “'”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” '“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “”“”'“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”'“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” '“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“'”“”“”“”“”“”“”“”“”“” “”“”'“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” '“”'“”“”“”“”“”“”“”“”“”“”“”“”“'”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”'“”“”“”“”“”“”“”“”“”“” “”“”“”“”“”“”“”“”“”“”“”“”“”“”“'”“”“”“”“”“”“”“”“”“” “”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” '“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”'“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”'“”“”“”“”“”“”“”“”“”“” “”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” '“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”'“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “'”“”'“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “'”“'”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”““”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”'“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “'”“'”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“ “”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“ “”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”'“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” '“”'“”'“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “”'“”“'“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “”“”“”'“”“”“”“'“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“”“” “”“”“”'“”“”“”“

说明

考虑以下示例输入:

>--{
[---}

在整个执行过程中,磁带的布局如下:

  • 单元格0到5是各种变量的位置。

  • 从第6单元开始,包含有关包装盒中电缆组的所有信息:

    磁带布局示例

  • “零终止符”之后的其余单元包含堆栈。每个“堆栈框架”都是指向电缆的第一个单元(“启动插头”单元)的单个单元。在上面的示例中,当程序确定找到解决方案时,堆栈将包含6(指>--{第一根电缆)和21(指{---]第二根电缆的镜像)。

该计划分为三个主要阶段:

  1. 阅读整个输入并生成以上结构,包括所有镜像电缆。
  2. 尝试所有组合(但如果找到解决方案,则停止)。
  3. 如果找到解决方案,请输出它。

第一阶段(读取输入并生成电缆结构)仅使用#1单元格(我将其称为p)和#2单元格(将其称为ch),并在while循环中进行如下操作:

  • 条件:加p6时,将下一个字符(开始插入)读入cell *p,并检查其是否不是-1(EOF)。

  • 将后续字符读入*(p+2),并在中计数*(p+1),直到遇到除-(连字符)以外的其他字符。到那时,*(p+1)将包含连字符的数量(电缆长度)和*(p+2)最后一个非连字符(结束符)。(我们还将连字符复制到单元格5中,以便稍后在输出阶段访问此ASCII代码。)

  • 在while循环中,找到镜像插头并将其存储在*(p+3),然后增加p2,直到*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开始,但在while条件内增加6,因此电缆数据从6号单元开始。p在回路体内增加4,因此每条电缆总共增加10,这正是我们所需要的。

在第二阶段,细胞#0-4被变量占用的,我会打电话apqm,和notdone。(单元格5仍记住连字符的ASCII码。)

为了做好第二阶段的准备,我们需要将其设置*p回0(标记为“零终结器”的单元),以便它可以用作电缆列表的终结器;我们还设置q(这是我们的堆栈指针)为p+1(即“零终止符”之后的单元;这是堆栈开始的位置);*q到1(堆栈中的第一个项目;为什么稍后会出现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循环中将其递增p5(从而遍历电缆),并检查是否*(p+4)已设置(“使用中”)。如果不是,请将其设置m为0。在循环结束时,m告诉我们是否所有电缆都在使用中。如果是这样,请将其设置notdone为0以终止主循环。否则,请继续下面的步骤2。

  2. 设置p*q(电缆在堆栈顶部),并在类似于上述的while循环中,增加p5以遍历电缆。从开始*q确保我们只考虑那些我们以前没有考虑过的东西;但是,请记住,新堆栈帧的初始值为1,因此查看的第一条电缆是单元格6的电缆,这实际上是第一条电缆。

    对于每一个连接线,我们需要检查*(p+4),以确保它没有被使用,也即要么 *(q-1)为零(这意味着我们是在堆栈的底部,因此不会在一开始插头没有限制), *p(电缆的开始插头)等于*(*(q-1)+2)(电缆末端在堆叠下面的插头)。我们通过设置a为to *(*(q-1)+2)mto *p+1,然后在while循环中将两者递减来检查是否相等。的+1是,因为m是递减的,而条件里面,所以它一旦减少超过a。如果a在此结尾处为零,则两个插头相等。

    因此,如果其中一个*(q-1)为零或相等性比较成功,则该电缆合格。设置*qp用新的电缆替换堆叠顶部的电缆;设置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,我们发现它指向零值,那么它就是“零终止符”,这意味着我们欠栈。我们得出结论,没有解决方案。我们设置notdone为0终止主循环。

第三阶段是输出阶段。可能发生两件事:

  • 主循环找到了我们需要输出的解决方案,或者
  • 主循环得出结论,没有解决方案,我们什么也没输出。

方便地,如果没有解决方案,p则为零,因为我们在将其*q检查为零之前将其设置为的值。如果有一个解决方案,p以“零终结者”的指点,因为它只是通过电缆迭代,所以我们现在可以使用p通过堆栈进行迭代。因此,只需遍历堆栈,为每根电缆输出起始插头(*(*p)),连字符(通过*(*p+1)在while循环中递减;并使用存储在单元5中的连字符ASCII码)和结束插头(*(*p+2))。没关系,这会破坏电缆长度信息。我们不再需要了。


3

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

也许是对它如何工作的解释?
Timwi

@Timwi好的,我也打了一点
高尔夫球–aditsu

该解决方案无效,因为它不会为输入生成任何输出(-] ]-> >-} }-) )-[ [-< <-{ {-(
R. Kap

@ R.Kap确实解决了该输入问题,但是该特定的在线解释器存在超时(对此非常安静)。您可以在这里尝试(给它几分钟),也可以使用Java解释器(最快)
aditsu

实际上,我上面链接的口译员可能需要很长时间才能解决该输入问题。在Java解释器解决它在我的电脑上小于1.5分钟。
aditsu '16

2

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>


1

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个for循环是不必要的,并且检查顶部的单个元素输入和底部的单个元素匹配是很糟糕的...但是它似乎有效并且处理测试输入。

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
您可以重命名功能以节省很多字节。stackoverflow.com/questions/6156319/...
noɥʇʎԀʎzɐɹƆ

1
在任何版本的JavaScript中都避免使用.charAt。s.charAt(x)===s[x]
edc65 '16

1

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的演示


这如何接受输入?
R. Kap

@ R.Kap在stdin上,每行一根线。
Anders Kaseorg '16

至少在我运行时似乎没有。
R. Kap

另外,它能以多快的速度找到正确的答案(-] ]-> >-} }-) )-[ [-< <-{ {-(
R. Kap

@ R.Kap有关获取输入并产生输出的示例,请参见Ideone上的演示。(如果您要这样做,则可能无法在Windows上运行?)它可以在您的测试用例上立即运行。当然,在某些情况下,这将花费指数时间。
Anders Kaseorg '16

0

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

接受软线作为命令行参数


0

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个字节)

(提示:要尝试,只需选择“叉子”,然后输入您的选择,以空格分隔,然后选择“运行”即可)

说明

基本上,正在发生的是...

  1. 一个列表, B通过在空格处将输入分割成其组成部分“编码”,可以根据输入创建。
  2. M是我创建的字符串,在评估后会返回一个列表,B其中包含所有电线,但这次是向后的
  3. 从中创建的列表M最终会与B自身连接在一起以创建列表,f,其中带有“软线”的所有可能方向。
  4. d创建了另一个列表,该列表将使用的第一个值(value f[0])初始化。f
  5. 最后,对in d中的所有值进行迭代,并将每个值的最后一个字符与in中每个元素的第一个字符进行比较f,当找到匹配项时,将该字符弹出(或删除)并从list返回f。这种情况一直发生,直到a IndexError升高,或者list的长度d超过B且对a NameError的调用之后a 都升高E,这两个都被处理,然后list d的内容被连接到一个字符串中,并且只要list的长度d更大就返回。等于或等于列表的长度B。否则,将返回一个空字符串(''),因为无法将其连接成一个长的“软线”。d其长度不等于B表示列表中的所有“软线”的长度B

@KennyLau您做了什么更改?据我<!-- language: lang-python -->所知,您刚刚添加了。这会发生什么变化?
R. Kap

这样可以为您的代码启用语法突出显示。
Leaky Nun

@KennyLau Wow,太酷了。我想知道如何在PPCG上做到这一点。现在我知道了!谢谢!:)
R. Kap
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.