[Question]
  [
Given a string as input, output the string with the following algorithm applied:
```
1. Split the String by " " (find the words): "Hello World" -> ["Hello","World"]
2. Find the vowel count of each component: [2,1]   ( ["H[e]ll[o]","W[o]rld"] )
3. For each of the components, output the first n letter where n is the number 
   of vowels it contains: ["He","W"]
4. Join the list to a single string and reverse it: "HeW" -> "WeH"
```
## Specs
* You may take input and provide output by [any standard form](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods?answertab=votes#tab-top), and the only data type allowed for both Input and Output is your language's native String type. Taking input directly as a list of individual words is not permitted.
* You are guaranteed that there will be no consecutive spaces.
* The vowels are `"a","e","i","o","u","A","E","I","O","U"`, but `"y","Y"` *are not considered vowels*.
* You are guaranteed that only letters and spaces will appear in the input, but without any newlines.
* Output *must* be case-sensitive.
* You are not guaranteed that each word contains a vowel. If no vowels appear in that word, you do not have to output anything for it.
## Test Cases
```
Input -> Output
---------------
""                                  -> ""
"Hello World"                       -> "WeH"
"Waves"                             -> "aW"
"Programming Puzzles and Code Golf" -> "GoCauPorP"
"Yay Got it"                        -> "iGY" 
"Thx for the feedback"              -> "eeftf"                  
"Go Cat Print Pad"                  -> "PPCG"   
"ICE CREAM"                         -> "RCCI"
```
## Scoring
The shortest valid submission for each language wins, this is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"). Good luck and have fun!
---
[Sandbox](https://codegolf.meta.stackexchange.com/questions/2140/sandbox-for-proposed-challenges/12896#12896) for those who can see deleted posts. 
  
[Answer]
## Haskell, 59 bytes
```
map fst.reverse.(>>=zip<*>filter(`elem`"aeiouAEIOU")).words
```
[Try it online!](https://tio.run/##VcqxDoIwFAXQ3a@4aRzAgS8QEmOMcZJBd6p9hca2j7wWNfx8nT3zmXR6kfel2DboGTblRuhNkqipuq5d3bzfddb5TFIN5CkMSpPj5XC6XO@qrpsPi0klaBfRwvAGmMXFjC0sVC88ig7BxRH9sq6eEnQ0OLIhnNlb9f9v0xeWBXkiWCLz0M@XKj8 "Haskell – Try It Online")
```
       words     -- split into a list of words
  (>>=      )    -- apply a function to every word and collect the results in a
                 -- single list
     zip<*>filter(`elem`"aeiouAEIOU")
                 -- f <*> g x = f x (g x), i.e. zip x (filter(...)x)
                 -- we now have a list of pairs of (all letters of x, vowel of x)
                 -- with the length of number of vowels
 reverse         -- reverse the list
map fst          -- drop vowels from the pairs
```
[Answer]
# [V](https://github.com/DJMcMayhem/V), 31 bytes
```
Í /ò
òÄøã[aeiou]
|DJ@"|D-òÍî
æ
```
[Try it online!](https://tio.run/##K/v//3Cvgv7hTVyHNx1uObzj8OLoxNTM/NJYLsYaFy8HpRoXXaBE7@F1XIeX/f8fklGhkJZfpFCSkaqQlpqakpSYnA0A "V – Try It Online")
```
00000000: cd20 2ff2 0af2 c4f8 e35b 6165 696f 755d  . /......[aeiou]
00000010: 0a01 7c44 4a40 227c 442d f2cd ee0a e6    ..|DJ@"|D-.....
```
And explanation:
```
Í               " Substitute Every space
  /             " With
   ò            " Newlines
                " This puts us on the last line of the buffer
ò               " Recursively:
 Ä              "   Duplicate the current line
  ø             "   Count:
   ã            "   Case insensitive
    [aeiou]     "   The number of vowels
<C-a>           "   Increment this number
     |          "   Go to the beginning of this line
DJ              "   Delete the number of vowels, and remove a newline that was accidentally made.
                "   Also, my name! :D
  @"            "   Run the unnamed register, which is the number of vowels that we deleted
    |           "   And move to the n'th column in this line
     D          "   Delete everything on this line after the cursor, keeping the first *n* characters
      -         "   Move up a line
       ò        " End the loop
        Íî      " Remove all newlines
æ               " And reverse:
                "   (implicit) The current line
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 17 bytes
```
ṇ₁{{∋ḷ∈Ṿ}ᶜ}ᶻs₎ᵐc↔
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r//@HO9kdNjdXVjzq6H@7Y/qij4@HOfbUPt80B4t3Fj5r6Hm6dkPyobcr//0oBRfnpRYm5uZl56QoBpVVVOanFCol5KQrO@SmpCu75OWlK/6MA "Brachylog – Try It Online")
### Explanation
That's a direct translation of the problem:
```
Example input: "Hello World"
ṇ₁                  Split on spaces:         ["Hello", "World"]
  {       }ᶻ        Zip each word with:      [["Hello",2],["World",1]]
   {    }ᶜ            The count of:
    ∋ḷ∈Ṿ                Chars of the words that when lowercased are in "aeiou"
            s₎ᵐ     Take the first substring of length <the count> of each word: ["He","W"]
               c    Concatenate:             "HeW"
                ↔   Reverse:                 "WeH"
```
[Answer]
# [Perl 5](https://www.perl.org/) + `-p040F`, 35 bytes
```
$\=$_.$\for@F[0..lc=~y/aeiou//-1]}{
```
[Try it online!](https://tio.run/##K0gtyjH9/18lxlYlXk8lJi2/yMEt2kBPLyfZtq5SPzE1M79UX1/XMLa2@v//gKL89KLE3NzMvHSFgNKqqpzUYoXEvBQF5/yUVAX3/Jy0f/kFJZn5ecX/dQsMTAzcAA "Perl 5 – Try It Online")
[Answer]
# [Perl 6](http://perl6.org/), 57 bytes
```
{flip [~] .words.map:{.substr(0,.comb(rx:i/<[aeiou]>/))}}
```
[Answer]
## [Alice](https://github.com/m-ender/alice), 32 bytes
```
/.'*%-.m"Re.oK"
\iu &wN.;aoi$u@/
```
[Try it online!](https://tio.run/##S8zJTE79/19fT11LVVcvVykoVS/fW4krJrNUQa3cT886MT9TpdRB////gKL89KLE3NzMvHSFgNKqqpzUYoXEvBQF5/yUVAX3/Jw0AA "Alice – Try It Online")
### Explanation
```
/....
\...@/
```
This is just a framework for linear code in Ordinal (string-processing mode). Unfolding the program, we get:
```
i' %w.."aeiou".u*&-Nm;Ro.$K@
```
Here's what it does:
```
i           Read all input.
' %         Split the input around spaces.
w           Push the current IP address to the return address stack to mark
            the beginning of the main loop. Each iteration will process one
            word, from the top of the stack to the bottom (i.e. in reverse 
            order).
  ..          Make two copies of the current word.
  "aeiou"     Push this string.
  .u*         Append an upper case copy to get "aeiouAEIOU".
  &-          Fold substring removal over this string. What that means is that
              we push each character "a", "e", ... in turn and execute -
              on it. That will remove all "a"s, all "e"s, etc. until all
              vowels are removed from the input word.
  N           Compute the multiset complement of this consonant-only version
              in the original word. That gives us only the vowels in the word.
              We now still have a copy of the input word and only its vowels
              on top of the stack.
  m           Truncate. This reduces both strings to the same length. In particular,
              it shortens the input word to how many vowels it contains.
  ;           Discard the vowels since we only needed their length.
  R           Reverse the prefix.
  o           Print it.
  .           Duplicate the next word. If we've processed all words, this
              will give an empty string.
$K          Jump back to the beginning of the loop if there is another word
            left on the stack.
@           Otherwise, terminate the program.
```
[Answer]
## JavaScript (ES6), 76 bytes
```
s=>s.split` `.map(w=>w.split(/[aeiou]/i).map((_,i)=>o=i?w[i-1]+o:o),o='')&&o
```
### Test cases
```
let f =
s=>s.split` `.map(w=>w.split(/[aeiou]/i).map((_,i)=>o=i?w[i-1]+o:o),o='')&&o
console.log(f(""                                 )) // -> ""
console.log(f("Hello World"                      )) // -> "WeH"
console.log(f("Waves"                            )) // -> "aW"
console.log(f("Programming Puzzles and Code Golf")) // -> "GoCauPorP"
console.log(f("Yay Got it"                       )) // -> "iGY" 
console.log(f("Thx for the feedback"             )) // -> "eeftf"                  
console.log(f("Go Cat Print Pad"                 )) // -> "PPCG"
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~54~~ 59+1 = ~~55~~ 60 bytes
Uses the `-p` flag for +1 byte.
```
$_=$_.split.map{|w|w[0,w.count("aeiouAEIOU")]}.join.reverse
```
[Try it online!](https://tio.run/##HY7BSsNAFEX3@YprG1BRR3@gCylSBTFZKEVEymvykoxO5oWZl8bU@u01urp3ce/hhH47HucnYQpcdcd0s0g3JnbOqmmp@z4Mh@Ht5nIwhfRez2bEVvrbu4fsZXb@/mM@xHoTeMch8vS9WKTXmCPzboTngmOkMEIFXa8g56AcFQVFjhCP0lYVB/YKZz1HgydRdBQUUkEbBhXak0MhJR/v2TnBWoIrkzXtOCZ5kDpQ21pfI@/3ezdRyZdYTnOsxFXJK41TUVhNnpsvVBL@sRVzuaXiM1kJlqTIg50cciqTR9bTiFr@nLPGyi8 "Ruby – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt) v2.0a0, ~~12~~ 10 bytes
```
¸®¯Zè\vÃ¬w
```
[Try it](https://ethproductions.github.io/japt/?v=2.0a0&code=uK6vWuhcdsOsdw==&input=IlRoeCBmb3IgdGhlIGZlZWRiYWNrIg==)
---
## Explanation
Pretty much does exactly what the spec describes!
```
        :Implicit input of string U.
¸       :Split to array on spaces.
®       :Map over the array, replacing each element with itself ...
¯       :  sliced from the 0th character to ...
Zè\v    :  the count (è) of vowels (\v) in the element (Z).
Ã       :End mapping.
¬       :Join to a string.
w       :Reverse.
        :Implicit output of result.
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 14 bytes
```
#RʒDžMDu«Ãg£R?
```
[Try it online!](https://tio.run/##MzBNTDJM/f9fOejUJJej@3xdSg@tPtycfmhxkP3//@75Cs6JJQoBRZl5QDIxBQA "05AB1E – Try It Online")
*Darn 05AB1E doesn't have builtin for AEIOUaeiou ಠ\_ಠ*
[Answer]
# JavaScript (ES6), 96 bytes
```
s=>[...s.split` `.map(w=>w.slice(0,(m=w.match(/[aeiou]/gi))&&m.length)).join``].reverse().join``
```
```
f=
s=>[...s.split` `.map(w=>w.slice(0,(m=w.match(/[aeiou]/gi))&&m.length)).join``].reverse().join``
console.log(
    f(''),
    f('Hello World'),
    f('Waves'),
    f('Programming Puzzles and Code Golf'),
    f('Yay Got it'),
    f('Thx for the feedback'),
    f('Go Cat Print Pad')
)
```
[Answer]
# [Python 3](https://docs.python.org/3/), 83 81 79 77 bytes
* [Mr. Xcoder](https://codegolf.stackexchange.com/users/59487/mr-xcoder)  saved 2 bytes
* [Griffin](https://codegolf.stackexchange.com/users/2501/griffin)  saved 2 bytes: Switch from Python 3 to 2
* saved 2 bytes: use of lambda
```
lambda z:''.join(i[:sum(y in'aeiouAEIOU'for y in i)]for i in z.split())[::-1]
```
[Try it online!](https://tio.run/##dY4/C8IwFMR3P8WjS5PBgrgVHEREnXRQRNQhNUn7NM0raSq2X77aDv4ZvOn43R1cUfuM7LjVk1NrRJ5IAU0chtGV0DI8xmWVsxrQhkIhVdP5ar0LNTnoGCA/dx4730RlYdAzzo9xPByd28Kh9UyzYKmMIdiTMzLgfPDme3FXZQCcw4dtHKVO5DnaFDZV0xhVgrASZiQVLMjovv81OIj6xT2gD36DbfaA7pzPFGilZCIut77yT@0T "Python 3 – Try It Online")
[Answer]
# Pyth - 19 bytes
```
_jkm<dl@"aeiou"rd0c
```
[Try it here](https://pyth.herokuapp.com/?code=_jkm%3Cdl%40%22aeiou%22rd0c&input=Hello%20World&test_suite=1&test_suite_input=%22%22%0A%22Hello%20World%22%0A%22Waves%22%0A%22Programming%20Puzzles%20and%20Code%20Golf%22%0A%22Yay%20Got%20it%22%0A%22Thx%20for%20the%20feedback%22%0A%22Go%20Cat%20Print%20Pad%22&debug=0)
Explanation:
```
_jkm<dl@"aeiou"rd0c
                  c  # Split implicit input on whitespace
   m                 # For each word d...
               rd0   # ...take the lower-case conversion...
       @"aeiou"      # filter it to only vowels...
      l              # and find the length of this string (i.e., the number of vowels in the word)
    <d               # Take the first # characters of the word (where # is the length from above)
 jk                  # Join on empty string (can't use s, because that will screw up when the input is the empty string)
_                    # Reverse the result (and implicitly print)
```
I could have 18 bytes if not for the empty string:
```
_sm<dl@"aeiou"rd0c
```
[Answer]
# Pyth, 31
This took me a long time to write, and I feel like there is probably a better approach, but here is what I have:
```
_jkm<Fd.T,cQ)ml:d"[aeiou]"1crQ0
```
[Online test](https://pyth.herokuapp.com/?code=_jkm%3CFd.T%2CcQ%29ml%3Ad%22%5Baeiou%5D%221crQ0&test_suite=1&test_suite_input=%27%27%0A%27Hello+World%27%0A%27Waves%27%0A%27Programming+Puzzles+and+Code+Golf%27%0A%27Yay+Got+it%27%0A%27Thx+for+the+feedback%27%0A%27Go+Cat+Print+Pad%27&debug=0).
```
                             Q     # input
                            r 0    # to lowercase   
                           c       # split by whitespace
               :d"[aeiou]"1        # lambda: regex to find vowels in string
              l                    # lambda: count the vowels in string
             m                     # map lambda over list of words
          cQ)                      # split input by whitespace
         ,                         # list of (input words, vowel counts)
       .T                          # transpose
    <Fd                            # lambda to get first n chars of string
   m                               # map lambda over list of (input words, vowel counts)
 jk                               # join on on empty strings
_                                 # reverse
```
[Answer]
# Ohm, 13 bytes
```
z:αv_K_σh;0JR
```
## Explanation
* First the (implicit) input is split on spaces by `z`.
* Then a foreach loop is started (`:`) with it's associated codeblock being `αv_K_σh`.
	+ `av` pushes `aeiou`
	+ `_` pushes the current iterated element
	+ `K` counts the occurrences of `aeiou` in `_`
	+ `_` the element again
	+ `σh` Splits the element into slices of length `occurences` and takes the first element.
		- Effectively this takes the first `occurences` chars
* `0J` Pushes the stack joined on `''`
	+ The `0` is necessary because it requires an argument that will be joined. If that argument isn't an array it joins the stack
* `R` reverses the result
* implicit print of the TOS
[Answer]
# [Java 8](http://openjdk.java.net/), ~~171~~ 151 bytes
-20 bytes thanks to @Lukas Rotter
I feel like it still needs some golfing... let me know in the comments if you have any suggestions.
```
s->{String z="";for(String w:s.split(" "))z+=w.substring(0,w.replaceAll("(?i)[^aeiou]","").length());return new StringBuilder(z).reverse().toString();}
```
[Try it online!](https://tio.run/##hZExb8MgEIV3/4oTE6gJ6lwrrdoM6dLIUitFVZRKxD4nJBgswHbjyL/dxa2z1guCe98d78FJ1GJuStSn7NxHqRLOwZuQ@hoBSO3R5iJFWA9HgHdvpT5ASseNY3God1FYnBdeprAGDQvo3fzxOjLtgpA4N/bW0zw47kolPSVAGGvvFg131d79qvR@1nCLpQqXPitFCX2SbPslUJpqR2aEMK5QH/yRMhZb9JXVoLEZjb1UUmVoacvCjBqtQ8q4N38iZXHXx4PVstqrYHV0XBuZQRESjwa3OxBsjHtxHgtuKs/LIHmlqeYpJa@olIGNsSoLCeJ/2Y2o0U1SiTUHK4pieKCkaluFDoTOYGkyhJVR@eSET3EJoAfpJ9GP4zeEDwF/RMgRs71Iz5NNKwNL4SEZapCIW/Au6vof "Java (OpenJDK 8) – Try It Online")
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 10 bytes
```
⌈ƛk∨↔LẎ;∑Ṙ
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=&code=%E2%8C%88%C6%9Bk%E2%88%A8%E2%86%94L%E1%BA%8E%3B%E2%88%91%E1%B9%98&inputs=Hello%20World&header=&footer=)
```
⌈          # Split on spaces
 ƛ     ;   # Map...
    ↔      # Remove characters not in...
  k∨       # 'aeiouAEIOU'
     L     # Get the length of that
      Ẏ    # Get that many characters of the original string
        ∑  # Concatenate all of them
         Ṙ # Reverse the whole thing
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 12 bytes
```
ḲµfØcLḣ@µ€FU
```
[Try it online!](https://tio.run/##y0rNyan8///hjk2HtqYdnpHs83DHYodDWx81rXEL/a9zuD3rUcMcJQVdOwWlRw1zQWwQnQVWEPn/v5KSjpIH0IR8hfD8opwUIC88sSy1GEgHFOWnFyXm5mbmpSsElFZV5aQWKyTmpSg456ekKrjn56QB1UQmVgKZJQqZJUBOSEaFQlp@kUJJRqpCWmpqSlJicjZQ2D1fwTmxRCGgKDMPSCamKAEA "Jelly – Try It Online")
[Answer]
# Mathematica, 145 bytes
```
(s=StringCount[#,{"a","e","i","o","u","A","E","I","O","U"}]&/@(x=StringSplit@#);StringReverse[""<>Table[StringTake[x[[i]],s[[i]]],{i,Tr[1^s]}]])&
```
[Answer]
# [Retina](https://github.com/m-ender/retina), ~~49~~ 46 bytes
```
i`(?=(([aeiou])|\w)+)((?<-2>.)+)\w* ?
$3
O^$`.
```
[Try it online!](https://tio.run/##DcaxDoIwEADQ/b7iBkyKRgZdVQYG3GQwIUY0nPaAxtImpYgS/x1ZXp5jrwxNC5GWkypFvBfiSqxsfwt/xRCuQiHi3XpziOYWwxJjCLZwugdlNE1wZK0t5tZpCTm9uYPM2dpR2ypTY9aPo@YOyUhMrGRMra7gQt85HpWHc/PByjr0DWPFLB/0fEFqMSGPmVNmluQf "Retina – Try It Online") Link includes test suite. Explanation: This is an application of .NET's balancing groups. The lookahead searches the word for vowels, which are captured in group 2. The group is then popped as each letter is matched, thus capturing the number of letters equal to the number of vowels in the word. The rest of the word and any trailing space is then ignored so that the process can begin again with the next word. Finally the remaining letters are reversed.
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 144 bytes
```
using System.Linq;s=>new string(string.Join("",s.Split(' ').Select(e=>e.Substring(0,e.Count(c=>"aeiouAEIOU".Contains(c))))).Reverse().ToArray())
```
[Try it online!](https://tio.run/##jVDBTsMwDL33K6xclkgj4j5aaZoAgUBMdIhzlrpbRJpAnA42xLeXdK2G4MQ72NKz/Ww/TWfaB@xaMm4D5Z4iNvLOuLdZlkGCtooIlsFvgmqOzOcx9qCootGw86aCe2UcF6fST1OPUfaqdfqCYkibpjDkAmrIs47ywuH7yPEhyVufJBmbkixfrYl8AhMhS7SoI8e8QFm263HifIpy4VsXuc4LptD4dn558/DEEutiOo24Fj3kI@4wEHIhV34egtpzIbrx1z/nplHyFuVzMBGTJchrzkYnmt6tZXs4WCRQroKFrxCuva2ZELN/q622H1D7AHGLUCNWa6Vffgl8ZUPsvgE "C# (.NET Core) – Try It Online")
The worst part is that reversing a `string` in C# returns a `IEnumerable<char>` which you have to convert back to a `string`.
[Answer]
# [PHP](https://php.net/), 96 bytes
```
foreach(explode(" ",$argn)as$w)$r.=substr($w,0,preg_match_all("#[aeiou]#i",$w));echo strrev($r);
```
[Try it online!](https://tio.run/##Hcu9CsIwFEDh3acIaYYEgrjX4uDg2l2kXNvbJJA/blorfflYXA/nyzbX6y3bfBJAJna8p2QIQnDRsH7dd4@FQZzYPU3IHsnPvK1zIoTRSvxmf2TJGdd/rqCITQk6d2V9l4Wk2PRFZ0IzBFhGO4D3kjdPQJfWV@MOtinV4mgTO3bCjxSk2lp/ "PHP – Try It Online")
[Answer]
# Common Lisp, 218 bytes
```
(defun p(s &aux(j 0)c(v 0)r)(dotimes(i(1+(length s))(apply'concatenate'string r))(cond((or(= i(length s))(eql(setf c(elt s i))#\ ))(setf r(cons(reverse(subseq s j(+ j v)))r)v 0 j(1+ i)))((find c"AEIOUaeiou")(incf v)))))
```
**Explanation**
```
(defun p(s &aux (j 0) c (v 0) r)               ; j start of word, c current char, v num of wovels, r result
  (dotimes (i                                  ; iteration var
            (1+ (length s))                    ; iteration limit
            (apply 'concatenate 'string r))    ; iteration final result
    (cond ((or (= i (length s))                ; if string is terminated   
               (eql (setf c (elt s i)) #\ ))   ;  or, set current char, and this is a space, then
           (setf r (cons (reverse (subseq s j (+ j v))) r) ; push on result from current word chars as number of vowels
                 v 0                           ; reset number of vowels to 0
                 j (1+ i)))                    ; reset start of current word to next char
          ((find c "AEIOUaeiou")               ; if current char is a wovel
           (incf v)))))                        ;   then increment num of vowels
```
[Answer]
# sed, 133 (132+1) bytes
sed is called with the `-E` flag, which apparently means I add one byte.  
Note: I have not really attempted to golf this yet.
```
s/$/\n/
:l
s/(.)(\n.*)/\2\1/
tl
s/\n/ /
h
s/[aoeui]//g
G
:r
s/^(\S*) \S(.*\n\S* )\S/\1 \2/
tr
s/^ //
s/(\n\S*) /\1/
/^\n/!br
s/\s//g
```
[Try it online!](https://tio.run/##HYzBasMwEETv@xVb6ME2xEtyzDUU92hwIZRuA4ol26KKtkhKafPfvVaVc1mGebMvGp1zpEdiT7B3EKlq64p929TEO94SpLUsFAmWkt6UmKt9J5qhg30ozanioamRh6pt2JeMNQ/EW@Rd@b4vkGg132mNtGrpVJwP5xVzLLacn41zgkcJTsNRfZkIfZA5qMvF@hn76@3mTETlNR5EG@zETfCqfkpIaBO8LN84ScC0GJyM0Wc1fkAneFAJ@2B9uUr/yWey4mPePP162YxqXMw/ "sed – Try It Online")
[Answer]
## Clojure, ~~96~~ 94 bytes
```
#(apply str(mapcat(fn[i](take(count(filter(set"aeiouAEIOU")i))i))(reverse(re-seq #"[^ ]+"%))))
```
Well this length is quite ridiculous. `mapcat` saved two bytes.
[Answer]
# Swift 3, 240 bytes
This is a function that can be used with `f(s:"Input")`. Surprisingly, I don't think it can be golfed further:
```
import Foundation
func f(s:String){var c=s.components(separatedBy:" "),r="";for i in c{let b=i.startIndex;r+=i[b...i.index(b,offsetBy: i.characters.filter{"aeiouAEIOU".contains(String($0))}.count-1)]};print(String(r.characters.reversed()))}
```
[Try it at IBM Sandbox!](http://swift.sandbox.bluemix.net/#/repl/5945a5bef5dc584046fa2027)
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 26 bytes
```
qS/{_el"aeiou"fe=:+<}%:+W%
```
[Try it online!](https://tio.run/##S85KzP3/vzBYvzo@NUcpMTUzv1QpLdXWStumVtVKO1z1///cxOxUBa/SvGwF56LEtJJiAA "CJam – Try It Online")
I was proud of coming up with the `el"aeiou"fe=:+` snippet to count vowels.
[Answer]
# [GolfScript](http://www.golfscript.com/golfscript/), 33 bytes
```
" "/-1%{.{"aeiouAIUEO"?)},,<-1%}/
```
[Try it online!](https://tio.run/##S8/PSStOLsosKPn/X0lBSV/XULVar1opMTUzv9TRM9TVX8les1ZHxwYoXqv//79Hak5OvkJ4flFOCgA "GolfScript – Try It Online")
```
" "/                                # Split the words                          ["Hello" "World"]
    -1%                             # Reverse the list                         ["World" "Hello"]
       {                       }/   # For each word                            "World"         | "Hello"
        .                           # Copy it                                  "World" "World" | "Hello" "Hello"
         {              },          # List all letters that pass this test
          "aeiouAIUEO"?)            # Is it a vowel?                           "World" ["o"]   | "Hello" ["e" "o"]
                          ,         # Get the number of letters in the list    "World" 1       | "Hello" 2
                           <        # Get that many letters from the beginning "W"             | "He"
                            -1%     # Reverse it                               "W"             | "eH"
                                                                               "WeH"
```
[Answer]
# k, ~~33~~ ~~28~~ 27 bytes
```
|,/{x@!+/~^"aeiou"?_x}'" "\
```
[Try it online!](https://tio.run/##fcm9CsIwFEDhPU9xzVJFJc4uCh3q2EEogihXc9uGprmQpqXWn1ePPoHL4YPTrLmJ8bVSz3E/W6rPRSIZ7uXuOr4TCfIc53/mItlspdI0qC5o42Q8kLUMBXurRYEDdSL3XHlsW@MqyPtpstQBOg0pa4KMbSlO@PghgAniWI9QsodQE5RE@ob3RmQMKQbIvXG/ov4C "K (oK) – Try It Online")
---
[-5 bytes](https://codegolf.stackexchange.com/questions/126935/make-string-waves/126948?noredirect=1#comment501575_126948) thanks to [coltim](https://codegolf.stackexchange.com/users/98547/coltim), [-1 byte](https://codegolf.stackexchange.com/questions/126935/make-string-waves/126948?noredirect=1#comment577893_126948) thanks to [doug](https://codegolf.stackexchange.com/users/111844/doug).
[Answer]
# [Husk](https://github.com/barbuz/Husk), 17 bytes
```
ṁS↑ṁ#¨aeıuAEIOU¨w
```
[Try it online!](https://tio.run/##yygtzv7//@HOxuBHbROBlPKhFYmpRzaWOrp6@oceWlH@//9/j9ScnHyF8PyinBQA "Husk – Try It Online")
Even without a builtin, does pretty well.
]