Author: Priyanka B.

(If-elif control flow)

Problem Statement:

Once upon a time, there was a country inhabited by happy and prosperous people. The people paid taxes, of course – their happiness had limits. The most important tax, called the Personal Income Tax (PIT ), had to be paid yearly and was evaluated using the following rule:

• If the citizen’s income was not higher than 85,528 INR, the tax was equal to 18% of the income minus 556 INR and 2 paisa (this was the so-called tax relief)
• If the income was higher than this amount, the tax was equal to 14,839 INR and 2 paisa, plus 32% of the surplus over 85,528 INR.

Your task is to write a tax calculator.

• It should accept one floating-point value: the income.
• Next, it should print the calculated tax, rounded to the full INR. There’s a function named round() which will do the rounding for you – you’ll find it in the skeleton code in the editor.

Note: This happy country never returns money to its citizens. If the calculated tax is less than zero, it means there is no tax (the tax is zero). Take this into consideration during your calculations.

Test Data

Sample input: 10000

Expected output: The tax is: 1244.0 INR

Sample input: 100000

Expected output: The tax is: 19470.0 INR

Sample input: 1000

Expected output: The tax is: 0.0 INR

Sample input: -100

Expected output: The tax is: 0.0 INR

Solution:

income = float(input("Enter the annual income: "))
tax = 0
if income <= 0:
    tax = 0.0
elif 0 < income <= 85528:
    tax = (18/100)*income - 556.2
elif income >= 85528:
    tax = 14839.2 + (32/100)*(income - 85528)
else:
    print("Invalid Input!")
tax = round(tax, 0)
print("The tax is:", tax, "INR")

Output:

(Python)

Problem Statement:

Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

You can return the answer in any order.

Example 1:

Input: nums = [2,7,11,15], target = 9
Output: [0,1]
Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].

Example 2:

Input: nums = [3,2,4], target = 6
Output: [1,2]

Example 3:

Input: nums = [3,3], target = 6
Output: [0,1]

Constraints:

• 2 <= nums.length <= 104
• -109 <= nums[i] <= 109
• -109 <= target <= 109
• Only one valid answer exists.

Follow-up: Can you come up with an algorithm that is less than O(n2) time complexity?

Solution:

1. [Naive Approach] Generating all Possible Pairs – O(n²) time and O(1) space

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        for i in range(0, len(nums)):
            for j in range(i+1, len(nums)):
                if nums[i] + nums[j] == target:
                    two_sum = [i,j]
                    break
        return two_sum

2. [Expected Approach] Using Hash Set – O(n) time and O(n) space

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        s = set()
        for index, num in enumerate(nums):
            complement = target - num
            if complement in s:
                return [next(index for index,num in enumerate(nums) if num == complement), index]
            s.add(num)
        return []

Reference: Two Sum – LeetCode

What is Encapsulation?

Encapsulation is an Object-Oriented Programming (OOP) concept where data (attributes) and methods (functions) are bundled together in a class and access to the data is controlled to protect it from unintended interference or misuse.

Why Encapsulation?

• Data hiding (restricting direct access to variables)
• Better maintainability
• Controlled access through getter and setter methods

Access Modifiers in Python

Python does not have strict access modifiers like some other languages, but it uses naming conventions:

For Example:

class BankAccount:
    def __init__(self, account_holder, balance):
        self.account_holder = account_holder  # Public attribute
        self._account_type = "Savings"        # Protected attribute
        self.__balance = balance              # Private attribute
    # Getter for balance
    def get_balance(self):
        return self.__balance
    # Setter for balance with validation
    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            print(f"Deposited ₹{amount}. New balance: ₹{self.__balance}")
        else:
            print("Deposit amount must be positive.")
    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount
            print(f"Withdrew ₹{amount}. Remaining balance: ₹{self.__balance}")
        else:
            print("Invalid withdrawal amount.")
# Usage
account = BankAccount("Rahul", 5000)
# Public access
print(account.account_holder)  # ✅ Works
# Protected access (possible but discouraged)
print(account._account_type)   # ⚠️ Works but not recommended
# Private access (will cause error)
# print(account.__balance)     # ❌ AttributeError
# Correct way to access private data
print("Balance:", account.get_balance())
# Modify balance safely
account.deposit(2000)
account.withdraw(1000)

Key Points

1. Public: Accessible anywhere.
2. Protected: Accessible but should be treated as internal.
3. Private: Not directly accessible; use getters/setters.
4. Name Mangling: Private attributes are internally renamed to _ClassName__attribute to avoid accidental access.

(OOP)

What is Object Oriented Programming (OOP)?

Object-Oriented Programming (OOP) is a programming paradigm that organizes software design around objects — entities that combine data (attributes) and behavior (methods). It models real-world entities and promotes modularity, reusability, and maintainability in code.

At its core, OOP uses classes as blueprints to create objects. A class defines the structure (attributes) and capabilities (methods) of its objects, while each object is an instance with its own state.

Key Concepts

• Class – A template or a blueprint that define attributes and methods.
• Object – An instance of a class with specific data.
• Attributes – Variables that store the state of an object.
• Methods – Functions inside a class that define object behavior.

OOP Principles

1. Encapsulation – Bundling data and methods, restricting direct access to internal state.
2. Abstraction – Hiding complex implementation details, exposing only necessary functionality.
3. Inheritance – Allowing a class (child) to acquire properties and behaviors from another (parent).
4. Polymorphism – Enabling the same method name to behave differently based on the object.

Benefits of OOP

• Code Reusability via inheritance.
• Modularity for easier debugging and maintenance.
• Security through encapsulation.
• Flexibility with polymorphism for adaptable behaviors.

Data Structures – Stacks

Problem Statement:

You are given a block of code or a string. Check for balanced parenthesis.

Example:

Sample Input1:

" # Example: Python code with unbalanced parentheses \
def add_numbers(a, b): \
return (a + b # Missing closing parenthesis \
# Calling the function \
result = add_numbers(5, 3) \
print('Result':, result) "

Expected Output1:

False

Sample Input2:

" # Example: Python code with unbalanced parentheses \
def add_numbers(a, b): \
return (a + b) # Closed parenthesis \
# Calling the function \
result = add_numbers(5, 3) \
print('Result':, result) "

Expected Output2:

True

Solution:

# Balanced parentheses
def is_balanced(s):
    stack = []
    mapping = {')':'(', ']':'[', '}':'{'}
    for char in s:
        if char in mapping.values():
            stack.append(char)
        elif char in mapping:
            if not stack or stack.pop() != mapping[char]:
                return False
    return not stack
string1 = " # Example: Python code with unbalanced parentheses \
            def add_numbers(a, b): \
                return (a + b  # Missing closing parenthesis \
            # Calling the function \
            result = add_numbers(5, 3) \
            print('Result':, result) "
print(is_balanced(string1)) 

Output: