def transfor(s): result='' for char in s: if char in lowercase: if char<'w': char=lowercase[lowercase.index(char)+4] else: char=lowercase[3-len(lowercase)+lowercase.index(char)] elif char in uppercase: if char<'W': char=uppercase[uppercase.index(char)+4] else: char=uppercase[3-len(uppercase)+uppercase.index(char)] result+=char return result
def caesar_decrypt(cipher, n):
return "".join(
ch.isalpha() and lowercase[
(lowercase.index(ch) - n) % len(lowercase)
] or ch
for ch in cipher
)
def doDecode(self,msg,key):
"""Decode Vigenere cipher"""
result = ''
key_len=len(key)
key_pos = 0
for i in msg.lower():
try:
_ = lc.index(i)
except(ValueError):
result = "{}{}".format(result,i)
continue
if key_pos == key_len:
key_pos=0
newchr = unshift(i,lc.index(key[key_pos]))
key_pos=key_pos+1
result = "{}{}".format(result,newchr)
return result
def main():
keyword = argv[1]
message = " ".join(argv[2:])
keys = [lowercase.index(c.lower())+1 for c in keyword]
letter_count = 0
encoded = []
for c in message:
if c.lower() in lowercase:
ind = lowercase.index(c.lower())
new_ind = (ind + keys[letter_count % len(keys)]) % 26
letter_count += 1
if c in uppercase:
encoded.append(uppercase[new_ind])
elif c in lowercase:
encoded.append(lowercase[new_ind])
else:
encoded.append(c)
print "".join(encoded)
def rot(c, n):
""" Rotates a single character forward or backward n numbers in the alphabet
"""
if c in lowercase:
return lowercase[(lowercase.index(c) + n) % 26]
elif c in uppercase:
return uppercase[(uppercase.index(c) + n) % 26]
else:
return c
def encoded_letter(c, key):
if c.lower() in lowercase:
ind = lowercase.index(c.lower())
new_ind = (ind + key) % 26
if c in uppercase:
return uppercase[new_ind]
elif c in lowercase:
return lowercase[new_ind]
else:
return c
def get_position(letter):
# type: (str) -> str
letter_lowercase = letter.strip().lower()
res = list()
if len(letter) > 1:
for single_letter in letter_lowercase:
try:
pos = lowercase.index(single_letter) + 1
except ValueError:
return "error: bad letter \'{letter}\' in \'{para}\'".format(letter=single_letter, para=letter)
single_res = "{letter}: {pos}".format(letter=single_letter, pos=pos)
res.append(single_res)
return "\n".join(res)
else:
try:
pos = lowercase.index(letter_lowercase) + 1
except ValueError:
return "error: bad letter \'{letter}\'".format(letter=letter)
return "{letter}: {pos}".format(letter=letter, pos=pos)
def caesarCipher(s, k):
result = []
for c in s:
if c in lowercase:
idx = (lowercase.index(c) + k) % 26
result.append(lowercase[idx])
elif c in uppercase:
idx = (uppercase.index(c) + k) % 26
result.append(uppercase[idx])
else:
result.append(c)
return "".join(result)
def _transpose_string(self):
""" transpose string creates a transposed alphabet based
self.offset and then returns a new string using the index of the
transposed alphabet. use regex to identify uppercase letters
Args:
None
Returns:
transposed string
"""
transposed_alphabet = lowercase[self.offset:] + lowercase[:self.offset]
new_string = str()
for character in self.original:
if re.search(character, lowercase):
new_string += transposed_alphabet[lowercase.index(character)]
elif re.search(character, lowercase, re.I):
new_string += transposed_alphabet[lowercase.index(
character.lower())].upper()
else:
new_string += character
#raise ValueError, "%s is not in %s" % (character, lowercase)
return new_string
def next_password(password):
"""
>>> next_password('abcdefgh')
'abcdefgi'
>>> next_password('ghijklzz')
'ghjaaaaa'
"""
# Fast operation if forbidden letter found
for c in "ilo":
i = password.find(c)
if i >= 0:
j = lowercase.index(c) + 1
return password[:i] + lowercase[j] + "a" * (8 - i - 1)
# Increment last letter, rollover/carry if necessary
for i in range(7, -1, -1):
left, c, right = password[:i], password[i], password[i + 1 :]
if c == "z":
password = left + "a" + right
else:
j = lowercase.index(c) + 1
return left + lowercase[j] + right
def encode(text, key):
'''
Encodes based on received text and key.
(string, string) -> string
>>> encode('mary had a little lamb', 'hakuna matata')
'ghpy bhu h fcrrfn fhga'
'''
cipher = get_cipher(key)
encoded_text = [
cipher[lowercase.index(i)] if i in lowercase else i for i in text
]
return ''.join(encoded_text)
def decipher(raw):
""" Should return a encipherd string based on probability in the english alphabet
"""
S = raw.lower()
max = 0
#Maak een frequentietabel van het alphabet, met als index het nummer in lowercase
scores = [0] * 26
s_index = [0] * 26
for n in range(len(S)):
if S[n] in lowercase:
scores[lowercase.index(S[n])] += 1
#Check iedere rotation
for rotation in range(0, 26):
for letter in range(0, 26):
#s_index[rotation] += ( letProb((letter + rotation) % 26) )
if (max < s_index):
max = s_index[rotation]
print s_index
print scores
pass
def rotate(character, offset):
i = lowercase.index(character)
return lowercase[(i + offset) % 26]
def gematriya(word):
global dictionary
return sum(1 + alphabet.index(letter)
for letter in word if letter in alphabet)
