Updates

app.py

@@ -3,6 +3,7 @@ import importlib
 import logging
 from fpdf import FPDF
 import uuid
+import json
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -63,12 +64,13 @@ def generate_pdf_report():
 
         for entry in st.session_state.questions:
             if entry['module'] == module:
-                question, options, selected, correct, explanation = (
+                question, options, selected, correct, explanation, step_by_step_solution = (
                     entry['question'], 
                     entry['options'], 
                     entry['selected'], 
-                    entry['correct'], 
-                    entry['explanation']
+                    entry['correct_answer'], 
+                    entry['explanation'],
+                    entry['step_by_step_solution']
                 )
                 pdf.multi_cell(0, 10, f"Q: {question}")
                 for option in options:
@@ -83,6 +85,10 @@ def generate_pdf_report():
                         pdf.multi_cell(0, 10, f"   {option}")
                 pdf.set_text_color(0, 0, 0)  # Reset color
                 pdf.multi_cell(0, 10, f"Explanation: {explanation}")
+                pdf.ln(5)
+                pdf.multi_cell(0, 10, "Step-by-Step Solution:")
+                for step in step_by_step_solution:
+                    pdf.multi_cell(0, 10, step)
                 pdf.ln(10)
 
         pdf.ln(10)  # Add space after each module
@@ -96,16 +102,8 @@ def load_module(module_name):
 
 def generate_new_question(module_name):
     module = load_module(module_name)
-    question, options, correct_answer, explanation = module.generate_question()
-    return {
-        'module': module_name,
-        'question': question,
-        'options': options,
-        'correct': correct_answer,
-        'explanation': explanation,
-        'selected': None,
-        'answered': False
-    }
+    question_data = module.generate_question()
+    return question_data
 
 def navigate_question(direction):
     if direction == "prev" and st.session_state.current_index > 0:
@@ -128,38 +126,17 @@ if module_name != st.session_state.current_module:
     st.session_state.current_index = 0
     st.session_state.questions = [generate_new_question(module_name)]
 
-# Load the current module for title and description
-current_module = load_module(st.session_state.current_module)
+# Load the current module's question
 current_question = st.session_state.questions[st.session_state.current_index]
 
 # Display module title and description
-st.title(current_module.title)
-st.write(current_module.description)
-
-# Button Row: Prev, Next, and PDF Download
-col1, col2, col3 = st.columns([1, 1, 2])
-with col1:
-    st.button("⬅️ Prev", disabled=st.session_state.current_index == 0, on_click=lambda: navigate_question("prev"))
-with col2:
-    st.button("➡️ Next", on_click=lambda: navigate_question("next"))
-with col3:
-    if len(st.session_state.questions) > 0:
-        pdf = generate_pdf_report()
-        st.session_state.pdf_data = pdf  # Reset PDF cache
-        st.download_button(
-            label="Download PDF Report 📄",
-            data=st.session_state.pdf_data,
-            file_name="quiz_report.pdf",
-            mime="application/pdf"
-        )
-
-# Display the current question
-st.write(f"**Question {st.session_state.current_index + 1}:** {current_question['question']}")
+st.title(module_name)
+st.write(current_question["question"])
 
 # Option highlighting logic
 def get_option_style(option):
     if current_question['answered']:
-        if option == current_question['correct']:
+        if option == current_question['correct_answer']:
             return "background-color:#d4edda;padding:10px;border-radius:5px;"  # Green background for correct
         elif option == current_question['selected']:
             return "background-color:#f8d7da;padding:10px;border-radius:5px;"  # Red background for incorrect
@@ -168,21 +145,27 @@ def get_option_style(option):
 selected_answer = st.radio(
     "Choose an answer:", 
     current_question['options'], 
-    index=current_question['options'].index(current_question['selected']) if current_question['selected'] else None, 
-    key=st.session_state.current_index,
-    format_func=lambda x: f"{x}"
+    index=current_question['options'].index(current_question['selected']) if current_question.get('selected') else None, 
+    key=st.session_state.current_index
 )
 
 if st.button("Submit"):
-    if not current_question['answered']:
+    if not current_question.get('answered'):
         current_question['selected'] = selected_answer
         current_question['answered'] = True
         st.session_state.module_question_count[module_name] += 1
 
-        if selected_answer == current_question['correct']:
+        if selected_answer == current_question['correct_answer']:
             st.session_state.correct_count += 1
             st.session_state.module_correct_count[module_name] += 1
 
 # Retain and highlight the options after submission
 for option in current_question['options']:
     st.markdown(f"<div style='{get_option_style(option)}'>{option}</div>", unsafe_allow_html=True)
+
+# Show explanation and step-by-step solution
+if current_question.get('answered'):
+    st.write(f"**Explanation:** {current_question['explanation']}")
+    st.write("**Step-by-Step Solution:**")
+    for step in current_question['step_by_step_solution']:
+        st.write(step)

modules/addition_bases.py

@@ -1,35 +1,46 @@
 import random
 
-title = "Addition in Different Bases"
-description = "This module helps you practice adding numbers in different bases such as binary, octal, and hexadecimal."
-
 def generate_question():
-    base = random.choice([2, 8, 16])
+    base = random.choice([2, 8, 10, 16])
     num1 = random.randint(1, 15)
     num2 = random.randint(1, 15)
-    
-    if base == 2:
-        correct_answer = bin(num1 + num2)[2:]
+
+    if base == 10:
+        num1_rep = str(num1)
+        num2_rep = str(num2)
+    elif base == 2:
+        num1_rep = bin(num1)[2:]
+        num2_rep = bin(num2)[2:]
+    elif base == 8:
+        num1_rep = oct(num1)[2:]
+        num2_rep = oct(num2)[2:]
+    elif base == 16:
+        num1_rep = hex(num1)[2:].upper()
+        num2_rep = hex(num2)[2:].upper()
+
+    sum_decimal = num1 + num2
+    if base == 10:
+        correct_answer = str(sum_decimal)
+    elif base == 2:
+        correct_answer = bin(sum_decimal)[2:]
     elif base == 8:
-        correct_answer = oct(num1 + num2)[2:]
-    else:
-        correct_answer = hex(num1 + num2)[2:]
-    
-    question = f"Add {num1} and {num2} in base {base}."
-    options = [correct_answer]
-    
-    # Generate incorrect options
-    while len(options) < 5:
-        fake_option = bin(random.randint(1, 30))[2:]
-        if fake_option not in options:
-            options.append(fake_option)
-    
-    random.shuffle(options)
-    explanation = (
-        f"The sum of {num1} and {num2} in base {base} is {correct_answer}."
-        "\n\n**Step-by-step solution:**\n"
-        "1. Convert the numbers to decimal if necessary.\n"
-        "2. Perform the addition in decimal.\n"
-        "3. Convert the result back to the base if needed."
-    )
-    return question, options, correct_answer, explanation
+        correct_answer = oct(sum_decimal)[2:]
+    elif base == 16:
+        correct_answer = hex(sum_decimal)[2:].upper()
+
+    steps = [
+        f"Convert {num1_rep} and {num2_rep} to decimal if needed.",
+        f"Add the numbers: {num1} + {num2} = {sum_decimal} in decimal.",
+        f"Convert {sum_decimal} from decimal to base {base}.",
+        f"The result in base {base} is {correct_answer}."
+    ]
+
+    question_data = {
+        "question": f"Add the numbers {num1_rep} and {num2_rep} in base {base}.",
+        "options": [correct_answer] + [str(random.randint(1, 30)) for _ in range(3)],
+        "correct_answer": correct_answer,
+        "explanation": f"The sum of {num1_rep} and {num2_rep} in base {base} is {correct_answer}.",
+        "step_by_step_solution": steps
+    }
+
+    return question_data

modules/conversion_bases.py

@@ -1,46 +1,41 @@
 import random
 
-title = "Base Conversion"
-description = "This module focuses on converting numbers between different bases, including binary, octal, decimal, and hexadecimal, with and without fractions."
-
 def generate_question():
-    num = random.randint(1, 100)
-    from_base = random.choice([2, 8, 10, 16])
-    to_base = random.choice([2, 8, 10, 16])
-    
-    if from_base == 10:
-        value = num
-    elif from_base == 2:
-        value = int(bin(num)[2:], 2)
-    elif from_base == 8:
-        value = int(oct(num)[2:], 8)
-    else:
-        value = int(hex(num)[2:], 16)
-    
-    if to_base == 2:
-        correct_answer = bin(value)[2:]
-    elif to_base == 8:
-        correct_answer = oct(value)[2:]
-    elif to_base == 16:
-        correct_answer = hex(value)[2:]
-    else:
-        correct_answer = str(value)
-    
-    options = [correct_answer]
-    
-    # Generate incorrect options
-    while len(options) < 5:
-        fake_option = bin(random.randint(1, 100))[2:]
-        if fake_option not in options:
-            options.append(fake_option)
-    
-    random.shuffle(options)
-    question = f"Convert {num} from base {from_base} to base {to_base}."
-    explanation = (
-        f"The number {num} in base {from_base} is {correct_answer} in base {to_base}."
-        "\n\n**Step-by-step solution:**\n"
-        "1. Convert the number from the original base to decimal if necessary.\n"
-        "2. Convert the decimal number to the target base.\n"
-        "3. The correct answer is the result of the conversion."
-    )
-    return question, options, correct_answer, explanation
+    base_from = random.choice([2, 8, 10, 16])
+    base_to = random.choice([2, 8, 10, 16])
+    number = random.randint(1, 255)
+
+    if base_from == 10:
+        number_rep = str(number)
+    elif base_from == 2:
+        number_rep = bin(number)[2:]
+    elif base_from == 8:
+        number_rep = oct(number)[2:]
+    elif base_from == 16:
+        number_rep = hex(number)[2:].upper()
+
+    if base_to == 10:
+        correct_answer = str(int(number_rep, base_from))
+    elif base_to == 2:
+        correct_answer = bin(int(number_rep, base_from))[2:]
+    elif base_to == 8:
+        correct_answer = oct(int(number_rep, base_from))[2:]
+    elif base_to == 16:
+        correct_answer = hex(int(number_rep, base_from))[2:].upper()
+
+    steps = [
+        f"Convert the number {number_rep} from base {base_from} to decimal.",
+        f"Result: {int(number_rep, base_from)} in decimal.",
+        f"Now, convert {int(number_rep, base_from)} from decimal to base {base_to}.",
+        f"Final result: {correct_answer}."
+    ]
+
+    question_data = {
+        "question": f"Convert the number {number_rep} from base {base_from} to base {base_to}.",
+        "options": [correct_answer] + [str(random.randint(1, 255)) for _ in range(3)],
+        "correct_answer": correct_answer,
+        "explanation": f"The number {number_rep} in base {base_from} is {correct_answer} in base {base_to}.",
+        "step_by_step_solution": steps
+    }
+
+    return question_data

modules/presentation_bases.py

@@ -1,36 +1,20 @@
 import random
 
-title = "Presentation in Bases"
-description = "This module covers the representation of numbers in different bases including binary, octal, decimal, and hexadecimal."
-
 def generate_question():
-    num = random.randint(1, 20)
-    base = random.choice([2, 8, 10, 16])
-    if base == 2:
-        representation = bin(num)[2:]
-    elif base == 8:
-        representation = oct(num)[2:]
-    elif base == 16:
-        representation = hex(num)[2:]
-    else:
-        representation = str(num)
+    number = random.randint(1, 15)
+    binary_rep = bin(number)[2:].zfill(4)
+
+    question_data = {
+        "question": f"What is the binary representation of the decimal number {number}?",
+        "options": [bin(i)[2:].zfill(4) for i in random.sample(range(1, 16), 4)],
+        "correct_answer": binary_rep,
+        "explanation": f"The decimal number {number} is represented as {binary_rep} in binary.",
+        "step_by_step_solution": [
+            f"1. Start with the decimal number {number}.",
+            "2. Divide the number by 2 and note the quotient and remainder.",
+            "3. Continue dividing the quotient by 2 until you reach 0.",
+            "4. The binary representation is formed by reading the remainders from bottom to top."
+        ]
+    }
 
-    question = f"What is the representation of decimal number {num} in base {base}?"
-    correct_answer = representation
-    options = [correct_answer]
-    
-    # Generate incorrect options
-    while len(options) < 5:
-        fake_option = bin(random.randint(1, 20))[2:]
-        if fake_option not in options:
-            options.append(fake_option)
-    
-    random.shuffle(options)
-    explanation = (
-        f"The number {num} in base {base} is represented as {representation}."
-        "\n\n**Step-by-step solution:**\n"
-        "1. Convert the number from decimal to the required base.\n"
-        "2. Match with the provided options.\n"
-        "3. The correct answer is the one that matches the conversion."
-    )
-    return question, options, correct_answer, explanation
+    return question_data

modules/subtraction_bases.py

@@ -1,35 +1,46 @@
 import random
 
-title = "Subtraction in Base 2 Using 2's Complement"
-description = "This module teaches subtraction in binary using the 2's complement method, which allows subtraction to be performed as an addition operation."
-
 def generate_question():
-    num1 = random.randint(1, 7)
-    num2 = random.randint(1, 7)
-    
-    result = num1 - num2
-    bit_length = 4
-    if result >= 0:
-        binary_result = bin(result)[2:].zfill(bit_length)
-    else:
-        binary_result = bin((1 << bit_length) + result)[2:]
-    
-    question = f"Subtract {num2} from {num1} in base 2 using 2's complement method."
-    correct_answer = binary_result
-    options = [correct_answer]
-    
-    # Generate incorrect options
-    while len(options) < 5:
-        fake_option = bin(random.randint(-7, 7) & 0xF)[2:]
-        if fake_option not in options:
-            options.append(fake_option)
-    
-    random.shuffle(options)
-    explanation = (
-        f"The result of subtracting {num2} from {num1} in base 2 using 2's complement is {binary_result}."
-        "\n\n**Step-by-step solution:**\n"
-        "1. Find the 2's complement of the subtracted number.\n"
-        "2. Add it to the first number.\n"
-        "3. If there's a carry, discard it. The result is the binary difference."
-    )
-    return question, options, correct_answer, explanation
+    base = random.choice([2, 8, 10, 16])
+    num1 = random.randint(10, 15)
+    num2 = random.randint(1, 9)
+
+    if base == 10:
+        num1_rep = str(num1)
+        num2_rep = str(num2)
+    elif base == 2:
+        num1_rep = bin(num1)[2:]
+        num2_rep = bin(num2)[2:]
+    elif base == 8:
+        num1_rep = oct(num1)[2:]
+        num2_rep = oct(num2)[2:]
+    elif base == 16:
+        num1_rep = hex(num1)[2:].upper()
+        num2_rep = hex(num2)[2:].upper()
+
+    difference_decimal = num1 - num2
+    if base == 10:
+        correct_answer = str(difference_decimal)
+    elif base == 2:
+        correct_answer = bin(difference_decimal)[2:]
+    elif base == 8:
+        correct_answer = oct(difference_decimal)[2:]
+    elif base == 16:
+        correct_answer = hex(difference_decimal)[2:].upper()
+
+    steps = [
+        f"Convert {num1_rep} and {num2_rep} to decimal if needed.",
+        f"Subtract the numbers: {num1} - {num2} = {difference_decimal} in decimal.",
+        f"Convert {difference_decimal} from decimal to base {base}.",
+        f"The result in base {base} is {correct_answer}."
+    ]
+
+    question_data = {
+        "question": f"Subtract {num2_rep} from {num1_rep} in base {base}.",
+        "options": [correct_answer] + [str(random.randint(1, 10)) for _ in range(3)],
+        "correct_answer": correct_answer,
+        "explanation": f"The result of subtracting {num2_rep} from {num1_rep} in base {base} is {correct_answer}.",
+        "step_by_step_solution": steps
+    }
+
+    return question_data

modules/twos_complement.py

@@ -1,32 +1,28 @@
 import random
 
-title = "2's Complement"
-description = "This module covers the representation of numbers using the 2's complement method, which is commonly used for representing negative numbers in binary."
-
 def generate_question():
-    num = random.randint(-8, 7)
-    bit_length = 4
-    if num >= 0:
-        binary = bin(num)[2:].zfill(bit_length)
-    else:
-        binary = bin((1 << bit_length) + num)[2:]
-    
-    question = f"What is the 2's complement representation of {num}?"
-    correct_answer = binary
-    options = [correct_answer]
-    
-    # Generate incorrect options
-    while len(options) < 5:
-        fake_option = bin(random.randint(-8, 7) & 0xF)[2:]
-        if fake_option not in options:
-            options.append(fake_option)
-    
-    random.shuffle(options)
-    explanation = (
-        f"The 2's complement representation of {num} is {binary}."
-        "\n\n**Step-by-step solution:**\n"
-        "1. If the number is positive, convert it to binary and pad with leading zeros to fit the bit length.\n"
-        "2. If the number is negative, take its absolute value, convert to binary, invert the digits, and add 1.\n"
-        "3. The result is the 2's complement representation."
-    )
-    return question, options, correct_answer, explanation
+    binary_number = bin(random.randint(1, 15))[2:].zfill(4)
+
+    def twos_complement(binary_str):
+        n = len(binary_str)
+        ones_complement = ''.join('1' if bit == '0' else '0' for bit in binary_str)
+        twos_complement_result = bin(int(ones_complement, 2) + 1)[2:].zfill(n)
+        return twos_complement_result[-n:]
+
+    correct_answer = twos_complement(binary_number)
+
+    steps = [
+        f"Start with the binary number: {binary_number}.",
+        f"Find the 1's complement by flipping each bit: {''.join('1' if bit == '0' else '0' for bit in binary_number)}.",
+        f"Add 1 to the 1's complement to get the 2's complement: {correct_answer}.",
+    ]
+
+    question_data = {
+        "question": f"What is the 2's complement of the binary number {binary_number}?",
+        "options": [correct_answer] + [bin(random.randint(1, 15))[2:].zfill(4) for _ in range(3)],
+        "correct_answer": correct_answer,
+        "explanation": f"The 2's complement of the binary number {binary_number} is {correct_answer}.",
+        "step_by_step_solution": steps
+    }
+
+    return question_data

modules/valid_invalid_numbers.py

@@ -1,8 +1,5 @@
 import random
 
-title = "Validity of Numbers in Bases"
-description = "This module helps you determine whether a given number is valid or invalid in various bases like binary, octal, decimal, and hexadecimal."
-
 def generate_question():
     base = random.choice([2, 8, 10, 16])
     length = random.randint(3, 5)
@@ -12,25 +9,22 @@ def generate_question():
 
     def generate_invalid_number():
         valid_digits = ''.join([str(random.randint(0, base - 1)) for _ in range(length - 1)])
-        invalid_digit = str(random.randint(base, base + 1)) if base < 10 else chr(random.randint(ord('A'), ord('F')))
+        invalid_digit = str(random.randint(base, 9))
         return valid_digits + invalid_digit
 
     correct_answer = generate_invalid_number()
-    options = [correct_answer]
+    options = [correct_answer] + [generate_valid_number() for _ in range(3)]
 
-    # Generate valid options
-    while len(options) < 5:
-        valid_option = generate_valid_number()
-        if valid_option not in options:
-            options.append(valid_option)
-    
-    random.shuffle(options)
-    question = f"Which of the following is an invalid number in base {base}?"
-    explanation = (
-        f"The number {correct_answer} is invalid in base {base} because it contains a digit outside the range 0-{base-1}."
-        "\n\n**Step-by-step solution:**\n"
-        "1. Identify the valid digits for the base.\n"
-        "2. Check each option to see if it contains any invalid digits.\n"
-        "3. The correct answer will have a digit that is not allowed in the specified base."
-    )
-    return question, options, correct_answer, explanation
+    question_data = {
+        "question": f"Which of the following is an invalid number in base {base}?",
+        "options": options,
+        "correct_answer": correct_answer,
+        "explanation": f"The number {correct_answer} is invalid in base {base} because it contains a digit outside the range 0-{base-1}.",
+        "step_by_step_solution": [
+            "1. Identify the valid digits for the base.",
+            f"2. Check each option to see if it contains any invalid digits (greater than {base-1}).",
+            "3. The correct answer will have a digit that is not allowed in the specified base."
+        ]
+    }
+
+    return question_data