Let's try again.

exercises/practice/queen-attack/.meta/example.py

@@ -1,22 +1,22 @@
 class Queen:
     def __init__(self, row, column):
         if row < 0:
-            raise ValueError("row not positive")
+            raise ValueError('row not positive')
         if not 0 <= row <= 7:
-            raise ValueError("row not on board")
+            raise ValueError('row not on board')
         if column < 0:
-           raise ValueError("column not positive")
+            raise ValueError('column not positive')
         if not 0 <= column <= 7:
-            raise ValueError("column not on board")
+            raise ValueError('column not on board')
         self.row = row
         self.column = column
 
     def can_attack(self, another_queen):
-        dx = abs(self.row - another_queen.row)
-        dy = abs(self.column - another_queen.column)
-        if dx == dy == 0:
+        idx = abs(self.row - another_queen.row)
+        edx = abs(self.column - another_queen.column)
+        if idx == edx == 0:
             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
         else:
             return False

exercises/practice/rail-fence-cipher/.meta/example.py

@@ -8,11 +8,10 @@ def fence_pattern(rails, size):
 
 def encode(msg, rails):
     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):
     fence = fence_pattern(rails, len(msg))
     fence_msg = zip(msg, sorted(fence))
-    return ''.join(
-        char for char, _ in sorted(fence_msg, key=lambda item: item[1][1]))
+    return ''.join(char for char, _ in sorted(fence_msg, key=lambda item: item[1][1]))

exercises/practice/rational-numbers/.meta/example.py

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

exercises/practice/rational-numbers/rational_numbers.py

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

exercises/practice/react/.meta/example.py

@@ -21,13 +21,13 @@ class Cell:
 
 class InputCell(Cell):
     def __init__(self, initial_value):
-        super(InputCell, self).__init__()
+        super().__init__()
         self._value = initial_value
 
 
 class ComputeCell(Cell):
     def __init__(self, inputs, compute_function):
-        super(ComputeCell, self).__init__()
+        super().__init__()
         self.inputs = inputs
         self.func = compute_function
         self.callbacks = set()
@@ -40,7 +40,7 @@ class ComputeCell(Cell):
 
     def compute(self):
         # 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
         new_val = self.func([inp.value for inp in self.inputs])
         if new_val != self._value:

exercises/practice/rectangles/.meta/example.py

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

exercises/practice/rest-api/.meta/example.py

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

exercises/practice/rna-transcription/.meta/example.py

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

exercises/practice/robot-name/.meta/example.py

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

exercises/practice/robot-simulator/.meta/example.py

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

exercises/practice/robot-simulator/robot_simulator.py

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

exercises/practice/roman-numerals/.meta/example.py

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

exercises/practice/rotational-cipher/.meta/example.py

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

exercises/practice/run-length-encoding/.meta/example.py

@@ -3,11 +3,11 @@ from re import sub
 
 
 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 single_helper(k, g):
-        size = len(list(g))
-        return k if size == 1 else str(size) + k
+    def single_helper(key, group):
+        size = len(list(group))
+        return key if size == 1 else str(size) + key
     return ''.join(single_helper(key, group) for key, group in groupby(string))