Upload end-sem pyq for DAA, november-december 2025. Provided by Ayush Kalaskar.

Codes/C++/Code-A1 (Fibonacci).cpp

@@ -3,24 +3,34 @@
 #include <iostream>
 using namespace std;
 
+int recursiveSteps = 0;
+int iterativeSteps = 0;
+
 // Recursive function for Fibonacci
 int fibRecursive(int n) {
+    recursiveSteps++;
     if (n <= 1)
-        return n;  // Base case: fib(0)=0, fib(1)=1
+        return n;  
     return fibRecursive(n - 1) + fibRecursive(n - 2);
 }
 
 // Non-recursive (Iterative) Fibonacci
-int fibIterative(int n) {
-    if (n <= 1)
-        return n;
+void fibIterative(int n) {
+    if (n <= 0)
+        return;
     int prev = 0, curr = 1, next;
-    for (int i = 2; i <= n; i++) {
+    cout << prev << " ";
+    if (n == 1)
+        return;
+
+    cout << curr << " ";
+    for (int i = 2; i < n; i++) {
         next = prev + curr;
+        cout << next << " ";
         prev = curr;
         curr = next;
+        iterativeSteps++;
     }
-    return curr;
 }
 
 int main() {
@@ -29,22 +39,26 @@ int main() {
     cin >> n;
 
     cout << "\nFibonacci Series using Recursion: ";
-    for (int i = 0; i < n; i++)
+    for (int i = 0; i < n; i++) {
         cout << fibRecursive(i) << " ";
+    }
+    cout << "\nTotal Recursive Steps: " << recursiveSteps;
 
-    cout << "\nFibonacci Series using Iteration: ";
-    for (int i = 0; i < n; i++)
-        cout << fibIterative(i) << " ";
+    cout << "\n\nFibonacci Series using Iteration: ";
+    fibIterative(n);
+    cout << "\nTotal Iterative Steps: " << iterativeSteps;
 
     cout << endl;
     return 0;
 }
 
-// SAMPLE OUTPUT
+// SAMPLE OUTOUT
 /*
-* $ ./a.out 
 * Enter the number of terms: 5
 * 
 * Fibonacci Series using Recursion: 0 1 1 2 3 
+* Total Recursive Steps: 19
+* 
 * Fibonacci Series using Iteration: 0 1 1 2 3 
+* Total Iterative Steps: 3
 */

Codes/C++/Code-A2 (Huffman Coding).cpp

@@ -1,4 +1,4 @@
-// Code-A2 (Huffman)
+// Code-A2 (Huffman Coding)
 
 #include <iostream>
 #include <queue>

Codes/Code-A1.py

@@ -1,33 +1,50 @@
+# Code-A1 (Fibonacci)
 # Problem Statement: Write a program non-recursive and recursive program to calculate Fibonacci numbers and analyze their time and space complexity.
 
-# Non-recursion
-def fibonacci(n):
-    fib_series = []
-    a = 0
-    b = 1
+# Initalize global variables
+iteration_counter = 0
+recursion_counter = 0
 
-    for i in range(n):
-        fib_series.append(a)
-        a, b = b, a + b
+# Iteration
+def fibonacci_iteration(n):
+  fib_series = []           # For storing Fibonacci series
+  previous = 0              # Previous
+  current = 1               # Next
+  global iteration_counter  # Global iteration counter
+  iteration_counter = 0     # Initialize global iteration counter to 0
 
-    return fib_series
+  for i in range(n):
+    fib_series.append(previous)
+    previous, current = current, previous + current
+    iteration_counter += 1
+
+  return fib_series
 
 # Recursion
-def fibonacci_recursive(n):
-    if n <= 0:
-        return []
-    elif n == 1:
-        return [0]
-    elif n == 2:
-        return [0, 1]
-    else:
-        fib_series = fibonacci_recursive(n - 1)  # Get the series up to n-1
-        fib_series.append(fib_series[-1] + fib_series[-2])  # Append the next Fibonacci number
-        return fib_series
+def fibonacci_recursion(n):
+  global recursion_counter # Global recursion counter
+  recursion_counter += 1   # Increment recursion counter for each call
+
+  if (n <= 0):    # Handle n less than or equal to 0
+    return 0
+  elif (n <= 1):  # Handle n less than or equal to 1
+    return n
+  else:           # Recursive call
+    return fibonacci_recursion(n - 1) + fibonacci_recursion(n - 2)
 
-# Non-recursion
 n = int(input("Enter total numbers to print in fibonacci series:\t"))
-print("Fibonacci Series (non-recusive):\t", fibonacci(n))
 
-# Recursion
-print("Fibonacci Series (recusive):\t\t", fibonacci_recursive(n))
+# Fibonacci using iteration
+fib_series = fibonacci_iteration(n)
+print(f"Fibonacci using iteration:\t{fib_series}")
+print(f"Iteration counter:\t{iteration_counter}| Time Complexity: O(n) (linear growth)")
+
+print("="*80)
+
+# Fibonacci using recursion
+fib_series = []
+for i in range(n):
+  fib_series.append(fibonacci_recursion(i))
+print(f"Fibonacci using recursion:\t{fib_series}")
+print(f"Recursion counter:\t{recursion_counter} | Time Complexity: O(2^n) (exponential growth)")
+

Codes/Python/Code-A1-optimized.py

@@ -0,0 +1,46 @@
+# Problem Statement: Write a program non-recursive and recursive program to calculate Fibonacci numbers and analyze their time and space complexity.
+
+## NOTE: THIS IS A HEAVILY OPTIMIZED CODE FOR FIBONACCI.
+## NUMBER OF RECURSION CALLS (IN RECURSION) ARE LOWER THAN NUMBER OF ITERATIONS (IN ITERATION FUNCTION)
+
+iteration_counter = 0
+recursion_counter = 0
+
+# Non-recursion
+def fibonacci(n):
+    global iteration_counter
+    fib_series = []
+    a = 0
+    b = 1
+
+    for i in range(n):
+        fib_series.append(a)
+        a, b = b, a + b
+        iteration_counter += 1
+
+    return fib_series
+
+# Recursion
+def fibonacci_recursive(n):
+    global recursion_counter
+    recursion_counter += 1
+    if n <= 0:
+        return []
+    elif n == 1:
+        return [0]
+    elif n == 2:
+        return [0, 1]
+    else:
+        fib_series = fibonacci_recursive(n - 1)  # Get the series up to n-1
+        fib_series.append(fib_series[-1] + fib_series[-2])  # Append the next Fibonacci number
+        return fib_series
+
+# Non-recursion
+n = int(input("Enter total numbers to print in fibonacci series:\t"))
+print("Fibonacci Series (non-recusive):\t", fibonacci(n))
+print("Iteration counter:\t", iteration_counter)
+
+# Recursion
+print("Fibonacci Series (recusive):\t\t", fibonacci_recursive(n))
+print("Recursion counter:\t", recursion_counter)
+

Codes/Python/Code-A2 (Huffman Coding).py

@@ -0,0 +1,95 @@
+# Code-A2 (Huffman Coding)
+
+import heapq
+
+# Node class for Huffman Tree
+class Node:
+    def __init__(self, char, freq):
+        self.char = char
+        self.freq = freq
+        self.left = None
+        self.right = None
+
+    # Comparison function for priority queue
+    def __lt__(self, other):
+        return self.freq < other.freq
+
+
+# Function to build Huffman Tree
+def build_huffman_tree(char_freq):
+    heap = [Node(ch, freq) for ch, freq in char_freq.items()]
+    heapq.heapify(heap)
+
+    while len(heap) > 1:
+        # Pick two smallest nodes (greedy choice)
+        left = heapq.heappop(heap)
+        right = heapq.heappop(heap)
+
+        # Merge them into a new node
+        merged = Node(None, left.freq + right.freq)
+        merged.left = left
+        merged.right = right
+
+        heapq.heappush(heap, merged)
+
+    return heap[0]
+
+
+# Function to generate Huffman codes
+def generate_codes(root, current_code="", codes={}):
+    if root is None:
+        return
+
+    if root.char is not None:
+        codes[root.char] = current_code
+
+    generate_codes(root.left, current_code + "0", codes)
+    generate_codes(root.right, current_code + "1", codes)
+    return codes
+
+
+# Main program
+text = input("Enter text to encode: ")
+
+# Step 1: Calculate frequency of each character
+freq = {}
+for ch in text:
+    freq[ch] = freq.get(ch, 0) + 1
+
+# Step 2: Build Huffman Tree using greedy approach
+root = build_huffman_tree(freq)
+
+# Step 3: Generate Huffman Codes
+codes = generate_codes(root)
+
+# Step 4: Encode the text
+encoded_text = "".join(codes[ch] for ch in text)
+
+# Step 5: Display results
+print("\nCharacter | Frequency | Huffman Code")
+print("------------------------------------")
+for ch in freq:
+    print(f"    {ch!r}     |     {freq[ch]}      |    {codes[ch]}")
+
+print("\nEncoded Text:", encoded_text)
+
+# SAMPLE OUTPUT
+"""
+Enter text to encode: lord kska git
+
+Character | Frequency | Huffman Code
+------------------------------------
+    'l'     |     1      |    1100
+    'o'     |     1      |    1101
+    'r'     |     1      |    001
+    'd'     |     1      |    1010
+    ' '     |     2      |    011
+    'k'     |     2      |    100
+    's'     |     1      |    000
+    'a'     |     1      |    010
+    'g'     |     1      |    1011
+    'i'     |     1      |    1111
+    't'     |     1      |    1110
+
+Encoded Text: 110011010011010011100000100010011101111111110
+"""

Codes/Python/Code-A5 (N-Queen).py

@@ -0,0 +1,74 @@
+# Code-A5 (N-Queen)
+
+def print_board(board, n):
+    for i in range(n):
+        for j in range(n):
+            print(board[i][j], end=" ")
+        print()
+    print()  # blank line between solutions
+
+
+def is_safe(board, row, col, n):
+    # Check column
+    for i in range(row):
+        if board[i][col] == 1:
+            return False
+
+    # Check upper-left diagonal
+    i, j = row, col
+    while i >= 0 and j >= 0:
+        if board[i][j] == 1:
+            return False
+        i -= 1
+        j -= 1
+
+    # Check upper-right diagonal
+    i, j = row, col
+    while i >= 0 and j < n:
+        if board[i][j] == 1:
+            return False
+        i -= 1
+        j += 1
+
+    return True
+
+
+def solve_n_queens(board, row, n):
+    if row == n:
+        print_board(board, n)
+        return True
+
+    res = False
+    for col in range(n):
+        if is_safe(board, row, col, n):
+            board[row][col] = 1
+            res = solve_n_queens(board, row + 1, n) or res
+            board[row][col] = 0  # backtrack
+
+    return res
+
+
+# Main program
+n = int(input("Enter number of queens: "))
+board = [[0 for _ in range(n)] for _ in range(n)]
+
+print(f"\nSolutions for {n}-Queens Problem:\n")
+if not solve_n_queens(board, 0, n):
+    print("No solution exists!")
+
+# SAMPLE OUTPUT
+"""
+Enter number of queens: 4
+
+Solutions for 4-Queens Problem:
+
+0 1 0 0 
+0 0 0 1 
+1 0 0 0 
+0 0 1 0 
+
+0 0 1 0 
+1 0 0 0 
+0 0 0 1 
+0 1 0 0 
+"""

README.md

@@ -25,6 +25,7 @@ This repository contains valuable resources for the Design and Analysis of Algor
 
 > [!NOTE]
 > C++ versions of all codes are available in the [./Codes/C++](./Codes/C++) directory.
+> Python version of some codes are available in [./Codes/Python](./Codes/Python) directory.
 
 ### Practical
 
@@ -40,6 +41,7 @@ This repository contains valuable resources for the Design and Analysis of Algor
 - [END-SEM](Question%20Papers/END-SEM)
 
 ### [IN-SEM PYQ Answers](Notes/IN-SEM%20PYQ%20Answers)
+### [END-SEM PYQ Answers](Notes/END-SEM%20PYQ%20Answers)
 
 ---