Défi

Le défi consiste à chiffrer une chaîne donnée, en utilisant les règles spécifiées ci-dessous. La chaîne ne contiendra que des alphabets minuscules , des chiffres et / ou des espaces vides .

Équivalent d'un personnage

Maintenant, vous devez d'abord savoir comment trouver «l'équivalent» de chaque personnage.

Si le caractère est une consonne, c'est la façon de trouver son équivalent:

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.

par exemple: «h» et «t» sont équivalents l'un de l'autre parce que «h», «t» sont respectivement en 6e position depuis le début et la fin.

La même procédure est suivie pour trouver l'équivalent de voyelles / chiffres. Vous listez toutes les voyelles ou les chiffres (à partir de 0) dans l'ordre et trouvez l'équivalent.

Ci-dessous, la liste des équivalents de tous les caractères:

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

Règles de cryptage

1) Vous commencez à vous déplacer de la gauche et allez vers la droite.

2) Si le caractère est une consonne / un chiffre, alors son équivalent est pris et s'il s'agit d'un espace vide, alors un espace vide est pris.

3) Si le personnage est une voyelle, vous prenez son équivalent et commencez à vous déplacer dans la direction opposée. Par exemple, si vous vous déplacez vers la droite et rencontrez une voyelle, cryptez ce caractère, puis passez au caractère non chiffré le plus à droite et commencez à chiffrer dans la direction gauche, et vice versa.

4) Vous ne devriez pas considérer deux fois un personnage dans la même position. Les étapes doivent être suivies jusqu'à ce que tous les caractères de l'entrée soient couverts.

5) Le nombre total de caractères dans l'entrée (y compris les espaces vides) doit être égal au nombre total de caractères dans la sortie.

Veuillez noter que les caractères cryptés apparaissent dans la sortie dans l'ordre dans lequel ils ont été cryptés.

Permettez-moi maintenant de crypter une chaîne pour vous.

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"

Exemples

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

Vous pouvez également choisir d'utiliser des alphabets majuscules au lieu de minuscules.

Notation

C'est le code-golf , donc le code le plus court gagne!

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

-28 octets Merci 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

Essayez-le en ligne!

Dans la première itération, le Stringsera changé en Array, et les itérations suivantes continueront à être utilisées Array. Voilà!

Approche originale (166 octets):

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 octets

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

Essayez-le en ligne! ou comme suite de tests

Explication

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 octets

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

Essayez-le en ligne!

J , 132 octets

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
)

Essayez-le en ligne!

Un verbe explicite verbeux cette fois.

Explication:

c=.(u:97+i.26) fait une liste az

v=.'aeiou' fait une liste de voyelles

-. supprime les voyelles de la liste des lettres

d=.u:48+i.10 fait une liste de chiffres

g=.;"0|. un verbe utilitaire pour créer une liste de paires encadrées de symboles de remplacement

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

a=.'' une liste pour stocker le résultat

while.*#y do.a=.a,{.y rplc(g c),(g d),g v tandis que la longueur de la liste est> 0, prenez un symbole, remplacez-le et ajoutez-le au résultat

y=.|.^:({:a e.v)}.y déposez un symbole du début de la liste et si le symbole est une voyelle, inversez la liste

end.termine la whileboucle

a renvoie le résultat

Propre , 221 206 198 190 186 178 178 octets

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

Essayez-le en ligne!

Rétine , 78 octets

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

V`

Essayez-le en ligne! Le lien inclut des cas de test. Explication:

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

Échangez chaque personnage avec son équivalent.

/[aeiou]/{

Répétez l'opération pendant qu'il reste une voyelle.

*>0L`.*?[aeiou]

Sortez le texte jusqu'à la voyelle.

0`.*?[aeiou]

Supprimez le texte jusqu'à la voyelle.

V`

Inverse le texte restant. Lorsqu'il n'y a plus de voyelles, elles sont ensuite implicitement sorties, mais pour les besoins des cas de test, l'en-tête sort le texte à la fin de chaque ligne.

Stax , 24 octets

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

Exécuter

Voici la représentation ascii du même programme.

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

Il traduit d'abord chaque classe de caractères, puis commence une boucle while. Dans la boucle, il sort le caractère suivant et inverse conditionnellement le reste de la chaîne si une voyelle est rencontrée.

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