def encrypt(self):
encrypted = ''
key = ''.join(self.key.split()).upper()
for index, char in enumerate(self.plain):
encrypted += ascii_uppercase[(ascii_uppercase.index(char) + ascii_uppercase.index(key[index])) % 26]
return encrypted
def __encode_rotor_chain(self, char, right_to_left):
"""
Encode a character though the whole rotor chain in a specific direction taking into account physical properties
like to rotors positions and the ring settings
:param char: The character to encode
:type char: str
:param right_to_left: True if the encoding must be performed from right to left, False otherwise
:type right_to_left: bool
:return: The encoded character
:rtype: str
:raises: :class:`TypeError, ValueError`: If the provided character is invalid
"""
self._alpha_character_validator.validate(char)
current_char, prev_rotor_position = char.upper(), 0
for rotor in reversed(
self.__rotors) if right_to_left else self.__rotors:
current_char = ascii_uppercase[
(ascii_uppercase.index(current_char) + rotor.position -
rotor.ring_setting + 1 - prev_rotor_position) %
len(ascii_uppercase)]
if right_to_left:
current_char = rotor.encode_right_to_left(current_char)
else:
current_char = rotor.encode_left_to_right(current_char)
prev_rotor_position = rotor.position - rotor.ring_setting + 1
current_char = ascii_uppercase[(ascii_uppercase.index(current_char) -
prev_rotor_position) %
len(ascii_uppercase)]
return current_char
def kill_ship(self, ship):
ship = ship.upper()
if self.field[((ascii_uppercase.index(ship[0]) * self.size) + int(ship[1]) - 1)] == 0:
self.field[((ascii_uppercase.index(ship[0]) * self.size) + int(ship[1]) - 1)] = '_'
return True
else:
return False
def multibuy(items, items_on_offer):
"""Check if items in the particular order fulfil multibuy requirements to sub in an offer price
for "buy any x items" offers.
"""
offers = 0
offer_items = []
# pick interested items
for i in range(len(items_on_offer)):
j = asc_up.index(items_on_offer[i])
for k in range(items[j]):
offer_items.append((items_on_offer[i], prices[items_on_offer[i]]))
# sort items by price
offer_items = sorted(offer_items, key=itemgetter(1), reverse=True)
# remove 3 highest, add to offers
while len(offer_items) >= 3:
offers += 45
del offer_items[:3]
# reassign values of relevant items
counts = Counter(item[0] for item in offer_items)
for item in items_on_offer:
index = asc_up.index(item)
items[index] = counts[
item] # where all items of a type are in the offer this gives 0, else 1 or 2
return items, offers
def adjacent_hexes(hex_id):
col, row = au.index(hex_id[0]), int(hex_id[1])
t_row = row + col % 2 - 1
b_row = row + col % 2
adj_hexes = set()
if row - 1 > 0:
adj_hexes.add((col, row - 1))
if row + 1 < 10:
adj_hexes.add((col, row + 1))
if col + 1 <= au.index(MAX_COL):
if t_row > 0:
adj_hexes.add((col + 1, t_row))
if b_row < 10:
adj_hexes.add((col + 1, b_row))
if col - 1 >= 0:
if t_row > 0:
adj_hexes.add((col - 1, t_row))
if b_row < 10:
adj_hexes.add((col - 1, b_row))
return set(map(lambda a: au[a[0]] + str(a[1]), adj_hexes))
def get_words(game):
game = [i for i in game.split("#p")[0].split("\n")[1:-1]
if i.startswith(">")][:-1]
words = [(i.split()[2], i.split()[3]) for i in game]
board = [['' for i in range(16)] for i in range(16)]
nw = []
for (pos, word) in words:
if pos[0] in ascii_uppercase:
row = ascii_uppercase.index(pos[0])
col = int(pos[1:])
d = 'A'
else:
col = int(pos[:-1])
row = ascii_uppercase.index(pos[-1])
d = 'D'
n = ''
for l in word:
if l == '.':
n += board[row][col]
else:
n += l
board[row][col] = l
if d == 'D':
row += 1
else:
col += 1
nw.append(n)
return nw
def decodeGrundStellung(self):
#find out the starting grund stellung if we know the other parts
enigmai = Enigma(
rotors={
1: Rotor("VIII", 19 - 1, pomlist.index(
self.grundStellung[0])), #slowest, left-most
2: Rotor("II", 7 - 1,
pomlist.index(self.grundStellung[1])), #middle
3: Rotor("IV", 12 - 1, pomlist.index(
self.grundStellung[2])), #fastest, right-most
},
reflector=Reflector("B"),
plugboard=Plugboard({
"B": "D",
"C": "O",
"E": "I",
"G": "L",
"J": "S",
"K": "T",
"N": "V",
"P": "M",
"Q": "R",
"W": "Z"
}))
text = enigmai.EDcrypt(self.grundStellung[3:])
return text
def play_pass(s, n):
"""
shift each letter by a given number but the transformed letter must be a letter (circular shift),
replace each digit by its complement to 9,
keep such as non alphabetic and non digit characters,
downcase each letter in odd position, upcase each letter in even position (the first character is in position 0),
reverse the whole result.
"""
from string import ascii_lowercase, ascii_uppercase, punctuation, whitespace
news = ''
llower = ascii_lowercase * 2
uuper = ascii_uppercase * 2
for idx, ch in enumerate(s):
if ch in punctuation + whitespace:
news += ch
if ch in ascii_lowercase:
news += llower[ascii_lowercase.index(ch) +
n] if idx % 2 else llower[ascii_lowercase.index(ch)
+ n].upper()
if ch in ascii_uppercase:
news += uuper[ascii_uppercase.index(ch) +
n] if idx % 2 == 0 else uuper[
ascii_uppercase.index(ch) + n].lower()
if ch in '0123456789':
news += str(9 - int(ch))
return news[::-1]
def parse_sgf_move(move_str: str) -> Optional[Tuple[int, int]]:
"""Returns either None or (x, y) coordinates of board."""
if not (move_str == '' or _SGF_MOVE_REGEX.match(move_str)):
raise SgfContentError
if move_str == '' or move_str == 'tt':
return None
e = SgfContentError("Invalid move string %s" % move_str)
if len(move_str) != 2:
raise e
try:
# GameState expects (x, y) where x is column and y is row
col = ascii_uppercase.index(move_str[0].upper())
row = ascii_uppercase.index(move_str[1].upper())
if (0 <= col < 19) and (0 <= row < 19):
return col, row
raise e
except ValueError:
raise e
def encrypt(text, key):
if not isinstance(text, str) or not isinstance(key, str):
raise TypeError
if key == '' or bool(re.match(r".*[^a-zA-Z].*", key)):
raise ValueError
res = ''
key = key.lower()
t_index = 0
key_len = len(key)
for i in text:
if i == ' ':
res += i
continue
if i in ascii_uppercase:
res += ascii_uppercase[(ascii_uppercase.index(i) +
ascii_uppercase.index(key[t_index])) % 26]
t_index = (t_index + 1) % key_len
continue
if i in ascii_lowercase:
res += ascii_lowercase[(ascii_lowercase.index(i) +
ascii_lowercase.index(key[t_index])) % 26]
t_index = (t_index + 1) % key_len
continue
return res
def SaoViz(self, u='', v=''):
i = ascii_uppercase.index(u)
j = ascii_uppercase.index(v)
if not self.__orientado:
return self.__matriz[i][j] == 1 and self.__matriz[i][j] == 1
else:
return self.__matriz[i][j] == 1
def test(self):
#print (self.grundStellung)
grunds = self.decodeGrundStellung()
enigmai = Enigma(
rotors={
1: Rotor("VIII", 19 - 1,
pomlist.index(grunds[0])), #slowest, left-most
2: Rotor("II", 7 - 1, pomlist.index(grunds[1])), #middle
3: Rotor("IV", 12 - 1,
pomlist.index(grunds[2])), #fastest, right-most
},
reflector=Reflector("B"),
plugboard=Plugboard({
"B": "D",
"C": "O",
"E": "I",
"G": "L",
"J": "S",
"K": "T",
"N": "V",
"P": "M",
"Q": "R",
"W": "Z"
}))
text = enigmai.EDcrypt(self.ttc)
print("DECRYPTED TEXT: " + text)
print("STECKERS: %s" % enigmai.plugboard.wiring)
def vigenere_e(plaintext, key):
plaintext = plaintext.upper()
key = mapped_key(plaintext, key.upper())
ciphertext = [
alph[(alph.index(a) + alph.index(b)) % 26] if a in alph else a
for a, b in zip(plaintext, key)
]
return "".join(ciphertext)
def AdicionarAresta(self, u='', v=''):
self.__vazio = False
i = ascii_uppercase.index(u)
j = ascii_uppercase.index(v)
self.__matriz[i][j] = 1
if not self.__orientado:
self.__matriz[j][i] = 1
return self.__matriz
def RemoverAresta(self, u='', v=''):
i = ascii_uppercase.index(u)
j = ascii_uppercase.index(v)
self.__matriz[i][j] = 0
if not self.__orientado:
self.__matriz[j][i] = 0
return [(u, v), (v, u)]
return [(u, v)]
def vigenere_d(ciphertext, key):
ciphertext = ciphertext.upper()
key = mapped_key(ciphertext, key.upper())
plaintext = [
alph[(alph.index(a) - alph.index(b)) % 26] if a in alph else a
for a, b in zip(ciphertext, key)
]
return "".join(plaintext)
def decrypt_vigenere(ciphertext_string, key):
decrypted_plaintext = {}
decrypted_text_string = ''
for letter_index, letter in enumerate(ciphertext_string):
decrypted_text_string += ascii_uppercase[(ascii_uppercase.index(letter) - ascii_uppercase.index(key[letter_index % len(key)])) % 26]
decrypted_plaintext = get_letter_count_of_text(decrypted_text_string)
return decrypted_plaintext
def convertMessage(self, message):
cipherResponse = ''
for letter in message.upper():
if letter not in uppercaseAlphabet:
cipherResponse += letter
else:
letter = self.applySwap(letter) #Plugboard Swap
self.leftRotor.step() # Left Rotor
leftRotorOutput = self.leftRotor.encodeDecode(uppercaseAlphabet.index(letter))
reflectorOutput = self.REFLECTOR[uppercaseAlphabet[leftRotorOutput % Enigma.alphaLength]]
convertedLetter = uppercaseAlphabet[self.rightRotor.encodeDecode(uppercaseAlphabet.index(reflectorOutput), forward = False)]
convertedLetter = self.applySwap(convertedLetter) #Plugboard Swap
cipherResponse += convertedLetter
return cipherResponse
def transform(text, key, sign):
text_nums = [ascii_uppercase.index(c) for c in text]
key_nums = [ascii_uppercase.index(c) for c in key]
i = 0
n_k = len(key_nums)
n_c = len(ascii_uppercase)
answer = []
for n in text_nums:
n = (n + sign * key_nums[i]) % n_c
answer.append(ascii_uppercase[n])
i = (i + 1) % n_k
return "".join(answer)
def caeser(sourcetext, offset=None, reverse=False):
# caeser(string) -> string
# offset - integer value for cipher offset
# reverse - bool to reverse the offset (useful for decryption)
# Apply an offset to ascii characters.
# Trivial case, return sourcetext unchanged and avoid
# translating character by character.
if offset == None:
return sourcetext
# reverse flag undoes the cipher offset. This is the same
# as making the offset negative. Conditional merely changes
# the sign of offset. The same effect can be achieved by
# manually adjusting the sign of offset in the caller.
if reverse:
offset = -offset
# build enciphered string character by character
# For each character, if it is an ascii letter apply
# the offset and append the new character to the cipher.
# Otherwise, simply append nonletters to the cipher.
cipher = []
for char in sourcetext:
if char in ascii_letters:
if char in ascii_lowercase:
i = ascii_lowercase.index(char) + offset
i = modulate_index(ascii_lowercase, i)
cipher.append(ascii_lowercase[i])
else:
i = ascii_uppercase.index(char) + offset
i = modulate_index(ascii_uppercase, i)
cipher.append(ascii_uppercase[i])
else: cipher.append(char)
ciphertext = ''.join(cipher)
return ciphertext
def get_name_value(name):
"""
get value of a name
"""
value = sum([ascii_uppercase.index(letter) + 1
for letter in name])
return value
def decrypt_ciphertext_by_shift(ciphertext_string, key: int):
decrypted_ciphertext_string = ''
for letter in ciphertext_string:
decrypted_ciphertext_string += ascii_uppercase[(ascii_uppercase.index(letter) + key) % 26]
decrypted_ciphertext = get_letter_count_of_text(decrypted_ciphertext_string)
return decrypted_ciphertext
def columnIndex(column): try: column = int(column) - 1 except: column = ascii_uppercase.index(column) return column
def set_position(self, letter_position: str) -> None:
"""Turn the rotor to a given position."""
numeric_position = alphabet.index(letter_position) + 1
offset = numeric_position - self.ring_setting
if offset < 0:
offset += len(self.wiring)
self.rotation = offset
def transform(letter):
if letter in key_lower:
return key_lower[ascii_lowercase.index(letter)]
elif letter in key_upper:
return key_upper[ascii_uppercase.index(letter)]
else:
return letter
def column_index(col):
''' static method that returns the zero-based column index '''
try:
col = int(col) - 1
except:
col = ascii_uppercase.index(col)
return col
def get_next_well(self, previous_coordinates):
row = ascii_uppercase.index(previous_coordinates[0])
col = int(previous_coordinates[1:])
if self.placement == 'column':
# Select next well by column (going down the plate)
if (row != 0 and (row + self.spacing) % self.layout[1]
== 0) or row > self.layout[1]:
next_row = ascii_uppercase[0]
next_col = col + self.spacing
else:
next_row = ascii_uppercase[row + self.spacing]
next_col = int(previous_coordinates[1:])
else:
# Select next well by row (across the plate)
if col % self.divisor == 0 or col > self.divisor:
next_row = ascii_uppercase[row + self.spacing]
next_col = self.spacing
else:
next_row = previous_coordinates[0]
next_col = col + self.spacing
lookup = (next_row, next_col)
try:
well = self.wells[lookup]
except KeyError as e:
raise Exception('Location chosen is out of range')
return well, '{}{}'.format(next_row, next_col)
def moving_shift(string, shift):
words = string
lens = len(words)
m, n = divmod(lens, 5)
if n > 0:
m += 1
res = ['', '', '', '', '']
chars = -1
for idx, char in enumerate(words):
chars += 1
change = None
if char in ascii_lowercase + ascii_uppercase:
if char in ascii_lowercase:
pos = ascii_lowercase.index(char)
np = (pos + shift + chars) % 26
change = ascii_lowercase[np]
elif char in ascii_uppercase:
pos = ascii_uppercase.index(char)
np = (pos + shift + chars) % 26
change = ascii_uppercase[np]
else:
change = char
res[chars // m] += change
return res
def moving_shift(string, shift):
words = string
lens = len(words)
m, n = divmod(lens, 5)
if n > 0:
m +=1
res = ['', '', '', '' ,'']
chars = -1
for idx, char in enumerate(words):
chars += 1
change=None
if char in ascii_lowercase + ascii_uppercase:
if char in ascii_lowercase:
pos = ascii_lowercase.index(char)
np = (pos + shift + chars) % 26
change = ascii_lowercase[np]
elif char in ascii_uppercase:
pos = ascii_uppercase.index(char)
np = (pos + shift + chars) % 26
change = ascii_uppercase[np]
else:
change = char
res[chars//m] += change
return res
def main():
n = 1
optlist, args = getopt.getopt(sys.argv[1:], "n:")
for opt, val in optlist:
if opt in ['-n']:
n = int(val)
for infile_name in args:
with open(infile_name, "r") as infile:
text = get_text(infile)
print("%s\n" % (''.join(text)))
split_text = [[] for i in range(n)]
for i, c in enumerate(text):
split_text[i % n].append(c)
for i, l in enumerate(split_text):
print("Position %d:" % (i))
print(" %s" % ("".join(l)))
dist = get_ngram_freqs(l, 1)
dist_l = [(dist[c], c) for c in dist]
dist_l.sort(reverse=True)
for ndx in range(min(5, len(dist))):
c = dist_l[ndx][1]
n_c = dist_l[ndx][0]
i_c = ascii_uppercase.index(c)
i_e = (i_c - 5) % len(ascii_uppercase)
print(" %s: %d %s" % (c, n_c, ascii_uppercase[i_e]))
def __init__(self,
left_rotor,
middle_rotor,
right_rotor,
reflector,
menu_link='ZZZ',
conx_in={},
conx_out={}):
"""rotors must be strings referring to either ['I','II','III','IV','V']
reflector must be string, one of either ['B','C']"""
self.right_rotor = right_rotor
self.middle_rotor = middle_rotor
self.left_rotor = left_rotor
self.reflector = reflectors[reflector]
self.menu_link = menu_link
self.middle_notch = entry.index(
notches[self.middle_rotor]
) ## point if right rotor reaches will trigger middle rotor to step
self.left_notch = entry.index(
notches[self.left_rotor]
) ## point if middle rotor reaches will trigger left rotor to step
self.current_position = menu_link
self.pos_left_rotor, self.pos_mid_rotor, self.pos_rgt_rotor = (
ascii_uppercase.index(m) for m in menu_link.upper())
self.status = {}
self.status['in'] = {char: 0 for char in entry}
self.status['out'] = {char: 0 for char in entry}
self.conxns = {'in': conx_in, 'out': conx_out}
def solution(name):
name_len = len(name)
queue = [(name_len - cntName("A" * name_len, name), 0, 0, "A" * name_len)]
heapq.heapify(queue)
while True:
weight, cnt, idx, temp = heapq.heappop(queue)
print(temp, weight, idx)
print("".join([(name[i]) if i == idx else " "
for i in range(name_len)]))
if temp == name: return cnt
heapq.heappush(queue,
(weight + 1, cnt + 1, (idx + 1) % name_len, temp))
heapq.heappush(queue,
(weight + 1, cnt + 1, (idx - 1) % name_len, temp))
ntemp = temp[:idx] + name[idx] + temp[idx + 1:]
if temp == ntemp:
continue
j_cnt = min(ascii_uppercase.index(name[idx]),
ascii_uppercase[::-1].index(name[idx]) + 1)
if j_cnt:
heapq.heappush(
queue,
(weight - cntName(name, ntemp), cnt + j_cnt, idx, ntemp))
sleep(0.5)
def part_2(steps):
workers = [Worker(i) for i in range(5)]
def get_free_worker():
for worker in workers:
if worker.is_ready():
return worker
ans = ''
time = 0
while not all([i[1].finished for i in steps]):
# Loop through the steps and assign a worker to it if the step
# is ready to be worked on, and the worker is available
for step in steps:
worker = get_free_worker()
if worker is not None and step[1].is_ready():
if step[1].is_ready() and not step[1].finished:
# print(f'Worker {worker.name}: Started {step[0]} at {time} ')
worker.start_work(step[0])
step[1].is_being_worked_on = True
continue
for w in workers:
completed = w.working()
if completed:
# print(f'Worker {w.name}: Completed {completed} at {time}')
ans += completed
idx = UP.index(completed)
steps[idx][1].finished = True
steps[idx][1].is_being_worked_on = False
time += 1
print(f'Time taken: {time}')
def __init__(self,
left_rotor: str,
middle_rotor: str,
right_rotor: str,
reflector: str,
menu_link: str = 'ZZZ'):
"""rotors must be strings referring to either ['I','II','III','IV','V']
reflector must be string, one of either ['B','C']"""
assert all([
r in raw_rotors.keys()
for r in (left_rotor, middle_rotor, right_rotor)
])
assert reflector in reflectors.keys()
self.right_rotor = right_rotor
self.middle_rotor = middle_rotor
self.left_rotor = left_rotor
self.reflector = reflectors[reflector]
self.menu_link = menu_link
self.middle_notch = entry.index(
notches[self.middle_rotor]
) ## point if right rotor reaches will trigger middle rotor to step
self.left_notch = entry.index(
notches[self.left_rotor]
) ## point if middle rotor reaches will trigger left rotor to step
self.pos_left_rotor, self.pos_mid_rotor, self.pos_rgt_rotor = (
ascii_uppercase.index(m) for m in menu_link.upper())
self.in_status = {char: 0 for char in entry}
self.out_status = {char: 0 for char in entry}
self.current_position = menu_link
self.record = {}
def enigmatise(self, tocode, startset='AAA'):
encoded = ''
tocode = self.only_ascii(tocode)
self.pos_left_rotor, self.pos_mid_rotor, self.pos_rgt_rotor = (
ascii_uppercase.index(s) for s in startset.upper())
for i, c in enumerate(tocode):
# print('in: ', c)
self.step_enigma()
# print('rp = ', self.pos_rgt_rotor, 'mp = ', self.pos_mid_rotor, 'lp = ', self.pos_left_rotor)
out = self.full_scramble(c)
# print('out: ', out,'\n')
encoded += out
self.translate_current_position()
self.record[i] = {
'in': c,
'out': out,
'current_pos': self.current_position
}
return encoded
def alpha_to_int(alpha):
try:
return ascii_uppercase.index(alpha.upper())+1
except ValueError:
if alpha == ' ':
return 0
else:
raise WrongCharError
def make_diamond(letter):
lines = []
length = ascii_uppercase.index(letter) + 1
for l in range(length):
line = [' '] * length
line[l] = ascii_uppercase[l]
lines.append(''.join(list(reversed(line)) + line[1:]))
return '\n'.join(lines[:-1] + list(reversed(lines))) + '\n'
def value( name ):
"""
>>> from euler22 import value
>>> value("COLIN")
53
"""
chars= [ ascii_uppercase.index(c)+1 for c in name ]
return sum( chars )
def ltr2nbr( s ):
"""
>>> from euler42 import ltr2nbr
>>> ltr2nbr("SKY")
[19, 11, 25]
>>> sum(ltr2nbr("SKY"))
55
"""
return [ 1+ascii_uppercase.index(c) for c in s ]
def rotate(message, key):
coded_message = ""
for char in message:
if char in alpha_lower:
char = alpha_lower[(alpha_lower.index(char) + key) % ALPHA_LEN]
elif char in alpha_upper:
char = alpha_upper[(alpha_upper.index(char) + key) % ALPHA_LEN]
coded_message += char
return coded_message
def caeser_cipher(text, key):
encrypted = ''
for i in text:
if i in l:
encrypted += l[(l.index(i) + key) % 26]
elif i in u:
encrypted += u[(u.index(i) + key) % 26]
else:
encrypted += i
return encrypted
def checkio(number):
to_int = lambda x: int(x) if x.isdigit() else alpha.index(x) + 10
digits = list(map(to_int, number))
k = max(digits) + 1
for k in itertools.count(k):
if k > MAX_K:
return 0
else:
decimal = sum((k ** i) * x for i, x in enumerate(reversed(digits)))
if not decimal % (k - 1):
return k
def _alpha_value(chars):
"""Calculate the alphabetical value (as described by `Problem 22`_).
.. _Problem 22: http://projecteuler.net/index.php?section=problems&id=22
>>> _alpha_value('COLIN')
53
>>> _alpha_value('RUTH')
67
"""
return sum((1 + ascii_uppercase.index(char) for char in chars))
def lex(word):
score,i = [],0
while i <= 15:
if i < len(word):
value = abc.index(word[i])
value = str(value) if value > 9 else "0"+str(value)
score.append(value)
else:
score.append("00")
i = i + 1
return int(reduce(lambda a,b: a+b,score))
def caesar(s, shift):
result = []
for a in s:
if a.isalpha():
if a.islower():
result.append(low[(low.index(a) + shift) % 26])
else:
result.append(up[(up.index(a) + shift) % 26])
else:
result.append(a)
return ''.join(result)
def encryptor(key, message):
key %= 26
result = []
for a in message:
if a.islower():
result.append(low[(low.index(a) + key) % 26])
elif a.isupper():
result.append(up[(up.index(a) + key) % 26])
else:
result.append(a)
return ''.join(result)
def rotate(text, degrees):
# Building this dictionary is almost certainly a preoptimization given the
# lengths of the test inputs.
rotate_dict = {}
for l in ascii_lowercase:
rotated_index = (ascii_lowercase.index(l) + degrees) % NUM_LETTERS
rotate_dict[l] = ascii_lowercase[rotated_index]
for l in ascii_uppercase:
rotated_index = (ascii_uppercase.index(l) + degrees) % NUM_LETTERS
rotate_dict[l] = ascii_uppercase[rotated_index]
return sub(r'(.)', lambda l: rotate_dict.get(l.group(1), l.group(1)), text)
def triangle_words(file, c=0):
triangles = {x*(x+1)/2 for x in xrange(1000)}
value = {c: ascii_uppercase.index(c)+1 for c in ascii_uppercase}
with open(file, 'r') as f:
words = list(f.read().replace('"', '').split(','))
for word in words:
s = 0
for char in word:
s += value[char]
if s in triangles:
c += 1
return c
def play_pass(string, n):
result = []
for i, a in enumerate(string):
if a.isdigit():
char = str(9 - int(a))
elif a.isalpha():
char = up[(up.index(a) + n) % 26]
char = char if i % 2 == 0 else char.lower()
else:
char = a
result.append(char)
return ''.join(reversed(result))
def change_pass(password,enc1,enc2): lpas = list(password) for i in range(len(lpas)): let = lpas[i] if let in ascii_lowercase: ind = ascii_lowercase.index(let) newlet = enc1[ind] elif let in ascii_uppercase: ind = ascii_uppercase.index(let) newlet = enc2[ind] else: continue lpas[i] = newlet return "".join(lpas)
def getPixelWidth(self, sentence, uppercase, lowercase):
l = 0
letters = 0
for i in sentence:
if i in U:
l += uppercase[U.index(i)]
elif i in L:
l += lowercase[L.index(i)]
else:
l += 3
letters += 1
l += letters-1
print letters, len(sentence)
return l
def cord2pos(self,key):
keys = key.split('!')
if len(keys) == 2:
sheetKey = keys[0]
key = keys[1]
elif len(keys) == 1:
sheetKey = None
else:
raise ValueError(key)
key = key.upper()
if len(key) == 1:
if key in ascii_uppercase:
colKey = key
rowKey = None
else:
colKey = None
rowKey = self.str2int(key)
else:
if key[1] in ascii_uppercase:
colKey = key[:1]
rowKey = self.str2int(key[2:])
elif key[0] in ascii_uppercase:
colKey = key[0]
rowKey = self.str2int(key[1:])
else:
colKey = None
rowKey = self.str2int(key)
if colKey:
if len(colKey) == 1:
colKey = ascii_uppercase.index(colKey)+1
elif len(colKey) == 2:
colKey = (ascii_uppercase.index(colKey[0])+1)*2 \
+ ascii_uppercase.index(colKey[1])+1
else:
raise KeyError(key)
return (sheetKey,rowKey,colKey)
def play_pass(s, n):
"""
shift each letter by a given number but the transformed letter must be a letter (circular shift),
replace each digit by its complement to 9,
keep such as non alphabetic and non digit characters,
downcase each letter in odd position, upcase each letter in even position (the first character is in position 0),
reverse the whole result.
"""
from string import ascii_lowercase, ascii_uppercase, punctuation, whitespace
news = ''
llower = ascii_lowercase * 2
uuper = ascii_uppercase * 2
for idx, ch in enumerate(s):
if ch in punctuation + whitespace:
news += ch
if ch in ascii_lowercase:
news += llower[ascii_lowercase.index(ch) + n] if idx % 2 else llower[ascii_lowercase.index(ch) + n].upper()
if ch in ascii_uppercase:
news += uuper[ascii_uppercase.index(ch) + n] if idx % 2 ==0 else uuper[ascii_uppercase.index(ch) + n].lower()
if ch in '0123456789':
news += str(9-int(ch))
return news[::-1]
def main():
shifts = [21, 10, 23, 17, 23, 3]
lShifts = len(shifts)
crypt = open("../found1").read().rstrip("\n")
for i in range(len(crypt)):
shift2Use = i % lShifts
try:
indexInAlp = alphabet.index(crypt[i])
except ValueError:
continue
#print indexInAlp, indexInAlp + shifts[shift2Use] % 26
newIndex = (indexInAlp + shifts[shift2Use]) % 26
print alphabet[newIndex],
def get_move(self, game):
moves = subprocess.check_output(['./a.out', 'games/%d.gcg' % game.id]).split('\n')
for move in moves:
if not move:
return
if move.startswith('nonmove'):
return
logging.info("Quackle suggests: %s" % move)
place, word, _ = move.split(None, 2)
logging.debug(place, word)
word = word.decode('utf-8')
# Number first for horizontal plays
direction = Word.ACROSS if place[0].isdigit() else Word.DOWN
board = game.get_board()
if direction == Word.ACROSS:
y, x = re.findall(r'([0-9]+)([a-zA-Z]+)', place)[0]
x = ascii_uppercase.index(x)
y = int(y) - 1
w = ''.join([board[(x + i, y)] if v == '.' else swapcase(v) for i, v in enumerate(word)])
else:
x, y = re.findall(r'([a-zA-Z]+)([0-9]+)', place)[0]
x = ascii_uppercase.index(x)
y = int(y) - 1
w = ''.join([board[(x, y + i)] if v == '.' else swapcase(v) for i, v in enumerate(word)])
try:
logging.info('Attempting %s @ %d, %d', str(w), x, y)
game.play(w, x, y, direction)
return
except WordfeudError, e:
logging.error('Error placing %s' % word)
def UserMakesMove(self):
#user enters coords to make a mov function, prevents invalid ones
valid=False
computer=False
while not valid:
try:
#x=random.randint(0,9)
#=random.randint(0,9)
userinput=input("Enter coordinates x y (x in [A..J] and y in [1..10]): ")
x,y=userinput.split()
x=ascii_uppercase.index(x.upper())
y=int(y)-1
except:
print("Invalid coordinates please try again")
else:
if x >-1 and x <10 and y>-1 and y<10:
if self.makeA_Move(computer,y,x):
return
def userplacement(self):
computer=False
hide=True
# UNCODE THIS PORTION FOR RANDOM PLACEMENT OF USER SHIPS
randominput=input("Would you like your ships to be randomly placed? (Y/ENTER): ")
if randominput.lower()=='y':
self.RandomShipGenerator(computer)
self.drawBoards(hide)
return
#Generates the 5 user ships
for index in range(len(self.__Ship_Sizes)):
valid=False
size=self.__Ship_Sizes[index]
ship=self.__Ship_letter[index]
while not valid:
#validating coords enter by user
print("Placing a",self.__Ship_Names[index],"of size",self.__Ship_Sizes[index])
try:
userinput=input("Enter coordinates x y (x in [A..J] and y in [1..10]): ")
x,y=userinput.split()
x=ascii_uppercase.index(x.upper())
y=int(y)-1
if x >-1 and x <10 and y>-1 and y<10:
orientation=input("This ship is vertical or horizontal (v,h)? ")
else:
#Purposely raises an error to reset the validating process
error=int(error)
except:
pass
else:
#Sends the info to the placement functions
if self.validatePlacement(computer,ship,size,y,x,orientation):
self.drawBoards(hide)
valid=True
else:
#Makes the user enter new coords
self.drawBoards(hide)
if orientation.lower()=='h' or orientation.lower()=='v':
print('Cannot place a',self.__Ship_Names[index],'there. Stern is out of the board or collides with other ship. \nPlease take a look at the board and try again.')
pointless=input('Hit ENTER to continue. ')
else:
print("Invalid orientation.")
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.
"Return a string in its ROT-13 format"
total = ""
for x in range(len(str)):
if str[x] in ascii_uppercase:
total += ascii_uppercase[(ascii_uppercase.index(str[x])+13)%26]
elif str[x] in ascii_lowercase:
total += ascii_lowercase[(ascii_lowercase.index(str[x])+13)%26]
else:
total += str[x]
return total
def shifty(string, shift, encode=True):
if not encode:
string = ''.join(string)
length = 0
shifted_chars = []
for a in string:
shifter = shift if encode else -shift
if a.islower():
shifted_chars.append(low[(low.index(a) + shifter) % 26])
elif a.isupper():
shifted_chars.append(up[(up.index(a) + shifter) % 26])
else:
shifted_chars.append(a)
length += 1
shift += 1
if not encode:
return ''.join(shifted_chars)
chunk = int(ceil(length / 5.0))
result = [''.join(shifted_chars[b:b + chunk])
for b in xrange(0, length, chunk)]
return result if len(result) == 5 else result + ['']
def demoving_shift(strings, shift):
raw_string = ''
coded_message = ''.join(strings)
lens = len(coded_message)
chars = -1
for idx, char in enumerate(coded_message):
chars +=1
change=None
if char in ascii_lowercase + ascii_uppercase:
if char in ascii_lowercase:
pos = ascii_lowercase.index(char)
np = (pos - shift - chars) % 26
change = ascii_lowercase[np]
elif char in ascii_uppercase:
pos = ascii_uppercase.index(char)
np = (pos - shift - chars) % 26
change = ascii_uppercase[np]
else:
change = char
raw_string += change
return raw_string
