Program powinien pobrać ciąg znaków i odwrócić w nim spółgłosek, zachowując kolejność samogłosek. Wszystkie litery będą pisane małymi literami, więc nie musisz się martwić o obudowę. Przykłady podano poniżej.

1. Wejście: a test case.
   Spółgłoski są tutaj t,s,t,c,s. Powinny one pochodzić w odwrotnej kolejności, tzn s,c,t,s,ti wstawiony z powrotem do napisu na tych samych stanowiskach, na których znajdowały się wstępnie odwrócone znaki: a sect sate.

2. Wejście: well-done. Wyjście: nedl-lowe.

3. Wejście: reverse the consonants. Wyjście: setenne sne cohtosarvr.

To jest kod golfowy, wygrywa najkrótsze rozwiązanie.

Y należy uważać za samogłoskę bez względu na to, co to jest, a nie odwróconą.

Wszystko, jak również liczby, znaki interpunkcyjne, cudzysłowy i inne symbole ( @#$%^&*(){}[]\|/<>~-_+=`), mogą potencjalnie pojawić się na wejściu.

Siatkówka oka, 22 21 20 17

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

Wypróbuj online!

1 bajt dzięki Dziurawej Zakonnicy!

4 bajty dzięki Martinowi!

Ooznacza sortuj i #oznacza sortuj według wartości liczbowej. Ponieważ żaden z dopasowanych znaków nigdy nie będzie miał wartości liczbowej, wszystkie litery mają tę samą wagę: 0. ^oznacza odwrócenie kolejności sortowanych wartości, co dzięki stabilnemu sortowaniu oznacza, że ​​wartości są odwrócone.

Te -[...]środki, aby zrobić różnicę setwise pomiędzy zewnętrzną klasy postaci i tej wewnętrznej klasy. Jest to część .NET i możesz przeczytać więcej na MSDN .

Python 2, 86 bajtów

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

Pobiera dane wejściowe jako ciąg znaków w cudzysłowie. Iteruje przez dane wejściowe, zastępując każdą spółgłoskę %sin s. Krotka cprzechowuje napotkane spółgłosek w odwrotnej kolejności. Następnie formatowanie ciągów zastępuje litery %s„s” sspółgłoskami „in” c.

Podziękowania dla Sp3000 za sprawdzenie spółgłoski, co pozwoliło zaoszczędzić 4 bajty na liście spółgłosek.

Galaretka , 22 20 bajtów

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

Wypróbuj online!

Jak to działa

Ø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 bajtów

Zapisano bajt dzięki Martinowi i Dziurawej Zakonnicy oraz 2 bajty Neilowi!

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

Testowanie

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 bajtów

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)

Oczekuje danych wejściowych "quotes", które moim zdaniem są dozwolone.

Pyke, 18 bajtów

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

Wypróbuj tutaj!

lub 16 bajtów w nowej wersji:

(Zmień, więc jeśli dla zwraca wszystkie dane wyjściowe ciągów i miał dane wejściowe, zwraca ciąg zamiast listy)

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

Wypróbuj tutaj!

~c zawiera spółgłosek: bcdfghjklmnpqrstvwxz

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

GNU sed, 73

Wynik obejmuje +1 za -rflagę przekazaną do sed.

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

Ideone.

Wielokrotnie przełącza pierwszą i ostatnią małą spółgłoskę i konwertuje je na wielkie litery, dopóki nie będzie więcej dopasowań. Następnie przekonwertuj cały ciąg z powrotem na małe litery.

J, 53 bajty

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

Może nie jest to najlepszy sposób, ale chciałem użyć, C.ponieważ można to rozwiązać za pomocą permutacji.

Stosowanie

   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

Wyjaśnienie

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 bajtów

tt2Y211Y2'y'hX-m)P5M(

1 bajt zapisany dzięki @Luis

Niestety najdłuższą częścią tego jest uzyskanie listy spółgłosek ( 2Y211Y2'y'hX-).

Wypróbuj online!

Wyjaśnienie

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

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

+4 kara za bieg z -0777flagą, która ustawia Perla w tryb slurp, aby poprawnie obsługiwać nowe linie.

Akceptuje wprowadzanie przez STDIN i drukuje do STDOUT.

Wyjaśnienie

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

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

Rozdzielenie /([^\W\d_aeiouy])/powoduje, że spółgłoski spadają w nieparzystych wpisach w tablicy. Następnie wystarczy zamienić te wpisy z równoważnym wpisem odliczającym od końca tablicy i połączyć wynik razem.

JavaScript (ES6), 57 70

Edytuj Niesamowite 20% oszczędności dzięki x @ Neil

Późno na imprezę, ale wydaje się, że wszyscy javascript coś przeoczyli

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 bajtów

Zaoszczędzono 37 bajtów dzięki pomocy @manatwork . ;-)

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

Tłumaczenie rozwiązania @Lynn Python na Perla.

Pyth, 26 25 24 23 bajtów

si: Q ++ \ [JG „aeiouy” \] 3_ @ J
JG „aeiouy” sm? @DJ @ _ @ JQ ~ hZ <- po prostu zachowuję to z powodu @ _ @
JG „aeiouy” sm? @ DJ @@ JQ = tZ
sm? @ dJ-G „aeiouy” @@ JQ = tZ
sm | -dJ-G "aeiouy" @@ JQ = tZ

Zestaw testowy.

Julia, 53 bajty

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

To pobiera tablicę znaków jako dane wejściowe i odwraca spółgłoski w miejscu. Wypróbuj online!

Kredyt trafia do @ Sp3000 za sprawdzanie spółgłoski małymi literami.

Jak to działa

i=find(...,s)zwraca wszystkie indeksy s, dla których predykat ... zwraca true i zapisuje je jako zmienną i .

c->'}'>c∉"aeiouy"<"$c"wykonuje trzy testy i zwraca wartość true tylko wtedy, gdy wszystkie są dodatnie.

• '}'>csprawdza, czy znak c jest przed { .

• "aeiou"sprawdza, czy ciąg c występuje po a .

• c∉"aeiouy"sprawdza, czy c nie jest samogłoską.

Na koniec s[i]zwraca wszystkie spółgłosek i s[flipud(i)]=s[i]przypisuje je do pozycji ws, które odpowiadają odwróconym indeksom wi .

Java, 319 305 261 188 bajtów

Podziękowania dla @ Leaky Nun za pomoc w tym :-)

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

Stary:

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

Inspiracja zaczerpnięta stąd ❤

Nie golfił

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

Rubin, 53 50 bajtów

-3 bajty z @manatwork

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

Wypróbuj tutaj

Python 2, 103 98 100 bajtów

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

Port mojej odpowiedzi JavaScript. Edycja: Zapisałem 5 bajtów dzięki @ Dennis ♦, z których natychmiast musiałem wydać dwie cyfry poprawiające.

R, 120 bajtów

Nowa odpowiedź:

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

przyjmuje ciąg znaków jako x

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

Stara odpowiedź poniżej (110 bajtów) była z mojej strony kiepska, co właśnie odwróciło spółgłosek:

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 bajtów

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

⎕a~'aeoiuy'małe litery bez samogłosek
t←⍞przechowują wprowadzane znaki jako t
c←( … )∊przechowują logiczne „spółgłoski?” jak c
t/⍨ ekstrakt (spółgłosek) z t
⌽ odwróć
(c/t)←zamień spółgłosek z (odwrócone)
tzwraca zmodyfikowany ciąg

Python 2.7, 144 bajty

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)

To najpierw buduje odwróconą listę spółgłosek, a następnie wstawia każdy z pozostałych znaków z powrotem w oryginalnym indeksie.

Bez golfa:

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

Matematyka 216 bajtów

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 bajtów

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

Aktualizacja

Rozwiązanie @ atlasologa uświadomiło mi, że potrzebuję tylko listy spółgłosek zamiast par (nie trzeba ich jednak odwracać, ponieważ używam prawego zagięcia).

Nie golfił

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

Stary

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

Tworzy listę par spółgłosek, a następnie przechodzi przez łańcuch, zastępując każdą spółgłoskę, używając tej listy.

Trochę prymitywne, ale chciałem to zrozumieć, nie patrząc najpierw na odpowiedzi. :)

s-lang ,17 16 bajtów (niekonkurujących)

Zapisano jeden bajt, ponieważ s-lang nie wymaga już ostatniego nawiasu argumentów

Wypróbuj online!

r[(?![aeiouy])\w

Zacząłem pracować nad językiem golfowym do manipulacji strunami (od dłuższego czasu chciałem to zrobić) i pomyślałem, że będzie to zabawne pytanie.

Wyjaśnienie:

• rodwraca ciąg z danym dopasowaniem wyrażenia regularnego (jeśli nie podano argumentu wyrażenia regularnego, domyślnie będzie to .)
• [ rozpoczyna opcjonalny argument wyrażenia regularnego dla r
• (?![aeiouy])\w regex pasujący do dowolnego znaku spółgłoskowego z wyłączeniem y (niestety JavaScript nie pozwala na odejmowanie klas znaków)
• ]zwykle kończy opcjonalny argument wyrażenia regularnego dla r, ale nie jest nam potrzebny, ponieważ jest to ostatnia funkcja i ostatni argument

Matlab, 67 znaków

Dla wejścia 'this is a string of- stuff.'

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

produkuje s = ffit is a fgnirt os- ssuht.

sito wskaźniki spółgłosek w ciągu wejściowym. Ostatnia instrukcja zastępuje te znaki tymi samymi znakami, ale w odwrotnej kolejności przez indeksowanie.

PowerShell , 81 bajtów

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

Wypróbuj online!

Mniej golfa:

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

PowerShell , 88 bajtów, -f

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

Wypróbuj online!

q / kdb +, 45 bajtów

Rozwiązanie:

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

Wyjaśnienie:

Znajdź indeksy spółgłosek i zamień je na odwrócone spółgłosek:

{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

Uwagi:

Miałem 3 sposoby na zbudowanie listy spółgłoskowej, ta w rozwiązaniu jest nieco lepsza niż alternatywy:

• "bcdfghjklmnpqrstvwxz" na 22 znaki (najbardziej nudne)
• .Q.a _/0 3 6 11 16 19 na 21 znaków (trochę fajnie, upuść każdy indeks)
• .Q.a except"aeiouy" na 19 znaków (drugi najbardziej nudny)

Jq 1,5 , 289 263 bajtów

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

Wyjaśnienie

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

Przykładowy przebieg

$ 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

Wypróbuj online

Java 8, 157 bajtów

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

Wypróbuj online!

Uwaga: wypisuje ostrzeżenia kompilatora na stderr.
Wyjaśnienie:

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

Nie będę kłamał, moim jedynym celem było pokonanie tej odpowiedzi

APL (Dyalog Extended) , 22 bajty

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

Wypróbuj online!