Arka fon

Üç yıl önce, bu adam Tom Murphy bir portmanteau fikrini bir dildeki tüm kelimelere genişletmeyi başardı ve buna portmantout ( portmanteau plus tout [ herkes için Fransızca ]) dedi . İngilizceyi 108,709 kelimelik bir liste olarak tanımlayarak, aşağıdaki iki özelliğe sahip 611,820 harflik bir sıra bulmayı başardı:

• Her İngilizce sözcük dizede bulunur.
• Dizede herhangi iki bitişik harf içeren bazı semtler İngilizce bir kelimedir.

İşte bu portmantoutun bulunabileceği bir sayfaya bağlantı (video açıklamasıyla birlikte).

Bir portmantout

Portmantoutun iki özelliğinden birincisini anlamak kolaydır. İkincisi biraz açıklama gerektirebilir.

Temel olarak, kelimeler örtüşmelidir. "golfcode" hiçbir zaman İngilizce portmantout'ta görünmeyecektir, çünkü orada "fc" kelimesini içeren bir kelime yoktur. Ancak, bir portmantout "codegolf" bulabilirsiniz, "ego" için boşluk köprüler (ve diğer tüm harf çiftleri "kod" veya "golf" bulunmaktadır).

Senin görevin:

Dizelerin listesini alan ve listenin herhangi bir portmantout'unu döndüren bir program veya işlev yazın.

Bu Python 3 kodu bir portmantout'u doğrular.

Test senaryoları

Tüm listeler sırasız; yani,

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

Ve neden olmasın? Eğer kodunuz makul bir süre içinde çalıştırılırsa, Murphy'nin sitesinde büyük olan.

kurallar

• Kodunuz durmalıdır.
• Her yürütmede aynı portmantout'u döndürmeniz gerekmez.
• Tüm dizeleri sadece küçük harflerden oluşmuyor varsayabiliriz aaracılığıyla z.
• Portmantout mümkün değilse, programınız her şeyi yapabilir. Ör:{"most", "short", "lists"}
• G / Ç ve boşluklar için standart kurallar geçerlidir.

Bu kod golf , bu yüzden her dilde en kısa çözüm (bayt cinsinden) kazanır! Mutlu golf!

Python 2 , 204202 bayt

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

Çevrimiçi deneyin!

Kayıtlı

• Özyinelemeli sayesinde -2 bayt

Pyth, 39 bayt

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

Burada deneyin

açıklama

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 bayt

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

Çalıştır ve hata ayıkla

Tüm test senaryolarını yaklaşık bir saniye içinde deterministik olarak çalıştırır.

Bu özyinelemeli bir algoritmadır.

• Her girdi kelimesiyle aday olarak başlayın
• Her adımda, kelimeleri adayın alt dizeleri olarak gerçekleşme sayısına göre sıralayın.
• Mevcut adayın sonu ile uyumlu olan her kelime için, yeni bir aday oluşturmak üzere kelimeye katılın ve özyinelemeli bir çağrı yapın.

İşte paketten çıkarılmış, çözülmemiş ve yorum yapılmış program.

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

Bunu çalıştır

Düzenleme: Bu ["ab", "ba", "ca"], diğer gönderilen yanıtların çoğu gibi bir döngüye sahip bir giriş sınıfı için başarısız olur .

JavaScript (ES6), 138 130 bayt

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

Tamamen resmedilemeyen listeler için hata döndürür.

Ungolfed:

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"

Kod, tam alfabe örneğinde çok yavaştır (bu nedenle yukarıdaki Snippet'e dahil değildir).

Bu, 2 bayt kaybı mapiçin somes'yi s'ye değiştirerek giderilir :

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"