挑战

挑战在于使用以下指定的规则对给定的字符串进行加密。该字符串将仅包含小写字母，数字和/或空格。

等效字符

现在，首先，您将需要知道如何查找每个字符的“等效”字符。

如果字符是辅音，则可以通过以下方法找到它的等价物：

1) List all the consonants in alphabetical order
    b c d f g h j k l m n p q r s t v w x y z
2) Get the position of the consonant you are finding the equivalent of.
3) The equivalent is the consonant at that position when starting from the end.

例如：“ h”和“ t”彼此等效，因为“ h”和“ t”分别位于从开始和结束的第6个位置。

遵循相同的过程来找到等效的元音/数字。您可以按顺序列出所有元音或数字（从0开始）并找到等效项。

以下是所有字符的等效列表：

b <-> z
c <-> y
d <-> x
f <-> w
g <-> v
h <-> t
j <-> s
k <-> r
l <-> q
m <-> p
n <-> n

a <-> u
e <-> o
i <-> i

0 <-> 9
1 <-> 8
2 <-> 7
3 <-> 6
4 <-> 5

加密规则

1）您开始从左侧移动到右侧。

2）如果字符是辅音/数字，则使用等效字符；如果是空格，则使用空格。

3）如果字符是元音，则将其视为等效，然后开始朝相反的方向移动。例如，如果您向右移动并遇到一个元音，请对该字符进行加密，然后跳到最右边的未加密字符，然后开始向左方向加密，反之亦然。

4）您不应该两次考虑相同位置的字符。应该遵循这些步骤，直到输入中的所有字符都被覆盖为止。

5）输入中的字符总数（包括空格）应等于输出中的字符总数。

请注意，加密字符以加密顺序出现在输出中。

现在，让我为您加密一个字符串。

String = "tre d1go3t is"
Moving left to right
"t" -> "h"
"r" -> "k"
"e" -> "o"
Vowel encountered. Now moving right to left.
"s" -> "j"
"i" -> "i"
Vowel encountered. Now moving left to right.
" " -> " "
"d" -> "x"
"1" -> "8"
"g" -> "v"
"o" -> "e"
Vowel encountered. Now moving right to left.
" " -> " "
"t" -> "h"
"3" -> "6"

Output -> "hkoji x8ve h6"

例子

"flyspy" -> "wqcjmc"
"hero" -> "toek"
"heroic" -> "toyike"
"ae" -> "uo"
"abe" -> "uoz"
"the space" -> "htoo jmuy"
"a d1g13t" -> "uh68v8x "
"we xi12" -> "fo78i d"
"this is a code" -> "htioj ixej uy "

您也可以选择使用大写字母而不是小写字母。

计分

这是代码高尔夫球，因此最短的代码获胜！

的JavaScript（Node.js的），173 ... 166 156 ... 124个 123字节

-28字节谢谢Arnauld

f=([q,...s])=>q?(c="aeioubcdfghjklmpqrstvwxyz",t=c.search(q),q=="0"|+q?9-q:~t?c[(t<5?4:29)-t]:q)+f(~t&&t<5?s.reverse():s):s

在线尝试！

在第一个迭代中，String它将更改为Array，随后的迭代将继续使用Array。瞧！

原始方法（166字节）：

f=(s,i=0,r=s.length,d=1,c="bcdfghjklmnpqrstvwxyz",v="aeiou")=>(d^=!!(t=~v.search(q=s[d?i:r])),q<"0"|q>"9"?c[20-c.search(q)]||v[5+t]||q:9-q)+(i<r-1?f(s,i+d,r-!d,d):"")

05AB1E，22字节

vćžN‡žM‡žh‡D?žMsåiR

在线尝试！ 或作为测试套件

说明

v                        # for each char in input
 ć                       # extract the head of the current string (initially input)
  žN‡                   # transform consonants
      žM‡               # transofrm vowels
          žh‡           # transform numbers
              D?         # print a copy of the current char
                žMsåi    # if the current char is a vowel
                     R   # reverse the rest of the string

C，196字节

#define C(k,m)for(i=m;i--;)k[i]-c||putchar(k[m+~i],r^=m==5);
r;p(c,i){C("bcdfghjklmnpqrstvwxyz",21)C("0123456789",10)C("aeiou",5)C(" ",1)}f(S){char*s=S,*t=s+strlen(s);for(r=1;s<t;)p(r?*s++:*--t);}

在线尝试！

J，132字节

f=:3 :0
c=.(u:97+i.26)-.v=.'aeiou'
d=.u:48+i.10
g=.;"0|.
a=.''
while.*#y do.a=.a,{.y rplc(g c),(g d),g v
y=.|.^:({:a e.v)}.y
end.a
)

在线尝试！

这次是一个冗长的显式动词。

说明：

c=.(u:97+i.26) 列出清单

v=.'aeiou' 列出元音

-. 从字母列表中删除元音

d=.u:48+i.10 列出数字

g=.;"0|. 一个实用动词，用于创建一盒替换符号对的列表

   g d
┌─┬─┐
│0│9│
├─┼─┤
│1│8│
├─┼─┤
│2│7│
├─┼─┤
│3│6│
├─┼─┤
│4│5│
├─┼─┤
│5│4│
├─┼─┤
│6│3│
├─┼─┤
│7│2│
├─┼─┤
│8│1│
├─┼─┤
│9│0│
└─┴─┘

a=.'' 存储结果的列表

while.*#y do.a=.a,{.y rplc(g c),(g d),g v 当列表的长度> 0时，取一个符号，将其替换并附加到结果中

y=.|.^:({:a e.v)}.y 从列表的开头删除一个符号，如果该符号是元音，则反转列表

end.结束while循环

a 返回结果

干净，221个 206 198 190 186 178字节

import StdEnv
r=reverse
l=['bcdfghjklm01234aeou56789pqrstvwxyz']
$s#(a,b)=span(\e=all((<>)e)['aeiou'])s
|s>[]=[j\\e<-a++b%(0,0),i<-['in ':l]&j<-['in ':r l]|e==i]++ $(init(r b))=s

在线尝试！

视网膜，78字节

T`dl`9-0uz-x\ow-vtis-pnem-j\hagfd-b
/[aeiou]/{*>0L`.*?[aeiou]
0`.*?[aeiou]

V`

在线尝试！链接包括测试用例。说明：

T`dl`9-0uz-x\ow-vtis-pnem-j\hagfd-b

交换每个字符及其等效字符。

/[aeiou]/{

保留元音时重复。

*>0L`.*?[aeiou]

将文本输出到元音。

0`.*?[aeiou]

删除直到元音的文本。

V`

反转剩余的文本。如果没有元音，则将其隐式输出，但是出于测试用例的目的，标题将在每行末尾输出文本。

Stax，24 个字节

╥j•td╢Ä;Sµ*ûⁿvÉ╫î▓J o╩π╗

运行

这是同一程序的ascii表示。

VcGVdGVvGwB]qVvs#!Hv*c}cr\$|t

它首先翻译每个字符类，然后开始while循环。在循环中，它输出下一个字符，如果遇到元音，则有条件地反转字符串的其余部分。

VcG                             Push lowercase consonants and jump to trailing }
   VdG                          Push digits and jump to trailing }
      VvG                       Push lowercase vowels and jump to trailing }
         wB]qVvs#!Hv*c          While; run this block until popped value is falsy
          B]                    Split first character off string 
            q                   Output with no newline; keep on the stack
             Vvs#               1 if letter is a vowel, 0 otherwise
                 !Hv            Not, Double, then Decrement
                                    -1 for vowels, 1 otherwise
                    *           Multiply string. -1 causes reversal       
                     c          Copy value to be popped as while condition
                      }         Jump target from above.  Return when done.
                       cr\$     Copy, reverse, zip, and flatten.
                           |t   Translate: use string as a character map
                                    for replacements