Computer Networks

Python

  

1. What problem does reference counting fail to solve, and how does Python fix it?

Reference counting works by keeping track of how many variables are pointing to an object. When the count becomes zero, the object is removed from memory. This method is simple and fast, but it has one major problem – it cannot handle circular references.

A circular reference happens when two or more objects refer to each other. For example, Object A refers to Object B, and Object B refers back to Object A. Even if no other part of the program is using them, their reference count never becomes zero. Because of that, memory is not freed, and this creates a memory leak.

Python solves this problem by adding something called a garbage collector. In addition to reference counting, Python runs a background process that looks for groups of objects that are only referencing each other and are not being used anywhere else in the program. When it finds such unused circular objects, it safely removes them from memory.

So in short, reference counting alone cannot clean circular references, but Python fixes this by combining reference counting with an automatic garbage collection system.

2. What happens internally when you do: a = b = []

When you write:

a = b = []

Python does not create two different lists. It creates only one empty list in memory. Then both variables a and b are made to point to that same list.

Internally, Python first creates the list object. After that, it assigns the reference of that list to b, and then assigns the same reference to a. So both variables are pointing to the same memory location.

Because of this, if you change the list using one variable, the change will also appear in the other variable.

a = b = []

a.append(10)

print("a:", a)
print("b:", b)

3. Explain Python’s object model (everything is an object) and its impact.

In Python, everything is an object. Numbers, strings, lists, functions, and even classes are all objects stored in memory. When you create a variable, you are not storing the value directly – you are storing a reference to that object.

Every object has three things: identity (its memory location), type (like int, str, list), and value (actual data). For example, when you write a = 10, Python creates an integer object 10 and a points to it.

This model makes Python very flexible. You can pass functions as arguments, return them from other functions, and store them inside variables because they are also objects. It also affects how variables behave – especially with mutable objects like lists, where multiple variables can point to the same object and changes reflect everywhere.

Because of this design, Python stays simple, consistent, and powerful, but you must understand references to avoid confusion.

4. Why Are Sets Faster Than Lists for Membership Checks?

5. You are given a square matrix (n × n). Rotate the matrix 90 degrees clockwise, in place, meaning you should not use any extra matrix for the result.

When a file is very large, loading the whole file into memory at once can slow down your program or even crash it. So instead of reading everything together, we can read it step by step using a generator.

A generator reads one line at a time and gives it back only when needed. This way, memory usage stays low and the program runs smoothly even with very big files.

What happens here:

• The file is opened safely using with (so it closes automatically).
• It reads one line at a time.
• yield sends one line back instead of storing all lines in memory.

def read_large_file(file_path):
    with open(file_path, "r") as file:
        for line in file:
            yield line.strip()

for line in read_large_file("bigfile.txt"):
    print(line)

6. How does method resolution order (MRO) work?

class A:
    def show(self):
        print("A")

class B(A):
    def show(self):
        print("B")

class C(A):
    def show(self):
        print("C")

class D(B, C):
    pass

obj = D()
obj.show()

7. Difference between __new__ and __init__


__new__ and __init__ are both used when creating objects in Python, but they do different jobs.

__new__ is responsible for creating the object.
It is called first and returns a new instance of the class. This method is mainly used when you need control over object creation, such as in immutable objects.

__init__ is responsible for initializing the object.
It runs after __new__ and sets or modifies the object’s attributes.

class Example:
    def __new__(cls):
        print("__new__ called")
        return super().__new__(cls)

    def __init__(self):
        print("__init__ called")


obj = Example()

8. How would you debug a memory leak in Python production?

When a Python app keeps using more memory and does not release it, it may have a memory leak. The first step is to monitor memory usage using tools like top or cloud dashboards. If memory keeps increasing even with normal traffic, something is not being freed.

Then use tools like tracemalloc to see which part of the code is allocating memory. You can also check which objects are increasing over time.

Common reasons include growing global variables, caches that never clear, large lists or dictionaries that keep adding data, and circular references. If needed, check the garbage collector using the gc module.

In practice, reproduce the issue in staging, track memory usage step by step, find what keeps growing, and fix the root cause.

9. What is __slots__ and why would Amazon use it?

10. Difference between shallow copy and deep copy.

When we use a dictionary in Python, we access values using square brackets like data[key].
This works because dictionaries internally use special methods like __getitem__ and __setitem__.
We can create our own class and implement these methods to make it behave like a dictionary.

Dsa

  

1. Given a string, write a program to find the length of the longest substring that does not contain any repeating characters.

To solve this problem, we use the sliding window technique.
We keep two pointers to track the current substring and use an array (or map) to remember the last position of each character.
If we see a repeated character, we move the left pointer forward to remove the duplicate from the window.

This way, we scan the string only once and keep updating the maximum length.

#include <iostream>
#include <vector>
#include <string>
using namespace std;

int lengthOfLongestSubstring(string s) {
    vector<int> lastIndex(256, -1);  // store last position of characters
    int maxLength = 0;
    int start = 0;  // left pointer of window

    for (int i = 0; i < s.length(); i++) {
        if (lastIndex[s[i]] >= start) {
            start = lastIndex[s[i]] + 1;  // move start after duplicate
        }

        lastIndex[s[i]] = i;  // update last seen index
        maxLength = max(maxLength, i - start + 1);
    }

    return maxLength;
}

int main() {
    string s = "abcabcbb";
    cout << "Length of longest substring: " 
         << lengthOfLongestSubstring(s) << endl;
    return 0;
}

2. Check if Parentheses Are Valid

To solve this, we use a stack.

When we see an opening bracket, we push it into the stack.
When we see a closing bracket, we check the top of the stack:

• If it matches, we remove (pop) it

• If it doesn’t match or the stack is empty, the string is not valid

At the end, if the stack is empty, it means all brackets were matched correctly.

#include <iostream>
#include <stack>
#include <string>
using namespace std;

bool isValid(string s) {
    stack<char> st;

    for (char ch : s) {
        if (ch == '(' || ch == '{' || ch == '[') {
            st.push(ch);
        } else {
            if (st.empty()) return false;

            char top = st.top();
            st.pop();

            if ((ch == ')' && top != '(') ||
                (ch == '}' && top != '{') ||
                (ch == ']' && top != '[')) {
                return false;
            }
        }
    }

    return st.empty();
}

int main() {
    string s = "{[()]}";
    
    if (isValid(s))
        cout << "Valid Parentheses" << endl;
    else
        cout << "Invalid Parentheses" << endl;

    return 0;
}

3. You are given two linked lists. Both lists are already sorted in increasing order. Write a function to merge them into one single sorted linked list and return the head of the new list.

Since both lists are already sorted, we don’t need to sort again.
We just compare the current nodes of both lists and always pick the smaller value. Then we move forward in that list.

We keep doing this until one list becomes empty. After that, we attach the remaining part of the other list.

This way, we build a new sorted list step by step.

#include <iostream>
using namespace std;

struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(NULL) {}
};

ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
    ListNode dummy(0);
    ListNode* tail = &dummy;

    while (l1 != NULL && l2 != NULL) {
        if (l1->val < l2->val) {
            tail->next = l1;
            l1 = l1->next;
        } else {
            tail->next = l2;
            l2 = l2->next;
        }
        tail = tail->next;
    }

    if (l1 != NULL)
        tail->next = l1;
    else
        tail->next = l2;

    return dummy.next;
}

// Helper function to print list
void printList(ListNode* head) {
    while (head != NULL) {
        cout << head->val << " ";
        head = head->next;
    }
}

int main() {
    // First list: 1 -> 3 -> 5
    ListNode* l1 = new ListNode(1);
    l1->next = new ListNode(3);
    l1->next->next = new ListNode(5);

    // Second list: 2 -> 4 -> 6
    ListNode* l2 = new ListNode(2);
    l2->next = new ListNode(4);
    l2->next->next = new ListNode(6);

    ListNode* merged = mergeTwoLists(l1, l2);

    printList(merged);

    return 0;
}

4. You are given a list of intervals, where each interval has a start and an end value. If any intervals overlap, merge them into a single interval and return the final list. Intervals that do not overlap should remain as they are.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

vector<vector<int>> mergeIntervals(vector<vector<int>>& intervals) {
    vector<vector<int>> result;

    if (intervals.empty())
        return result;

    sort(intervals.begin(), intervals.end());

    result.push_back(intervals[0]);

    for (int i = 1; i < intervals.size(); i++) {
        if (intervals[i][0] <= result.back()[1]) {
            result.back()[1] = max(result.back()[1], intervals[i][1]);
        } else {
            result.push_back(intervals[i]);
        }
    }

    return result;
}

int main() {
    vector<vector<int>> intervals = {{1,3}, {2,6}, {8,10}, {15,18}};

    vector<vector<int>> output = mergeIntervals(intervals);

    cout << "Input Intervals: ";
    for (auto &i : intervals)
        cout << "[" << i[0] << "," << i[1] << "] ";

    cout << "\nMerged Intervals: ";
    for (auto &i : output)
        cout << "[" << i[0] << "," << i[1] << "] ";

    return 0;
}

5. Find the Lowest Common Ancestor in a Binary Tree

In a binary tree, the Lowest Common Ancestor is the first node where both given nodes meet when coming up from the bottom.

The idea is simple:

• If the current node is null, return null.

• If the current node matches one of the given nodes, return it.

• Recursively check the left and right subtree.

• If both left and right return non-null values, then the current node is the LCA.

• If only one side returns a value, pass that value upward.

This works because we search both sides of the tree and stop at the first point where both nodes are found under the same parent.

#include <iostream>
using namespace std;

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
    if (root == NULL || root == p || root == q)
        return root;

    TreeNode* left = lowestCommonAncestor(root->left, p, q);
    TreeNode* right = lowestCommonAncestor(root->right, p, q);

    if (left != NULL && right != NULL)
        return root;

    return (left != NULL) ? left : right;
}

int main() {
    // Creating tree manually
    /*
            3
           / \
          5   1
         / \
        6   2
    */

    TreeNode* root = new TreeNode(3);
    root->left = new TreeNode(5);
    root->right = new TreeNode(1);
    root->left->left = new TreeNode(6);
    root->left->right = new TreeNode(2);

    int n1, n2;
    cout << "Enter two node values: ";
    cin >> n1 >> n2;

    // Finding nodes manually (simple search)
    TreeNode* p = root->left->left;   // node 6
    TreeNode* q = root->left->right;  // node 2

    TreeNode* lca = lowestCommonAncestor(root, p, q);

    if (lca != NULL)
        cout << "Lowest Common Ancestor: " << lca->val << endl;
    else
        cout << "Nodes not found in tree" << endl;

    return 0;
}

6. You are given a main string and a pattern string; find all starting indices in the main string where a substring is an anagram of the pattern. For example, if the string is "cbaebabacd" and the pattern is "abc", the output is [0, 6] because "cba" and "bac" are valid anagrams of "abc".

An anagram means the same characters with the same frequency but in a different order.
We slide a window of the same length as the pattern string across the main string and compare character counts.
Whenever the counts match, we store the starting index.

This approach is fast because we reuse previous calculations instead of checking from scratch every time.

#include <iostream>
#include <vector>
#include <string>
using namespace std;

vector<int> findAnagrams(string s, string p) {
    vector<int> result;
    if (s.size() < p.size()) return result;

    vector<int> countP(26, 0), countS(26, 0);

    for (char c : p)
        countP[c - 'a']++;

    int windowSize = p.size();

    for (int i = 0; i < s.size(); i++) {
        countS[s[i] - 'a']++;

        if (i >= windowSize)
            countS[s[i - windowSize] - 'a']--;

        if (countS == countP)
            result.push_back(i - windowSize + 1);
    }

    return result;
}

int main() {
    string s = "cbaebabacd";
    string p = "abc";

    vector<int> output = findAnagrams(s, p);

    cout << "Input String: " << s << endl;
    cout << "Pattern: " << p << endl;
    cout << "Output Indices: ";

    for (int index : output)
        cout << index << " ";

    return 0;
}

7. You are given an array of numbers and a target value. Find two different indices such that the numbers at those indices add up to the target, and return the indices.

Instead of checking every pair, we store numbers in a hash map while scanning the array.
For each number, we check if the remaining value (target − current number) already exists.
This gives a fast solution in one pass.

#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std;

vector<int> twoSum(vector<int>& nums, int target) {
    unordered_map<int, int> seen;

    for (int i = 0; i < nums.size(); i++) {
        int need = target - nums[i];
        if (seen.count(need))
            return {seen[need], i};
        seen[nums[i]] = i;
    }
    return {};
}

int main() {
    vector<int> nums = {2, 7, 11, 15};
    int target = 9;

    vector<int> result = twoSum(nums, target);

    cout << "Output: [" << result[0] << ", " << result[1] << "]";
    return 0;
}

8. You are given an array of integers and a number k. Count how many continuous subarrays have a total sum equal to k.

We use a prefix sum and a hash map.
As we move through the array, we store how many times a prefix sum has appeared.
If currentSum - k exists in the map, it means a subarray with sum k is found.

This avoids checking all subarrays and works in one pass.

#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std;

int subarraySum(vector<int>& nums, int k) {
    unordered_map<int, int> prefixCount;
    prefixCount[0] = 1;

    int sum = 0, count = 0;

    for (int num : nums) {
        sum += num;

        if (prefixCount.count(sum - k))
            count += prefixCount[sum - k];

        prefixCount[sum]++;
    }

    return count;
}

int main() {
    vector<int> nums = {1, 1, 1};
    int k = 2;

    cout << "Output: " << subarraySum(nums, k);
    return 0;
}

9. You are given an unsorted array of integers. Find the length of the longest sequence of consecutive numbers that appear in the array. The solution must run in O(n) time.

We put all numbers into a hash set so lookup is fast.
Then we only start counting when a number has no previous consecutive number (number − 1).
From there, we keep checking the next numbers until the sequence breaks.

Each number is processed once, so the solution stays linear.

#include <iostream>
#include <vector>
#include <unordered_set>
using namespace std;

int longestConsecutive(vector<int>& nums) {
    unordered_set<int> s(nums.begin(), nums.end());
    int longest = 0;

    for (int num : s) {
        if (!s.count(num - 1)) {
            int current = num;
            int length = 1;

            while (s.count(current + 1)) {
                current++;
                length++;
            }

            longest = max(longest, length);
        }
    }
    return longest;
}

int main() {
    vector<int> nums = {100, 4, 200, 1, 3, 2};

    cout << "Output: " << longestConsecutive(nums);
    return 0;
}

Database

  

1. How can you find duplicate orders placed by the same user within 5 minutes?

SELECT user_id,
       order_id,
       order_time,
       LAG(order_time) OVER (PARTITION BY user_id ORDER BY order_time) AS previous_order_time
FROM orders
HAVING TIMESTAMPDIFF(MINUTE, previous_order_time, order_time) <= 5;

2. How do you find orders where shipping time was longer than the average shipping time?

SELECT *
FROM orders
WHERE DATEDIFF(shipped_date, order_date) >
      (SELECT AVG(DATEDIFF(shipped_date, order_date)) FROM orders);

3. When would a subquery perform better than a JOIN?

In most real cases, JOIN is faster and more optimized. But sometimes a subquery
can perform better, especially when you only need a small filtered result
instead of combining full tables.

A subquery can be useful when:

• You only need a single value like MAX(), COUNT(), or AVG().
• You want to filter records first before comparing them.
• The inner query returns a small result set.
• The database optimizer handles the subquery efficiently.

Example:

SELECT *
FROM orders
WHERE user_id IN (
    SELECT user_id 
    FROM users 
    WHERE status = 'active'
);

Here, the subquery first finds active users. Then the outer query fetches
their orders. If the active user list is small, this can work efficiently.

4. Explain how indexes affect INSERT performance.

5. What is a deadlock in SQL? Give an example and explain how to fix it.

-- Transaction 1
BEGIN;
UPDATE accounts SET balance = balance - 100 WHERE id = 1;

-- Transaction 2
BEGIN;
UPDATE accounts SET balance = balance - 50 WHERE id = 2;

-- Now:
-- Transaction 1 tries to update id = 2
-- Transaction 2 tries to update id = 1
-- Both wait forever → Deadlock

6. What is the difference between Optimistic Locking and Pessimistic Locking?

7. What is the difference between Strong Consistency and Eventual Consistency? Where would Amazon use each?

8. How does Amazon manage very high numbers of write operations every second?