Bạn đã bao giờ nghĩ đến việc tạo ra các hashtag thú vị trên twitter như #oustxit hoặc #brangelina chưa? golf này là dành cho bạn.

Viết chương trình chấp nhận hai chuỗi A & B làm đầu vào và hợp nhất chúng theo thuật toán sau:

1. hãy nlà số nhóm nguyên âm trong A (ví dụ: britaincó 2 nhóm nguyên âm: iở vị trí 3 và aiở vị trí 5).
   • if n = 1: cắt ngắn A bắt đầu từ vị trí nhóm nguyên âm đầu tiên của nó (ví dụ: bill=> b)
   • if n> 1: cắt ngắn A bắt đầu từ n-1vị trí nhóm nguyên âm thứ của nó (ví dụ: programming=> progr, britain=> br)
2. xóa tất cả các phụ âm ở đầu B ( jennifer=> ennifer)
3. nối A & B đã sửa đổi

Nguyên âm là aeiou; phụ âm là bcdfghjklmnpqrstvwxyz.

Đầu vào

Bạn có thể giả sử các chuỗi đầu vào là chữ thường và chứa ít nhất một nguyên âm và một phụ âm.

Ví dụ

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 byte

+1 byte cho -pcờ. Đưa đầu vào được phân tách bằng dấu cách trên STDIN.
-1 byte nhờ Martin Ender
-2 byte nhờ histocrat

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

Hãy thử trực tuyến!

GNU sed, 39 37 + 1 = 38 byte

+1 byte cho -Ecờ. Đưa đầu vào được phân tách bằng dấu cách trên STDIN.
-1 byte nhờ Martin Ender

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

Hãy thử trực tuyến!

Không đăng bài này như một câu trả lời riêng biệt bởi vì nó thực sự là cùng một giải pháp.

MATL, 31 30 byte

t13Y2XJmFwhdl=fql_):)itJmYsg)h

Dùng thử trực tuyến

Giải trình

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

Đã lưu 8 byte nhờ @Jordan, 1 nhờ @DavidConrad

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

Mặc dù .matchtrả về một mảng, array+arraytrả về một chuỗi có nội dung của các mảng được nối (nghĩa là[0]+[1] trả về "01").

Kiểm tra đoạn

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>

Giải pháp Ruby tuyệt vời của Jordan sẽ là 53 byte trong JS:

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

Thạch , 23 22 byte

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

Dùng thử

Làm sao?

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]*')

Rõ ràng đây là một regex phổ biến ... ;-)

Sử dụng -replacetoán tử để kéo ra các mảnh thích hợp, sau đó nối các kết quả lại với nhau. Thêm vào một $đầu tiên để đảm bảo chúng ta kéo phần cuối của chuỗi và thêm một ^vào phần thứ hai để đảm bảo chúng ta kéo ra phía trước chuỗi.

Võng mạc , 35 byte

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

Hãy thử trực tuyến! (Dòng đầu tiên cho phép bộ kiểm tra được phân tách bằng nguồn cấp.)

Đơn giản chỉ cần loại bỏ tất cả các trận đấu của regex trên dòng đầu tiên.

Quế Gum, 23 byte

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

Hãy thử trực tuyến.

Giải trình

Điều này giải nén d([aeiou]+[^aeiou]*)([aeiou]+[^aeiou]*)? [^aeiou]*, mà dbỏ qua bất cứ điều gì phù hợp với regex đó. (Lưu ý rằng gôn thủ của Jordan d([aeiou]+[^aeiou]*){,2} [^aeiou]*nén tới 24 byte do thiếu các yếu tố lặp lại để nén.)

PHP, 95 byte

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

với preg_match thay vì preg_filter 110 Byte

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

Lua, 66 byte

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

Perl 5, 39 byte

38, cộng 1 cho -pethay vì-e

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

Đầu mũ.

Python 2, 139 byte

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

Điều này thật khó khăn.

Kiểm tra nó trên repl.it

Tiếng Litva , 65 byte

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

Về cơ bản, đây là một cổng của câu trả lời JavaScript ở trên, trong ngôn ngữ lập trình chức năng Lisp-ish của tôi.

Ví dụ sử dụng:

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

Không có thông dịch viên trực tuyến nào. Tôi sẽ cung cấp một sớm. Sẽ không khó, ngôn ngữ của tôi được viết bằng JavaScript.

Thay vào đó, giải pháp câu đố này được thực hiện như một ví dụ hoạt động cho ngôn ngữ của tôi. Nó có thể được chạy với lệnh sau:

node run.js l_src/progruzzle-colf.lithp

Haskell, 111 108 byte

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

Giải pháp phi regex này hóa ra lâu hơn dự kiến. Dù sao thì nó cũng vậy.

Jq 1,5 , 45 byte

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

Không có gì đặc biệt, chỉ là một cổng của giải pháp perl của msh210 cho PCRE của jq.

Hãy thử trực tuyến!

Japt , 18 byte

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

Hãy thử trực tuyến!

Cổng trực tiếp của giải pháp JS ngắn , lần lượt là cổng của giải pháp Ruby của Jordan .

Làm thế nào nó hoạt động

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.