¿Alguna vez te ha gustado crear hashtags geniales de Twitter como #brexit o #brangelina ? Este golf es para ti.

Escriba un programa que acepte dos cadenas A y B como entrada y las combine de acuerdo con el siguiente algoritmo:

1. Sea nel número de grupos de vocales en A (por ejemplo, britaintiene 2 grupos de vocales: ien la posición 3 y aien la posición 5).
   • si n = 1: truncar A comenzando en su primera posición de grupo vocal (ejemplo: bill=> b)
   • si n> 1: truncar A comenzando en su n-1posición del grupo de vocales th (ejemplo: programming=> progr, britain=> br)
2. eliminar todas las consonantes al comienzo de B ( jennifer=> ennifer)
3. concatenar el A y B modificado

Las vocales son aeiou; consonantes son bcdfghjklmnpqrstvwxyz.

Entrada

Puede suponer que las cadenas de entrada son minúsculas y contienen al menos una vocal y una consonante.

Ejemplos

brad + angelina      => brangelina
britain + exit       => brexit
ben + jennifer       => bennifer
brangelina + exit    => brangelexit
bill + hillary       => billary
angelina + brad      => angelad
programming + puzzle => progruzzle
code + golf          => colf
out + go             => o

Ruby, 44 43 40 + 1 = 41 bytes

+1 byte para -pbandera. Toma entradas separadas por espacios en STDIN.
-1 byte gracias a Martin Ender
-2 bytes gracias a histocrat

sub /([aeiou]+([^aeiou]*)){,2} \g<2>/,""

Pruébalo en línea!

GNU sed, 39 37 + 1 = 38 bytes

+1 byte para -Ebandera. Toma entradas separadas por espacios en STDIN.
-1 byte gracias a Martin Ender

s/([aeiou]+[^aeiou]*){,2} [^aeiou]*//

Pruébalo en línea!

No publicar esto como una respuesta separada porque es literalmente la misma solución.

MATL, 31 30 bytes

t13Y2XJmFwhdl=fql_):)itJmYsg)h

Pruébalo en línea

Explicación

t       % Implicitly grab the input and duplicate it
13Y2    % Push the string literal 'aeiouAEIOU'
XJ      % Store this in clipboard J for later use
m       % Check which characters from the input are vowels (true for vowel)
Fwh     % Prepend FALSE to this logical array
dl=     % Compute the difference and find where we went from not-vowel to vowel
f       % Find the indices of these transitions
q       % Subtract 1 to get the location of the last consonant in each transition
l_)     % Get the next-to-last one of these
:)      % Grab the first string up to this location

% Now for the second component!

it      % Explicitly grab the input and duplicate
J       % Retrieve the string literal 'aeiouAEIOU' from clipboard J
m       % Find where the vowels are (true for vowel)
Ys      % Compute the cumulative sum along the array. The result will be 0
        % for all characters before the first vowel and non-zero after
g)      % Convert to logical and use this as an index so any characters
        % after the first value are retrieved

% Now to combine them

h       % Horizontally concatenate the first and second pieces together
        % Implicitly display the result

JavaScript (ES6), 81 73 72 bytes

Guardado 8 bytes gracias a @Jordan, 1 gracias a @DavidConrad

a=>b=>a.match(/.*?(?=(?:[aeiou]+[^aeiou]*){1,2}$)/)+b.match(/[aeiou].*/)

Aunque .matchdevuelve una matriz, array+arraydevuelve una cadena con el contenido de las matrices concatenadas (es decir, [0]+[1]devuelve "01").

Fragmento de prueba

f=a=>b=>console.log(a,"+",b,"=",a.match(/.*?(?=(?:[aeiou]+[^aeiou]*){1,2}$)/)+b.match(/[aeiou].*/))
f("brad")("angelina")
f("britain")("exit")
f("ben")("jennifer")
f("brangelina")("exit")
f("bill")("hillary")
f("angelina")("brad")
f("programming")("puzzle")
f("code")("golf")
f("progruzzle")("colf")
f("out")("go")

<input id=A value="super">
<input id=B value="chafouin">
<button onclick="f(A.value)(B.value)">Run</button>

La excelente solución Ruby de Jordan sería de 53 bytes en JS:

x=>x.replace(/([aeiou]+[^aeiou]*){1,2} [^aeiou]*/,"")

Jalea , 23 22 bytes

eۯcT
ǵḟ‘-ị’
Ç⁸ḣ⁹ÑḢ⁹ṫ

TryItOnline

¿Cómo?

eۯcT    - Link 1, vowel indexes: s   e.g. "colouring"
  Øc     - yield vowels, "AEIOUaeiou"
e€       - in for each                     [0,1,0,1,1,0,1,0,0]
    T    - truthy indexes (1-based)        [2,4,5,7]

ǵḟ‘-ị’  - Link 2, n-1th or only vowel group index start - 1: s
 µ       - monadic chain separation
Ç        - call last link (1) as a monad   [2,4,5,7]
   ‘     - increment                       [3,5,6,8]
  ḟ      - filter out                      [2,4,7]
    -    - -1
     ị   - index value                     [4]
               (Jelly is 1-based and has modular indexing,
                so the last but one item is at index -1,
                and when there is only 1 item in the list it is also at index -1)
      ’  - decrement                       [3]

Ç⁸ḣ⁹ÑḢ⁹ṫ - Main link: a, b                      e.g. "colouring", "pencils"
Ç        - call last link (2) as a monad with a      [3]
 ⁸       - link's left argument, a
  ḣ      - head a[:y]                                "col"
   ⁹  ⁹  - link's right argument, b
    Ñ    - call next link (1) as a monad                          [2,5]
     Ḣ   - pop head                                               [2]
       ṫ - tail b[y-1:]                                           "encils"
         - implicit print                            "colencils"

PowerShell v2 +, 76 bytes

param($n,$m)($n-replace'([aeiou]+[^aeiou]*){1,2}$')+($m-replace'^[^aeiou]*')

Aparentemente esta es una expresión regular popular ... ;-)

Utiliza el -replaceoperador para extraer las piezas apropiadas, luego concatena los resultados juntos. Agrega una $a la primera para asegurarnos de que tiramos del extremo de la cuerda, y agrega una ^a la segunda para asegurar que tiramos del frente de la cuerda.

Retina , 35 bytes

([aeiou]+[^aeiou]*){1,2} [^aeiou]*

Pruébalo en línea! (La primera línea habilita un conjunto de pruebas separado por salto de línea).

Simplemente elimina todas las coincidencias de la expresión regular en la primera línea.

Chicle de canela, 23 bytes

0000000: 64d3 884e 4ccd cc2f 8dd5 8e8e 8330 b434  d..NL../.....0.4
0000010: b108 d92b c0d9 00                        ...+...

Pruébalo en línea.

Explicación

Esto descomprime a d([aeiou]+[^aeiou]*)([aeiou]+[^aeiou]*)? [^aeiou]*, que delige cualquier cosa que coincida con esa expresión regular. (Tenga en cuenta que el golfista de Jordan d([aeiou]+[^aeiou]*){,2} [^aeiou]*comprime a 24 bytes debido a la falta de elementos repetidos para comprimir).

PHP, 95 bytes

$t="aeiou]";echo($p=preg_filter)("#([$t+[^$t*){1,2}$#","",$argv[1]).$p("#^[^$t*#","",$argv[2]);

con preg_match en lugar de preg_filter 110 Bytes

$t="aeiou]";($p=preg_match)("#(.*?)([$t+[^$t*){1,2}$#",$argv[1],$m);$p("#[$t.*#",$argv[2],$n);echo$m[1].$n[0];

Lua, 66 bytes

$ cat merge.lua
print(((...):gsub(("[]+[^]*[]*[^]*+[^]*"):gsub("]","aeiou]"),"")))
$ lua merge.lua brad+angelina
brangelina
$ lua merge.lua programming+puzzle
progruzzle

Perl 5, 39 bytes

38, más 1 para en -pelugar de-e

s/([aeiou]+[^aeiou]*){1,2} [^aeiou]*//

Punta de sombrero.

Python 2, 139 bytes

n=lambda a,b:a[:a.index(([l for l in[[l,"!"][i!=0and a[i-1]in v]for i,l in enumerate(a)]if l in v]*2)[-2])]+b[sorted([(b+v).index(c)for c in v])[0]:]

Este fue duro.

Compruébalo en repl.it

Lithp , 65 bytes

#X::((replace X (regex "([aeiou]+[^aeiou]*){1,2} [^aeiou]*") ""))

Esto es básicamente un puerto de la respuesta de JavaScript anterior, en mi lenguaje de programación funcional Lisp-ish.

Ejemplo de uso:

(
    % Note, you can define this as a function, or assign it to a variable
    % and use the call function instead.
    (def f #X::((replace X (regex "([aeiou]+[^aeiou]*){1,2} [^aeiou]*") "")))
    (print (f "programming puzzle"))
)

No hay intérprete en línea todavía. Proporcionaré uno pronto. No será difícil, mi idioma está escrito en JavaScript.

En cambio, esta solución de rompecabezas se implementa como un ejemplo de trabajo para mi idioma. Se puede ejecutar con el siguiente comando:

node run.js l_src/progruzzle-colf.lithp

Haskell, 111108 bytes

v x=elem x"aeiou"
d=dropWhile
e=d v
k=d$not.v
r=reverse
f a|c<-e.k.e.k$a,""/=c=c|1<3=e.k$a
a!b=(r.f.r)a++k b

Esta solución no regex resultó más larga de lo esperado. Ideone de todos modos.

Jq 1.5 , 45 bytes

gsub("([aeiou]+[^aeiou]*){1,2} [^aeiou]*";"")

Nada especial, solo un puerto de la solución perl de msh210 para PCRE de jq.

Pruébalo en línea!

Japt , 18 bytes

r/\v+\V*){1,2} \V*

Pruébalo en línea!

Puerto directo de la solución JS corta, que a su vez es el puerto de la solución Ruby de Jordan .

Cómo funciona

Ur/\v+\V*){1,2} \V*/

Ur    Replace on the input...
/\v+\V*){1,2} \V*/  this regex with empty string.
      \v == [AEIOUaeiou], \V == [^AEIOUaeiou], `g` flag is on by default in Japt
      so the uncompressed regex is roughly /([aeiou]+[^aeiou]*){1,2} [^aeiou]*/g.