Le programme doit prendre une chaîne en tant qu'entrée et inverser les consonnes qu'il contient tout en conservant l'ordre des voyelles. Toutes les lettres seront en minuscules, vous n’avez donc pas à vous soucier de la casse. Des exemples suivent.

1. Entrée: a test case.
   Les consonnes ici sont t,s,t,c,s. Ils devraient venir dans l' ordre inverse, à savoir s,c,t,s,tet à l' arrière inséré dans la chaîne aux mêmes positions où les caractères inversés pré-ont été trouvés: a sect sate.

2. Entrée: well-done. Sortie: nedl-lowe.

3. Entrée: reverse the consonants. Sortie: setenne sne cohtosarvr.

C'est le code golf, la solution la plus courte l'emporte.

Y devrait être considéré comme une voyelle, peu importe de quoi il s'agit et non inversé.

N'importe quel élément, ainsi que des chiffres, des signes de ponctuation, des guillemets et d'autres symboles ( @#$%^&*(){}[]\|/<>~-_+=`), pourrait éventuellement apparaître dans l'entrée.

Rétine, 22 21 20 17

O#^`[b-z-[eiouy]]

Essayez-le en ligne!

1 octet grâce à Leaky Nun!

4 octets merci à Martin!

Osignifie trier et #signifie trier par valeur numérique. Etant donné qu'aucun des caractères correspondants n'aura jamais de valeur numérique, toutes les lettres ont le même poids: 0. ^signifie inverser l'ordre des valeurs triées, ce qui, grâce à un tri stable, signifie que les valeurs sont inversées.

Le -[...]moyen de faire la différence entre la classe de caractères externe et cette classe interne. Cela fait partie de .NET et vous pouvez en lire plus sur MSDN .

Python 2, 86 octets

s='';c=()
for x in input():b='{'>x not in'aeiouy'<x;s+=b*'%s'or x;c=(x,)*b+c
print s%c

Prend l'entrée sous forme de chaîne entre guillemets. Itère dans l'entrée en remplaçant chaque consonne par %sdans s. Le tuple cstocke les consonnes rencontrées dans l'ordre inverse. Ensuite, le formatage des chaînes remplace le %s's spar les consonnes de c.

Merci à Sp3000 pour la vérification des consonnes, qui a économisé 4 octets sur la liste des consonnes.

Gelée , 22 à 20 octets

Øaḟ“<1Ṛż»
e€¢œpżf¢Ṛ$

Essayez-le en ligne!

Comment ça marche

Øaḟ“<1Ṛż»   Helper link. No arguments.

Øa          Yield the lowercase alphabet/
   “<1Ṛż»   Decompress that string, yielding "oui aye".
  ḟ         Filter; remove the characters from the right string from the left one.


e€¢œpżf¢Ṛ$  Main link. Argument: s (string)

  ¢         Call the helper link, yielding the string of all consonants.
e€          Test each character of s for membership.
   œp       Partition s at members/consonants.
         $  Combine the three links to the left into a monadic chain.
      f¢    Filter by presence in the consonant string.
        Ṛ   Reverse the result.
     ż      Zipwith; interleave chunks of non-consonants and reversed consonants.

JavaScript ES6, 82 81 80 78 octets

A sauvé un octet à chacun de Martin et Leaky Nun, et 2 octets à Neil!

a=>a.replace(r=/(?[_aeiouy])\w/g,e=>[...a].reverse().join``.match(r)[i++],i=0)

Essai

f=
a=>a.replace(r=/(?![aeiouy])[a-z]/g,e=>[...a].reverse().join``.match(r)[i++],i=0)
;
q.onchange=q.onkeydown=q.onkeyup=function(){
  o.innerHTML = "";
  o.appendChild(document.createTextNode(f(q.value)));
}

*{font-family:Consolas,monospace;}

<input autocomplete="off" id=q>
<div id=o></div>

Python 2, 106 octets

s=input()
b=[x for x in s if x in'bcdfghjklmnpqrstvwxz']*2
print''.join(x in b and b.pop()or x for x in s)

Attend une entrée "quotes", ce qui, je pense, est autorisé.

Pyke, 18 octets

FD~c{IK_#~c{)oR@(s

Essayez-le ici!

ou 16 octets avec la nouvelle version:

(Modifiez donc si, pour renvoie la totalité de la sortie de chaîne et avait une entrée de chaîne, renvoie chaîne au lieu d'une liste)

FD~c{IK_#~c{)oR@

Essayez-le ici!

~c contient les consonnes: bcdfghjklmnpqrstvwxz

F                - For i in input:
  ~c{I           -  if i in "bcdfghjklmnpqrstvwxz":
       _#~c{)    -    filter(reversed(input), <-- in "bcdfghjklmnpqrstvwxz")
             oR@ -   ^[o++]

GNU sed, 73

Le score inclut +1 pour le -rdrapeau passé à sed.

:
s/([b-df-hj-np-tv-xz])(.*)([b-df-hj-np-tv-xz])/\u\3\2\u\1/
t
s/./\l&/g

Idéone.

Commute à plusieurs reprises la première et la dernière consonne minuscule et les convertit en majuscules jusqu'à ce qu'il n'y ait plus de correspondance. Reconvertissez ensuite la chaîne entière en minuscule.

J, 53 octets

C.~[:~.<@~.@/:~"1@(,.|.)@I.@e.&'bcdfghjklmnpqrstvwxz'

Peut-être que ce n'est pas la meilleure façon, mais je voulais utiliser C.car cela peut être résolu en utilisant des permutations.

Usage

   f =: C.~[:~.<@~.@/:~"1@(,.|.)@I.@e.&'bcdfghjklmnpqrstvwxz'
   f 'a test case'
a sect sate
   f 'well-done'
nedl-lowe
   f 'reverse the consonants'
setenne sne cohtosarvr

Explication

C.~[:~.<@~.@/:~"1@(,.|.)@I.@e.&'...'  Input: s
                               '...'  The list of consonants
                            e.&'...'  Generate a boolean mask where an index is true
                                      if the char at that index in s is a consonant
                         I.@          Get a list of the true indices
                  (  |.)@             Reverse that list
                  (,.  )@             Join the original and reversed list as columns
            /:~"1@                    Sort each row of that 2d list
         ~.@                          Take the distinct values in each row
       <@                             Box them
   [:~.                               Take the distinct boxes - Now represents the
                                      permutation needed to solve this in cycle notation
C.~                                   Permute s according the cycles and return

MATL, 18 22 21 octets

tt2Y211Y2'y'hX-m)P5M(

1 octet enregistré grâce à @Luis

Malheureusement, la partie la plus longue de ceci est d'obtenir la liste des consonnes ( 2Y211Y2'y'hX-).

Essayez-le en ligne!

Explication

            % Implicitly grab the input
tt          % Duplicate twice
2Y2         % Grab the pre-defined list of all lower-case letters
llY2        % Grab the pre-defined list of lower-case vowels (excluding 'y')
'y'h        % Add 'y' to the list of vowels
X-          % Find the set difference between these two lists (the consonants)
m           % Create a boolean array the size of the input that is true for all consonants
)           % Use this as an index to grab all consonants
P           % Reverse the order of the consonants
5M          % Get the boolean array again
(           % Re-assign the flipped consonants with the original consonant locations
            % Implicitly dislpay the result

Perl 5 (58 + 4 = 62 octets)

$_=<>;$r=qr/(?![eiouy])[b-z]/;@a=/$r/g;s/$r/pop@a/ge;print

Pénalité de +4 pour l'exécution avec -0777flag, qui définit Perl en mode slurp pour gérer correctement les nouvelles lignes.

Accepte les entrées via STDIN et imprime vers STDOUT.

Explication

                   $_=<>;   Read the input
 $r=qr/(?![eiouy])[b-z]/;   Save the regex; we'll be using it twice
                @a=/$r/g;   Store all the consonants in an array
           s/$r/pop@a/ge;   Replace each consonant with the final value in the array and pop
                   print    Output the result

JavaScript (ES6), 72 octets

s=>s.split(/([^\W\d_aeiouy])/).map((c,i,a)=>i&1?a[a.length+~i]:c).join``

Le fait de diviser les /([^\W\d_aeiouy])/résultats dans les consonnes tombant dans les entrées impaires du tableau. Il suffit ensuite de basculer ces entrées avec l'entrée équivalente comptant à partir de la fin du tableau et de joindre le résultat.

JavaScript (ES6), 57 70

Modifier 20% d'économies incroyables @Neil

En retard pour la fête, mais il semble que toutes les personnes en javascript ont oublié quelque chose

a=>a.replace(r=/[^\W\d_aeiouy]/g,_=>c.pop(),c=a.match(r))

Tester

f=a=>a.replace(r=/[^\W\d_aeiouy]/g,_=>c.pop(),c=a.match(r))

function test() {
  var i=I.value
  O.textContent=f(i)
}

test()

#I { width:90% }

<input id=I oninput="test()" value="reverse the consonants."><pre id=O></pre>

Perl 5, 92 68 55 octets

Sauvegardé 37 octets grâce à l 'aide de @manatwork . ;-)

$_=<>;@b=@a=/[^\Waeiou]/g;print$_~~@b?pop@a:$_ for/./g

Une traduction de la solution @Lynn Python en Perl.

Pyth, 26 25 24 23 octets

si: Q ++ \ [JG "aeiouy" \] 3_ @ J
JG "aeiouy" sm? @DJ @ _ @ JQ ~ hZ <- garder cela à cause du @ _ @
JG "aeiouy" sm? @ DJ @@ JQ = tZ
sm? @ dJ-G "aeiouy" @@ JQ = tZ
sm | -dJ-G "aeiouy" @@ JQ = tZ

Suite de tests.

Julia, 53 octets

!s=s[flipud(i)]=s[i=find(c->'}'>c∉"aeiouy"<"$c",s)]

Cela prend un tableau de caractères en entrée et inverse ses consonnes sur place. Essayez-le en ligne!

Le crédit va à @ Sp3000 pour le contrôle de consonne minuscule.

Comment ça marche

i=find(...,s)donne tous les indices de s pour lesquels le prédicat ... renvoie true et les enregistre dans la variable i .

c->'}'>c∉"aeiouy"<"$c"effectue trois tests et renvoie true si et seulement si tous sont positifs.

• '}'>cvérifie si le caractère c vient avant { .

• "aeiou"vérifie si la chaîne c vient après a .

• c∉"aeiouy"vérifie que c n'est pas une voyelle.

Enfin, s[i]donne toutes les consonnes et les s[flipud(i)]=s[i]affecte aux positions dans s qui correspondent aux indices inversés dans dans i .

Java, 319 305 261 188 octets

Nous remercions @ Leaky Nun pour son aide :-)

char[]r(char[]s){int i=0,j=0,n=s.length;char[]o=new char[n];for(;i<n;i++){if((s[i]+"").matches("(?![eiouy])[b-z]")){o[j++]=s[i];s[i]=65;}}for(i=0;i<n;i++)if(s[i]==65)s[i]=o[--j];return s;}

Vieux:

s(String p){int i=0,j=0;char[]s=p.toCharArray(),o=p.toCharArray();for(;i<s.length;i++){if(((s[i]+"").matches("[aeiouy @#$%^&*(){}\\[\\]\\|/\\\\<>~\\-_+=`]")))continue;o[j++]=(s[i]);s[i]='A';}for(i=0;i<s.length;i++)if(s[i]=='A')s[i]=o[--j];return new String(s);}

Inspiration prise d' ici ❤

Ungolfed

String s(String p){
    int i = 0, j = 0;
    char[]s=p.toCharArray(),o=p.toCharArray();
    for (;i<s.length;i++) {
        if (((s[i]+"").matches("[aeiouy @#$%^&*(){}\\[\\]\\|/\\\\<>~\\-_+=`]"))) continue;
        o[j++] = (s[i]); // Store the consonant into o
        s[i] = 'A'; // Put a special character in its place
    }
    for (i=0;i<s.length;i++)
        if (s[i] == 'A') // If special character
            s[i] = o[--j]; // Put back the consonant in reverse order
    return new String(s);
}

Ruby, 53 ans 50 octets

-3 octets de @manatwork

->s{i=0;s.gsub(r=/[^\Waeiouy_]/){s.scan(r)[i-=1]}}

Essayez ici

Python 2, 103 98 100 octets

import re
def r(s):a=re.split("([^\W\d_aeiouy])",s);print''.join(sum(zip(a[::2],a[-2::-2]+['']),()))

Port de ma réponse JavaScript. Edit: 5 octets enregistrés grâce à @ Dennis ♦, dont j'ai rapidement dû passer deux chiffres de réparation.

R, 120 octets

Nouvelle réponse:

az=function(x){
y=strsplit(x, NULL)[[1]]
a=regexpr("[bc-df-hj-np-tv-z]", y)
y[a==1]=rev(y[a==1])
paste(y, collapse="")
}

prend une chaîne de caractères comme x

az("reverse the consonants")
[1] "setenne sne cohtosarvr"

L'ancienne réponse ci-dessous (110 octets) était de mauvaise qualité de ma part, ce qui a simplement inversé les consonnes:

xrev=function(x){y=rev(strsplit(x, NULL)[[1]])
paste(y[is.na(match(y, c("a", "e","i","o","u","y")))], collapse="")}

APLX, 31 octets

(c/t)←⌽t/⍨c←(t←⍞)∊⎕a~'aeoiuy'
t

⎕a~'aeoiuy'alphabet en minuscule sans voyelles
t←⍞stocke la saisie de caractères sous la forme t
c←( … )∊store Boolean "consonant?" as c
t/⍨ extract (consonnes) de t
⌽ reverse
(c/t)←remplace les consonnes par (les inverses)
tretourne la chaîne modifiée

Python 2.7, 144 octets

def f(a):c='bcdfghjklmnpqrstvwxz';b=[x for x in list(a[::-1])if x in c];[b.insert(x,a[x])for x in range(len(a))if a[x]not in c];return''.join(b)

Cela construit d'abord une liste inversée des consonnes, puis insère chacun des autres caractères dans leur index d'origine.

Non-golfé:

s = 'well-done'
reverse = list(s[::-1])
consonants = [i for i in reverse if i in 'bcdfghjklmnpqrstvwxz']

for x in range(len(s)):
    if s[x] not in 'bcdfghjklmnpqrstvwxz':
        consonants.insert(x,s[x])

print(''.join(consonants))

https://repl.it/C30O

Mathematica 216 octets

Module[{h,v,i},v=Characters["aeiouy "];h[s_]:=SortBy[Flatten[Thread/@Transpose@{v,#[[All,1]]&/@(StringPosition[s,#]&/@v)},1],Last];i[s_,{a_,n_}]:=StringInsert[s,a,n];Fold[i,StringReverse@StringReplace[#,v->""],h@#]]&

Haskell, 157 131 octets

k="bcdfghjklmnpqrstvwxz";f c((r:q),s)=if c`elem`k then(q,r:s)else(r:q,c:s);f c("",s)=("",c:s);g s=snd$foldr f(filter(`elem`k)s,"")s

Mise à jour

La solution de @ atlasologist m'a fait comprendre que je n'avais besoin que d'une liste de consonnes au lieu de paires (inutile de les inverser, bien que j'utilise le bon pli.)

Ungolfed

consonants = "bcdfghjklmnpqrstvwxz"

-- Combining function (right fold, improved)
f :: Char -> (String, String) -> (String, String)
f c ((r:rest), s) = if c `elem` consonants then (rest, r:s) else (r:rest, c:s)
f c ("", s) = ("", c:s)

transform :: String -> String
transform s = snd $ foldr f (filter (`elem` consonants) s, "") s


main = do
    line <- getLine
    putStrLn . transform $ line

Vieux

c="bcdfghjklmnpqrstvwxz";n c(a@((f,t):q),s)=if c==f then(q,t:s)else(a,c:s);n c([],s)=([],c:s);g s=let z=filter(`elem`c)s in snd$foldr n(zip (reverse z)z,"")s

Crée une liste de paires de consonnes, puis parcourt la chaîne en remplaçant chaque consonne à l’aide de cette liste.

Un peu primitif, mais je voulais comprendre cela sans regarder les réponses en premier. :)

s-lang ,17 16 octets (non concurrents)

Un octet enregistré car s-lang ne nécessite plus de crochet de dernier argument

Essayez-le en ligne!

r[(?![aeiouy])\w

J'ai commencé à travailler sur un langage de golf à manipulation de cordes (je voulais le faire depuis un moment maintenant) et j'ai pensé que ce serait une question amusante de travailler dessus.

Explication:

• rinverse la chaîne avec un attribut de caractère de regex donné (si aucun argument de regex n'est donné, sa valeur par défaut sera .)
• [ commence l'argument optionnel regex pour r
• (?![aeiouy])\w la regex pour faire correspondre toute consonne à l'exception de y (malheureusement, JavaScript ne permet pas la soustraction de classe de caractère)
• ]termine généralement l'argument optionnel regex pour r, mais nous n'en avons pas besoin puisqu'il s'agit de la dernière fonction et du dernier argument

Matlab, 67 caractères

Pour une entrée 'this is a string of- stuff.'

s=input('','s');si=regexp(s,'[b-df-hj-np-tv-xz]');s(si)=s(flip(si))

produit s = ffit is a fgnirt os- ssuht.

siest les indices des consonnes dans la chaîne d'entrée. L'instruction finale remplace les caractères par les mêmes caractères, mais dans l'ordre inverse par indexation.

PowerShell , 81 octets

-join(($a=$args|% t*y)|%{if($_-in($c=$a-match'[^\W\d_aeiouy]')){$_=$c[--$i]};$_})

Essayez-le en ligne!

Moins joué au golf:

$a          = $args|% toCharArray
$consonants = $a-match'[^\W\d_aeiouy]'
$result     = $a|%{if($_-in$consonants){$_=$consonants[--$i]};$_}
-join($result)

PowerShell , 88 octets, -f

$i=0;-join($args|% t*y|%{if($_-match'[^\W\d_aeiouy]'){$c=,$_+$c;$_="{$i}";$i++};$_})-f$c

Essayez-le en ligne!

q / kdb +, 45 octets

Solution:

{x[w]:x(|)w:(&)max x=/:.Q.a except"aeiouy";x}

Explication:

Trouvez les indices des consonnes et remplacez-les par les consonnes inversées:

{x[w]:x reverse w:where max x=/:.Q.a except "aeiouy";x} / ungolfed
{                                                   ; } / two-statement lambda
                                .Q.a except "aeiouy"    / alphabet (a..z) except vowels
                            x=/:                        / equals each-right (returns boolean lists where input is each a consonant)
                        max                             / 'or' the results together
                  where                                 / indices where results are true
                w:                                      / save in variable w
        reverse                                         / reverse this list
      x                                                 / index into input at these indices
 x[w]:                                                  / assign values to x at indices w
                                                     x  / return x

Remarques:

J'avais 3 façons de construire la liste des consonnes, celle de la solution est légèrement meilleure que celle des alternatives:

• "bcdfghjklmnpqrstvwxz" pour 22 caractères (le plus ennuyeux)
• .Q.a _/0 3 6 11 16 19 pour 21 caractères (cool, laissez tomber chaque index)
• .Q.a except"aeiouy" pour 19 caractères (deuxième plus ennuyeux)

Jq 1.5 , 289 263 octets

def C:"bcdfghjklmnpqrstvwxz";. as$s|[("^","")as$p|[match("([\($p)\(C)]+)";"g").captures[].string]]|.[1]|=(reduce map(length)[]as$l({s:add|explode|reverse|implode,r:[]};.r+=[.s[0:$l]]|.s=.s[$l:])|.r)|if$s[0:1]|inside(C)then[.[1,0]]else . end|transpose|map(add)|add

Explication

def consonants:"bcdfghjklmnpqrstvwxz";

  . as $s
| [  ("^","") as $p                                              # parse string onto non-consonant
   | [match("([\($p)\(consonants)]+)";"g").captures[].string]]   # and consonant groups
| .[1] |= (
     reduce map(length)[] as $l (                                # build new for consonant groups
       {s:add|explode|reverse|implode,r:[]}                      # by adding groups from reversed string
     ; .r+=[.s[0:$l]] | .s=.s[$l:]                               
     )
     |.r
  )
| if $s[0:1]|inside(consonants) then  [.[1,0]] else . end        # put groups into proper order for merge
| transpose | map(add) | add                                     # merge groups into final string

Échantillon échantillon

$ jq -MRr 'def C:"bcdfghjklmnpqrstvwxz";. as$s|[("^","")as$p|[match("([\($p)\(C)]+)";"g").captures[].string]]|.[1]|=(reduce map(length)[]as$l({s:add|explode|reverse|implode,r:[]};.r+=[.s[0:$l]]|.s=.s[$l:])|.r)|if$s[0:1]|inside(C)then[.[1,0]]else . end|transpose|map(add)|add' input
a sect sate
nedl-lowe
setenne sne cohtosarvr

Essayez-le en ligne

Java 8, 157 octets

s->s.format(s.replaceAll("[^\\W\\d_aeiouy]","%s"),s.chars().mapToObj(c->""+(char)c).filter(c->c.matches("[^\\W\\d_aeiouy]")).reduce("",(x,y)->y+x).split(""))

Essayez-le en ligne!

Remarque: affiche les avertissements du compilateur sur stderr.
Explication:

s->                                                    // Lambda function
    s.format(                                          // Format a string using the given arguments
        s.replaceAll("[^\\W\\d_aeiouy]","%s"),         // Generate the format string by replacing all consonants with "%s"
        s.chars()                                      // Stream the characters of the input string s
            .mapToObj(c->""+(char)c)                   // Map characters back to strings
            .filter(c->c.matches("[^\\W\\d_aeiouy]"))  // Filter out vowels and symbols
            .reduce("",(x,y)->y+x)                     // Build the string of consonants in reverse
            .split("")                                 // Turn into an array of single-char strings (varargs abuse)
    )                                                  // Implicit return of the formatted string

Je ne vais pas mentir, mon seul objectif était de battre cette réponse

APL (Dyalog Extended) , 22 octets

⌽@(('aeiou'~⍨∘⌊⎕A)∊⍨⊢)

Essayez-le en ligne!