Bir dize girdi olarak verildiğinde, şu algoritmayı uygulayarak dizeyi çıktılayın:

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"

gözlük

• Herhangi bir standart forma göre girdi alıp çıktı sağlayabilirsiniz ve hem Girdi hem de Çıktı için izin verilen tek veri türü dilinizin yerel Dize türüdür. Girişi doğrudan tek tek kelimelerin listesi olarak kabul etmek yasaktır.

• Art arda boşluk olmayacağı garanti edilir.

• Ünlüler "a","e","i","o","u","A","E","I","O","U", ancak ünlü olarak "y","Y" kabul edilmezler .

• Girişte yalnızca harfler ve boşluklar görünecek, ancak herhangi bir satırsonu bulunmayacaksınız.

• Çıktı büyük / küçük harfe duyarlı olmalıdır .

• Her kelimenin bir sesli harf içerdiği garanti edilmez. Bu kelimede sesli harf görünmüyorsa, bunun için hiçbir şey çıkarmanız gerekmez.

Test Durumları

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"

puanlama

Her dil için en kısa geçerli gönderim kazanır, bu kod golfüdür . İyi şanslar ve iyi eğlenceler!

_{Sandbox silinen yayınları görebilir olanlar için.}

Haskell, 59 bayt

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

Çevrimiçi deneyin!

       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 bayt

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

Çevrimiçi deneyin!

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

Ve açıklama:

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

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

Çevrimiçi deneyin!

açıklama

Bu sorunun doğrudan çevirisi:

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 bayt

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

Alice , 32 bayt

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

Çevrimiçi deneyin!

açıklama

/....
\...@/

Bu sadece Ordinal (dize işleme modu) doğrusal kod için bir çerçevedir. Programı açarken:

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

İşte yaptığı şey:

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 bayt

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

Test senaryoları

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 bayt

45 bayt kodu + 2 için -pa.

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

Çevrimiçi deneyin!

JavaScript (ES6), 96 bayt

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 bayt

_jkm<dl@"aeiou"rd0c

Burada deneyin

Açıklama:

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

Boş dize için değilse 18 bayt olabilir:

_sm<dl@"aeiou"rd0c

Pyth, 31

Bu, yazmak için uzun zamanımı aldı ve muhtemelen daha iyi bir yaklaşım varmış gibi hissediyorum, ama işte sahip olduğum şey:

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

Çevrimiçi test .

                             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 bayt

z:αv_K_σh;0JR

açıklama

• İlk olarak (örtük) girdi boşluklar tarafından bölünür z.
• Sonra bir foreach döngüsü ( :) ile ilişkili codeblock varlık başlar αv_K_σh.
  • av iter aeiou
  • _ geçerli yinelenen öğeyi iter
  • Ktekrarlarını sayar aeiouin_
  • _ eleman tekrar
  • σhElemanı uzunluk dilimlerine böler occurencesve ilk elemanı alır.
    • Etkili bir şekilde bu ilk occurenceskarakterleri alır
• 0J Birleştirilmiş yığını iter ''
  • Bu 0gereklidir çünkü birleştirilecek bir argüman gerektirir. Bu bağımsız değişken bir dizi değilse yığına katılır
• R sonucu tersine çevirir
• Hizmet Şartlarının örtülü baskısı

Yakut , 54 , 59 + 1 = 55 60 bayt

-p+1 baytlık bayrağını kullanır .

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

Çevrimiçi deneyin!

Japt v2.0a0, 12 10 bayt

¸®¯Zè\vìw

Dene

açıklama

Spesifikasyonun tam olarak ne yaptığını yapıyor!

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

Jöle , 12 bayt

ḲµfØcLḣ@µ€FU

Çevrimiçi deneyin!

05AB1E , 14 bayt

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

Çevrimiçi deneyin!

Darn 05AB1E, AEIOUaeiou ಠ_ಠ için yerleşik değil

Mathematica, 145 bayt

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

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

Çevrimiçi deneyin! Bağlantı test paketini içerir. Açıklama: Bu, .NET'in dengeleme gruplarının bir uygulamasıdır. İlerleme sözcüğü, grup 2'de yakalanan sesli harfleri arar. Grup daha sonra her harf eşleştikçe açılır ve böylece sözcükteki ünlü sayısına eşit olan harf sayısını yakalar. Sözcüğün geri kalanı ve herhangi bir sondaki boşluk daha sonra göz ardı edilir, böylece işlem bir sonraki sözcükle yeniden başlayabilir. Sonunda kalan harfler ters çevrilir.

C # (.NET Core) , 144 bayt

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

Çevrimiçi deneyin!

En kötü yanı, bir stringC # 'a IEnumerable<char>geri döndürmek için a dönüştürmek zorunda bir döndürür string.

PHP , 96 bayt

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

Çevrimiçi deneyin!

Python 3 , 83 81 79 77 bayt

• Bay Xcoder 2 bayt kurtardı
• Griffin 2 bayt kurtardı: Python 3'ten 2'ye geçin
• 2 bayt kaydedildi: lambda kullanımı

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

Çevrimiçi deneyin!

Java 8 , 171151 bayt

@Lukas Rotter sayesinde -20 bayt

Hala golf ihtiyacı gibi hissediyorum ... herhangi bir öneriniz varsa yorumlarda bana bildirin.

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

Çevrimiçi deneyin!

k, 33 bayt

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

Çevrimiçi deneyin!

Ortak Lisp, 218 bayt

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

açıklama

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

sed -Ebayrağı ile çağrılır , yani görünüşe göre bir bayt ekliyorum.
_{Not: Henüz golf oynamaya çalışmadım.}

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

Çevrimiçi deneyin!

Clojure, 96 94 bayt

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

Bu uzunluk oldukça saçma. mapcatiki bayt kaydetti.

Swift 3, 240 bayt

Bu, ile kullanılabilen bir işlevdir f(s:"Input"). Şaşırtıcı bir şekilde, daha fazla golf oynayabileceğini sanmıyorum:

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'ta deneyin!