update questions module

scripts/quiz/questions.py

@@ -1,175 +1,29 @@
-import random
-from typing import Literal
+from .utils import convert_sequence_to_string
 
 
-def generate_question_data(level: Literal["easy", "medium", "hard"] = "easy", increment=1):
-    """generate question, its numbers and proper answer"""
-
-    nums = generate_numbers_by_level(level)
-    cur_num = nums['current_number']                                        # current number
-    ord_num = nums['ordinal_number']                                        # ordinal number
-    num_seq = generate_number_sequence(cur_num, ord_num, times=increment)   # sequence with ord_num = 1, times = 1
-
-    count_up_by_one_questions = [
-        {
-            "question": f"Let's practice counting. After {cur_num}, what number is next?\n{num_seq}",
-            "current_number": cur_num,
-            "ordinal_number": 1,
-            "times": 1,
-            "answer": cur_num + 1
-        }
-    ]
-    seq_up_by_ord = generate_number_sequence(cur_num, ord_num, times=1)     # sequence with times = 1
-    count_up_by_ord_questions = [
-        {
-            "question": f"What number comes {ord_num} number after {cur_num}?\n{seq_up_by_ord}",
-            "current_number": cur_num,
-            "ordinal_number": ord_num,
-            "times": 1,
-            "answer": cur_num + ord_num 
-        },
-        {
-            "question": f"If we count up {ord_num} from {cur_num}, what number is next?\n{seq_up_by_ord}",
-            "current_number": cur_num,
-            "ordinal_number": ord_num,
-            "times": 1,
-            "answer": cur_num + ord_num
-        }
-    ]
-    times = 1 if level == "easy" else nums['times']
-    times_ord_seq = generate_number_sequence(cur_num, ord_num, times)
-    times_ord_questions = [
-        {
-            "question": f"We're counting up by {times}s. What number is {ord_num} after {cur_num}?\n{times_ord_seq}",
-            "current_number": cur_num,
-            "ordinal_number": ord_num,
-            "times": times,
-            "answer": cur_num + ord_num * times
-        }
-    ]
-    times_only_seq = generate_number_sequence(cur_num, 1, times)            # sequence with ordinal number = 1
-    times_only_questions = [
-        {
-            "question": f"Let's count up by {times}s. What number is next if we start from {cur_num}?\n{times_only_seq}",
-            "current_number": cur_num,
-            "ordinal_number": 1,
-            "times": times,
-            "answer": cur_num + times
-        }
-    ]
-    print(f"Let's practice counting   {'... '.join([str(num) for num in range(8, 11)])}... After 10, what is the next number you will count?")
-    # Let's practice counting   8...  9... 10...   After 10, what is the next number you will count?
-    8, 9, 10
-    questions = [*count_up_by_one_questions, *count_up_by_ord_questions, *times_only_questions, *times_ord_questions]
-    random_choice = random.choice(questions)
-    return random_choice
-
-
-def generate_question(start, step=None, seq=None, question_num=1):
+def generate_question_data(start, step, question_num=1):
     """returns question by provided number with filled parameters
     
     parameters
     ----------
-    :num: question number
     :start: current number
     :step: interval between current and next numbers
-    :seq: sequence of numbers"""
-    convert_sequence_to_string(start, step, )
-    questions = {
-        1: f"Let's practice counting   {seq}   After {start}, what is the next number you will count?",
-        2: f"What number comes {step} number after {start}?",
-        3: f"We're counting by {step}s.  What number is 1 after {start}?",
-        4: f"What is {step} number up from {start}?",
-        5: f"If we could up {step} from {start}, what number is next?",
-    }
-    if step > 1:
-        questions.update({
-            6: f"Now we're counting up by {step} 😄 From {start - 2 * step}, I count {step} numbers to get to {start - step}.  Then from {start - step} I count {step} numbers to get to {start}.  What is {step} numbers after {start}?",
-            7: f"What is {step} numbers after {start}?  Let's count one number ... {start + 1}... now what is the next number?"
+    :question_num: question number"""
+    seq = convert_sequence_to_string(start, step)
+    start_from_num = start + 2 * step
+    questions = [
+        f"Let's practice counting   {convert_sequence_to_string(start, step, sep='... ')}   After {start_from_num}, what is the next number you will count?\n{seq}",
+        f"What number comes {step} number after {start_from_num}?\n{seq}",
+        f"We're counting by {step}s.  What number is 1 after {start_from_num}?\n{seq}",
+        f"What is {step} number up from {start_from_num}?\n{seq}",
+        f"If we count up {step} from {start_from_num}, what number is next?\n{seq}",
+    ]
+    questions_data = []
+    for quest in questions:
+        questions_data.append({
+            "question": quest,
+            "answer": start_from_num + step,
+            "start": start_from_num,
+            "step": step
         })
-    return questions[question_num]
-
-
-def generate_start_by_score(score):
-    """generate number by scrore
-    
-    to calculate the starting point """
-    if score <= 0.3:
-        range_size = 27 - 1                              # total range size
-        range_offset = score                             # offset from the lower end of the range
-        proportion = range_offset / 0.3                  # proportion of the total range
-        number_range = int(proportion * range_size)      # size of the range based on the argument
-        return random.randint(1, 1 + number_range)
-    elif score >= 0.6:
-        range_size = 495 - 97                            # total range size
-        range_offset = score - 0.6                       # offset from the lower end of the range
-        proportion = range_offset / (1 - 0.6)            # proportion of the total range
-        number_range = int(proportion * range_size)      # size of the range based on the argument
-        return random.randint(98, 98 + number_range)
-    else:
-        range_size = 97 - 28                             # total range size
-        range_offset = score - 0.3                       # offset from the lower end of the range
-        proportion = range_offset / (0.6 - 0.3)          # proportion of the total range
-        number_range = int(proportion * range_size)      # size of the range based on the argument
-        return random.randint(28, 28 + number_range)
-
-
-def convert_sequence_to_string(start, step):
-    func_vars = {}
-    exec("seq = ', '.join([str(num) for num in range({start}, {stop}, {step})][::-1])".format(start=start, stop=start-3*step, step=step * (-1)), func_vars)
-    return func_vars['seq']
-
-
-
-def generate_numbers_by_level(level: Literal["easy", "medium", "hard"] = "easy"):
-    """generate current number, ordinal number and times parameter
-    
-    returns
-    dict with params:
-    :param current_number: current number
-    :param ordinal numebr: the number we count up by
-    :param times: the number of times we count up by ordinal number"""
-
-    if level == "easy":
-        cur_num = random.randint(5, 15)
-        ord_num = random.randint(1, 2)
-        times = 1
-    elif level == "medium":
-        cur_num = random.randint(1, 94)
-        ord_num = random.randint(1, 3)
-        times = random.randint(1, 2)
-    elif level == "hard":
-        cur_num = random.randint(1, 488)
-        ord_num = random.randint(1, 4)
-        times = random.randint(1, 2)
-
-    return {
-        "current_number": cur_num,
-        "ordinal_number": ord_num,
-        "times": times
-    }
-
-
-def generate_number_sequence(cur_num, ord_num, times=1):
-    """generate one of 2 sequences. For example we want 55 to be a right answer, then sequences can be:
-    52 53 54 ...
-    ... 56 57 58
-    
-    parameters
-    :cur_num: current number
-    :ord_num: ordinal number
-    :times: times"""
-    max_num = cur_num + times * ord_num
-
-    seq_before = [str(num) for num in range(max_num - times, 0, -times)][:3][::-1]
-    seq_after = [str(num) for num in range(max_num + times, max_num + 4 * times, times)]
-    seq_before.append("...")
-    seq_after.insert(0, "...")
-
-    seqs = []
-    if len(seq_before) == 4:
-        seqs.append(seq_before)
-    if len(seq_after) == 4:
-        seqs.append(seq_after)
-    rand_seq = " ".join(random.choice(seqs))
-    return rand_seq
+    return questions_data[question_num]