[Question]
  [
This challenge is a tribute to the winner of Best Picture at the Oscars 2017, [~~La La Land~~ Moonlight](http://www.independent.co.uk/a7598151.html)!
---
Write a function/program that takes a string containing only letters `[A-Za-z]`, the four symbols that are common in every day sentences `.,'?` and spaces, and outputs the string in the style of La La Land.
To be more specific, take the letters up to, and including, the first vowel group, and print/output it twice adding a space each time, then print/output the whole string. *[y is a vowel](https://en.oxforddictionaries.com/explore/is-the-letter-y-a-vowel-or-a-consonant)* in this challenge. Punctuation and capitalization should be kept. 
You may assume that all strings contain at least one vowel, and that all strings start with a letter.
**Test cases:**
```
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?
```
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so the shortest code in each language wins. [**Explanations are encouraged**](http://meta.codegolf.stackexchange.com/questions/10127/how-can-we-help-users-who-are-put-off-by-the-use-of-golfing-languages/10132#comment32351_10132), also in mainstream languages.
  
[Answer]
## Sed 30 bytes
```
s/[^aeiouy]*[aeiouy]\+/& & &/i
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~23~~ ~~19~~ 18 bytes
Saved 1 byte thanks to *Okx*.
```
Dlð«žOsSåJTk>£D¹ðý
```
[Try it online!](https://tio.run/nexus/05ab1e#ASUA2v//RGzDsMKrxb5Pc1PDpUpUaz7Co0TCucOww73//3F1ZXVlaW5n)
or as a [Test suite](https://tio.run/nexus/05ab1e#Hcs7DoJAFEbhflbxdzSEJVhZiNFYyAYGGWDi5V5lBsgk7sZY2bABLSSuCx/tyfkufZiXNI2v@/u5c/vpts6Oi9d1GaZxeszxvNFcqK0Ik61qr86d6YzlSmW1dbCOIw8N9y1kMEhbJCr1kUPZMbzgRDqgEirVTkSlUQM56qBWTRODJUFWm/brLBFyA@1BRjsPYYNeBkMx8s7Dehw0/w8Ow48kHw)
**Explanation**
```
 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
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~24 22 20 19~~ 14 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
-5 bytes by utilising a trick from Emigna's [brilliant answer](https://codegolf.stackexchange.com/a/111488/53748) (look for 10 in the isVowel list)
```
;⁶e€Øyw⁵ḣ@;⁶Ȯ;
```
**[Try it online!](https://tio.run/nexus/jelly#@2/9qHFb6qOmNYdnVJY/atz6cMdiB5DQiXXW////VwrKqCzJyFUCAA)** (not quite sure how to make a test suite for this full program)
---
**15** byte alternative:
```
;⁶e€Øyw⁵ḣ@;⁶ẋ2;
```
**[Here](https://tio.run/nexus/jelly#HYshDsJAEEWv8lNT01RgMUhIIBgMIYgFpu2G7QywW5pKMAgugMdiIQTbk9CLlC3u5b3/235zelFzftS3qmxOz@/7PujU93Pt9dv64su8bRfBWPEmiIKJCBudZs7zvqCCNKceZ5m20JZDBwXrnSGUctjEvo1caJEUDCfYGVUhFZN4PxXpaphDtqryOMzzCCwxZhkd/F8bgxVBORhS1kGYcJSSTIRV4aAd1or/C67K7hIHyx8)** is full test suite.
### How?
```
;⁶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)
```
[Answer]
# Python, 61 bytes
```
import re;lambda x:re.sub('(.*?[aeiouy]+)',r'\1 \1 \1',x,1,2)
```
Here comes the first non-regex-based language (using regex).
Saved 1 byte thanks to [Neil](/users/17602/neil).
[Answer]
# JavaScript (ES6), 40 ~~46~~
**Edit** 5+1 bytes saved thx @Arnauld
Overly long compared to other using the same trick (as usual)
```
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);
})
```
[Answer]
## [Retina](https://github.com/m-ender/retina), 24 bytes
```
i`^.*?[aeiouy]+
$& $& $&
```
[Try it online!](https://tio.run/nexus/retina#HcgxCgIxEAXQfk7xCzWisFewlAXFxk6UHdhsdjDOqEmQnD6K8Kq3XO@HJsOt2@wu7MVKvW5pscJfawfWkY5mGiXMmV7FFy8a6DxLgiR1GYz0m@jxsffYUZ9dwlQU2fCMXBEsTnQyo949YHeuXw "Retina – TIO Nexus")
[Answer]
## Batch, 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%
```
Implements a state machine. `g` keeps track of whether we've ever seen a vowel, so if the current letter isn't a vowel we know whether to output or continue with the next letter.
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~46~~ ~~47~~ ~~41~~ ~~39~~ 38 bytes
```
$args-replace"^.*?[aeiouy]+",(,'$&'*3)
```
[Try it online!](https://tio.run/##NY9PSwMxEMXv/RSPsDRa1714lp4KFhQvBQ@ikLazSTCbqfnjEsTPvsa6vc2P92bemxOPFKIh56amv/@eGhV0vA10cupA4r1brV8VWc7l7Ua0V61slnJ1dz39LBbLpod4VP4o/scnZu@sNmnmz7zJtPV6xp2xETZ6maAQrdeOMHI4drO@TTKizx6JUcMLNLt@1p6ZLy45gD9UmfFhGFp47rAzFOo96xz2BJXgSMUE9oSv@qFrsc8JNuGg/Nnhy/i3ckl/MaWWQ6ndzv61mH4B "PowerShell – Try It Online")
Thanks to Maarten Bamelis for the bugfix
Saved 6 bytes thanks to Rynant
Saved ~~2~~ 3 bytes thanks to Joey
[Answer]
# Ruby, ~~31~~ ~~32~~ 30 Bytes
```
->s{(s[/.*?[aeiouy]+/i]+' ')*2+s}
```
Two bytes saved thanks to G B and Cyoce.
[Answer]
# PHP, ~~55~~ 54 bytes
Note: encoded version uses IBM-850 encoding.
```
echo preg_filter("/^(.*?[aeiouy]+)/i","$1 $1 $0",$argn);
echo preg_filter(~ðíÎÐı└ñ×ÜûÉèåóÈÍðû,~█╬▀█╬▀█¤,$argn);     # Encoded
```
Run like this:
```
echo "This isn't a single word." | php -nR 'echo preg_filter(~ðíÎÐı└ñ×ÜûÉèåóÈÍðû,~█╬▀█╬▀█¤,$argn);'
```
# Explanation
Just a regex replace with non-eager matching any character at the start of the string, followed by any amount of vowels (use [`i` option](http://php.net/manual/en/regexp.reference.internal-options.php) for case insensitivity). That capture group is then printed twice, followed by the entire string.
# Tweaks
* Saved a byte by using `-R` to make `$argn` available (Thx Titus)
[Answer]
# 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?">
```
[Answer]
# Perl, 25 + 1 (`-p` flag)
```
s/.*?[aeiouy]+/$& $& $&/i
```
[Answer]
# [Perl 6](https://perl6.org), 30 bytes
```
{S:i/.*?<[aeiouy]>+/{$/xx 3}/}
```
[Try it online!](https://tio.run/nexus/perl6#Ky1OVSgz00u25sqtVFBLU7D9Xx1slamvp2VvE52YmplfWhlrp61fraJfUaFgXKtf@784sVIhTUHJNz8/LyczPaNEyZoLKuSpnquQn51YiRDxz89Xsv4PAA "Perl 6 – TIO Nexus")
[Answer]
# 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);}`
[Try it online!](https://tio.run/nexus/c-gcc#VVDLasMwELznK7YCBymRU9vpKa4IPRTaUy/toYQcFCPj9UMustwQSj6753RtmhYPLEgzu7PDXlBFaakiWVE1VJb@s5xnhXYLLb5mQMCc6x3exsleKfbw@Pzy9q4Ntv2J7XC5DIgXY9@ASlmV3IUciRbpSJu6M386eVXz@Y0Nw1/zKxpVKo5hvBa0KJ1IQ8YJkbeOp3hfLpJUTATCh0Prc86CLMiYpNxBuZcclSrDWGzXySYSklJPDa9DEHRMghb/6nl8NdsN3YDo84UaodFoOeWnQ7GnppFg2xW8FsYZOGJdw8GA9lAb3XlorYHP9mhqCYfeA3rItB077Ok4jKwY@dIWZ3zvLETDkm/bhpnOCvMD)
---
Thing left to golf:  
  
•Collapse two printf into one.
•Printing my space char can be changed into `%*c` logic I'm sure.
•I'm using conditionals which can be removed somehow
•`j=(i-13)/12` can likely be shortened.
•[A-Y] conditional checks if `==0` which is usually un-necessary, though I'm currently stuck on that one (tried switching if-else and ditching the `==0` altogether but that requires adding more {brackets} and increase byte size)
---
Tricks I've used to golf this down:
•Combined a double for loop string search by using modulo for x-axis and integer-division for y-axis (input string vs vowel string). (X-axis is looped twice before iterating once on y-axis; the first time with [A-Z] and the second time with [a-z] using character value 32 differential.
•Bypassed having to use "[A-Y] and [a-y]" by just taking the distance between character sets and modulo 32. That way if the distance is 0 (A-A) or if the distance is 32 (a-A)
•Re-using integer variables that are no longer in use as boolean variables.
•Recursively calling a function with the same string to process through it and avoid a second for-loop.
•Set BOOL values to the logic of setting another variable. (e.g. bool = i=5;) to knock out both with one stone.
•Ternary empty-true exploit abuse. (GCC)
---
Readable Format:
```
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);
}
```
---
Knocked off 10 bytes thanks to Keyu Gan (in comments)
[Answer]
# [V](https://github.com/DJMcMayhem/V), ~~21~~, 20 bytes
```
é /ã[aeiouy]«“.
3ä|<
```
[Try it online!](https://tio.run/nexus/v#@394pYL@4cXRiamZ@aWVsYdWH5qsx2V8eEmNzf//4RmVCpnFCpUKiQpl@eWpOfYA "V – TIO Nexus")
Explanation:
```
é               " 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.|<
```
Alternate version (21 bytes):
```
Íã¨ƒ[aeiouy]«©/± ± &
```
[Try it online!](https://tio.run/nexus/v#HY4xbsJAFET7f4qpcIPMEWhBSpTGUoooxRI@9irr/xN2F2tLlJpT0ICocoX1wZyNpalm3mhmGi/jNd/yz5thqzG950e@5/Mq/6JoMU1PRvZEz6ribNsFou/Ika20RE1nPayXKsDAF8sxBj3ua6JtqDwOURAUX84ktOoORC@qJat66KdJRJu@X0K0RtPxsXStc9gxTIBj4wNUGCcd2C2xiwE24MPITEga/itl6bVL5QNSuTCj6z8 "V – TIO Nexus")
This uses ridiculous regex compression, and it still manages to get it's butt kicked by the other golfing languages. For reference, this is about two/thirds the length of the regular "uncompressed" version, namely:
```
:%s/\v\c(.{-}[aeiou]).*/\1 \1 &
```
Explanation:
```
Í                               " 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
```
Here is a hexdump:
```
00000000: cde3 a883 5b61 6569 6f75 795d aba9 812f  ....[aeiouy].../
00000010: b120 b120 26                             . . &
```
[Answer]
# [Python 3](https://docs.python.org/3/), ~~75~~ 68 bytes
```
lambda s:(s[:[x in"aAeEiIoOuUyY"for x in s][1:].index(0)+1]+" ")*2+s
```
[Try it online!](https://tio.run/nexus/python3#@59mm5OYm5SSqFBspVEcbRVdoZCZp5TomOqa6ZnvXxqqlJZfpAASUyiOjTa0itXLzEtJrdAw0NQ2jNVWUlDS1DLSLuYqKMrMK9FI01DyScxLUdLU/P8fAA "Python 3 – TIO Nexus")
Explanation:
Works by generating a boolean value for every character in the input string based on whether or not it is a vowel, and finding the lowest index of `0`, the first non-vowel (excluding the first character). It returns the substring to this index twice,separated by spaces, and the original string.
[Answer]
# 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 by inlining `first-sp-pred` (whoops).
-7 bytes by removing some missed spaces
This was far more challenging than I thought it would be going in! I'm manually parsing the string...since I still haven't gotten around to learning regex :/
See pre-golfed code for breakdown:
```
(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)))
```
[Answer]
# [Python 3](https://docs.python.org/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)
```
[Try it online!](https://tio.run/nexus/python3#@19sm5lXUFqioclVZptpa8CVll@kkKyQmadQbMWlUG4LYqonOqa6Znrm@5eGVkaqcylkpimUadXpllslFaUmZnMplNmWW2dq2xpyFRRl5pVoFEdbZcbqQEnN///98/MB "Python 3 – TIO Nexus")
a non-regex solution
---
Commented:
```
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)
```
[Answer]
# PHP, ~~69 65~~ 53 bytes
```
<?=preg_filter("#.*?[aeiouy]+#i","$0 $0 $0",$argn,1);
```
requires PHP 5.3 or later. Run as pipe with `-F` or [try some versions online](http://sandbox.onlinephpfunctions.com/code/40734d429b3f87f8e1dfaf75f838301f9ea81379).
Saved 4 bytes (and fixed the code) with regex stolen from @aross;  
10 more with `preg_filter` instead of `preg_match` and `-F`  
and another two with an improved regex.
**~~75~~ 81 bytes** for a non-regex version:
```
for(;$c=$argn[$i++];)($k+=$k^!trim($c,aeiouyAEIOUY))>1?:$w.=$c;echo"$w $w $argn";
```
requires PHP 5 or later; replace `?:` with `?1:` for older PHP. Run with `-nR`
**Breakdown**
```
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
```
[Answer]
## R, 49bytes
`sub("(.*?[aeiouy]+)","\\1 \\1 \\1",scan(,""),T,T)`
Regex based replace, match everything until not a vowel, capture and replace it by itself 3 times.
`scan` wait for a `double` type input, to tell it to use `character` type we have to give it two arguments, first is the default , emtpy string for stdin, and for the second the R evaluation allow to use only `c` as it's not ambiguous for `character` in this context.
`T` stands for `TRUE` and save some char as 4th and 5th parameter to sub to tell it to ignore case and use PCRE (the greedyness is not the same with R regex syntax)
4 bytes saved courtesy of [Sumner18](https://codegolf.stackexchange.com/users/82163/sumner18) along with the Tio [link to running code](https://tio.run/##PY5BT8MwDIXv/AorlyQQInEH7TSJSSAulTgwDumWthGpDU1CF0377SVdKw6W/Pye7W@Ymqcm4SE6QnGS53Aw@Hj/P9Fay/PpMoVUCyb07ebDWEcpf95Jpth@/wBrMTVvCsW5VJWq5HS5aQR7MXhkcu5eidC7touL/EnbZHfYLqrqXAAXkEcwEBy23sJIw1Ev9i7yAAUJIsG3Nxla8s1ivRGtGd4DfZm8qOe@V4CkoersUG4576G2YCJ4a0IEQgu/NFqvoE4RXIQCf01gHueV9fN7lwsX5IJ1jW@YnP4A)
[Answer]
# MATL, 33 bytes
```
'(^.*?[yY%s]+)'13Y2YD'$1 $1 $1'YX
```
Try it at [**MATL Online**](https://matl.io/?code=%27%28%5E.%2a%3F%5ByY%25s%5D%2B%29%2713Y2YD%27%241+%241+%241%27YX&inputs=%27Land%27&version=19.8.0)
**Explanation**
```
                % 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
```
[Answer]
# [Ohm](https://github.com/MiningPotatoes/Ohm), 19 bytes (CP437)
```
≡┬üC▓αy_ε;TF«u├DQüj
```
Explanation:
```
≡┬ü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
```
[Answer]
# Java 8, 147 140 bytes
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);
  }
}
```
Note: the literal `2` in the code is the value of `java.util.regex.Pattern.CASE_INSENSITIVE`.
[Answer]
# 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);}
```
Call as:
```
main(){char s[] = "queueing"; f(s);}
```
[Answer]
# [Pyke](https://github.com/muddyfish/PYKE), 22 bytes
```
l1~V\y+L{$0R+f2<ssDQdJ
```
[Try it online!](https://tio.run/nexus/pyke#@59jWBcWU6ntU61iEKSdZmRTXOwSmOL1/79vXn6@f15OZnpGCQA "Pyke – TIO Nexus")
This is 4 bytes longer than it should really be had I implemented a shorter way of getting vowels including `y`.
[Answer]
# Retina, 24 bytes
```
i1`.*?[aeiouy]+
$0 $0 $0
```
[**Try it online**](https://tio.run/nexus/retina#HYvBCsIwEAXv@xXvoFRUin6BVwuKFy8iQqNd22C6q01iydfXWpjTMDNflDTYbZkvd1fDVmO6rWi2wcQwHIxUdFQVZ@sm0CdyZCs1nRvrYb1kAQZ@NI7Ra1flVITM4xkFQfF2JqFW96STKhVZC32ZRPu2XUM0x7nhbvysc7gzTIBj4wNUGF/t2a1xjwE24GFkKiT1/yWniyb9AQ)
[Answer]
# [Python 3](https://docs.python.org/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)
```
[Try it online!](https://tio.run/nexus/python3#@19um5lXUFqioWmdaKuubl1ma8CVll@kkKmQmadQbsXFmZkGYasnpmbml1Y6unr6h0aqWymU2RpycabmAKXLgKo4k4pSE7O5OBO1bTO5gIS6grp1QVFmXolGopaRdrnm//85iXkpAA "Python 3 – TIO Nexus")
Uses no function of any kind and no external libraries! (Unless print and input count as functions, which they do).
Works by seeing if it gets out of the consonants in the start of the title into the 'vowel zone'. If it is in the 'vowel zone' and detects a consonant, then it prints the title.
Saved 28 bytes thanks to @LliwTelracs
[Answer]
# MATLAB / Octave, ~~58~~ 51 bytes
*7 Bytes saved thanks to @HughNolan*
```
@(x)regexprep(x,'(^.*?[aeiouyAEIOUY]+)','$1 $1 $1')
```
Creates an anonymous function named `ans` which can be called by passing a string to it: `ans('Land')`
[Online Demo](http://ideone.com/xl3UzO)
For MATLAB compatibility, `$0` should be used in place of `$1` in the above function.
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), 28 bytes
### [`'(?i)^.*?[aeiouy]+'⎕R'& & &'`](https://tio.run/##PY5NSgNBEIX3nuKtLH/iXGFWgoERIQRciELF6cw01lQl6W6HvoBLceMFc5E4JnSoTdWr7z0eb@SuzSzWHQ4NN7z/@qGr2l@/VTf1CztvKb/e0v77d0GXmIZOGKhhbenitD@aqfiuj0XYpvvk5tqVe9n7AB@UKIIRvHbiMNqurQoxj0QB66SIho1wRmeyLt8nszNINMA@OBfhYRhmUKuw7N1uSvUiWDlwhDgOEaYOnzY6mWGVInzEO@uR0Dz@W84dnvs8lUSeKh4NNf0B "APL (Dyalog Unicode) – Try It Online") or 29 chars: [`'^.*?[aeiouy]+'⎕R'& & &'⍠1`](https://tio.run/##PY5BSgNBEEX3nuKvLNA44AmyEgyMCBJwIQoVpzPTpKYqprsd@gLuFDfuPdtcJI4JHWpT9ev9z@etXDWZxdr9vuaax49veqku5k/svKX8fEnj188DnWMaGj9/r48YqGZt6Oy435mp@LaLRXhLN8kttC33svMBPihRBCN4bcVhsF1TFWIRiQLWSRENW@GM1mRdvvdmJ5Coh204F@G272dQq7Ds3G5K9SJYOXCEOA4Rpg7vNjiZYZUifMQr64HQPPxbTh0euzyVRJ4qHgxz@gM "APL (Dyalog Unicode) – Try It Online")
Simply a (`(?i)` or `⍠1`) case-insensitive PCRE **R**eplace of
`^` the beginning  
`.*?` zero or more characters (lazy)  
`[aeiouy]+` one or more vowels
with
`& & &` the entire match thrice with spaces inbetween
---
### Version without RegEx, 43 bytes
[`⊢(↑,' ',↑,' ',⊢)⍨1⍳⍨1 0⍷'aeiouy'∊⍨' ',⍨819⌶`](https://tio.run/##PY4xTsNAEEV7TvG7AclEpIOKColIRjSRUk/wZr1ivZPE61h7gQhZWIIrpEqPBPfZiwTHkV3NzJ/3vz6v7W0W2Io@nVJOOe6/YnO4jvvvhEDJOJvDTWyP09j@nAfuYvtHrIxUgeJH02k91R7vpw/x8/eSBUrZZXR12V9EnDU694OwqZ4qNXN6uOe5KWFKR@TBKI3TVqGWbTYZiJknKrGqHLxgbTlAi10N31eRESQqIO8cBuG5KBI4mWCeq22XaqzFUoE9rOLSQ5zCTmplEywrD@Pxxq4nXKjPlrHDIg9dSYSuYm94pH8 "APL (Dyalog Unicode) – Try It Online")
`819⌶` lowercase
`' ',⍨` append a space
`'aeiouy'∊⍨` which letters are vowels
`1 0⍷` vowels that are followed by a non-vowel
`1⍳⍨` index of first one
`⊢(`…`)⍨` apply the following tacit function with the string as right argument, and the above index as left argument
 `↑` that many characters taken from the string
 `,` followed by
 `↑` that many characters taken from the string
 `,` followed by
 `⊢` the string
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~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);}
```
[Try it online!](https://tio.run/##bY/NasMwEITveYpFUGwlbqBnE0IPgRpackkpPa5s2RaVV65@akTIs7tKAr24t2HmG2a3fuzqep7XzY49H6rj@ydKZUJkpSjbvO7RrpGfxc55W7uRciwaXk5WeZmPVpFvcwaMF1jcvaekxCbBN3YjEs15@Uc@OFYgLy/zgIpyfl4BJPsVqWGJCt7lLIm7@2YMadX1fhl9h0OQFXXL5NQrB8pR5gHBKeq0hMnYZrtEK585aAOBNzBqjNAZ3S6xozH/dLMBzBfGZfLRx7QPMc3/mEnq/RJ5GYYCyGzh1EubzlNag5CAHrRE58GQvHcLEMGD8lAj3QiK07VyfWZ1mX8B "C (gcc) – Try It Online")
This just uses library functions `strspn()` and `strcspn()` and exploits the order in which gcc evaluates function parameters. Slightly less golfed
```
*d="AEIOUYaeiouy";b;
f(char*a){
  b=strcspn(a,d);
  write(printf(" "),a,write(1,a,b+strspn(a+b,d)));
  printf(" %s",a);
}
```
Thanks to @gastropner for -1.
]