Programming in Python · End Term · Sep 2025 · FN

**1. Identify the recursive functions:** p removes one decimal digit using integer division by 10 and counts one per call, so it counts digits of a nonnegative integer. q sums digits. r multiplies n by r(n-1), so it computes n factorial. **2. Compose in the requested order:** First compute 50 factorial using r(50), then count its decimal digits using p. Therefore the call is p(r(50)); its value is 65. **Answer: C — p(r(50)).** **Convention note:** The recursive returns are read inside their function bodies, with the final return following the base-case if. The PDF flattens Python indentation. A: **Incorrect:** It counts digits of the digit sum of 50, not digits of its factorial. B: **Incorrect:** It sums digits of 50 factorial rather than counting them. C: **Correct:** It first computes the factorial, then counts its decimal digits. D: **Incorrect:** It computes factorial of the digit sum 5, giving 120. E: **Incorrect:** It computes factorial of the digit count 2, giving 2.

**1. Write the header:** Opening in w mode creates or truncates the file, and the first write outputs the single line “Name,Salary”. **2. Write rows in order:** Each tuple is unpacked as employee name and salary and written as name,salary. Rows are Alice,75000; Bob,64000; Charlie,82000; Diana,71000; Eve,69000. A newline is added after each row except the last. **Answer: A — Name,Salary followed by the five name,salary rows.** **Convention note:** The function’s loop body and if body are read with their intended indentation; f.close() is after the writing loop. The last data row has no trailing newline. A: **Correct:** It includes the correct header and all five rows in input order. B: **Incorrect:** It omits the header explicitly written by the function. C: **Incorrect:** It reverses the header labels without changing the data order. D: **Incorrect:** The header contains a comma, not a newline between its two words. E: **Incorrect:** It reverses both column order and the data format.

**1. Trace each source character:** For each character in “database”, the inner loop checks whether that character appears anywhere in “baseball”. d and t have no matches; each of the three a positions matches, and b,s,e also match. **2. Preserve repeats and stop after the first match:** break prevents duplicate appends from multiple matching target positions for the same source character. It does not remove repeated a positions from the source. The result is ['a','a','b','a','s','e']. **Answer: A — ['a', 'a', 'b', 'a', 's', 'e'].** **Convention note:** The intended indentation puts append and break inside the equality test, with the loops nested. Whether the shown else attaches to that test or to the inner for does not alter this result here. A: **Correct:** It retains all matching characters in source order, including all three a occurrences. B: **Incorrect:** t does not appear in baseball and cannot be appended. C: **Incorrect:** It wrongly removes one repeated a. D: **Incorrect:** It wrongly removes one repeated a before s.

**1. Build the frequencies:** Splitting removes the comma separators from the character count. Across the words, n appears 6 times; t,i,a each appear 3 times; o and p each appear twice. **2. Select the maximum:** Scanning the alphabet updates the winner whenever its count is at least the stored maximum. That tie rule would prefer the later letter on a tie, but n is the unique maximum, so the output is n. **Answer: A — n.** **Convention note:** The counting increment is inside the character loop but outside the initialization if; the PDF flattens these block indents. A: **Correct:** n has the highest count, 6. B: **Incorrect:** o occurs only twice. C: **Incorrect:** i occurs three times, below n. D: **Incorrect:** p occurs twice, below n.

**1. Identify the selected integers:** range(1,3n+1) includes 1 through 3n. The divisibility condition keeps exactly \(3,6,9,\ldots,3n\). **2. Sum the progression:** The program prints \(3(1+2+\cdots+n)=3n(n+1)/2\), corresponding to B. **Answer: B — 3+6+9+…+3n.** A: **Incorrect:** It omits the factor of 3. B: **Correct:** It lists exactly the multiples retained by the comprehension. C: **Incorrect:** It sums all integers, not just multiples of 3. D: **Incorrect:** It describes odd integers rather than multiples of 3. E: **Incorrect:** It also describes an odd-number progression rather than the selected list.

**1. Check the tuple and set snippets:** Assigning T[0]=10 raises TypeError because tuples are immutable. Sets have add(), not insert(), so S.insert(2) raises AttributeError. **2. Check the list snippet:** L.append(3) is a valid list mutation. Therefore exactly Code-1 and Code-2 fail on their second line. **Answer: D — Code-1 and Code-2 will throw an error line-2.** A: **Incorrect:** Code-2 fails as well. B: **Incorrect:** Code-1 fails as well. C: **Incorrect:** Code-3 is valid; the other two fail. D: **Correct:** It identifies precisely the immutable-item assignment and nonexistent set method. E: **Incorrect:** Code-3 does not fail, while Code-1 does. F: **Incorrect:** The list append is valid.

**1. State the filter and output:** Each employee tuple must be unpacked, tested with salary>70000, and contribute only the name. The sample retains Alice, Charlie and Diana. **2. Compare implementations:** A puts the filter after the for clause in a valid comprehension. B performs the same filter and append in a loop. C has invalid conditional-expression syntax; D omits the filter. **Answer: A, B — high_earners = [name for (name, salary) in employees if salary > 70000] ; high_earners = [] .** **Convention note:** Read B’s append inside the if and the if inside the loop, as the displayed nested snippet indicates. A: **Correct:** It is the correct filtered name comprehension. B: **Correct:** Its loop appends exactly the names passing the salary test. C: **Incorrect:** A conditional expression in this position needs an else; this is invalid syntax. D: **Incorrect:** It returns every employee name, including Bob and Eve.

**1. Track both levels of insertion order:** Alice must first appear before Bob; Alice’s first department must be HR before IT, and Bob’s Finance before IT. Later assignments to an existing key replace its value without moving it. **2. Check the files:** A establishes the required order and values. B first sets Bob/Finance to 66000 but later overwrites it with 65000, preserving the insertion order. C inserts Bob first; D inserts Alice’s IT before HR. **Answer: A, B — Alice,HR,70000 ; Alice,HR,70000 .** **Convention note:** The assignments are read inside the file loop, with inner-dictionary initialization conditional on a new name. The file has no header because every third field is converted directly to int. A: **Correct:** It produces the required nested key order and final values. B: **Correct:** Its later Finance row overwrites 66000 with 65000 without changing key order. C: **Incorrect:** It places Bob before Alice in the printed outer dictionary. D: **Incorrect:** It places IT before HR in Alice’s inner dictionary.

**1. Interpret the frequency result:** With k=2, all(c<2 for c in freq.values()) is true exactly when every character that occurs has count 1. Thus no character is repeated. **2. Interpret isdigit:** The other True requires a nonempty string consisting entirely of digit characters. Therefore the qualifying strings contain only digits and each character occurs once. **Answer: A, D — input_str contains only numeric characters; All elements of input_str occur exactly one time.** **Convention note:** Python isdigit includes some Unicode digit characters beyond ASCII 0–9. “Numeric characters” in A is used broadly; the precise predicate is digit characters, not every Unicode numeric symbol. The question assumes the implied function/block indentation. A: **Correct:** isdigit() being true ensures all characters are digits. B: **Incorrect:** Alphabetic characters would make isdigit() false. C: **Incorrect:** The all-counts-below-2 test forbids a count of exactly two. D: **Correct:** Every present character has a positive count less than 2, hence exactly one. E: **Incorrect:** Every count is 1, the opposite of at least two.

**1. Follow the divisions:** The recursive arguments are 1024,512,256,128,64,32,16,8,4,2,1. The base call at x=1 returns zero. **2. Count non-base calls:** Each preceding call adds 1, so ten divisions by 2 yield a total of 10. Equivalently 1024=2 to the power 10. **Answer: 10.**

**1. Process successful conversions:** int converts “5”, “7” and “8”, contributing 5+7+8=20. int("2.5") raises ValueError because it is not an integer-format string. **2. Process the exception:** The except block increments errors once and adds the fallback 5 to total. Thus total=25 and errors=1. **3. Evaluate the final expression:** total+errors=25+1=26. **Answer: 26.** **Convention note:** The fallback total+=5 is read inside the except block. If it were outside try/except and executed for every input, the result would differ; the PDF does not preserve indentation.

**1. Interpret the divisor count:** For each integer from 10 through 20 inclusive, the inner loop counts its positive divisors. Exactly two divisors means the number is prime. **2. Identify and add the qualifying values:** The primes in this range are 11,13,17,19. Their sum is 11+13+17+19=60. **Answer: 60.** **Convention note:** The count==2 test occurs after finishing the divisor loop; num increments once per while iteration. These are the intended block levels in the flattened PDF.

**1. Simplify the slices:** For each i=0,1,2, L[:i]+L[i:] reconstructs the full list [2,3,4], whose sum is 9. The += operation extends S rather than resetting it. **2. Track cumulative S:** The three passes make S contain one, two and three copies of L, with sums 9,18,27 respectively. Each pass adds the sum of the entire current S to T. **3. Add the contributions:** T=9+18+27=54. **Answer: 54.** **Convention note:** The for j in S loop runs inside the while, and i increments once after that for loop. The PDF flattens the indentation.

**1. Identify the recurrence:** Each non-base call adds 1 and divides x by y using floor division until x<y. For exact powers x=y to the power k, the result is k. **2. Trace the three powers:** 81=3 to the power 4 gives 4; 64=2 to the power 6 gives 6; 125=5 to the power 3 gives 3. **3. Sum the results:** The printed value is 4+6+3=13. **Answer: 13.**

**1. Follow the prefix of presses:** Starting at floor 0, the first six presses U,D,D,U,U,U give floors 1,0,-1,0,1,2. **2. Interpret the stop condition:** At the first visit to floor 2, the program prints index+1, the number of presses consumed, and immediately breaks. It does not process the rest of the sequence. **Answer: A — It prints the number of button presses after which you reach the floor 2 for the first .** **Convention note:** Read the floor updates and the floor==2 check inside the while loop, and break inside that check. A: **Correct:** It describes the first hitting-time count printed before break. B: **Incorrect:** The code does not count repeated crossings and stops at the first hit. C: **Incorrect:** It stops early and prints a press count rather than the final floor. D: **Incorrect:** A correctly describes the program.

**1. Follow the prefix of presses:** Starting at floor 0, the first six presses U,D,D,U,U,U give floors 1,0,-1,0,1,2. **2. Interpret the stop condition:** At the first visit to floor 2, the program prints index+1, the number of presses consumed, and immediately breaks. It does not process the rest of the sequence. **3. Read the output:** Floor 2 is first reached at zero-based index 5, so the printed one-based count is 6. **Answer: 6.**

**1. Swap the two diagonal positions within each row:** At i=0, columns 0 and -1 exchange 2 and 6. At i=1, columns 1 and -2 are the same middle position, so nothing changes. At i=2, columns 2 and -3 exchange 18 and 14. **2. Read the mutated matrix:** P is [[6,4,2],[8,10,12],[18,16,14]]. The operation swaps the main- and anti-diagonal entries row by row; it does not reverse the entire row order. **Answer: A — [[6, 4, 2], [8, 10, 12], [18, 16, 14]].** **Convention note:** Return M occurs after the full loop in ProcedureOne. The PDF flattens the function/loop indentation; reading return inside the loop would stop too early. A: **Correct:** It contains the correctly swapped row-end diagonal entries. B: **Incorrect:** It incorrectly leaves the original matrix unchanged. C: **Incorrect:** It reverses the row order, which the procedure never does. D: **Incorrect:** It swaps the wrong within-row positions.

**1. Swap the two diagonal positions within each row:** At i=0, columns 0 and -1 exchange 2 and 6. At i=1, columns 1 and -2 are the same middle position, so nothing changes. At i=2, columns 2 and -3 exchange 18 and 14. **2. Read the mutated matrix:** P is [[6,4,2],[8,10,12],[18,16,14]]. The operation swaps the main- and anti-diagonal entries row by row; it does not reverse the entire row order. **3. Multiply the new main diagonal:** ProcedureTwo multiplies P[0][0],P[1][1],P[2][2], giving 6×10×14=840. **Answer: 840.** **Convention note:** ProcedureTwo returns p after completing its loop, so all three diagonal entries contribute.