Summer Analyst Intern

Build the Graph
Convert the list of edges into an adjacency list.
Each node points to a list of nodes it is connected to.
Initialize Visited Set
Create a visited set to keep track of nodes you have already explored.
Traverse the Graph
For each unvisited node, perform BFS or DFS to explore all nodes connected to it.
Count the number of nodes visited in this traversal → this is the size of the connected component.
Filter Components
Ignore components with only one node.
Keep sizes of components with 2 or more nodes in a list.
Find Smallest and Largest
From the list of valid component sizes, find the minimum → smallest component.
Find the maximum → largest component.
Return the Result
Return [smallest_component_size, largest_component_size] as the answer.

Check Total Feasibility
Calculate total_gas = sum(gas) and total_cost = sum(cost).
If total_gas < total_cost, it’s impossible to complete the tour → return -1.
Initialize Tracking Variables
tank = 0 → keeps track of fuel in the car while traveling.
start = 0 → candidate starting station.
Traverse Each Station
For every station i from 0 to n-1:
Update fuel tank: tank += gas[i] - cost[i]
If tank < 0:
The current start station cannot work.
Move start = i + 1 and reset tank = 0.
Return the Result
After traversing all stations:
If total_gas >= total_cost, return start index.
Else, return -1.

Understand XOR Properties
XOR of a number with itself → 0
XOR of a number with 0 → the number itself
XOR is commutative and associative
Use a Bitset / Binary Representation
Think of each number in binary form.
You can try greedy approach on bits from highest to lowest to build the maximum XOR.
Algorithm (Greedy Basis / Linear Algebra on Bits)
Initialize an empty array basis[] to store independent numbers for XOR.
For each number in the array:
Try to reduce it using existing basis:
For each bit from highest to lowest, if the bit is set and there’s already a number in basis with that bit, XOR it.
If number becomes non-zero after reduction, add it to the basis.
Finally, XOR all basis numbers in such a way to get the maximum possible XOR.
Return Maximum XOR
XOR of all basis elements in a greedy manner gives the answer.

You have coins[] with different denominations.
You need to make amount using minimum number of coins.
You can use any number of each coin.
Let dp[i] = minimum number of coins to make amount i.
dp[0] = 0 → 0 coins needed to make amount 0
dp[1..amount] = infinity → initially assume impossible
Fill the DP Array
For each amount i from 1 to amount:
For each coin in coins:
If i - coin >= 0, update:
dp[i] = min(dp[i], dp[i - coin] + 1)
If dp[amount] is still infinity → cannot make the amount → return -1
Otherwise → return dp[amount]

Create a placeholder node called dummyHead with a value of 0. This node will hold the resulting linked list.
Initialize a pointer called tail and set it to dummyHead. This pointer will keep track of the last node in the result list.
Initialize a variable called carry to 0. This variable will store the carry value during addition.
Start a loop that continues until there are no more digits in both input lists (l1 and l2) and there is no remaining carry value.
Inside the loop:
Check if there is a digit in the current node of l1. If it exists, assign its value to a variable called digit1. Otherwise, set digit1 to 0.
Check if there is a digit in the current node of l2. If it exists, assign its value to a variable called digit2. Otherwise, set digit2 to 0.
Add the current digits from l1 and l2, along with the carry value from the previous iteration, and store the sum in a variable called sum.
Calculate the unit digit of sum by taking the modulus (%) of sum by 10. This digit will be placed in a new node for the result.
Update the carry variable by dividing sum by 10 and taking the integer division (/) part. This gives us the carry value for the next iteration.
Create a new node with the calculated digit as its value.
Attach the new node to the tail node of the result list.
Move the tail pointer to the newly added node.
Move to the next nodes in both l1 and l2, if they exist. If either list is exhausted, set the corresponding pointer to nullptr.
After the loop, obtain the actual result list by skipping the dummyHead node.
Delete the dummyHead node.
Return the resulting list.

Identify the Key Entities
Example: BankAccount, Customer, Transaction
Decide Which Attributes Should Be Private
Account number, account holder name, balance → should not be directly accessible.
Provide Public Methods to Interact
Deposit money
Withdraw money
Check balance
Show account details
Add Validation Inside Methods
For example:
Don’t allow withdrawing more than balance
Don’t allow depositing negative amounts
Explain in Interviews
Emphasize:
Data is hidden (private)
Interaction is controlled (public methods)
This prevents errors and ensures security

Tip 1: Focus on core concepts like processes, threads, deadlocks, scheduling algorithms, memory management, and synchronization mechanisms.
Tip 2: Understand practical examples and watch videos for better clarity.
Tip 3: Practice solving OS-related questions from past placement interviews and make notes for revision.

Normalize the string (optional for case-insensitive check):
Convert all letters to lowercase.
Remove spaces or punctuation if needed.
Compare characters:
Compare the first character with the last character.
Compare the second character with the second-last character.
Continue until the middle of the string.
If all corresponding characters match, it is a palindrome.
Decide the result:
If all comparisons succeed → string is a palindrome.
If any comparison fails → string is not a palindrome.