Программа должна принимать строку в качестве входных данных и инвертировать согласные в ней, сохраняя порядок гласных. Все буквы будут строчными, поэтому вам не нужно беспокоиться о регистре. Примеры следуют.

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

Принимает ввод в виде строки в кавычках. Перебирает ввод, заменяя каждый согласный на %sin 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 байтов с новой версией:

(Измените так, если for возвращает все строковые выходные данные и имеет строковые входные данные, возвращает строку вместо списка)

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флага, переданного в sed.

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

Ideone.

Повторно переключает первый и последний нижний регистр согласных и преобразует их в верхний регистр, пока не останется совпадений. Затем преобразуйте всю строку обратно в нижний регистр.

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

си: Q ++ \ [JG "aeiouy" \] 3_ @ J
JG "aeiouy" sm? @DJ @ _ @ JQ ~ hZ <- просто держу это из-за @ _ @
JG "aeiouy" см? @ ДиДжей @@ JQ = TZ
см? @ ДиДжей-G "aeiouy" @@ JQ = TZ
см | -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"выполняет три теста и возвращает true, если и только если все они положительны.

• '}'>cпроверяет, стоит ли символ c перед { .

• "aeiou"проверяет , является ли строка с приходит после того, как а .

• c∉"aeiouy"проверяет, что с не является гласным.

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

Ява, 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);}

Вдохновение взято отсюда ❤

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

Рубин, 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 байтов сохранены благодаря @ Деннис ♦, из которых мне быстро пришлось потратить две фиксирующие цифры.

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

принимает символьную строку как х

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)

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

Un-golfed:

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

Обновить

Решение @ atlasologist заставило меня понять, что мне нужен только список согласных вместо пар (хотя не нужно менять их, поскольку я использую правую складку).

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

старый

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, но нам это не нужно, так как это последняя функция и последний аргумент

Matlab, 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)∊⍨⊢)

Попробуйте онлайн!