甲混成词是两个词的组合拍摄每一个单词的一部分，使它们变成单一的新词。例如，狮子 + 老虎 => liger。

让我们编写一个从一对输入单词生成portmanteaus的程序。电脑不是英语水平最好的，所以我们需要建立一些规则以确保输出的portmanteaus令人耳目一新。

^{（为清楚起见li|ger，此处的示例在前缀和后缀之间显示了分隔符：。但是，程序的实际输出不应包含分隔符：liger。）}

• 每个portmanteau将由第一个单词的非空前缀与第二个单词的非空后缀组成：yes到li|ger，no to |iger。
• 如果前缀以元音结尾，则后缀必须以辅音开头，反之亦然：是lio|ger或l|er，否是lio|iger或l|ger。您可以决定算作y元音还是辅音。但是，您的解决方案必须选择一个选项并坚持使用。
• 产生的字词不得完整包含两个原始字词：是lio|ger，lion|iger或li|tiger。
  • 即使所讨论的部分是由两个单词的一部分组成的，该规则仍然成立：输入为two+时words，输出tw|ords仍然是非法的，因为它包含子字符串words。（此对的唯一有效输出是t|ords。）

您的程序或函数必须使用两个单词，并输出/返回可以由这些单词按该顺序形成的所有令人愉悦的portmanteaus列表。

细节

• 标准输入和输出方法适用。禁止出现标准漏洞。
• 单词将仅包含小写字母（或者，如果您愿意，也仅包含大写字母）。
• 您可以将两个输入单词作为列表，元组，两个单独的输入，带有非字母定界符的单个字符串等。
• 输出格式同样具有灵活性；如果您返回或输出一个字符串，则应将其定界，以使一个portmanteau单词的末尾清晰而下一个开始。
• 在portmanteau单词内不应有任何定界符。
• 如果您的输出列表中包含重复的结果，也可以；也可以删除重复项。

测试用例

> lion, tiger
< liger, ler, liger, lir, lioger, lior

> tiger, lion
< tion, ton, tin, tigion, tigon, tigen

> spoon, fork
< sork, spork, spork, spok, spoork, spook

> smoke, fog
< sog, smog, smog, smokog

> gallop, triumph
< giumph, gumph, gariumph, gamph, gaph, gah, galiumph, galumph, galliumph, gallumph, galloriumph, gallomph, galloh

> breakfast, lunch
< bunch, brunch, brench, brech, breh, breanch, breach, breah, breakunch, breakfunch, breakfanch, breakfach, breakfah, breakfasunch

> two, words
< tords

> harry, ginny (if y is treated as a consonant)
< hinny, hanny, hany, hay, harinny, harrinny

> harry, ginny (if y is treated as a vowel)
> hinny, hy, hanny, hany, harinny, hary, harrinny

参考溶液

这是Pip中的参考解决方案（y作为辅音）。

这是代码高尔夫：每种语言中最短的答案胜出！

05AB1E，28个字节

y 是一个元音（虽然与辅音的字节数相同）。

нη¨sθ.s¨âʒ`нsθ‚žOsåË_}Jʒs¢Z_

在线尝试！ 或作为稍微修改的测试套件

视网膜，72字节

L$w`(?<=[aeiou]()|.())((.+),(.+))\B(?!\4)(?<!\5\3)(?([aeiou])\2|\1)
$`$'

在线尝试！

Pyth，38个字节

f!s}RTQm+hd_edfxFm}ed"aeiou"T*._hQ.__e

输入是两个单词的列表，并且y不被视为辅音。

在此处在线尝试，或在此处一次验证所有测试用例。

f!s}RTQm+hd_edfxFm}ed"aeiou"T*._hQ.__e   Implicit: Q=eval(input())
                                hQ       First input word
                              ._         All prefixes of the above
                                     e   Second input word (Q inferred)
                                  .__    Reverse, take all prefixes
                             *           Cartesian product of the above
              f                          Filter the above using:
                 m          T              Map d in the current element using:
                   ed                        The last letter of the word part
                  }  "aeiou"                 Is it contained in the vowel list?
               xF                          Take the XOR of the list
                                         (This ensures that the word parts meet at one consonant)
       m                                 Map d in the filtered set using:
        +hd_ed                             Add the first part to the reversed second part
f                                        Filter the above using:
  s}RTQ                                    Does the portmanteau contain either of the input words?
 !                                         Logical NOT (remove from list if the above is true)

爪哇8，228个 225 215字节

v->w->{String r="",t,p=" aeiou";for(int i=w.length(),j;--i>0;)for(j=1;j<v.length();)r+=(t=v.substring(0,j)+w.substring(i)).matches(v+".*|.*"+w)|p.indexOf(t.charAt(j-1))*p.indexOf(t.charAt(j++))>0?"":t+" ";return r;}

采用可循语法的两个字符串，并返回一个字符串。黄柏y作为辅音。在这里在线尝试。

感谢DLosc打高尔夫球2个字节。

取消高尔夫：

v -> w -> { // lambda taking two String parameters in currying syntax
    String r = "", // result
    t, // temporary variable used for storing
       // the portmanteau candidate currently being evaluated
    p = " aeiou"; // vowels for the purposes of this function;
                  // the leading space is so that they all have a positive index
    for(int i = w.length(), j; --i > 0; ) // loop over all proper suffixes
                                          // of the second word
        for(j = 1; j < v.length(); )      // loop over all proper prefixes
                                          // of the first word
            r += // construct the portmanteau candidate
                 (t = v.substring(0, j) + w.substring(i))
                 // if it contains one of the input words ...
                 .matches(v + ".*|.*" + w)
                 // ... or the boundary is consonant-consonant 
                 // or vowel-vowel (here we make use of the facts
                 // that all the vowels have a positive index, and
                 // indexOf() returns -1 in case of no match) ...
                 | p.indexOf(t.charAt(j-1)) * p.indexOf(t.charAt(j++)) > 0
                 ? "" // ... reject it ...
                 : t + " "; // ... else add it to the result
    return r; // return the result
}

Japt，32字节

å+ ïVw å+)f_xè"%v$" uÃmrÈ+YwÃkøN

日语翻译

由于Shaggy对Japt的语法有更清楚的了解，因此节省了10个字节。

由于新的语言功能，节省了8个字节

由于ETHproductions的一些建议，节省了2个字节

Japt的最新版本引入了笛卡尔乘积函数，该函数节省了很多字节，并允许我恢复输入的顺序（因此“狮子”“老虎”输出“ liger”等）。“ y”仍被视为辅音。

说明：

   ï     )       Cartesian product of...
å+                prefixes of first input
    Vw å+         and suffixes of second input.

f_         Ã     Remove the ones where...
  xè"%v$"         the number of vowels at the joining point
          u       is not 1.

m     Ã          Replace each pair with...
 rÈ+Yw            the prefix and suffix joined together
       køN       then remove the ones that contain either input

Python 3中，156个 150字节

我认为y是辅音。

lambda a,b:{a[:i]+b[j:]for i in range(1,len(a))for j in range(1,len(b))if((a[i-1]in'aeiou')^(b[j]in'aeiou'))*0**(a in a[:i]+b[j:]or b in a[:i]+b[j:])}

-6个字节，感谢Jonathan Frech

在线尝试！

JavaScript（ES6），124个字节

用currying语法取2个单词，(a)(b)并用打印结果alert()。假设y是辅音。

a=>b=>[...a].map(c=>[...b].map((C,j)=>!(w=s+b.slice(j)).match(a+'|'+b)&v.test(c)-v.test(C)&&alert(w),s+=c),s='',v=/[aeiou]/)

在线尝试！

果冻，27个字节

¹Ƥp¹ÐƤ}Ø.ị"e€Øc⁻/ƲƇẎ€wÐḟƒ@,

在线尝试！

Yy是辅音。两种情况都支持。返回重复项。

输出已通过TIO美化。+/€从页脚中删除以查看实际输出。

C ++ 11，217 202字节

[](auto v,auto w){auto r=v,t=v,p=v;r="",p="aeiou";for(int i=w.size(),j;--i;)for(j=v.size();j;)(t=v.substr(0,j)+w.substr(i)).find(v)+1|t.find(w)+1|p.find(t[j-1])<5==p.find(t[j--])<5?v:r+=t+" ";return r;}

大量使用std::string#find。黄柏y作为辅音。在这里在线尝试。

取消高尔夫：

// lambda; relies on auto to keep declarations short
[] (auto v, auto w) {
    // let's declare some strings. To keep it terse, we're using auto and the type of the arguments.
    auto r = v, // result string
    t = v,      // temporary string for storing the portmanteau candidate
    p = v;      // vowels string
    // now assign them their values
    r = "",    // result starts empty
    p = "aeiou"; // vowels don't include 'y'
    for(int i = w.size(), j; --i; ) // suffixes of the second word
        for(j = v.size(); j; ) // prefixes of the first word
            // create the portmanteau candidate
            (t = v.substr(0, j) + w.substr(i))
            // if it includes one of the input words ...
            .find(v) + 1 | t.find(w) + 1
            // ... or the boundary is consonant-consonant or vowel-vowel ...
            | p.find(t[j - 1]) < 5 == p.find(t[j--]) < 5
            ? v // ... discard it ...
            : r += t + " "; // ... else add it to the result.
    return r; // return the result
}

Python 2中，179个 176 166 162字节

lambda s,t:[w for w in g(s,t)if(s in w)<1>(t in w)]
g=lambda s,t:s[:-1]and[s[:-1]+t[j:]for j in range(1,len(t))if(s[-2]in'aeiou')^(t[j]in'aeiou')]+g(s[:-1],t)or[]

在线尝试！

Jonathan Frech的 3个字节。还有10个字节到The Matt。

在我的世界里，y不是元音。（这是一个叫！）

Ruby，113112109104字节

y 是辅音

这将输出与问题中的示例相同的重复项，我必须使用相同的循环

->a,b,i=j=1{r=a[0,i]+b[j..-1];g=:aeiou;!g[a[i-1]]^g[b[j]]|r[a]|r[b]||z=[*z,r];b[j+=1]||a[i+=j=1]?redo:z}

在线尝试！

Emacs Lisp，306 + 13 = 319字节

+13 (require'seq)

(require'seq)(lambda(a b)(dotimes(i(1-(length b)))(dotimes(j(1-(length a)))(progn(setq w(substring a 0(1+ j))x(substring b(1+ i))c(concat w x))(defun V(c)(seq-contains"aeiou"(elt c 0)'char-equal))(if(not(or(string-prefix-p a c)(string-suffix-p b c)))(if(V(substring w -1))(if(not(V x))(print c))(if(V x)(print c))))))))

在线尝试！

定义一个匿名lambda函数。输出以换行符分隔的portmanteaus序列，每个序列都用引号引起来。欢迎打高尔夫球。这封信y被认为是辅音。

不打高尔夫球

(require 'seq)                                                                                                                                                           
(defun Portmanteus(word1 word2)
  "Find all valid portmanteus of the two given words"
  (dotimes (i (1- (length word2)))
    (dotimes (j (1- (length word1)))
      (progn
        (setq w (substring word1 0 (1+ j)) w2 (substring word2 (1+ i)) comb (concat w w2))
        (defun isVowel (c) (seq-contains "aeiou" (elt c 0) 'char-equal))
        (if (not (or (string-prefix-p word1 comb) (string-suffix-p word2 comb)))
          (if (isVowel (substring w -1))
            (if (not (isVowel w2))
              (princ (format "%s\n" comb))
            )
            (if (isVowel w2)
              (princ (format "%s\n" comb))
            )
          )
        )
      )
    )
  )
)