Étant donné une chaîne en entrée, sortez la chaîne avec l'algorithme suivant appliqué:

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"

Spécifications

• Vous pouvez prendre des entrées et fournir des sorties sous n'importe quelle forme standard , et le seul type de données autorisé pour Input et Output est le type String natif de votre langue. Il n'est pas permis de saisir directement une liste de mots individuels.

• Vous avez la garantie qu'il n'y aura pas d'espaces consécutifs.

• Les voyelles sont "a","e","i","o","u","A","E","I","O","U", mais "y","Y" ne sont pas considérées comme des voyelles .

• Vous avez la garantie que seules les lettres et les espaces apparaîtront dans l'entrée, mais sans aucune nouvelle ligne.

• La sortie doit être sensible à la casse.

• Vous n'êtes pas assuré que chaque mot contient une voyelle. Si aucune voyelles n'apparaissent dans ce mot, vous n'avez rien à produire pour cela.

Cas de test

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"

Notation

La soumission valide la plus courte pour chaque langue gagne, c'est le code-golf . Bonne chance et amusez-vous bien!

_{Sandbox pour ceux qui peuvent voir les messages supprimés.}

Haskell, 59 octets

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

Essayez-le en ligne!

       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 octets

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

Essayez-le en ligne!

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

Et explication:

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

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

Essayez-le en ligne!

Explication

C'est une traduction directe du problème:

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 octets

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

Alice , 32 octets

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

Essayez-le en ligne!

Explication

/....
\...@/

Ceci est juste un cadre pour le code linéaire en Ordinal (mode de traitement de chaîne). En déroulant le programme, nous obtenons:

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

Voici ce qu'il fait:

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 octets

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

Cas de test

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 octets

Code de 45 octets + 2 pour -pa.

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

Essayez-le en ligne!

JavaScript (ES6), 96 octets

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 octets

_jkm<dl@"aeiou"rd0c

Essayez-le ici

Explication:

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

Je pourrais avoir 18 octets sinon pour la chaîne vide:

_sm<dl@"aeiou"rd0c

Pyth, 31

Cela m'a pris du temps à écrire, et j'ai l'impression qu'il y a probablement une meilleure approche, mais voici ce que j'ai:

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

Test en ligne .

                             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 octets

z:αv_K_σh;0JR

Explication

• D'abord, l'entrée (implicite) est divisée sur les espaces par z.
• Ensuite, une boucle foreach est lancée ( :) avec son bloc de code associé αv_K_σh.
  • av pousse aeiou
  • _ pousse l'élément itéré actuel
  • Kcompte les occurrences de aeioudans_
  • _ l'élément à nouveau
  • σhDivise l'élément en tranches de longueur occurenceset prend le premier élément.
    • Effectivement, cela prend les premiers occurencescaractères
• 0J Pousse la pile jointe ''
  • Le 0est nécessaire car il nécessite un argument qui sera joint. Si cet argument n'est pas un tableau, il rejoint la pile
• R inverse le résultat
• impression implicite des CGU

Rubis , 54 59 + 1 = 55 60 octets

Utilise l' -pindicateur pour +1 octet.

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

Essayez-le en ligne!

Japt v2.0a0, 12 10 octets

¸®¯Zè\vìw

Essayez-le

Explication

Fait à peu près exactement ce que la spécification décrit!

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

Gelée , 12 octets

ḲµfØcLḣ@µ€FU

Essayez-le en ligne!

05AB1E , 14 octets

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

Essayez-le en ligne!

Darn 05AB1E n'a pas intégré pour AEIOUaeiou ಠ_ಠ

Mathematica, 145 octets

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

Rétine , 49 46 octets

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

Essayez-le en ligne! Le lien inclut une suite de tests. Explication: il s'agit d'une application des groupes d'équilibrage de .NET. La tête de recherche recherche le mot pour les voyelles, qui sont capturées dans le groupe 2. Le groupe est ensuite sauté lorsque chaque lettre est appariée, capturant ainsi le nombre de lettres égal au nombre de voyelles dans le mot. Le reste du mot et tout espace de fin sont ensuite ignorés afin que le processus puisse recommencer avec le mot suivant. Enfin, les lettres restantes sont inversées.

C # (.NET Core) , 144 octets

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

Essayez-le en ligne!

Le pire, c'est qu'inverser un stringen C # renvoie un IEnumerable<char>que vous devez reconvertir en a string.

PHP , 96 octets

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

Essayez-le en ligne!

Python 3 , 83 81 79 77 octets

• M. Xcoder a enregistré 2 octets
• Griffin a économisé 2 octets: passer de Python 3 à 2
• économisé 2 octets: utilisation de lambda

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

Essayez-le en ligne!

Java 8 , 171 151 octets

-20 octets grâce à @Lukas Rotter

J'ai l'impression qu'il faut encore du golf ... faites le moi savoir dans les commentaires si vous avez des suggestions.

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

Essayez-le en ligne!

k, 33 octets

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

Essayez-le en ligne!

Lisp commun, 218 octets

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

Explication

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

sed est appelé avec le -Edrapeau, ce qui signifie apparemment que j'ajoute un octet.
_{Remarque: je n'ai pas encore vraiment essayé de jouer au golf.}

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

Essayez-le en ligne!

Clojure, 96 94 octets

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

Eh bien, cette longueur est assez ridicule. mapcatenregistré deux octets.

Swift 3, 240 octets

C'est une fonction qui peut être utilisée avec f(s:"Input"). Étonnamment, je ne pense pas qu'il puisse être joué plus loin:

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

Essayez-le chez IBM Sandbox!