Updates

app.py

@@ -1,37 +1,13 @@
 import streamlit as st
 import importlib
+import os
 from fpdf import FPDF
 import uuid
 
-# List of available modules with shorter names and icons
-module_names = {
-    "Bases": "presentation_bases",
-    "Validity": "valid_invalid_numbers",
-    "Conversion": "conversion_bases",
-    "Grouping": "grouping_techniques",
-    "Addition": "addition_bases",
-    "2's Complement": "twos_complement",
-    "Negative Numbers": "negative_binary",
-    "Subtraction": "subtraction_bases",
-}
-
-# Module descriptions
-module_descriptions = {
-    "Bases": "This module covers the presentation of numbers in various bases, including binary, octal, decimal, and hexadecimal.",
-    "Validity": "This module helps determine the validity of numbers in different bases.",
-    "Conversion": "This module covers conversion techniques between different bases, including with and without fractions.",
-    "Grouping": "This module focuses on grouping techniques for conversion between bases such as binary and hexadecimal.",
-    "Addition": "This module covers addition operations in bases like binary, octal, and hexadecimal.",
-    "2's Complement": "This module explains the 2's complement method for representing negative numbers.",
-    "Negative Numbers": "This module covers negative binary numbers and their representation.",
-    "Subtraction": "This module focuses on subtraction operations in binary using the 2's complement method.",
-}
-
-# Initialize unique session state
+# Initialize session state variables
 if 'session_id' not in st.session_state:
     st.session_state.session_id = str(uuid.uuid4())
 
-# Initialize session state variables
 if 'questions' not in st.session_state:
     st.session_state.questions = []
 if 'current_index' not in st.session_state:
@@ -41,9 +17,9 @@ if 'current_module' not in st.session_state:
 if 'correct_count' not in st.session_state:
     st.session_state.correct_count = 0
 if 'module_correct_count' not in st.session_state:
-    st.session_state.module_correct_count = {name: 0 for name in module_names}
+    st.session_state.module_correct_count = {}
 if 'module_question_count' not in st.session_state:
-    st.session_state.module_question_count = {name: 0 for name in module_names}
+    st.session_state.module_question_count = {}
 if 'pdf_data' not in st.session_state:
     st.session_state.pdf_data = None
 
@@ -58,12 +34,11 @@ def generate_pdf_report():
     pdf.cell(200, 10, txt="Quiz Report", ln=True, align="C")
     pdf.ln(10)
 
-    for module in module_names.keys():
-        pdf.set_text_color(0, 0, 0)
+    for module, data in st.session_state.module_question_count.items():
+        correct_count = st.session_state.module_correct_count.get(module, 0)
+        total_count = data
         pdf.cell(200, 10, txt=f"Module: {module}", ln=True, align="L")
         pdf.ln(5)
-        correct_count = st.session_state.module_correct_count[module]
-        total_count = st.session_state.module_question_count[module]
         pdf.cell(200, 10, txt=f"Correct Answers: {correct_count}/{total_count}", ln=True, align="L")
         pdf.ln(5)
 
@@ -100,21 +75,29 @@ def generate_pdf_report():
 
     return pdf.output(dest='S').encode('latin1', 'replace')
 
-def load_module(module_name):
-    module_file = module_names[module_name]
-    module = importlib.import_module(f'modules.{module_file}')
-    return module
-
-def generate_new_question(module_name):
-    module = load_module(module_name)
-    question_data = module.generate_question()
+def load_modules():
+    modules = {}
+    module_dir = "modules"
+    for filename in os.listdir(module_dir):
+        if filename.endswith(".py") and filename != "__init__.py":
+            module_name = filename[:-3]
+            module = importlib.import_module(f"{module_dir}.{module_name}")
+            modules[module_name] = {
+                "title": getattr(module, "title", module_name),
+                "description": getattr(module, "description", "No description available."),
+                "generate_question": module.generate_question
+            }
+    return modules
+
+def generate_new_question(module_name, module):
+    question_data = module['generate_question']()
     # Ensure 'answered' is initialized to False and add the 'module' and 'selected' keys
     question_data['answered'] = False
     question_data['module'] = module_name  # Add the module name to the question data
     question_data['selected'] = None  # Initialize 'selected' to None
-    # Ensure there are 5 options
-    if len(question_data['options']) != 5:
-        st.warning(f"Question does not have 5 options. Found {len(question_data['options'])}.")
+    # Ensure there are exactly 4 options
+    if len(question_data['options']) != 4:
+        st.warning(f"Question in module '{module_name}' does not have 4 options. Found {len(question_data['options'])}.")
     return question_data
 
 def navigate_question(direction):
@@ -125,30 +108,30 @@ def navigate_question(direction):
             st.session_state.current_index += 1
         else:
             # Generate a new question if at the end of the list
-            new_question = generate_new_question(st.session_state.current_module)
+            new_question = generate_new_question(st.session_state.current_module, modules[st.session_state.current_module])
             st.session_state.questions.append(new_question)
             st.session_state.current_index += 1
 
+# Load all modules dynamically
+modules = load_modules()
+
 # Streamlit interface
 st.sidebar.title("Quiz Modules")
-module_name = st.sidebar.radio("Choose a module:", list(module_names.keys()), index=0)
+module_name = st.sidebar.radio("Choose a module:", list(modules.keys()), index=0)
 
 if module_name != st.session_state.current_module:
     st.session_state.current_module = module_name
     st.session_state.current_index = 0
-    st.session_state.questions = [generate_new_question(module_name)]
+    st.session_state.questions = [generate_new_question(module_name, modules[module_name])]
+    st.session_state.module_question_count[module_name] = 0
+    st.session_state.module_correct_count[module_name] = 0
 
 # Load the current module's question
-if st.session_state.current_index < len(st.session_state.questions):
-    current_question = st.session_state.questions[st.session_state.current_index]
-else:
-    current_question = generate_new_question(st.session_state.current_module)
-    st.session_state.questions.append(current_question)
-    st.session_state.current_index = len(st.session_state.questions) - 1
+current_question = st.session_state.questions[st.session_state.current_index]
 
 # Display module title and description
-st.title(module_name)
-st.write(module_descriptions.get(module_name, "No description available for this module."))
+st.title(modules[module_name]["title"])
+st.write(modules[module_name]["description"])
 st.write(current_question["question"])
 
 # Use a form to prevent rerun on option selection

modules/addition_bases.py

@@ -1,46 +1,44 @@
-import random
+# modules/addition_bases.py
+
+title = "Addition in Various Bases"
+description = "This module covers addition operations in bases like binary, octal, and hexadecimal."
 
 def generate_question():
-    base = random.choice([2, 8, 10, 16])
-    num1 = random.randint(1, 15)
-    num2 = random.randint(1, 15)
+    import random
 
-    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()
+    base = random.choice([2, 8, 16])
+    num1 = ''.join(random.choice('0123456789ABCDEF') for _ in range(3))
+    num2 = ''.join(random.choice('0123456789ABCDEF') for _ in range(3))
 
-    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(sum_decimal)[2:]
-    elif base == 16:
-        correct_answer = hex(sum_decimal)[2:].upper()
+    def add_numbers(num1, num2, base):
+        return hex(int(num1, base) + int(num2, base))[2:].upper() if base == 16 else \
+               oct(int(num1, base) + int(num2, base))[2:] if base == 8 else \
+               bin(int(num1, base) + int(num2, base))[2:] if base == 2 else \
+               str(int(num1) + int(num2))
 
-    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}."
-    ]
+    correct_answer = add_numbers(num1, num2, base)
+    options = [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)],
+    # Generate incorrect answers
+    while len(options) < 4:
+        invalid_answer = ''.join(random.choice('0123456789ABCDEF') for _ in range(4))
+        if invalid_answer != correct_answer:
+            options.append(invalid_answer)
+    
+    random.shuffle(options)
+    
+    question = f"Add the numbers {num1} and {num2} in base {base}."
+    explanation = f"The sum of {num1} and {num2} in base {base} is {correct_answer}."
+    step_by_step_solution = [
+        f"Step 1: Convert the numbers {num1} and {num2} to base 10.",
+        "Step 2: Add the numbers in base 10.",
+        f"Step 3: Convert the sum back to base {base}."
+    ]
+    
+    return {
+        "question": question,
+        "options": options,
         "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
+        "explanation": explanation,
+        "step_by_step_solution": step_by_step_solution
     }
-
-    return question_data

modules/conversion_bases.py

@@ -1,41 +1,51 @@
-import random
+# modules/conversion_bases.py
+
+title = "Conversion Between Bases"
+description = "This module covers conversion techniques between different bases, including with and without fractions."
 
 def generate_question():
-    base_from = random.choice([2, 8, 10, 16])
-    base_to = random.choice([2, 8, 10, 16])
-    number = random.randint(1, 255)
+    import random
 
-    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()
+    from_base = random.choice([2, 8, 10, 16])
+    to_base = random.choice([2, 8, 10, 16])
+    number = ''.join(random.choice('0123456789ABCDEF') for _ in range(4))
 
-    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()
+    def convert_number(number, from_base, to_base):
+        # Convert from `from_base` to base 10
+        base_10 = int(number, from_base)
+        # Convert from base 10 to `to_base`
+        if to_base == 10:
+            return str(base_10)
+        elif to_base == 16:
+            return hex(base_10)[2:].upper()
+        elif to_base == 8:
+            return oct(base_10)[2:]
+        elif to_base == 2:
+            return bin(base_10)[2:]
 
-    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}."
-    ]
+    correct_answer = convert_number(number, from_base, to_base)
+    options = [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)],
+    # Generate incorrect answers
+    while len(options) < 4:
+        invalid_number = ''.join(random.choice('0123456789ABCDEF') for _ in range(4))
+        if invalid_number != correct_answer:
+            options.append(invalid_number)
+    
+    random.shuffle(options)
+    
+    question = f"Convert the number {number} from base {from_base} to base {to_base}."
+    explanation = f"The number {number} in base {from_base} is {correct_answer} in base {to_base}."
+    step_by_step_solution = [
+        f"Step 1: Convert the number {number} from base {from_base} to base 10.",
+        f"Step 2: Convert the base 10 number to base {to_base}.",
+        f"Step 3: The correct answer is {correct_answer}."
+    ]
+    
+    return {
+        "question": question,
+        "options": options,
         "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
+        "explanation": explanation,
+        "step_by_step_solution": step_by_step_solution
     }
-
-    return question_data

modules/grouping_techniques.py

@@ -1,30 +1,49 @@
-import random
+# modules/grouping_techniques.py
 
-title = "Grouping Techniques for Base Conversion"
-description = "This module covers the techniques used for converting binary numbers to octal and hexadecimal by grouping bits."
+title = "Grouping Techniques for Conversion"
+description = "This module focuses on grouping techniques for conversion between bases such as binary and hexadecimal."
 
 def generate_question():
-    binary_num = bin(random.randint(1, 63))[2:]
-    padded_binary = binary_num.zfill(len(binary_num) + (3 - len(binary_num) % 3) % 3)
-    
-    octal = ''.join([str(int(padded_binary[i:i+3], 2)) for i in range(0, len(padded_binary), 3)])
-    
-    question = f"Group the binary number {binary_num} into octal."
-    correct_answer = octal
+    import random
+
+    from_base = random.choice([2, 8, 16])
+    to_base = 8 if from_base == 2 else 2
+    number = ''.join(random.choice('01') for _ in range(8))
+
+    def group_conversion(number, from_base, to_base):
+        # Group the binary digits for conversion
+        if from_base == 2 and to_base == 8:
+            return oct(int(number, 2))[2:]
+        elif from_base == 2 and to_base == 16:
+            return hex(int(number, 2))[2:].upper()
+        elif from_base == 8 and to_base == 2:
+            return bin(int(number, 8))[2:]
+        elif from_base == 16 and to_base == 2:
+            return bin(int(number, 16))[2:]
+
+    correct_answer = group_conversion(number, from_base, to_base)
     options = [correct_answer]
-    
-    # Generate incorrect options
-    while len(options) < 5:
-        fake_option = ''.join([str(random.randint(0, 7)) for _ in range(len(octal))])
-        if fake_option not in options:
-            options.append(fake_option)
+
+    # Generate incorrect answers
+    while len(options) < 4:
+        invalid_number = ''.join(random.choice('01234567') for _ in range(4))
+        if invalid_number != correct_answer:
+            options.append(invalid_number)
     
     random.shuffle(options)
-    explanation = (
-        f"The binary number {binary_num} is grouped into octal as {octal}."
-        "\n\n**Step-by-step solution:**\n"
-        "1. Pad the binary number with leading zeros to make its length a multiple of 3.\n"
-        "2. Group the binary digits in groups of three, starting from the right.\n"
-        "3. Convert each group to its octal equivalent."
-    )
-    return question, options, correct_answer, explanation
+    
+    question = f"Convert the binary number {number} from base {from_base} to base {to_base} using grouping technique."
+    explanation = f"The number {number} in base {from_base} is {correct_answer} in base {to_base} using grouping technique."
+    step_by_step_solution = [
+        "Step 1: Group the binary digits in sets of 3 (for base 8) or 4 (for base 16).",
+        "Step 2: Convert each group to the corresponding digit in the target base.",
+        "Step 3: Combine the digits to form the final answer."
+    ]
+    
+    return {
+        "question": question,
+        "options": options,
+        "correct_answer": correct_answer,
+        "explanation": explanation,
+        "step_by_step_solution": step_by_step_solution
+    }

modules/negative_binary.py

@@ -1,29 +1,39 @@
-import random
+# modules/negative_binary.py
 
-title = "Negative Numbers in Binary"
-description = "This module focuses on the binary representation of negative numbers using 2's complement and other methods."
+title = "Negative Binary Numbers"
+description = "This module covers negative binary numbers and their representation."
 
 def generate_question():
-    num = random.randint(-8, -1)
-    bit_length = 4
-    binary = bin((1 << bit_length) + num)[2:]
-    
-    question = f"What is the binary representation of {num} using 4 bits?"
-    correct_answer = binary
+    import random
+
+    number = ''.join(random.choice('01') for _ in range(8))
+
+    def calculate_negative_binary(number):
+        # Example logic: return a simple 2's complement representation
+        return bin(int(number, 2) * -1)[3:].zfill(len(number))
+
+    correct_answer = calculate_negative_binary(number)
     options = [correct_answer]
-    
-    # Generate incorrect options
-    while len(options) < 5:
-        fake_option = bin(random.randint(-8, -1) & 0xF)[2:]
-        if fake_option not in options:
-            options.append(fake_option)
+
+    # Generate incorrect answers
+    while len(options) < 4:
+        invalid_number = ''.join(random.choice('01') for _ in range(8))
+        if invalid_number != correct_answer:
+            options.append(invalid_number)
     
     random.shuffle(options)
-    explanation = (
-        f"The binary representation of {num} using 4 bits is {binary}."
-        "\n\n**Step-by-step solution:**\n"
-        "1. Convert the absolute value of the negative number to binary.\n"
-        "2. Find the 2's complement of the binary number to represent the negative number.\n"
-        "3. The result is the binary representation of the negative number."
-    )
-    return question, options, correct_answer, explanation
+    
+    question = f"What is the negative representation of the binary number {number}?"
+    explanation = f"The negative binary representation of {number} is {correct_answer}."
+    step_by_step_solution = [
+        "Step 1: Determine the 2's complement of the binary number.",
+        "Step 2: The result is the negative binary representation."
+    ]
+    
+    return {
+        "question": question,
+        "options": options,
+        "correct_answer": correct_answer,
+        "explanation": explanation,
+        "step_by_step_solution": step_by_step_solution
+    }

modules/presentation_bases.py

@@ -1,20 +1,35 @@
-import random
+# modules/presentation_bases.py
 
-def generate_question():
-    number = random.randint(1, 15)
-    binary_rep = bin(number)[2:].zfill(4)
+title = "Bases"
+description = "This module covers the presentation of numbers in various bases, including binary, octal, decimal, and hexadecimal."
 
-    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."
-        ]
+def generate_question():
+    import random
+    # Generate a random base
+    base = random.choice([2, 8, 10, 16])
+    # Generate a valid number in that base
+    number = ''.join(random.choice('0123456789ABCDEF') for _ in range(4))
+    # Generate incorrect answers
+    correct_answer = number
+    options = [correct_answer]
+    while len(options) < 4:
+        invalid_number = ''.join(random.choice('0123456789ABCDEF') for _ in range(4))
+        if invalid_number != correct_answer:
+            options.append(invalid_number)
+    random.shuffle(options)
+    
+    question = f"What is the representation of {number} in base {base}?"
+    explanation = f"The number {number} in base {base} is {correct_answer}."
+    step_by_step_solution = [
+        "Step 1: Identify the digits.",
+        "Step 2: Convert each digit based on the base.",
+        "Step 3: Combine the digits to form the final answer."
+    ]
+    
+    return {
+        "question": question,
+        "options": options,
+        "correct_answer": correct_answer,
+        "explanation": explanation,
+        "step_by_step_solution": step_by_step_solution
     }
-
-    return question_data

modules/subtraction_bases.py

@@ -1,46 +1,44 @@
-import random
+# modules/subtraction_bases.py
+
+title = "Subtraction in Bases"
+description = "This module focuses on subtraction operations in binary using the 2's complement method."
 
 def generate_question():
-    base = random.choice([2, 8, 10, 16])
-    num1 = random.randint(10, 15)
-    num2 = random.randint(1, 9)
+    import random
 
-    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()
+    base = random.choice([2, 8, 16])
+    num1 = ''.join(random.choice('0123456789ABCDEF') for _ in range(3))
+    num2 = ''.join(random.choice('0123456789ABCDEF') for _ in range(3))
 
-    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()
+    def subtract_numbers(num1, num2, base):
+        return hex(int(num1, base) - int(num2, base))[2:].upper() if base == 16 else \
+               oct(int(num1, base) - int(num2, base))[2:] if base == 8 else \
+               bin(int(num1, base) - int(num2, base))[2:] if base == 2 else \
+               str(int(num1) - int(num2))
 
-    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}."
-    ]
+    correct_answer = subtract_numbers(num1, num2, base)
+    options = [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)],
+    # Generate incorrect answers
+    while len(options) < 4:
+        invalid_answer = ''.join(random.choice('0123456789ABCDEF') for _ in range(4))
+        if invalid_answer != correct_answer:
+            options.append(invalid_answer)
+    
+    random.shuffle(options)
+    
+    question = f"Subtract the number {num2} from {num1} in base {base}."
+    explanation = f"The result of subtracting {num2} from {num1} in base {base} is {correct_answer}."
+    step_by_step_solution = [
+        f"Step 1: Convert the numbers {num1} and {num2} to base 10.",
+        "Step 2: Subtract the numbers in base 10.",
+        f"Step 3: Convert the result back to base {base}."
+    ]
+    
+    return {
+        "question": question,
+        "options": options,
         "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
+        "explanation": explanation,
+        "step_by_step_solution": step_by_step_solution
     }
-
-    return question_data

modules/twos_complement.py

@@ -1,28 +1,41 @@
-import random
+# modules/twos_complement.py
+
+title = "2's Complement Questions"
+description = "This module explains the 2's complement method for representing negative numbers."
 
 def generate_question():
-    binary_number = bin(random.randint(1, 15))[2:].zfill(4)
+    import random
 
-    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:]
+    number = ''.join(random.choice('01') for _ in range(8))
 
-    correct_answer = twos_complement(binary_number)
+    def calculate_twos_complement(number):
+        n = len(number)
+        ones_complement = ''.join('1' if bit == '0' else '0' for bit in number)
+        twos_complement = bin(int(ones_complement, 2) + 1)[2:]
+        return twos_complement.zfill(n)
 
-    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}.",
-    ]
+    correct_answer = calculate_twos_complement(number)
+    options = [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)],
+    # Generate incorrect answers
+    while len(options) < 4:
+        invalid_number = ''.join(random.choice('01') for _ in range(8))
+        if invalid_number != correct_answer:
+            options.append(invalid_number)
+    
+    random.shuffle(options)
+    
+    question = f"What is the 2's complement of the binary number {number}?"
+    explanation = f"The 2's complement of {number} is {correct_answer}."
+    step_by_step_solution = [
+        "Step 1: Find the 1's complement by flipping all bits.",
+        "Step 2: Add 1 to the 1's complement to get the 2's complement."
+    ]
+    
+    return {
+        "question": question,
+        "options": options,
         "correct_answer": correct_answer,
-        "explanation": f"The 2's complement of the binary number {binary_number} is {correct_answer}.",
-        "step_by_step_solution": steps
+        "explanation": explanation,
+        "step_by_step_solution": step_by_step_solution
     }
-
-    return question_data

modules/valid_invalid_numbers.py

@@ -1,40 +1,45 @@
-import random
+# modules/valid_invalid_numbers.py
+
+title = "Validity of Numbers in Bases"
+description = "This module helps determine the validity of numbers in different bases like binary, octal, decimal, and hexadecimal."
 
 def generate_question():
+    import random
+    
     base = random.choice([2, 8, 10, 16])
     length = random.randint(3, 5)
     
     def generate_valid_number():
         return ''.join([str(random.randint(0, base - 1)) for _ in range(length)])
-
+    
     def generate_invalid_number():
-        if base <= 9:
-            valid_digits = ''.join([str(random.randint(0, base - 1)) for _ in range(length - 1)])
-            invalid_digit = str(random.randint(base, 9))
-            return valid_digits + invalid_digit
-        else:
-            # For bases higher than 9 (base 10 and base 16), generate an invalid number differently.
-            valid_digits = [str(random.randint(0, base - 1)) for _ in range(length - 1)]
-            invalid_digit = chr(random.randint(65, 70))  # Use A-F for invalid hex digits
-            valid_digits[random.randint(0, length - 2)] = invalid_digit
-            return ''.join(valid_digits)
+        valid_digits = ''.join([str(random.randint(0, base - 1)) for _ in range(length - 1)])
+        invalid_digit = str(random.randint(base, 9))
+        return valid_digits + invalid_digit
 
     correct_answer = generate_invalid_number()
-    options = [correct_answer] + [generate_valid_number() for _ in range(3)]
-    random.shuffle(options)
+    options = [correct_answer]
 
-    steps = [
-        f"Check if all digits are within the valid range for base {base}.",
-        f"In base {base}, valid digits are 0 to {base-1}.",
-        f"The number {correct_answer} contains a digit outside this range, so it is invalid."
+    # Generate valid options
+    while len(options) < 4:
+        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}."
+    step_by_step_solution = [
+        "Step 1: Identify the valid digits for the base.",
+        "Step 2: Check each option to see if it contains any invalid digits.",
+        "Step 3: The correct answer will have a digit that is not allowed in the specified base."
     ]
-
-    question_data = {
-        "question": f"Which of the following is an invalid number in base {base}?",
+    
+    return {
+        "question": question,
         "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": steps
+        "explanation": explanation,
+        "step_by_step_solution": step_by_step_solution
     }
-
-    return question_data