Ce défi est un hommage au gagnant du meilleur film aux Oscars 2017, La La Land Moonlight !

Ecrivez une fonction / programme qui prend une chaîne contenant uniquement des lettres [A-Za-z], les quatre symboles qui sont communs dans les phrases .,'?et les espaces quotidiens , et génère la chaîne dans le style de La La Land.

Pour être plus précis, prenez les lettres jusqu'au premier groupe de voyelles, y compris, et imprimez / exportez-le deux fois en ajoutant un espace à chaque fois, puis imprimez / sortez la chaîne entière. y est une voyelle dans ce défi. La ponctuation et la capitalisation doivent être conservées.

Vous pouvez supposer que toutes les chaînes contiennent au moins une voyelle et que toutes les chaînes commencent par une lettre.

Cas de 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?

C'est du code-golf donc le code le plus court dans chaque langue gagne. Les explications sont encouragées , même dans les langues courantes.

Sed 30 octets

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

05AB1E , 23 19 18 octets

Sauvé 1 octet grâce à Okx .

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

Essayez-le en ligne! ou en tant que suite de tests

Explication

 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

Jelly , 24 22 20 19 14 octets

-5 octets en utilisant une astuce de la réponse géniale d'Emigna (recherchez 10 dans la liste isVowel)

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

Essayez-le en ligne! (pas tout à fait sûr de savoir comment faire une suite de tests pour ce programme complet)

Alternative de 15 octets:

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

Voici la suite de tests complète.

Comment?

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

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

Voici le premier langage non basé sur regex (utilisant regex).

Sauvé 1 octet grâce à Neil .

JavaScript (ES6), 40 46

Éditez 5 + 1 octets enregistrés thx @Arnauld

Trop long comparé aux autres en utilisant le même truc (comme d'habitude)

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 octets

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

Essayez-le en ligne!

Lot, 180 octets

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

Implémente une machine à états. ggarde la trace de savoir si nous avons déjà vu une voyelle, donc si la lettre actuelle n'est pas une voyelle, nous savons s'il faut sortir ou continuer avec la lettre suivante.

PowerShell , 46 47 41 39 38 octets

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

Essayez-le en ligne!

Merci à Maarten Bamelis pour le correctif

Sauvegardé 6 octets grâce à Rynant

2 2 octets sauvés grâce à Joey

Rubis, 31 32 30 octets

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

Deux octets enregistrés grâce à GB et Cyoce.

PHP, 55 54 octets

Remarque: la version codée utilise le codage IBM-850.

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

Courez comme ça:

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

Explication

Il suffit de remplacer une regex par une correspondance non-désirée n’importe quel caractère au début de la chaîne, suivie de n’importe quelle quantité de voyelles ( ioption d’ utilisation pour l’insensibilité à la casse). Ce groupe de capture est ensuite imprimé deux fois, suivi de la chaîne entière.

Tweaks

• Enregistré un octet en utilisant -Rpour rendre $argndisponible (Thx Titus)

Javascript (ES6), 38 octets

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

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

Perl 6 , 30 octets

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

Essayez-le en ligne!

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

Essayez-le en ligne!

Ce qu'il reste au golf:

• Réduisez deux printf en un seul.

• L'impression de mon caractère d'espace peut être changée en %*clogique, j'en suis sûr.

• J'utilise des conditionnels qui peuvent être supprimés en quelque sorte

• j=(i-13)/12peut probablement être raccourci.

• [AY] vérifie si ==0ce qui est généralement inutile, bien que je sois actuellement bloqué sur celui-ci (j'essaie de changer si, sinon, ==0mais cela nécessite d'ajouter plus de {parenthèses} et d'augmenter la taille en octets)

Trucs que j'ai l'habitude de jouer au golf:

• Combiné une double recherche de chaîne de boucle en utilisant modulo pour l'axe des x et une division entière pour l'axe des y (chaîne d'entrée vs chaîne de voyelles). (L'axe des X est bouclé deux fois avant d'être itéré une fois sur l'axe des y; la première fois avec [AZ] et la deuxième fois avec [az] avec une valeur de caractère 32 différentielle.

• Contourné devant utiliser "[AY] et [ay]" en prenant simplement la distance entre les jeux de caractères et le modulo 32. De cette façon, si la distance est 0 (AA) ou si la distance est 32 (aA)

• Réutiliser des variables entières qui ne sont plus utilisées comme variables booléennes.

• Appel récursif d'une fonction avec la même chaîne pour le traiter et éviter une seconde boucle for.

• Définissez les valeurs BOOL sur la logique de définition d'une autre variable. (par exemple bool = i = 5;) pour assommer les deux avec une pierre.

• Abus d'exploitation ternaire vide-vrai. (GCC)

Format lisible:

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

Bloqué 10 octets grâce à Keyu Gan (dans les commentaires)

MATL, 33 octets

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

Essayez-le sur MATL Online

Explication

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

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

Essayez-le en ligne!

Explication:

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

Version alternative (21 octets):

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

Essayez-le en ligne!

Cela utilise une compression regex ridicule, et il parvient toujours à se faire foutre par les autres langues du golf. Pour référence, cela représente environ les deux tiers de la longueur de la version normale "non compressée", à savoir:

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

Explication:

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

Voici un hexdump:

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

Python 3 , 75 68 octets

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

Essayez-le en ligne!

Explication:

Fonctionne en générant une valeur booléenne pour chaque caractère de la chaîne d'entrée en fonction du statut de voyelle et en recherchant l'index le plus bas de 0la première non-voyelle (à l'exclusion du premier caractère). Il renvoie la sous-chaîne à cet index deux fois, séparés par des espaces et la chaîne d'origine.

Clojure, 192 188 181 octets

(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 octets en ligne first-sp-pred (whoops).

-7 octets en supprimant certains espaces manquants

C'était beaucoup plus difficile que je ne le pensais! Je suis manuellement analyser la chaîne ... depuis que je n'ai pas encore appris à regex: /

Voir le code pré-golfé pour la ventilation:

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

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)

Essayez-le en ligne!

une solution non regex

Commenté:

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 octets (CP437), non en compétition

Nouveau langage, et en tant que tel, j'ai dû ajouter de nouvelles fonctionnalités pour rendre ce travail efficace, ce qui le rend malheureusement non compétitif (car des échappatoires).

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

Explication:

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

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

nécessite PHP 5.3 ou une version ultérieure. Exécuter en pipe -Fou essayer quelques versions en ligne .

Enregistré 4 octets (et fixe le code) avec regex volé de @aross;
10 de plus avec preg_filterau lieu de preg_matchet -F
et deux autres avec une regex améliorée.

75 81 octets pour une version non regex:

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

nécessite PHP 5 ou une version ultérieure; remplacez ?:par ?1:pour les anciens PHP. Courir avec-nR

Panne

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)

Regex basé remplacer, correspondre à tout jusqu'à pas une voyelle, capturer et le remplacer par lui-même 3 fois.

scanattendez une doubleentrée de type, pour lui dire d'utiliser charactertype, nous devons lui donner deux arguments, la première est la chaîne par défaut, empty pour stdin, et pour la seconde l'évaluation R permet d'utiliser uniquement ccar elle n'est pas ambiguë characterdans ce contexte.

T représente TRUE et sauvegarde un caractère en tant que 4ème et 5ème paramètre à indiquer à Sub de lui dire d'ignorer la casse et d'utiliser PCRE (greedyness n'est pas la même chose que la syntaxe regex R)

4 octets enregistrés grâce à Sumner18 avec le lien Tio vers le code en cours d'exécution

Java 8, 147 140 octets

Golfé:

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

Remarque: le littéral 2dans le code est la valeur de java.util.regex.Pattern.CASE_INSENSITIVE.

C, 123 octets

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

Appeler comme:

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

Pyke , 22 octets

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

Essayez-le en ligne!

C'est 4 octets de plus que ce qui devrait être réellement si j'avais implémenté un moyen plus rapide d'obtenir des voyelles, y compris y.

Retina, 24 octets

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

Essayez-le en ligne

Python 3 , 130 102 octets

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)

Essayez-le en ligne!

N'utilise aucune fonction d'aucune sorte et aucune bibliothèque externe! (À moins que l’impression et la saisie ne comptent comme des fonctions, ce qu’ils font).

Cela fonctionne en vérifiant s’il sort des consonnes du début du titre dans la "zone des voyelles". S'il se trouve dans la "zone des voyelles" et détecte une consonne, le titre est imprimé.

28 octets sauvegardés grâce à @LliwTelracs

MATLAB / Octave, 58 51 octets

7 octets sauvés grâce à @HughNolan

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

Crée une fonction anonyme nommée ansqui peut être appelée en lui passant une chaîne:ans('Land')

Démo en ligne

Pour la compatibilité MATLAB, $0doit être utilisé à la place de $1la fonction ci-dessus.

C (gcc) , 111 110 octets

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

Essayez-le en ligne!

Il utilise simplement des fonctions de bibliothèque strspn()et strcspn()et exploite l'ordre dans lequel gcc évalue les paramètres de fonction. Un peu moins golfé

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

Merci à @gastropner pour -1.

Pyth - 24 octets

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

Suite de test .