Biorąc pod uwagę ciąg wejściowy, wyślij ciąg przy użyciu następującego algorytmu:

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"

Okular

• Możesz pobierać dane wejściowe i dostarczać dane wyjściowe w dowolnej standardowej formie , a jedynym typem danych dozwolonym zarówno dla danych wejściowych, jak i wyjściowych jest rodzimy typ łańcucha w Twoim języku. Bezpośrednie wprowadzanie danych jako listy pojedynczych słów jest niedozwolone.

• Masz gwarancję, że nie będzie kolejnych spacji.

• Samogłoski są "a","e","i","o","u","A","E","I","O","U", ale "y","Y" nie są uważane za samogłoski .

• Masz gwarancję, że na wejściu pojawią się tylko litery i spacje, ale bez żadnych znaków nowej linii.

• Wyjście musi być rozróżniana.

• Nie ma gwarancji, że każde słowo zawiera samogłoskę. Jeśli w tym słowie nie ma samogłosek, nie musisz nic dla niego wypisywać.

Przypadki testowe

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"

Punktacja

Wygrywa najkrótszy ważny zgłoszenie dla każdego języka, to jest golf golfowy . Powodzenia i miłej zabawy!

_{Piaskownica dla tych, którzy widzą usunięte posty.}

Haskell, 59 bajtów

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

Wypróbuj 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 bajtów

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

Wypróbuj online!

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

I wyjaśnienie:

Í               " 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 bajtów

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

Wypróbuj online!

Wyjaśnienie

To bezpośrednie tłumaczenie problemu:

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 bajtów

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

Alice , 32 bajty

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

Wypróbuj online!

Wyjaśnienie

/....
\...@/

To tylko struktura dla kodu liniowego w Ordinal (tryb przetwarzania łańcucha). Po rozwinięciu programu otrzymujemy:

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

Oto, co robi:

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 bajtów

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

Przypadki testowe

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 bajtów

Kod 45 bajtów + 2 dla -pa.

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

Wypróbuj online!

JavaScript (ES6), 96 bajtów

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 bajtów

_jkm<dl@"aeiou"rd0c

Wypróbuj tutaj

Wyjaśnienie:

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

Mógłbym mieć 18 bajtów, gdyby nie pusty ciąg:

_sm<dl@"aeiou"rd0c

Pyth, 31

Zajęło mi to dużo czasu i wydaje mi się, że istnieje prawdopodobnie lepsze podejście, ale oto, co mam:

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

Test 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 bajtów

z:αv_K_σh;0JR

Wyjaśnienie

• Najpierw (niejawne) dane wejściowe są dzielone na spacje przez z.
• Następnie uruchamiana jest pętla foreach ( :) z powiązanym blokiem kodu αv_K_σh.
  • av popycha aeiou
  • _ wypycha bieżący iterowany element
  • Kzlicza wystąpienia aeiouw_
  • _ element ponownie
  • σhDzieli element na plasterki długości occurencesi bierze pierwszy element.
    • Skutecznie zajmuje to pierwsze occurencesznaki
• 0J Wpycha połączony stos ''
  • Jest 0to konieczne, ponieważ wymaga argumentu, który zostanie dołączony. Jeśli ten argument nie jest tablicą, dołącza się do stosu
• R odwraca wynik
• niejawny wydruk warunków świadczenia usługi

Rubinowy , 54 59 + 1 = 55 60 bajtów

Używa -pflagi dla bajtu +1.

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

Wypróbuj online!

Japt v2.0a0, 12 10 bajtów

¸®¯Zè\vìw

Spróbuj

Wyjaśnienie

Prawie robi dokładnie to, co opisuje specyfikacja!

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

Galaretka , 12 bajtów

ḲµfØcLḣ@µ€FU

Wypróbuj online!

05AB1E , 14 bajtów

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

Wypróbuj online!

Darn 05AB1E nie ma wbudowanego AEIOUaeiou ಠ_ಠ

Mathematica, 145 bajtów

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

Siatkówka , 49 46 bajtów

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

Wypróbuj online! Link zawiera pakiet testowy. Objaśnienie: Jest to aplikacja grup równoważących platformy .NET. Lookahead szuka słowa w celu znalezienia samogłosek, które są przechwytywane w grupie 2. Grupa jest następnie wyskakująca, gdy każda litera jest dopasowywana, przechwytując w ten sposób liczbę liter równą liczbie samogłosek w słowie. Reszta słowa i końcowe spacje są następnie ignorowane, aby proces mógł rozpocząć się ponownie od następnego słowa. Na koniec pozostałe litery są odwrócone.

C # (.NET Core) , 144 bajty

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

Wypróbuj online!

Najgorsze jest to, że odwrócenie a stringw C # zwraca wartość, IEnumerable<char>którą musisz przekonwertować z powrotem na a string.

PHP , 96 bajtów

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

Wypróbuj online!

Python 3 , 83 81 79 77 bajtów

• Pan Xcoder zapisał 2 bajty
• Griffin zapisał 2 bajty: Przełącz z Python 3 na 2
• zapisane 2 bajty: użycie lambda

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

Wypróbuj online!

Java 8 , 171 151 bajtów

-20 bajtów dzięki @Lukas Rotter

Wydaje mi się, że nadal wymaga gry w golfa ... daj mi znać w komentarzach, jeśli masz jakieś sugestie.

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

Wypróbuj online!

k, 33 bajtów

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

Wypróbuj online!

Common Lisp, 218 bajtów

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

Wyjaśnienie

(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) bajtów

sed jest wywoływany z -Eflagą, co najwyraźniej oznacza dodanie jednego bajtu.
_{Uwaga: Tak naprawdę jeszcze nie próbowałem grać w golfa.}

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

Wypróbuj online!

Clojure, 96 94 bajtów

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

Ta długość jest niedorzeczna. mapcatzapisane dwa bajty.

Swift 3, 240 bajtów

Jest to funkcja, której można używać z f(s:"Input"). Zaskakujące, nie sądzę, że można go dalej grać w golfa:

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

Wypróbuj w IBM Sandbox!