生成Portmantout！

16

背景

三年前，这个家伙汤姆·墨菲（Tom Murphy）想到了将Portmanteau的概念扩展到语言中的所有单词，并称其为portmantout（portmanteau加上tout [French for all ]）。他将英语定义为108,709个单词的列表，设法找到了具有以下两个属性的611,820个字母序列：

  • 字符串中包含每个英语单词。
  • 字符串中包含任意两个相邻字母的邻域是一个英语单词。

这是指向该portmantout的页面的链接（以及视频说明）。

搬运工

portmantout的两个属性中的第一个很容易理解。第二个可能需要一些解释。

基本上，单词必须重叠。“ golfcode”将永远不会出现在英语的portmantout中，因为那里没有包含“ fc”的词。但是，您可能会在portmantout中找到“ codegolf”，因为“ ego”弥合了差距（所有其他字母对都在“ code”或“ golf”中）。

你的任务：

编写一个程序或函数，该程序或函数需要一个字符串列表并返回该列表的所有portmantout。

此Python 3代码将验证portmantout。

测试用例

所有列表都是无序的；那是，

{"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网站上找到大量代码。

规则

  • 您的代码必须暂停。
  • 您不必在每次执行时都返回相同的portmantout。
  • 你可以假设所有的字符串只包含小写字母的a通过z。
  • 如果无法进行portmantout，则您的程序可能会执行任何操作。例如：{"most", "short", "lists"}
  • I / O和漏洞的标准规则适用。

这是代码高尔夫，因此每种语言中最短的解决方案（以字节为单位）将获胜！打高尔夫球快乐！

code-golf  string  graph-theory 
— 库尔德拉西斯·纳巴里亚
source
— Khuldraeseth na'Barya
1
也许一些测试用例？
— ADAM
{"sic", "bar", "rabbits", "cradle"} -> "barabbitsicradle" {"mauve", "elated", "cast", "electric", "tame"} -> "mauvelectricastamelated"（更多测试用例）
— sundar-恢复莫妮卡
2
是的，也许其中一个字一个测试用例需要使用两次
— ASCII-仅
2
我们会收到1个字母的单词吗？

Answers:

3

Python 2中，204个 202字节

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个字节，由于递归
— 场
source
您可以在最后两行使用制表符来节省2个字节。
— 递归
— 乔纳森·弗雷希
这不会产生的正确输出["ab", "ba", "ca"]。我的解决方案具有相同的错误。
— 递归
1

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.
1

Stax，39 36 字节

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

运行并调试

确定性地在大约一秒钟内运行所有测试用例。

这是一种递归算法。

  • 从每个输入单词开始作为候选
  • 在每个步骤中，将单词按候选单词的子字符串出现的次数排序。
  • 对于与当前候选词末尾兼容的每个词，请将该词加入以形成新候选词，然后进行递归调用。

这是解压，解压和注释的程序。

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"]其他大多数已发布答案也一样。

— 递归的
source
0

JavaScript（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

显示代码段

在完整的字母示例中，该代码的运行速度非常慢（由于上述原因未包括在上面的代码段中）。

通过将maps 更改为s可以弥补some2字节的丢失：

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

显示代码段

— 里克·希区柯克
source
1
看来我弄错了。我无法重现我的行为以为我昨天看到。对不起，我很困惑，浪费您的时间。我将删除对该主题的评论，因为它们都是错误的和误导性的。
— 递归
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.