Програма повинна брати рядок як вхідний і зворотний в ньому приголосних, зберігаючи порядок голосних. Усі літери будуть малі, тому не потрібно хвилюватися про обробку. Наступні приклади.

1. Вхід: a test case.
   Приголосні тут є t,s,t,c,s. Вони повинні прийти в зворотному порядку, тобто s,c,t,s,tі вставити назад в рядок в одних і тих же місцях , де були розташовані попередньо зверненим символи: a sect sate.

2. Вхід: well-done. Вихід: nedl-lowe.

3. Вхід: reverse the consonants. Вихід: setenne sne cohtosarvr.

Це кодовий гольф, виграє найкоротше рішення.

Y слід вважати голосною незалежно від того, що вона є, а не відміняти.

Все, а також цифри, пунктуація, лапки та інші символи ( @#$%^&*(){}[]\|/<>~-_+=`), потенційно можуть відображатися у вводі.

Сітківка, 22 21 20 17

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

Спробуйте в Інтернеті!

1 байт завдяки Leaky Nun!

4 байти дякую Мартіну!

Oозначає сортувати, і #означає сортувати за числовим значенням. Оскільки жоден з відповідних символів ніколи не матиме числового значення, всі літери мають однакову вагу: 0. ^означає повернути порядок відсортованих значень, що завдяки стабільному сортуванню означає, що значення змінюються на зворотному рівні.

В -[...]кошти , щоб зробити різницю setwise між зовнішнім символьним класом , і цим внутрішнім класом. Це частина .NET, і ви можете прочитати більше на MSDN .

Python 2, 86 байт

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

Приймає введення в якості лапки в лапки. Ітератує через вхід, замінюючи кожен приголосний на %sв s. Кортеж cзберігає зустрічні приголосні у зворотному порядку. Потім форматування рядків замінює %s's у sприголосними в c.

Завдяки Sp3000 за перевірку приголосних, яка врятувала 4 байти за перелік приголосних.

Желе , 22 20 байт

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

Спробуйте в Інтернеті!

Як це працює

Ø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 байт

Збережено байт завдяки кожному Мартіну та Ліна монахині та 2 байти Нілу!

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

Тестування

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 байт

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)

Очікує введення в "quotes", що, на мою думку, дозволено.

Пайк, 18 байт

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

Спробуйте тут!

або 16 байт з новою версією:

(Змініть так, якщо для повернення всього рядкового виводу і було введення рядка, поверніть рядок замість списку)

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

Спробуйте тут!

~c містить приголосні: bcdfghjklmnpqrstvwxz

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

GNU sed, 73

Оцінка включає +1 для -rпрапора, переданого до с.

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

Ідеон.

Неодноразово перемикає перший і останній малі приголосні і перетворює їх у верхній регістр, поки не буде більше збігів. Потім перетворіть всю нитку назад в малі регістри.

J, 53 байти

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

Можливо, не найкращий спосіб, але я хотів використати, C.оскільки це можна вирішити за допомогою перестановок.

Використання

   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

Пояснення

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 байт

tt2Y211Y2'y'hX-m)P5M(

1 байт збережено завдяки @Luis

На жаль, найдовша частина цього - це перелік приголосних ( 2Y211Y2'y'hX-).

Спробуйте в Інтернеті!

Пояснення

            % 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 байти)

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

+4 штрафу за біг з -0777прапором, який встановлює режим Perl в режимі "slurp", щоб правильно обробляти нові рядки.

Приймає введення через STDIN та друкує до STDOUT.

Пояснення

                   $_=<>;   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 байти

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

Розбиття за /([^\W\d_aeiouy])/результатами приголосних, що потрапляють у записи непарних чисел у масиві. Потім достатньо переключити ці записи з еквівалентним підрахунком запису з кінця масиву і об'єднати результат разом.

JavaScript (ES6), 57 70

Редагувати Дивовижна 20% економія thx @Neil

Пізно на вечірку, але, схоже, всі користувачі JavaScript щось пропустили

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

Тест

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 байт

Збережено 37 байт завдяки допомозі @manatwork . ;-)

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

Переклад рішення @Lynn Python на Perl.

Pyth, 26 25 24 23 байт

si: Q ++ \ [JG "aeiouy" \] 3_ @ J
JG "aeiouy" sm? @DJ @ _ @ JQ ~ hZ <- просто зберігаючи це через @ _ @
JG "aeiouy" sm? @ DJ @@ JQ = tZ
sm? @ dJ-G "aeiouy" @@ JQ = tZ
sm | -dJ-G "aeiouy" @@ JQ = tZ

Тестовий набір.

Джулія, 53 байти

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

Це приймає символьний масив як вхідний і повертає його приголосні на місце. Спробуйте в Інтернеті!

Кредит належить до @ Sp3000 для перевірки приголосних рядків.

Як це працює

i=find(...,s)дає всі індекси s, для яких предикат ... повертає true та зберігає їх змінну i .

c->'}'>c∉"aeiouy"<"$c"виконує три тести і повертає істину, якщо і тільки якщо всі позитивні.

• '}'>cперевіряє, чи не надходить символ c до { .

• "aeiou"перевіряє, чи є рядок c після a .

• c∉"aeiouy"перевіряє, що c не є голосним.

Нарешті, s[i]поступається всім приголосним і s[flipud(i)]=s[i]призначає їх на позиції в s, які відповідають зворотним індексам в i .

Java, 319 305 261 188 байт

Подяку @ Leaky Nun за допомогу в цьому :-)

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

Старий:

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

Натхнення, взяте звідси ❤

Безумовно

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

Рубі, 53 50 байт

-3 байти від @manatwork

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

Спробуйте тут

Python 2, 103 98 100 байт

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

Порт моєї відповіді на JavaScript. Редагувати: Збережено 5 байтів завдяки @ Dennis ♦, з яких мені негайно довелося витратити дві фіксуючі цифри.

R, 120 байт

Нова відповідь:

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

приймає символьний рядок як x

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

Старий відгук нижче (110 байт) був поганою формою з мого боку, що просто перевернуло приголосні:

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 байт

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

⎕a~'aeoiuy'рядковий алфавіт без голосних
t←⍞зберігає введення символів як t
c←( … )∊зберігає булевий "приголосний?" як c
t/⍨ витяг (приголосні) з t
⌽ зворотної
(c/t)←заміни приголосних на (зворотні)
tповертають модифікований рядок

Python 2.7, 144 байти

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)

Це спочатку створює перевернутий список приголосних, а потім вставляє всі інші символи назад у їх первісний індекс.

Без гольфу:

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 байт

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 байт

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

Оновлення

@ рішення атласолога дало мені зрозуміти, що мені потрібен лише список приголосних замість пар (не потрібно перевертати їх, хоча я використовую праву складку.)

Безумовно

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

Старий

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

Створює список пар приголосних, а потім проходить по рядку, замінюючи кожного приголосного, використовуючи зазначений список.

Трохи примітивно, але я хотів це зрозуміти, не дивлячись відповіді спочатку. :)

s-lang ,17 16 байт (не конкуруючий)

Збережено один байт, оскільки s-lang більше не потребує останньої дужки аргументів

Спробуйте в Інтернеті!

r[(?![aeiouy])\w

Я почав працювати над гольф-мовою для стринг-маніпуляцій (я хотів це зробити вже деякий час), і думав, що це буде цікаве питання, з яким можна працювати над цим.

Пояснення:

• rповертає рядок із заданим відповідним символом регексу (якщо не вказано аргумент регулярного вираження, він буде за замовчуванням .)
• [ починається необов'язковий аргумент для регулярного вираження для r
• (?![aeiouy])\w регулярний вираз збігається з будь-яким приголосним символом, виключаючи y (на жаль, JavaScript не дозволяє відняти клас символів)
• ]Зазвичай закінчується необов'язковим аргументом для регулярного вираження r, але він нам не потрібен, оскільки це остання функція та останній аргумент

Матлаб, 67 годин

Для введення 'this is a string of- stuff.'

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

виробляє s = ffit is a fgnirt os- ssuht.

si- це індекси приголосних у вхідному рядку. Заключний вислів замінює цих символів тими ж символами, але у зворотному порядку індексуванням.

PowerShell , 81 байт

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

Спробуйте в Інтернеті!

Менше гольфу:

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

PowerShell , 88 байт, -f

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

Спробуйте в Інтернеті!

q / kdb +, 45 байт

Рішення:

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

Пояснення:

Знайдіть індекси приголосних і замініть їх на зворотні приголосні:

{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

Примітки:

У мене було 3 способи побудови списку приголосних, той, що знаходиться в розчині, трохи кращий, ніж альтернативи:

• "bcdfghjklmnpqrstvwxz" на 22 символи (найбільш нудні)
• .Q.a _/0 3 6 11 16 19 для 21 символу (якось круто, опустити кожен індекс)
• .Q.a except"aeiouy" на 19 символів (друга найбільш нудна)

Jq 1,5 , 289 263 байт

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

Пояснення

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

Вибірка зразка

$ 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

Спробуйте в Інтернеті

Java 8, 157 байт

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

Спробуйте в Інтернеті!

Примітка: друкує попередження компілятора на stderr.
Пояснення:

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

Не брешу, моєю єдиною метою було перемогти цю відповідь

APL (Dyalog Extended) , 22 байти

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

Спробуйте в Інтернеті!