O programa deve usar uma string como entrada e reverter as consoantes, mantendo a ordem das vogais. Todas as letras serão minúsculas, para que você não precise se preocupar com maiúsculas e minúsculas. Seguem exemplos.

1. Entrada: a test case.
   As consoantes aqui são t,s,t,c,s. Eles devem vir em ordem inversa, ou seja, s,c,t,s,te volta inserido na seqüência para as mesmas posições onde os personagens pré-revertida foram localizados: a sect sate.

2. Entrada: well-done. Saída: nedl-lowe.

3. Entrada: reverse the consonants. Saída: setenne sne cohtosarvr.

Este é o código golf, a solução mais curta vence.

Y deve ser considerada vogal, independentemente do que é e não revertida.

Qualquer coisa, assim como números, pontuação, aspas e outros símbolos ( @#$%^&*(){}[]\|/<>~-_+=`), podem aparecer na entrada.

Retina, 22 21 20 17

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

Experimente online!

1 byte graças a Leaky Nun!

4 bytes graças a Martin!

Osignifica classificar e #significa classificar por valor numérico. Como nenhum dos caracteres correspondentes terá um valor numérico, todas as letras têm o mesmo peso: 0. ^significa reverter a ordem dos valores classificados, o que, graças à classificação estável, significa que os valores são revertidos.

Os -[...]meios para fazer a diferença definida entre a classe de caracteres externos e essa classe interna. Isso faz parte do .NET e você pode ler mais no MSDN .

Python 2, 86 bytes

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

Recebe a entrada como uma string entre aspas. Repete a entrada, substituindo cada consoante por %sin s. A tupla carmazena as consoantes encontradas em ordem inversa. Então, corda formatação substitui o %s's em scom as consoantes c.

Obrigado ao Sp3000 pela verificação de consoantes, que economizou 4 bytes ao listar as consoantes.

Geléia , 22 20 bytes

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

Experimente online!

Como funciona

Ø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 bytes

Salvei um byte graças a cada um de Martin e Leaky Nun e 2 bytes a Neil!

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

Teste

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 bytes

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)

Espera entrada "quotes", o que eu acho que é permitido.

Pyke, 18 bytes

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

Experimente aqui!

ou 16 bytes com a nova versão:

(Altere para que, se for retorne toda a saída da string e tivesse entrada de string, retorne a string em vez de uma lista)

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

Experimente aqui!

~c contém as consoantes: bcdfghjklmnpqrstvwxz

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

GNU sed, 73

A pontuação inclui +1 para a -rbandeira passada para sed.

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

Ideone.

Alterna repetidamente a primeira e a última consoante em minúscula e as converte em maiúsculas, até que não haja mais correspondências. Em seguida, converta a string inteira novamente em minúsculas.

J, 53 bytes

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

Talvez não seja o melhor, mas eu queria usar, C.pois isso pode ser resolvido usando permutações.

Uso

   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

Explicação

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 bytes

tt2Y211Y2'y'hX-m)P5M(

1 byte salvo graças a @Luis

Infelizmente, a parte mais longa disso é obter a lista de consoantes ( 2Y211Y2'y'hX-).

Experimente Online!

Explicação

            % 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 bytes)

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

+4 de penalidade por rodar com -0777sinalizador, que define o Perl no modo slurp para lidar com as novas linhas corretamente.

Aceita entrada por STDIN e imprime em STDOUT.

Explicação

                   $_=<>;   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 bytes

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

A divisão /([^\W\d_aeiouy])/resulta nos consoantes que caem nas entradas com números ímpares na matriz. Em seguida, basta alternar essas entradas com a entrada equivalente contando do final da matriz e unir o resultado.

JavaScript (ES6), 57 70

Editar Incrível 20% de economia thx @Neil

Tarde para a festa, mas parece que todas as pessoas javascript perderam algo

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

Teste

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 bytes

Economizou 37 bytes graças à ajuda de @manatwork . ;-)

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

Uma tradução da solução @Lynn Python para Perl.

Pitão, 26 25 24 23 bytes

si: Q ++ \ [JG "aeiouy" \] 3_ @ J
JG "aeiouy" sm? @DJ @ _ @ JQ ~ hZ <- apenas mantendo isso por causa da @ _ @
JG "aeiouy" sm? @ DJ @@ JQ = tZ
sm? @ dJ-G "aeiouy" @@ JQ = tZ
sm | -dJ-G "aeiouy" @@ JQ = tZ

Suíte de teste.

Julia, 53 bytes

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

Isso leva uma matriz de caracteres como entrada e reverte suas consoantes no local. Experimente online!

O crédito vai para @ Sp3000 para a verificação de consoante em minúsculas.

Como funciona

i=find(...,s)produz todos os índices de s para os quais o predicado ... retorna verdadeiro e os salva na variável i .

c->'}'>c∉"aeiouy"<"$c"executa três testes e retorna true se e somente se todos forem positivos.

• '}'>cverifica se o caractere c vem antes de { .

• "aeiou"verifica se a sequência c vem após a .

• c∉"aeiouy"verifica se c não é uma vogal.

Finalmente, s[i]gera todas as consoantes e as s[flipud(i)]=s[i]atribui a posições em s que correspondem aos índices revertidos em i .

Java, 319 305 261 188 bytes

Agradecemos a @ Leaky Nun por ajudar com isso :-)

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;}

Velho:

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

Inspiração tirada daqui ❤

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 50 bytes

-3 bytes de @manatwork

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

Experimente aqui

Python 2, 103 98 100 bytes

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

Porta da minha resposta JavaScript. Edit: Salvo 5 bytes, graças a @ Dennis ♦, dos quais eu tive que gastar dois dígitos de fixação.

R, 120 bytes

Nova resposta:

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="")
}

usa uma cadeia de caracteres como x

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

A resposta antiga abaixo (110 bytes) foi ruim da minha parte, o que acabou de reverter as consoantes:

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 bytes

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

⎕a~'aeoiuy'alfabeto em minúsculas sem vogais
t←⍞armazena a entrada de caracteres como t
c←( … )∊armazena "consoante?" booleana como c
t/⍨ extract (consoantes) de t
⌽ reverse
(c/t)←substitui consoantes por (as invertidas)
tretornam a string modificada

Python 2.7, 144 bytes

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)

Isso primeiro cria uma lista invertida de consoantes e, em seguida, insere cada um dos outros caracteres novamente no índice original.

Sem golfe:

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 bytes

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 bytes

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

Atualizar

A solução do @ atlasologist me fez perceber que só preciso de uma lista de consoantes em vez de pares (não é necessário revertê-las, pois estou usando a dobra à direita).

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

Velho

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

Cria uma lista de pares de consoantes e, em seguida, percorre a cadeia substituindo cada consoante usando a lista.

Um pouco primitivo, mas eu queria descobrir isso sem olhar as respostas primeiro. :)

s-lang ,17 16 bytes (não concorrente)

Salvo um byte porque s-lang não requer mais o último colchete de argumento

Experimente online!

r[(?![aeiouy])\w

Comecei a trabalhar em uma linguagem de golfe para manipulação de strings (já fazia algum tempo que fazia isso) e achei que seria uma pergunta divertida de se trabalhar.

Explicação:

• rinverte a string com um determinado correspondente de caracteres regex (se nenhum argumento regex for fornecido, o padrão será .)
• [ inicia o argumento regex opcional para r
• (?![aeiouy])\w o regex para corresponder a qualquer caractere consoante excluindo y (infelizmente, o JavaScript não permite subtração de classe de caractere)
• ]geralmente termina o argumento regex opcional para r, mas não precisamos dele, pois é a última função e o último argumento

Matlab, 67 caracteres

Para uma entrada 'this is a string of- stuff.'

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

produz s = ffit is a fgnirt os- ssuht.

sisão os índices das consoantes na sequência de entrada. A declaração final substitui esses caracteres pelos mesmos, mas em ordem inversa pela indexação.

PowerShell , 81 bytes

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

Experimente online!

Menos golfe:

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

PowerShell , 88 bytes, -f

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

Experimente online!

q / kdb +, 45 bytes

Solução:

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

Explicação:

Encontre índices das consoantes e substitua-os pelas consoantes revertidas:

{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

Notas:

Eu tinha três maneiras de criar a lista de consoantes, a da solução é um pouco melhor do que as alternativas:

• "bcdfghjklmnpqrstvwxz" por 22 caracteres (mais chato)
• .Q.a _/0 3 6 11 16 19 por 21 caracteres (meio legal, solte cada índice)
• .Q.a except"aeiouy" por 19 caracteres (o segundo mais chato)

Jq 1,5 , 289 263 bytes

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

Explicação

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

Amostra de execução

$ 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

Experimente online

Java 8, 157 bytes

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

Experimente online!

Nota: imprime avisos do compilador no stderr.
Explicação:

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

Não vou mentir, meu único objetivo era vencer essa resposta

APL (Dyalog Extended) , 22 bytes

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

Experimente online!