신축성이 뱀 같은 :

<||=|||:)~

수직 막대 (각 개별 시퀀스 |A와 공지 신축성 뱀)에 신축성 부분은 회 폭을 각각 확장하고, 교류 슬래시 (그린되고 /, \한번 확장).

위의 특정 뱀에는 두 개의 신축성이있는 부분이있어서 네 가지 포즈가 가능합니다.

<||=|||:)~

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

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

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

가장 스트레칭이 적은 포즈의 신축성 뱀의 일반적인 형태는 이 정규식에 의해 정의됩니다 .

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

다음과 같이 말로 표현할 수 있습니다.

<의 서열의 숫자 다음 |의 결합 에 =이어, 표지판 :)~.

그리고 <|:)~and <||:)~and <|=|:)~and <|=|=||=|||||=||:)~는 신축성이있는 뱀이지만 <=:)~and <=|:)~and <||=:)~and <|==||:)~not.

신축성있는 뱀도 오른쪽 대신 왼쪽을 향할 수 있습니다 (예 :) ~(:|||=||>. 양식은 동일합니다.

도전

서로 마주 보는 두 개의 신축성있는 뱀으로 구성된 한 줄짜리 문자열을 사용하는 프로그램을 작성하십시오. 두 뱀은 가장 짧게 포즈를 취합니다 (모든 수직 막대, 슬래시 없음). 줄은 오른쪽을 향한 뱀의 꼬리로 시작하고 왼쪽을 향한 뱀의 꼬리로 끝납니다 (선택적으로 후행 줄 바꿈이 있다고 가정 할 수 있습니다).

예를 들어, 뱀 사이에 5 개의 공백이있는 입력이 있습니다.

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

^{.명확성을 위해 실제 공백 문자 대신 마침표 ( )를 사용하고 있습니다 .}

뱀 사이에 공백이없는 것도 유효한 입력입니다.

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

우리는 뱀이 혀가 이렇게 닿을 때 키스 하고 있다고 말합니다 .

당신의 프로그램은 뱀이 그들 사이에 가능한 한 적은 수의 공간을 갖도록 ( 즉 , 겹치지 않는), 즉 뱀이 가능한 한 키스에 가까워 지도록 두 뱀의 신축 부분의 조합을 확장해야 합니다 .

뱀의 꼬리는 모두 고정되어 있지만 머리와 몸은 오른쪽으로 향한 뱀의 경우 오른쪽으로, 왼쪽으로 향한 뱀의 경우 왼쪽으로 움직입니다.

프로그램의 출력은 확장 된 신축성 부분을 위해 세로 막대 대신 교대로 슬래시를 사용하여 뱀을 가능한 한 키스에 가깝게 표시하는 단일 행 문자열 (옵션 후행 줄 바꿈)입니다.

예를 들어, 위의 출력 <|=||:)~.....~(:||||>은 다음과 같습니다.

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

신축성있는 부분의 다른 조합이 확장되면 뱀이 겹치거나 키스에서 멀리 떨어져 있기 때문에 이것은 유일한 해결책입니다.

여러 솔루션이 가능한 경우 출력은 그 중 하나 일 수 있습니다.

예를 들어 입력이

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

출력은

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

또는

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

뱀에게 키스하는 것이 항상 가능하지는 않지만, 가능한 한 가깝게 접근해야합니다.

예를 들어 입력이

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

출력은

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

또는

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

뱀이 이미 키스하는 경우 출력은 입력과 동일합니다. 예 :

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

일반적으로 신축 부분의 연장으로 뱀이 겹치게되면 출력은 입력과 동일합니다. 예 :

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

노트

• 평소와 같이 stdin 또는 명령 행에서 입력을 받거나 문자열을 취하는 함수를 작성합니다. 출력을 인쇄하거나 반환하십시오.
• 원하는 경우 .공백 ( ) 대신 입력 및 출력에 마침표 ( )를 사용할 수 있습니다 .
• 슬래시가 교체 한 일련의 수직 막대 내에서 번갈아가는 것이 중요합니다. 뱀의 순서가 크거나 슬래시가 먼저 오는지 여부는 중요하지 않습니다.
• 신축성있는 부분은 부분적으로 확장 할 수 없습니다. 정확히 두 배이거나 전혀 확장되지 않습니다.

채점

이것은 code-golf 입니다. 바이트 단위의 최단 제출이 이깁니다. Tiebreaker가 이전 답변입니다.

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.

망막 , 209 (107) 99 97 92 바이트

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

계산을 위해 각 줄은 별도의 파일로 이동하지만 -s플래그 를 사용하여 단일 파일에서 코드를 실행할 수 있습니다 .

.NET 정규식과 Retina의 최고의 기능을 함께 제공합니다 : 그룹, 임의 길이 비하인드 및 반복 정규식 대체.

본질적으로 긴 정규식은 유효한 솔루션을 인코딩하고 정규식 엔진의 역 추적기는 최적의 솔루션 중 하나를 찾습니다.

설명

먼저 정규식으로 올바른 솔루션을 찾는 방법 (정확한 출력을 생성 할 필요는 없음)을 고려하십시오. .NET의 밸런싱 그룹 을 사용 하여 신축성있는 부품 수를 계산할 수 있습니다. 다음과 같은 간단한 정규식을 고려하십시오.

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

우리는 그것을 해부 할 수 있습니다.

\S+( )+.+

이것은 전체 문자열과 일치 1하여 입력의 각 공간에 대해 하나의 캡처를 그룹 스택으로 푸시합니다. 이 스택을 사용하여 신축성있는 부분이 해당 그룹으로 캡처 된 공간을 정확하게 채울 수 있습니다.

다음은 살펴보기입니다. 캐치 비하인드는 .NET에서 오른쪽에서 왼쪽으로 일치한다는 것입니다 (그래서 읽는 방법입니다). 이것은 우리에게 일치하는 공간의 수와 합쳐지는 신축성있는 부분의 부분 집합이 있는지 알아내는 두 번째로 문자열을 횡단 할 수있는 기회를 제공합니다. 오른쪽에서 왼쪽으로 lookbehind를 살펴보십시오.

>

이것은 우리가 실제로 줄의 끝 (뱀의 꼬리)에서 시작한다는 것을 보증합니다.

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

신축성있는 각 부분에 대해 이것은 아무것도하지 않고 전체 부분 \|+과 일치 시키거나 ( ) 터지는 동안 스택 전체를 일치시킵니다 1( (?<-1>\|)*). 이러한 교대를 가짐으로써 신축성있는 부분 만 완전히 확장하거나 변경하지 않은 채로두고 물건을 얻을 수 없습니다 |/\|. 그런 다음으로 다음 신축성있는 부분으로 넘어갑니다 [^|]+.

(?(1)!)^

마지막으로, 우리는 전체 문자열 (뱀 둘 다)을 가로 지르고 스택 1이 완전히 비어 있는지 확인합니다 . 즉, 이전에 캡처 한 공간 수와 정확히 일치하는 신축성 부분의 하위 집합을 찾았습니다.

역 추적기는 부분 집합 합계 문제가 해결 될 때까지 변경되지 않은 부분과 확장 된 부분의 모든 조합을 시도하는 문자열을 통해 앞뒤로 이동합니다. 이러한 하위 집합이 존재하지 않으면 lookbehind가 실패합니다. 이로 인해 백 트래커가 \S+( )+.+부품 으로 돌아가서 한 공간을 덜 차지하게됩니다 ( )+( .+대신 덮을 것입니다). +따라서 우리 는 탐욕 때문에 가능한 많은 공간을 채우려 고 노력합니다.

이 약간 수정 된 대체를 사용하여이 방법의 유효성을 확인할 수 있습니다.

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

=spaces=주어진 뱀으로 채워질 수있는 공간의 수를 정확하게 나타내는 줄을 줄 것입니다 .

실제로 올바른 |s를 확장하기 위해 더 많은 속임수를 추가해야했습니다 . 기본적으로 분기를 |사용하여 일치하는 모든을 바꾸고 싶습니다 (?<-1>\|)+. 아이디어는 개별 문자를 일치시키고 솔버를 둘러보고 해당 일치가 해당 분기 내에있는 경우 플래그를 설정하는 것입니다. 해당 플래그가 설정되지 않은 경우 다른 문자의 교체를 피하기 위해 끝에 일치를 무효화합니다.

이를 위해 다수의 중첩 된 둘러보기를 사용합니다. .NET의 가변 길이 lookbehinds는 오른쪽에서 왼쪽으로 일치하므로 lookaheads와 lookbehinds를 중첩하면 정규식 엔진이 문자열을 여러 번 통과하도록 할 수 있습니다. 골프의 이유로 인해 솔버는 실제 솔루션에서 끝납니다 (끝에서 시작하여 공간을 오른쪽에서 왼쪽으로 가져간 다음 하위 집합 합계를 왼쪽에서 오른쪽으로 해결). 그렇지 않으면 솔버의 구조는 정확히 같습니다 . 정규 표현식 전체를 해보자.

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

단일 문자를 일치시킨 다음 나머지 문자열을 캡처하고 커서를 문자열의 끝으로 이동합니다. 1나중에이 그룹을 사용 하여 솔버에서 매치 위치에 있는지 확인합니다.

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

위의 간단한 솔버의 첫 번째 부분과 비슷하지만 오른쪽에서 왼쪽으로 공백을 가져옵니다. 공간 수의 역 추적은 5지금 그룹을 사용한다는 점을 제외하면 이전과 정확히 동일하게 작동합니다 .

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

이것은 왼쪽에서 오른쪽으로 진행한다는 점을 제외하고는 이전과 동일 |하며 확장 지점에서 a와 일치 할 때마다 a와 일치 하는지 확인합니다.

(?=\1())?

이것은 선택적인 예견입니다. 그룹을 1다시 일치 시키려고 시도 합니다 (여기서는 문자가 일치 한 직후에 가능합니다). 그렇다면 빈 문자열을 group으로 캡처하여 그룹 4에서 현재 문자를 찾았 음을 나타냅니다. 확장 비트. 경우 \1일치하지 않는, 4아무것도를 캡처하고,되지 않습니다 ?실패한 내다 전혀 해석에 영향을 미치지 않습니다 보장합니다.

마지막으로 모든 해결이 완료된 \4후이 미리보기가 사용되었는지 확인 합니다. 그렇다면 현재 문자를로 바꾸고 싶습니다 /\.

한 가지 어려움이 남아 있습니다. 적절한 양의 공백을 제거하십시오. 내가 지금까지 찾은 가장 짧은 방법은와 함께 공백을 삽입 한 /\다음 별도의 단계에서 각 마커 공간에 대한 텅 사이에 하나의 공백을 제거하는 것입니다.

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

루비 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기능이 인라인되었습니다.

파이썬, 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","/\\")

하나의 람다가 깔끔하게 보이지만 이것이 최선의 방법은 아니라고 확신합니다. 그러나 나는 이것이 지금까지 가지고있는 전부이기 때문에 이것을 게시하고 있습니다.

이것은 모든 가능한 교체를 통해 간단한 무력하다 |와 /\잘못된 구성을 필터링. 내가 생각하는 유일한 깔끔한 비트는 우리가 실제로 대체하지 않는다는 것입니다 |와 /\직접 - 우리는 먼저 교체 |로 X하고 드롭 .한 후 교체, 모든 유효한 문자열을 통해 최소 길이 문자열을, 모든 교체를 위해 중앙에서 X의과 /\.

재귀 적 접근법을 포함하여 다른 접근법을 시도했지만 결국 혼란 스러웠습니다. 또한 re.split현재 빈 문자열로 나뉘 지 않는다는 것을 배웠습니다. 불행히도 내 아이디어 중 하나는 \b단어 경계를 나누는 것과 관련이 있기 때문 입니다.

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.

프롤로그 (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:NNnnormalsstretched

  • 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는 새로운 뱀을 분리하는 공간 을 최소화하면서 각 부분이 정상이거나 늘어나는 수정 된 왼쪽 및 오른쪽 바디를 만듭니다 . 계산 된 문자열의 총 길이는 검색이 종료되도록 제한됩니다.

파이썬 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] =>  <|=||:)~~(:||||>

확실히 이것은 더 잘 이루어질 수 있습니다 (어떻게 알아낼 수는 없습니다 :)).
골프를 치는 동안 분명한 것을 놓친 경우 알려주십시오 (저의 첫 번째 코드 골퍼입니다.

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)