La La Land ... no, espera, Moo Moo Moonlight

122

¡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 por lo que gana el código más corto en cada idioma. Se alientan las explicaciones , también en los idiomas principales.

Stewie Griffin
fuente
1
Caso de prueba para el caso de falta de sensibilidad: MOONLIGHT. Y solo por diversión:Why did the chicken cross the road?
Titus
35
Desafío patrocinado por: National Stuttering Association
sergiol
66
O Prof. Quirrell
Brian J
1
Sexto caso de prueba comprado por Louis Prima y el libro de la selva. Se unió solo para agregar este juego de palabras (malo).
Toby

Respuestas:

57

Sed 30 bytes

s/[^aeiouy]*[aeiouy]\+/& & &/i
Michael Vehrs
fuente
¿Podrías usar en *lugar de \+?
Kritixi Lithos
30

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
Emigna
fuente
25

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)
Jonathan Allan
fuente
19

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 .

Erik el Outgolfer
fuente
18

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

edc65
fuente
@Arnauld no, pero podría usarlo '$& $& $&': siempre olvido los caracteres especiales en dólares. Gracias. Desafortunadamente ahora es realmente un puerto de la respuesta de retina de Martin.
edc65
Se ^requiere en Retina que, creo, busca todas las coincidencias por defecto. ¿Pero realmente lo necesitamos aquí?
Arnauld
@Arnauld tienes razón otra vez
edc65
-2:x=>(y=/.*?[aeiouy]+/i.exec(x)+' ')+y+x
nderscore
@ETHproductions de hecho. Gracias por notarlo.
edc65
12

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.

Neil
fuente
12

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

Bjorn Molenmaker
fuente
8

Rubí, 31 32 30 bytes

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

Dos bytes guardados gracias a GB y Cyoce.

gntskn
fuente
6

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)
aross
fuente
6

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

nderscore
fuente
6

Perl, 25 + 1 ( -pbandera)

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

Perl 6 , 30 bytes

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

Pruébalo en línea!

smls
fuente
1
Es interesante que esta es la misma longitud que{S:i/.*?<[aeiouy]>+/$/ $/ $//}
b2gills Brad Gilbert
5

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)

Albert Renshaw
fuente
Nota personal: j=(i-13)/12es probable que se pueda acortar.
Albert Renshaw
¿Me estoy perdiendo algo o podrías comenzar i=j=k=m=n=0;?
Richard Irons
@RichardIrons las variables deben declararse primero.
Albert Renshaw
Puede usar i,j,k,m,n;para la inicialización.
Keyu Gan
@KeyuGan comportamiento indefinido, no se garantiza que siempre sea 0. (por lo que sé)
Albert Renshaw
4

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
Suever
fuente
'(^.*?[yY%s]+)'13Y2YD'$1 '8:)YXahorra 2 bytes
Luis Mendo
'(^.*?[%s]+)'19Y2YD'$1 '8:)YXsalva otro 2
B. Mehta
@ B.Mehta 19Y2no existía cuando desafortunadamente se envió esta respuesta
Suever
Sí, esperaba un poco esa respuesta ... Mantendré mi comentario para que otros puedan aprender sobre 'aeiouy' literal incorporado también.
B. Mehta
@ B.Mehta No se preocupe. Con MATL Online (matl.suever.net) puede seleccionar una versión específica usando el menú desplegable en la parte superior derecha
Suever
4

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                             . . &
DJMcMayhem
fuente
2
+1 Esta tiene que ser la presentación de V regex más impresionante que he visto
Kritixi Lithos
4

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.

Trelzevir
fuente
4

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)))
Carcigenicate
fuente
4

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)
ovs
fuente
¿Por qué necesitas un? Reemplazar w=c in aconw=c in'aAeEiIoOuUyY'
sagiksp
4

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
Nick Clifford
fuente
Tengo curiosidad por saber qué características implementaste ...
Stewie Griffin
@StewieGriffin Reversión de pila ( Q), búsqueda de submatriz ( u), corte de cadena / matriz ( ) y constantes vocales ( αvy αy).
Nick Clifford
4

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
Titus
fuente
No parece funcionar Fuera puesto para This isn't a single word:T T This isn't a single word.
aross
@aross parece que solo está comprobando valores en minúsculas? Puedo estar equivocado, no conozco bien PHP
Albert Renshaw
1
@AlbertRenshaw La versión regex utiliza el imodificador que hace que las mayúsculas y minúsculas sean insensibles. La otra versión solo marcó en minúsculas. Fijo.
Titus
4

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

Tensibai
fuente
3

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.


fuente
2
Creo que puedes usar import java.util.regex.*;para guardar algunos bytes.
Roman Gräf
@ RomanGräf tienes razón. Expliqué los paquetes porque en una versión anterior del código (no funcionaba) era más corto no usar importaciones. No volví a evaluar después de arreglar el código.
3

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);}
Lynn
fuente
1
¡Esto es bonito! Has sacado mi solución C del parque jajaja.
Albert Renshaw
2

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.

Azul
fuente
2

Retina, 24 bytes

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

Pruébalo en línea

mbomb007
fuente
Muy similar a esto
Emigna
Si lo se. Pero hice la respuesta de forma independiente. Aun así, se decidió que se permiten respuestas duplicadas, si el trabajo no es plagiado.
mbomb007
2

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

Camarada SparklePony
fuente
2

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.

Suever
fuente
Estaba pensando en esto y luego vi que ya lo había hecho. Ahorre algunos bytes: @(x)regexprep(x,'^.*?[aeiouyAEIOUY]+','$0 $0 $0 ');- también Matlab parece usar $ 0 en lugar de $ 1 de manera extraña
Hugh Nolan
@HughNolan Gran punto, gracias!
Suever
2

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.

techo
fuente
¡¡Guau!! ¡Buen trabajo!
Albert Renshaw
105 bytes
gastropner
1

Pyth - 24 bytes

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

Test Suite .

Maltysen
fuente
1
Creo que tal vez lo olvidaste y?
Stewie Griffin