Lý lịch

Ba năm trước, anh chàng Tom Murphy này đã đưa nó vào đầu để mở rộng ý tưởng về một portmanteau cho tất cả các từ trong một ngôn ngữ và gọi đây là một portmantout ( portmanteau plus tout [tiếng Pháp cho tất cả ]). Xác định tiếng Anh là danh sách 108.709 từ, anh quản lý để tìm một chuỗi gồm 611.820 chữ cái với hai thuộc tính sau:

• Mỗi từ tiếng Anh được chứa trong chuỗi.
• Một số vùng lân cận chứa bất kỳ hai chữ cái liền kề trong chuỗi là một từ tiếng Anh.

Đây là một liên kết đến một trang mà trên đó có thể tìm thấy portmantout này (cùng với một lời giải thích video).

Một portmantout

Điều đầu tiên trong hai thuộc tính của một portmantout là dễ hiểu. Thứ hai có thể yêu cầu một số lời giải thích.

Về cơ bản, các từ phải chồng chéo. "Golfcode" sẽ không bao giờ xuất hiện trong phần mô tả tiếng Anh, vì không có từ nào có chứa "fc". Tuy nhiên, bạn có thể tìm thấy "codegolf" trong một bản portmantout, vì "cái tôi" thu hẹp khoảng cách (và tất cả các cặp chữ cái khác nằm trong "mã" hoặc "golf").

Nhiệm vụ của bạn:

Viết chương trình hoặc hàm lấy danh sách các chuỗi và trả về bất kỳ portmantout nào của danh sách.

Mã Python 3 này sẽ xác minh một portmantout.

Các trường hợp thử nghiệm

Tất cả các danh sách là không có thứ tự; đó là,

{"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

Và tại sao không? Số lượng lớn trên trang web của Murphy, nếu mã của bạn thực thi trong thời gian hợp lý.

Quy tắc

• Mã của bạn phải dừng lại.
• Bạn không cần phải trả lại cùng một portmantout với mỗi lần thực hiện.
• Bạn có thể giả định tất cả các chuỗi chỉ gồm chữ thường athông qua z.
• Nếu không có khả năng portmantout, chương trình của bạn có thể làm bất cứ điều gì. Ví dụ:{"most", "short", "lists"}
• Quy tắc chuẩn cho I / O và sơ hở được áp dụng.

Đây là môn đánh gôn , vì vậy giải pháp ngắn nhất (tính bằng byte) trong mỗi ngôn ngữ sẽ thắng! Chúc bạn chơi golf vui vẻ!

Python 2 , 204 202 byte

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

Hãy thử trực tuyến!

Đã lưu

• -2 byte, nhờ đệ quy

Bình thường, 39 byte

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

Hãy thử nó ở đây

Giải trình

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 byte

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

Chạy và gỡ lỗi nó

Chạy tất cả các trường hợp thử nghiệm một cách xác định trong khoảng một giây.

Đây là một thuật toán đệ quy.

• Bắt đầu với mỗi từ đầu vào như một ứng cử viên
• Ở mỗi bước, sắp xếp các từ theo số lần chúng xuất hiện dưới dạng chuỗi con của ứng viên.
• Đối với mỗi từ tương thích với phần cuối của ứng cử viên hiện tại, hãy nối từ đó để tạo thành một ứng cử viên mới và thực hiện cuộc gọi đệ quy.

Đây là chương trình giải nén, không ghi chú và nhận xét.

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

Chạy cái này

Chỉnh sửa: Điều này không thành công đối với một lớp đầu vào có vòng lặp, giống ["ab", "ba", "ca"]như hầu hết các câu trả lời được đăng khác.

JavaScript (ES6), 138 130 byte

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

Trả về một lỗi cho các danh sách không thể được đưa ra hoàn toàn.

Ung dung:

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"

Mã này rất chậm trên ví dụ bảng chữ cái đầy đủ (không bao gồm vì lý do đó trong Đoạn trích trên).

Điều đó được khắc phục bằng cách thay đổi maps thành somes, vì mất 2 byte:

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"