El programa debe tomar una cadena como entrada e invertir las consonantes, manteniendo el orden de las vocales. Todas las letras estarán en minúsculas, por lo que no tiene que preocuparse por la carcasa. Siguen ejemplos.

1. Entrada: a test case.
   Las consonantes aquí son t,s,t,c,s. Ellos deben entrar en orden inverso, es decir, s,c,t,s,ty de vuelta insertado en la secuencia de las mismas posiciones en las que se encontraban los personajes pre-invertido: a sect sate.

2. Entrada: well-done. Salida: nedl-lowe.

3. Entrada: reverse the consonants. Salida: setenne sne cohtosarvr.

Este es el código de golf, gana la solución más corta.

Y debe considerarse vocal independientemente de lo que sea y no invertida.

Cualquier cosa, así como números, signos de puntuación, comillas y otros símbolos ( @#$%^&*(){}[]\|/<>~-_+=`), podrían aparecer en la entrada.

Retina, 22 21 20 17

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

Pruébalo en línea!

¡1 byte gracias a Leaky Nun!

4 bytes gracias a Martin!

Osignifica ordenar y #ordenar por valor numérico. Dado que ninguno de los caracteres coincidentes tendrá un valor numérico, todas las letras tienen el mismo peso: 0. ^significa invertir el orden de los valores ordenados, lo que gracias a una clasificación estable significa que los valores se invierten.

Los -[...]medios para hacer la diferencia setwise entre la clase de carácter externo y esta clase interna. Esto es parte de .NET y puede leer más en 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

Toma la entrada como una cadena entre comillas. Itera a través de la entrada, reemplazando cada consonante con %sin s. La tupla calmacena las consonantes encontradas en orden inverso. Luego, el formato de cadena reemplaza el %s's in scon las consonantes en c.

Gracias a Sp3000 por la verificación de consonantes, que ahorró 4 bytes al enumerar las consonantes.

Jalea , 22 20 bytes

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

Pruébalo en línea!

Cómo 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

¡Ahorré un byte gracias a cada uno de Martin y Leaky Nun, y 2 bytes a Neil!

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

Pruebas

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", lo que creo que está permitido.

Pyke, 18 bytes

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

Pruébalo aquí!

o 16 bytes con la nueva versión:

(Cambie así si for devuelve toda la salida de cadena y tuvo entrada de cadena, devuelva cadena en lugar de una lista)

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

Pruébalo aquí!

~c contiene las consonantes: bcdfghjklmnpqrstvwxz

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

GNU sed, 73

La puntuación incluye +1 para la -rbandera pasada a sed.

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

Ideona

Cambia repetidamente la primera y la última consonante en minúsculas y las convierte a mayúsculas, hasta que no haya más coincidencias. Luego convierta toda la cadena de nuevo a minúsculas.

J, 53 bytes

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

Quizás no sea la mejor manera, pero quería usarlo, C.ya que esto se puede resolver mediante permutaciones.

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

Explicación

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 guardado gracias a @Luis

Desafortunadamente, la parte más larga de esto es obtener la lista de consonantes ( 2Y211Y2'y'hX-).

Pruébalo en línea!

Explicación

            % 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 penalización por correr con -0777bandera, lo que configura a Perl en modo sorber para manejar correctamente las nuevas líneas.

Acepta entradas a través de STDIN e imprime en STDOUT.

Explicación

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

Al dividir los /([^\W\d_aeiouy])/resultados, las consonantes caen en las entradas impares de la matriz. Entonces es suficiente cambiar esas entradas con la entrada equivalente contando desde el final de la matriz y unir el resultado.

JavaScript (ES6), 57 70

Editar Amazing 20% ​​thx @Neil ahorro

Tarde a la fiesta, pero parece que todas las personas de JavaScript se perdieron algo

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

Prueba

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

Guardado 37 bytes gracias a @manatwork ayuda 's. ;-)

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

Una traducción de la solución @Lynn Python a Perl.

Pyth, 26 25 24 23 bytes

si: Q ++ \ [JG "aeiouy" \] 3_ @ J
JG "aeiouy" sm? @DJ @ _ @ JQ ~ hZ <- solo manteniendo esto debido a @ _ @
JG "aeiouy" sm? @ DJ @@ JQ = tZ
sm? @ dJ-G "aeiouy" @@ JQ = tZ
sm | -dJ-G "aeiouy" @@ JQ = tZ

Banco de pruebas.

Julia, 53 bytes

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

Esto toma una matriz de caracteres como entrada e invierte sus consonantes en el lugar. Pruébalo en línea!

El crédito va a @ Sp3000 para la verificación de consonantes en minúsculas.

Cómo funciona

i=find(...,s)produce todos los índices de s para los cuales el predicado ... devuelve verdadero y los guarda en la variable i .

c->'}'>c∉"aeiouy"<"$c"realiza tres pruebas y devuelve verdadero si y solo si todas son positivas.

• '}'>ccomprueba si el carácter c viene antes de { .

• "aeiou"comprueba si la cadena c viene después de a .

• c∉"aeiouy"verifica que c no es una vocal.

Finalmente, s[i]produce todas las consonantes y las s[flipud(i)]=s[i]asigna a posiciones en s que corresponden a los índices invertidos en en i .

Java, 319 305 261 188 bytes

Gracias a @ Leaky Nun por ayudar con esto :-)

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

Antiguo:

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

Inspiración tomada de aquí ❤

Sin golf

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

Pruébalo aquí

Python 2, 103 98100 bytes

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

Puerto de mi respuesta de JavaScript. Editar: ahorré 5 bytes gracias a @ Dennis ♦, de los cuales tuve que pasar rápidamente dos dígitos fijos.

R, 120 bytes

Nueva respuesta:

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

toma una cadena de caracteres como x

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

La respuesta anterior a continuación (110 bytes) fue deficiente por mi parte, lo que acaba de revertir las consonantes:

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'el alfabeto en minúsculas sin vocales
t←⍞almacena la entrada de caracteres como t
c←( ... )∊almacena la "consonante booleana"? como c
t/⍨ extract (consonantes) de t
⌽ reverse
(c/t)←reemplaza consonantes con (los invertidos)
tdevuelve la cadena 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)

Este primero crea una lista invertida de las consonantes, luego inserta cada uno de los otros caracteres en su índice original.

Sin 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 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

Actualizar

La solución de @ atlasologist me hizo darme cuenta de que solo necesito una lista de las consonantes en lugar de pares (aunque no es necesario revertirlas ya que estoy usando el pliegue derecho).

Sin golf

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

Antiguo

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

Crea una lista de pares de consonantes, luego camina a través de la cuerda reemplazando cada consonante usando dicha lista.

Un poco primitivo, pero quería resolver esto sin mirar primero las respuestas. :)

s-lang ,17 16 bytes (no competitivos)

Se guardó un byte porque s-lang ya no requiere el último paréntesis de argumento

Pruébalo en línea!

r[(?![aeiouy])\w

Comencé a trabajar en un lenguaje de golf de manipulación de cuerdas (he estado esperando hacer esto por un tiempo ahora), y pensé que sería una pregunta divertida para trabajar.

Explicación:

• rinvierte la cadena con una coincidencia de caracteres regex dada (si no se proporciona ningún argumento regex, el valor predeterminado será .)
• [ comienza el argumento opcional regex para r
• (?![aeiouy])\w la expresión regular para que coincida con cualquier carácter consonante excluyendo y (desafortunadamente JavaScript no permite la resta de la clase de caracteres)
• ]generalmente finaliza el argumento opcional regex para r, pero no lo necesitamos ya que es la última función y el último argumento

Matlab, 67 caracteres

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

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

produce s = ffit is a fgnirt os- ssuht.

sison los índices de las consonantes en la cadena de entrada. La declaración final reemplaza esos caracteres con los mismos caracteres pero en orden inverso mediante indexación.

PowerShell , 81 bytes

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

Pruébalo en línea!

Menos golfizado:

$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

Pruébalo en línea!

q / kdb +, 45 bytes

Solución:

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

Explicación:

Encuentre índices de las consonantes y reemplácelas con las consonantes invertidas:

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

Tenía 3 formas de construir la lista de consonantes, la de la solución es ligeramente mejor que las alternativas:

• "bcdfghjklmnpqrstvwxz" por 22 caracteres (lo más aburrido)
• .Q.a _/0 3 6 11 16 19 por 21 caracteres (algo genial, suelte cada índice)
• .Q.a except"aeiouy" por 19 caracteres (el segundo más aburrido)

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

Explicación

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

Ejecución de la muestra

$ 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

Pruébalo en línea

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

Pruébalo en línea!

Nota: imprime advertencias del compilador en stderr.
Explicación:

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

No voy a mentir, mi único objetivo era superar esta respuesta

APL (Dyalog Extended) , 22 bytes

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

Pruébalo en línea!