top-interview-qs-I

8. String to Integer (atoi) Implement the myAtoi(string s) function, which converts a string to a 32-bit signed integer (similar to C/C++'s atoi function). The algorithm for myAtoi(string s) is as follows: Read in and ignore any leading whitespace. Check if the next character (if not already at the end of the string) is '-' or '+'. Read this character in if it is either. This determines if the final result is negative or positive respectively. Assume the result is positive if neither is present. Read in next the characters until the next non-digit charcter or the end of the input is reached. The rest of the string is ignored. Convert these digits into an integer (i.e. "123" -> 123, "0032" -> 32). If no digits were read, then the integer is 0. Change the sign as necessary (from step 2). If the integer is out of the 32-bit signed integer range [-231, 231 - 1], then clamp the integer so that it remains in the range. Specifically, integers less than -231 should be clamped to -231, and integers greater than 231 - 1 should be clamped to 231 - 1. Return the integer as the final result. Note: Only the space character ' ' is considered a whitespace character. Do not ignore any characters other than the leading whitespace or the rest of the string after the digits.

'10' - '0' parses an integer string into an integer

350. Intersection of Two Arrays II Follow-Ups Given two integer arrays nums1 and nums2, return an array of their intersection. Each element in the result must appear as many times as it shows in both arrays and you may return the result in any order. 1. What if the given array is already sorted? How would you optimize your algorithm? 2. What if nums1's size is small compared to nums2's size? Which algorithm is better?

1. We can use either 2-pointer sorted approach 2. Hashset approach is good for

136. Single Number (Mathematical Method) Given a non-empty array of integers nums, every element appears twice except for one. Find that single one. You must implement a solution with a linear runtime complexity and use only constant extra space.

2∗(a+b+c)−(a+a+b+b+c)=c 2 * sum(set(nums)) - sum(nums) iterate through nums if it hasn't been seen, add it to the set sum return equation above Time complexity : O(n + n) = O(n)O(n+n)=O(n). sum will call next to iterate through \text{nums}nums. We can see it as sum(list(i, for i in nums)) which means the time complexity is O(n)O(n) because of the number of elements(nn) in \text{nums}nums. Space complexity : O(n + n) = O(n)O(n+n)=O(n). set needs space for the elements in nums

344. Reverse String (Recursion, In-Place, O(N) Space) Write a function that reverses a string. The input string is given as an array of characters s. Example 1: Input: s = ["h","e","l","l","o"] Output: ["o","l","l","e","h"] Example 2: Input: s = ["H","a","n","n","a","h"] Output: ["h","a","n","n","a","H"]

Base case: if left >= right, do nothing. Otherwise, swap s[left] and s[right] and call helper(left + 1, right - 1). To solve the problem, call helper function passing the head and tail indexes as arguments: return helper(0, len(s) - 1) Time complexity : O(n) Time to perform N/2 swaps. Space complexity : O(N) to keep the recursion stack.

169. Majority Element (Boyer Moore Approach) Given an array nums of size n, return the majority element. The majority element is the element that appears more than ⌊n / 2⌋ times. You may assume that the majority element always exists in the array. Example 1: Input: nums = [3,2,3] Output: 3 Example 2: Input: nums = [2,2,1,1,1,2,2] Output: 2

First - the "majority" element is one that appears more than half of the total elements. Otherwise this algorithim doesn't seem to work. The algorithm: iterate through each number. Keep track of a candidate and a count. Select the first element to be the candidate and start counting. Iterate, and if the next element is not a match, decrement. If the count reaches 0, swap the candidate for the current number. At the end, the remaining candidate should be the majority element.

350. Intersection of Two Arrays II (Hash approach) Given two integer arrays nums1 and nums2, return an array of their intersection. Each element in the result must appear as many times as it shows in both arrays and you may return the result in any order. Example 1: Input: nums1 = [1,2,2,1], nums2 = [2,2] Output: [2,2] Example 2: Input: nums1 = [4,9,5], nums2 = [9,4,9,8,4] Output: [4,9] Explanation: [9,4] is also accepted.

If nums1 is larger than nums2, swap the arrays. For each element in nums1: - Add it to the hash map m. - Increment the count if the element is already there. Initialize the insertion pointer (k) with zero. Iterate along nums2: If the current number is in the hash map and count is positive: - Copy the number into nums1[k], and increment k. - Decrement the count in the hash map. - Return first k elements of nums1. Return first k elements of nums1.

53. Maximum Subarray T: O(n) S: O(1) Given an integer array nums, find the contiguous subarray (containing at least one number) which has the largest sum and return its sum. A subarray is a contiguous part of an array. Example 1: Input: nums = [-2,1,-3,4,-1,2,1,-5,4] Output: 6 Explanation: [4,-1,2,1] has the largest sum = 6. Example 2: Input: nums = [1] Output: 1 Example 3: Input: nums = [5,4,-1,7,8] Output: 23

Initialize 2 integer variables. Set both of them equal to the first value in the array. - currentSubarray will keep the running count of the current subarray we are focusing on. - maxSubarray will be our final return value. Continuously update it whenever we find a bigger subarray. Iterate through the array, starting with the 2nd element (as we used the first element to initialize our variables). For each number, add it to the currentSubarray we are building. If currentSubarray becomes negative, we know it isn't worth keeping, so throw it away. Remember to update maxSubarray every time we find a new maximum. Return maxSubarray.

136. Single Number (Hash Method) Given a non-empty array of integers nums, every element appears twice except for one. Find that single one. You must implement a solution with a linear runtime complexity and use only constant extra space.

Iterate through numbers, keep frequency count or a set to track. Return the one value left in the set.

Random Pick Index Given an integer array nums with possible duplicates, randomly output the index of a given target number. You can assume that the given target number must exist in the array. Implement the Solution class: Solution(int[] nums) Initializes the object with the array nums. int pick(int target) Picks a random index i from nums where nums[i] == target. If there are multiple valid i's, then each index should have an equal probability of returning.

Observe closely how using a map with arrays as values.

70. Climbing Stairs ( with memo) You are climbing a staircase. It takes n steps to reach the top. Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top? Example 1: Input: n = 2 Output: 2 Explanation: There are two ways to climb to the top. 1. 1 step + 1 step 2. 2 steps

Secretly fibonnaci utilize a memo to store the results if the results don't exist, cache it.

344. Reverse String (Two Pointers, Iteration, O(1) Space) Write a function that reverses a string. The input string is given as an array of characters s. Example 1: Input: s = ["h","e","l","l","o"] Output: ["o","l","l","e","h"] Example 2: Input: s = ["H","a","n","n","a","h"] Output: ["h","a","n","n","a","H"]

Set pointer left at index 0, and pointer right at index n - 1, where n is a number of elements in the array. While left < right: - Swap s[left] and s[right]. - Move left pointer one step right, and right pointer one step left.

350. Intersection of Two Arrays II (Sort approach) Given two integer arrays nums1 and nums2, return an array of their intersection. Each element in the result must appear as many times as it shows in both arrays and you may return the result in any order. Example 1: Input: nums1 = [1,2,2,1], nums2 = [2,2] Output: [2,2] Example 2: Input: nums1 = [4,9,5], nums2 = [9,4,9,8,4] Output: [4,9] Explanation: [9,4] is also accepted.

Sort nums1 and nums2. Initialize i, j and k with zero. Move indices i along nums1, and j through nums2: - Increment i if nums1[i] is smaller. - Increment j if nums2[j] is smaller. - If numbers are the same, copy the number into nums1[k], and increment i, j and k. Return first k elements of nums1.

70. Climbing Stairs ( brute force ) You are climbing a staircase. It takes n steps to reach the top. Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top? Example 1: Input: n = 2 Output: 2 Explanation: There are two ways to climb to the top. 1. 1 step + 1 step 2. 2 steps

The approach is to recursively add 1 steps and 2 steps. Then check for base cases where the current step exceeds n and the base case when the current step matches n (step is like 1 or 0)

14. Longest Common Prefix T: O(n log n) approach Write a function to find the longest common prefix string amongst an array of strings. If there is no common prefix, return an empty string "". Example 1: Input: strs = ["flower","flow","flight"] Output: "fl" Example 2: Input: strs = ["dog","racecar","car"] Output: "" Explanation: There is no common prefix among the input strings. Constraints: 1 <= strs.length <= 200 0 <= strs[i].length <= 200 strs[i] consists of only lower-case English letters.

The thing is with js we can sort strings and when we sort an array of different strings they will be sorted alphabetically, which means all we left to do is find the common part between the first and the last values in the sorted array.

36. Valid Sudoku Determine if a 9 x 9 Sudoku board is valid. Only the filled cells need to be validated according to the following rules: Each row must contain the digits 1-9 without repetition. Each column must contain the digits 1-9 without repetition. Each of the nine 3 x 3 sub-boxes of the grid must contain the digits 1-9 without repetition. Note: A Sudoku board (partially filled) could be valid but is not necessarily solvable. Only the filled cells need to be validated according to the mentioned rules. Example 1: Input: board = [ ["5","3",".",".","7",".",".",".","."] , ["6",".",".","1","9","5",".",".","."] , [".","9","8",".",".",".",".","6","."] , ["8",".",".",".","6",".",".",".","3"] , ["4",".",".","8",".","3",".",".","1"] , ["7",".",".",".","2",".",".",".","6"] , [".","6",".",".",".",".","2","8","."] , [".",".",".","4","1","9",".",".","5"] , [".",".",".",".","8",".",".","7","9"] ] Output: true

This will require heavy iteration throughout all cells. The magic sauce here is the box algorithm. We go through each row and column and collect appearances with a hashset. If it contains a duplicate, return false. Additionally, we find sub-boxes in the 2d grid using a box algorithm.

658. Find K Closest Elements (Sort With Custom Comparator) Given a sorted integer array arr, two integers k and x, return the k closest integers to x in the array. The result should also be sorted in ascending order. An integer a is closer to x than an integer b if: |a - x| < |b - x|, or |a - x| == |b - x| and a < b Example 1: Input: arr = [1,2,3,4,5], k = 4, x = 3 Output: [1,2,3,4]

Time: O(n*log n) + k*log(k) due to sort in the beginning and sort at the end Space: O(n) Algorithm Create a new array sortedArr, that is arr sorted with a custom comparator. The comparator should be abs(x - num) for each num in arr. Sorting the array in ascending order means that the first k elements will be the k closest elements to x. We also have to sort the "sorted" array, since the problem wants our output in ascending order. Return the first k elements of sortedArr, sorted by value, in ascending order.

189. Rotate Array Space: O(n) approach Given an array, rotate the array to the right by k steps, where k is non-negative. Example 1: Input: nums = [1,2,3,4,5,6,7], k = 3 Output: [5,6,7,1,2,3,4] Explanation: rotate 1 steps to the right: [7,1,2,3,4,5,6] rotate 2 steps to the right: [6,7,1,2,3,4,5] rotate 3 steps to the right: [5,6,7,1,2,3,4]

Use modulo and an extra array

680. Valid Palindrome II Given a string s, return true if the s can be palindrome after deleting at most one character from it. Example 1: Input: s = "aba" Output: true Example 2: Input: s = "abca" Output: true Explanation: You could delete the character 'c'.

Use two pointers, one initialized to 0 and the other initialized to end of string. Check if characters at each index are the same. If they are the same, shrink both pointers. Else, we have two possibilities: one that neglects character at left pointer and the other that neglects character at right pointer. Hence, we check if s[low+1...right] is a palindrome or s[low...right-1] is a palindrome. If one of them is a palindrome, we know that we can form a palindrome with one deletion and return true. Else, we require more than one deletion, and hence we return false.

7. Reverse Integer Given a signed 32-bit integer x, return x with its digits reversed. If reversing x causes the value to go outside the signed 32-bit integer range [-2^31, 2^31 - 1], then return 0. Assume the environment does not allow you to store 64-bit integers (signed or unsigned). Example 1: Input: x = 123 Output: 321 Example 2: Input: x = -123 Output: -321

have stack at 0 to represent the final number pop the last digit using division / modulo technique check for overflow as we pop digits push digit onto stack with multiplciation for negative numbers, track it immediately

14. Longest Common Prefix T: O(n-ish approach) approach Write a function to find the longest common prefix string amongst an array of strings. If there is no common prefix, return an empty string "". Example 1: Input: strs = ["flower","flow","flight"] Output: "fl" Example 2: Input: strs = ["dog","racecar","car"] Output: "" Explanation: There is no common prefix among the input strings. Constraints: 1 <= strs.length <= 200 0 <= strs[i].length <= 200 strs[i] consists of only lower-case English letters.

iterate through each character in first string each iteration step scan if character is common between all if a character is not common, immediately return the slice(0,i) for the prefix

283. Move Zeroes Given an integer array nums, move all 0's to the end of it while maintaining the relative order of the non-zero elements. Note that you must do this in-place without making a copy of the array. Example 1: Input: nums = [0,1,0,3,12] Output: [1,3,12,0,0]

keep two pointers first pointer goes through nums. second pointer tracks the final moved positions. when current element is not zero, use second pointer to find a zero and swap. Important : we keep a variable for tracking the number of swaps or zeroes. trick is...after iterating through nums with first pointer, the second pointer's final location is where the zero's should begin so have to fill the rest of nums array with xeros

125. Valid Palindrome (character code approach) Given a string s, determine if it is a palindrome, considering only alphanumeric characters and ignoring cases. Example 1: Input: s = "A man, a plan, a canal: Panama" Output: true Explanation: "amanaplanacanalpanama" is a palindrome.

let code = s.charCodeAt(idx) let isNumeric = code > 47 && code < 58 let isAlpha = (code > 64 && code < 91) || (code > 96 && code < 123)

263. Ugly Number An ugly number is a positive integer whose prime factors are limited to 2, 3, and 5. Given an integer n, return true if n is an ugly number. Example 1: Input: n = 6 Output: true Explanation: 6 = 2 × 3

take each of the prime factors keep reducing the target number until it's no longer divisible by prime factor return if it's equal to 1

53. Maximum Subarray T: O(n log n) S: O(log n) Given an integer array nums, find the contiguous subarray (containing at least one number) which has the largest sum and return its sum. A subarray is a contiguous part of an array. Example 1: Input: nums = [-2,1,-3,4,-1,2,1,-5,4] Output: 6 Explanation: [4,-1,2,1] has the largest sum = 6. Example 2: Input: nums = [1] Output: 1 Example 3: Input: nums = [5,4,-1,7,8] Output: 23

we split the array in half find the best sum in both sides find the max sum between combined sums against best left and half sums