Wenn Sie eine Zeichenfolge als Eingabe angeben, geben Sie die Zeichenfolge mit dem folgenden Algorithmus aus:

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"

Technische Daten

• Sie können Eingaben und Ausgaben in jedem Standardformular vornehmen . Der einzige Datentyp, der sowohl für die Eingabe als auch für die Ausgabe zulässig ist, ist der native Zeichenfolgentyp Ihrer Sprache. Eine direkte Eingabe als Liste einzelner Wörter ist nicht zulässig.

• Sie werden garantiert, dass es keine aufeinander folgenden Leerzeichen geben wird.

• Die Vokale sind "a","e","i","o","u","A","E","I","O","U", werden aber "y","Y" nicht als Vokale betrachtet .

• Es wird garantiert, dass nur Buchstaben und Leerzeichen in der Eingabe angezeigt werden, jedoch ohne Zeilenumbrüche.

• Bei der Ausgabe muss die Groß- und Kleinschreibung beachtet werden.

• Es ist nicht garantiert, dass jedes Wort einen Vokal enthält. Wenn in diesem Wort keine Vokale vorkommen, müssen Sie nichts dafür ausgeben.

Testfälle

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"

Wertung

Die kürzeste gültige Einsendung für jede Sprache gewinnt, das ist Code-Golf . Viel Glück und hab Spaß!

_{Sandbox für diejenigen, die gelöschte Beiträge sehen können.}

Haskell, 59 Bytes

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

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

Probieren Sie es online!

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

Und Erklärung:

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

Probieren Sie es online!

Erläuterung

Das ist eine direkte Übersetzung des Problems:

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@/

Probieren Sie es online!

Erläuterung

/....
\...@/

Dies ist nur ein Framework für linearen Code in Ordinal (Zeichenfolgenverarbeitungsmodus). Das Programm entfaltet sich, wir bekommen:

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

Das macht es:

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

Testfälle

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

45 Byte Code + 2 für -pa.

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

Probieren Sie es 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 Bytes

_jkm<dl@"aeiou"rd0c

Probieren Sie es hier aus

Erläuterung:

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

Ich könnte 18 Bytes haben, wenn nicht für die leere Zeichenfolge:

_sm<dl@"aeiou"rd0c

Pyth, 31

Das hat lange gedauert und ich habe das Gefühl, dass es wahrscheinlich einen besseren Ansatz gibt, aber hier ist, was ich habe:

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

Online-Test .

                             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

Erläuterung

• Zuerst wird die (implizite) Eingabe nach Leerzeichen aufgeteilt z.
• Dann wird eine foreach-Schleife :mit dem zugehörigen Codeblock gestartet ( ) αv_K_σh.
  • av drückt aeiou
  • _ verschiebt das aktuell iterierte Element
  • Kzählt die Vorkommen von aeiouin_
  • _ das Element wieder
  • σhTeilt das Element in Längsschnitte occurencesund übernimmt das erste Element.
    • Tatsächlich dauert dies die ersten occurencesZeichen
• 0J Schiebt den Stapel zusammen ''
  • Das 0ist notwendig, weil es ein Argument erfordert, das verbunden wird. Wenn dieses Argument kein Array ist, wird es dem Stapel hinzugefügt
• R kehrt das Ergebnis um
• impliziter Ausdruck der AGB

Ruby , 54 59 + 1 = 55 60 Bytes

Verwendet das -pFlag für +1 Byte.

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

Probieren Sie es online!

Japt v2.0a0, 12 10 Bytes

¸®¯Zè\vìw

Versuch es

Erläuterung

Ziemlich genau das, was die Spezifikation beschreibt!

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

Gelee , 12 Bytes

ḲµfØcLḣ@µ€FU

Probieren Sie es online!

05AB1E , 14 Bytes

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

Probieren Sie es online!

Darn 05AB1E ist nicht für AEIOUaeiou ಠ_ಠ integriert

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^$`.

Probieren Sie es online! Link enthält Testsuite. Erläuterung: Dies ist eine Anwendung der .NET-Bilanzkreise. Der Lookahead durchsucht das Wort nach Vokalen, die in Gruppe 2 erfasst werden. Die Gruppe wird dann beim Abgleichen jedes Buchstabens geknallt. Auf diese Weise wird die Anzahl der Buchstaben erfasst, die der Anzahl der Vokale im Wort entspricht. Der Rest des Wortes und alle nachfolgenden Leerzeichen werden dann ignoriert, damit der Vorgang mit dem nächsten Wort erneut beginnen kann. Schließlich werden die verbleibenden Buchstaben umgekehrt.

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

Probieren Sie es online!

Das Schlimmste ist, dass das Umkehren von a stringin C # a zurückgibt, IEnumerable<char>das Sie zurück in a konvertieren müssen string.

PHP , 96 Bytes

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

Probieren Sie es online!

Python 3 , 83 81 79 77 Bytes

• Mr. Xcoder hat 2 Bytes gespart
• Greif sparte 2 Bytes: Wechseln Sie von Python 3 zu 2
• 2 Bytes gespart: Verwendung von Lambda

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

Probieren Sie es online!

Java 8 , 171 151 bytes

-20 Bytes dank @Lukas Rotter

Ich habe das Gefühl, dass es noch etwas Golf braucht ... lass es mich in den Kommentaren wissen, wenn du irgendwelche Vorschläge hast.

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

Probieren Sie es online!

k, 33 Bytes

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

Probieren Sie es online!

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

Erläuterung

(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 wird mit dem -EFlag aufgerufen , was anscheinend bedeutet, dass ich ein Byte hinzufüge.
_{Anmerkung: Ich habe noch nicht wirklich versucht, Golf zu spielen.}

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

Probieren Sie es online!

Clojure, 96 94 Bytes

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

Nun, diese Länge ist ziemlich lächerlich. mapcatsparte zwei Bytes.

Schnelle 3, 240 Bytes

Dies ist eine Funktion, die mit verwendet werden kann f(s:"Input"). Überraschenderweise glaube ich nicht, dass man weiter Golf spielen kann:

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

Probieren Sie es bei IBM Sandbox!