Cho một chuỗi làm đầu vào, xuất chuỗi với thuật toán sau được áp dụng:

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"

Thông số kỹ thuật

• Bạn có thể nhận đầu vào và cung cấp đầu ra theo bất kỳ dạng chuẩn nào và loại dữ liệu duy nhất được phép cho cả Đầu vào và Đầu ra là loại Chuỗi gốc của ngôn ngữ của bạn. Lấy đầu vào trực tiếp như một danh sách các từ riêng lẻ không được phép.

• Bạn được đảm bảo rằng sẽ không có không gian liên tiếp.

• Nguyên âm là "a","e","i","o","u","A","E","I","O","U", nhưng "y","Y" không được coi là nguyên âm .

• Bạn được đảm bảo rằng chỉ có các chữ cái và dấu cách sẽ xuất hiện trong đầu vào, nhưng không có bất kỳ dòng mới nào.

• Đầu ra phải phân biệt chữ hoa chữ thường.

• Bạn không được đảm bảo rằng mỗi từ có chứa một nguyên âm. Nếu không có nguyên âm xuất hiện trong từ đó, bạn không phải xuất bất cứ thứ gì cho từ đó.

Các trường hợp thử nghiệm

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"

Chấm điểm

Bài nộp hợp lệ ngắn nhất cho mỗi ngôn ngữ sẽ thắng, đây là môn đánh gôn . Chúc may mắn và vui vẻ!

_{Sandbox cho những người có thể xem bài viết đã bị xóa.}

Haskell, 59 byte

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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

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

Và giải thích:

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

Hãy thử trực tuyến!

Giải trình

Đó là bản dịch trực tiếp của vấn đề:

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

Hãy thử trực tuyến!

Giải trình

/....
\...@/

Đây chỉ là một khung cho mã tuyến tính trong Ordinal (chế độ xử lý chuỗi). Mở ra chương trình, chúng tôi nhận được:

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

Đây là những gì nó làm:

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

Các trường hợp thử nghiệm

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

Mã 45 byte + 2 cho -pa.

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

Hãy thử trực tuyến!

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

Hãy thử nó ở đây

Giải trình:

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

Tôi có thể có 18 byte nếu không có chuỗi trống:

_sm<dl@"aeiou"rd0c

Bình thường, 31

Điều này khiến tôi mất nhiều thời gian để viết và tôi cảm thấy có lẽ có một cách tiếp cận tốt hơn, nhưng đây là những gì tôi có:

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

Kiểm tra trực tuyến .

                             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 byte

z:αv_K_σh;0JR

Giải trình

• Đầu tiên, đầu vào (ẩn) được phân chia trên khoảng trắng bởi z.
• Sau đó, một vòng lặp foreach được bắt đầu ( :) với mã cơ sở được liên kết αv_K_σh.
  • av đẩy aeiou
  • _ đẩy phần tử lặp hiện tại
  • Kđếm lần xuất hiện của aeioutrong_
  • _ yếu tố một lần nữa
  • σhChia phần tử thành các lát có độ dài occurencesvà lấy phần tử đầu tiên.
    • Hiệu quả này có occurenceský tự đầu tiên
• 0J Đẩy ngăn xếp tham gia vào ''
  • Điều 0này là cần thiết bởi vì nó đòi hỏi một đối số sẽ được tham gia. Nếu đối số đó không phải là một mảng, nó tham gia ngăn xếp
• R đảo ngược kết quả
• in ngầm của ĐKDV

Ruby , 54 59 + 1 = 55 60 byte

Sử dụng -pcờ cho byte 1.

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

Hãy thử trực tuyến!

Japt v2.0a0, 12 10 byte

¸®¯Zè\vìw

Thử nó

Giải trình

Khá nhiều làm chính xác những gì thông số kỹ thuật mô tả!

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

Thạch , 12 byte

ḲµfØcLḣ@µ€FU

Hãy thử trực tuyến!

05AB1E , 14 byte

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

Hãy thử trực tuyến!

Darn 05AB1E không tích hợp sẵn cho AEIOUaeiou _ಠ

Toán học, 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]}]])&

Võng mạc , 49 46 byte

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

Hãy thử trực tuyến! Liên kết bao gồm bộ kiểm tra. Giải thích: Đây là một ứng dụng của các nhóm cân bằng của .NET. Lookahead tìm kiếm từ cho nguyên âm, được bắt trong nhóm 2. Sau đó, nhóm được bật lên khi mỗi chữ cái được khớp, do đó nắm bắt số lượng chữ cái bằng số nguyên âm trong từ. Phần còn lại của từ và bất kỳ dấu cách nào sau đó được bỏ qua để quá trình có thể bắt đầu lại với từ tiếp theo. Cuối cùng các chữ cái còn lại được đảo ngược.

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

Hãy thử trực tuyến!

Phần tồi tệ nhất là việc đảo ngược a stringtrong C # trả về a IEnumerable<char>mà bạn phải chuyển đổi trở lại thành a string.

PHP , 96 byte

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

Hãy thử trực tuyến!

Python 3 , 83 81 79 77 byte

• Ông Xcoder đã lưu 2 byte
• Griffin đã lưu 2 byte: Chuyển từ Python 3 sang 2
• đã lưu 2 byte: sử dụng lambda

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

Hãy thử trực tuyến!

Java 8 , 171 151 byte

-20 byte nhờ Công cụ quay vòng @Lukas

Tôi cảm thấy như nó vẫn cần chơi gôn ... hãy cho tôi biết trong các bình luận nếu bạn có bất kỳ đề xuất nào.

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

Hãy thử trực tuyến!

k, 33 byte

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

Hãy thử trực tuyến!

Lisp thông thường, 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)))))

Giải trình

(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 được gọi với -Ecờ, có nghĩa là tôi thêm một byte.
_{Lưu ý: Tôi chưa thực sự cố gắng chơi golf này.}

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

Hãy thử trực tuyến!

Clojure, 96 94 byte

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

Vâng chiều dài này là khá vô lý. mapcatlưu hai byte.

Swift 3, 240 byte

Đây là một chức năng có thể được sử dụng với f(s:"Input"). Đáng ngạc nhiên, tôi không nghĩ rằng nó có thể được chơi gôn hơn nữa:

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

Hãy dùng thử tại IBM Sandbox!