Hast du schon mal Lust gehabt , coole Twitter-Hashtags wie #brexit oder #brangelina zu erstellen ? Dieser Golf ist für Sie.

Schreiben Sie ein Programm, das zwei Strings A & B als Eingabe akzeptiert und diese nach folgendem Algorithmus zusammenführt:

1. sei ndie Anzahl der Vokalgruppen in A (zB britainhat 2 Vokalgruppen: iin Position 3 und aiin Position 5).
   • wenn n = 1: A ab der ersten Vokalgruppenposition abschneiden (Beispiel: bill=> b)
   • wenn n> 1: A ab der n-1Position der Vokalgruppe abschneiden (Beispiel: programming=> progr, britain=> br)
2. entferne alle Konsonanten am Anfang von B ( jennifer=> ennifer)
3. Verketten Sie die modifizierten A & B

Vokale sind aeiou; Konsonanten sind bcdfghjklmnpqrstvwxyz.

Eingang

Sie können davon ausgehen, dass die Eingabezeichenfolgen klein geschrieben sind und mindestens einen Vokal und einen Konsonanten enthalten.

Beispiele

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 für -pFlag. Übernimmt eine durch Leerzeichen getrennte Eingabe für STDIN.
-1 Byte dank Martin Ender
-2 Byte dank Histokrat

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

Probieren Sie es online!

GNU sed, 39 37 + 1 = 38 Bytes

+1 Byte für -EFlag. Übernimmt eine durch Leerzeichen getrennte Eingabe für STDIN.
-1 Byte dank Martin Ender

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

Probieren Sie es online!

Dies nicht als separate Antwort zu posten, da es buchstäblich dieselbe Lösung ist.

MATL, 31 30 Bytes

t13Y2XJmFwhdl=fql_):)itJmYsg)h

Probieren Sie es online

Erläuterung

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 Byte

8 Bytes dank @Jordan, 1 dank @DavidConrad gespeichert

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

Obwohl .matchein Array zurückgegeben wird, wird array+arrayeine Zeichenfolge mit dem Inhalt der verketteten Arrays zurückgegeben (dh [0]+[1]zurückgegeben "01").

Testschnipsel

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>

Jordans exzellente Ruby-Lösung wäre 53 Bytes in JS:

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

Jelly , 23 22 Bytes

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

TryItOnline

Wie?

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 Byte

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

Anscheinend ist dies ein beliebter Regex ... ;-)

Verwendet den -replaceOperator, um die entsprechenden Teile abzuziehen, und verknüpft dann die Ergebnisse miteinander. Fügt ein $zum ersten hinzu, um sicherzustellen, dass wir das Ende der Zeichenfolge ziehen, und fügt ein ^zum zweiten hinzu, um sicherzustellen, dass wir die Vorderseite der Zeichenfolge abziehen.

Retina , 35 Bytes

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

Probieren Sie es online! (Die erste Zeile aktiviert eine durch Zeilenvorschub getrennte Testsuite.)

Entfernt einfach alle Übereinstimmungen des regulären Ausdrucks in der ersten Zeile.

Zimtgummi, 23 Bytes

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

Probieren Sie es online aus.

Erläuterung

Dies dekomprimiert nach d([aeiou]+[^aeiou]*)([aeiou]+[^aeiou]*)? [^aeiou]*, wodurch dalles gelöscht wird, was zu diesem regulären Ausdruck passt. (Beachten Sie, dass Jordaniens Golfspieler d([aeiou]+[^aeiou]*){,2} [^aeiou]*aufgrund des Fehlens wiederholter zu komprimierender Elemente auf 24 Byte komprimiert.)

PHP, 95 Bytes

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

mit preg_match statt 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, plus 1 für -pestatt-e

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

Hutspitze.

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

Dieser war schwer.

Schau es dir auf repl.it an

Lithp , 65 Bytes

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

Dies ist im Grunde eine Portierung der obigen JavaScript-Antwort in meiner funktionalen Programmiersprache "Lisp-ish".

Anwendungsbeispiel:

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

Noch kein Online-Dolmetscher. Ich werde bald eine zur Verfügung stellen. Es wird nicht schwierig sein, meine Sprache ist in JavaScript geschrieben.

Stattdessen wird diese Rätsellösung als Arbeitsbeispiel für meine Sprache implementiert. Es kann mit dem folgenden Befehl ausgeführt werden:

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

Diese Nicht-Regex-Lösung erwies sich als länger als erwartet. Ideone es trotzdem.

Jq 1,5 , 45 Bytes

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

Nichts Besonderes, nur ein Port von msh210 ‚s Perl Lösung jq der PCRE.

Probieren Sie es online!

Japt , 18 Bytes

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

Probieren Sie es online!

Direkter Port der kurzen JS-Lösung, die wiederum der Port von Jordans Ruby-Lösung ist .

Wie es funktioniert

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.