Já imaginou criar hashtags legais para o twitter, como #brexit ou #brangelina ? este golfe é para você.

Escreva um programa que aceite duas seqüências de caracteres A e B como entrada e as mescla de acordo com o seguinte algoritmo:

1. deixar que nseja o número de grupos de vogais em A (por exemplo, britaintem 2 vogais grupos: ina posição 3 e aina posição 5).
   • se n = 1: truncar A começando na sua primeira posição de grupo de vogais (exemplo: bill=> b)
   • se n> 1: truncar A começando na sua n-1posição do grupo de vogais (exemplo: programming=> progr, britain=> br)
2. remova todas as consoantes no início de B ( jennifer=> ennifer)
3. concatenar o A & B modificado

As vogais são aeiou; consoantes são bcdfghjklmnpqrstvwxyz.

Entrada

Você pode assumir que as seqüências de entrada são minúsculas e contêm pelo menos uma vogal e uma consoante.

Exemplos

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 -psinalizador. Pega entrada separada por espaço no STDIN.
-1 byte graças a Martin Ender
-2 bytes graças a histocrat

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

Experimente online!

GNU sed, 39 37 + 1 = 38 bytes

+1 byte para -Esinalizador. Pega entrada separada por espaço no STDIN.
-1 byte graças a Martin Ender

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

Experimente online!

Não postar isso como uma resposta separada, porque é literalmente a mesma solução.

MATL, 31 30 bytes

t13Y2XJmFwhdl=fql_):)itJmYsg)h

Experimente Online

Explicação

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 graças a @Jordan, 1 graças a @DavidConrad

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

Mesmo .matchretornando uma matriz, array+arrayretorna uma string com o conteúdo das matrizes concatenadas (ou seja, [0]+[1]retorna "01").

Snippet de teste

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>

A excelente solução Ruby da Jordan teria 53 bytes em JS:

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

Geléia , 23 22 bytes

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

TryItOnline

Quão?

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, este é um regex popular ... ;-)

Usa o -replaceoperador para retirar as peças apropriadas e concatena os resultados juntos. Adiciona um $ao primeiro para garantir que puxamos o final da corda e adiciona um ^ao segundo para garantir que puxamos a frente da corda.

Retina , 35 bytes

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

Experimente online! (A primeira linha ativa um conjunto de testes separado por avanço de linha.)

Simplesmente remove todas as correspondências do regex na primeira linha.

Goma de canela, 23 bytes

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

Experimente online.

Explicação

Isso descompacta para d([aeiou]+[^aeiou]*)([aeiou]+[^aeiou]*)? [^aeiou]*, o que dexclui qualquer coisa que corresponda a esse regex. (Observe que o golfista da Jordânia d([aeiou]+[^aeiou]*){,2} [^aeiou]*compacta até 24 bytes devido à falta de elementos repetidos para compactar.)

PHP, 95 bytes

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

com preg_match em vez 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, mais 1 para em -pevez de-e

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

Ponta do chapéu.

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 foi difícil.

Confira em repl.it

Lit , 65 bytes

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

Esta é basicamente uma porta da resposta JavaScript acima, na minha linguagem de programação funcional Lisp-ish.

Exemplo 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"))
)

Ainda não há intérprete online. Eu vou fornecer um em breve. Não será difícil, minha linguagem está escrita em JavaScript.

Em vez disso, essa solução de quebra-cabeça é implementada como um exemplo de trabalho para o meu idioma. Pode ser executado com o seguinte comando:

node run.js l_src/progruzzle-colf.lithp

Haskell, 111 108 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

Essa solução não-regex ficou mais tempo do que o esperado. Idone de qualquer maneira.

Jq 1.5 , 45 bytes

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

Nada de especial, apenas uma porta da solução perl do msh210 para o PCRE da jq.

Experimente online!

Japonês , 18 bytes

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

Experimente online!

Porta direta da solução JS curta, que por sua vez é a porta da solução Ruby da Jordânia .

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