57

一条可弯曲的蛇看起来像这样：

<||=|||:)~

垂直条（每个单独序列|）是一个弹性的蛇，被称为一个有弹性的部分，是单独地可伸展到它的宽度的两倍，并绘制具有交替斜杠（/，\）一次延长。

上面特定的蛇有两个这样的伸展部分，给它四个可能的姿势：

<||=|||:)~

</\/\=|||:)~

<||=/\/\/\:)~

</\/\=/\/\/\:)~

此正则表达式定义了伸展最少的伸展蛇的一般形式：

<(\|+=)*\|+:\)~

可以用以下文字表示：

<，随后通过任何数目的序列|的连接与=迹象，随后:)~。

So <|:)~and <||:)~and <|=|:)~and <|=|=||=|||||=||:)~是可弯曲的蛇，而<=:)~and <=|:)~and <||=:)~and <|==||:)~不是。

易弯曲的蛇也可以朝左而不是朝右，例如~(:|||=||>。形式是一样的，只是被镜像。

挑战

编写一个程序，该程序使用两条彼此面对的伸缩性蛇的单行字符串，中间留有一定数量的空格。两条蛇都将处于其伸展最少的姿势（所有竖线，无斜线）。字符串将从右向蛇的尾部开始，然后从左向蛇的尾部结束（您可以选择假设还有尾随换行符）。

例如，这是一条可能的输入，在蛇之间有五个空格：

<|=||:)~.....~(:||||>

^{.为了清楚起见，我使用句点（）而不是实际的空格字符。}

蛇之间的零间距也是有效的输入：

<|=||:)~~(:||||>

我们说蛇在舌头这样触摸时在亲吻。

您的程序需要扩展两条蛇的可拉伸部分的某种组合，以使蛇之间的间隔最少（不重叠），即蛇尽可能接近接吻。

两条蛇的尾巴都是固定的，但它们的头部和身体可以移动-根据伸展的部分，向右移动，向右移动，向左移动。

程序的输出是单行字符串（加上可选的尾随换行符），该字符串显示蛇尽可能接近接吻的位置，并为延伸的可伸展部分绘制交替的斜线代替竖线。

例如，<|=||:)~.....~(:||||>（从上面）的输出为：

</\=||:)~~(:/\/\/\/\>

这是唯一的解决方案，因为在伸展部分的任何其他组合下，蛇会重叠或离接吻更远。

如果有多种解决方案，则输出可能是其中任何一种。

例如，如果输入是

<|=||:)~.....~(:|||=|>

输出可能是

<|=/\/\:)~~(:/\/\/\=|>

要么

</\=||:)~~(:/\/\/\=/\>

请记住，并非总是能够使蛇亲吻，但是您仍然需要使它们尽可能靠近。

例如，如果输入是

<||=||||:)~...~(:||>

输出可能是

</\/\=||||:)~.~(:||>

要么

<||=||||:)~.~(:/\/\>

如果蛇已经在接吻，则输出将与输入相同。例如

<|=||:)~~(:||||>

通常，如果任何可伸展部分的延伸会使蛇重叠，则输出将与输入相同。例如

<|||=|||:)~..~(:||||=|||||=||||||>

笔记

像往常一样从stdin或命令行获取输入，或编写一个带有字符串的函数。打印或返回输出。
如果愿意，可以.在输入和输出中使用句点（）代替空格（）。
在斜杠被替换的垂直条序列中交替出现斜线是唯一重要的。不管它们在蛇中的顺序是大还是先是斜线还是后斜线都没有关系。
可伸展的部分不能延伸一半-完全是延伸或根本没有延伸。

计分

这是代码高尔夫球。以字节为单位的最短提交获胜。决胜局是较早的答案。

— 卡尔文的爱好
source

17

Snex Education 101-如何正确接吻

— 优化器

45

“我们说蛇的舌头像这样触摸时它们正在亲吻。” 我在读什么...

— Fatalize 2015年

8

那么蛇只法语吗？

— Optimizer

3

@PeterTaylor好吧，“镜像”，而不是“反转”（否则，对于和，>都不会变得<相同），但他还说：“斜线在它们替换的竖线的序列中交替出现是很重要的。不管是大蛇还是先斜线还是后斜线都没关系。” ()

— 马丁·恩德

7

@qwr想象力。

— 加尔文的爱好

9

CJam，87 71 70 68字节

l:L"|"f&Qa%_,Y\m*\f{.{_,"/\\"*?}L'|%.\s" /"1$fe=:-\a+}${0a>}=~S%\S**

在CJam解释器中在线尝试。

这个怎么运作

l:L        e# Read a line from STDIN and save it in L.
"|"f&      e# Intersect each character with the string "|".
           e# This pushes either "|" or "".
Qa%        e# Split the resulting array at runs of "".
_,         e# Compute the length of the resulting array (A).
           e# This yield K, the number of stretchy parts.
Y\m*       e# Push the array of all vectores in {0,1}^K.
\f{        e# For each vector V in {0,1}^K, push V and A; then:
  .{       e#   For each C in V and the corresponding P in A:
    _,     e#     Compute the length of the stretchy part P.
    "/\\"* e#     Repeat "/\" that many times.
    ?      e#     If C, select P; else, select "/\"*length(P).
  }        e#   This modifies A.
  L'|%     e#   Split L at runs of vertical lines.
  .\s      e#   Interleave the chunks of L and the modified A. Sringify.
           e#   In each iteration, this constructs a different modification of L,
           e#   with some stretched out stretchy parts.
  " /"1$   e#   Push " /" and a copy of the modified L.
  fe=      e#   Calculate the number of spaces and slashes in the modifed L.
  :-       e#   Subtract the number of occurrences.
  \a+      e#   Construct the array [difference modified-L].
}          e#
$          e# Sort the array (by final number of spaces).
{0a>}=     e# Find the first element greater than [0].
           e# This skips over too far stretched snakes, where the number of
           e# slashes is less than the number of spaces.
~          e# Dump the difference (D) and modified L on the stack.
S%         e# Split L at runs of spaces.
\S*        e# Construct a string of D spaces.
*          e# Join the split L, delimiting by D spaces.

— 丹尼斯
source

19

视网膜，209个 107 99 97 92字节

.(?=(.+)(?<=(?=<((\|+|(?<-5>\|(?=\1())?)+)[^|]+)+$(?(5)!)).+( )+\S+))\4
/ \
+` (.*~|~.*) 
$1

为了进行计数，每一行都放在一个单独的文件中，但是您可以从带有-s标志的单个文件中运行代码。

将.NET正则表达式和Retina的最佳功能结合在一起：平衡组，任意长度的后置和重复的正则表达式替换。

本质上，长的正则表达式对有效的解决方案进行编码，而正则表达式引擎的回溯器为我找到了最佳解决方案之一。

说明

首先，让我们考虑如何使用正则表达式找到有效的解决方案（不一定产生正确的输出）。我们可以使用.NET的平衡组来帮助我们计算拉伸部分。考虑以下更简单的正则表达式：

\S+( )+.+(?<=(?(1)!)^([^|]+(\|+|(?<-1>\|)*))+>)

我们可以剖析。

\S+( )+.+

这与整个字符串匹配，将1每个输入的一个捕获推入组堆栈。我们将使用该堆栈来确保可拉伸部分完全填充捕获到这些组中的空间。

接下来是一个回望。问题是，.NET中的lookbehinds从右到左是匹配的（因此您应该阅读它们）。这为我们提供了第二次遍历字符串的机会，从而确定是否存在一部分弹性部分加起来等于匹配空间的数量。从右到左浏览后面的内容：

这只是确保我们实际上是从字符串的末尾（蛇的尾巴）开始的。

(
  [^|]+
  (
    \|+
  |
    (?<-1>\|)+
  )
)+

(?(1)!)^

最后，我们确保遍历整个字符串（两条蛇），并且堆栈1完全为空。也就是说，我们找到了一个可拉伸部分的子集，该子集恰好等于我们之前捕获的空间数。

Backtracker将尝试通过字符串来回尝试所有未更改部分和扩展部分的组合，直到解决子集总和问题。如果不存在这样的子集，则后向查找将失败。这将使回溯器返回到该\S+( )+.+零件，并尝试使用少捕获一个空间( )+（而只是被其遮盖了.+）。由于我们的贪婪，+因此我们尝试填充尽可能多的空间。

您可以通过以下稍微修改的替换来检查此方法的有效性：

\S+(( )+).+(?<=(?(2)!)^([^|]+(\|+|(?<-2>\|)*))+>)
=$1=

这将为您提供一个字符串=spaces=，其中包含给定蛇可以完全填充的空格数。

我必须添加一些技巧才能真正扩展正确的|s。基本上，我想替换所有|使用(?<-1>\|)+分支匹配的。想法是匹配单个字符，将求解器放在环视范围内，如果匹配恰好在该分支内，则设置标志。如果未设置该标志，我们将在最后使匹配无效，以避免替换其他字符。

为此，我们使用了一堆嵌套的环顾四周。同样，.NET的可变长度lookbehinds从右到左是匹配的，因此，如果我们嵌套lookaheads和lookbehinds，则可以让正则表达式引擎多次遍历字符串。出于打高尔夫球的原因，求解器在我的实际解决方案中是相反的（从结尾开始，从右到左拾取空间，然后从左到右求解子集总和），但是求解器的结构完全相同。让我们剖析完整的正则表达式：

.(?=(.+)...)

我们匹配一个字符，然后捕获字符串的其余部分，然后将光标移到字符串的末尾。稍后我们将使用该组1来检查求解器是否在匹配位置。

(?<=....+( )+\S+)

这类似于上面的简单求解器的第一部分，不同之处在于我们从右到左拾取了空格。回溯空格数量的工作原理与以前完全相同，只是我们现在正在使用group 5。

(?=<((\|+|(?<-5>\|(?=\1())?)+)[^|]+)+$(?(5)!))

这与以前相同，除了我们要从左到右移动，并且每当我们|在扩展分支中匹配a 时，我们都会检查它是否与

(?=\1())?

这是可选的前瞻。它尝试1再次匹配组（在这里，只有当我们紧跟在匹配的字符之后才可能），如果匹配，我们将一个空字符串捕获到group中4，这表明我们确实在一个字符中找到了当前字符。扩展位。如果\1不匹配，4则不会捕获任何内容，并?确保失败的超前行为完全不会影响求解器。

最后，在完成所有求解之后，我们只需检查\4是否已使用了该超前功能。如果是这样，我们要用替换当前字符/\。

仍然存在一个难题：删除适量的空格。到目前为止，我发现的最简单的方法是在旁边插入一个空格/\，然后在单独的步骤中为每个标记空间消除舌头之间的一个空格：

+` (.*~|~.*) 
$1

— 马丁·恩德
source

6

红宝石191 187 186 170 162

->t{s=r=t.size
i=m=t[o=/ +/].size
(0...2**t.scan(y=/\|+/).size).map{|n|q=-1
x=t.gsub(y){|r|n[q+=1]<1?r:'\/'*r.size}
d=i+s-x.size
d<0||d<m&&r=x.gsub(o,' '*m=d)}
r}

这是一个将字符串作为参数并返回字符串的函数。

在线测试：http：//ideone.com/uhdfXt

这是可读的版本：

# enumerates the possible states for any string containing snakes
COMBINATIONS =-> snake {
  expandable_fragments = snake.scan /(\|+)/

  (0...2**(expandable_fragments.size)).map{ |i|
    x=-1
    snake.gsub(/\|+/){|r| i[x+=1]>0 ? '\/'*r.size : r}
  }
}

# finds the configuration in which snakes are closest to each other
KISS=
-> input {
  result = input
  s = input.size
  initial_distance = min_distance = input[/ +/].size

  COMBINATIONS[input].map{|c|
    distance = initial_distance + s - c.size
    if distance > -1 && distance < min_distance
      min_distance = distance
      result = c.gsub(/ +/,' '*distance)
    end
  }

  result
}

在高尔夫版本中，主要功能与KISS上面的功能等效，并且该COMBINATIONS功能已内联。

— 克里斯蒂安·卢帕斯库（Cristian Lupascu）
source

输入失败<|=||:)~~(:||||>，规范中提到这是有效输入。

— 值墨水

6

Python，205个字节

from itertools import*
f=lambda s:min([c.replace(".","",c.count("X"))for c in map("".join,product(*map({"|":"|X"}.get,s,s)))if{c.count("X")>c.count("."),"|X"in c,"X|"in c}=={0}],key=len).replace("X","/\\")

拥有一个lambda看起来很整洁，但是我几乎可以肯定这不是最好的方法。但是我发布这个是因为到目前为止，我所拥有的一切看起来还不错。

这是对的所有可能替换的简单蛮力，|以/\过滤掉无效的配置。唯一的整齐一点我想的是，我们实际上并不取代任何|与/\直接-我们第一次替换|用X拖放一个.从中间的每更换，以最小长度的字符串对所有有效的字符串，然后更换Xs的/\。

我尝试了其他一些方法，包括递归方法，但是它们最终变得非常混乱。我还了解到，re.split目前不能拆分成空字符串，这是不幸的，因为我的想法之一涉及拆分\b单词边界。

— Sp3000
source

5

Mathematica，381个字节

StringReplace[MapAt[StringReplace[#,"|"->"/\\"]&,StringSplit[#<>"="<>#2,"="],#3]~StringRiffle~"=",")="->")~"<>If[#4>0,"."~StringRepeat~#4,""]<>"~"]&[#1,#3,Sequence@@Function[{l,s},{#,#2-Total@Extract[l,#]}&[Flatten[l~Position~#~Take~#2&@@@Tally@#&@@Select[Subsets@l,Total@#<=s&]~MaximalBy~Total,1],s]][StringLength/@StringCases[#1<>#3,"|"..],StringLength@#2]]&@@#~StringSplit~"~"&

以字符串为参数的纯函数。期望.而不是蛇之间。

我没想到会这么糟糕...这就是我将它捣碎并固定好所有东西之前的样子。

f[lhs_, rhs_, 
  spaces_] := {StringLength /@ StringCases[lhs <> rhs, "|" ..], 
  StringLength@spaces}

g[barLens_, 
   spaceLen_] := {#, #2 - Total@Extract[barLens, #]} & @@ {Flatten[
     Take[Position[barLens, #], #2] & @@@ 
      Tally[First[
        MaximalBy[Select[Subsets[barLens], Total@# <= spaceLen &], 
         Total]]], 1], spaceLen};

h[lhs_, rhs_, partspec_, newSpaceLen_] := 
 StringReplace[
  StringRiffle[
   MapAt[StringReplace[#, "|" -> "/\\"] &, 
    StringSplit[lhs <> "=" <> rhs, "="], partspec], "="], 
  ")=" -> ")~" <> 
    If[newSpaceLen > 0, StringRepeat[".", newSpaceLen], ""] <> "~"]

 h[#1, #3, Sequence @@ g @@ f[#1, #3, #2]] & @@ 
     StringSplit[#, "~"] &

这是一个带有解释的示例示例：

Input: "<|=||:)~.....~(:||||>"
@Call StringSplit[#, "~"] &, yielding  {"<|=||:)", ".....", "(:||||>"}
@@Apply h[#1, #3, Sequence @@ g @@ f[#1, #3, #2]] &, but first
Set arguments: h["<|=||:)", "(:||||>", Sequence @@ g @@ f["<|=||:)", "(:||||>", "....."]]
@Call f, yielding {{1, 2, 4}, 5} = {# of bars in each segment, # of spaces}
@@Apply g, let's trace from the interior:
Subsets[barLens] = all subsets of {1, 2, 4}
Select those subsets whose sum is less than # of spaces {{},{1},{2},{4},{1,2},{1,4}}
MaximalBy Total, yielding a list of all subsets whose sum is maximal {{1, 4}}
First of these subsets, can be any of them {1, 4}
Tally the subset, yielding frequencies of each {{1, 1}, {4, 1}}
@@@Apply Take[Position[barLens, #], #2] & at the first level, yielding
    {Take[Position[{1, 2, 4}, 1], 1], Take[Position[{1, 2, 4}, 4, 1]]}
    which takes the first 1 positions of 1 and the first 1 positions of 4, yielding
    {{{1}},{{3}}}
Flatten at the first level, yielding {{1}, {3}}
Create a list {{{1}, {3}}, 5}
@@Apply {#, #2 - Total@Extract[barLens, #]} &, inserting arguments:
    {{{1}, {3}}, 5 - Total@Extract[{1, 2, 4}, {{1}, {3}}]} = {{{1}, {3}}, 0}
    where the second element becomes the # of spaces left over.
Done with g, it returned {{{1}, {3}}, 0}
@@Apply Sequence, splicing the return of g into h, yielding the
@Call, h["<|=||:)", "(:||||>", {{1}, {3}}, 0]; let's start from the interior
StringSplit the concatenated "<|=||:)=(:||||>" with delimiter "=", {"<|","||:)","(:||||>"}
MapAt the part specification {{1}, {3}} and StringReplace at those indices any | with /\
    yielding {"</\","||:)","(:/\/\/\/\>"}
StringRiffle together, inserting back the delimiter "=", yielding "</\=||:)=(:/\/\/\/\>"
StringReplace ")=" with ")~", concat the new number of spaces, concat "~"
Yields "</\=||:)~~(:/\/\/\/\>", done.

— ca
source

通过a=StringReplace;b=StringSplit;c=StringLength;d=Total;将其替换为内部的其他位置所需的内容轻松地减少到355 ：

a=StringReplace;b=StringSplit;c=StringLength;d=Total;a[MapAt[a[#,"|"->"/\\"]&,b[#<>"="<>#2,"="],#3]~StringRiffle~"=",")="->")~"<>If[#4>0,"."~StringRepeat~#4,""]<>"~"]&[#1,#3,Sequence@@Function[{l,s},{#,#2-d@Extract[l,#]}&[Flatten[l~Position~#~Take~#2&@@@Tally@#&@@Select[Subsets@l,d@#<=s&]~MaximalBy~d,1],s]][c/@StringCases[#1<>#3,"|"..],c@#2]]&@@#~b~"~"&

— Alex Meiburg 2016年

3

Prolog（ECLiPSe），438个字节

我的其他答案是解决错误的问题（对不起声音）。这是Prolog中的另一种尝试，它实际上遵守所有规则。

:-lib(fd).
a([],[]).
a([H|T],L):-append(H,X,L),a(T,X).
s(E,Z,X,Y,L):-length(E,L),a([[60],M,[58,41,126],T,[126,40,58],W,[62]],E),checklist(=(32),T),length(T,Z),b(M,X-[]),b(W,Y-[]).
b(I,[K:M|R]-E):-(I:K=[47,92|L]:s;I:K=[124|L]:n),M#=N+1,N#>=0,b(L,[K:N|R]-E).
b([61|L],[_:0|R]-E):-b(L,R-E).
b([],[_:0|E]-E).
d(_:N,Y:N):-Y=s;Y=n.
s(W,P):-string_list(W,E),s(E,_,X,Y,L),minimize((maplist(d,X,U),maplist(d,Y,V),s(K,Q,U,V,L)),Q),string_list(P,K).

测验

（格式：输入，输出，换行符）

<===:)~         ~(:>
<===:)~         ~(:>

<|||:)~         ~(:||||=|>
</\/\/\:)~ ~(:/\/\/\/\=/\>

<=|=:)~         ~(:||||=|>
<=/\=:)~   ~(:/\/\/\/\=/\>

<===|:)~         ~(:||=|>
<===/\:)~     ~(:/\/\=/\>

<|=|=|||=|:)~         ~(:=|>
</\=/\=/\/\/\=/\:)~  ~(:=/\>

<||||||:)~         ~(:=|>
</\/\/\/\/\/\:)~  ~(:=/\>

<||||||:)~         ~(:||>
</\/\/\/\/\/\:)~ ~(:/\/\>

<||=||||:)~ ~(:||>
<||=||||:)~ ~(:||>

<||=||||:)~   ~(:||>
</\/\=||||:)~ ~(:||>

<||=||||:)~    ~(:||>
</\/\=||||:)~~(:/\/\>

<||=||||:)~~(:||>
<||=||||:)~~(:||>

说明

主要谓词是s/2，它将输入作为第一个参数，并使用第二个参数（两个字符串）取消匹配结果。输入将转换为字符代码列表E。
然后，s(E,Z,X,Y,L)将列表分解为以下元素：
- Z 蛇之间的间隔数
- X和Y，左右身体的抽象表示
  
  主体的格式是n:N或s:N表达式的列表，其中N是正长度；n手段normal和s手段stretched。
- L 清单的总长度

有趣的s/5是，它是双向的，即如果实例化了其他参数，我们可以制造一条蛇：

    s(E,5,[n:3],[s:2,n:7,s:1],_),string_list(S,E).

... unifies `S` with `"<|||:)~     ~(:/\\/\\=|||||||=/\\>"` (backslashes are quoted). This is due to how `b/2` is written, which can parse the character list or generate it.

我们构建修改后的左右身体，其中每个部分都是正常的或拉伸的，同时最小化了Q分隔新蛇的空间。计算字符串的总长度是有界的，以便搜索终止。

— 核心转储
source

1

Python 2.7.3 427 421 400 371字节

import re,itertools as K
g,o,k='\|+',len,raw_input()
d=k.count(' ')
if d==0:exit(k)
p,x,y,s=re.sub,0,0,map(o,re.findall(g,k))
for e in [A for w in range(o(s)+1)for A in K.combinations(s,w)]:
 v=sum(e)
 if v==d or x<v<d:x,y=v,list(e)
print p(" +",' '*(d-x),p(g,lambda m:('/\\'*o(m.group(0))if y.remove(o(m.group(0)))or True else 1)if o(m.group(0))in y else m.group(0),k))

这里的非高尔夫代码-

#!/usr/bin/env python
import sys
import re

def find_dist_combo(li, d):
    #Listing all combinations
    from itertools import combinations as c
    max_dist = -1
    max_dist_combo = []
    for p_len in xrange(1,len(li)+1):
        for e in c(li, p_len):
            e_sum = sum(e)
            cond1 = e_sum == d
            cond2 = max_dist < e_sum < d
            if cond1 or cond2:
                max_dist = e_sum
                max_dist_combo = list(e)
                if cond1:
                    return (max_dist, max_dist_combo)
    return (max_dist, max_dist_combo)

def snakes_foreplay(snakes):
    #find distance
    distance = snakes.count(" ")

    #already kissing
    if distance == 0:
        return snakes

    #find num_stretches
    stretch = map(len, re.findall("\|+", snakes))

    #find lowest combination of numbers
    (e_dist, res_stretch) = find_dist_combo(stretch, distance)

    def sub_callback(m):
        s = m.group(0)
        l = len(s) 
        if l in res_stretch:
            res_stretch.remove(l)
            return '/\\'*l
        return s

    #Resultant substitution
    res_snakes = re.sub("\s+", " "*(distance - e_dist), re.sub("\|+", sub_callback, snakes))

    return res_snakes

if __name__ == "__main__":
    for s in [ip.strip() for ip in sys.stdin]:
        print snakes_foreplay(s)

测试高尔夫球解决方案-

$ python stretchy_snakes.py
[In]  <=  <|=||:)~     ~(:||||>
[Out] =>  </\=||:)~~(:/\/\/\/\>

$ python stretchy_snakes.py
[In]  <=  <|=||:)~             ~(:||||>
[Out] =>  </\=/\/\:)~      ~(:/\/\/\/\>

$ python stretchy_snakes.py
[In]  <=  <|=||:)~     ~(:|||=|>
[Out] =>  </\=||:)~~(:/\/\/\=/\>

$ python stretchy_snakes.py
[In]  <=  <||=||||:)~   ~(:||>
[Out] =>  </\/\=||||:)~ ~(:||>

$ python stretchy_snakes.py
[In]  <=  <|=||:)~~(:||||>
[Out] =>  <|=||:)~~(:||||>

当然可以做得更好（我不知道怎么做：））。
让我知道打高尔夫球时是否错过了任何明显的事情（这是我的第一个高尔夫，我可能正在做一些愚蠢的：P事情）

— 卡美哈美哈
source

@ Sp3000那是一个好人。替换exit为sys.exit()（已exit存在）。而且您是对的，__import__可以删除，消除了20个字符：)

— Kamehameha 2015年

顺便说一句：对于别名，> 6如果使用两次，> 3则需要使用chars才能值得别名；如果使用三次，则需要使用chars。我不确定f=' '别名是否值得（我数了两次）

— Sp3000

@ Sp3000是的，您是对的。在较早的版本中，我曾三次使用该变量。为我节省了另外几个字节:) :)

— Kamehameha 2015年

1

05AB1E，93 字节

#õKDεγʒ'|å]©ε€gxøDgU`XGâ€˜]`âDε˜ODI„| Ãg>‹*}ZQÏε˜ε®˜NèDgyÊi„/\y∍]н©J'/¢Ið¢αð×ý'|¡õK®.ιJIðå≠iI

太长了..>>

在线试用或验证所有测试用例或验证所有可能的结果对所有的测试用例。

说明：

#õK                   # Split the (implicit) input by one or multiple adjacent spaces
                      # (we now have both snakes as separated items
                      #  - if any spaces were in the input-string)
   D                  # Duplicate this list
    ε                 # Map both snakes to:
     γ                #  Split the snake into chunks of the same character-type
      ʒ'|å]          '#  And only leave the chunks of "|" characters
    ©                 #  Store this list in variable `r` (without popping)
     ε                #  Map the "|" chunks of both snakes again:
      €g              #  Get the length of each chunk of "|"
        xø            #  Pair each length with double itself
          DgU`XGâ€˜   #  Create all possible combinations for the current snake
     ]`â              # After the map: create all possible combinations for both snakes
        ε             # Map over each possible combination
         ˜O           #  Get the flattened sum
            I„| Ãg    #  Count the amount of "|" and spaces in the input
                  >‹  #  Check if it's smaller than or equal to this sum
                      #  (1 if truthy; 0 if falsey)
           D        * #  And multiply it by the sum
        }ZQ           # After the map, get the positions of the largest flattened sum,
                      # still below (or equal to) the amount of "|" and spaces combined
       D   Ï          # And only keep those combinations
ε                     # Then map over the remaining combinations
 ˜ε                   #  Flatten it, and map over each value `y`
   ®˜Nè               #   Get the `N`'th part of the snakes
                      #   (where `N` is the index of the map for the current combination)
       D              #   Duplicate this "|"-part
        gyÊi          #   If the length of this "|"-part is not equal to the map-value:
            „/\       #    Push the string "/\"
               y∍     #    Extended to a size equal to the map-value
                      #   (implicit else:
                      #    use the duplicated value)
]н                    # After the map: only leave the first (since we don't have
                      # to output all possibilities)
 ©                    # Store it in variable `r` (without popping)
  J'/¢               '# Count the amount of "/" in it
      Ið¢             # Count the amount of spaces in the input
         α            # Get the difference between those
          ð×ý         # And join the list of snakes by that many spaces
'|¡õK                '# Then split by one or multiple adjacent "|"
     ®.ι              # Interleave it with the modified parts of variable` r`
        J             # And join everything together to a single string
Iðå≠i                 # If the input didn't contain any spaces:
     I                #  Output the input instead
                      # (implicit else:
                      #  output the top of the stack before this if)

— 凯文·克鲁伊森
source

做蛇蛇之吻

挑战

笔记

计分