Questa sfida è un omaggio al vincitore del miglior film agli Oscar 2017, La La Land Moonlight !

Scrivi una funzione / programma che prende una stringa contenente solo lettere [A-Za-z], i quattro simboli che sono comuni nelle frasi .,'?e negli spazi di ogni giorno , e genera la stringa nello stile di La La Land.

Per essere più specifici, prendi le lettere fino al primo gruppo vocale incluso e includilo e stampalo / stampalo due volte aggiungendo uno spazio ogni volta, quindi stampa / stampi l'intera stringa. y è una vocale in questa sfida. La punteggiatura e le maiuscole dovrebbero essere mantenute.

Puoi presumere che tutte le stringhe contengano almeno una vocale e che tutte le stringhe inizino con una lettera.

Casi 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.

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

Questo è code-golf, quindi vince il codice più corto in ogni lingua. Le spiegazioni sono incoraggiate , anche nelle lingue tradizionali.

Sed 30 byte

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

05AB1E , 23 19 18 byte

Salvato 1 byte grazie a Okx .

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

Provalo online! o come una suite di test

Spiegazione

 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 byte

-5 byte utilizzando un trucco dalla brillante risposta di Emigna (cercare 10 nell'elenco isVowel)

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

Provalo online!(non sono sicuro di come creare una suite di test per questo programma completo)

15Alternativa a byte:

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

Ecco la suite di test completa.

Come?

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

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

Ecco che arriva il primo linguaggio non basato su regex (usando regex).

Salvato 1 byte grazie a Neil .

JavaScript (ES6), 40 46

modificare 5 + 1 byte salvati grazie a @Arnauld

Troppo lungo rispetto ad altri usando lo stesso trucco (come al solito)

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 byte

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

Provalo online!

Lotto, 180 byte

@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 macchina a stati. gtiene traccia del fatto che abbiamo mai visto una vocale, quindi se la lettera corrente non è una vocale sappiamo se produrre o continuare con la lettera successiva.

PowerShell , 46 47 41 39 38 byte

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

Provalo online!

Grazie a Maarten Bamelis per la correzione

6 byte salvati grazie a Rynant

Salvato 2 3 byte grazie a Joey

Rubino, 31 32 30 byte

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

Due byte salvati grazie a GB e Cyoce.

PHP, 55 54 byte

Nota: la versione codificata utilizza la codifica IBM-850.

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

Esegui in questo modo:

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

Spiegazione

Solo una regex sostituisce con non desiderosi che corrispondono a qualsiasi carattere all'inizio della stringa, seguito da qualsiasi quantità di vocali (utilizzare l' iopzione per l'insensibilità al maiuscolo / minuscolo). Il gruppo di acquisizione viene quindi stampato due volte, seguito dall'intera stringa.

Ritocchi

• Salvataggio di un byte utilizzando -Rper rendere $argndisponibile (Thx Titus)

Javascript (ES6), 38 byte

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

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

Perl 6 , 30 byte

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

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

Provalo online!

Cosa è rimasta al golf:

• Comprimi due impronte in una.

• La stampa del mio carattere spaziale può essere cambiata in %*clogica, ne sono sicuro.

• Sto usando condizionali che possono essere rimossi in qualche modo

• j=(i-13)/12può essere probabilmente abbreviato.

• [AY] controlli condizionali se di ==0solito non sono necessari, anche se al momento sono bloccato su quello (ho provato a cambiare if-else e abbandonare del ==0tutto ma ciò richiede l'aggiunta di più {parentesi} e l'aumento della dimensione dei byte)

Trucchi che ho usato per giocare a golf:

• Combinato un doppio per la ricerca di stringhe di loop utilizzando il modulo per l'asse xe la divisione intera per l'asse y (stringa di input vs stringa di vocale). (L'asse X viene ripetuto due volte prima di iterare una volta sull'asse y; la prima volta con [AZ] e la seconda volta con [az] utilizzando il valore del carattere 32 differenziale.

• Bypassato che deve usare "[AY] e [ay]" prendendo semplicemente la distanza tra set di caratteri e modulo 32. In questo modo se la distanza è 0 (AA) o se la distanza è 32 (aA)

• Riutilizzo di variabili intere che non sono più utilizzate come variabili booleane.

• Chiamare in modo ricorsivo una funzione con la stessa stringa per elaborarla ed evitare un secondo for-loop.

• Impostare i valori BOOL sulla logica di impostazione di un'altra variabile. (es. bool = i = 5;) per eliminare entrambi con una fava.

• Abuso di exploit ternario vuoto-vero. (GCC)

Formato leggibile:

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

Eliminato 10 byte grazie a Keyu Gan (nei commenti)

MATL, 33 byte

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

Provalo su MATL Online

Spiegazione

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

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

Provalo online!

Spiegazione:

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

Versione alternativa (21 byte):

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

Provalo online!

Questo utilizza una ridicola compressione regex e riesce ancora a farsi prendere a calci dagli altri linguaggi del golf. Per riferimento, si tratta di circa due / terzi della lunghezza della normale versione "non compressa", vale a dire:

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

Spiegazione:

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

Ecco un hexdump:

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

Python 3 , 75 68 byte

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

Provalo online!

Spiegazione:

Funziona generando un valore booleano per ogni carattere nella stringa di input in base al fatto che si tratti di una vocale o meno e di trovare l'indice più basso del 0primo non vocale (escluso il primo carattere). Restituisce la sottostringa a questo indice due volte, separata da spazi e dalla stringa originale.

Clojure, 192 188 181 byte

(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 byte mediante allineamento first-sp-pred(whoops).

-7 byte rimuovendo alcuni spazi mancanti

Questo è stato molto più impegnativo di quanto pensassi sarebbe successo! Sto analizzando manualmente la stringa ... dal momento che non sono ancora riuscito a imparare regex: /

Vedi il codice pre-golf per la ripartizione:

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

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)

Provalo online!

una soluzione non regex

ha commentato:

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 byte (CP437), non in competizione

Nuovo linguaggio, e come tale, ho dovuto aggiungere alcune nuove funzionalità per far funzionare questo, che purtroppo rende questo non competitivo (perché scappatoie).

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

Spiegazione:

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

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

richiede PHP 5.3 o successivo. Esegui come pipe con -Fo prova alcune versioni online .

Salvati 4 byte (e risolto il codice) con regex rubato da @aross;
10 in più con preg_filterinvece di preg_matche-F
e altri due con regex migliorato.

75 81 byte per una versione non regex:

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

richiede PHP 5 o successivo; sostituire ?:con?1: per PHP precedente. Corri con-nR

Abbattersi

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)

Sostituisci basato su Regex, abbina tutto fino a quando non una vocale, acquisiscilo e sostituiscilo da solo 3 volte.

scanattendere un doubleinput di tipo, per dirgli di usare charactertype dobbiamo dargli due argomenti, il primo è la stringa di default, emtpy per stdin, e per il secondo la valutazione R permette di usare soloc perché non è ambiguo characterin questo contesto.

T sta per TRUE salvare alcuni caratteri come 4o e 5o parametro su sub per dirgli di ignorare il caso e usare PCRE (l'avidità non è la stessa con la sintassi della regex di R)

4 byte salvati per gentile concessione di Sumner18 insieme al collegamento Tio al codice in esecuzione

Java 8, 147 140 byte

golfed:

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: il valore letterale 2nel codice è il valore di java.util.regex.Pattern.CASE_INSENSITIVE.

C, 123 byte

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

Chiama come:

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

Pyke , 22 byte

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

Provalo online!

Questo è di 4 byte più lungo di quanto dovrebbe essere se avessi implementato un modo più breve di ottenere vocali incluso y.

Retina, 24 byte

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

Provalo online

Python 3 , 130 102 byte

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)

Provalo online!

Non utilizza alcuna funzione di alcun tipo e nessuna libreria esterna! (A meno che la stampa e l'input contino come funzioni, cosa che fanno).

Funziona vedendo se esce dalle consonanti all'inizio del titolo nella "zona vocale". Se si trova nella "zona vocale" e rileva una consonante, stampa il titolo.

Risparmiato 28 byte grazie a @LliwTelracs

MATLAB / Octave, 58 51 byte

7 byte salvati grazie a @HughNolan

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

Crea una funzione anonima denominata ans che può essere chiamata passando una stringa ad essa:ans('Land')

Demo online

Per la compatibilità MATLAB, $0dovrebbe essere usato al posto della $1funzione sopra.

C (gcc) , 111 110 byte

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

Provalo online!

Questo utilizza solo funzioni di libreria strspn()e strcspn()e sfrutta l'ordine in cui gcc restituisce parametri di funzione. Leggermente meno golfato

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

Grazie a @gastropner per -1.

Pyth - 24 byte

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

Test Suite .