Este desafio é uma homenagem ao vencedor de Melhor Filme no Oscar 2017, La La Land Moonlight !

Escreva uma função / programa que use uma sequência que contenha apenas letras [A-Za-z], os quatro símbolos comuns em frases .,'?e espaços diários , e emita a sequência no estilo La La Land.

Para ser mais específico, pegue as letras até e incluindo o primeiro grupo de vogais e imprima / produza duas vezes, adicionando um espaço a cada vez, depois imprima / imprima a seqüência inteira. y é uma vogal neste desafio. A pontuação e a capitalização devem ser mantidas.

Você pode assumir que todas as cadeias contêm pelo menos uma vogal e que todas as cadeias iniciam com uma letra.

Casos de teste:

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?

Isso é código-golfe, portanto o código mais curto em cada idioma vence. As explicações são incentivadas , também nos idiomas principais.

Sed 30 bytes

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

05AB1E , 23 19 18 bytes

Guardado 1 byte graças a Okx .

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

Experimente online! ou como um conjunto de testes

Explicação

 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

Gelatina , 24 22 20 19 14 bytes

-5 bytes, utilizando um truque da brilhante resposta de Emigna (procure 10 na lista isVowel)

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

Experimente online! (não tenho certeza de como criar um conjunto de testes para este programa completo)

Alternativa de 15 bytes:

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

Aqui está o conjunto completo de testes.

Quão?

;⁶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 bytes

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

Aí vem a primeira linguagem não baseada em regex (usando regex).

Guardado 1 byte graças a Neil .

JavaScript (ES6), 40 46

Editar 5 + 1 bytes salvos thx @Arnauld

Excessivamente longo comparado a outros usando o mesmo truque (como de costume)

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);
})

Retina , 24 bytes

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

Experimente online!

Lote, 180 bytes

@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%

Implementa uma máquina de estado. gcontrola se alguma vez vimos uma vogal, portanto, se a letra atual não for uma vogal, sabemos se a saída será ou continuará com a próxima letra.

PowerShell , 46 47 41 39 38 bytes

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

Experimente online!

Obrigado a Maarten Bamelis pela correção

Economizou 6 bytes graças a Rynant

Guardado 2 3 bytes graças a Joey

Rubi, 31 32. 30 bytes

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

Dois bytes salvos graças ao GB e Cyoce.

PHP, 55 54 bytes

Nota: a versão codificada usa a codificação IBM-850.

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

Execute assim:

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

Explicação

Apenas um regex substitui por não ansioso que corresponda a qualquer caractere no início da string, seguido por qualquer quantidade de vogais (use a iopção para diferenciar maiúsculas de minúsculas). Esse grupo de captura é então impresso duas vezes, seguido pela sequência inteira.

Tweaks

• Salvo um byte usando -Rpara $argndisponibilizar (Thx Titus)

Javascript (ES6), 38 bytes

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 ( -pbandeira)

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

Perl 6 , 30 bytes

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

Experimente online!

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);}

Experimente online!

O que resta para o golfe:

• Recolha duas impressões em uma.

• A impressão do meu caractere de espaço pode ser alterada em %*clógica, tenho certeza.

• Estou usando condicionais que podem ser removidos de alguma forma

• j=(i-13)/12provavelmente pode ser encurtado.

• [AY] verifica condicionalmente o ==0que normalmente não é necessário, embora eu esteja atualmente preso nesse (tentei alternar entre outros e abandonar o ==0conjunto, mas isso exige adicionar mais {colchetes} e aumentar o tamanho de bytes)

Truques que eu usei para jogar isso:

• Combinou uma pesquisa dupla para sequência de loop usando módulo para o eixo xe divisão inteira para o eixo y (sequência de entrada versus sequência de vogais). (O eixo X é repetido duas vezes antes de iterar uma vez no eixo y; a primeira vez com [AZ] e a segunda vez com [az] usando o valor do caractere 32 diferencial.

• Ignorou a necessidade de usar "[AY] e [ay]", apenas medindo a distância entre os conjuntos de caracteres e o módulo 32. Dessa forma, se a distância for 0 (AA) ou se a distância for 32 (aA)

• Reutilizando variáveis ​​inteiras que não são mais usadas como variáveis ​​booleanas.

• Chamar recursivamente uma função com a mesma string para processá-la e evitar um segundo loop for.

• Defina os valores BOOL com a lógica de definir outra variável. (por exemplo, bool = i = 5;) nocautear ambos com uma pedra.

• Abuso de exploração vazio-verdadeiro ternário. (GCC)

Formato legível:

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);
}

Derrubou 10 bytes graças a Keyu Gan (nos comentários)

MATL, 33 bytes

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

Experimente no MATL Online

Explicação

                % 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 bytes

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

Experimente online!

Explicação:

é               " 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

Hexdump:

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

Versão alternativa (21 bytes):

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

Experimente online!

Isso usa uma ridícula compactação de expressões regulares e ainda consegue ser chutado por outras línguas do golfe. Para referência, este é cerca de dois terços do comprimento da versão "descompactada" regular, a saber:

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

Explicação:

Í                               " 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

Aqui está um hexdump:

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

Python 3 , 75 68 bytes

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

Experimente online!

Explicação:

Funciona gerando um valor booleano para cada caractere na cadeia de entrada com base em se é ou não uma vogal e em encontrar o índice mais baixo da 0primeira não vogal (excluindo o primeiro caractere). Retorna a substring para esse índice duas vezes, separada por espaços e a string original.

Clojure, 192 188 181 bytes

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

-4 bytes inlining first-sp-pred(gritos).

-7 bytes removendo alguns espaços perdidos

Isso foi muito mais desafiador do que eu pensava! Estou analisando manualmente a string ... já que ainda não aprendi a regex: /

Consulte o código pré-golfe para obter informações detalhadas:

(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 bytes

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)

Experimente online!

uma solução não regex

Comentado:

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)

Ohm , 19 bytes (CP437), não concorrente

Nova linguagem e, como tal, tive que adicionar alguns novos recursos para fazer esse trabalho, o que infelizmente torna isso não competitivo (por brechas).

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

Explicação:

≡┬ü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 bytes

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

requer PHP 5.3 ou posterior. Execute como pipe -Fou experimente algumas versões online .

Salvo 4 bytes (e corrigido o código) com o regex roubado do @aross;
Mais 10 com em preg_filtervez de preg_matche -F
e outros dois com um regex aprimorado.

75 81 bytes para uma versão não regex:

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

requer PHP 5 ou posterior; substitua ?:por?1: PHP mais velho. Correr com-nR

Demolir

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, 49bytes

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

Substituição baseada em Regex, combine tudo até que não seja uma vogal, capture e substitua por si mesma 3 vezes.

scanespere por uma doubleentrada de tipo, para dizer a ela para usar o charactertipo, temos que fornecer dois argumentos: primeiro é a string emtpy padrão para stdin e, no segundo, a avaliação R permite usar apenas uma cvez que não é ambíguo characternesse contexto.

T apoia TRUE e salva alguns caracteres como 4º e 5º parâmetro para sub para dizer a ele para ignorar maiúsculas e minúsculas e usar PCRE (a ganância não é a mesma com a sintaxe de regex R)

4 bytes salvos, cortesia de Sumner18, juntamente com o link Tio para executar o código

Java 8, 147 140 bytes

Golfe:

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

Ungolfed:

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);
  }
}

Nota: o literal 2no código é o valor de java.util.regex.Pattern.CASE_INSENSITIVE.

C, 123 bytes

#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);}

Ligue como:

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

Pyke , 22 bytes

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

Experimente online!

Isso tem 4 bytes a mais do que deveria, se eu tivesse implementado uma maneira mais curta de obter vogais, inclusive y.

Retina, 24 bytes

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

Experimente online

Python 3 , 130 102 bytes

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)

Experimente online!

Não usa nenhuma função de nenhum tipo e nenhuma biblioteca externa! (A menos que impressão e entrada sejam contabilizadas como funções, o que eles fazem).

Funciona verificando se sai das consoantes no início do título para a 'zona da vogal'. Se estiver na 'zona da vogal' e detectar uma consoante, será impresso o título.

Guardado 28 bytes graças a @LliwTelracs

MATLAB / Oitava, 58 51 bytes

7 bytes salvos graças a @HughNolan

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

Cria uma função anônima chamada ansque pode ser chamada passando uma string para ela:ans('Land')

Demo Online

Para compatibilidade com MATLAB, $0deve ser usado no lugar da $1função acima.

C (gcc) , 111 110 bytes

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

Experimente online!

Isso só usa as funções da biblioteca strspn()e strcspn()e explora a ordem em que gcc avalia parâmetros da função. Um pouco menos golfe

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

Obrigado a @gastropner por -1.

Pitão - 24 bytes

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

Conjunto de Teste .