Desafio

O desafio é criptografar uma determinada sequência, usando as regras especificadas abaixo. A sequência conterá apenas letras minúsculas , dígitos e / ou espaços em branco .

Equivalente a um personagem

Agora, primeiro você precisaria saber como encontrar o "equivalente" de cada personagem.

Se o personagem é uma consoante, esta é a maneira de descobrir que é equivalente:

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.

por exemplo: 'h' e 't' são equivalentes entre si porque 'h', 't' estão na 6ª posição do início e do fim, respectivamente.

O mesmo procedimento é seguido para encontrar o equivalente a vogais / dígitos. Você lista todas as vogais ou dígitos (começando em 0) em ordem e encontra o equivalente.

Dada a seguir, é apresentada a lista dos equivalentes de todos os caracteres:

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

Regras de criptografia

1) Você começa a se mover da esquerda e vai para a direita.

2) Se o caractere for uma consoante / dígito, seu equivalente será utilizado e, se for um espaço em branco, será utilizado um espaço em branco.

3) Se o personagem é uma vogal, você pega o equivalente e começa a se mover na direção oposta. Por exemplo, se você estiver se movendo para a direita e encontrar uma vogal, criptografe esse caractere, pule para o caractere não criptografado mais à direita e comece a criptografar na direção esquerda e vice-versa.

4) Você não deve considerar um personagem na mesma posição duas vezes. As etapas devem ser seguidas até que todos os caracteres na entrada sejam cobertos.

5) O número total de caracteres na entrada (incluindo espaços em branco) deve ser igual ao número total de caracteres na saída.

Observe que os caracteres criptografados aparecem na saída na ordem em que foram criptografados.

Agora, deixe-me criptografar uma string para você.

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"

Exemplos

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

Você também pode optar por usar letras maiúsculas em vez de letras minúsculas.

Pontuação

Isso é código-golfe , então o código mais curto vence!

JavaScript (Node.js) , 173 ... 166 156 ... 124 123 bytes

-28 byte Obrigado 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

Experimente online!

Na primeira iteração, a Stringalteração será alterada para Arraye as iterações subsequentes continuarão sendo usadas Array. Voilà!

Abordagem original (166 bytes):

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 bytes

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

Experimente online! ou como um conjunto de testes

Explicação

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 bytes

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

Experimente online!

J , 132 bytes

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
)

Experimente online!

Um verbo explícito detalhado desta vez.

Explicação:

c=.(u:97+i.26) faz uma lista az

v=.'aeiou' faz uma lista de vogais

-. remove as vogais da lista de letras

d=.u:48+i.10 faz uma lista de dígitos

g=.;"0|. um verbo utilitário para criar uma lista de pares em caixa de símbolos de substituição

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

a=.'' uma lista para armazenar o resultado

while.*#y do.a=.a,{.y rplc(g c),(g d),g v enquanto o comprimento da lista for> 0, pegue um símbolo, substitua-o e anexe-o ao resultado

y=.|.^:({:a e.v)}.y solte um símbolo do início da lista e, se o símbolo for uma vogal, inverta a lista

end.termina o whileloop

a retorna o resultado

Limpo , 221 206 198 190 186 178 bytes

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

Experimente online!

Retina , 78 bytes

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

V`

Experimente online! O link inclui casos de teste. Explicação:

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

Troque cada personagem pelo seu equivalente.

/[aeiou]/{

Repita enquanto uma vogal permanece.

*>0L`.*?[aeiou]

Envie o texto até a vogal.

0`.*?[aeiou]

Exclua o texto até a vogal.

V`

Inverta o texto restante. Quando não há vogais restantes, isso é emitido implicitamente; no entanto, para os propósitos dos casos de teste, o cabeçalho gera o texto no final de cada linha.

Stax , 24 bytes

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

Executá-lo

Aqui está a representação ascii do mesmo programa.

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

Ele traduz cada classe de personagem primeiro e depois inicia um loop while. No loop, ele gera o próximo caractere e reverte condicionalmente o restante da string se uma vogal for encontrada.

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