¡Este desafío es un tributo al ganador de la Mejor Película en los Oscar 2017, La La Land Moonlight !

Escriba una función / programa que tome una cadena que contenga solo letras [A-Za-z], los cuatro símbolos que son comunes en las oraciones .,'?y espacios de cada día , y genere la cadena al estilo de La La Land.

Para ser más específico, tome las letras hasta el primer grupo de vocales, e imprímalo / imprímalo dos veces agregando un espacio cada vez, luego imprima / imprima toda la cadena. y es una vocal en este desafío. La puntuación y la capitalización deben mantenerse.

Puede suponer que todas las cadenas contienen al menos una vocal, y que todas las cadenas comienzan con una letra.

Casos de prueba:

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?

Este es el código de golf, por lo que gana el código más corto en cada idioma. Se alientan las explicaciones , también en los idiomas principales.

Sed 30 bytes

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

05AB1E , 23 19 18 bytes

Guardado 1 byte gracias a Okx .

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

Pruébalo en línea! o como un conjunto de pruebas

Explicación

 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 un truco de la brillante respuesta de Emigna (busque 10 en la lista isVowel)

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

Pruébalo en línea! (no estoy seguro de cómo hacer un conjunto de pruebas para este programa completo)

15 alternativa de bytes:

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

Aquí está el conjunto de pruebas completo.

¿Cómo?

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

Aquí viene el primer lenguaje no basado en expresiones regulares (usando expresiones regulares).

Guardado 1 byte gracias a Neil .

JavaScript (ES6), 40 46

Editar 5 + 1 bytes guardados gracias a @Arnauld

Demasiado largo en comparación con otros que usan el mismo truco (como de costumbre)

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]+
$& $& $&

Pruébalo en línea!

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 una máquina de estados. grealiza un seguimiento de si alguna vez hemos visto una vocal, por lo que si la letra actual no es una vocal, sabemos si se debe emitir o continuar con la siguiente letra.

PowerShell , 46 47 41 39 38 bytes

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

Pruébalo en línea!

Gracias a Maarten Bamelis por la corrección de errores.

Guardado 6 bytes gracias a Rynant

Guardado 2 3 bytes gracias a Joey

Rubí, 31 32 30 bytes

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

Dos bytes guardados gracias a GB y Cyoce.

PHP, 55 54 bytes

Nota: la versión codificada utiliza la codificación IBM-850.

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

Corre así:

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

Explicación

Solo una expresión regular se reemplaza por una coincidencia no ansiosa de cualquier carácter al comienzo de la cadena, seguido de cualquier cantidad de vocales (use i opción para la insensibilidad a mayúsculas y minúsculas). Ese grupo de captura se imprime dos veces, seguido de la cadena completa.

Ajustes

• Guardado un byte utilizando -Rpara poner a $argndisposición (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 ( -pbandera)

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

Perl 6 , 30 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!

Cosa que queda al golf:

• Contrae dos printf en uno.

• La impresión de mi espacio de caracteres se puede cambiar a %*clógica, estoy seguro.

• Estoy usando condicionales que se pueden eliminar de alguna manera

• j=(i-13)/12probablemente puede acortarse.

• [AY] verificaciones condicionales si ==0 generalmente no es necesario, aunque actualmente estoy atascado en eso (intenté cambiar if-else y deshacerme del==0 todo, pero eso requiere agregar más {corchetes} y aumentar el tamaño del byte)

Trucos que he usado para jugar golf:

• Combinó una búsqueda de doble cadena de bucle mediante el módulo para el eje xy la división de enteros para el eje y (cadena de entrada vs cadena de vocal). (El eje X se repite dos veces antes de iterar una vez en el eje y; la primera vez con [AZ] y la segunda con [az] usando el valor de carácter 32 diferencial.

• Omitió tener que usar "[AY] y [ay]" simplemente tomando la distancia entre los conjuntos de caracteres y el módulo 32. De esa manera, si la distancia es 0 (AA) o si la distancia es 32 (aA)

• Reutilizar variables enteras que ya no se usan como variables booleanas.

• Llamada recursiva a una función con la misma cadena para procesarla y evitar un segundo for-loop.

• Establezca los valores BOOL en la lógica de establecer otra variable. (por ejemplo, bool = i = 5;) para noquear a los dos de una piedra.

• Abuso de exploits ternario vacío verdadero. (CCG)

Formato legible:

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

Eliminó 10 bytes gracias a Keyu Gan (en comentarios)

MATL, 33 bytes

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

Pruébalo en MATL Online

Explicación

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

Pruébalo en línea!

Explicación:

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

Versión alternativa (21 bytes):

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

Pruébalo en línea!

Esto utiliza una compresión ridícula de expresiones regulares, y aún se las arregla para que otros lenguajes de golf lo pateen a tope. Como referencia, esto es aproximadamente dos tercios de la longitud de la versión regular "sin comprimir", a saber:

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

Explicación:

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

Aquí hay un 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

Pruébalo en línea!

Explicación:

Funciona generando un valor booleano para cada carácter en la cadena de entrada en función de si es o no una vocal, y encuentra el índice más bajo de 0la primera no vocal (excluyendo el primer carácter). Devuelve la subcadena a este índice dos veces, separadas por espacios y la cadena 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 en línea first-sp-pred (whoops).

-7 bytes eliminando algunos espacios perdidos

¡Esto fue mucho más desafiante de lo que pensaba! Estoy analizando manualmente la cadena ... ya que todavía no he podido aprender regex: /

Vea el código previo al golf para el desglose:

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

Pruébalo en línea!

una solución no 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), no competidor

Nuevo lenguaje, y como tal, tuve que agregar algunas características nuevas para que esto funcione, lo que lamentablemente hace que esto no sea competitivo (debido a las lagunas).

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

Explicación:

≡┬ü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);

requiere PHP 5.3 o posterior. Ejecutar como pipe con -Fo probar algunas versiones en línea .

Se guardaron 4 bytes (y se arregló el código) con expresiones regulares robadas de @aross;
10 más con en preg_filterlugar de preg_matchy -F
y otros dos con una expresión regular mejorada.

75 81 bytes para una versión no regex:

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

requiere PHP 5 o posterior; reemplazar ?:con ?1:PHP anterior. Corre con-nR

Descompostura

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)

Reemplazo basado en expresiones regulares, unir todo hasta que no sea una vocal, capturarlo y reemplazarlo solo 3 veces.

scanespere una doubleentrada de tipo, para decirle que use charactertipo tenemos que darle dos argumentos, primero es la cadena predeterminada, emtpy para stdin, y para el segundo la evaluación R permite usar solo cya que no es ambiguo characteren este contexto.

T representa TRUE y guarda algunos caracteres como 4º y 5º parámetro en sub para indicar que ignore mayúsculas y minúsculas y use PCRE (la codicia no es lo mismo con la sintaxis R regex)

4 bytes guardados por cortesía de Sumner18 junto con el enlace Tio al código en ejecución

Java 8, 147 140 bytes

Golfizado:

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

Sin golf:

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: el literal 2en el código es el 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);}

Llamar como:

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

Pyke , 22 bytes

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

Pruébalo en línea!

Esto es 4 bytes más de lo que debería haberse implementado. Implementé una forma más corta de obtener vocales incluidas y.

Retina, 24 bytes

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

Pruébalo en línea

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)

Pruébalo en línea!

¡No utiliza ninguna función de ningún tipo ni bibliotecas externas! (A menos que la impresión y la entrada cuenten como funciones, lo que hacen).

Funciona al ver si sale de las consonantes al comienzo del título hacia la "zona de vocales". Si está en la 'zona de vocales' y detecta una consonante, imprime el título.

Guardado 28 bytes gracias a @LliwTelracs

MATLAB / Octave, 58 51 bytes

7 bytes guardados gracias a @HughNolan

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

Crea una función anónima llamada a la ansque se puede llamar pasándole una cadena:ans('Land')

Demo en línea

Para compatibilidad con MATLAB, $0debe usarse en lugar de $1en la función anterior.

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

Pruébalo en línea!

Esto sólo utiliza funciones de biblioteca strspn()y strcspn()y explota el orden en que gcc evalúa parámetros de la función. Ligeramente menos golfizado

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

Gracias a @gastropner por -1.

Pyth - 24 bytes

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

Test Suite .