Let's Encrypt It!


12

Sfida

La sfida è crittografare una determinata stringa, usando le regole come specificato di seguito. La stringa conterrà solo alfabeti minuscoli , cifre e / o spazi vuoti .

Equivalente di un personaggio

Ora, prima di tutto dovresti sapere come trovare "l'equivalente" di ogni personaggio.

Se il personaggio è una consonante, questo è il modo di trovarlo 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.

ad esempio: 'h' e 't' sono equivalenti l'uno dall'altro perché 'h', 't' sono rispettivamente in sesta posizione dall'inizio e dalla fine.

La stessa procedura è seguita per trovare l'equivalente di vocali / cifre. Elencate tutte le vocali o le cifre (a partire da 0) in ordine e trovate l'equivalente.

Di seguito è riportato l'elenco degli equivalenti di tutti i caratteri:

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

Regole di crittografia

1) Inizi a muoverti da sinistra e vai verso destra.

2) Se il personaggio è una consonante / cifra, viene preso il suo equivalente e se è uno spazio vuoto, viene preso uno spazio vuoto.

3) Se il personaggio è una vocale, prendi l'equivalente e inizi a muoverti nella direzione opposta. Ad esempio, se ti sposti a destra e incontri una vocale, crittografa quel carattere, quindi salta al carattere non crittografato più a destra e inizia a crittografare nella direzione sinistra e viceversa.

4) Non dovresti considerare un personaggio nella stessa posizione due volte. I passaggi devono essere seguiti fino a quando tutti i caratteri nell'input sono coperti.

5) Il numero totale di caratteri nell'input (inclusi gli spazi vuoti) dovrebbe essere uguale al numero totale di caratteri nell'output.

Si noti che i caratteri crittografati vengono visualizzati nell'output nell'ordine in cui sono stati crittografati.

Ora lasciami crittografare una stringa per te.

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"

Esempi

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

Puoi anche scegliere di usare alfabeti maiuscoli anziché minuscoli.

punteggio

Questo è , quindi vince il codice più corto!


1
Il passaggio 3 non è chiaro per quanto riguarda le direzioni di commutazione. Penso che dovresti dire qualcosa del tipo "Se ti stai muovendo a destra e incontri una vocale, crittografa quel carattere, quindi salta al carattere non crittografato più a destra e inizia a crittografare nella direzione sinistra." (Se è quello che vuoi dire). Penso che dovresti anche specificare esplicitamente che i caratteri crittografati compaiono nell'output nell'ordine in cui sono stati crittografati.
Dylnan,

@dylnan L'ha aggiunto.
Manish Kundu

Solo per curiosità: puoi descrivere la procedura di decrittazione? Perché la funzione di crittografia non è propriamente inversa (come in algo ROT13). Quindi, se passiamo i dati crittografati alla stessa procedura di cifratura, non otterremo il testo originale. Grazie
Agnius Vasiliauskas l'

1
@AgniusVasiliauskas: Un modo per farlo sarebbe: applicare le stesse trasformazioni del personaggio. Mantieni 2 stringhe di decrittografia. Passa sopra la stringa da sinistra a destra. Alternare tra aggiungere caratteri alla prima stringa e anteporre alla seconda ogni volta che si maneggia una vocale. Unisci le stringhe alla fine.
Emigna

3
Presto ci sarà una sfida di decodifica per lo stesso, in cui proverò a spiegare il processo
Manish Kundu,

Risposte:


4

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

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

Provalo online!

Nella prima iterazione Stringverrà modificato in Arraye le successive iterazioni continueranno a essere utilizzate Array. Ecco!

Approccio originale (166 byte):

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

&non ha funzionato per alcuni numeri ma ha &&funzionato. Grazie.
Shieru Asakoto,

Oh sì, non ho trovato un metodo per ottimizzarlo e tu l'hai fatto! Grazie!
Shieru Asakoto,

3
124 byte usando la stessa stringa per tutte le lettere e applicando un po 'più di golf.
Arnauld,

Wow geniale! Non ho pensato di combinare le corde TUTTO
Shieru Asakoto

q=="0"|+qè in realtà 1 byte più corto di q>" "&&1/q.
Arnauld

3

05AB1E , 22 byte

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

Provalo online! o come una suite di test

Spiegazione

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

žhžMžN)UvćXJXíJ‡D?žMsåiRera quello che stavo pensando di migliorare, ma non posso ridurre XJXiJabbastanza.
Magic Octopus Urn

@MagicOctopusUrn: ho avuto un'idea simile con la DJsíJquale non era neanche molto efficace.
Emigna,

1

C, 196 byte

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

Provalo online!


1

J , 132 byte

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
)

Provalo online!

Un verbo esplicito dettagliato questa volta.

Spiegazione:

c=.(u:97+i.26) fa una lista az

v=.'aeiou' fa un elenco di vocali

-. rimuove le vocali dall'elenco delle lettere

d=.u:48+i.10 crea un elenco di cifre

g=.;"0|. un verbo di utilità per la creazione di un elenco di coppie inscatolate di simboli di sostituzione

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

a=.'' un elenco per memorizzare il risultato

while.*#y do.a=.a,{.y rplc(g c),(g d),g v mentre la lunghezza dell'elenco è> 0 prendi un simbolo, sostituiscilo e aggiungilo al risultato

y=.|.^:({:a e.v)}.y rilascia un simbolo dall'inizio dell'elenco e se il simbolo è una vocale, inverti l'elenco

end.termina il whileciclo

a restituisce il risultato


1

Pulito , 221 206 198 190 186 178 byte

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

Provalo online!


0

Retina , 78 byte

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

V`

Provalo online! Il link include casi di test. Spiegazione:

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

Scambia ogni personaggio con il suo equivalente.

/[aeiou]/{

Ripeti finché rimane una vocale.

*>0L`.*?[aeiou]

Stampa il testo fino alla vocale.

0`.*?[aeiou]

Elimina il testo fino alla vocale.

V`

Invertire il testo rimanente. Quando non sono rimaste vocali, questo viene quindi implicitamente emesso, tuttavia ai fini dei casi di test, l'intestazione emette il testo alla fine di ogni riga.


0

Stax , 24 byte

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

Eseguirlo

Ecco la rappresentazione ascii dello stesso programma.

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

Traduce prima ogni classe di caratteri, quindi inizia un ciclo while. Nel ciclo, emette il carattere successivo e inverte in modo condizionale il resto della stringa se viene rilevata una vocale.

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
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.