เคยลองสร้างแฮชแท็ก Twitter ที่ยอดเยี่ยมเช่น#brexitหรือ#brangelinaหรือไม่ กอล์ฟนี้เหมาะสำหรับคุณ

เขียนโปรแกรมที่ยอมรับสองสตริง A & B เป็นอินพุทและผสานมันตามอัลกอริทึมต่อไปนี้:

1. อนุญาตnเป็นจำนวนกลุ่มเสียงสระใน A (เช่นbritainมีกลุ่มเสียงสระ 2 กลุ่ม: iในตำแหน่งที่ 3 และaiในตำแหน่งที่ 5)
   • ถ้า n = 1: ตัดปลาย A เริ่มต้นที่ตำแหน่งกลุ่มเสียงสระแรก (ตัวอย่าง: bill=> b)
   • ถ้า n> 1: truncate A เริ่มต้นที่n-1ตำแหน่งกลุ่มเสียงสระ th (ตัวอย่าง: programming=> progr, britain=> br)
2. ลบพยัญชนะทั้งหมดที่จุดเริ่มต้นของ B ( jennifer=> ennifer)
3. เชื่อมต่อ A&B ที่แก้ไข

สระคือaeiou; bcdfghjklmnpqrstvwxyzพยัญชนะ

อินพุต

คุณสามารถสมมติว่าสตริงอินพุตเป็นตัวพิมพ์เล็กและมีเสียงสระอย่างน้อยหนึ่งเสียงและหนึ่งตัวอักษร

ตัวอย่าง

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 ไบต์

+1 ไบต์สำหรับการ-pตั้งค่าสถานะ ใช้อินพุตที่คั่นด้วยช่องว่างบน STDIN
-1 ไบต์ขอบคุณ Martin Ender
-2 ไบต์ขอบคุณ histocrat

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

ลองออนไลน์!

รุ่น GNU, 39 37 + 1 = 38 ไบต์

+1 ไบต์สำหรับการ-Eตั้งค่าสถานะ ใช้อินพุตที่คั่นด้วยช่องว่างบน STDIN
-1 ไบต์ขอบคุณ Martin Ender

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

ลองออนไลน์!

ไม่โพสต์คำตอบนี้เป็นคำตอบแยกต่างหากเพราะเป็นคำตอบเดียวกัน

MATL, 31 30 ไบต์

t13Y2XJmFwhdl=fql_):)itJmYsg)h

ลองออนไลน์

คำอธิบาย

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 ไบต์

บันทึกแล้ว 8 ไบต์ขอบคุณ @Jordan, 1 ขอบคุณ @DavidConrad

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

แม้ว่าจะ.matchส่งคืนอาร์เรย์ แต่array+arrayส่งกลับสตริงที่มีเนื้อหาของอาร์เรย์ที่ต่อกัน (เช่น[0]+[1]ส่งคืน"01")

ตัวอย่างการทดสอบ

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>

โซลูชันทับทิมที่ยอดเยี่ยมของจอร์แดนจะอยู่ที่ 53 ไบต์ใน JS:

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

เยลลี่ , 23 22 ไบต์

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

TryItOnline

อย่างไร?

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 ไบต์

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

เห็นได้ชัดว่านี่คือ regex ยอดนิยม ... ;-)

ใช้-replaceโอเปอเรเตอร์เพื่อดึงชิ้นส่วนที่เหมาะสมออกจากนั้นเชื่อมต่อสตริงเข้าด้วยกัน เพิ่ม a $เข้ากับแรกเพื่อให้แน่ใจว่าเราดึงจุดสิ้นสุดของสตริงและเพิ่ม^ไปที่สองเพื่อให้แน่ใจว่าเราดึงออกจากด้านหน้าของสตริง

เรติน่า 35 ไบต์

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

ลองออนไลน์! (บรรทัดแรกเปิดใช้งานชุดทดสอบที่แยกบรรทัดด้วยฟีด)

เพียงลบการแข่งขันทั้งหมดของ regex ในบรรทัดแรก

หมากฝรั่งอบเชย, 23 ไบต์

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

ลองออนไลน์

คำอธิบาย

สิ่งนี้จะขยายตัวd([aeiou]+[^aeiou]*)([aeiou]+[^aeiou]*)? [^aeiou]*ซึ่งจะdลบสิ่งที่ตรงกับ regex (โปรดทราบว่านักกอล์ฟของจอร์แดนd([aeiou]+[^aeiou]*){,2} [^aeiou]*บีบอัดได้ถึง 24 ไบต์เนื่องจากขาดองค์ประกอบที่ต้องบีบอัดซ้ำ)

PHP, 95 ไบต์

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

กับ preg_match แทน 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 ไบต์

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

Perl 5, 39 ไบต์

38, บวก 1 -peแทน-e

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

ปลายหมวก

Python 2, 139 ไบต์

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

อันนี้ยาก

ลองดูที่ repl.it

Lithp , 65 ไบต์

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

นี่เป็นพอร์ตของคำตอบ JavaScript ข้างต้นในภาษาการเขียนโปรแกรม Lisp-ish ของฉัน

ตัวอย่างการใช้งาน:

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

ยังไม่มีล่ามออนไลน์ ฉันจะให้เร็ว ๆ นี้ ไม่ยากภาษาของฉันเขียนด้วย JavaScript

แต่วิธีการแก้ปัญหาปริศนานี้ถูกนำมาใช้เป็นตัวอย่างการทำงานสำหรับภาษาของฉัน มันสามารถทำงานได้ด้วยคำสั่งต่อไปนี้:

node run.js l_src/progruzzle-colf.lithp

Haskell, 111 108 ไบต์

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

โซลูชันที่ไม่ใช่ regex นี้เปิดใช้งานนานกว่าที่คาดไว้ ยังไงก็เถอะ

Jq 1.5 , 45 ไบต์

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

ไม่มีอะไรพิเศษเพียงแค่พอร์ตของโซลูชัน pershของmsh210ไปยัง PCRE ของjq

ลองออนไลน์!

Japt , 18 ไบต์

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

ลองออนไลน์!

พอร์ตโดยตรงของการแก้ปัญหา JS สั้นซึ่งเป็นในการเปิดพอร์ตของการแก้ปัญหาทับทิมจอร์แดน

มันทำงานอย่างไร

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.