Tip 1: Must solve standard DSA
Tip 2: Minimum of 2 good projects on your resume
Tip 3: Solve LLDs for the system design round
Tip 1: 0+ years of Experience
Tip 2: Impactable Work and Technology Independent
The round focused on Data Structures and Algorithms. It was conducted in the evening, from 5 to 6 PM. Strong DSA skills are essential, as the questions were challenging despite being based on simple topics. The environment was professional, and the interviewer maintained a focused and engaging approach.



Given a string `num` representing a non-negative integer and an integer `k`, remove `k` digits from `num` to create the smallest possible integer.
The resulting number should not have leading zeroes. If the resulting number is empty, return `"0"`.
**Examples:**
1. **Input:**
`num = "1432219", k = 3`
**Output:**
`"1219"`
**Explanation:**
Remove the digits `4`, `3`, and `2` to form the new number `1219`, which is the smallest.
2. **Input:**
`num = "10200", k = 1`
**Output:**
`"200"`
**Explanation:**
Remove the leading `1`. The result must not contain leading zeroes.
3. **Input:**
`num = "10", k = 2`
**Output:**
`"0"`
**Explanation:**
Remove all digits, leaving no number. Hence, the result is `"0"`.
A stack is employed to facilitate the greedy decision-making process:
We traverse each digit of num and compare it with the top of the stack (the most recent digit we've chosen to keep).
If the current digit is smaller than the top of the stack and we still have removals (k > 0) remaining, we pop digits from the stack until a suitable position for the current digit is found.
This stack-based approach allows us to maintain the order of digits while dynamically removing larger, less significant digits to form the smallest possible number.


Given an integer array nums, reorder it such that nums[0] < nums[1] > nums[2] < nums[3]....
You may assume the input array always has a valid answer.
Example 1:
Input: nums = [1,5,1,1,6,4]
Output: [1,6,1,5,1,4]
Explanation: [1,4,1,5,1,6] is also accepted.
Example 2:
Input: nums = [1,3,2,2,3,1]
Output: [2,3,1,3,1,2]
By sorting the array, we can easily place smaller numbers in the even positions and larger numbers in the odd positions. This ensures that the wiggle property is satisfied: numbers at odd positions are greater than their neighbors and numbers at even positions are smaller. The key is to rearrange the array by alternating between the two halves of the sorted array.
This round was entirely focused on Low-Level Design (LLD) and System Design, emphasizing problem-solving and designing scalable systems. It was conducted by a CTO-level person from the company. The timing was in the evening slot, between 4-8 PM. The environment was professional and engaging, with a strong focus on understanding design principles and thought processes.
Design the Low Level Design for URL Shortening.
Tip 1: Be prepared to handle synchronous calls effectively in your design.
Tip 2: Focus on optimizing memory usage while implementing the solution.
Tip 3: Ensure efficient caching mechanisms and avoid generating new URLs for already shortened ones.

Here's your problem of the day
Solving this problem will increase your chance to get selected in this company
What is recursion?