def encrypting( rawString: str, shift: int, keyword: str) -> EncryptedString: """ Encrypting string by Caesar's method with keyword. Arguments: rawString -- str type. User's string, that will be enctypted. shift -- int type. Index of start of alphabet jumpling. keyword -- str type. Word from rawString, that will start alphabet from shift to len(keyword). Return: EncryptedString -- str type. String, that encrypted by Caesar's method with keyword. """ if isinstance(shift, str): shift = int(shift) encryptedSting = '' jumpledAlphabet = alphabet_from_keyword(keyword, shift) for letter in rawString: if letter in punctuation + ' ': encryptedSting += letter else: if letter.isupper(): encryptedSting += jumpledAlphabet[alphabet.find( letter.lower())].upper() else: encryptedSting += jumpledAlphabet[alphabet.find( letter.lower())] return encryptedSting
def encrypt_message(s): """ str -> str Replace all letters in string with next letters in aplhabet. If argument is not a string function should return None. >>> encrypt_message("Revenge is a dish that tastes best when served cold.") 'Sfwfohf jt b ejti uibu ubtuft cftu xifo tfswfe dpme.' >>> encrypt_message("Never hate your enemies. It affects your judgment.") 'Ofwfs ibuf zpvs fofnjft. Ju bggfdut zpvs kvehnfou.' >>> encrypt_message(2015) """ if type(s) is not str: return None else: from string import ascii_lowercase from string import ascii_uppercase for i in range(len(s)): if s[i] == s[i].lower() and ascii_lowercase.find(s[i]) >= 0: s = s[:i] + ascii_lowercase[(ascii_lowercase.find(s[i]) + 1)]\ + s[i+1:] elif s[i] == s[i].upper() and ascii_uppercase.find(s[i]) >= 0: s = s[:i] + ascii_uppercase[(ascii_uppercase.find(s[i]) + 1)]\ + s[i+1:] return s
def main(data, key, action, letter_position, key_position, result): if action == "encrypt": for letter in data: letter_position.append(low.find(letter)) for key_letter in key: key_position.append(low.find(key_letter)) char_list = [(x + y) % 26 for (x, y) in zip(letter_position, key_position)] for char in char_list: result.append(low[char]) print(''.join(result)) elif action == "decrypt": for letter in data: letter_position.append(low.find(letter)) for key_letter in key: key_position.append(low.find(key_letter)) char_list = [(x - y) % 26 for (x, y) in zip(letter_position, key_position)] for char in char_list: result.append(low[char]) print(''.join(result)) else: syntax()
def funnyString(s): # Complete this function r = s[::-1] for i in range(1, len(s)): if abs(ass.find(s[i]) - ass.find(s[i - 1])) != abs((ass.find(r[i]) - ass.find(r[i - 1]))): return "Not Funny" return "Funny"
def encrypting(phrase: str, initialShift: int, furtherShift: int) -> EncryptedString: """ Encrypt input phrase with jumpled alphabet. Args: phrase (str): User's string, that will be enctypted. initialShift (int): shift, that will start jumpling an alphabet. furtherShift (int): shift, that will continue jumpling an alphabet. Returns: EncryptedString: enctypted string. """ encryptedSting = '' jumpledAlphabet = alphabet_from_formula(initialShift, furtherShift) for letter in phrase: if letter in punctuation + ' ': encryptedSting += letter else: if letter.isupper(): encryptedSting += jumpledAlphabet[alphabet.find( letter.lower())].upper() else: encryptedSting += jumpledAlphabet[alphabet.find( letter.lower())] return encryptedSting
def shift_letter(letter, sector): if alphabet.find(letter) + sector % 26 < 26: nletter = alphabet[alphabet.find(letter) + sector % 26] else: nletter = alphabet[alphabet.find(letter) + sector % 26 - 26] return nletter
def valueOf_1(Letter): letter = Letter.lower() if('a' <= letter <= 'k'): return lc.find(letter) elif('l' <= letter <= 'p'): return 10 else: # 'q' <= letter <= 'z' return 25 - lc.find(letter)
def codec(self, text: str, dir: int = 1) -> str: encoded = "" for i, char in enumerate(text): k = self.key[i % len(self.key)] # key char pos = ASCII.find(char) # char position in ascii offset = ASCII.find(k) # key char position " encoded += ASCII[(pos + offset * dir) % len(ASCII)] # nu char return encoded
def theLoveLetterMystery(s): i = len(s) // 2 diff = [] for a, b in zip(s[:i], s[::-1][:i]): a = ascii_lowercase.find(a) b = ascii_lowercase.find(b) diff.append(abs(a - b)) return sum(diff)
def encrypt_char(key, char): """ >>> encrypt_char('s', 't') 'l' """ shift_by = ascii_lowercase.find(key) shifted_alphabet = shifted(shift_by, ascii_lowercase) char_idx = ascii_lowercase.find(char) return shifted_alphabet[char_idx]
def safe_pawns(pawns): count=0 for a in pawns: print(a) need1 =ascii_lowercase [ascii_lowercase.find(a[0])-1]+ str(int(a[1])-1) need2 = ascii_lowercase [ascii_lowercase.find(a[0])+1]+ str(int(a[1])-1) print(need1,need2 ) if need1 and need1 in pawns or need2 and need2 in pawns: count+=1 return(count)
def rotate(input_string, ROT): cipher = list() for char in input_string: if char.lower() in ascii_lowercase: index = (ascii_lowercase.find(char.lower()) + ROT) - (int( (ascii_lowercase.find(char.lower()) + ROT) / 26) * 26) cipher.append( ascii_lowercase[index]) if char.islower() else cipher.append( ascii_lowercase[index].upper()) else: cipher.append(char) return ''.join(cipher)
def is_symmetric(word): """returns word if word is symmetric else returns false""" from string import ascii_lowercase as myalphabet # grab ascii alphabet word_reverse = word[::-1] # a reversed copy will come in handy # iterate over each letter in word up to half way point for i in range(0, len(word) / 2): # returns false if symmetric property doesn't hold # note the +1 and len() hackishness to help with 0-index list if(not(myalphabet.find(word[i])+1) \ == (len(myalphabet) - myalphabet.find(word_reverse[i]))): return False return word
def moving_shift(str, number): output_str = str for i in range(len(output_str)): letter = str[i] if ascii_lowercase.find(letter) >= 0: index = ascii_lowercase.find(letter) output_str = output_str[:i] + ascii_lowercase[ (index + number) % len(ascii_lowercase)] + output_str[i + 1:] if ascii_uppercase.find(letter) >= 0: index = ascii_uppercase.find(letter) output_str = output_str[:i] + ascii_uppercase[ (index + number) % len(ascii_uppercase)] + output_str[i + 1:] number += 1 return output_str
def encrypt(secret, message, decrypt=False): secret_values = [ascii_lowercase.find(char) for char in secret] message_values = [ascii_lowercase.find(char) for char in message] secret_values = [ secret_values[i % len(secret_values)] for i in range(len(message)) ] final = [] for index, message_value in enumerate(message_values): if decrypt: final.append( ascii_lowercase[(message_value - secret_values[index]) % 26]) else: final.append( ascii_lowercase[(secret_values[index] + message_value) % 26]) return ''.join(final)
def cipher(plain_text: str, shift_value: int) -> str: """Applies Caesar cipher to plain text and returns that string. Args: plain_text (str): plain string shift_value (int): how many characters should be each letter in the plain text shifted. can be negative or positive Returns: str: obfuscated string """ obf_text: str = "" for char in plain_text: if char not in alphabet: obf_text += char continue alphabet_index = alphabet.find(char) possible_index = alphabet_index + shift_value if possible_index >= len(plain_text): obf_text += alphabet[possible_index - len(plain_text)] else: obf_text += alphabet[alphabet_index + shift_value] return obf_text
def caesar(Ltr, shift): if (Ltr in lc): return lc[(lc.find(Ltr) + shift) % 26] elif (Ltr in uc): return uc[(uc.find(Ltr) + shift) % 26] else: return Ltr
def get_trim_text(text): text = text.lower() trim_text = '' for l in text: if lowercase.find(l) >= 0: trim_text += l return trim_text
def enc(char, shift): if char not in ascii_lowercase: return char else: ndx = ascii_lowercase.find(char) newNdx = (ndx + shift) % 26 return ascii_lowercase[newNdx]
def main(length, initial_char): char_indx = ascii_lowercase.find(initial_char) for charecter in ascii_lowercase[char_indx:]: pool = Pool(processes=3) try: words = [] fname = "pt-%s-%s" % (length, charecter) html = get_page((charecter, length, 1)) fwords = parse_words(html) if fwords: words.extend(fwords) number_pages_match = pagination_re.search(html) num_pages = number_pages_match.group(1) num_total_words = int(number_pages_match.group(2)) if num_pages > 1: page_mapping = [(charecter, length, index) for index in range(2, int(num_pages) + 1)] results = pool.map(get_words, page_mapping) print "[*]\tAppending resutls to list" for fwords in results: if fwords: words.extend(fwords) print "[*]\ttotal words found %s total words expected %s" % ( len(words), num_total_words) save_data(words, fname) pool.close() pool.join() except KeyboardInterrupt: pool.terminate() sys.exit(1) print "[*]\nYou cancelled the program!" finally: pool.close() pool.terminate()
def main(length, initial_char): char_indx = ascii_lowercase.find(initial_char) for charecter in ascii_lowercase[char_indx:]: pool = Pool(processes=3) try: words = [] fname = "pt-%s-%s" % (length, charecter) html = get_page((charecter, length, 1)) fwords = parse_words(html) if fwords: words.extend(fwords) number_pages_match = pagination_re.search(html) num_pages = number_pages_match.group(1) num_total_words = int(number_pages_match.group(2)) if num_pages > 1: page_mapping = [(charecter, length, index) for index in range(2, int(num_pages) + 1)] results = pool.map(get_words, page_mapping) print"[*]\tAppending resutls to list" for fwords in results: if fwords: words.extend(fwords) print "[*]\ttotal words found %s total words expected %s" % (len(words), num_total_words) save_data(words, fname) pool.close() pool.join() except KeyboardInterrupt: pool.terminate() sys.exit(1) print "[*]\nYou cancelled the program!" finally: pool.close() pool.terminate()
def main(data,key,action,result,key_value): for letter in data: if letter in low: value = low.find(letter) if action == "encrypt": value += low.find(key[key_value % len(key)]) elif action == "decrypt": value -= low.find(key[key_value % len(key)]) else: syntax() result += low[value % 26] key_value += 1 else: result += letter print(result)
def decrypt(step, word): newWord = '' for letter in word: letterIndex = lwc.find(letter) letterIndex -= step newWord += lwc[letterIndex] return newWord
def encode(self, st): msg = '' for s in st.lower(): if s in LETTERS: msg += LETTERS[(LETTERS.find(s) + self.shift) % 26] else: msg += s return msg.upper()
def _swap_case(c): index = ascii_uppercase.find(c) if index != INDEX_NOT_FOUND: return ascii_lowercase[index] index = ascii_lowercase.find(c) if index != INDEX_NOT_FOUND: return ascii_uppercase[index] raise ValueError("Expected ascii character")
def encodeL(Letter): if Letter in lc: return lc[(25 - lc.find(Letter))] # ndx = lc.find(Letter) '''I though I would leave these in # encNdx = 25 - ndx but I like the one liner better.''' # return lc[encNdx] else: return Letter
def increment_job(job_number): """Increment job number to find a unique value""" last_char = job_number[-1].lower() if last_char in ascii_lowercase and last_char != 'z': return job_number[0:-1] + \ ascii_lowercase[ascii_lowercase.find(last_char) + 1] else: return job_number + 'a'
def encode(text): code = "" for i in text.lower(): if i.isalpha(): code += ascii_lowercase[::-1][ascii_lowercase.find(i.lower())] elif i.isdigit(): code += i return " ".join(code[i:i + 5] for i in xrange(0, len(code), 5))
def v_encode(s1,key): key_map='' res='' key=key.lower() s1=''.join(s1.split()).lower() n=len(s1)/len(key) y=len(s1)%len(key) key_map+=key*n+key[:y] print "秘钥: "+key for i in range(len(s1)): ming=al.find(s1[i]) mi=al.find(key_map[i]) q.rotate(-mi) res+=q[ming] q.rotate(mi) print '密文: '+res return res
def convert(char, rot): val = ord(char) if char in ascii_lowercase: return ascii_lowercase[(rot + ascii_lowercase.find(char)) % LENGTH] elif char in ascii_uppercase: return ascii_uppercase[(rot + ascii_uppercase.find(char)) % LENGTH] else: return chr(val)
def numValSngl(Char): # a = char.lower() # if(a in lc): # x = lc.find(a) # return x + 1 # else: # return 0 return lc.find(Char.lower()) + 1
def wordchain(): total_tests = int(readline()) for testcase in range(total_tests): n = int(readline()) adj = [[0 for j in range(26)] for i in range(26)] graph = [[[] for j in range(26)] for i in range(26)] indegree = defaultdict(int) outdegree = defaultdict(int) for i in range(n): word = readline() a = ascii_lowercase.find(word[0]) b = ascii_lowercase.find(word[-1]) graph[a][b].append(word) adj[a][b] += 1 outdegree[a] += 1 indegree[b] += 1 result = solve(graph, adj, outdegree, indegree, n) print result if result else 'IMPOSSIBLE'
def _get_ciphered_index_for(self, lower_char): index = ascii_lowercase.find(lower_char) + self.shift if index >= self.max_length: index -= self.max_length if index < 0: index += self.max_length return index
def decrypt(): result = '' for letra in encrypted: if letra in alfabeto: posicao = alfabeto.find(letra) result += alfabeto[posicao - numero_casas] else: result += letra return result
def alphabeticShift(inputString): shift = [] for c in inputString: try: shift.append(ascii_lowercase[ascii_lowercase.find(c) + 1]) except IndexError: shift.append('a') return ''.join(e for e in shift)
def crypt(text, key, al): t = len(text) textB = "" for i in range(t): location = al.find(text[i]) # location = location + 1 new_location = (location + key) % 26 textB += al[new_location] return textB
def encode(text): cipher = "" for letter in text: if letter in lowerLetters: cipher = cipher + revLowerLetters[lowerLetters.find(letter)] elif letter in upperLetters: cipher = cipher + revUpperLetters[upperLetters.find(letter)] else: cipher = cipher + letter return cipher
def caesar(plain_text, key): cipher_text = '' for char in plain_text: if not char.isalpha(): cipher_text += char else: if char.isupper(): cipher_text += POOL[(POOL.find(char) + key) % 26] else: cipher_text += pool[(pool.find(char) + key) % 26] return cipher_text
def string_rot13(str): total = [] for s in str: if s in ascii_uppercase: index = (ascii_uppercase.find(s) + 13) % 26 total.append(ascii_uppercase[index]) elif s in ascii_lowercase: index = (ascii_lowercase.find(s) + 13) % 26 total.append(ascii_lowercase[index]) else: total.append(s) return "".join(total)
def update(self, data): total = [] for char in data.decode("hex"): if char in ascii_uppercase: index = (ascii_uppercase.find(char) + 13) % 26 total.append(ascii_uppercase[index]) elif char in ascii_lowercase: index = (ascii_lowercase.find(char) + 13) % 26 total.append(ascii_lowercase[index]) else: total.append(char) return "".join(total)
def main(): string_rot13() for chr in str: if chr in ascii_uppercase: index = (ascii_uppercase.find(chr) + 13) % 26 total.append(ascii_uppercase[index]) elif chr in ascii_lowercase: index = (ascii_lowercase.find(chr) + 13) % 26 total.append(ascii_lowercase[index]) else: total.append(chr) return ''.join(total)
def one(): from string import ascii_lowercase text = "g fmnc wms bgblr rpylqjyrc gr zw fylb. rfyrq ufyr amknsrcpq ypc dmp. bmgle gr gl zw fylb gq glcddgagclr ylb rfyr'q ufw rfgq rcvr gq qm jmle. sqgle qrpgle.kyicrpylq() gq pcamkkclbcb. lmu ynnjw ml rfc spj." rot2 = "" for c in text: if c in ascii_lowercase: c_pos = ascii_lowercase.find(c) rot2 += ascii_lowercase[(c_pos + 2) % 26] else: rot2 += c return rot2
def rot13(data): """ A simple rot-13 encoder since `str.encode('rot13')` was removed from Python as of version 3.0. It rotates both uppercase and lowercase letters individually. """ total = [] for char in data: if char in ascii_uppercase: index = (ascii_uppercase.find(char) + 13) % 26 total.append(ascii_uppercase[index]) elif char in ascii_lowercase: index = (ascii_lowercase.find(char) + 13) % 26 total.append(ascii_lowercase[index]) else: total.append(char) return "".join(total)
def v_decode(mi,key): key_map='' res='' key=key.lower() mi=''.join(mi.split()).lower() n=len(mi)/len(key) y=len(mi)%len(key) key_map+=key*n+key[:y] for i in range(len(mi)): ming=al.find(key_map[i]) q.rotate(-ming) res+=al[list(q).index(mi[i])] q.rotate(ming) print '密文: '+res return res
def __rotN(self, plaintext, rotation): ''' Accepts a string of plaintext, and will rotate N units ie: a rotation of 1 will change A to B, B to C, and so forth ''' cipher = [] for char in plaintext: if (self.ignoreList.count(char) != 0): cipher.append(char) elif char in ascii_uppercase: index = (ascii_uppercase.find(char) + rotation) % 26 cipher.append(ascii_uppercase[index]) elif char in ascii_lowercase: index = (ascii_lowercase.find(char) + rotation) % 26 cipher.append(ascii_lowercase[index]) return "".join(cipher)
def string_rot13(str): # ROT-13 is a simple substitution cypher. It stands for # "ROTate by 13 places." The cypher replaces any letter # (a-z or A-Z) with the one that appears 13 sequential places # behind it. Note that for the last half of the alphabet, the # ROT-13 character loops back around to the beginning of the # alphabet. Also note that characters that aren't in the alphabet # are passed through total = [] for chr in str: if chr in ascii_uppercase: index = (ascii_uppercase.find(chr) + 13) % 26 total.append(ascii_uppercase[index]) elif chr in ascii_lowercase: index = (ascii_lowercase.find(chr) + 13) % 26 total.append(ascii_lowercase[index]) else: total.append(chr) return ''.join(total)
def rot13(ask): total=[] n=" " for i in ask: if i in ascii_lowercase: index=(ascii_lowercase.find(i)+13)%26 total.append(ascii_lowercase[index]) if i in ascii_uppercase: index=(ascii_uppercase.find(i)+13)%26 total.append(ascii_uppercase[index]) elif i in num: index=(num.find(i)+5)%10 total.append(num[index]) elif i in sym: index=(sym.find(i)+len(sym)/2)%len(sym) total.append(sym[int(index)]) elif i in n: total.append(n) return "".join(total)
#!/usr/bin/env python import sys from string import ascii_lowercase from operator import add with open(sys.argv[1]) as f: lines = f.read().strip().splitlines() moves = [(1, 2), (1, -2), (-1, 2), (-1, -2), (2, 1), (2, -1), (-2, 1), (-2, -1)] for line in lines: c, n = line pos = (ascii_lowercase.find(c) + 1, int(n)) all_moves = [list(map(add, pos, i)) for i in moves] val_moves = [(x, y) for x, y in all_moves if 0 < x <= 8 and 0 < y <= 8] out = ' '.join(sorted(ascii_lowercase[x-1] + str(y) for x, y in val_moves)) print(out)
def shift(character, offset): index = alphabet.find(character) if(index < 0): return character return alphabet[(index + offset) % len(alphabet)]
Xlmw irgvCtxih qiwweki wlepp gpevmjC lsA RSX xs irgvCtx e qiwweki xsheC! Izir mj mx Aew wyjjmgmirx efsyx 6444 Cievw eks, sv xs fi qsvi tvigmwi mr xli Ciev 88 FG, rsAeheCw mx mw rsx. XsheC iegl ws-geppih Wgvmtx Omhhmi Asyph fi efpi xs kix wirwmxmzi mrjsvqexmsr, mj xliC Aivi irgvCtxih xlmw AeC.""" #cipherText = re.sub('[^a-z]', '', cipherText.lower()) #custom alphabet? alphabet = ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','0','1','2','3','4','5','6','7','8','9'] alphabet = ''.join(alphabet) #print str(alphabet) for i in range (-62,62): plainText = [] print i,":", for char in cipherText: if char in alphabet: index = (alphabet.find(char) + i) % 62 plainText.append(alphabet[index]) elif char in ascii_lowercase: index = (ascii_lowercase.find(char) + i) % 26 plainText.append(ascii_lowercase[index]) elif char in ascii_uppercase: index = (ascii_uppercase.find(char) + i) % 26 plainText.append(ascii_uppercase[index]) elif char in digits: index = (digits.find(char) + i) % 10 plainText.append(digits[index]) else: plainText.append(char) print "".join(plainText) key = sys.stdin.readline()
def _encrypt_letter(self, letter, offset=0): position = (alphabet.find(letter) + offset) % self.alpha_len return alphabet[position]