Dada uma sequência como entrada, produza a sequência com o seguinte algoritmo aplicado:

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"

Especificações

• Você pode receber e fornecer saída de qualquer forma padrão , e o único tipo de dados permitido para entrada e saída é o tipo String nativo do seu idioma. Não é permitido receber entradas diretamente como uma lista de palavras individuais.

• Você está garantido que não haverá espaços consecutivos.

• As vogais são "a","e","i","o","u","A","E","I","O","U", mas "y","Y" não são consideradas vogais .

• Você tem a garantia de que apenas letras e espaços aparecerão na entrada, mas sem novas linhas.

• A saída deve fazer distinção entre maiúsculas e minúsculas.

• Você não tem garantia de que cada palavra contenha uma vogal. Se nenhuma vogal aparecer nessa palavra, você não precisará produzir nada para ela.

Casos de teste

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"

Pontuação

A submissão válida mais curta para cada idioma vence, é o código-golfe . Boa sorte e divirta-se!

_{Sandbox para quem pode ver as postagens excluídas.}

Haskell, 59 bytes

map fst.reverse.(>>=zip<*>filter(`elem`"aeiouAEIOU")).words

Experimente 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

V , 31 bytes

Í /ò
òÄøã[aeiou]
|DJ@"|D-òÍî
æ

Experimente online!

00000000: cd20 2ff2 0af2 c4f8 e35b 6165 696f 755d  . /......[aeiou]
00000010: 0a01 7c44 4a40 227c 442d f2cd ee0a e6    ..|DJ@"|D-.....

E explicação:

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

Braquilog , 17 bytes

ṇ₁{{∋ḷ∈Ṿ}ᶜ}ᶻs₎ᵐc↔

Experimente online!

Explicação

Essa é uma tradução direta do problema:

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"

Perl 6 , 57 bytes

{flip [~] .words.map:{.substr(0,.comb(rx:i/<[aeiou]>/))}}

Alice , 32 bytes

/.'*%-.m"Re.oK"
\iu &wN.;aoi$u@/

Experimente online!

Explicação

/....
\...@/

Esta é apenas uma estrutura para código linear no Ordinal (modo de processamento de string). Desdobrando o programa, obtemos:

i' %w.."aeiou".u*&-Nm;Ro.$K@

Aqui está o que ele faz:

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.

JavaScript (ES6), 76 bytes

s=>s.split` `.map(w=>w.split(/[aeiou]/i).map((_,i)=>o=i?w[i-1]+o:o),o='')&&o

Casos de teste

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"

Perl 5, 47 bytes

Código de 45 bytes + 2 para -pa.

map$\=$_.$\,(/./g)[0..lc=~y/aeiou//-1]for@F}{

Experimente online!

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')
)

Pitão - 19 bytes

_jkm<dl@"aeiou"rd0c

Experimente aqui

Explicação:

_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)

Eu poderia ter 18 bytes, se não fosse a string vazia:

_sm<dl@"aeiou"rd0c

Pyth, 31

Demorei muito tempo para escrever e sinto que provavelmente existe uma abordagem melhor, mas eis o que tenho:

_jkm<Fd.T,cQ)ml:d"[aeiou]"1crQ0

Teste online .

                             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

Ohm, 13 bytes

z:αv_K_σh;0JR

Explicação

• Primeiro, a entrada (implícita) é dividida em espaços por z.
• Em seguida, um loop foreach é iniciado ( :) com seu código associado αv_K_σh.
  • av empurra aeiou
  • _ empurra o elemento iterado atual
  • Kconta as ocorrências de aeiouem_
  • _ o elemento novamente
  • σhDivide o elemento em fatias de comprimento occurencese pega o primeiro elemento.
    • Efetivamente, isso leva os primeiros occurencescaracteres
• 0J Empurra a pilha unida ''
  • O 0é necessário porque requer um argumento que será associado. Se esse argumento não é uma matriz, ele se junta à pilha
• R reverte o resultado
• impressão implícita dos Termos de Serviço

Ruby , 54 59 + 1 = 55 60 bytes

Usa o -psinalizador para +1 byte.

$_=$_.split.map{|w|w[0,w.count("aeiouAEIOU")]}.join.reverse

Experimente online!

Japt v2.0a0, 12 10 bytes

¸®¯Zè\vìw

Tente

Explicação

Praticamente faz exatamente o que a especificação descreve!

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

Gelatina , 12 bytes

ḲµfØcLḣ@µ€FU

Experimente online!

05AB1E , 14 bytes

#RʒDžMDu«Ãg£R?

Experimente online!

Darn 05AB1E não tem builtin para AEIOUaeiou ಠ_ಠ

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]}]])&

Retina , 49 46 bytes

i`(?=(([aeiou])|\w)+)((?<-2>.)+)\w* ?
$3
O^$`.

Experimente online! O link inclui o conjunto de testes. Explicação: Este é um aplicativo dos grupos de balanceamento do .NET. O lookahead pesquisa a palavra em busca de vogais, que são capturadas no grupo 2. O grupo é exibido quando cada letra é correspondida, capturando assim o número de letras igual ao número de vogais na palavra. O restante da palavra e qualquer espaço à direita são ignorados para que o processo possa começar novamente com a próxima palavra. Finalmente, as letras restantes são invertidas.

C # (.NET Core) , 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())

Experimente online!

A pior parte é que reverter a stringem C # retorna a IEnumerable<char>que você deve converter novamente em a string.

PHP , 96 bytes

foreach(explode(" ",$argn)as$w)$r.=substr($w,0,preg_match_all("#[aeiou]#i",$w));echo strrev($r);

Experimente online!

Python 3 , 83 81 79 77 bytes

• Mr. Xcoder economizou 2 bytes
• Griffin salvou 2 bytes: alterne de Python 3 para 2
• salvou 2 bytes: uso de lambda

lambda z:''.join(i[:sum(y in'aeiouAEIOU'for y in i)]for i in z.split())[::-1]

Experimente online!

Java 8 , 171 151 bytes

-20 bytes graças a @Lukas Rotter

Eu sinto que ainda precisa de golfe ... deixe-me saber nos comentários se você tiver alguma sugestão.

s->{String z="";for(String w:s.split(" "))z+=w.substring(0,w.replaceAll("(?i)[^aeiou]","").length());return new StringBuilder(z).reverse().toString();}

Experimente online!

k, 33 bytes

{|,/(+/'-1<"aoeui"?/:_x)#'x}@" "\

Experimente online!

Lisp comum, 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)))))

Explicação

(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

sed, 133 (132 + 1) bytes

sed é chamado com a -Ebandeira, o que aparentemente significa que eu adiciono um byte.
_{Nota: Ainda não tentei jogar golfe ainda.}

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

Experimente online!

Clojure, 96 94 bytes

#(apply str(mapcat(fn[i](take(count(filter(set"aeiouAEIOU")i))i))(reverse(re-seq #"[^ ]+"%))))

Bem, esse comprimento é bastante ridículo. mapcatsalvou dois bytes.

Swift 3, 240 bytes

Esta é uma função que pode ser usada com f(s:"Input"). Surpreendentemente, não acho que possa ser jogado mais:

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

Experimente na IBM Sandbox!