Ein Portmanteau-Wort ist eine Kombination aus zwei Wörtern, die aus jedem Wort ein neues Wort bilden. Zum Beispiel Löwe + Tiger => Liger .

Lassen Sie uns ein Programm schreiben, um Portmanteaus aus zwei Eingabewörtern zu generieren. Computer beherrschen nicht die englische Sprache, daher müssen wir einige Regeln festlegen, um sicherzustellen, dass die Ausgabe-Portmanteaus für Auge und Ohr angenehm sind.

^{(Beispiele sind hier zur Verdeutlichung mit einem Trennzeichen zwischen Präfix und Suffix versehen:. li|gerDie tatsächlichen Ausgaben des Programms sollten jedoch kein Trennzeichen haben:. liger)}

• Jedes Portmanteau besteht aus einem nicht leeren Präfix des ersten Wortes, das mit einem nicht leeren Suffix des zweiten Wortes verknüpft ist: Ja bis li|ger, Nein bis |iger.
• Wenn das Präfix mit einem Vokal endet, muss das Suffix mit einem Konsonanten beginnen und umgekehrt: Ja zu lio|geroder l|er, Nein zu lio|igeroder l|ger. Sie können entscheiden, ob Sie yals Vokal oder Konsonant zählen möchten. Ihre Lösung muss jedoch eine Option auswählen und dabei bleiben.
• Das resultierende Wort darf keines der ursprünglichen Wörter vollständig enthalten: ja bis lio|ger, nein bis lion|igeroder li|tiger.
  • Diese Regel gilt auch dann, wenn der betreffende Teil aus Teilen beider Wörter besteht: Bei Eingabe von two+ wordsist die Ausgabe tw|ordsimmer noch unzulässig, da sie die Teilzeichenfolge enthält words. (Die einzig gültige Ausgabe für dieses Paar wäre t|ords.)

Ihr Programm oder Ihre Funktion muss aus zwei Wörtern bestehen und eine Liste aller angenehmen Portmanteausgeben / zurückgeben , die aus diesen Wörtern in dieser Reihenfolge gebildet werden können.

Einzelheiten

• Es gelten die Standard-Eingabe- und Ausgabemethoden . Standardlücken sind verboten.
• Wörter bestehen nur aus Kleinbuchstaben (oder, wenn Sie möchten, nur aus Großbuchstaben).
• Sie können die beiden Eingabewörter als Liste, Tupel, zwei separate Eingaben, eine einzelne Zeichenfolge mit einem Nicht-Buchstaben-Trennzeichen usw. verwenden.
• Das Ausgabeformat ist ähnlich flexibel. Wenn Sie eine Zeichenfolge zurückgeben oder ausgeben, sollte sie so begrenzt sein, dass klar ist, wo ein Portmanteau-Wort endet und das nächste beginnt.
• Ein Portmanteau-Wort sollte keine Begrenzer enthalten.
• Es ist in Ordnung, wenn Ihre Ausgabeliste doppelte Ergebnisse enthält. Duplikate können auch entfernt werden.

Testfälle

> 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

Referenzlösung

Hier ist eine Referenzlösung in Pip (wird yals Konsonant behandelt ).

Das ist Code-Golf : Die kürzeste Antwort in jeder Sprache gewinnt!

05AB1E , 28 Bytes

y ist ein Vokal (die gleiche Anzahl von Bytes wie der Konsonant).

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

Probieren Sie es online! oder als leicht modifizierte Test Suite

Netzhaut , 72 Bytes

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

Probieren Sie es online!

Pyth , 38 Bytes

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

Die Eingabe ist eine Liste der beiden Wörter, und y wird nicht als Konsonant behandelt.

Versuchen Sie es online hier , oder prüfen Sie alle Testfälle auf einmal hier .

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)

Java 8, 228 225 215 Bytes

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;}

Nimmt zwei Strings in der aktuellen Syntax und gibt einen String zurück. Behandelt yals Konsonant. Probieren Sie es online aus hier aus .

Dank an DLosc für das Golfen mit 2 Bytes.

Ungolfed:

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 Bytes

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

Japt Interpreter

Dank Shaggys klarerem Verständnis der Japt-Syntax konnten 10 Byte eingespart werden.

8 Byte aufgrund einer neuen Sprachfunktion eingespart

2 Byte gespart dank einiger Anregungen von ETHproductions

Die neueste Version von Japt hat die Cartesian Product-Funktion eingeführt, die einige Bytes einspart und es mir ermöglicht, die Reihenfolge der Eingaben wiederherzustellen (also "lion" "tiger" gibt "liger" und so weiter). "y" wird immer noch als Konsonant behandelt.

Erläuterung:

   ï     )       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 Bytes

Ich habe yals Konsonant betrachtet.

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 Bytes dank Jonathan Frech

Probieren Sie es online!

JavaScript (ES6), 124 Byte

Nimmt die 2 Wörter in currying Syntax (a)(b)und druckt die Ergebnisse mit alert(). Angenommen, y ist ein Konsonant.

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]/)

Probieren Sie es online!

Gelee , 27 Bytes

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

Probieren Sie es online!

Yy ist ein Konsonant. Beide Fälle werden unterstützt. Gibt Duplikate zurück.

Die Ausgabe wurde über TIO vorgegeben. Entfernen Sie +/€aus der Fußzeile, um die tatsächliche Ausgabe anzuzeigen.

C ++ 11, 217 202 Bytes

[](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;}

Macht viel Gebrauch von std::string#find. Behandelt yals Konsonant. Probieren Sie es hier online aus .

Ungolfed:

// 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 Bytes

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[]

Probieren Sie es online!

3 Bytes von Jonathan Frech . Und 10 Bytes danke an The Matt .

In meiner Welt yist kein Vokal. (Es ist ein Jaulen!)

Ruby , 113 112 109 104 Bytes

y ist ein Konsonant

Dies gibt die gleichen Duplikate wie die Beispiele in der Frage aus, ich muss die gleiche Schleife verwenden

->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}

Probieren Sie es online!

Emacs Lisp , 306 + 13 = 319 Bytes

+13 für (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))))))))

Probieren Sie es online!

Definiert eine anonyme Lambda-Funktion. Gibt eine Folge von Portmanteaus mit Zeilenumbrüchen aus, wobei jedes von Anführungszeichen umgeben ist. Golftipps sind willkommen. Der Brief ygilt als Konsonant.

Ungolfed

(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))
            )
          )
        )
      )
    )
  )
)