这项挑战是对2017年奥斯卡最佳影片奖得主La La Land Moonlight的致敬！

编写一个函数/程序，该函数/程序接受仅包含字母的字符串[A-Za-z]，该字符串是日常句子.,'?和空格中常见的四个符号 ，并以La La Land的样式输出该字符串。

更具体地说，将字母带到第一个元音组，包括第一个，然后打印/输出两次，每次添加一个空格，然后打印/输出整个字符串。y是这个挑战中的元音。标点符号和大写字母应保留。

您可以假定所有字符串至少包含一个元音，并且所有字符串均以字母开头。

测试用例：

Land
La La Land

Moonlight
Moo Moo Moonlight

quEueIng
quEueI quEueI quEueIng

This isn't a single word.
Thi Thi This isn't a single word.

It's fun to play golf
I I It's fun to play golf

Ooo
Ooo Ooo Ooo

I'm okay
I I I'm okay

Hmm, no. There will be at least one vowel, but it can be anywhere.
Hmm, no Hmm, no Hmm, no. There will be at least one vowel, but it can be anywhere.

Why is y a vowel?
Why Why Why is y a vowel?

这是代码高尔夫球，因此每种语言中最短的代码将获胜。鼓励以主流语言进行解释。

sed 30字节

s/[^aeiouy]*[aeiouy]\+/& & &/i

05AB1E，23 19 18字节

由于Okx，节省了1个字节。

Dlð«žOsSåJTk>£D¹ðý

在线尝试！ 或作为测试套件

说明

 Dl                  # create a lowercase copy of implicit input
   ð«                # append a space
     žO              # push the vowels
       s             # swap lowercase input to the top of the stack
        S            # split into a list of chars
         å           # check each char for membership in the vowel-string
                     # (creates a list with 1 at the index of vowels and 0 for non-vowels)
          J          # join to string
           Tk        # find the index of 10
             >       # increment
              £      # take that many items from input
               D     # duplicate this string
                ¹    # push input
                 ðý  # join the strings by space

果冻，24 22 20 19 14 字节

通过使用Emigna 出色答案的技巧获得-5个字节（在isVowel列表中查找10 个字节）

;⁶e€Øyw⁵ḣ@;⁶Ȯ;

在线尝试！（不太确定如何为此完整程序制作测试套件）

15字节替代：

;⁶e€Øyw⁵ḣ@;⁶ẋ2;

这是完整的测试套件。

怎么样？

;⁶e€Øyw⁵ḣ@;⁶Ȯ; - Main link: string s
 ⁶             - space character
;              - concatenate to s (for all vowel edge case)
    Øy         - vowels + y yield
  e€           - exists in? for €ach (gives a list of isVowel identifiers)
       ⁵       - 10
      w        - index of first sublist (with implicit decimalisation of 10 to [1,0])
        ḣ@     - head with reversed @rguments (start of word up to & including vowel group)
           ⁶   - space character
          ;    - concatenate (start of word up to & including vowel group plus a space)
            Ȯ  - print and yield (hence a full program...
               -     ...the alternative ẋ2 repeats instead in order to return the result)
             ; - join with the input, s
               - implicit print (of the second repetition and input string)

Python，61个字节

import re;lambda x:re.sub('(.*?[aeiouy]+)',r'\1 \1 \1',x,1,2)

这是第一种基于非正则表达式的语言（使用正则表达式）。

感谢Neil，节省了1个字节。

JavaScript（ES6），40 46

编辑保存的5 + 1字节@Arnauld

与使用相同技巧的其他工具相比，时间过长（通常）

x=>x.replace(/.*?[aeiouy]+/i,'$& $& $&')

let f=
x=>x.replace(/.*?[aeiouy]+/i,'$& $& $&')

test=`Land
La La Land

Moonlight
Moo Moo Moonlight

queueing
queuei queuei queueing

This isn't a single word.
Thi Thi This isn't a single word.

It's fun to play golf
I I It's fun to play golf

Ooo
Ooo Ooo Ooo

I'm okay
I I I'm okay

Hmm, no. There will be at least one vowel, but it can be anywhere.
Hmm, no Hmm, no Hmm, no. There will be at least one vowel, but it can be anywhere.`
test.split(`\n\n`).forEach(z=>{
  var [i,k]=z.split(`\n`),x=f(i);
  console.log(k==x ? 'OK':'KO',i+'\n'+x);
})

视网膜，24字节

i`^.*?[aeiouy]+
$& $& $&

在线尝试！

批量180字节

@echo off
set/ps=
set v=aeiouy
set g=c
set t=
:l
call set w=%%v:%s:~,1%=%%
if %v%==%w% goto %g%
set g=o
:c
set t=%t%%s:~,1%
set s=%s:~1%
goto l
:o
echo %t% %t% %t%%s%

实现状态机。g跟踪我们是否见过元音，因此，如果当前字母不是元音，我们会知道是输出还是继续下一个字母。

PowerShell，46 47 41 39 38字节

$args-replace"^.*?[aeiouy]+",(,'$&'*3)

在线尝试！

感谢Maarten Bamelis的错误修复

多亏了Rynant，节省了6个字节

由于Joey，节省了2 3个字节

红宝石， 31 32 30字节

->s{(s[/.*?[aeiouy]+/i]+' ')*2+s}

多亏了GB和Cyoce，节省了两个字节。

PHP，55 54字节

注：编码版本使用IBM-850编码。

echo preg_filter("/^(.*?[aeiouy]+)/i","$1 $1 $0",$argn);
echo preg_filter(~ðíÎÐı└ñ×ÜûÉèåóÈÍðû,~█╬▀█╬▀█¤,$argn);     # Encoded

像这样运行：

echo "This isn't a single word." | php -nR 'echo preg_filter(~ðíÎÐı└ñ×ÜûÉèåóÈÍðû,~█╬▀█╬▀█¤,$argn);'

说明

只是用正则表达式替换非急切匹配字符串开头的任何字符，然后再匹配任意数量的元音（不区分大小写使用i选项）。然后将捕获组打印两次，然后打印整个字符串。

调整

• 通过使用-R来保存一个字节$argn（Thx Titus）

Javascript（ES6），38个字节

x=>(y=/.*?[aeiouy]+/i.exec(x)+' ')+y+x

f=
x=>(y=/.*?[aeiouy]+/i.exec(x)+' ')+y+x

<!-- snippet demo: -->
<input list=l oninput=console.log(f(this.value))>
<datalist id=l><option value=Land>
<option value=Moonlight>
<option value=queueing>
<option value="This isn't a single word.">
<option value="It's fun to play golf">
<option value=Ooo>
<option value="I'm okay.">
<option value="Hmm, no. There will be at least one vowel, but it can be anywhere.">
<option value="Why is y a vowel?">

Perl，25 + 1（-p标志）

s/.*?[aeiouy]+/$& $& $&/i

Perl 6，30个字节

{S:i/.*?<[aeiouy]>+/{$/xx 3}/}

在线尝试！

C，202 196 195 193 190 180

i,j,k,m,n;f(char*a){if((a[i/12]-"AEIOUY"[i++%6])%32==0)k=n=24-(i%12);else if(k&&!n--){m=j=(i-13)/12;for(i=0;i<j*2;)printf("%c%c",a[i%j],(i==j-1)*32),i++;printf(" %s", a);}m?:f(a);}

在线尝试！

剩下的事情要打高尔夫球：

•将两份打印f合为一。

我可以%*c肯定，打印我的空格字符可以更改为逻辑。

•我正在使用可以以某种方式删除的条件

• j=(i-13)/12可能会缩短。

•[AY]有条件地检查==0通常是否不必要，尽管我目前仍停留在那个位置（尝试切换if-else并==0完全放弃，但这需要添加更多的{brackets}并增加字节大小）

我过去经常打高尔夫球的技巧：

•通过对x轴使用模和对y轴使用整数除法来组合双精度循环字符串搜索（输入字符串与元音字符串）。（X轴循环两次，然后在y轴上迭代一次；第一次使用[AZ]，第二次使用[az]使用字符值32微分。

•通过仅使用字符集和模32之间的距离来绕过必须使用“ [AY]和[ay]”的情况。如果距离为0（AA）或距离为32（aA），则采用这种方式

•重新使用不再用作布尔变量的整数变量。

•递归调用具有相同字符串的函数来处理该函数，并避免第二个for循环。

•将BOOL值设置为设置另一个变量的逻辑。（例如bool = i = 5;）用一块石头将两者都击倒。

•三重虚假利用漏洞。（海湾合作委员会）

可读格式：

i,j,k,m,n;
f(char*a){
    if((a[i/12]-"AEIOUY"[i++%6])%32==0)
        k=n=24-(i%12);
    else
        if(k&&!n--){
            m=j=(i-13)/12;
            i=0;
            for(;i<j*2;)
               printf("%c%c",a[i%j],(i==j-1)?32:0),i++;
            printf(" %s", a);
        }
    m?:f(a);
}

感谢Keyu Gan（在评论中）删除了10个字节

MATL，33个字节

'(^.*?[yY%s]+)'13Y2YD'$1 $1 $1'YX

在MATL Online上尝试

说明

                % Implicitly grab input as a string
'(^.*?[yY%s]+)' % Push this string literal (regex pattern)
13Y2            % Push the string literal 'AEIUOaeiuo'
YD              % Replace the '%s' in the string with 'AEIUOaeiuo'
'$1 $1 $1'     % Push the string literal to use for replacement which repeats
                % the first match 3 times
YX              % Perform regular expression matching and replacement
                % Implicitly display the result

V，21，20字节

é /ã[aeiouy]«“.
3ä|<

在线尝试！

说明：

é               " Insert a space
  /             " Jump forward too...
   ã[aeiouy]«. "   The first non-vowel after a vowel
3ä              " Make three copies of
  |             " Everything from the cursor to the first character
   <            " Delete the space we inserted

十六进制转储：

00000000: e920 2fe3 5b61 6569 6f75 795d ab93 2e0a  . /.[aeiouy]....
00000010: 33e4 7c3c                                3.|<

备用版本（21字节）：

Í㨃[aeiouy]«©/± ± &

在线尝试！

这使用了可笑的正则表达式压缩，并且仍然设法使其与其他高尔夫语言相提并论。作为参考，这大约是常规“未压缩”版本的三分之二，即：

:%s/\v\c(.{-}[aeiou]).*/\1 \1 &

说明：

Í                               " Replace on every line:
 ã                              "   Case-insensitive
  ¨              ©              "   Capture-group 1
   <131>                        "   Any character, any number of times (non-greedy)
        [aeiouy]«               "   A vowel, repeated once or more
                  <129>         "   Followed by anything
                       /        " Replaced with:
                        ± ±     "   Capture group one twice, with spaces between
                            &   "   The whole matched pattern

这是一个十六进制转储：

00000000: cde3 a883 5b61 6569 6f75 795d aba9 812f  ....[aeiouy].../
00000010: b120 b120 26                             . . &

Python 3中，75 68个字节

lambda s:(s[:[x in"aAeEiIoOuUyY"for x in s][1:].index(0)+1]+" ")*2+s

在线尝试！

说明：

通过根据是否为元音为输入字符串中的每个字符生成一个布尔值，并找到0第一个非元音的最低索引（不包括第一个字符）来工作。它将子字符串返回到该索引两次，以空格和原始字符串分隔。

Clojure中，192个 188 181字节

(fn[p](let[[f] p v #(#{\a \e \i \o \u \y}(Character/toLowerCase %))[q r](split-with(if(v f)v #(not(v %)))p)[w _](split-with v r)as #(apply str %)](str(as(repeat 2(str(as q)(as w) \ )))p)))

通过内联first-sp-pred（whoops）-4个字节。

删除一些遗漏的空格-7字节

这比我想的要困难得多！我正在手动解析字符串...因为我仍然没有去学习正则表达式：/

请参阅预查询的代码以获取细分：

(defn repeat-prefix-cons [phrase]
  (let [[first-letter] phrase ; Get first letter

        ; Function that checks if a lowercased character is a part of the vowel set
        vowel? #(#{\a \e \i \o \u \y} (Character/toLowerCase %))

        ; cons(onant)? Negation of above
        cons? #(not (vowel? %))

        ; Decide how to split it depending on if the first character is a vowel
        first-sp-pred (if (vowel? first-letter) vowel? cons?)

        ; Split off the first chunk of cons/vowels
        [pre1 r] (split-with first-sp-pred phrase)

        ; Split off the rest of the vowels
        [pre2 r2] (split-with vowel? r)

        ; Shortcut function that turns a list into a string (Basically (join "" some-list-of-strings) )
        as #(apply str %)]

    (str ; ... then concat the prefix in front of the original phrase, and return
      (as ; ...then turn it back into a string since "repeat" returns a list... ^
        (repeat 2 ; ... then repeat it twice (shame Clojure doesn't have string multiplication)... ^
                (str (as pre1) (as pre2) \ ))) ; Concat the 2 prefix parts together with an space at the end... ^
      phrase)))

Python 3中，101个 96字节

s=input()
v=i=0
for c in s:
 w=c in'aAeEiIoOuUyY'
 if v*~-w:break
 v=w;i+=1
print(s[:i],s[:i],s)

在线尝试！

非正则表达式解决方案

评论：

s=input()
a='aAeEiIoOuUyY'
v=i=0
for c in s:          # for each character in the string
 w=c in a            # w = True if the character is a vowel, else false
                     # true is equivalent to 1  and false to zero
                     # v*(w-1) evaluates only to true (-1 in this case) if v=1 (last character was a vowel) and w=0 (current character is not a vowel)
 if v*(w-1):break    # if so, break the loop
 v=w;i+=1            # increase the counter and set v to w
print(s[:i],s[:i],s)

欧姆，19字节（CP437），无竞争

使用新语言，因此，我必须添加一些新功能才能使此功能生效，但令人遗憾的是，这使该功能失去了竞争力（因为存在漏洞）。

≡┬üC▓αy_ε;TF«u├DQüj

说明：

≡┬üC▓αy_ε;TF«u├DQüj     Main wire, arguments: s

≡                       Triplicate input
 C                    Push input, all lowercase with concatenated space character
    ▓    ;              Map string into an array with...
     αy_ε                 Boolean: is element a vowel?
          TF«u          Find first occurrence of [true, false]
              ├D        Slice input up to that index and duplicate it
                Q       Reverse stack
                 üj     Join on spaces, implicitly print

PHP，69 65 53字节

<?=preg_filter("#.*?[aeiouy]+#i","$0 $0 $0",$argn,1);

需要PHP 5.3或更高版本。使用-F或以管道方式运行在线尝试某些版本。

使用@aross窃取的正则表达式保存了4个字节（并修复了代码）；
还有10个，preg_filter而不是preg_match和-F
和另外两个具有改进的正则表达式。

非正则表达式版本为 75 81字节：

for(;$c=$argn[$i++];)($k+=$k^!trim($c,aeiouyAEIOUY))>1?:$w.=$c;echo"$w $w $argn";

需要PHP 5或更高版本；替换?:为?1:的旧的PHP。与运行-nR

分解

for(;$c=$argn[$i++];)       // loop $c through input characters
    ($k+=$k^!                   // 2. !$k and vowel or $k and not vowel: increment $k
        trim($c,aeiouyAEIOUY)   // 1. strip vowels -> vowel=false, non-vowel=true
    )>1                         // 3. if $k>1
    ?                           // do nothing
    :$w.=$c;                    // else append $c to $w
echo"$w $w $argn";          // output

R，49位元组

sub("(.*?[aeiouy]+)","\\1 \\1 \\1",scan(,""),T,T)

基于正则表达式的替换，匹配所有内容直到没有元音，然后捕获并自行替换3次。

scan等待double类型输入，要告诉它使用character类型，我们必须给它提供两个参数，第一个是stdin的default，emtpy字符串，第二个是R评估只允许使用，c因为它character在这种情况下没有歧义。

T代表TRUE并将一些char作为第4和第5个参数保存到sub来告诉它忽略大小写并使用PCRE（贪婪性与R regex语法不同）

Sumner18提供了4个字节的保存，并附带了Tio 链接到运行代码

Java 8、147字节

打高尔夫球：

import java.util.regex.*;s->{Matcher m=Pattern.compile("([^aeiouy]*[aeiouy]+)",2).matcher(s);m.find();return m.group()+" "+m.group()+" "+s;}

取消高尔夫：

import java.util.regex.*;

public class LaLaLandNoWaitMooMooMoonlight {

  public static void main(String[] args) {
    for (String[] strings : new String[][] { { "Land", "La La Land" }, { "Moonlight", "Moo Moo Moonlight" },
        { "queueing", "queuei queuei queueing" }, { "This isn't a single word.", "Thi Thi This isn't a single word." },
        { "It's fun to play golf", "I I It's fun to play golf" }, { "Ooo", "Ooo Ooo Ooo" },
        { "I'm okay", "I I I'm okay" }, { "Hmm, no. There will be at least one vowel, but it can be anywhere.",
            "Hmm, no Hmm, no Hmm, no. There will be at least one vowel, but it can be anywhere." } }) {
      final String input = strings[0];
      final String expected = strings[1];
      final String actual = f(s -> {
        java.util.regex.Matcher m = java.util.regex.Pattern.compile("([^aeiouy]*[aeiouy]+)", 2).matcher(s);
        m.find();
        return m.group() + " " + m.group() + " " + s;
      } , input);
      System.out.println("Input:    " + input);
      System.out.println("Expected: " + expected);
      System.out.println("Actual:   " + actual);
      System.out.println();
    }

  }

  private static String f(java.util.function.Function<String, String> function, String input) {
    return function.apply(input);
  }
}

注意：2代码中的文字是的值java.util.regex.Pattern.CASE_INSENSITIVE。

C，123字节

#define v(x)while(x strchr("AEIOUY",*s&95))++s;
a;f(s,t)char*s,*t;{t=s;v(!)v()a=*s;*s=0;printf("%s %s ",t,t);*s=a;puts(t);}

致电为：

main(){char s[] = "queueing"; f(s);}

Pyke，22个字节

l1~V\y+L{$0R+f2<ssDQdJ

在线尝试！

这比我实施了一种更短的获取元音（包括）的方法实际所需要的长4个字节y。

视网膜，24字节

i1`.*?[aeiouy]+
$0 $0 $0

在线尝试

Python 3中，130个 102字节

w=input();a='';v=0
for i in w:
	if i in 'aeiouyAEIOUY': v=1
	elif v:
		break
	a+=i
a+=' ';print(a*2+w)

在线尝试！

不使用任何函数，也不使用外部库！（除非将打印和输入视为功能，否则它们会这样做）。

通过查看标题开头的辅音是否进入“元音区”来工作。如果它在“元音区”中并且检测到辅音，则它将打印标题。

@LliwTelracs节省了28个字节

MATLAB /八度， 58 51字节

@HughNolan节省了7个字节

@(x)regexprep(x,'(^.*?[aeiouyAEIOUY]+)','$1 $1 $1')

创建一个名为的匿名函数 ans，该可以通过将字符串传递给它来调用：ans('Land')

在线演示

为了与MATLAB兼容，$0应使用代替$1上面的函数。

C（gcc），111110字节

*d="AEIOUYaeiouy";b;f(char*a){b=strcspn(a,d);write(printf(" "),a,write(1,a,b+strspn(a+b,d)));printf(" %s",a);}

在线尝试！

这仅使用库函数strspn()并strcspn()利用gcc评估函数参数的顺序。少打高尔夫球

*d="AEIOUYaeiouy";b;
f(char*a){
  b=strcspn(a,d);
  write(printf(" "),a,write(1,a,b+strspn(a+b,d)));
  printf(" %s",a);
}

感谢@gastropner -1。

Pyth-24个字节

jd[Ke:Q"^.*?[aeiou]+"1KQ

测试套件。