程序应以字符串作为输入，并在保持元音顺序的同时反转其辅音。所有字母都是小写，因此您不必担心大小写。示例如下。

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。^表示颠倒排序值的顺序，这归功于稳定的排序意味着将值颠倒了。

的-[...]手段做外字符类和这个内部类之间的逐集合差。这是.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的辅音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字节

感谢Martin和Leaky Nun分别节省了一个字节，向Neil节省了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"，我认为是允许的。

Pyke，18个字节

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

在这里尝试！

或16个字节（使用新版本）：

（更改，以便如果for返回所有字符串输出并具有字符串输入，则返回string而不是列表）

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岁

得分包括-r传递给sed 的标志的+1 。

:
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(

@Luis节省了1个字节

不幸的是，其中最长的部分是获取辅音列表（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

带-0777标志运行将导致+4罚款，这会将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％节省@xNeil

聚会晚了，但似乎所有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字节

感谢@manatwork的帮助，节省了37个字节。;-)

$_=<>;@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)得出谓词...返回true的s的所有索引，并将其保存为变量i。

c->'}'>c∉"aeiouy"<"$c"执行且仅当全部为正时，才返回true。

• '}'>c检查字符c是否在{之前。

• "aeiou"检查该字符串 Ç来后一个。

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

Ruby，53个 50字节

@manatwork的-3个字节

->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回答的端口。编辑：感谢@ Dennis♦，节省了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="")
}

将字符串作为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，157131字节

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的解决方案使我意识到我只需要一个辅音列表而不是配对（尽管由于我使用了正确的折叠方式，所以不需要颠倒它们）。

不打高尔夫球

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-郎，17 16个字节（非竞争）

保存了一个字节，因为s-lang不再需要最后一个参数括号

在线尝试！

r[(?![aeiouy])\w

我开始研究一种字符串操纵高尔夫球语言（我已经想做一段时间了），我认为这是一个很有趣的问题。

说明：

• r用给定的正则表达式字符匹配器反转字符串（如果未提供正则表达式参数，则默认为.）
• [ 开始可选的regex参数 r
• (?![aeiouy])\w 正则表达式匹配除y以外的任何辅音字符（不幸的是，JavaScript不允许字符类减法）
• ]通常以结束可选的regex参数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扩展），22字节

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

在线尝试！