rot13 med æøå. :S Yikes

[fontpage]

Hei har lyst og legge til æøå men siden de ikke følger Z på Ascii table så blir det vanskelig, noen som vett hvordan?

message = input("What shal be encoded then? \n\n")
key = 2
coded_message = ""
for ch in message:
   code_val  = ord(ch) + key
   if ch.isalpha():
    if code_val > ord('å'):
	    code_val -= ord('å') - ord('a')
    coded_message = coded_message + chr(code_val)
   else:
print (message)
print (coded_message)

[fontpage]

Bump* Ingen som vett hvordan men gjør dette. :'(

[dabear]

rot13 brukes oftest kun på det engelske alfabetet. Andre bokstaver ignoreres

Æ e en bjønn

==

Æ r ra owøaa

 

Dersom du tar rot13(rot13("enellerannentekst")) vil svaret være "enellerannentekst", fordi det eksisterer 13*2 bokstaver i det engelske alfabetet. Som kjent, har det norske språk 29 bokstaver, som ikke går opp i to. Selv om det er mulig å lage en egen funksjon norsk rot13-funksjon, vil du ikke kunne sørge for at rot13_norsk(rot13_norsk("øl")) == "øl".

 

Ville altså gjort noe sånt for andre bokstaver enn a-z:

coded_message = coded_message + ch

Endret 29. mars 2013 av dabear

[jonny]

ROT13-algoritmen gir vel kun mening når du snakker om 26 tegn, dvs. a-z, slik at a-m blir byttet ut med n-z (chr(ord(ch) + 13)) og n-z blir byttet ut med a-m (chr(ord(ch) - 13)). Du kan sikkert utvide til et slags ROT14-system, der a-n blir byttet ut med p-å og omvendt (og o aldri byttes om). Da kan du for eksempel lage dine egne varianter av chr() og ord()-metodene, slik at du mapper a-å til 0-28. Alle "ugyldige" tegn kan du mappe til en ugyldig verdi (f.eks. -1).

 

Edit: ROT15 blir vel mer riktig... her er en måte å gjøre det på (Python-kode):

 

def myord(c):
   if 'A' <= c <= 'Z': return ord(c) - ord('A');
   if 'a' <= c <= 'z': return ord(c) - ord('a') + 100;
   if c == 'Æ': return 26;
   if c == 'Ø': return 27;
   if c == 'Å': return 28;
   if c == 'æ': return 126;
   if c == 'ø': return 127;
   if c == 'å': return 128;
   return -1;


def mychr(v):
   if 0 <= v <= 25: return chr(v + ord('A'));
   if 100 <= v <= 125: return chr(v + ord('a') - 100);
   if v == 26: return 'Æ';
   if v == 27: return 'Ø';
   if v == 28: return 'Å';
   if v == 126: return 'æ';
   if v == 127: return 'ø';
   if v == 128: return 'å';
   return '.';

def rot15(c):
   cval = myord(c);
   if 0 <= cval < 14: return mychr(cval + 15);
   if 14 < cval <= 28: return mychr(cval - 15);
   if 100 <= cval < 114: return mychr(cval + 15);
   if 114 < cval <= 128: return mychr(cval - 15);
   return c;

s = list("ABCLMNOPQRÆØÅabclmnopqræøå");
for i in range(len(s)): s[i] = rot15(s[i]);
print("".join(s));
for i in range(len(s)): s[i] = rot15(s[i]);
print("".join(s));

Endret 29. mars 2013 av jonny

[puse]

Lag en liste med alfabetet i seg, lettest er a-z. Så iterere du over klarteksten, og om bokstaven ikke er i listen blir den lagt til på slutten. Da ender du opp med en liste som ser ut som det her:

 

["z", "9", "æ"....] 

 

Da kan du bruke liste indexen som den numeriske verdien, og samtidig støtter mer enn bare æøå. Da bare roterer du som vanlig og sjekker om den bokstaven du skal rotere + antall rotasjoner er mindre enn lengden på listen, om den er større må du begynne fra andre enden av listen.

[zotbar1234]

Hei har lyst og legge til æøå men siden de ikke følger Z på Ascii table så blir det vanskelig,

 

Mnja, akkurat vanskelig er det ikke.

 

Det enkleste er kanskje å lage en generell funksjon som lager en substitusjonssiffer der bokstavene forskyves N plasser i alfabetet. Denne funksjonen vil være nødt til å lage både krypterings- og dekrypteringsfunksjon, siden (som flere har påpekt alt) rot13 er dekrypteringsfunksjon kun for alfabeter med 26 symboler. Eller, rettere sagt, rot13 kan generaliseres for rotN, der alfabetet har 2N tegn.

 

Uansett, det greieste er kanskje å lage en oversettelsestabell, siden det vil mer eller mindre bruke definisjonen av "substitusjonssiffer" ordrett (pun not intended):

 

def encryptorN(alphabet, N):
"""Create a substitution cipher rotating N symbols over alphabet."""

assert len(alphabet) > N
table_enc = string.maketrans(alphabet, alphabet[N:] + alphabet[:N])
table_dec = string.maketrans(alphabet[N:] + alphabet[:N], alphabet)
def encryptor(s):
	return s.translate(table_enc)
def decryptor(s):
	return s.translate(table_dec)

return encryptor, decryptor
# end encryptorN

rot13, derot13 = encryptorN(string.lowercase + "æøå", 13)
x = "the magic words are squeamish ossifrage"
print "rot13(%s) = %s => %s" % (x, rot13(x), derot13(rot13(x)))

 

Voila.

 

edit: dammit! Må huske historien min rett :/

Endret 30. mars 2013 av zotbar1234

[zotbar1234]

ROT13-algoritmen gir vel kun mening når du snakker om 26 tegn

 

... fordi at ?

[dabear]

Fordi hensikten bak algorytmen er at du skal kunne kjøre samme funksjon på resultatet av forrige kjøring av funksjonen, og få tilbake originalteksten, mao rot13(rot13(x)) == x

[zotbar1234]

Fordi hensikten bak algorytmen er at du skal kunne kjøre samme funksjon på resultatet av forrige kjøring av funksjonen, og få tilbake originalteksten, mao rot13(rot13(x)) == x

 

Hensikten med algoritmen er en simpel regel for å kryptere. At krypteringsfunksjonen er også en dekrypteringsfunksjon er en praktisk egenskap men gjør ikke rotasjon med 13 noe mindre nyttig for andre alfabeter enn de med eksakt 26 tegn. Dvs rotasjon med 13 gir definitivt mening for andre alfabeter også.

Endret 30. mars 2013 av zotbar1234

[fontpage]

Takk for svar