Dada una cadena como entrada, genera la cadena con el siguiente 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"

Especificaciones

• Puede tomar datos de entrada y salida de cualquier forma estándar , y el único tipo de datos permitido para Entrada y Salida es el tipo de Cadena nativa de su idioma. Tomar entradas directamente como una lista de palabras individuales no está permitido.

• Le garantizamos que no habrá espacios consecutivos.

• Las vocales son "a","e","i","o","u","A","E","I","O","U", pero "y","Y" no se consideran vocales .

• Se garantiza que solo aparecerán letras y espacios en la entrada, pero sin líneas nuevas.

• La salida debe ser sensible a mayúsculas y minúsculas.

• No se garantiza que cada palabra contenga una vocal. Si no aparecen vocales en esa palabra, no tiene que emitir nada para ella.

Casos de prueba

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"

Puntuación

La presentación válida más corta para cada idioma gana, este es el código de golf . ¡Buena suerte y diviertete!

_{Sandbox para aquellos que pueden ver publicaciones eliminadas.}

Haskell, 59 bytes

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

Pruébalo en línea!

       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-òÍî
æ

Pruébalo en línea!

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

Y explicación:

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

Brachylog , 17 bytes

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

Pruébalo en línea!

Explicación

Esa es una traducción directa del 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@/

Pruébalo en línea!

Explicación

/....
\...@/

Esto es solo un marco para el código lineal en Ordinal (modo de procesamiento de cadenas). Al desplegar el programa, obtenemos:

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

Esto es lo que hace:

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 prueba

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}{

Pruébalo en línea!

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

Pyth - 19 bytes

_jkm<dl@"aeiou"rd0c

Pruébalo aquí

Explicación:

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

Podría tener 18 bytes si no fuera por la cadena vacía:

_sm<dl@"aeiou"rd0c

Pyth, 31

Me llevó mucho tiempo escribir, y siento que probablemente haya un mejor enfoque, pero esto es lo que tengo:

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

Prueba en línea .

                             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

Explicación

• Primero, la entrada (implícita) se divide en espacios por z .
• Luego se inicia un bucle foreach ( :) con su bloque de código asociado αv_K_σh.
  • av empuja aeiou
  • _ empuja el elemento iterado actual
  • Kcuenta las ocurrencias de aeiouen_
  • _ el elemento nuevamente
  • σh Divide el elemento en rodajas de longitud occurences y toma el primer elemento.
    • Efectivamente, esto toma los primeros occurencescaracteres
• 0J Empuja la pila unida ''
  • El 0es necesario porque requiere un argumento que se unirá. Si ese argumento no es una matriz, se une a la pila
• R invierte el resultado
• impresión implícita de los TOS

Rubí , 54 59 + 1 = 55 60 bytes

Utiliza la -pbandera para +1 byte.

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

Pruébalo en línea!

Japt v2.0a0, 12 10 bytes

¸®¯Zè\vìw

Intentalo

Explicación

¡Más o menos hace exactamente lo que describe la especificación!

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

Jalea , 12 bytes

ḲµfØcLḣ@µ€FU

Pruébalo en línea!

05AB1E , 14 bytes

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

Pruébalo en línea!

Darn 05AB1E no tiene incorporado 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^$`.

Pruébalo en línea! El enlace incluye un conjunto de pruebas. Explicación: Esta es una aplicación de los grupos de equilibrio de .NET. La búsqueda anticipada busca vocales en la palabra, que se capturan en el grupo 2. Luego, el grupo aparece cuando cada letra coincide, capturando así el número de letras igual al número de vocales en la palabra. El resto de la palabra y cualquier espacio final se ignora para que el proceso pueda comenzar nuevamente con la siguiente palabra. Finalmente se invierten las letras restantes.

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

Pruébalo en línea!

La peor parte es que revertir a stringen C # devuelve un IEnumerable<char>que debe volver a convertir a a string.

PHP , 96 bytes

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

Pruébalo en línea!

Python 3 , 83 81 79 77 bytes

• El Sr. Xcoder ahorró 2 bytes
• Grifo guardó 2 bytes: cambie de Python 3 a 2
• 2 bytes guardados: uso de lambda

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

Pruébalo en línea!

Java 8 , 171 151 bytes

-20 bytes gracias a @Lukas Rotter

Siento que todavía necesita algo de golf ... avíseme en los comentarios si tiene alguna sugerencia.

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

Pruébalo en línea!

k, 33 bytes

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

Pruébalo en línea!

Lisp común, 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)))))

Explicación

(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 se llama con la -Ebandera, lo que aparentemente significa que agrego un byte.
_{Nota: Realmente no he intentado jugar golf todavía.}

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

Pruébalo en línea!

Clojure, 96 94 bytes

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

Bueno, esta longitud es bastante ridícula. mapcatGuardado dos bytes.

Swift 3, 240 bytes

Esta es una función que se puede usar con f(s:"Input"). Sorprendentemente, no creo que se pueda jugar más al golf:

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

¡Pruébalo en IBM Sandbox!