exercism/python
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Let's try again.

Browse Source
This commit is contained in:
Job van der Wal
2021-11-23 14:05:17 +01:00
committed by BethanyG
parent 3f4d788214
commit 37e518470a
14 changed files with 103 additions and 123 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
exercises/practice/queen-attack/.meta/example.py
View File

@@ -1,22 +1,22 @@
class Queen: class Queen:
def __init__(self, row, column): def __init__(self, row, column):
if row < 0: if row < 0:
raise ValueError("row not positive") raise ValueError('row not positive')
if not 0 <= row <= 7: if not 0 <= row <= 7:
raise ValueError("row not on board") raise ValueError('row not on board')
if column < 0: if column < 0:
raise ValueError("column not positive") raise ValueError('column not positive')
if not 0 <= column <= 7: if not 0 <= column <= 7:
raise ValueError("column not on board") raise ValueError('column not on board')
self.row = row self.row = row
self.column = column self.column = column
def can_attack(self, another_queen): def can_attack(self, another_queen):
dx = abs(self.row - another_queen.row) idx = abs(self.row - another_queen.row)
dy = abs(self.column - another_queen.column) edx = abs(self.column - another_queen.column)
if dx == dy == 0: if idx == edx == 0:
raise ValueError('Invalid queen position: both queens in the same square') raise ValueError('Invalid queen position: both queens in the same square')
elif dx == dy or dx == 0 or dy == 0: elif idx == edx or idx == 0 or edx == 0:
return True return True
else: else:
return False return False

5
exercises/practice/rail-fence-cipher/.meta/example.py
View File

@@ -8,11 +8,10 @@ def fence_pattern(rails, size):
def encode(msg, rails): def encode(msg, rails):
fence = fence_pattern(rails, len(msg)) fence = fence_pattern(rails, len(msg))
return ''.join(msg[i] for _, i in sorted(fence)) return ''.join(msg[idx] for _, idx in sorted(fence))
def decode(msg, rails): def decode(msg, rails):
fence = fence_pattern(rails, len(msg)) fence = fence_pattern(rails, len(msg))
fence_msg = zip(msg, sorted(fence)) fence_msg = zip(msg, sorted(fence))
return ''.join( return ''.join(char for char, _ in sorted(fence_msg, key=lambda item: item[1][1]))
char for char, _ in sorted(fence_msg, key=lambda item: item[1][1]))

9
exercises/practice/rational-numbers/.meta/example.py
View File

@@ -1,9 +1,4 @@
from __future__ import division from math import gcd
try:
from math import gcd
except ImportError:
from fractions import gcd
class Rational: class Rational:
@@ -22,7 +17,7 @@ class Rational:
return self.numer == other.numer and self.denom == other.denom return self.numer == other.numer and self.denom == other.denom
def __repr__(self): def __repr__(self):
return '{}/{}'.format(self.numer, self.denom) return f'{self.numer}/{self.denom}'
def __add__(self, other): def __add__(self, other):
numer = (self.numer * other.denom) + (other.numer * self.denom) numer = (self.numer * other.denom) + (other.numer * self.denom)

5
exercises/practice/rational-numbers/rational_numbers.py
View File

@@ -1,6 +1,3 @@
from __future__ import division
class Rational: class Rational:
def __init__(self, numer, denom): def __init__(self, numer, denom):
self.numer = None self.numer = None
@@ -10,7 +7,7 @@ class Rational:
return self.numer == other.numer and self.denom == other.denom return self.numer == other.numer and self.denom == other.denom
def __repr__(self): def __repr__(self):
return '{}/{}'.format(self.numer, self.denom) return f'{self.numer}/{self.denom}'
def __add__(self, other): def __add__(self, other):
pass pass

6
exercises/practice/react/.meta/example.py
View File

@@ -21,13 +21,13 @@ class Cell:
class InputCell(Cell): class InputCell(Cell):
def __init__(self, initial_value): def __init__(self, initial_value):
super(InputCell, self).__init__() super().__init__()
self._value = initial_value self._value = initial_value
class ComputeCell(Cell): class ComputeCell(Cell):
def __init__(self, inputs, compute_function): def __init__(self, inputs, compute_function):
super(ComputeCell, self).__init__() super().__init__()
self.inputs = inputs self.inputs = inputs
self.func = compute_function self.func = compute_function
self.callbacks = set() self.callbacks = set()
@@ -40,7 +40,7 @@ class ComputeCell(Cell):
def compute(self): def compute(self):
# Only compute this cell when all inputs have same counters # Only compute this cell when all inputs have same counters
if len(set([inp.counter for inp in self.inputs])) > 1: if len({inp.counter for inp in self.inputs}) > 1:
return return
new_val = self.func([inp.value for inp in self.inputs]) new_val = self.func([inp.value for inp in self.inputs])
if new_val != self._value: if new_val != self._value:

80
exercises/practice/rectangles/.meta/example.py
View File

@@ -2,34 +2,36 @@ import itertools
class Corners: class Corners:
def __init__(self, i, j): def __init__(self, idx, jdx):
# i, j are position of corner # i, j are position of corner
self.i = i self.idx = idx
self.j = j self.jdx = jdx
def __str__(self): def __str__(self):
return "[" + str(self.i) + ", " + str(self.j) + "]" return '[' + str(self.idx) + ', ' + str(self.jdx) + ']'
# return corner on the same line # return corner on the same line
def same_line(index, list): def same_line(index, list_obj):
for corner in list: for corner in list_obj:
if corner.i == index: if corner.idx == index:
return corner return corner
return None
# return corner on the same column # return corner on the same column
def same_col(index, list): def same_col(index, list_obj):
for corner in list: for corner in list_obj:
if corner.j == index: if corner.jdx == index:
return corner return corner
return None
def search_corners(input): def search_corners(list_obj):
return [Corners(item, element) for item in range(len(input)) return [Corners(item, element) for item in range(len(list_obj))
for element in range(len(input[item])) for element in range(len(list_obj[item]))
if (input[item][element] == "+")] if list_obj[item][element] == '+']
# validate that 4 points form a rectangle by # validate that 4 points form a rectangle by
@@ -39,54 +41,54 @@ def possible_rect(quartet):
mid_y = 0 mid_y = 0
for centroid in quartet: for centroid in quartet:
mid_x = mid_x + centroid.i / 4.0 mid_x = mid_x + centroid.idx / 4.0
mid_y = mid_y + centroid.j / 4.0 mid_y = mid_y + centroid.jdx / 4.0
# reference distance using first corner # reference distance using first corner
dx = abs(quartet[0].i - mid_x) dx = abs(quartet[0].idx - mid_x)
dy = abs(quartet[0].j - mid_y) dy = abs(quartet[0].jdx - mid_y)
# Check all the same distance from centroid are equals # Check all the same distance from centroid are equals
for i in range(1, len(quartet)): for idx in range(1, len(quartet)):
if abs(quartet[i].i - mid_x) != dx or abs(quartet[i].j - mid_y) != dy: if abs(quartet[idx].idx - mid_x) != dx or abs(quartet[idx].jdx - mid_y) != dy:
return False return False
return True return True
# validate path between two corners # validate path between two corners
def path(corner1, corner2, input): def path(corner1, corner2, item):
if corner1.i == corner2.i: if corner1.idx == corner2.idx:
for j in range(min(corner1.j + 1, corner2.j + 1), for jdx in range(min(corner1.jdx + 1, corner2.jdx + 1),
max(corner1.j, corner2.j)): max(corner1.jdx, corner2.jdx)):
if input[corner1.i][j] != "-" and input[corner1.i][j] != "+": if item[corner1.idx][jdx] != '-' and item[corner1.idx][jdx] != '+':
return False return False
return True return True
elif corner1.j == corner2.j: elif corner1.jdx == corner2.jdx:
for i in range(min(corner1.i + 1, corner2.i + 1), for idx in range(min(corner1.idx + 1, corner2.idx + 1),
max(corner1.i, corner2.i)): max(corner1.idx, corner2.idx)):
if input[i][corner1.j] != "|" and input[i][corner1.j] != "+": if item[idx][corner1.jdx] != '|' and item[idx][corner1.jdx] != '+':
return False return False
return True return True
return None
# validate path of rectangle # validate path of rectangle
def validate_rect(rectangle, input): def validate_rect(rectangle, item):
# validate connection at every corner # validate connection at every corner
# with neighbours on the same line and col # with neighbours on the same line and col
for i in range(0, len(rectangle)): for idx, _ in enumerate(rectangle):
line = same_line(rectangle[i].i, rectangle[0:i] + rectangle[i + 1:]) line = same_line(rectangle[idx].idx, rectangle[0:idx] + rectangle[idx + 1:])
column = same_col(rectangle[i].j, rectangle[0:i] + rectangle[i + 1:]) column = same_col(rectangle[idx].jdx, rectangle[0:idx] + rectangle[idx + 1:])
if ((not path(rectangle[i], line, input)) or if not path(rectangle[idx], line, item) or not path(rectangle[idx], column, item):
(not path(rectangle[i], column, input))):
return False return False
return True return True
# count number of rectangles inside ASCII in input lines # count number of rectangles inside ASCII in input lines
def rectangles(strings=""): def rectangles(strings=''):
rectangle_total = 0 rectangle_total = 0
# test empty str # test empty str
if not strings: if not strings:
@@ -95,7 +97,7 @@ def rectangles(strings=""):
corners = search_corners(strings) corners = search_corners(strings)
# no corners in str # no corners in str
if not len(corners): if not corners:
return rectangle_total return rectangle_total
# all combinations of 4 corners # all combinations of 4 corners
@@ -103,7 +105,7 @@ def rectangles(strings=""):
paths = (quartet for quartet in quartets if possible_rect(quartet)) paths = (quartet for quartet in quartets if possible_rect(quartet))
# validate paths # validate paths
for path in paths: for idx in paths:
if validate_rect(path, strings): if validate_rect(idx, strings):
rectangle_total += 1 rectangle_total += 1
return rectangle_total return rectangle_total

21
exercises/practice/rest-api/.meta/example.py
View File

@@ -33,10 +33,11 @@ class RestAPI:
else: else:
return json.dumps({ return json.dumps({
'users': [ 'users': [
u for u in self.database['users'] user for user in self.database['users']
if u['name'] in payload['users'] if user['name'] in payload['users']
] ]
}) })
return None
def post(self, url, payload=None): def post(self, url, payload=None):
result = None result = None
@@ -47,9 +48,9 @@ class RestAPI:
name = payload['user'] name = payload['user']
users = self.database['users'] users = self.database['users']
user = None user = None
for u in users: for idx in users:
if u['name'] == name: if idx['name'] == name:
user = u user = idx
break break
if user is None: if user is None:
new_user = { new_user = {
@@ -67,11 +68,11 @@ class RestAPI:
borrower_name = payload['borrower'] borrower_name = payload['borrower']
amount = payload['amount'] amount = payload['amount']
lender = borrower = None lender = borrower = None
for u in self.database['users']: for user in self.database['users']:
if u['name'] == lender_name: if user['name'] == lender_name:
lender = u lender = user
elif u['name'] == borrower_name: elif user['name'] == borrower_name:
borrower = u borrower = user
if lender is not None and borrower is not None: if lender is not None and borrower is not None:
lender['owed_by'].setdefault(borrower_name, 0) lender['owed_by'].setdefault(borrower_name, 0)
lender['owed_by'][borrower_name] += amount lender['owed_by'][borrower_name] += amount

9
exercises/practice/rna-transcription/.meta/example.py
View File

@@ -1,11 +1,4 @@
import sys DNA_TO_RNA = str.maketrans("AGCT", "UCGA")
if sys.version_info[0] == 2:
from string import maketrans
else:
maketrans = str.maketrans
DNA_TO_RNA = maketrans("AGCT", "UCGA")
def to_rna(dna_strand): def to_rna(dna_strand):
return dna_strand.translate(DNA_TO_RNA) return dna_strand.translate(DNA_TO_RNA)

6
exercises/practice/robot-name/.meta/example.py
View File

@@ -1,16 +1,14 @@
import random import random
ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
class Robot: class Robot:
alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
def __init__(self): def __init__(self):
self._name = None self._name = None
self._past_names = set() self._past_names = set()
def prefix(self): def prefix(self):
return ''.join([ return ''.join([
random.choice(self.alphabet) random.choice(ALPHABET)
for _ in range(0, 2) for _ in range(0, 2)
]) ])

16
exercises/practice/robot-simulator/.meta/example.py
View File

@@ -15,20 +15,20 @@ class Compass:
class Robot: class Robot:
def __init__(self, direction=NORTH, x=0, y=0): def __init__(self, direction=NORTH, x_pos=0, y_pos=0):
self.compass = Compass(direction) self.compass = Compass(direction)
self.x = x self.x_pos = x_pos
self.y = y self.y_pos = y_pos
def advance(self): def advance(self):
if self.direction == NORTH: if self.direction == NORTH:
self.y += 1 self.y_pos += 1
elif self.direction == SOUTH: elif self.direction == SOUTH:
self.y -= 1 self.y_pos -= 1
elif self.direction == EAST: elif self.direction == EAST:
self.x += 1 self.x_pos += 1
elif self.direction == WEST: elif self.direction == WEST:
self.x -= 1 self.x_pos -= 1
def turn_left(self): def turn_left(self):
self.compass.left() self.compass.left()
@@ -50,4 +50,4 @@ class Robot:
@property @property
def coordinates(self): def coordinates(self):
return (self.x, self.y) return (self.x_pos, self.y_pos)

2
exercises/practice/robot-simulator/robot_simulator.py
View File

@@ -7,5 +7,5 @@ SOUTH = None
class Robot: class Robot:
def __init__(self, direction=NORTH, x=0, y=0): def __init__(self, direction=NORTH, x_pos=0, y_pos=0):
pass pass

26
exercises/practice/roman-numerals/.meta/example.py
View File

@@ -1,24 +1,18 @@
NUMERAL_MAPPINGS = ( NUMERAL_MAPPINGS = (
(1000, 'M'), (1000, 'M'), (900, 'CM'),
(900, 'CM'), (500, 'D'), (400, 'CD'),
(500, 'D'), (100, 'C'), (90, 'XC'),
(400, 'CD'), (50, 'L'), (40, 'XL'),
(100, 'C'), (10, 'X'), (9, 'IX'),
(90, 'XC'), (5, 'V'), (4, 'IV'),
(50, 'L'),
(40, 'XL'),
(10, 'X'),
(9, 'IX'),
(5, 'V'),
(4, 'IV'),
(1, 'I') (1, 'I')
) )
def roman(number): def roman(number):
result = '' result = ''
for arabic, roman in NUMERAL_MAPPINGS: for arabic_num, roman_num in NUMERAL_MAPPINGS:
while number >= arabic: while number >= arabic_num:
result += roman result += roman_num
number -= arabic number -= arabic_num
return result return result

17
exercises/practice/rotational-cipher/.meta/example.py
View File

@@ -1,14 +1,15 @@
from string import ascii_lowercase as alpha_lower from string import ascii_lowercase, ascii_uppercase
from string import ascii_uppercase as alpha_upper
ALPHA_LEN = len(alpha_lower)
ALPHA_LEN = len(ascii_lowercase)
def rotate(message, key): def rotate(message, key):
coded_message = "" coded_message = ''
for char in message: for char in message:
if char in alpha_lower: if char in ascii_lowercase:
char = alpha_lower[(alpha_lower.index(char) + key) % ALPHA_LEN] char = ascii_lowercase[(ascii_lowercase.index(char) + key) % ALPHA_LEN]
elif char in alpha_upper: elif char in ascii_uppercase:
char = alpha_upper[(alpha_upper.index(char) + key) % ALPHA_LEN] char = ascii_uppercase[(ascii_uppercase.index(char) + key) % ALPHA_LEN]
coded_message += char coded_message += char
return coded_message return coded_message

8
exercises/practice/run-length-encoding/.meta/example.py
View File

@@ -3,11 +3,11 @@ from re import sub
def decode(string): def decode(string):
return sub(r'(\d+)(\D)', lambda m: m.group(2) * int(m.group(1)), string) return sub(r'(\d+)(\D)', lambda main: main.group(2) * int(main.group(1)), string)
def encode(string): def encode(string):
def single_helper(k, g): def single_helper(key, group):
size = len(list(g)) size = len(list(group))
return k if size == 1 else str(size) + k return key if size == 1 else str(size) + key
return ''.join(single_helper(key, group) for key, group in groupby(string)) return ''.join(single_helper(key, group) for key, group in groupby(string))