Das Programm sollte einen String als Eingabe nehmen und die darin enthaltenen Konsonanten umkehren, wobei die Reihenfolge der Vokale eingehalten wird. Alle Buchstaben werden in Kleinbuchstaben geschrieben, sodass Sie sich keine Gedanken über die Schreibweise machen müssen. Beispiele folgen.

1. Input: a test case.
   Die Konsonanten hier sind t,s,t,c,s. Sie sollten in umgekehrter Reihenfolge kommen, das heißt s,c,t,s,tund eingefügt zurück in die Zeichenfolge in den gleichen Positionen , an denen die vorge Zeichen umgekehrt angeordnet waren: a sect sate.

2. Input: well-done. Ausgang: nedl-lowe.

3. Input: reverse the consonants. Ausgang: setenne sne cohtosarvr.

Dies ist der Code Golf, gewinnt die kürzeste Lösung.

Y sollte als Vokal betrachtet werden, unabhängig davon, was es ist und nicht umgekehrt.

@#$%^&*(){}[]\|/<>~-_+=`In der Eingabe können sowohl Zahlen als auch Satzzeichen, Anführungszeichen und andere Symbole ( ) enthalten sein.

Retina, 22 21 20 17

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

Probieren Sie es online!

1 Byte dank Leaky Nun!

4 Bytes danke an Martin!

Obedeutet sortieren und #bedeutet nach numerischem Wert sortieren. Da keines der übereinstimmenden Zeichen jemals einen numerischen Wert haben wird, haben alle Buchstaben das gleiche Gewicht: 0. ^bedeutet, die Reihenfolge der sortierten Werte umzukehren, was dank stabiler Sortierung bedeutet, dass die Werte umgekehrt werden.

Das -[...]Mittel, um den entscheidenden Unterschied zwischen der äußeren und der inneren Klasse zu machen. Dies ist Teil von .NET und Sie können mehr auf der MSDN lesen .

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

Nimmt Eingaben als Zeichenfolge in Anführungszeichen. Durchläuft die Eingabe und ersetzt jeden Konsonanten durch %sin s. Das Tupel cspeichert die gefundenen Konsonanten in umgekehrter Reihenfolge. Die Formatierung der Zeichenfolgen ersetzt dann das %ss in sdurch die Konsonanten in c.

Vielen Dank an Sp3000 für die Konsonantenüberprüfung, die 4 Byte bei der Auflistung der Konsonanten eingespart hat.

Jelly , 22 bis 20 Bytes

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

Probieren Sie es online!

Wie es funktioniert

Ø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

Dank an Martin und Leaky Nun jeweils ein Byte und an Neil 2 Byte!

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

Testen

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)

Erwartet Eingaben in "quotes", was meiner Meinung nach erlaubt ist.

Pyke, 18 Bytes

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

Probieren Sie es hier aus!

oder 16 Bytes mit der neuen Version:

(Ändern Sie dies, wenn für alle Zeichenfolgenausgaben und Zeichenfolgeneingaben Zeichenfolgen anstelle einer Liste zurückgegeben werden sollen.)

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

Probieren Sie es hier aus!

~c enthält die Konsonanten: bcdfghjklmnpqrstvwxz

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

GNU sed, 73

Das Ergebnis enthält +1 für die -rFlagge, die an sed übergeben wurde.

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

Ideone.

Wechselt wiederholt den ersten und den letzten Kleinbuchstabenkonsonanten und konvertiert sie in Großbuchstaben, bis keine Übereinstimmungen mehr vorhanden sind. Konvertieren Sie dann die gesamte Zeichenfolge wieder in Kleinbuchstaben.

J, 53 Bytes

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

Vielleicht ist das nicht der beste Weg, aber ich wollte ihn nutzen, C.da dies mit Permutationen gelöst werden kann.

Verwendungszweck

   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

Erläuterung

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 gespart dank @Luis

Leider ist der längste Teil davon die Liste der Konsonanten ( 2Y211Y2'y'hX-).

Probieren Sie es online!

Erläuterung

            % 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 Strafe für das Laufen mit -0777Flag, wodurch Perl in den Slurp-Modus versetzt wird, um Zeilenumbrüche korrekt zu behandeln.

Akzeptiert Eingaben über STDIN und druckt auf STDOUT.

Erläuterung

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

Die Aufteilung auf /([^\W\d_aeiouy])/führt dazu, dass die Konsonanten in die ungeradzahligen Einträge im Array fallen. Es genügt dann, diese Einträge zu vertauschen, wobei der entsprechende Eintrag vom Ende des Arrays zurückzählt, und das Ergebnis zusammenzufügen.

JavaScript (ES6), 57 70

Bearbeiten Erstaunliche 20% Ersparnis dank @Neil

Spät zur Party, aber anscheinend haben alle Javascript-Leute etwas verpasst

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

Prüfung

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

Gespeichert 37 Bytes dank @manatwork ‚s Hilfe. ;-)

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

Eine Übersetzung von @Lynn Python-Lösung zu Perl.

Pyth, 26 25 24 23 Bytes

si: Q ++ \ [JG "aeiouy" \] 3_ @ J
JG "aeiouy" sm? @DJ @ _ @ JQ ~ hZ <- behalte das nur wegen des @ _ @
JG "aeiouy" sm? @ DJ @@ JQ = tZ
sm? @ dJ-G "aeiouy" @@ JQ = tZ
sm | -dJ-G "aeiouy" @@ JQ = tZ

Testsuite.

Julia, 53 Bytes

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

Dies nimmt ein Zeichenarray als Eingabe und kehrt seine Konsonanten an Ort und Stelle um. Probieren Sie es online!

Die Gutschrift für die Konsonantenprüfung in Kleinbuchstaben geht an @ Sp3000.

Wie es funktioniert

i=find(...,s)liefert alle Indizes von s, für die das Prädikat ... true zurückgibt und speichert sie in der Variablen i .

c->'}'>c∉"aeiouy"<"$c"Führt drei Tests durch und gibt nur dann true zurück , wenn alle positiv sind.

• '}'>cüberprüft , ob das Zeichen c vor kommt { .

• "aeiou"überprüft , ob die Zeichenfolge c nach kommt ein .

• c∉"aeiouy"verifiziert, dass c kein Vokal ist.

Schließlich s[i]liefert alle Konsonanten und s[flipud(i)]=s[i]ordnet sie Positionen in s , dass entsprechen den umgekehrten Indizes in in i .

Java, 319 305 261 188 Bytes

Dank an @ Leaky Nun, die mir dabei geholfen haben :-)

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

Alt:

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 von hier genommen ❤

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 von @manatwork

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

Probieren Sie es hier aus

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]+['']),()))

Port meiner JavaScript-Antwort. Edit: 5 Bytes gespart dank @ Dennis ♦, von dem ich prompt zwei Fixziffern ausgeben musste.

R, 120 Bytes

Neue Antwort:

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

Nimmt eine Zeichenkette als x

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

Die alte Antwort unten (110 Bytes) war eine schlechte Form meinerseits, die die Konsonanten einfach umkehrte:

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'Kleinbuchstaben ohne Vokale
t←⍞speichern Zeicheneingabe als t
c←( ... )∊store Boolean „Konsonant?“ Wenn c
t/⍨ (Konsonanten) aus t
⌽ reverse extrahiert,
(c/t)←ersetzen Sie Konsonanten durch (die umgekehrten) und
tgeben Sie die modifizierte Zeichenfolge zurück

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)

Dies erstellt zuerst eine umgekehrte Liste der Konsonanten und fügt dann jedes der anderen Zeichen wieder in ihren ursprünglichen Index ein.

Nicht golfen:

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

Aktualisieren

Durch die Lösung von @atlasologist wurde mir klar, dass ich nur eine Liste der Konsonanten anstelle von Paaren benötige (obwohl ich sie nicht umkehren muss, da ich die rechte Falte verwende).

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

Alt

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

Erstellt eine Liste mit Konsonantenpaaren und durchläuft dann die Zeichenfolge, wobei jeder Konsonant anhand dieser Liste ersetzt wird.

Ein bisschen primitiv, aber ich wollte das herausfinden, ohne zuerst auf die Antworten zu schauen. :)

s lang ,17 16 Bytes (nicht konkurrierend)

1 Byte gespeichert, da für s-lang die letzte Argumentklammer nicht mehr erforderlich ist

Probieren Sie es online!

r[(?![aeiouy])\w

Ich habe angefangen, an einer Saitenmanipulations-Golfsprache zu arbeiten (das wollte ich jetzt schon eine Weile), und ich dachte, es wäre eine lustige Frage, damit zu arbeiten.

Erläuterung:

• rKehrt die Zeichenfolge mit einem angegebenen Regex-Zeichenvergleich um (wenn kein Regex-Argument angegeben wird, wird standardmäßig Folgendes verwendet .)
• [ beginnt das optionale reguläre Ausdrucksargument für r
• (?![aeiouy])\w der reguläre Ausdruck, der mit einem beliebigen Konsonantenzeichen außer y übereinstimmt (leider erlaubt JavaScript keine Zeichenklassen-Subtraktion)
• ]Normalerweise endet optionales reguläres Argument für r, aber wir brauchen es nicht, da es die letzte Funktion und das letzte Argument ist

Matlab, 67 Zeichen

Für eine Eingabe 'this is a string of- stuff.'

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

produziert s = ffit is a fgnirt os- ssuht.

siist der Index der Konsonanten in der Eingabezeichenfolge. Die abschließende Anweisung ersetzt diese Zeichen durch dieselben Zeichen, jedoch in umgekehrter Reihenfolge durch Indizierung.

PowerShell , 81 Byte

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

Probieren Sie es online!

Weniger golfen:

$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

Probieren Sie es online!

q / kdb + 45 Bytes

Lösung:

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

Erläuterung:

Finden Sie die Indizes der Konsonanten und ersetzen Sie sie durch die umgekehrten Konsonanten:

{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

Anmerkungen:

Ich hatte 3 Möglichkeiten, die Konsonantenliste zu erstellen, die in der Lösung ist etwas besser als die Alternativen:

• "bcdfghjklmnpqrstvwxz" für 22 Zeichen (am langweiligsten)
• .Q.a _/0 3 6 11 16 19 für 21 Zeichen (irgendwie cool, lassen Sie jeden Index fallen)
• .Q.a except"aeiouy" für 19 Zeichen (zweitlangweiligste)

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

Erläuterung

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

Probelauf

$ 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

Probieren Sie es online aus

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

Probieren Sie es online!

Hinweis: Gibt Compiler-Warnungen an stderr aus.
Erläuterung:

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

Ich werde nicht lügen, mein einziges Ziel war es, diese Antwort zu schlagen

APL (Dyalog Extended) , 22 Byte

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

Probieren Sie es online!