NCERT Solutions Class 11 Informatics Practices Chapter 4 2026-27

Quick solution. Chapter 4, list sorting and slicing: separate in-place changes from returned values. Part (a) prints the sorted list; (b) prints the original list. Parts (c) and (d) have expression values but print nothing in a script.

Concept used. A list stores values in order, with indices starting at zero. A slice creates a new list.

1. (a) The method sort() changes the existing list into ascending order.

   [10, 12, 26, 32, 65, 80]

2. (b) The function sorted() returns a new list. Its result is not assigned, so list1 stays unchanged.

   [12, 32, 65, 26, 80, 10]

3. (c) A step of -2 visits indices 9, 7, 5, 3 and 1. The slice value is [10, 8, 6, 4, 2]. The two adjacent slices then join into the full list.

   [10, 8, 6, 4, 2]
   [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

4. (d) The length is 5, so the index is 5-1=4. Index 4 contains 5. The expression value is therefore 5.

Final answer: Printed: (a) [10, 12, 26, 32, 65, 80]; (b) [12, 32, 65, 26, 80, 10]. Expressions in (c), (d) need print in a script.

Quick solution. Chapter 4, append and extend: append adds its argument as one element; extend adds each element separately. Run consecutively to obtain [10, 20, 30, 40, [50, 60], 80, 90]. If each part starts afresh, part (b) lacks the nested list.

Concept used. Appending a list creates one nested element. Extending a list adds the supplied elements at the top level.

1. (a) Start with four elements. The argument [50,60] is added as a single fifth element.

   [10, 20, 30, 40, [50, 60]]

2. (b), consecutive reading. Continue from (a). Add 80 and 90 separately, giving seven top-level elements.

   [10, 20, 30, 40, [50, 60], 80, 90]

3. (b), independent reading. If the initial assignment is repeated before (b), append never ran on this list.

   [10, 20, 30, 40, 80, 90]

Final answer: After (a): [10, 20, 30, 40, [50, 60]]. Consecutive (b) adds 80 and 90; independent (b) starts from the original list.

Quick solution. Chapter 4, list traversal: test the index, not the element. Even indices 0, 2, 4, 6 and 8 select values 1, 3, 5, 7 and 9. Each print call places one value on a new line.

Concept used. The loop visits list indices. The remainder operator tests whether an index is even.

1. The list has ten elements, so range(0,len(myList)) produces indices 0 through 9.
2. The condition i%2 == 0 is true for 0, 2, 4, 6 and 8. The other indices are skipped.
3. Look up each selected index: myList[0]=1, myList[2]=3, myList[4]=5, myList[6]=7, myList[8]=9.

   1
   3
   5
   7
   9

Final answer: The output is 1, 3, 5, 7 and 9, each on a separate line.

Quick solution. Chapter 4, slice deletion: mark the original indices selected by each slice, then retain the others. Outputs are (a) [1, 2, 3], (b) [6, 7, 8, 9, 10], and (c) [2, 4, 6, 8, 10]. Each part resets the list.

Concept used. The del statement removes the elements selected by a slice. A slice stop index is excluded.

1. (a) The slice [3:] selects index 3 through the end. Values 4 through 10 are deleted.

   [1, 2, 3]

2. (b) The slice [:5] selects indices 0 through 4. Values 1 through 5 are deleted.

   [6, 7, 8, 9, 10]

3. (c) The slice [::2] selects original indices 0, 2, 4, 6 and 8. Values 1, 3, 5, 7 and 9 are deleted.

   [2, 4, 6, 8, 10]

Final answer: (a) [1, 2, 3]; (b) [6, 7, 8, 9, 10]; (c) [2, 4, 6, 8, 10].

Quick solution. Chapter 4, list methods: append adds one object, while extend iterates through its argument and adds each item. Appending [3, 4] to [1, 2] gives [1, 2, [3, 4]]. Extending gives [1, 2, 3, 4]. Both modify the list and return None.

Concept used. A list is mutable, so its methods can change its contents without creating a replacement list.

1. append(x) adds the object x as one final element. The length increases by one, even when x is a list.

   a = [1, 2]
   a.append([3, 4])
   print(a)

   [1, 2, [3, 4]]

2. extend(iterable) adds each item supplied by an iterable. A list argument with two elements increases the length by two.

   b = [1, 2]
   b.extend([3, 4])
   print(b)

   [1, 2, 3, 4]

3. Both methods return None. Do not assign their result back to the list variable.

Final answer: append adds one object; extend adds the items from an iterable. Both change the original list and return None.

Quick solution. Chapter 4, repetition and mutation: multiplication repeats elements. Part (a) returns a repeated list without changing list1. Part (b) changes the existing list in place. Part (c) creates a repeated list and binds list1 to it. Other references distinguish (b) from (c).

Concept used. A variable refers to a list object. Two names can refer to the same object, called aliasing.

1. (a) Starting from [6,7,8,9], the expression value is [6,7,8,9,6,7,8,9]. No assignment changes list1.
2. (b) In-place repetition changes the existing list to [6,7,8,9,6,7,8,9]. Any alias sees this same change.
3. (c) Ordinary multiplication makes a new list. Assignment binds list1 to that new object. An alias still refers to the original four-element list.

   list1 = [6, 7, 8, 9]
   other = list1
   list1 = list1 * 2
   print(list1)
   print(other)

   [6, 7, 8, 9, 6, 7, 8, 9]
   [6, 7, 8, 9]

Final answer: (a) returns a new value; (b) mutates the list; (c) rebinds the name to a new repeated list.

Quick solution. Chapter 4, nested-list indexing: select the outer field first. The marks list is field 2; its fifth mark is index 4. Answers are 78.8, 69, 99 and A-36. Assign Raghav to field 0 to update the name.

Concept used. An outer index selects a field. A second index selects an element inside a nested list.

1. (a) Percentage is the fourth field, at index 3.

   print(stRecord[3])

   78.8

2. (b) Marks form field 2. The fifth subject uses index 4.

   print(stRecord[2][4])

   69

3. (c) Pass the marks list, not the entire mixed record, to max.

   print(max(stRecord[2]))

   99

4. (d) Roll number is field 1.

   print(stRecord[1])

   A-36

5. (e) Replace the first field.

   stRecord[0] = 'Raghav'

Final answer: (a) 78.8; (b) 69; (c) 99; (d) A-36; (e) assign Raghav to stRecord[0].

Quick solution. Chapter 4, dictionary views and lookup: get returns the stored value; keys, values and items expose insertion-order views. There are four pairs and Maharashtra is present. The supplied Assam value prints as Guwahati. Deletion leaves Bihar, Maharashtra and Rajasthan.

Concept used. A dictionary maps each unique key to a value. Python 3.7 and later preserve insertion order.

1. (a) Lookup by the key Bihar returns its stored value.

   Patna

2. (b) The keys view lists keys in their insertion order.

   dict_keys(['Assam', 'Bihar', 'Maharashtra', 'Rajasthan'])

3. (c) The values view follows the same key order.

   dict_values(['Guwahati', 'Patna', 'Mumbai', 'Jaipur'])

4. (d) Each item is a key-value tuple. Long output is wrapped below for readability.

   dict_items([('Assam', 'Guwahati'), ('Bihar', 'Patna'),
   ('Maharashtra', 'Mumbai'), ('Rajasthan', 'Jaipur')])

5. (e) Count the four key-value pairs.

   4

6. (f) Membership checks keys, so the result is true.

   True

7. (g) Return the string actually supplied in the question.

   Guwahati

8. (h) Remove the Assam entry, then display the remaining three entries.

   {'Bihar': 'Patna', 'Maharashtra': 'Mumbai', 'Rajasthan': 'Jaipur'}

Final answer: Outputs follow the eight labelled steps. Only (h) changes stateCapital; it removes the Assam pair.

Quick solution. Chapter 4, frequency counting: read integer elements and a target, then use count to return its number of occurrences. Alternatively, start a counter at zero and add one for each equal element. A missing target or empty list returns zero.

Concept used. Frequency is the number of list positions containing a value equal to the target.

1. This version accepts space-separated integers. An empty input line creates an empty list. The target is also an integer.
2. Convert each input token to an integer. Then apply the list count method, which checks every occurrence.

   values = [int(x) for x in input("Integers: ").split()]
   target = int(input("Target: "))
   print("Occurrences:", values.count(target))

3. For input 4 7 4 4 2 and target 4, three positions match.

   Occurrences: 3

Final answer: The program prints the total number of occurrences, including zero when the target is absent.

Quick solution. Chapter 4, list filtering: read n integers, then append positive values to one list and negative values to another. Zero belongs to neither list. Preserve the original list and print it alongside both filtered lists, keeping the original order.

Concept used. A positive number is greater than zero. A negative number is less than zero. Zero belongs to neither group.

1. Read a nonnegative count, then exactly that many integers. Reject a negative count rather than treating it as an empty list.
2. Use two separate destination lists. Each element passes one sign test; zero fails both.

   n = int(input("Number of integers: "))
   if n < 0:
       print("Count cannot be negative")
   else:
       values = []
       for i in range(n):
           values.append(int(input("Integer: ")))
       positive = []
       negative = []
       for value in values:
           if value > 0:
               positive.append(value)
           elif value < 0:
               negative.append(value)
       print("Original:", values)
       print("Positive:", positive)
       print("Negative:", negative)

3. For [3, -2, 0, 5, -7], the positive list is [3, 5] and the negative list is [-2, -7].

Final answer: All three lists are displayed; positive and negative values retain their input order, while zero remains only in the original.

Quick solution. Chapter 4, ordering and duplicates: for numeric inputs, collect distinct values and sort them. The last two values give the largest and second distinct largest. Report when fewer than two distinct values exist. If repetitions count, the final two entries of the original sorted list answer that interpretation.

Concept used. Sorting places comparable numbers in order. Here second largest means the second distinct value unless stated otherwise.

1. Use integer input and build a list without duplicate values. This makes the distinct-value convention explicit.
2. Sort the distinct list. A nonempty list has a largest value; a second distinct value requires at least two entries.

   values = [int(x) for x in input("Integers: ").split()]
   unique = []
   for value in values:
       if value not in unique:
           unique.append(value)
   unique.sort()
   if not unique:
       print("No largest value")
   else:
       print("Largest:", unique[-1])
       if len(unique) < 2:
           print("No second distinct largest")
       else:
           print("Second distinct largest:", unique[-2])

3. For [9, 9, 4, 7], distinct sorting gives [4, 7, 9], so the answers are 9 and 7. Counting repeated ranks instead would give 9 and 9.

Final answer: The programs report the largest and second distinct largest, or explicitly state when either does not exist.

Quick solution. Chapter 4, sorting and indexing: sort the integers, then use index n//2 for odd n. For even n, average entries at n//2-1 and n//2. Reject an empty list because its median is undefined. The program prints the resulting median.

Concept used. The median is the central value of sorted data. For even size, it is the arithmetic mean of the two central values.

1. For odd n, zero-based middle index is n//2. For even n, middle indices are n//2-1 and n//2.
2. The even-size formula is (a[n//2-1]+a[n//2])/2. Require n>0 before indexing.

   n = int(input("Number of integers: "))
   if n <= 0:
       print("Median needs at least one value")
   else:
       values = []
       for i in range(n):
           values.append(int(input("Integer: ")))
       values.sort()
       middle = n // 2
       if n % 2 == 1:
           median = values[middle]
       else:
           median = (values[middle - 1] + values[middle]) / 2
       print("Median:", median)

3. For [7, 1, 5], sorted data [1, 5, 7] gives 5. For [8, 2, 4, 6], middle values 4 and 6 give 5.0.

Final answer: The median is the sorted middle value for odd size, or the mean of the two middle values for even size.

Quick solution. Chapter 4, membership and slice assignment: keep a value only when it has not appeared earlier. Replace the original list contents with the collected unique values. This preserves first-occurrence order and changes the same list object, including any references to it.

Concept used. Membership tests whether an equal element exists. Slice assignment can replace all contents of the original list.

1. This program reads space-separated string elements. Equality uses the exact entered text; numbers can be handled by converting each token to int.
2. Collect each first occurrence, then assign it to the entire original slice.

   values = input("Elements separated by spaces: ").split()
   unique = []
   for value in values:
       if value not in unique:
           unique.append(value)
   values[:] = unique
   print(values)

3. For input red blue red green blue, the printed list is ['red', 'blue', 'green']. An empty input remains an empty list.

Final answer: Each value appears once, in its original first-occurrence order, and the original list is modified.

Quick solution. Chapter 4, insertion: use one-based user positions from 1 through len(list)+1. Convert the position to a zero-based index by subtracting one, validate it, then call insert. Position 1 inserts at the front; the final allowed position appends.

Concept used. Insertion places a new element before an index and shifts later elements right. User positions here start at one.

1. Read space-separated strings and one new string. State the position convention in the prompt.
2. Validate 1≤ p≤ n+1, where n is the current length. The corresponding Python index is p-1.

   values = input("List elements: ").split()
   element = input("Element to insert: ")
   position = int(input("Position (starting at 1): "))
   if 1 <= position <= len(values) + 1:
       values.insert(position - 1, element)
       print(values)
   else:
       print("Position out of range")

3. For ['a', 'c'] and element b at position 2, the result is ['a', 'b', 'c']. An empty list permits only position 1.

Final answer: The element is inserted at the requested one-based position, or an invalid position is reported.

Quick solution. Chapter 4, deletion by position and value: validate a one-based position, then delete index position-1. Next, remove the first matching value from the current list if it exists. Report invalid positions and missing values so the program does not crash.

Concept used. Position deletion identifies a location. Value deletion searches for an equal element and removes its first occurrence.

1. Both operations act consecutively on the same string list. First validate the one-based position. Then delete that element.
2. Before removing a value, test membership. Only the first occurrence is removed by remove.

   values = input("List elements: ").split()
   position = int(input("Position to delete (from 1): "))
   if 1 <= position <= len(values):
       del values[position - 1]
   else:
       print("Position out of range")
   print("After (a):", values)
   target = input("Value to delete: ")
   if target in values:
       values.remove(target)
   else:
       print("Value not found")
   print("After (b):", values)

3. For ['a', 'b', 'a', 'c'], position 2 leaves ['a', 'a', 'c']. Removing value a then leaves ['a', 'c'].

Final answer: Part (a) deletes the chosen position; part (b) deletes the first matching value from the resulting list.

Quick solution. Chapter 4, dictionary values and sorting: extract numeric values, sort them in descending order, and take the first two. Repeated values count as two entries here. If distinct values are intended, remove duplicates first. Report when fewer than two values are available.

Concept used. Dictionary keys identify entries; values are the quantities to compare. Sorting values does not sort keys.

1. Read unique keys with integer values. Re-entering a key updates its value, so the final dictionary size may be smaller.
2. Sort the values from greatest to least, check their count, then select the first two.

   data = {}
   n = int(input("Number of entries: "))
   if n < 0:
       print("Count cannot be negative")
   else:
       for i in range(n):
           key = input("Key: ")
           data[key] = int(input("Value: "))
       ordered = sorted(data.values(), reverse=True)
       if len(ordered) < 2:
           print("Need at least two entries")
       else:
           print("Highest two values:", ordered[:2])

3. For {'a': 9, 'b': 9, 'c': 7}, the result is [9, 9]. Under the distinct-value interpretation, the answer would instead be [9, 7].

Final answer: The programs print the two highest entry values, allowing repetition, or report insufficient entries.

Quick solution. Chapter 4, first-occurrence mapping: traverse w3resource from left to right. Add a character only when it is absent from the dictionary. Its first index is then preserved. Python 3 prints keys in insertion order; the textbook lists the same key-value pairs in another order.

Concept used. A dictionary has unique keys. A membership test prevents later occurrences from overwriting the first stored index.

1. The source has printing errors: its intended words are makes, first and makes. The supplied string and expected mapping are preserved.
2. Visit indices from zero through the final character. Store an index only for a new character.

   text = 'w3resource'
   first_index = {}
   for index in range(len(text)):
       character = text[index]
       if character not in first_index:
           first_index[character] = index
   print(first_index)

   {'w': 0, '3': 1, 'r': 2, 'e': 3, 's': 4, 'o': 5, 'u': 6, 'c': 8}

3. The second r at index 7 is skipped. The second e at index 9 is also skipped. Thus their earlier indices 2 and 3 remain.

Final answer: The mapping stores first indices: w:0, 3:1, r:2, e:3, s:4, o:5, u:6 and c:8.

Quick solution. Chapter 4, dictionary operations: use each friend name as a key and store its phone number as a string. Display items, insert a new key, delete or modify an existing key, test membership, and traverse sorted keys. Guard absent and duplicate names.

Concept used. Dictionary assignment inserts a new key or updates an existing key. Phone numbers are identifiers, so store them as strings.

1. Names are case-sensitive and assumed unique. Repeated names during initial input replace the earlier phone number.
2. Perform parts (a) through (f) in order on the same dictionary. Membership guards protect deletion and modification.

   friends = {}
   n = int(input("Number of friends: "))
   if n < 0:
       print("Count cannot be negative")
   else:
       for i in range(n):
           name = input("Name: ")
           friends[name] = input("Phone: ")
       print("(a) All friends")
       for name, phone in friends.items():
           print(name, phone)
       name = input("(b) New name: ")
       if name in friends:
           print("Name already exists")
       else:
           friends[name] = input("Phone: ")
       print(friends)
       name = input("(c) Name to delete: ")
       if name in friends:
           del friends[name]
       else:
           print("Name not found")
       name = input("(d) Name to modify: ")
       if name in friends:
           friends[name] = input("New phone: ")
       else:
           print("Name not found")
       name = input("(e) Name to find: ")
       print("Present:", name in friends)
       print("(f) Sorted by name")
       for name in sorted(friends):
           print(name, friends[name])

3. Sorting the keys controls display order without changing the stored dictionary. Leading zeros and a plus sign in a phone number remain intact.

Final answer: The program implements all six operations, preserving phone strings and checking names before destructive changes.

Quick solution. Chapter 4, student dictionaries: map each unique roll number to a tuple containing name, percentage and subject marks. Search by key and compare percentages for overall toppers. Subject toppers require additional subject marks, which the stated percentage alone cannot supply. Display every tied topper.

Concept used. A tuple is immutable. A dictionary can map roll numbers to tuples, while nested marks tuples support subject-wise comparisons.

1. The stated inputs cannot identify subject toppers. Therefore this complete version explicitly collects each subject mark, out of 100, as additional data.
2. The supplied percentage determines the overall topper. Subject marks determine subject toppers. They are separate inputs; no weighting formula is assumed.
3. Reject duplicate roll numbers and out-of-range scores. Use a tuple containing name, percentage and an inner tuple of marks.

   n = int(input("Number of students: "))
   students = {}
   if n <= 0:
       print("Need at least one student")
   else:
       subjects = input("Subject names separated by commas: ").split(",")
       subjects = [s.strip() for s in subjects]
       if not all(subjects) or len(set(subjects)) != len(subjects):
           raise ValueError("Use nonempty, distinct subject names")
       while len(students) < n:
           roll = input("Roll number: ")
           if roll in students:
               print("Duplicate roll number")
               continue
           name = input("Name: ")
           percentage = float(input("Percentage (0 to 100): "))
           marks = []
           for subject in subjects:
               marks.append(float(input(subject + " mark (out of 100): ")))
           if not 0 <= percentage <= 100 or any(m < 0 or m > 100 for m in marks):
               print("Marks and percentage must be from 0 to 100")
               continue
           students[roll] = (name, percentage, tuple(marks))
       wanted = input("Roll number to search: ")
       print("Search:", students.get(wanted, "Not found"))
       print("All results")
       for roll, record in students.items():
           print(roll, record)
       best = max(record[1] for record in students.values())
       print("Overall toppers:")
       for roll, record in students.items():
           if record[1] == best:
               print(roll, record[0], best)
       for index, subject in enumerate(subjects):
           best = max(record[2][index] for record in students.values())
           print("Subject toppers:", subject)
           for roll, record in students.items():
               if record[2][index] == best:
                   print(roll, record[0], best)

4. Every student matching the maximum is displayed, so ties are preserved. The program needs at least one student and one named subject.

Final answer: The program accepts records, searches, displays all results and finds all overall and subject toppers using explicitly added subject marks.

Quick solution. Chapter 4, dictionary records and menu control: store one customer account, validate deposits and withdrawals, and enforce its chosen minimum balance. For an FD estimate, select the entered public or senior slab rate and compound quarterly. The program uses verified product inputs and displays the customer and maturity amount.

Concept used. A dictionary stores account fields. Functions separate transactions from menu selection. A fixed quarterly rate compounds once per quarter. Example investigation, checked 18 October 2026. SBI's common account form asks for identity, birth date, contact/address, PAN or Form 60, occupation and nominee details. Use dummy data in this classroom program.

• SBI savings interest: 2.50% p.a., effective 15 June 2025, on the cited page.
• Retail FD examples, public/senior rates: 1 to under 2 years, 6.25/6.75%; 2 to under 3 years, 6.40/6.90%; 3 to under 5 years, 6.30/6.80%.
• SBI's basic savings product has no minimum balance. Other products may differ; enter the selected product's requirement.

1. For principal P rupees, annual percentage rate r and q whole quarters, the illustrative model is A=P(1+r/400)^q. This assumes quarterly compounding, no tax, no premature withdrawal and an unchanged rate.
2. The user enters the applicable tenor slab rates from the researched bank schedule. The code chooses the customer category. It estimates an FD; it does not book one or debit the savings balance.
3. Use finite numeric input. This compact program handles invalid ranges and menu choices; it assumes numbers are typed in valid numeric form.

def deposit(account, amount):
    if amount <= 0:
        return "Amount must be positive"
    account["balance"] += amount
    return "Deposited"

def withdraw(account, amount):
    if amount <= 0:
        return "Amount must be positive"
    if account["balance"] - amount < account["minimum"]:
        return "Withdrawal refused: minimum balance"
    account["balance"] -= amount
    return "Withdrawn"

def maturity(principal, rate, quarters):
    return principal * (1 + rate / 400) ** quarters

account = None
while True:
    print("1 Open  2 Deposit  3 Withdraw  4 FD  0 Exit")
    choice = input("Choice: ")
    if choice == "0":
        break
    if choice == "1":
        if account is not None:
            print("Account already open")
            continue
        name = input("Customer name: ")
        senior = input("Senior category eligible? y/n: ").lower()
        minimum = float(input("Product minimum balance (rupees): "))
        balance = float(input("Opening balance (rupees): "))
        if minimum < 0 or balance < minimum or senior not in ("y", "n"):
            print("Invalid account details")
            continue
        account = {"name": name, "senior": senior == "y",
                   "minimum": minimum, "balance": balance}
        print("Account opened")
    elif choice in ("2", "3", "4"):
        if account is None:
            print("Open an account first")
            continue
        if choice in ("2", "3"):
            amount = float(input("Amount (rupees): "))
            if choice == "2":
                print(deposit(account, amount))
            else:
                print(withdraw(account, amount))
            print("Balance:", round(account["balance"], 2))
        else:
            principal = float(input("FD principal (rupees): "))
            quarters = int(input("FD duration in whole quarters: "))
            regular = float(input("Verified slab rate, public (% p.a.): "))
            senior_rate = float(input("Verified senior rate (% p.a.): "))
            if principal <= 0 or quarters <= 0 or min(regular, senior_rate) < 0:
                print("Invalid FD inputs")
                continue
            rate = senior_rate if account["senior"] else regular
            amount = maturity(principal, rate, quarters)
            print("Customer:", account["name"])
            print("Illustrative maturity (rupees):", round(amount, 2))
    else:
        print("Invalid menu choice")

Final answer: The menu opens one account, deposits, withdraws with a minimum-balance guard and estimates an FD maturity for the customer.

Quick solution. Chapter 4, nested collections and menus: store categories as dictionary keys and question-answer tuples in lists. Authenticate administrative changes, register the student, select a category, compare answers and update the score. The final score counts correct responses out of the selected category total.

Concept used. A dictionary of lists groups related questions. A menu chooses operations, while a score counter records correct answers. Quiz-show analysis. The Sony LIV KBC Play Along FAQ describes answer choices and a lifeline. A BBC-hosted Mastermind account names specialist subjects. These examples suggest storing accepted answers, selecting subject categories and showing progress. This classroom version uses short text answers and a running score; it does not reproduce either television format.

1. Use a classroom quiz format: one point per correct answer, zero otherwise, with no negative marking. Categories control which questions appear.
2. Store admin credentials at setup. Only a matching login permits adding, modifying or deleting questions. Student registration occurs before category selection.
3. Each question has one short text answer. Matching ignores case and surrounding spaces; equivalent alternative wording is not automatically recognised.

admin_id = input("Create admin ID: ")
admin_password = input("Create admin password: ")
questions = {"Python": [("Which brackets make a list?", "[]")],
             "Maths": [("What is 2 + 3?", "5")]}
students = {}
while True:
    print("1 Manage questions  2 Register/play  0 Exit")
    choice = input("Choice: ")
    if choice == "0":
        break
    if choice == "1":
        uid = input("Admin ID: ")
        password = input("Password: ")
        if uid != admin_id or password != admin_password:
            print("Access denied")
            continue
        action = input("a Add  m Modify  d Delete: ").lower()
        category = input("Category: ").strip()
        if not category:
            print("Category cannot be empty")
            continue
        if action == "a":
            question = input("Question: ")
            answer = input("Answer: ").strip().lower()
            questions.setdefault(category, []).append((question, answer))
        elif action in ("m", "d"):
            entries = questions.get(category, [])
            for number, entry in enumerate(entries, 1):
                print(number, entry[0])
            index = int(input("Question number: ")) - 1
            if not 0 <= index < len(entries):
                print("Question not found")
            elif action == "d":
                del entries[index]
            else:
                question = input("Replacement question: ")
                answer = input("Answer: ").strip().lower()
                entries[index] = (question, answer)
        else:
            print("Invalid action")
    elif choice == "2":
        student_id = input("Student ID: ").strip()
        name = input("Student name: ").strip()
        if not student_id or not name:
            print("Registration requires ID and name")
            continue
        students[student_id] = name
        print("Categories:", list(questions))
        category = input("Choose category: ")
        entries = questions.get(category, [])
        if not entries:
            print("No questions in this category")
            continue
        score = 0
        for question, answer in entries:
            response = input(question + " ").strip().lower()
            if response == answer:
                score += 1
            print("Current score:", score)
        print(name, "Final score:", score, "out of", len(entries))
    else:
        print("Invalid menu choice")

Final answer: The menu supports authenticated question management, registration, category choice, running scores and final scores.

Quick solution. Chapter 4, nested dictionaries: use the site name as a key and store its district, state, period, builder, purpose and source link. Authenticate additions, modifications and deletions. The program lists recorded sites, retrieves one complete record and filters site names by state.

Concept used. A nested dictionary stores named fields within each site record. Membership and iteration support lookup and state filtering.

1. Verified starter record. UNESCO identifies the Taj Mahal in Agra district, Uttar Pradesh. Shah Jahan commissioned it in memory of Mumtaz Mahal. UNESCO dates the main mausoleum to 1632-1648; other complex works continued later. Source: UNESCO Taj Mahal entry, checked 18 October 2026.
2. The starter collection contains one verified Indian site, not the complete national inventory. Add further researched records using the UNESCO India list. Each record includes every requested field. The list option displays all records currently entered.
3. Authenticate before any change. Exact site-name searches are case-sensitive; state searches ignore case and surrounding spaces.

   admin_id = input("Create admin ID: ")
   admin_password = input("Create admin password: ")
   sites = {"Taj Mahal": {
       "district": "Agra", "state": "Uttar Pradesh",
       "built": "Main mausoleum: 1632 to 1648",
       "builder": "Commissioned by Shah Jahan",
       "purpose": "Memorial tomb for Mumtaz Mahal",
       "website": "https://whc.unesco.org/en/list/252/"}}
   fields = ["district", "state", "built", "builder", "purpose", "website"]
   
   def show(name, details):
       print("Site:", name)
       for field in fields:
           print(field + ":", details[field])
   
   while True:
       print("1 Manage  2 List  3 Search name  4 Search state  0 Exit")
       choice = input("Choice: ")
       if choice == "0":
           break
       if choice == "1":
           uid = input("Admin ID: ")
           password = input("Password: ")
           if uid != admin_id or password != admin_password:
               print("Access denied")
               continue
           action = input("a Add  m Modify  d Delete: ").lower()
           name = input("Exact site name: ").strip()
           if not name:
               print("Site name cannot be empty")
           elif action == "a" and name in sites:
               print("Site already exists")
           elif action in ("m", "d") and name not in sites:
               print("Site not found")
           elif action == "d":
               del sites[name]
           elif action in ("a", "m"):
               details = {}
               for field in fields:
                   details[field] = input(field + ": ")
               sites[name] = details
           else:
               print("Invalid action")
       elif choice == "2":
           print("Recorded Indian World Heritage sites:")
           for name in sorted(sites):
               print(name)
       elif choice == "3":
           name = input("Exact site name: ").strip()
           if name in sites:
               show(name, sites[name])
           else:
               print("Site not found")
       elif choice == "4":
           state = input("State: ").strip().lower()
           found = False
           for name, details in sites.items():
               if details["state"].strip().lower() == state:
                   print(name)
                   found = True
           if not found:
               print("No recorded site in that state")
       else:
           print("Invalid menu choice")

Final answer: The program stores all requested site fields and provides authenticated editing, listing, full-name lookup and state-based listing.