Una palabra de portmanteau es una combinación de dos palabras que forma parte de cada palabra y las convierte en una sola palabra nueva. Por ejemplo, lion + tiger => liger .

Escribamos un programa para generar carteras a partir de un par de palabras de entrada. Las computadoras no son las mejores en inglés, por lo que tendremos que establecer algunas reglas para asegurarnos de que las carteras de salida sean agradables a la vista y al oído.

^{(Los ejemplos aquí se muestran con un separador entre el prefijo y el sufijo para mayor claridad:. li|gerSin embargo, las salidas reales del programa no deberían tener un separador:. liger)}

• Cada portmanteau consistirá en un prefijo no vacío de la primera palabra concatenado a un sufijo no vacío de la segunda palabra: sí a li|ger, no a |iger.
• Si el prefijo termina con una vocal, el sufijo debe comenzar con una consonante, y viceversa: sí a lio|gero l|er, no a lio|igero l|ger. Puedes decidir si contar ycomo vocal o consonante. Sin embargo, su solución debe elegir una opción y seguir con ella.
• La palabra resultante no debe contener ninguna de las palabras originales en su totalidad: sí a lio|ger, no a lion|igero li|tiger.
  • Esta regla se cumple incluso si la parte en cuestión está formada por partes de ambas palabras: con la entrada de two+ words, la salida tw|ordssigue siendo ilegal porque contiene la subcadena words. (La única salida válida para este par sería t|ords).

Su programa o función debe tomar dos palabras y generar / devolver una lista de todos los acolchados agradables que se pueden formar a partir de esas palabras en ese orden.

Detalles

• Se aplican métodos estándar de entrada y salida . Las lagunas estándar están prohibidas.
• Las palabras consistirán solo en letras minúsculas (o, si lo prefiere, solo en letras mayúsculas).
• Puede tomar las dos palabras de entrada como una lista, tupla, dos entradas separadas, una sola cadena con un delimitador sin letras, etc.
• El formato de salida es igualmente flexible; si devuelve o genera una cadena, debe delimitarse de modo que quede claro dónde termina una palabra de portmanteau y comienza la siguiente.
• No debe haber delimitadores dentro de una palabra de portmanteau.
• Está bien si su lista de resultados incluye resultados duplicados; También está bien eliminar duplicados.

Casos de prueba

> 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

Solución de referencia

Aquí hay una solución de referencia en Pip (trata ycomo una consonante).

Este es el código de golf : ¡la respuesta más corta en cada idioma gana!

05AB1E , 28 bytes

y es una vocal (aunque el mismo número de bytes que la consonante).

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

Pruébalo en línea! o como un conjunto de pruebas ligeramente modificado

Retina , 72 bytes

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

Pruébalo en línea!

Pyth , 38 bytes

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

La entrada es una lista de las dos palabras, y y no se trata como una consonante.

Pruébelo en línea aquí , o verifique todos los casos de prueba a la vez aquí .

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

Toma dos cadenas en la sintaxis de curry y devuelve una cadena. Se trata ycomo una consonante. Pruébelo en línea aquí .

Gracias a DLosc por jugar al golf 2 bytes.

Sin golf:

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

Intérprete Japt

Ahorró 10 bytes gracias a la comprensión más clara de Shaggy de la sintaxis de Japt.

Se guardaron 8 bytes debido a una nueva función de idioma

Guardado 2 bytes gracias a algunas sugerencias de ETHproductions

La versión más reciente de Japt introdujo la función de producto cartesiano, que ahorró bastantes bytes y me permitió restaurar el orden de las entradas (de modo que "lion" "tiger" genera "liger" y demás). "y" todavía se trata como una consonante.

Explicación:

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

Lo he considerado ycomo una consonante.

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 gracias a Jonathan Frech

Pruébalo en línea!

JavaScript (ES6), 124 bytes

Toma las 2 palabras en sintaxis de curry (a)(b)e imprime los resultados con alert(). Asume que y es una consonante.

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

Pruébalo en línea!

Jalea , 27 bytes

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

Pruébalo en línea!

Yy es una consonante. Ambos casos soportados. Devuelve duplicados.

La salida ha sido prettified sobre TIO. Eliminar +/€del pie de página para ver la salida real.

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

Hace un uso intensivo de std::string#find. Se trata ycomo una consonante. Pruébelo en línea aquí .

Sin golf:

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

Pruébalo en línea!

3 bytes de Jonathan Frech . Y 10 bytes gracias a The Matt .

En mi mundo, yno es una vocal. (¡Es un aullido!)

Ruby , 113 112 109 104 bytes

y es una consonante

Esto genera los mismos duplicados que los ejemplos en la pregunta, debo estar usando el mismo bucle

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

Pruébalo en línea!

Emacs Lisp , 306 + 13 = 319 bytes

+13 para (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))))))))

¡Pruébelo en línea!

Define una función lambda anónima. Emite una secuencia de cartelas separadas por nueva línea con cada una entre comillas. Consejos de golf son bienvenidos. La letra yse considera una consonante.

Sin golf

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