Add application file 3

app.py

@@ -1,242 +1,38 @@
 import streamlit as st
-import random
-
-# Module 1: Presentation in bases 2, 10, 8, and 16
-def generate_question_presentation_in_bases():
-    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)
-
-    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) < 10:
-        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}."
-    return question, options, correct_answer, explanation
-
-# Module 2: Valid or invalid numbers in each base
-def generate_question_valid_or_invalid_numbers():
-    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():
-        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 options
-    while len(options) < 10:
-        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}."
-    return question, options, correct_answer, explanation
-
-# Module 3: Conversion with and without fractions among four bases of 10, 2, 8, and 16
-def generate_question_conversion_bases():
-    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) < 10:
-        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}."
-    return question, options, correct_answer, explanation
-
-# Module 4: Using grouping techniques for conversion between 2 and 8 and 16
-def generate_question_grouping_techniques():
-    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
-    options = [correct_answer]
-    
-    # Generate incorrect options
-    while len(options) < 10:
-        fake_option = ''.join([str(random.randint(0, 7)) for _ in range(len(octal))])
-        if fake_option not in options:
-            options.append(fake_option)
-    
-    random.shuffle(options)
-    explanation = f"The binary number {binary_num} is grouped into octal as {octal}."
-    return question, options, correct_answer, explanation
-
-# Module 5: Addition in base 2, 8, and 16
-def generate_question_addition_in_bases():
-    base = random.choice([2, 8, 16])
-    num1 = random.randint(1, 15)
-    num2 = random.randint(1, 15)
-    
-    if base == 2:
-        correct_answer = bin(num1 + num2)[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) < 10:
-        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}."
-    return question, options, correct_answer, explanation
-
-# Module 6: 2's complement questions
-def generate_question_2s_complement():
-    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) < 10:
-        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}."
-    return question, options, correct_answer, explanation
-
-# Module 7: Negative binary numbers
-def generate_question_negative_binary_numbers():
-    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
-    options = [correct_answer]
-    
-    # Generate incorrect options
-    while len(options) < 10:
-        fake_option = bin(random.randint(-8, -1) & 0xF)[2:]
-        if fake_option not in options:
-            options.append(fake_option)
-    
-    random.shuffle(options)
-    explanation = f"The binary representation of {num} using 4 bits is {binary}."
-    return question, options, correct_answer, explanation
-
-# Module 8: Subtraction in base 2 using 2's complement method
-def generate_question_subtraction_in_base_2():
-    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) < 10:
-        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}."
-    return question, options, correct_answer, explanation
-
-# Dictionary of modules
-modules = {
-    "Presentation in bases 2, 10, 8, and 16": generate_question_presentation_in_bases,
-    "Valid or invalid numbers in each base": generate_question_valid_or_invalid_numbers,
-    "Conversion with and without fractions among four bases of 10, 2, 8, and 16": generate_question_conversion_bases,
-    "Using grouping techniques for conversion between 2 and 8 and 16": generate_question_grouping_techniques,
-    "Addition in base 2, 8, and 16": generate_question_addition_in_bases,
-    "2's complement questions": generate_question_2s_complement,
-    "Negative binary numbers": generate_question_negative_binary_numbers,
-    "Subtraction in base 2 using 2's complement method": generate_question_subtraction_in_base_2,
+import importlib
+
+# List of available modules
+module_names = {
+    "Presentation in bases 2, 10, 8, and 16": "presentation_bases",
+    "Valid or invalid numbers in each base": "valid_invalid_numbers",
+    "Conversion with and without fractions among four bases of 10, 2, 8, and 16": "conversion_bases",
+    "Using grouping techniques for conversion between 2 and 8 and 16": "grouping_techniques",
+    "Addition in base 2, 8, and 16": "addition_bases",
+    "2's complement questions": "twos_complement",
+    "Negative binary numbers": "negative_binary",
+    "Subtraction in base 2 using 2's complement method": "subtraction_bases",
 }
 
 # Streamlit interface
-st.title("Multiple Choice Quiz")
-
-module = st.radio("Choose a module:", list(modules.keys()))
-
-if module:
-    generate_question = modules[module]
-    question, options, correct_answer, explanation = generate_question()
-    
-    st.write(f"**Question:** {question}")
-    answer = st.radio("Choose an answer:", options)
-    
-    if st.button("Submit"):
-        if answer == correct_answer:
-            st.success("Correct!")
-        else:
-            st.error("Incorrect.")
-        st.write(f"**Explanation:** {explanation}")
-
-# The modular design allows for easy addition of new modules.
+st.sidebar.title("Multiple Choice Quiz")
+module_name = st.sidebar.radio("Choose a module:", list(module_names.keys()))
+
+if module_name:
+    module_file = module_names[module_name]
+    try:
+        module = importlib.import_module(f'modules.{module_file}')
+        generate_question = module.generate_question
+        question, options, correct_answer, explanation = generate_question()
+        
+        st.write(f"**Question:** {question}")
+        answer = st.radio("Choose an answer:", options)
+        
+        if st.button("Submit"):
+            if answer == correct_answer:
+                st.success("Correct!", icon="✅")
+                st.write(f"**Explanation:** {explanation}")
+            else:
+                st.error("Incorrect.", icon="❌")
+                st.write(f"**Explanation:** {explanation}")
+    except ModuleNotFoundError:
+        st.error(f"The module '{module_name}' was not found. Please select another module.")

modules/addition_bases.py

@@ -0,0 +1,43 @@
+import random
+
+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

modules/conversion_bases.py

@@ -0,0 +1,43 @@
+import random
+
+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

modules/grouping_techniques.py

@@ -0,0 +1,27 @@
+import random
+
+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
+    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)
+    
+    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

modules/negative_binary.py

@@ -0,0 +1,26 @@
+import random
+
+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
+    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)
+    
+    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

modules/presentation_bases.py

@@ -0,0 +1,33 @@
+import random
+
+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)
+
+    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

modules/subtraction_bases.py

@@ -0,0 +1,32 @@
+import random
+
+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

modules/twos_complement.py

@@ -0,0 +1,43 @@
+import random
+
+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

modules/valid_invalid_numbers.py

@@ -0,0 +1,33 @@
+import random
+
+def generate_question():
+    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():
+        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 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