Подавши рядок у якості введення, виведіть рядок із застосуванням наступного алгоритму:

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"

Технічні характеристики

• Ви можете приймати введення та надати вихід у будь-якій стандартній формі , і єдиний тип даних, дозволений як для введення, так і для виводу, - це рідний тип рядка вашої мови. Введення даних безпосередньо як списку окремих слів заборонено.

• Вам гарантовано, що не буде пробілів поспіль.

• Голосні є "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"

Оцінка балів

Найкоротше дійсне подання для кожної мови виграє, це код-гольф . Хай щастить!

_{Пісочниця для тих, хто може бачити видалені публікації.}

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

Брахілог , 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підраховує події aeiouв_
  • _ елемент знову
  • σ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?

Спробуйте в Інтернеті!

Darn 05AB1E не має вбудованого для AEIOUaeiou ಠ_ಠ

Математика, 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, 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 байт

• Містер Xcoder врятував 2 байти
• Гриффін врятував 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 байт

-20 байт завдяки @Lukas Rotter

Я відчуваю, що це все ще потребує гольфу ... повідомте мені у коментарях, якщо у вас є якісь пропозиції.

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

Спробуйте в Інтернеті!

Лист звичайний, 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!