First files

Author: J08K

exercises/practice/matrix/.meta/example.py

@@ -1,7 +1,7 @@
 class Matrix:
-    def __init__(self, s):
-        self.rows = [[int(n) for n in row.split()]
-                     for row in s.split('\n')]
+    def __init__(self, matrix_string):
+        self.rows = [[int(number) for number in row.split()]
+                     for row in matrix_string.split('\n')]
         self.columns = [list(tup) for tup in zip(*self.rows)]
 
     def row(self, index):

exercises/practice/minesweeper/.meta/example.py

@@ -15,26 +15,26 @@ def annotate(minefield):
             high = min(index2 + 2, row_len + 2)
             counts = minefield[index1][low:high].count('*')
 
-            if(index1 > 0):
+            if index1 > 0:
                 counts += minefield[index1 - 1][low:high].count('*')
-            if(index1 < col_len - 1):
+            if index1 < col_len - 1:
                 counts += minefield[index1 + 1][low:high].count('*')
             if counts == 0:
                 continue
 
             board[index1][index2] = str(counts)
-    return ["".join(row) for row in board]
+    return [''.join(row) for row in board]
 
 
 def verify_board(minefield):
     # Rows with different lengths
     row_len = len(minefield[0])
     if not all(len(row) == row_len for row in minefield):
-        raise ValueError("The board is invalid with current input.")
+        raise ValueError('The board is invalid with current input.')
 
     # Unknown character in board
     character_set = set()
     for row in minefield:
         character_set.update(row)
     if character_set - set(' *'):
-        raise ValueError("The board is invalid with current input.")
+        raise ValueError('The board is invalid with current input.')

exercises/practice/nucleotide-count/.meta/example.py

@@ -15,4 +15,4 @@ def nucleotide_counts(strand):
 
 def _validate(abbreviation):
     if abbreviation not in NUCLEOTIDES:
-        raise ValueError('{} is not a nucleotide.'.format(abbreviation))
+        raise ValueError(f'{abbreviation} is not a nucleotide.')

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

@@ -3,8 +3,8 @@
 
 
 def split_ocr(ocr):
-    return [[ocr[i][NUM_COLS * j:NUM_COLS * (j + 1)] for i in range(NUM_ROWS)]
-            for j in range(len(ocr[0]) // NUM_COLS)]
+    return [[ocr[idx][NUM_COLS * jam:NUM_COLS * (jam + 1)] for idx in range(NUM_ROWS)]
+            for jam in range(len(ocr[0]) // NUM_COLS)]
 
 
 ALL = ['    _  _     _  _  _  _  _  _ ',
@@ -23,21 +23,21 @@ def convert(input_grid):
     lines = [input_grid[start:end]
              for start, end in zip(split_indices[:-1], split_indices[1:])]
 
-    return ",".join(convert_one_line(line) for line in lines)
+    return ','.join(convert_one_line(line) for line in lines)
 
 
 def convert_one_line(input_grid):
     if len(input_grid) != NUM_ROWS:
-        raise ValueError("Number of input lines is not a multiple of four")
+        raise ValueError('Number of input lines is not a multiple of four')
 
     if len(input_grid[0]) % NUM_COLS:
-        raise ValueError("Number of input columns is not a multiple of three")
+        raise ValueError('Number of input columns is not a multiple of three')
 
     numbers = split_ocr(input_grid)
     digits = ''
-    for n in numbers:
+    for num in numbers:
         try:
-            digits += str(OCR_LIST.index(n))
+            digits += str(OCR_LIST.index(num))
         except ValueError:
             digits += '?'
     return digits

exercises/practice/octal/.meta/example.py

@@ -1,11 +1,11 @@
 def parse_octal(digits):
     digits = _validate_octal(digits)
-    return sum(int(digit) * 8 ** i
-               for (i, digit) in enumerate(reversed(digits)))
+    return sum(int(digit) * 8 ** idx
+               for (idx, digit) in enumerate(reversed(digits)))
 
 
 def _validate_octal(digits):
-    for d in digits:
-        if not '0' <= d < '8':
-            raise ValueError("Invalid octal digit: " + d)
+    for digit in digits:
+        if not '0' <= digit < '8':
+            raise ValueError("Invalid octal digit: " + digit)
     return digits

exercises/practice/palindrome-products/.meta/example.py

@@ -3,16 +3,15 @@
 
 
 def largest(min_factor, max_factor):
-    return get_extreme_palindrome_with_factors(max_factor, min_factor, "largest")
+    return get_extreme_palindrome_with_factors(max_factor, min_factor, 'largest')
 
 
 def smallest(max_factor, min_factor):
-    return get_extreme_palindrome_with_factors(max_factor, min_factor, "smallest")
+    return get_extreme_palindrome_with_factors(max_factor, min_factor, 'smallest')
 
 
 def get_extreme_palindrome_with_factors(max_factor, min_factor, extreme):
-    palindromes_found = palindromes(max_factor, min_factor,
-                                    reverse=(extreme == "largest"))
+    palindromes_found = palindromes(max_factor, min_factor, reverse=(extreme == 'largest'))
     factor_pairs = None
     for palindrome in palindromes_found:
         factor_pairs = ((factor, palindrome // factor)
@@ -30,12 +29,12 @@ def get_extreme_palindrome_with_factors(max_factor, min_factor, extreme):
 
 
 def reverse_num(number):
-    reversed = 0
+    reversed_nums = 0
     while number > 0:
-        reversed *= 10
-        reversed += (number % 10)
+        reversed_nums *= 10
+        reversed_nums += (number % 10)
         number //= 10
-    return reversed
+    return reversed_nums
 
 
 def num_digits(number):
@@ -50,31 +49,31 @@ def palindromes(max_factor, min_factor, reverse=False):
     most of the palindromes just to find the one it needs.
     """
     if max_factor < min_factor:
-        raise ValueError("min must be <= max")
+        raise ValueError('min must be <= max')
 
     minimum = min_factor ** 2
     maximum = max_factor ** 2
 
-    def gen_palindromes_of_length(num_digits, reverse=reverse):
+    def gen_palindromes_of_length(digit_count, reverse=reverse):
         """Generates all palindromes with `nd` number of digits that are
         within the desired range.
         Again, if `reverse` is True, the palindromes are generated in
         reverse order.
         """
-        even_nd = (num_digits % 2 == 0)
+        even_nd = (digit_count % 2 == 0)
 
-        min_left_half = max(10 ** (int(ceil(num_digits / 2)) - 1),
-                            minimum // (10 ** (num_digits // 2)))
-        max_left_half = min((10 ** int(ceil(num_digits / 2))) - 1,
-                            maximum // (10 ** (num_digits // 2)))
+        min_left_half = max(10 ** (int(ceil(digit_count / 2)) - 1),
+                            minimum // (10 ** (digit_count // 2)))
+        max_left_half = min((10 ** int(ceil(digit_count / 2))) - 1,
+                            maximum // (10 ** (digit_count // 2)))
 
         current_left_half = min_left_half if not reverse else max_left_half
 
         def make_palindrome(left_half, even_nd=False):
             right_half = (reverse_num(left_half)
                           if even_nd
                           else reverse_num(left_half // 10))
-            return (left_half * (10 ** (num_digits // 2))) + right_half
+            return (left_half * (10 ** (digit_count // 2))) + right_half
 
         if not reverse:
             while current_left_half <= max_left_half:

exercises/practice/parallel-letter-frequency/.meta/example.py

@@ -2,11 +2,7 @@
 from collections import Counter
 from threading import Lock, Thread
 from time import sleep
-import sys
-if sys.version[0] == '2':
-    from Queue import Queue
-else:
-    from queue import Queue
+from queue import Queue
 
 total_workers = 3  # Maximum number of threads chosen arbitrarily
 
@@ -30,8 +26,8 @@ def count_letters(queue_of_texts, letter_to_frequency, worker_id):
         sleep(worker_id + 1)
         line_input = queue_of_texts.get()
         if line_input is not None:
-            letters_in_line = Counter([x for x in line_input.lower() if
-                                       x.isalpha()])
+            letters_in_line = Counter([idx for idx in line_input.lower() if
+                                       idx.isalpha()])
             letter_to_frequency.add_counter(letters_in_line)
         queue_of_texts.task_done()
         if line_input is None:
@@ -40,17 +36,18 @@ def count_letters(queue_of_texts, letter_to_frequency, worker_id):
 
 def calculate(list_of_texts):
     queue_of_texts = Queue()
-    [queue_of_texts.put(line) for line in list_of_texts]
+    for line in list_of_texts:
+        queue_of_texts.put(line)
     letter_to_frequency = LetterCounter()
     threads = []
-    for i in range(total_workers):
+    for idx in range(total_workers):
         worker = Thread(target=count_letters, args=(queue_of_texts,
-                                                    letter_to_frequency, i))
+                                                    letter_to_frequency, idx))
         worker.start()
         threads.append(worker)
     queue_of_texts.join()
-    for i in range(total_workers):
+    for _ in range(total_workers):
         queue_of_texts.put(None)
-    for t in threads:
-        t.join()
+    for thread in threads:
+        thread.join()
     return letter_to_frequency.value

exercises/practice/pascals-triangle/.meta/example.py

@@ -3,10 +3,10 @@ def rows(row_count):
         return None
     elif row_count == 0:
         return []
-    r = []
+    rows = []
     for i in range(row_count):
-        rn = [1]
+        ronald = [1]
         for j in range(i):
-            rn.append(sum(r[-1][j:j+2]))
-        r.append(rn)
-    return r
+            ronald.append(sum(rows[-1][j:j+2]))
+        rows.append(ronald)
+    return rows