resolve #81, #82

Author: lilyhe123

.gitignore

@@ -2,3 +2,5 @@ note.md
 __pycache__/
 venv/
 stats/
+.vscode
+sync.sh

daily.py

@@ -1780,43 +1780,38 @@ def test_78():
 """
 
 
-def canBecomeNonincreasing(nums):
+def canBecomeNondecreasing(nums):
     count = 0
     valley_idx = 0
-    pre = nums[0]
     for i in range(1, len(nums)):
-        if nums[i] < pre:
+        if nums[i] < nums[i - 1]:
             count += 1
             valley_idx = i
-        pre = nums[i]
-    if count == 0:
-        return True
-    if count > 1:
-        return False
-    # count = 1
-    if (
-        valley_idx == 1
+        if count > 1:
+            return False
+    # count = 0 or 1
+    return (
+        count == 0
+        or valley_idx == 1
         or valley_idx == len(nums) - 1
         or nums[valley_idx - 1] <= nums[valley_idx + 1]
-    ):
-        return True
-    else:
-        return False
+    )
 
 
 def test_79():
     nums = [10, 5, 7]
-    assert canBecomeNonincreasing(nums)
+    assert canBecomeNondecreasing(nums)
     nums = [10, 5, 1]
-    assert not canBecomeNonincreasing(nums)
+    assert not canBecomeNondecreasing(nums)
     nums = [1, 5, 2, 7]
-    assert canBecomeNonincreasing(nums)
+    assert canBecomeNondecreasing(nums)
     nums = [1, 5, 2, 3]
-    assert not canBecomeNonincreasing(nums)
+    assert not canBecomeNondecreasing(nums)
     nums = [1, 2, 3, -10]
-    assert canBecomeNonincreasing(nums)
+    assert canBecomeNondecreasing(nums)
 
 
+test_79()
 """
 question 80
 Given the root of a binary tree, return a deepest node. For example, in the
@@ -1850,3 +1845,143 @@ def question80():
 
 def test_80():
     pass
+
+
+"""
+question 81
+Given a mapping of digits to letters (as in a phone number), and a digit string,
+return all possible letters the number could represent. You can assume each
+valid number in the mapping is a single digit.
+
+For example if {“2”: [“a”, “b”, “c”], 3: [“d”, “e”, “f”], …} then “23” should
+return [“ad”, “ae”, “af”, “bd”, “be”, “bf”, “cd”, “ce”, “cf"].
+
+-------------------
+One digit can be mapped to different letters. We need to exhaust all the combinations
+of the possible letters of each digit.
+
+For a two-digit number, we can use two nested loops to exhaust all the combinations of
+the two lists.
+For a n-digit number, we need more general way to handle it.
+There are two approaches: iteration and recursion
+
+Iteration
+Create a queue and each element in the queue is a list of string.
+Initially for every digit of the given number, get its mapped letters from the map and
+store it to the queue.
+
+Then we can iterate the queue until only one element left.
+  At each step remove two elements from the queue and merge them into one,
+  with all combinations of the two list. Then add the merged list to the queue.
+Return the last element.
+
+Recursion
+Break down the problem into smaller problems.
+The problem is that for a given number we need to return a list of string reprented by letter.
+For a n-digit number, split it to two parts: first digit and n-1 digits.
+First sesolve the two smaller problels seperately and recursively.
+Then merge the returned two lists into one and return.
+The base case is when there is only one digit in the number, return its mapped letters directly.
+
+Let's do this in recursive way.
+"""
+
+
+def convertToLetters(map, num):
+    def dfs(s):
+        if len(s) == 1:
+            return map[s]
+        rtn = []
+        l1 = dfs(s[0])
+        l2 = dfs(s[1:])
+        for e1 in l1:
+            for e2 in l2:
+                rtn.append(e1 + e2)
+        return rtn
+
+    return dfs(num)
+
+
+def test_81():
+    map = {"2": ["a", "b", "c"], "3": ["d", "e", "f"], "4": ["h", "i"]}
+    num = "23"
+    assert convertToLetters(map, num) == [
+        "ad",
+        "ae",
+        "af",
+        "bd",
+        "be",
+        "bf",
+        "cd",
+        "ce",
+        "cf",
+    ]
+    num = "342"
+    assert convertToLetters(map, num) == [
+        "dha",
+        "dhb",
+        "dhc",
+        "dia",
+        "dib",
+        "dic",
+        "eha",
+        "ehb",
+        "ehc",
+        "eia",
+        "eib",
+        "eic",
+        "fha",
+        "fhb",
+        "fhc",
+        "fia",
+        "fib",
+        "fic",
+    ]
+
+
+"""
+question 82
+Using a read7() method that returns 7 characters from a file, implement readN(n)
+which reads n characters.
+
+For example, given a file with the content “Hello world”, three read7() returns
+“Hello w”, “orld” and then “”.
+
+-------------------
+
+"""
+input = "abcdefghijklmnopqrstuvw"
+idx = 0
+
+
+def read7():
+    global idx
+    diff = min(7, len(input) - idx)
+    idx += diff
+    return input[idx - diff : idx]
+
+
+def readN(n):
+    li = []
+    while n > 0:
+        s = read7()
+        if s == "":
+            break
+        elif n < len(s):
+            li.append(s[:n])
+        else:
+            li.append(s)
+        n -= 7
+    return "".join(li)
+
+
+def test_82():
+    global idx
+    assert len(readN(20)) == 20
+    idx = 0
+    assert len(readN(14)) == 14
+    idx = 0
+    assert len(readN(50)) == len(input)
+
+
+test_82()

format.py

@@ -1,10 +1,12 @@
 # Read problem description from a file
-# the first line of the file is the quesiton number.
-# Generate a output file with the description included in a block comment
+# the first line of the file is the question number.
+# Generate an output file with the description included in a block comment
 # with each line less than 80.
 # and create question and test functions for it.
+#
+# read from question.txt, write to daily.py
 def format_question(text: str, num: int, limit: int) -> str:
-    output = '"""\nquestion ' + str(num) + "\n"
+    output = '\n"""\nquestion ' + str(num) + "\n"
     cur_line = ""
     for line in text.splitlines():
         for token in line.split(" "):
@@ -34,8 +36,8 @@ def format_question(text: str, num: int, limit: int) -> str:
 
 
 def read_and_format(input_file, output_file):
-    with open(input_file) as file_object:
-        lines = file_object.readlines()
+    with open(input_file, "r") as input_obj:
+        lines = input_obj.readlines()
         text = ""
         for i, line in enumerate(lines):
             if i == 0:
@@ -44,8 +46,19 @@ def read_and_format(input_file, output_file):
                 text += line
 
     output = format_question(text, num, 80)
-    with open(output_file, "w") as file_object:
-        file_object.write(output)
+    test_method = "test_" + str(num) + "()"
+    with open(output_file, "a+") as output_obj:
+        output_obj.seek(0)
+        lines = output_obj.readlines()
+        for line in lines:
+            if test_method in line:
+                print(
+                    "The question is already included in ",
+                    output_file + ".",
+                    "Do Nothing.",
+                )
+                return
+        output_obj.write(output)
 
 
-read_and_format("question.txt", "output.txt")
+read_and_format("question.txt", "daily.py")

output.txt

@@ -1,12 +1,15 @@
 """
-question 80
-Given the root of a binary tree, return a deepest node. For example, in the
-following tree, return d.
+question 82
+Using a read7() method that returns 7 characters from a file, implement readN(n)
+which reads n characters.
+
+For example, given a file with the content “Hello world”, three read7() returns
+“Hello w”, “orld” and then “”.
 
 -------------------
 
 
 """
-def question80(): pass
-def test_80(): pass
-test_80()
+def question82(): pass
+def test_82(): pass
+test_82()

question.txt

@@ -1,8 +1,4 @@
-80
-Given the root of a binary tree, return a deepest node. For example, in the following tree, return d.
+82
+Using a read7() method that returns 7 characters from a file, implement readN(n) which reads n characters.
 
-    a
-   / \
-  b   c
- /
-d
+For example, given a file with the content “Hello world”, three read7() returns “Hello w”, “orld” and then “”.