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)