Unit 2: Control Flow, Functions, and Problem-Solving - Subjective Questions

Conditional statements allow a program to make decisions based on whether a condition is true or false.

• The if statement executes a block only when its condition is true.
• The if-else statement selects one of two blocks.
• The if-elif-else structure tests multiple conditions in sequence.

Example:

age = 20
if age >= 18:
    print("Adult")
else:
    print("Minor")

In an if-elif-else statement, Python evaluates conditions from top to bottom and executes the first true block. Indentation is essential because it defines the statement block.

Comparison of loops:

• A for loop is generally used when iterating over a sequence or when the number of iterations is known.
• A while loop is used when repetition should continue until a condition becomes false.
• A for loop automatically obtains values from an iterable.
• A while loop requires explicit initialization and updating of the control variable.

Example of a for loop:

for number in range(1, 4):
    print(number)

Example of a while loop:

count = 1
while count <= 3:
    print(count)
    count += 1

The loop condition in a while loop must eventually become false to avoid an infinite loop.

A nested loop is a loop placed inside another loop. The inner loop completes all its iterations for each iteration of the outer loop.

Example:

rows = 3
columns = 4

for i in range(rows):
    for j in range(columns):
        print("*", end=" ")
    print()

Output:

* * * *
* * * *
* * * *

The outer loop controls the number of rows. The inner loop controls the number of stars in each row. Nested loops are useful for processing tables, matrices, patterns, and combinations of values.

The break statement immediately terminates the nearest enclosing loop. Program execution continues with the statement after the loop.

The continue statement skips the remaining statements in the current iteration and begins the next iteration of the loop.

Example:

for number in range(1, 6):
    if number == 3:
        continue
    if number == 5:
        break
    print(number)

Output:

1
2
4

Here, continue skips printing 3, while break stops the loop when number becomes 5. Both statements should be used carefully because excessive use can make program logic difficult to follow.

The range() function generates a sequence of integers, commonly used with for loops. Its general forms are:

• range(stop) generates values from 0 to stop - 1.
• range(start, stop) generates values from start to stop - 1.
• range(start, stop, step) changes the difference between consecutive values.

Examples:

for i in range(5):
    print(i)

This prints 0 through 4.

for i in range(2, 7):
    print(i)

This prints 2 through 6.

for i in range(10, 0, -2):
    print(i)

This prints 10, 8, 6, 4, and 2. The stop value is never included, and a zero step is invalid.

An algorithm for this problem is:

1. Read the input string.
2. Initialize counters for vowels, consonants, digits, and spaces to zero.
3. Examine each character using a loop.
4. If the character is a vowel, increment the vowel counter.
5. Otherwise, if it is an alphabetic character, count it as a consonant.
6. If it is a digit or space, update the corresponding counter.
7. Display all counters.

Python implementation:

text = input("Enter a string: ")
vowels = 0
consonants = 0
digits = 0
spaces = 0

for char in text.lower():
    if char in "aeiou":
        vowels += 1
    elif char.isalpha():
        consonants += 1
    elif char.isdigit():
        digits += 1
    elif char.isspace():
        spaces += 1

print(vowels, consonants, digits, spaces)

The algorithm takes time, where is the length of the string.

A function is a named, reusable block of code that performs a specific task. It is defined using the def keyword.

Example:

def calculate_area(length, width):
    area = length * width
    return area

result = calculate_area(5, 3)

In this example:

• length and width are parameters.
• 5 and 3 are arguments supplied during the function call.
• area is a local variable because it is created inside the function.
• return sends a result back to the calling code.

Functions improve modularity, code reuse, readability, testing, and maintenance. A function without an explicit return statement returns None by default.

Python supports several ways to pass arguments to functions.

• Positional arguments: Values are matched according to their order.

  def subtract(a, b):
  return a - b
  subtract(10, 3)

• Keyword arguments: Values are passed using parameter names.

  subtract(a=10, b=3)

• Default arguments: A parameter has a predefined value.

  def greet(name, message="Welcome"):
  return message + ", " + name

• Variable-length positional arguments: *args collects extra positional arguments into a tuple.

  def total(*numbers):
  return sum(numbers)

• Variable-length keyword arguments: **kwargs collects extra keyword arguments into a dictionary.

  def show_details(**details):
  return details

These mechanisms make functions flexible and reusable.

Recursion is a technique in which a function calls itself to solve a smaller version of the same problem. Every recursive function must contain:

• A base case, which stops further calls.
• A recursive case, which reduces the problem toward the base case.

The factorial of a non-negative integer is defined as , with .

Python implementation:

def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n - 1)

For factorial(4), the calls are evaluated as .

The condition n == 0 is the base case. The expression n * factorial(n - 1) is the recursive case. Without a valid base case, recursion can continue until a recursion error occurs.

A lambda function is a small anonymous function written using the lambda keyword. It can contain any number of arguments but only one expression.

Syntax:

lambda arguments: expression

Example:

square = lambda x: x * x
print(square(5))

The same operation using an ordinary function is:

def square(x):
    return x * x

Lambda functions are often used as short callback functions. For example:

students = [("Ana", 82), ("Ben", 75), ("Cara", 91)]
students.sort(key=lambda item: item[1])

Here, the list is sorted according to each student's score. Ordinary functions are generally preferable when logic is long, complex, or needs documentation.

Strings are sequences of characters, and each character has an index. Positive indexing starts at 0 from the left, while negative indexing starts at -1 from the right.

For text = "Python":

• text[0] gives "P".
• text[-1] gives "n".
• text[1:4] gives "yth".
• text[:3] gives "Pyt".
• text[2:] gives "thon".
• text[::2] selects every second character.
• text[::-1] reverses the string.

The general slicing form is sequence[start:stop:step]. The start index is included, but the stop index is excluded. Slicing normally creates a new string and does not modify the original string because strings are immutable.

Python provides many methods for processing strings.

• lower() converts letters to lowercase: "Hello".lower() gives "hello".
• upper() converts letters to uppercase.
• strip() removes leading and trailing whitespace.
• replace(old, new) substitutes one substring for another.
• find(sub) returns the first index of a substring, or -1 if it is absent.
• startswith(prefix) tests whether a string begins with a specified prefix.
• endswith(suffix) tests whether a string ends with a specified suffix.

Example:

value = "  Python Programming  "
cleaned = value.strip().lower()
changed = cleaned.replace("python", "java")

String methods generally return a new string because strings are immutable. Methods such as startswith() and endswith() return Boolean values.

The split() method divides a string into a list using a separator. If no separator is specified, whitespace is used.

The join() method combines the elements of an iterable into one string using the calling string as the separator.

Program:

data = input("Enter names separated by commas: ")
names = data.split(",")
cleaned_names = []

for name in names:
    cleaned_names.append(name.strip())

result = "-".join(cleaned_names)
print(result)

For input " Ana, Ben, Cara ", the output is "Ana-Ben-Cara".

split() is useful for parsing input, while join() is useful for constructing formatted output. The elements passed to join() must be strings.

Python supports flexible string formatting through f-strings and the format() method.

An f-string places expressions inside braces:

name = "Ravi"
score = 87.456
print(f"{name} scored {score:.2f} marks")

The output is Ravi scored 87.46 marks because .2f formats the number to two decimal places.

Alignment and width can also be specified:

print(f"{name:<10} | {score:>8.2f}")

Here, < aligns text to the left and > aligns it to the right.

The format() method provides another approach:

message = "Student: {}, Score: {:.1f}".format(name, score)

Formatting improves readability and is useful for reports, tables, currency values, percentages, and numerical output.

String concatenation combines strings using the + operator:

message = "Hello, " + name

It is simple but can become difficult to read when many values or conversions are required.

F-strings use expressions inside braces:

message = f"Hello, {name}. You are {age} years old."

They are concise, readable, and support formatting expressions directly.

The format() method uses placeholders:

message = "Hello, {}. You are {} years old.".format(name, age)

It is flexible and remains useful in code that supports older Python versions.

Concatenation may require explicit conversion using str(). F-strings require a modern Python version, while format() can be more verbose. All three approaches create a new string rather than modifying the original.

A regular expression, or regex, is a pattern used to search, validate, and extract parts of text. Python provides regex support through the re module.

Important regex components include:

• Character classes such as [A-Z], [0-9], and \\d.
• Quantifiers such as *, +, ?, and {m,n}.
• Anchors such as ^ for the beginning and $ for the end.
• re.search() to find the first matching location.
• re.findall() to return all non-overlapping matches.

Example:

import re
text = "Order numbers: 125, 340, and 78"
numbers = re.findall(r"\\d+", text)
print(numbers)

The result is ['125', '340', '78']. Raw strings such as r"\\d+" are commonly used so that backslashes in patterns are handled clearly.

A simple email validation program can be written as follows:

import re

pattern = r"^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}$"
email = input("Enter an email address: ")

if re.fullmatch(pattern, email):
    print("Valid format")
else:
    print("Invalid format")

Explanation of the pattern:

• ^ and $ require the pattern to cover the entire string.
• [A-Za-z0-9._%+-]+ matches the username part.
• @ matches the separator.
• [A-Za-z0-9.-]+ matches the domain.
• \\. matches a literal dot.
• [A-Za-z]{2,} requires a domain suffix of at least two letters.

This checks a common format, but real email validation is more complex. A syntactically matching address may not exist, and only confirmation through email communication can establish that it is usable.

Algorithmic thinking is the systematic process of developing a precise solution to a problem before or while writing code.

Its main components are:

• Decomposition: Break a large problem into smaller, manageable tasks.
• Pattern recognition: Identify similarities with previously solved problems.
• Abstraction: Ignore irrelevant details and focus on important information.
• Algorithm design: Write an ordered sequence of unambiguous steps.
• Evaluation: Test the solution using normal, boundary, and invalid inputs.

For example, to find the largest value in a list, initialize the first element as the largest, compare each remaining element with it, update when a larger value is found, and finally return the stored value. This approach converts an informal problem into clear operations that can be implemented and tested.

The algorithm maintains running values while traversing the list once.

numbers = [12, 5, 18, 7, 10]

largest = numbers[0]
smallest = numbers[0]
total = 0
count = 0

for number in numbers:
    if number > largest:
        largest = number
    if number < smallest:
        smallest = number
    total += number
    count += 1

average = total / count
print(f"Largest: {largest}")
print(f"Smallest: {smallest}")
print(f"Average: {average:.2f}")

The first element initializes the largest and smallest values. Each later element is compared with them. The variables total and count are used to calculate the average. The time complexity is and the additional space complexity is , excluding the input list.

A palindrome reads the same from left to right and right to left, ignoring or including case and spaces according to the problem requirements.

Using slicing:

def is_palindrome(text):
    cleaned = text.lower().replace(" ", "")
    return cleaned == cleaned[::-1]

print(is_palindrome("Never odd or even"))

A loop-based approach compares characters at opposite ends:

def is_palindrome_loop(text):
    cleaned = text.lower().replace(" ", "")
    left = 0
    right = len(cleaned) - 1

    while left < right:
        if cleaned[left] != cleaned[right]:
            return False
        left += 1
        right -= 1
    return True

The slicing method is concise but creates a reversed copy. The loop-based method can stop early when a mismatch is found and uses constant additional space.