Diberikan string sebagai input, output string dengan algoritma berikut diterapkan:

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"

Spesifikasi

• Anda dapat mengambil input dan memberikan output dengan bentuk standar apa pun , dan satu-satunya tipe data yang diizinkan untuk Input dan Output adalah tipe String asli bahasa Anda. Mengambil input langsung sebagai daftar kata-kata individual tidak diizinkan.

• Anda dijamin tidak akan ada ruang berurutan.

• Vokal adalah "a","e","i","o","u","A","E","I","O","U", tetapi "y","Y" tidak dianggap vokal .

• Anda dijamin hanya huruf dan spasi yang akan muncul di input, tetapi tanpa baris baru.

• Keluaran harus peka huruf besar-kecil.

• Anda tidak dijamin bahwa setiap kata berisi vokal. Jika tidak ada vokal yang muncul di kata itu, Anda tidak perlu mengeluarkan apa pun untuk itu.

Uji Kasus

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"

Mencetak gol

Pengajuan terpendek yang valid untuk setiap bahasa menang, ini adalah kode-golf . Semoga berhasil dan selamat bersenang - senang!

_{Kotak pasir bagi mereka yang dapat melihat posting yang dihapus.}

Haskell, 59 byte

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

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

Cobalah online!

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

Dan penjelasannya:

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

Cobalah online!

Penjelasan

Itu adalah terjemahan langsung dari masalahnya:

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

Cobalah online!

Penjelasan

/....
\...@/

Ini hanya kerangka kerja untuk kode linier dalam Ordinal (mode pemrosesan string). Membuka program, kita mendapatkan:

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

Inilah fungsinya:

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

Uji kasus

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 kode + 2 untuk -pa.

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

Cobalah 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

Coba di sini

Penjelasan:

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

Saya dapat memiliki 18 byte jika bukan untuk string kosong:

_sm<dl@"aeiou"rd0c

Pyth, 31

Butuh waktu lama untuk menulis, dan saya merasa mungkin ada pendekatan yang lebih baik, tetapi inilah yang saya miliki:

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

Tes 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

Penjelasan

• Pertama input (implisit) dibagi pada spasi oleh z.
• Kemudian loop foreach dimulai ( :) dengan itu terkait kode kunci αv_K_σh.
  • av mendorong aeiou
  • _ mendorong elemen iterated saat ini
  • Kmenghitung kejadian aeioudi_
  • _ elemen lagi
  • σhPisahkan elemen menjadi irisan panjang occurencesdan ambil elemen pertama.
    • Secara efektif ini membutuhkan occurenceskarakter pertama
• 0J Dorong tumpukan bergabung ''
  • Ini 0perlu karena membutuhkan argumen yang akan digabung. Jika argumen itu bukan array, ia bergabung dengan stack
• R membalikkan hasilnya
• cetak implisit dari KL

Ruby , 54 59 + 1 = 55 60 byte

Menggunakan -pbendera untuk +1 byte.

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

Cobalah online!

Japt v2.0a0, 12 10 byte

¸®¯Zè\vìw

Cobalah

Penjelasan

Cukup banyak persis apa yang dijelaskan spec!

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

Jelly , 12 byte

ḲµfØcLḣ@µ€FU

Cobalah online!

05AB1E , 14 byte

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

Cobalah online!

Darn 05AB1E tidak ada bawaan untuk 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^$`.

Cobalah online! Tautan termasuk test suite. Penjelasan: Ini adalah aplikasi dari kelompok penyeimbang .NET. Lookahead mencari kata untuk vokal, yang ditangkap dalam grup 2. Grup kemudian muncul saat setiap huruf dicocokkan, sehingga menangkap jumlah huruf yang sama dengan jumlah vokal dalam kata. Sisa kata dan spasi tambahan apa pun kemudian diabaikan sehingga prosesnya dapat dimulai lagi dengan kata berikutnya. Akhirnya surat-surat yang tersisa dibalik.

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

Cobalah online!

Bagian terburuknya adalah membalikkan a stringdi C # mengembalikan IEnumerable<char>yang harus Anda konversi kembali menjadi a string.

PHP , 96 byte

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

Cobalah online!

Python 3 , 83 81 79 77 byte

• Tn. Xcoder menyimpan 2 byte
• Griffin menyimpan 2 byte: Beralih dari Python 3 ke 2
• disimpan 2 byte: penggunaan lambda

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

Cobalah online!

Java 8 , 171 151 byte

-20 byte berkat @Lukas Rotter

Saya merasa masih perlu bermain golf ... beri tahu saya di komentar jika Anda punya saran.

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

Cobalah online!

k, 33 byte

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

Cobalah online!

Common Lisp, 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)))))

Penjelasan

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

sed disebut dengan -Eflag, yang tampaknya berarti saya menambahkan satu byte.
_{Catatan: Saya belum benar-benar mencoba golf ini.}

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

Cobalah online!

Clojure, 96 94 byte

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

Yah panjang ini cukup konyol. mapcatmenyimpan dua byte.

Cepat 3, 240 byte

Ini adalah fungsi yang bisa digunakan f(s:"Input"). Anehnya, saya tidak berpikir itu bisa bermain golf lebih lanjut:

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

Cobalah di IBM Sandbox!