배경

3 년 전,이 톰 머피 (Tom Murphy) 는 포트만 토라는 아이디어를 언어로 된 모든 단어로 확장하기 위해 그것을 머리에 싣고 이것을 포트만 트 아웃 ( portmanteau plus tout [French for all ]) 이라고 불렀습니다 . 영어를 108,709 단어 목록으로 정의하면서 그는 다음 두 가지 특성을 가진 611,820 개의 문자 시퀀스를 찾을 수있었습니다.

• 모든 영어 단어가 문자열에 포함됩니다.
• 문자열에 인접한 두 글자가 포함 된 일부 이웃은 영어 단어입니다.

다음 은이 포트만 트 아웃을 찾을 수있는 페이지에 대한 링크입니다 (비디오 설명과 함께).

포트만 트 아웃

포트만 트 아웃의 두 속성 중 첫 번째 속성은 이해하기 쉽습니다. 두 번째는 약간의 설명이 필요할 수 있습니다.

기본적으로 단어는 겹칩니다. "fc"를 포함하는 단어가 없기 때문에 "golfcode"는 영어로 표시된 포트만에 나타나지 않습니다. 그러나 포트만 트 아웃에서 "egogo"를 찾을 수 있습니다. "ego"는 간격을 메 웁니다 (다른 모든 문자 쌍은 "code"또는 "golf"입니다).

당신의 작업 :

문자열 목록을 가져 와서 목록의 포트만 출력하는 프로그램이나 함수를 작성하십시오.

이 Python 3 코드 는 포트만 트 아웃을 확인합니다.

테스트 사례

모든 목록은 순서가 없습니다. 그건,

{"code", "ego", "golf"} -> "codegolf"
{"more", "elm", "maniac"} -> "morelmaniac" or "morelmorelmaniac" or "morelmorelmorelmaniac" or...
    Would a morelmaniac be some sort of mycologist?
{"ab", "bc", "cd", "de", "ef", "fg", "gh", "hi", "ij", "jk", "kl", "lm", "mn", "no", "op", "pq", "qr", "rs", "st", "tu", "uv", "vw", "wx", "xy", "yz", "za"} -> "abcdefghijklmnopqrstuvwxyza" or "rstuvwxyzabcdefghijklmnopqrstuvwxyzabcdef" or any 27+ letters in order

왜 안돼? 코드가 적절한 시간 내에 실행되는 경우 Murphy 사이트의 대규모 코드입니다.

규칙

• 코드가 정지되어야합니다.
• 각 실행마다 동일한 포트만 트 아웃을 리턴 할 필요는 없습니다.
• 당신은 모든 문자열은 소문자로 구성되어 가정 할 수 a을 통해 z.
• 포트만 트 아웃이 가능하지 않으면 프로그램이 무엇이든 할 수 있습니다. 전의:{"most", "short", "lists"}
• I / O 및 허점에 대한 표준 규칙이 적용됩니다.

이것은 code-golf 이므로 각 언어에서 가장 짧은 솔루션 (바이트)이 이깁니다! 행복한 골프!

파이썬 2 , 204202 바이트

def f(l,s=''):
 if all(w in s for w in l):return s
 for i,w in enumerate(l):
	a=next((s+w[i:]for i in range(len(w)-1,0,-1)if s[-i:]==w[:i]),0)if s else w;x=a and f(l[:i]+l[i+1:]+[l[i]],a)
	if x:return x

온라인으로 사용해보십시오!

저장되었습니다

• 재귀로 인한 -2 바이트

Pyth, 39 바이트

JQW}_1mxbdQ=+J|=b*qKOQ<=T+OP._KOJlKTY)b

여기 사용해보십시오

설명

JQW}_1mxbdQ=+J|=b*qKOQ<=T+OP._KOJlKTY)b
JQ                                        Get a copy of the input.
  W}_1mxbdQ                          )    While there are words in the input
                                          that aren't in b (initially space)...
                   KOQ    OP._KOJ         ... get a random input word, a random
                                          prefix, and a random joined word...
                       =T+                ... stick them together...
                  q   <          lKT      ... and check if joining them together
                                          is valid...
               =b*                        ... then update b accordingly...
           =+J|                     Y     ... and stick the new word into J.
                                      b   Output the final result.

Stax , 39 36 바이트

ä▬│•.k=╠lƒ☺╜00║¿~,▓╕╠7ÉΔB<e┼>☼Θ²└ô┴\

실행 및 디버깅

모든 테스트 케이스를 약 1 초 안에 결정적으로 실행합니다.

이것은 재귀 알고리즘입니다.

• 각 입력 단어를 후보로 시작하십시오.
• 각 단계에서 단어를 후보의 하위 문자열로 나타나는 횟수만큼 단어를 정렬하십시오.
• 현재 후보의 끝과 호환되는 각 단어에 대해 단어에 참여하여 새 후보를 형성하고 재귀 호출을합니다.

다음은 압축을 풀고 포장을 풀고 주석이 달린 프로그램입니다.

FG              for each word in input, call target block
}               unbalanced closing brace represents call target
  x{[#o         sort input words by their number of occurrences in the current candidate
  Y             store it in register Y
  h[#{,}M       if all of the words occur at least once, pop from input stack
                input stack is empty, so this causes immediate termination,
                followed by implicitly printing the top of the main stack
  yF            for each word in register y, do the following
    [n|]_1T|[|& intersect the suffixes of the candidate with prefixes of the current word
    z]+h        get the first fragment in the intersection, or a blank array
    Y           store it in register Y
    %t+         join the candidate with the current word, eliminating the duplicate fragment
    y{G}M       if the fragment was non-blank, recursively call to the call target
    d           pop the top of stack

이것을 실행

편집 : 이것은 ["ab", "ba", "ca"]다른 게시 된 답변 과 마찬가지로 루프가있는 입력 클래스에 대해 실패 합니다.

자바 스크립트 (ES6) 138 130 바이트

f=a=>a[1]?a.map((c,i)=>a.map((w,j,[...b])=>i!=j&&!/0/.test(m=(c+0+w).split(/(.+)0\1/).join``)?t=f(b,b[i]=m,b.splice(j,1)):0))&&t:a

완전히 이식 할 수없는 목록에 대한 오류를 반환합니다.

언 골프 드 :

f = a =>
  a[1] ?                                        //if more than one element ...
    a.map((c, i)=>                              // for each element
      a.map((w, j, [...b])=>                    //  for each element
        i != j &&                               //   if not the same element
        !/0/.test(m=(c+0+w).split(/(.+)0\1/).join``) &&  //   and the elements overlap
        (t = f(b,                               //   and f recursed is true when
               b[i] = m,    //    replacing the ith element with the 2-element portmanteau
               b.splice(j, 1)                   //    and removing the jth element
              )
        )
      )
    ) &&
    t :                                         //return the recursed function value
    a                                           //else return a

f=a=>a[1]?a.map((c,i)=>a.map((w,j,[...b])=>i!=j&&!/0/.test(m=(c+0+w).split(/(.+)0\1/).join``)?t=f(b,b[i]=m,b.splice(j,1)):0))&&t:a

console.log(f(["sic", "bar", "rabbits", "cradle"])+'')             // "barabbitsicradle"
console.log(f(["mauve", "elated", "cast", "electric", "tame"])+'') // "mauvelectricastamelated"

console.log(f(["more", "elm", "maniac"])+'')                       // "morelmaniac"
console.log(f(["elm", "more", "maniac"])+'')                       // "morelmaniac"
console.log(f(["more", "maniac", "elm"])+'')                       // "morelmaniac"

console.log(f(["ego", "code", "golf"])+'')                         // "codegolf"
console.log(f(["code", "ego", "golf"])+'')                         // "codegolf"
console.log(f(["golf", "ego", "code"])+'')                         // "codegolf"

console.log(f(['ab', 'bc', 'cd', 'de'])+'');                       // "abcde"
console.log(f(['de', 'bc', 'cd', 'ab'])+'');                       // "abcde"

console.log(f(["ab", "ba", "ca"])+'');                             // "caba"

전체 알파벳 예제에서 코드가 엄청나게 느립니다 (위의 스 니펫에는 해당 이유로 포함되지 않음).

2 바이트의 손실에 대해 maps를 somes 로 변경하면 해결됩니다 .

f=a=>a[1]?a.some((c,i)=>a.((w,j,[...b])=>i!=j&&!/0/.test(m=(c+0+w).split(/(.+)0\1/).join``)?t=f(b,b[i]=m,b.splice(j,1)):0))&&t:a

f=a=>a[1]?a.some((c,i)=>a.some((w,j,[...b])=>i!=j&&!/0/.test(m=(c+0+w).split(/(.+)0\1/).join``)?t=f(b,b[i]=m,b.splice(j,1)):0))&&t:a

console.log(f(["ab", "bc", "cd", "de", "ef", "fg", "gh", "hi", "ij", "jk", "kl", "lm", "mn", "no", "op", "pq", "qr", "rs", "st", "tu", "uv", "vw", "wx", "xy", "yz", "za"])+'');

console.log(f(["ab", "ba", "ca"])+'');                             // "caba"