Latar Belakang

Tiga tahun yang lalu, orang ini Tom Murphy memasukkannya ke dalam kepala untuk memperluas gagasan portmanteau ke semua kata dalam bahasa dan menyebut ini portmantout ( portmanteau plus tout [Bahasa Prancis untuk semua ]). Mendefinisikan bahasa Inggris sebagai daftar 108.709 kata, ia berhasil menemukan urutan 611.820 huruf dengan dua properti berikut:

• Setiap kata bahasa Inggris terkandung dalam string.
• Beberapa lingkungan yang berisi dua huruf yang berdekatan dalam string adalah kata bahasa Inggris.

Berikut ini tautan ke halaman tempat portmantout ini dapat ditemukan (bersama dengan penjelasan video).

Portmantout

Yang pertama dari dua properti portmantout mudah dimengerti. Yang kedua mungkin membutuhkan penjelasan.

Pada dasarnya, kata-kata harus tumpang tindih. "golfcode" tidak akan pernah muncul di portmantout bahasa Inggris, karena tidak ada kata di sana yang berisi "fc". Namun, Anda mungkin menemukan "codegolf" di portmantout, karena "ego" menjembatani kesenjangan (dan semua pasangan huruf lainnya berada dalam "kode" atau "golf").

Tugas Anda:

Tulis program atau fungsi yang mengambil daftar string dan mengembalikan portmantout daftar.

Kode Python 3 ini akan memverifikasi portmantout.

Uji kasus

Semua daftar tidak berurutan; itu adalah,

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

Dan kenapa tidak? Yang besar di situs Murphy, jika kode Anda dieksekusi dalam waktu yang wajar.

Aturan

• Kode Anda harus dihentikan.
• Anda tidak perlu mengembalikan portmantout yang sama dengan setiap eksekusi.
• Anda mungkin menganggap semua string hanya terdiri dari huruf kecil amelalui z.
• Jika tidak ada portmantout yang mungkin, program Anda dapat melakukan apa saja. Ex:{"most", "short", "lists"}
• Aturan standar untuk I / O dan celah berlaku.

Ini adalah kode-golf , sehingga solusi terpendek (dalam byte) di setiap bahasa menang! Selamat bermain golf!

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

Cobalah online!

Diselamatkan

• -2 byte, terima kasih untuk rekursif

Pyth, 39 byte

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

Coba di sini

Penjelasan

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┼>☼Θ²└ô┴\

Jalankan dan debug itu

Menjalankan semua test case secara deterministik dalam waktu sekitar satu detik.

Ini adalah algoritma rekursif.

• Mulailah dengan setiap kata masukan sebagai kandidat
• Pada setiap langkah, pesan kata-kata berdasarkan berapa kali mereka muncul sebagai substring dari kandidat.
• Untuk setiap kata yang kompatibel dengan akhir kandidat saat ini, bergabunglah dengan kata untuk membentuk kandidat baru, dan buat panggilan rekursif.

Inilah programnya membongkar, tidak berkhasiat, dan berkomentar.

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

Jalankan yang ini

Sunting: Ini gagal untuk kelas input yang memiliki loop, seperti ["ab", "ba", "ca"], seperti halnya sebagian besar jawaban yang diposting lainnya.

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

Mengembalikan kesalahan untuk daftar yang tidak dapat sepenuhnya portmantouted.

Tidak Terkumpul:

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"

Kode ini sangat lambat pada contoh alfabet lengkap (tidak termasuk karena alasan itu dalam Cuplikan di atas).

Itu diperbaiki dengan mengubah maps ke somes, untuk kehilangan 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"