Programming Fundamentals Short Notes for GATE DA

GATE DA Programming Fundamentals: 4 chapters, 9 previous year questions (29% of Programming, Data Structures and Algorithms), 474 practice questions and one solved question from each chapter.

About Programming Fundamentals Short Notes

Quick revision sheets for Programming Fundamentals in GATE DA. Every chapter is condensed into key formulas, shortcuts and common traps so you can revise 4 chapters fast before the exam.

Programming Fundamentals Weightage in GATE DA

Programming Fundamentals accounts for 9 of 31 Programming, Data Structures and Algorithms previous year questions in our bank (29%), about 3 per paper across 3 papers.

Programming Fundamentals Chapter Matrix

Chapter	Topics	PYQs	Share of unit PYQs	Practice questions
Python Data Structures: Lists, Sets and Dictionaries	Python List Operations and In-Place Updates, Python Set Operations and Membership Tracing	2	22%	112
Python Functions and Recursion	Recursive Function Tracing and Return Values	3	33%	155
List Processing and In-Place Mutation	Recursive List Processing and In-Place Mutation	2	22%	103
Function Scope, Closures and Default Arguments	Mutable Default Arguments, Closures and Enclosed State	2	22%	104

One Solved Question from Each Programming Fundamentals Chapter

Question 1 · Python Data Structures: Lists, Sets and Dictionaries MCQ

Consider the following Python code snippet.

a = [1, 2, 3]

b = a

c = a[:]

a += [4]

a = a + [5]

b.append(6)

What is the final value of c?

A.
[1, 2, 3]
B.
[1, 2, 3, 4]
C.
[1, 2, 3, 4, 6]
D.
[1, 2, 3, 6]

Correct Answer:

Step-by-Step Solution

Key idea: This is a list aliasing and mutation question. The key is tracking which operations mutate the existing list versus creating a new one, and understanding that slicing creates a shallow copy.

Step 1: Initial state

a = [1, 2, 3]
b = a (b points to the same list as a)
c = a[:] (c is a separate copy: [1, 2, 3])

Step 2: a += [4]

The += operator mutates the list in place
Both a and b now point to [1, 2, 3, 4]
c remains [1, 2, 3]

Step 3: a = a + [5]

The + operator creates a new list and rebinds a
a now points to [1, 2, 3, 4, 5]
b still points to [1, 2, 3, 4]
c remains [1, 2, 3]

Step 4: b.append(6)

This mutates the list that b points to
b becomes [1, 2, 3, 4, 6]
a remains [1, 2, 3, 4, 5]
c remains [1, 2, 3]

Final value of c: [1, 2, 3]

Answer: A

Question 2 · Python Functions and Recursion MCQ

Consider the following Python function:

```python

def f(n):

if n <= 1:

return n + 1

return (f(n - 1) + f(n - 2)) % 10

```

What is the maximum value returned by $f (n)$ for $n$ in the range $0 \leq n \leq 20$ ?

A.
9
B.
8
C.
7
D.
5

Correct Answer:

Step-by-Step Solution

Key idea: This is a dual-branch recursion with modular arithmetic. We must trace the function for all $n$ from 0 to 20 and find the maximum return value. The modulo operation ensures values stay in $[0, 9]$ .

Step 1: Trace the function systematically:

$f (0) = 0 + 1 = 1$
$f (1) = 1 + 1 = 2$
$f (2) = (f (1) + f (0)) %10 = (2 + 1) %10 = 3$
$f (3) = (f (2) + f (1)) %10 = (3 + 2) %10 = 5$
$f (4) = (f (3) + f (2)) %10 = (5 + 3) %10 = 8$
$f (5) = (f (4) + f (3)) %10 = (8 + 5) %10 = 13%10 = 3$
$f (6) = (f (5) + f (4)) %10 = (3 + 8) %10 = 11%10 = 1$
$f (7) = (f (6) + f (5)) %10 = (1 + 3) %10 = 4$
$f (8) = (f (7) + f (6)) %10 = (4 + 1) %10 = 5$
$f (9) = (f (8) + f (7)) %10 = (5 + 4) %10 = 9$
$f (10) = (f (9) + f (8)) %10 = (9 + 5) %10 = 14%10 = 4$
$f (11) = (f (10) + f (9)) %10 = (4 + 9) %10 = 13%10 = 3$
$f (12) = (f (11) + f (10)) %10 = (3 + 4) %10 = 7$
$f (13) = (f (12) + f (11)) %10 = (7 + 3) %10 = 10%10 = 0$
$f (14) = (f (13) + f (12)) %10 = (0 + 7) %10 = 7$
$f (15) = (f (14) + f (13)) %10 = (7 + 0) %10 = 7$
$f (16) = (f (15) + f (14)) %10 = (7 + 7) %10 = 14%10 = 4$
$f (17) = (f (16) + f (15)) %10 = (4 + 7) %10 = 11%10 = 1$
$f (18) = (f (17) + f (16)) %10 = (1 + 4) %10 = 5$
$f (19) = (f (18) + f (17)) %10 = (5 + 1) %10 = 6$
$f (20) = (f (19) + f (18)) %10 = (6 + 5) %10 = 11%10 = 1$

Step 2: Identify the maximum value from the traced results:

Values: $1, 2, 3, 5, 8, 3, 1, 4, 5, 9, 4, 3, 7, 0, 7, 7, 4, 1, 5, 6, 1$
Maximum: $9$ at $n = 9$

Answer: 9

Question 3 · List Processing and In-Place Mutation MCQ

Consider the following Python function:

```python

def process(L, i=0):

if i >= len(L) - 1:

return 0

count = 0

if L[i] > L[i+1]:

L[i], L[i+1] = L[i+1], L[i]

count = 1

return count + process(L, i+1)

```

The function is called as process([4, 3, 2, 5, 1]). Consider the following statements about this call:

I. The function returns $3$ .

II. After the call completes, L[4] equals $5$ .

III. After the call completes, the list L is sorted in non-decreasing order.

Which of the above statements is/are correct?

A.
I and III only
B.
I and II only
C.
II and III only
D.
I, II and III

Correct Answer:

Step-by-Step Solution

Key idea: This is a single-pass adjacent-swap recursive scan. The list is shared across all recursive calls, so each swap is visible to later calls. One pass moves large elements rightward but does not guarantee a fully sorted list.

Exam route: Trace the four comparisons (indices 0 through 3), count swaps, and inspect the final list.

Step-by-step trace for L = [4, 3, 2, 5, 1]:

|------|-----|---------------|------------|-------|------------|-------|

| 1 | 0 | [4,3,2,5,1] | $4 > 3$ | Yes | [3,4,2,5,1] | 1 |

| 2 | 1 | [3,4,2,5,1] | $4 > 2$ | Yes | [3,2,4,5,1] | 1 |

| 3 | 2 | [3,2,4,5,1] | $4 > 5$ | No | [3,2,4,5,1] | 0 |

| 4 | 3 | [3,2,4,5,1] | $5 > 1$ | Yes | [3,2,4,1,5] | 1 |

| 5 | 4 | base case | — | — | [3,2,4,1,5] | 0 |

Return value: $1 + 1 + 0 + 1 + 0 = 3$ . Statement I is true.

Final list: $[3, 2, 4, 1, 5]$ . So L[4] = 5. Statement II is true.

Sorted check: $[3, 2, 4, 1, 5]$ is not sorted ( $3 > 2$ , $4 > 1$ ). Statement III is false.

Trap path (overcounting): A student who assumes one left-to-right pass fully sorts the list will mark III as true and pick option D. A single pass only guarantees the largest element reaches the end; smaller elements may still be out of order.

Answer: Statements I and II only.

Question 4 · Function Scope, Closures and Default Arguments MCQ

Match the Python functions in List I with the length of their default argument's state after executing the calls f(2), f(4), f(6), f(8) in List II.

P) def f(x, lst=[]):

if len(lst) < 3: lst.append(x)

return lst

Q) def f(x, lst=[0]):

if lst[0] < 10: lst[0] += x

return lst

R) def f(x, lst=[]):

if x > 0: lst.append(x)

else: lst = [x]

return lst

S) def f(x, lst=[]):

lst.append(x)

if len(lst) > 2: lst.pop(0)

return lst

A.
P-3, Q-1, R-4, S-2
B.
P-2, Q-4, R-4, S-2
C.
P-3, Q-1, R-1, S-4
D.
P-3, Q-4, R-4, S-2

Correct Answer:

Step-by-Step Solution

Key idea: This is a boundary-case question testing the distinction between mutation and reassignment, combined with conditional logic that alters the shared state.

Step 1: Analyze P. The condition len(lst) < 3 allows appends until the list reaches length 3.

f(2): len 0 < 3. Appends 2. lst=[2].
f(4): len 1 < 3. Appends 4. lst=[2, 4].
f(6): len 2 < 3. Appends 6. lst=[2, 4, 6].
f(8): len 3 < 3 is False. No append. lst=[2, 4, 6].

Final length for P is 3.

Step 2: Analyze Q. The default is [0]. The condition lst[0] < 10 checks the first element. lst[0] += x mutates the element in place.

f(2): 0 < 10. lst[0] becomes 2. lst=[2].
f(4): 2 < 10. lst[0] becomes 6. lst=[6].
f(6): 6 < 10. lst[0] becomes 12. lst=[12].
f(8): 12 < 10 is False. No mutation. lst=[12].

Final length for Q is 1.

Step 3: Analyze R. All inputs (2, 4, 6, 8) are > 0, so the if branch is always taken. The else branch (reassignment) is never executed.

Each call appends to the shared list. After 4 calls, lst=[2, 4, 6, 8].

Final length for R is 4.

Step 4: Analyze S. The list appends first, then pops if length > 2.

f(2): Appends 2. lst=[2]. len > 2 is False.
f(4): Appends 4. lst=[2, 4]. len > 2 is False.
f(6): Appends 6. lst=[2, 4, 6]. len > 2 is True. Pops 0. lst=[4, 6].
f(8): Appends 8. lst=[4, 6, 8]. len > 2 is True. Pops 0. lst=[6, 8].

Final length for S is 2.

Matching: P-3, Q-1, R-4, S-2.

Answer: A

A question from this chapter

Login to view the complete short notes

Personalised first. High quality throughout.

Built around you, not around a syllabus PDF

Revision that hits your weak spots

Questions calibrated to the real exam

Notes written for recall, not for volume

One place for everything

Honest progress

Unlock the whole course

Programming Fundamentals Short Notes for GATE DA

About Programming Fundamentals Short Notes

Programming Fundamentals Weightage in GATE DA

Programming Fundamentals Chapter Matrix

More from Programming, Data Structures and Algorithms

One Solved Question from Each Programming Fundamentals Chapter

Step-by-Step Solution

Step-by-Step Solution

Step-by-Step Solution

Step-by-Step Solution