Avez-vous déjà rêvé de créer des hashtags Twitter tels que #brexit ou #brangelina ? ce golf est pour vous.

Ecrivez un programme qui accepte deux chaînes A & B en entrée et les fusionne selon l'algorithme suivant:

1. Soit nle nombre de groupes de voyelles dans A (par exemple, britaina 2 groupes de voyelles: ien position 3 et aien position 5).
   • si n = 1: tronque A en partant de la première position du groupe de voyelles (exemple: bill=> b)
   • si n> 1: tronque A en partant de n-1la position du groupe de voyelles (exemple: programming=> progr, britain=> br)
2. supprime toutes les consonnes au début de B ( jennifer=> ennifer)
3. concaténer les A & B modifiés

Les voyelles sont aeiou; les consonnes sont bcdfghjklmnpqrstvwxyz.

Contribution

Vous pouvez supposer que les chaînes en entrée sont en minuscules et contiennent au moins une voyelle et une consonne.

Exemples

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 octets

+1 octet pour le -pdrapeau. Prend une entrée séparée par des espaces sur STDIN.
-1 octet grâce à Martin Ender
-2 octets grâce à histocrat

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

Essayez-le en ligne!

GNU sed, 39 37 + 1 = 38 octets

+1 octet pour le -Edrapeau. Prend une entrée séparée par des espaces sur STDIN.
-1 octet grâce à Martin Ender

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

Essayez-le en ligne!

Ne pas poster ceci comme une réponse séparée parce que c'est littéralement la même solution.

MATL, 31 à 30 octets

t13Y2XJmFwhdl=fql_):)itJmYsg)h

Essayez-le en ligne

Explication

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 octets

Économisé 8 octets grâce à @Jordan, 1 grâce à @DavidConrad

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

Même si .matchrenvoie un tableau, array+arrayretourne une chaîne avec le contenu des tableaux concaténés (c'est-à-dire, les [0]+[1]retours "01").

Extrait de test

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>

L’excellente solution Ruby de Jordan serait de 53 octets dans JS:

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

Gelée , 23 22 octets

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

TryItOnline

Comment?

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 octets

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

Apparemment, c'est un regex populaire ... ;-)

Utilise l' -replaceopérateur pour extraire les pièces appropriées, puis concatène les résultats ensemble. Ajoute un $à la première pour s'assurer que nous tirons l'extrémité de la chaîne, et ajoute un ^à la seconde pour nous assurer de tirer l'avant de la chaîne.

Retina , 35 octets

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

Essayez-le en ligne! (La première ligne active une suite de tests séparée par saut de ligne.)

Supprime simplement toutes les correspondances de la regex sur la première ligne.

Cannelle, 23 octets

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

Essayez-le en ligne.

Explication

Cette décompresse à d([aeiou]+[^aeiou]*)([aeiou]+[^aeiou]*)? [^aeiou]* , ce qui dsupprime tout ce qui correspond à cette expression rationnelle. (Notez que le golfier de Jordan se d([aeiou]+[^aeiou]*){,2} [^aeiou]*compresse à 24 octets en raison de l'absence d'éléments répétés à compresser.)

PHP, 95 octets

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

avec preg_match au lieu de preg_filter 110 octets

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

Lua, 66 octets

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

Perl 5, 39 octets

38, plus 1 pour -peau lieu de-e

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

Pointe du chapeau.

Python 2, 139 octets

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

Celui-ci était difficile.

Découvrez-le sur repl.it

Lithp , 65 octets

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

Ceci est fondamentalement un port de la réponse JavaScript ci-dessus, dans mon langage de programmation fonctionnel Lisp-ish.

Exemple d'utilisation:

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

Pas d'interprète en ligne pour le moment. Je vais en fournir un bientôt. Ce ne sera pas difficile, ma langue est écrite en JavaScript.

Au lieu de cela, cette solution de puzzle est implémentée comme exemple de travail pour ma langue. Il peut être exécuté avec la commande suivante:

node run.js l_src/progruzzle-colf.lithp

Haskell, 111 108 octets

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

Cette solution non regex s'est avérée plus longue que prévu. Idéale-le quand même.

Jq 1.5 , 45 octets

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

Rien de spécial, juste un port de msh210 solution perl s » à PCRE de JQ.

Essayez-le en ligne!

Japt , 18 octets

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

Essayez-le en ligne!

Port direct de la solution JS courte qui est à son tour le port de la solution jordanienne Ruby .

Comment ça fonctionne

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.