给定字符串作为输入，使用以下算法输出字符串：

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"

眼镜

• 您可以采用任何标准格式进行输入并提供输出，并且输入和输出所允许的唯一数据类型是您语言的本机String类型。不允许直接将输入作为单个单词的列表。

• 您保证不会有连续的空格。

• 元音是"a","e","i","o","u","A","E","I","O","U"但"y","Y" 不被认为是元音。

• 您可以确保在输入中仅出现字母和空格，但没有任何换行符。

• 输出必须区分大小写。

• 您不能保证每个单词都包含一个元音。如果该单词中没有元音，则无需输出任何内容。

测试用例

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"

计分

每种语言的最短有效提交数将获胜，这是code-golf。祝好运并玩得开心点！

_{可以看到已删除帖子的人的沙盒。}

Haskell，59个字节

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

在线尝试！

       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个字节

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

在线尝试！

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

并说明：

Í               " 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个字节

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

在线尝试！

说明

那是问题的直接翻译：

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字节

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

爱丽丝，32字节

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

在线尝试！

说明

/....
\...@/

这只是Ordinal（字符串处理模式）中线性代码的框架。展开程序，我们得到：

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

这是它的作用：

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个字节

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

测试用例

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个字节

45个字节的代码+ 2个-pa。

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

在线尝试！

JavaScript（ES6），96个字节

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个字节

_jkm<dl@"aeiou"rd0c

在这里尝试

说明：

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

如果没有空字符串，我可以有18个字节：

_sm<dl@"aeiou"rd0c

珀斯，31岁

这花了我很长时间写，而且我觉得可能有更好的方法，但这就是我所拥有的：

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

在线测试。

                             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

欧姆，13个字节

z:αv_K_σh;0JR

说明

• 首先，将（隐式）输入用分隔z。
• 然后，开始foreach循环（:），并将其相关的代码块设为αv_K_σh。
  • av 推 aeiou
  • _ 推送当前迭代的元素
  • K计算aeiouin 的出现_
  • _ 再次元素
  • σh将元素拆分为多个长度片段，occurences并获取第一个元素。
    • 有效地，这需要第一个occurences字符
• 0J 将堆栈推入 ''
  • 0之所以必要，是因为它需要一个将要加入的参数。如果该参数不是数组，它将加入堆栈
• R 反转结果
• TOS的隐式打印

红宝石，54 59 + 1 = 55 60字节

使用-p+1字节的标志。

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

在线尝试！

Japt v2.0a0，12 10个字节

¸®¯Zè\vìw

尝试一下

说明

几乎完全符合规范的描述！

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

果冻，12字节

ḲµfØcLḣ@µ€FU

在线尝试！

05AB1E，14个字节

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

在线尝试！

达恩05AB1E尚未内置AEIOUaeiouಠ_ಠ

Mathematica，145个字节

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

视网膜，49 46字节

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

在线尝试！链接包括测试套件。说明：这是.NET平衡组的应用程序。超前搜索会在单词中搜索元音，然后在组2中捕获该元音。然后在匹配每个字母时弹出该组，从而捕获等于该单词中元音数量的字母数。然后忽略单词的其余部分和任何尾随空格，以便该过程可以从下一个单词重新开始。最后，其余字母颠倒过来。

C＃（.NET Core），144字节

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

在线尝试！

最糟糕的是，扭转了string在C＃回报IEnumerable<char>，你必须转换回一个string。

PHP，96字节

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

在线尝试！

Python 3中，83个 81 79 77字节

• Xcoder先生 节省了2个字节
• 格里芬 保存了2个字节：从Python 3切换到2
• 保存2个字节：使用lambda

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

在线尝试！

Java的8，171个 151字节

@Lukas Rotter，-20个字节

我觉得它仍然需要打高尔夫球...如果您有任何建议，请在评论中告诉我。

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

在线尝试！

k，33个字节

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

在线尝试！

普通Lisp，218字节

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

说明

(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）个字节

sed与-E标志一起调用，这显然意味着我添加了一个字节。
_{注意：我还没有真正尝试过打高尔夫球。}

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

在线尝试！

Clojure，96 94字节

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

那么这个长度是很荒谬的。mapcat保存了两个字节。

斯威夫特3，240字节

这是可以与使用的功能f(s:"Input")。出乎意料的是，我认为它不能被进一步推广：

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

在IBM Sandbox上尝试一下！