문자열을 입력으로 받으면 다음 알고리즘이 적용된 문자열을 출력하십시오.

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"

채점

각 언어에 대한 가장 짧은 유효한 제출이 이기고 code-golf 입니다. 행운을 빌고 재미있게 보내!

_{삭제 된 게시물을 볼 수있는 사용자를위한 샌드 박스}

하스켈, 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

Brachylog , 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"

펄 6 , 57 바이트

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

Alice , 32 바이트

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

온라인으로 사용해보십시오!

설명

/....
\...@/

이것은 서수 (문자열 처리 모드)에서 선형 코드의 프레임 워크 일뿐입니다. 프로그램을 전개하면 다음과 같은 이점이 있습니다.

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.

자바 스크립트 (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"

펄 5, 47 바이트

45 바이트 코드 + 2 -pa.

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

온라인으로 사용해보십시오!

자바 스크립트 (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

온라인으로 사용해보십시오!

apt 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는 AEIOU를위한 내장 기능이 없습니다.

수학, 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 밸런싱 그룹의 응용 프로그램입니다. lookahead는 그룹 2에서 캡처 된 모음에 대해 단어를 검색합니다. 그러면 각 문자가 일치 할 때 그룹이 팝업되어 단어의 모음 수와 같은 문자 수를 캡처합니다. 그런 다음 나머지 단어와 후행 공백은 무시되어 프로세스가 다음 단어로 다시 시작할 수 있습니다. 마지막으로 나머지 글자가 바뀝니다.

C # (. NET 코어) 144 바이트

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

온라인으로 사용해보십시오!

최악의 부분은 stringC #에서 a를 뒤집 으면 a IEnumerable<char>로 다시 변환해야한다는 것을 반환 한다는 것 string입니다.

PHP , 96 바이트

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

온라인으로 사용해보십시오!

파이썬 3 , 83 81 79 77 바이트

• Mr. Xcoder 가 2 바이트를 절약했습니다
• 그리핀 2 바이트 절약 : 파이썬 3에서 2로 전환
• 2 바이트 저장 : 람다 사용

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

온라인으로 사용해보십시오!

자바 8 ,171 151 bytes

@Lukas Rotter 덕분에 -20 바이트

아직 골프가 필요한 것 같습니다. 의견이 있으시면 의견에 알려주십시오.

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플래그 와 함께 호출되며 분명히 1 바이트를 추가한다는 것을 의미합니다.
_{참고 : 아직 골프를 시도하지 않았습니다.}

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

온라인으로 사용해보십시오!

클로저, 96 94 바이트

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

이 길이는 꽤 말도 안됩니다. mapcat2 바이트를 저장했습니다.

스위프트 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에서 사용해보십시오!