入力として文字列を指定すると、次のアルゴリズムが適用された文字列が出力されます。

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

オンラインでお試しください！

説明

/....
\...@/

これは、順序（文字列処理モード）の線形コードのフレームワークです。プログラムを展開すると、以下が得られます。

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

Pyth、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
  • _ 現在の反復要素をプッシュします
  • Kaeiouin の出現回数をカウントします_
  • _ 再び要素
  • σ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 for_ಠの組み込み機能がありません

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＃でaを反転すると、a に戻すIEnumerable<char>必要があるa が返されることです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バイト

• Mr. Xcoderは2バイトを節約しました
• Griffinは2バイトを節約しました：Python 3から2に切り替えます
• 2バイト節約：ラムダの使用

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}@" "\

オンラインでお試しください！

Common 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フラグ付きで呼び出されますが、これは明らかに1バイトを追加することを意味します。
_{注：私はまだこれを実際にゴルフしようとしませんでした。}

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 #"[^ ]+"%))))

まあ、この長さは非常にばかげています。mapcat2バイト節約しました。

Swift 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でお試しください！