Data una stringa come input, genera la stringa con il seguente algoritmo applicato:

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"

Specifiche

• È possibile accettare input e fornire output in qualsiasi formato standard e l'unico tipo di dati consentito sia per Input che per Output è il tipo String nativo della propria lingua. Non è consentito inserire direttamente un elenco come singole parole.

• Hai la garanzia che non ci saranno spazi consecutivi.

• Le vocali sono "a","e","i","o","u","A","E","I","O","U", ma "y","Y" non sono considerate vocali .

• Si garantisce che nell'input appariranno solo lettere e spazi, ma senza nuove righe.

• L'output deve essere sensibile al maiuscolo / minuscolo.

• Non è garantito che ogni parola contenga una vocale. Se non appaiono vocali in quella parola, non devi produrre nulla per essa.

Casi test

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"

punteggio

Vince l'invio valido più breve per ogni lingua, questo è code-golf . Buona fortuna e buon divertimento!

_{Sandbox per coloro che possono vedere i post eliminati.}

Haskell, 59 byte

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

Provalo 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 byte

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

Provalo online!

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

E spiegazione:

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

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

Provalo online!

Spiegazione

Questa è una traduzione diretta 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 byte

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

Alice , 32 byte

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

Provalo online!

Spiegazione

/....
\...@/

Questo è solo un framework per il codice lineare in Ordinal (modalità di elaborazione delle stringhe). Spiegando il programma, otteniamo:

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

Ecco cosa fa:

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 byte

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

Casi test

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 byte

45 byte codice + 2 per -pa.

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

Provalo online!

JavaScript (ES6), 96 byte

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 byte

_jkm<dl@"aeiou"rd0c

Provalo qui

Spiegazione:

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

Potrei avere 18 byte se non per la stringa vuota:

_sm<dl@"aeiou"rd0c

Pyth, 31

Mi ci è voluto molto tempo per scrivere e sento che probabilmente c'è un approccio migliore, ma ecco cosa ho:

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

Test 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 byte

z:αv_K_σh;0JR

Spiegazione

• Innanzitutto, l'input (implicito) viene suddiviso in spazi per z.
• Quindi viene avviato un ciclo foreach ( :) con il blocco codice associato associato αv_K_σh.
  • av spinte aeiou
  • _ spinge l'elemento iterato corrente
  • Kconta le occorrenze di aeiouin_
  • _ di nuovo l'elemento
  • σh Divide l'elemento in sezioni di lunghezza occurences e prende il primo elemento.
    • In effetti questo richiede i primi occurencescaratteri
• 0J Spinge lo stack unito ''
  • Il 0occorre perché richiede un argomento che verrà unito. Se tale argomento non è un array, si unisce allo stack
• R inverte il risultato
• stampa implicita del TOS

Rubino , 54 59 + 1 = 55 60 byte

Utilizza il -pflag per +1 byte.

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

Provalo online!

Japt v2.0a0, 12 10 byte

¸®¯Zè\vìw

Provalo

Spiegazione

Praticamente fa esattamente ciò che le specifiche descrivono!

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

ḲµfØcLḣ@µ€FU

Provalo online!

05AB1E , 14 byte

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

Provalo online!

Darn 05AB1E non ha builtin per AEIOUaeiou ಠ_ಠ

Mathematica, 145 byte

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

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

Provalo online! Il link include la suite di test. Spiegazione: Questa è un'applicazione dei gruppi di bilanciamento di .NET. Il lookahead cerca le vocali per le parole, che sono catturate nel gruppo 2. Il gruppo viene quindi spuntato quando ogni lettera è abbinata, catturando così il numero di lettere uguale al numero di vocali nella parola. Il resto della parola e qualsiasi spazio finale vengono quindi ignorati in modo che il processo possa ricominciare con la parola successiva. Alla fine le lettere rimanenti vengono invertite.

C # (.NET Core) , 144 byte

using System.Linq;s=>new string(string.Join("",s.Split(' ').Select(e=>e.Substring(0,e.Count(c=>"aeiouAEIOU".Contains(c))))).Reverse().ToArray())

Provalo online!

La parte peggiore è che l'inversione di a stringin C # restituisce a IEnumerable<char>che devi riconvertire in a string.

PHP , 96 byte

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

Provalo online!

Python 3 , 83 81 79 77 byte

• Il signor Xcoder ha salvato 2 byte
• Griffin ha salvato 2 byte: passa da Python 3 a 2
• salvato 2 byte: uso di lambda

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

Provalo online!

Java 8 , 171 151 byte

-20 byte grazie a @Lukas Rotter

Sento che ha ancora bisogno di golf ... fammi sapere nei commenti se hai qualche suggerimento.

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

Provalo online!

k, 33 byte

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

Provalo online!

Lisp comune, 218 byte

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

Spiegazione

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

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.

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!