Il programma dovrebbe prendere una stringa come input e invertire le consonanti in essa contenute, mantenendo l'ordine delle vocali. Tutte le lettere saranno minuscole, quindi non devi preoccuparti di involucro. Seguono esempi.

1. Ingresso: a test case.
   Le consonanti qui sono t,s,t,c,s. Essi dovrebbero venire in ordine inverso, vale a dire s,c,t,s,te di nuovo inserito nella stringa alle stesse posizioni in cui si trovavano i personaggi pre-invertito: a sect sate.

2. Ingresso: well-done. Uscita: nedl-lowe.

3. Ingresso: reverse the consonants. Uscita: setenne sne cohtosarvr.

Questo è il codice golf, vince la soluzione più breve.

Y dovrebbe essere considerata vocale indipendentemente da ciò che è e non invertita.

Qualsiasi cosa, così come numeri, punteggiatura, virgolette e altri simboli ( @#$%^&*(){}[]\|/<>~-_+=`), potrebbe potenzialmente apparire nell'input.

Retina, 22 21 20 17

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

Provalo online!

1 byte grazie a Leaky Nun!

4 byte grazie a Martin!

Osignifica ordinamento e #significa ordinamento per valore numerico. Poiché nessuno dei caratteri corrispondenti avrà mai un valore numerico, tutte le lettere hanno lo stesso peso: 0. ^significa invertire l'ordine dei valori ordinati, che grazie all'ordinamento stabile significa che i valori sono invertiti.

I -[...]mezzi per fare la differenza tra la classe di caratteri esterna e questa classe interna. Questo fa parte di .NET e puoi leggere di più su MSDN .

Python 2, 86 byte

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

Prende l'input come stringa tra virgolette. Scorre l'ingresso, sostituendo ciascuna consonante con %sin s. La tupla cmemorizza le consonanti incontrate in ordine inverso. Quindi, la formattazione della stringa sostituisce l %s'in scon le consonanti in c.

Grazie a Sp3000 per il controllo delle consonanti, che ha consentito di risparmiare 4 byte elencando le consonanti.

Gelatina , 22 20 byte

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

Provalo online!

Come funziona

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

Hai salvato un byte grazie a ciascuno di Martin e Leaky Nun e 2 byte a Neil!

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

analisi

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 byte

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)

Si aspetta input in "quotes", che penso sia permesso.

Pyke, 18 byte

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

Provalo qui!

o 16 byte con la nuova versione:

(Cambia così se per restituisce tutto l'output della stringa e aveva l'input della stringa, restituisce la stringa anziché un elenco)

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

Provalo qui!

~c contiene le consonanti: bcdfghjklmnpqrstvwxz

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

GNU sed, 73

Il punteggio include +1 per la -rbandiera passata a sed.

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

Ideone.

Commuta ripetutamente la prima e l'ultima consonante minuscola e li converte in lettere maiuscole, fino a quando non ci sono più corrispondenze. Quindi riconvertire l'intera stringa in minuscolo.

J, 53 byte

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

Forse non è il modo migliore ma volevo usarlo C.poiché questo può essere risolto usando le permutazioni.

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

Spiegazione

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 byte

tt2Y211Y2'y'hX-m)P5M(

1 byte salvato grazie a @Luis

Sfortunatamente la parte più lunga di questo è ottenere l'elenco delle consonanti ( 2Y211Y2'y'hX-).

Provalo online!

Spiegazione

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

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

+4 di penalità per l'esecuzione con -0777flag, che imposta Perl in modalità slurp per gestire correttamente le nuove linee.

Accetta input tramite STDIN e stampa su STDOUT.

Spiegazione

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

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

La suddivisione in /([^\W\d_aeiouy])/risultati comporta la caduta delle consonanti nelle voci dispari dell'array. È quindi sufficiente cambiare quelle voci con la voce equivalente contando alla fine dell'array e unendo il risultato.

JavaScript (ES6), 57 70

Modifica Incredibile risparmio del 20% grazie a @Neil

In ritardo alla festa, ma sembra che tutte le persone di JavaScript abbiano perso qualcosa

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

Test

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 byte

37 byte salvati grazie all'aiuto di @manatwork . ;-)

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

Una traduzione della soluzione @Lynn Python in Perl.

Pyth, 26 25 24 23 byte

SI: Q ++ \ [JG "aeiouy" \] 3_ @ J
JG "aeiouy" sm? @DJ @ _ @ JQ ~ hZ <- semplicemente mantenendo questo a causa del @ _ @
JG "aeiouy" sm? @ DJ @@ JQ = tZ
sm? @ DJ-G "aeiouy" @@ JQ = tZ
sm | -DJ-G "aeiouy" @@ JQ = tZ

Suite di test.

Julia, 53 byte

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

Questo prende una matrice di caratteri come input e inverte le sue consonanti sul posto. Provalo online!

Il credito va a @ Sp3000 per il controllo delle consonanti minuscole.

Come funziona

i=find(...,s)produce tutti gli indici di s per i quali il predicato ... restituisce vero e li salva nella variabile i .

c->'}'>c∉"aeiouy"<"$c"esegue tre test e restituisce vero se e solo se tutti sono positivi.

• '}'>ccontrolla se il carattere c precede { .

• "aeiou"controlla se la stringa c viene dopo a .

• c∉"aeiouy"verifica che c non sia una vocale.

Infine, s[i]fornisce tutte le consonanti e le s[flipud(i)]=s[i]assegna a posizioni in s che corrispondono agli indici invertiti in in i .

Java, 319 305 261 188 byte

Ringraziamo @ Leaky Nun per l'aiuto con questo :-)

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

Vecchio:

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

Ispirazione presa da qui ❤

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

Rubino, 53 50 byte

-3 byte da @manatwork

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

Provalo qui

Python 2, 103 98 100 byte

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

Porta della mia risposta JavaScript. Modifica: salvato 5 byte grazie a @ Dennis ♦, di cui ho dovuto prontamente spendere due cifre di correzione.

R, 120 byte

Nuova risposta:

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

accetta una stringa di caratteri come x

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

La vecchia risposta di seguito (110 byte) è stata una forma scadente da parte mia, che ha appena invertito le consonanti:

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 byte

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

⎕a~'aeoiuy'l'alfabeto minuscolo senza vocali
t←⍞memorizza l'immissione dei caratteri come t
c←( ... )∊archivia la "consonante" booleana? come c
t/⍨ extract (consonanti) da t
⌽ reverse
(c/t)←sostituiscono le consonanti con (quelle invertite)
trestituiscono la stringa modificata

Python 2.7, 144 byte

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)

Questo prima crea un elenco invertito delle consonanti, quindi inserisce nuovamente ciascuno degli altri caratteri nel loro indice originale.

Un-giocato a 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 byte

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 byte

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

Aggiornare

La soluzione di @tlaslas mi ha fatto capire che ho solo bisogno di un elenco delle consonanti anziché di coppie (non è necessario invertirle dal momento che sto usando la piega a destra.)

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

Vecchio

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 un elenco di coppie di consonanti, quindi cammina attraverso la stringa sostituendo ciascuna consonante utilizzando tale elenco.

Un po 'primitivo, ma volevo capirlo senza prima guardare le risposte. :)

s-lang ,17 16 byte (non concorrenti)

Salvato un byte perché s-lang non richiede più la parentesi dell'ultimo argomento

Provalo online!

r[(?![aeiouy])\w

Ho iniziato a lavorare su un linguaggio di manipolazione delle stringhe (volevo farlo da un po 'di tempo ormai) e ho pensato che sarebbe stata una domanda divertente su cui lavorare.

Spiegazione:

• rinverte la stringa con un determinato matcher di caratteri regex (se non viene fornito alcun argomento regex, verrà automaticamente impostato su .)
• [ inizia l'argomento regex opzionale per r
• (?![aeiouy])\w la regex per abbinare qualsiasi carattere consonante escluso y (purtroppo JavaScript non consente la sottrazione della classe di caratteri)
• ]di solito termina l'argomento regex opzionale per r, ma non ne abbiamo bisogno poiché è l'ultima funzione e l'ultimo argomento

Matlab, 67 caratteri

Per un input '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.

siè gli indici delle consonanti nella stringa di input. L'istruzione finale sostituisce quei caratteri con gli stessi caratteri ma in ordine inverso indicizzando.

PowerShell , 81 byte

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

Provalo online!

Meno golf:

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

PowerShell , 88 byte, -f

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

Provalo online!

q / kdb +, 45 byte

Soluzione:

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

Spiegazione:

Trova gli indici delle consonanti e sostituiscili con le consonanti invertite:

{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

Gli appunti:

Ho avuto 3 modi per costruire l'elenco delle consonanti, quello nella soluzione è leggermente migliore rispetto alle alternative:

• "bcdfghjklmnpqrstvwxz" per 22 caratteri (la maggior parte noioso)
• .Q.a _/0 3 6 11 16 19 per 21 caratteri (un po 'cool, rilascia ogni indice)
• .Q.a except"aeiouy" per 19 caratteri (il secondo più noioso)

Jq 1,5 , 289 263 byte

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

Spiegazione

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

Esecuzione del campione

$ 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

Provalo online

Java 8, 157 byte

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

Provalo online!

Nota: stampa gli avvisi del compilatore su stderr.
Spiegazione:

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

Non mentirò, il mio unico obiettivo era battere questa risposta

APL (Dyalog Extended) , 22 byte

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

Provalo online!