Add files via upload

Author: adityajamwal02

BinarySubarrayWithSum.cpp

@@ -0,0 +1,74 @@
+/*
+Given a binary array arr of size N and an integer target, return the number of non-empty subarrays with a sum equal to target.
+Note : A subarray is the contiguous part of the array.
+
+Example 1:
+Input:
+N = 5
+target = 2
+arr[ ] = {1, 0, 1, 0, 1}
+Output: 4
+Explanation: The 4 subarrays are:
+{1, 0, 1, _, _}
+{1, 0, 1, 0, _}
+{_, 0, 1, 0, 1}
+{_, _, 1, 0, 1}
+
+Example 2:
+Input:
+N = 5
+target = 5
+arr[ ] = {1, 1, 0, 1, 1}
+Output: 0
+Explanation: There is no subarray with sum equal to target.
+
+Your Task:
+You don't need to read input or print anything. Your task is to complete the function numberOfSubarrays() which takes the array arr, interger N and an integer target as input and returns the number of subarrays with a sum equal to target.
+
+Expected Time Complexity: O(N).
+Expected Auxiliary Space: O(1).
+*/
+
+/// Hashmap Solution
+
+class Solution {
+public:
+    int numSubarraysWithSum(vector<int>& nums, int goal) {
+        long long n=nums.size(), counter=0, prefixSum=0;
+        long long presum[n+1];
+        for(int i=0;i<n+1;i++){
+            presum[i]=0;
+        }
+        for(int i=0;i<n;i++){
+            prefixSum+=nums[i];
+            int leftover=prefixSum-goal;
+            if(leftover>=0) counter+=presum[leftover];
+            if(prefixSum==goal) counter++;
+            presum[prefixSum]+=1;
+        }
+    return counter;
+    }
+};
+
+/// Sliding Window Approach (IDEA: get atmostsum (sum<=goal) and then remove sum<goal)
+
+class Solution {
+public:
+    int atmostSubarray(vector<int> &nums, int target){
+        if(target<0) return 0;
+        int i=0, j=0, result=0, sum=0, n=nums.size();
+        while(j<n){
+            sum+=nums[j];
+            while(sum>target){
+                sum-=nums[i];
+                i++;
+            }
+            result+=(j-i+1);
+        j++;
+        }
+    return result;
+    }
+    int numSubarraysWithSum(vector<int>& nums, int goal) {
+        return atmostSubarray(nums,goal)-atmostSubarray(nums,goal-1);
+    }
+};

BinarySubarraysWithSum.cpp

@@ -0,0 +1,64 @@
+/*
+Given a binary array nums and an integer goal, return the number of non-empty subarrays with a sum goal.
+A subarray is a contiguous part of the array.
+
+Example 1:
+Input: nums = [1,0,1,0,1], goal = 2
+Output: 4
+Explanation: The 4 subarrays are bolded and underlined below:
+[1,0,1,0,1]
+[1,0,1,0,1]
+[1,0,1,0,1]
+[1,0,1,0,1]
+
+Example 2:
+Input: nums = [0,0,0,0,0], goal = 0
+Output: 15
+Output: 15
+*/
+
+
+class Solution {
+public:
+    int numSubarraysWithSum(vector<int>& nums, int goal) {
+        long long n=nums.size(), counter=0, prefixSum=0;
+        long long presum[n+1];
+        for(int i=0;i<n+1;i++){
+            presum[i]=0;
+        }
+        for(int i=0;i<n;i++){
+            prefixSum+=nums[i];
+            int leftover=prefixSum-goal;
+            if(leftover>=0) counter+=presum[leftover];
+            if(prefixSum==goal) counter++;
+            presum[prefixSum]+=1;
+        }
+    return counter;
+    }
+};
+
+
+/// Sliding Window
+
+class Solution {
+public:
+    int atmostSubarray(vector<int> &nums, int target){
+        if(target<0) return 0;
+        int i=0, j=0, result=0, sum=0, n=nums.size();
+        while(j<n){
+            sum+=nums[j];
+            while(sum>goal){
+                sum-=nums[i];
+                i++;
+            }
+            result+=(j-i+1);
+        j++;
+        }
+    return result;
+    }
+    int numSubarraysWithSum(vector<int>& nums, int goal) {
+        return atmostSubarray(nums,goal)-atmostSubarray(nums,goals-1);
+    }
+};
+
+

CountSubarraysWithMedianK.cpp

@@ -0,0 +1,43 @@
+/*
+You are given an array nums of size n consisting of distinct integers from 1 to n and a positive integer k.
+Return the number of non-empty subarrays in nums that have a median equal to k.
+Note:
+The median of an array is the middle element after sorting the array in ascending order. If the array is of even length, the median is the left middle element.
+For example, the median of [2,3,1,4] is 2, and the median of [8,4,3,5,1] is 4.
+A subarray is a contiguous part of an array.
+
+Example 1:
+Input: nums = [3,2,1,4,5], k = 4
+Output: 3
+Explanation: The subarrays that have a median equal to 4 are: [4], [4,5] and [1,4,5].
+
+Example 2:
+Input: nums = [2,3,1], k = 3
+Output: 1
+Explanation: [3] is the only subarray that has a median equal to 3.
+*/
+
+/// Prefix Sum + Hashmap
+
+class Solution {
+public:
+    int countSubarrays(vector<int>& nums, int k) {
+        int counter=0, found=0, sum=0;
+        unordered_map<int,int> mp;
+        mp[0]=1;
+        for(auto num : nums){
+            if(num==k) found=1;
+            else{
+                if(num<k){
+                    sum+=-1;
+                }else{
+                    sum+=1;
+                }
+            }
+            if(found) counter+=mp[sum-1]+mp[sum];
+            else mp[sum]++;
+        }
+    return counter;
+    }
+};
+

CountingBits.cpp

@@ -0,0 +1,49 @@
+/*
+Given an integer n, return an array ans of length n + 1 such that for each i (0 <= i <= n), ans[i] is the number of 1's in the binary representation of i.
+
+Example 1:
+Input: n = 2
+Output: [0,1,1]
+Explanation:
+0 --> 0
+1 --> 1
+2 --> 10
+
+Example 2:
+Input: n = 5
+Output: [0,1,1,2,1,2]
+Explanation:
+0 --> 0
+1 --> 1
+2 --> 10
+3 --> 11
+4 --> 100
+5 --> 101
+
+Constraints:
+0 <= n <= 105
+*/
+
+class Solution {
+public:
+    vector<int> countBits(int n) {
+        vector<int> result;
+        for(int i=0;i<=n;i++){
+            int counter=__builtin_popcount(i);
+            result.push_back(counter);
+        }
+    return result;
+    }
+};
+
+/// Optimal : DP + O(N)
+
+class Solution {
+public:
+    vector<int> countBits(int num) {
+        vector<int> result(num+1, 0);
+        for (int i = 1; i <= num; ++i)
+            result[i] = result[i&(i-1)] + 1;
+        return result;
+    }
+};

ExcelSheetColumnTitle.cpp

@@ -0,0 +1,40 @@
+/*
+Given an integer columnNumber, return its corresponding column title as it appears in an Excel sheet.
+For example:
+
+A -> 1
+B -> 2
+C -> 3
+...
+Z -> 26
+AA -> 27
+AB -> 28
+...
+
+Example 1:
+Input: columnNumber = 1
+Output: "A"
+
+Example 2:
+Input: columnNumber = 28
+Output: "AB"
+
+Example 3:
+Input: columnNumber = 701
+Output: "ZY"
+*/
+
+class Solution {
+public:
+    string convertToTitle(int columnNumber) {
+        string result;
+        while(columnNumber>0){
+            columnNumber--;
+            int curr=columnNumber%26;
+            columnNumber/=26;
+            result.push_back(curr+'A');
+        }
+        reverse(result.begin(),result.end());
+    return result;
+    }
+};