├── 3Sum.cpp
├── CountAndSay.cpp
├── FavouriteGenre.cpp
├── KokoEatingBananas.cpp
├── LICENSE
├── LongestPalindromicSubstring.cpp
├── MergeIntervals.cpp
├── ProductofArrayExceptSelf.cpp
├── README.md
├── RemoveElement.cpp
├── RottenOranges.cpp
├── SearchSuggestionSystem.cpp
├── SortedArraytoBalancedBST.cpp
├── SurroundedRegions.cpp
├── TrappingRainwater.cpp
├── TwoSum.cpp
├── UniquePathsII.cpp
├── ValidAnagram.cpp
└── WordBreak.cpp


/3Sum.cpp:
--------------------------------------------------------------------------------
 1 | vector<vector<int>> threeSum(vector<int>& nums) {
 2 |         int n = nums.size();
 3 |         if(n < 3) return {};
 4 |         vector<vector<int>> result;
 5 |         sort(nums.begin(), nums.end());
 6 |         for(int i = 0; i < n-2; ++i){
 7 |             if(i == 0 || nums[i] != nums[i-1]){
 8 |                 int j = i + 1, k = n-1;
 9 |                 while(j < k){
10 |                     int sum = nums[i] + nums[j] + nums[k];
11 |                     if(sum == 0){
12 |                         result.push_back({nums[i], nums[j], nums[k]});
13 |                         while(j < k && nums[j] == nums[j+1]) j++;
14 |                         while(j < k && nums[k] == nums[k-1]) k--;
15 |                         j++; k--;
16 |                     }
17 |                     else if (sum > 0) k--;
18 |                     else j++;
19 |                 }
20 |             }
21 |         }
22 |         return result;
23 |     }
24 |     
25 |     //LeetCode Link: https://leetcode.com/problems/3sum/
26 |     //Space Complexity: O(n)
27 |     //Time: O(n^2)
28 |     //Intuition: Fix ith element and apply two sum logic from i+1(j) to n-1(k) and when nums[i]+nums[j]+nums[k]==0, append it to the list. 
29 |     //Make sure that if duplicate elements occur, skip them.
30 | 


--------------------------------------------------------------------------------
/CountAndSay.cpp:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 | public:
 3 |     string countAndSay(int n) {
 4 |         vector<string>res(n+1);
 5 |         res[0]="1";
 6 |         res[1]="11";
 7 |         
 8 |         for(int i=2;i<=n;i++)
 9 |         {
10 |             string pre=res[i-1];
11 |             string temp = "";
12 |             for(int j=0;j<pre.length();j++)
13 |             {
14 |                 int count=1;
15 |                 while(j<pre.length()-1 && pre[j]==pre[j+1])
16 |                 {
17 |                     count++; j++;
18 |                 }
19 |                 temp+=to_string(count)+pre[j];
20 |             }
21 |             
22 |             res[i]=temp;
23 |         }
24 |         
25 |         return res[n-1];
26 |     }
27 | };
28 | 
29 | //LeetCode Link: https://leetcode.com/problems/count-and-say/
30 | //Time Complexity: O(n* m^2)
31 | 


--------------------------------------------------------------------------------
/FavouriteGenre.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | #include<unordered_map>
 3 | #include<map>
 4 | #include<string>
 5 | #include<vector>
 6 | #include<iostream>
 7 | 
 8 | using namespace std;
 9 | 
10 | map<string, vector<string>> getUserFavouriteGenres(map<string, vector<string>> userSongs, map<string, vector<string>> songGenres){
11 | 	map<string, vector<string>> userFavGenres;
12 | 
13 | 	map<string, string> songToGenre; // maps the song name to its genre
14 | 	for (auto it = songGenres.begin(); it != songGenres.end(); ++it){
15 | 		string genre = it->first;
16 | 		vector<string> songs = it->second;
17 | 
18 | 		for (string song : songs){
19 | 			songToGenre[song] = genre;
20 | 		}
21 | 	}
22 | 
23 | 	for (auto it = userSongs.begin(); it != userSongs.end(); ++it){
24 | 		string user = it->first;
25 | 		vector<string> userFavSongs = it->second;
26 | 		unordered_map<string, int> songGenresCount;
27 | 		int maxCount = 0;
28 | 		for (string song : userFavSongs){
29 | 			string songGenre = songToGenre[song];
30 | 			songGenresCount[songGenre]++;
31 | 			maxCount = max(maxCount, songGenresCount[songGenre]);
32 | 		}
33 | 
34 | 		for (auto ii = songGenresCount.begin(); ii != songGenresCount.end(); ++ii){
35 | 			if(ii->second == maxCount){
36 | 				if(userFavGenres.find(user) == userFavGenres.end())
37 | 					userFavGenres[user] = {};
38 | 				userFavGenres[user].push_back(ii->first);		
39 | 			}
40 | 		}
41 | 	}
42 | 	return userFavGenres;
43 | }
44 | 
45 | int main(void){
46 | 	map<string, vector<string>> userSongs;
47 | 	map<string, vector<string>> songGenres;
48 | 
49 | 	userSongs["David"] = {"song1", "song2", "song3", "song4", "song8"};
50 | 	userSongs["Emma"] = {"song5", "song6", "song7"};
51 | 
52 | 	songGenres["Rock"] = {"song1", "song3"};
53 | 	songGenres["Dubstep"] = {"song7"};
54 | 	songGenres["Techno"] = {"song2", "song4"};
55 | 	songGenres["Pop"] = {"song5", "song6"};
56 | 	songGenres["Jazz"] = {"song8", "song9"};
57 | 
58 | 	map<string, vector<string>> result = getUserFavouriteGenres(userSongs, songGenres);
59 | 	for (auto it = result.begin(); it != result.end(); ++it){
60 | 		cout << it->first << ": ";
61 | 		for (string g : it->second){
62 | 			cout << g << ", ";
63 | 		}
64 | 		cout << endl;
65 | 	}
66 | 
67 | 	return 0;
68 | }
69 | 


--------------------------------------------------------------------------------
/KokoEatingBananas.cpp:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 | public:
 3 |     
 4 |     bool canEatInTime(vector<int>& piles, int K, int H)
 5 |     {
 6 |         int hours=0;
 7 |         for(int i=0;i<piles.size();i++)
 8 |         {
 9 |             int div=piles[i]/K;
10 |             hours+=div;
11 |             if(piles[i]%K)
12 |             {
13 |                 hours++;
14 |             }
15 |         }
16 |         
17 |         return hours<=H;
18 |     }
19 |     int minEatingSpeed(vector<int>& piles, int H) {
20 |         int left=1, right=*max_element(piles.begin(), piles.end());
21 |         while(left<=right)
22 |         {
23 |             int mid=left+(right-left)/2;
24 |             if(canEatInTime(piles, mid, H))
25 |             {
26 |                 right=mid-1;
27 |             }
28 |             else
29 |             {
30 |                 left=mid+1;
31 |             }
32 |         }
33 |             return left;
34 |         
35 |     }
36 | };
37 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2020 Shreya Prasad
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/LongestPalindromicSubstring.cpp:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 | public:
 3 |     string longestPalindrome(string s) {
 4 |         
 5 |         if(s.length()<1)
 6 |         {
 7 |             return "";
 8 |         }
 9 |         
10 |         int start=0, end=0;
11 |         
12 |         for(int i=0;i<s.length();i++)
13 |         {
14 |             int len1 = expandAroundCenter(s,i, i);
15 |             int len2 = expandAroundCenter(s,i, i+1);
16 |             int len = max(len1, len2);
17 |             
18 |             if(len > end - start)
19 |             {
20 |                 start = i - (len-1)/2;
21 |                 end=i+len/2;
22 |             }
23 |         }
24 |         
25 |         return s.substr(start,end+1-start);
26 |     }
27 |     
28 |     int expandAroundCenter(string s, int left, int right)
29 |     {
30 |         int L=left, R=right;
31 |         while(L>=0 && R <s.length() && s[L]==s[R])
32 |         {
33 |             L--; R++;
34 |         }
35 |         return R-L-1;
36 |     }
37 | };
38 | 


--------------------------------------------------------------------------------
/MergeIntervals.cpp:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public:
 3 |     vector<vector> merge(vector<vector>& intervals) {
 4 |     //base case
 5 |         if(intervals.size()==0) return {};
 6 |         
 7 |      //main code   
 8 |         sort(intervals.begin(),intervals.end());
 9 |         
10 |         vector temp=intervals[0];
11 |         vector<vector> res;
12 |         for(int i=1; i<intervals.size(); i++)
13 |       {
14 |        
15 |         if(intervals[i][0]<=temp[1])
16 |         {
17 |                 temp[1]=max(intervals[i][1],temp[1]);
18 |         }
19 |         else
20 |         {
21 |          res.push_back(temp);
22 |          temp=intervals[i];
23 |           }
24 |       }
25 |     res.push_back(temp);
26 |     return res;
27 |     }
28 | };
29 | 


--------------------------------------------------------------------------------
/ProductofArrayExceptSelf.cpp:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 | public:
 3 |     vector<int> productExceptSelf(vector<int>& nums) {
 4 |         int n=nums.size();
 5 |         vector<int>right(n), left(n);
 6 |         right[0]=1;
 7 |         left[n-1]=1;
 8 |         
 9 |         for(int i=1;i<n;i++)
10 |         {
11 |             right[i]=nums[i-1]*right[i-1];
12 |         }
13 |         
14 |            for(int i=n-2;i>=0;i--)
15 |         {
16 |             left[i]=nums[i+1]*left[i+1];
17 |         }
18 |         
19 |         vector<int>ans(n);
20 |         
21 |         for(int i=0;i<n;i++)
22 |         {
23 |             ans[i]=right[i]*left[i];
24 |         }
25 |         
26 |         return ans;
27 |     }
28 | };
29 | 
30 | //Logic: Take two vectors right and left to store the product of all the array elements from start, up to that index and another array to store the product of all the array elements from the end of the array to that index.
31 | To get the product excluding that index, multiply the prefix product up to index i-1 with the suffix product up to index i+1.
32 | 
33 | //Time Complexity: O(n)
34 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Amazon-Interview-Questions
2 | 
3 | [How to Ace Amazon Behavioral Interview](https://leetcode.com/discuss/interview-experience/750054/how-to-ace-amazon-behavioral-interview)
4 | 


--------------------------------------------------------------------------------
/RemoveElement.cpp:
--------------------------------------------------------------------------------
 1 | //Method 1: Using STL
 2 | class Solution {
 3 | public:
 4 |     int removeElement(vector<int>& nums, int val) {
 5 |             nums.erase(remove(nums.begin(), nums.end(), val), nums.end());
 6 |         return nums.size();
 7 |     }
 8 | };
 9 | 
10 | //Method 2: Iteration
11 | 
12 | int removeElement(vector<int>& nums, int val) {
13 |         for(auto it=nums.begin();it!=nums.end();it++){
14 |             if(*it==val){
15 |                 nums.erase(it);
16 |                 --it;
17 |             }
18 |         }
19 |         return nums.size();
20 |     }
21 |     
22 |     
23 |  //Runtime: 4ms
24 |  //LeetCode: https://leetcode.com/problems/remove-element/
25 | 
26 | 


--------------------------------------------------------------------------------
/RottenOranges.cpp:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 | public:
 3 |     int orangesRotting(vector<vector<int>>& grid) {
 4 |         queue<pair<int, int>> rotten;
 5 |         int r = grid.size(), c = grid[0].size(), fresh = 0, t = 0;
 6 |         for(int i = 0; i < r; ++i){
 7 |             for(int j = 0; j < c; ++j){
 8 |                 if(grid[i][j] == 2) rotten.push({i, j});
 9 |                 else if(grid[i][j] == 1) fresh++;
10 |             }
11 |         }
12 |         
13 |         while(!rotten.empty()){
14 |             int num = rotten.size();
15 |             for(int i = 0; i < num; ++i){
16 |                 int x = rotten.front().first, y = rotten.front().second;
17 |                 rotten.pop();
18 |                 if(x > 0 && grid[x-1][y] == 1){ grid[x-1][y] = 2; fresh--; rotten.push({x-1, y});};
19 |                 if(y > 0 && grid[x][y-1] == 1){ grid[x][y-1] = 2; fresh--; rotten.push({x, y-1});};
20 |                 if(x < r-1 && grid[x+1][y] == 1){ grid[x+1][y] = 2; fresh--; rotten.push({x+1, y});};
21 |                 if(y < c-1 && grid[x][y+1] == 1){ grid[x][y+1] = 2; fresh--; rotten.push({x, y+1});};
22 |             }
23 |             if(!rotten.empty()) t++;
24 |         }
25 |         return (fresh == 0) ? t : -1;
26 |     }
27 | };
28 | 
29 | //Link: https://leetcode.com/problems/rotting-oranges/
30 | 


--------------------------------------------------------------------------------
/SearchSuggestionSystem.cpp:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 | public:
 3 |     vector<vector<string>> suggestedProducts(vector<string>& products, string searchWord) {
 4 |        sort(products.begin(),products.end());
 5 |        vector<vector<string>>ans;
 6 |        vector<string>mid_ans;
 7 |        string new_str="";
 8 |        int c=0; 
 9 |        for(int i=0;i<searchWord.size();i++)
10 |        {
11 |            new_str=new_str+searchWord[i];
12 |            c++;
13 |            int n=1;
14 |            for(int i=0;i<products.size();i++){
15 |                string cmp=products[i].substr(0,c);
16 |                if(cmp==new_str && n!=4){
17 |                    mid_ans.push_back(products[i]);
18 |                    n++;
19 |                }
20 |            }
21 |            ans.push_back(mid_ans);
22 |            mid_ans.clear();
23 |        }
24 |        
25 |         return ans;
26 |     }
27 | };
28 | 
29 | //LeetCode Link: https://leetcode.com/problems/search-suggestions-system/
30 | 


--------------------------------------------------------------------------------
/SortedArraytoBalancedBST.cpp:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 | public:
 3 |     
 4 |     TreeNode* arrToBST(vector<int>&nums, int start, int end)
 5 |     {
 6 |         if(start>end)
 7 |         {
 8 |             return NULL;
 9 |         }
10 |         
11 |         int mid= (start+end)/2;
12 |         
13 |         TreeNode* root = new TreeNode(nums[mid]);
14 |         
15 |          root->left = arrToBST(nums, start, mid-1);
16 |         root->right = arrToBST(nums,mid+1,end);
17 |         
18 |         return root;
19 |     }
20 |     
21 |     TreeNode* sortedArrayToBST(vector<int>& nums) {
22 |         
23 |         int n=nums.size()-1;
24 |         TreeNode* ans = arrToBST(nums, 0, n);
25 |         return ans;    
26 |     }
27 | };
28 | 


--------------------------------------------------------------------------------
/SurroundedRegions.cpp:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 | public:
 3 |     
 4 |     void floodFill(vector<vector<char>>& board,int x, int y, char prevV,char newV)
 5 |     {
 6 |           // Base cases 
 7 |     if (x < 0 || x >= board.size() || y < 0 || y >= board[0].size() || 
 8 |         board[x][y] != prevV) 
 9 |         return; 
10 |         
11 |   
12 |     // Replace the color at (x, y) 
13 |     board[x][y] = newV; 
14 |   
15 |     // Recur for north, east, south and west 
16 |     floodFill(board, x+1, y, prevV, newV); 
17 |     floodFill(board, x-1, y, prevV, newV); 
18 |     floodFill(board, x, y+1, prevV, newV); 
19 |     floodFill(board, x, y-1, prevV, newV); 
20 |     }
21 |     
22 |     void solve(vector<vector<char>>& board) {
23 |         if(board.empty())
24 |         {
25 |             return;
26 |         }
27 |         for(int i=0;i<board.size();i++)
28 |         {
29 |             for(int j=0;j<board[i].size();j++)
30 |             {
31 |                 if(board[i][j]=='O')
32 |                 {
33 |                     board[i][j]='-';
34 |                 }
35 |             }
36 |         }
37 |         
38 |         int row = board.size();
39 |         int col = board[0].size();
40 |         
41 |          // Call floodFill for all '-' lying on edges 
42 |    for (int i=0; i<row; i++)   // Left side 
43 |       if (board[i][0] == '-') 
44 |         floodFill(board, i, 0, '-', 'O'); 
45 |         
46 |    for (int i=0; i<row; i++)  //  Right side 
47 |       if (board[i][col-1] == '-') 
48 |         floodFill(board, i, col-1, '-', 'O'); 
49 |         
50 |    for (int i=0; i<col; i++)   // Top side 
51 |       if (board[0][i] == '-') 
52 |         floodFill(board, 0, i, '-', 'O'); 
53 |         
54 |    for (int i=0; i<col; i++)  // Bottom side 
55 |       if (board[row-1][i] == '-') 
56 |         floodFill(board, row-1, i, '-', 'O'); 
57 |   
58 |  
59 |    for (int i=0; i<row; i++) 
60 |       for (int j=0; j<col; j++) 
61 |          if (board[i][j] == '-') 
62 |              board[i][j] = 'X'; 
63 |     }
64 | };
65 | 


--------------------------------------------------------------------------------
/TrappingRainwater.cpp:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 | public:
 3 |     int trap(vector<int>& height) {
 4 |         if(height.empty())
 5 |         {
 6 |             return 0;
 7 |         }
 8 |         
 9 |         int count=0;
10 |         int n=height.size();
11 |         vector<int>left(n);
12 |         vector<int>right(n);
13 |         
14 |         
15 |         left[0]=height[0];
16 |         right[n-1]=height[n-1];
17 |         
18 |         //max in right subarray
19 |         for(int i=1;i<height.size();i++)
20 |         {
21 |             left[i]=max(height[i], left[i-1]);
22 |         }
23 |         
24 |         for(int i=n-2;i>=0;i--)
25 |         {
26 |             right[i]=max(right[i+1], height[i]);
27 |         }
28 |         
29 |         for(int i=0;i<n-1;i++)
30 |         {
31 |             count+=(min(right[i], left[i]) - height[i]);
32 |         }
33 |          return count;
34 |     }
35 |     
36 | };
37 | 
38 | //Logic: Find minimum of maximum height on either side of every index. 
39 | //LeetCode Link: https://leetcode.com/problems/trapping-rain-water/
40 | //Runtime: O(n)
41 | 


--------------------------------------------------------------------------------
/TwoSum.cpp:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 | public:
 3 |     vector<int> twoSum(vector<int>& nums, int target) {
 4 |         vector<int>ans; int j=1;
 5 |         if(!nums.size())
 6 |             ans.push_back(0);
 7 |        
 8 |         unordered_map<int,int>M;
 9 |         int x;
10 |         for(int i =0; i<nums.size(); i++){
11 |             x = target-nums[i];
12 |             auto itr = M.find(x);         
13 |             if(itr != M.end()){
14 |                 ans.push_back(i);
15 |                 ans.push_back(itr->second);
16 |             }
17 |             M[nums[i]] = i;
18 |         }
19 |         return ans;
20 |     }
21 | };
22 | 
23 | //Time Complexity: O(n)
24 | //LeetCode Link: https://leetcode.com/problems/two-sum/
25 | 


--------------------------------------------------------------------------------
/UniquePathsII.cpp:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 | public:
 3 |     int uniquePathsWithObstacles(vector<vector<int> > &obstacleGrid) {
 4 |         int m = obstacleGrid.size() , n = obstacleGrid[0].size();
 5 |         vector<vector<int>> dp(m+1,vector<int>(n+1,0));
 6 |         dp[0][1] = 1;
 7 |         for(int i = 1 ; i <= m ; ++i)
 8 |             for(int j = 1 ; j <= n ; ++j)
 9 |                 if(!obstacleGrid[i-1][j-1])
10 |                     dp[i][j] = dp[i-1][j]+dp[i][j-1];
11 |         return dp[m][n];
12 |     }
13 | };
14 | 
15 | //Time Complexity: O(mn)
16 | //LeetCode Link:https://leetcode.com/problems/unique-paths-ii/
17 | 


--------------------------------------------------------------------------------
/ValidAnagram.cpp:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 | public:
 3 |     bool isAnagram(string s, string t) {
 4 |         if(s.length()!=t.length())
 5 |         {
 6 |             return false;
 7 |         }
 8 |         unordered_map<char,int>m;
 9 |         for(int i=0;i<s.length();i++)
10 |         {
11 |             m[s[i]]++; m[t[i]]--;
12 |         }
13 |        
14 |         for(auto it=m.begin();it!=m.end();it++)
15 |         {
16 |             if(it->second!=0)
17 |             {
18 |                return false; 
19 |             }
20 |         }
21 |         
22 |         return true;
23 |     }
24 | };
25 | 
26 | //Time Complexity: O(n)
27 | //Space Complexity: O(1) because the size of the hash table remains constant. It has a fixed value which is why space has O(1). 
28 | //If the size would have depended on input dynamically then space complexity would have been O(n). 
29 | 


--------------------------------------------------------------------------------
/WordBreak.cpp:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 | public:
 3 |    bool wordBreak(string s, vector<string>& wordDict) {
 4 |         set<string> st;
 5 |         for(auto v:wordDict){
 6 |             st.insert(v);
 7 |         }
 8 |         vector<int> dp(s.size()+1);
 9 |         for(int i=0;i<s.size();i++){
10 |             if(st.find(s.substr(0,i+1))!=st.end()){
11 |                 dp[i]=1;
12 |             }
13 |             else{
14 |                 dp[i]=0;
15 |                 for(int j=0;j<i;j++){
16 |                     string test = s.substr(j+1,i-j);
17 |                     if(dp[j]==1 && st.find(test)!=st.end()){
18 |                         dp[i]=1;
19 |                     }
20 |                 }
21 |             }
22 |         }
23 |         return dp[s.size()-1];
24 |     }
25 | };
26 | 


--------------------------------------------------------------------------------