SonamPrasad

_zeros.cpp

@@ -0,0 +1,24 @@
+class Solution {
+public:
+    void moveZeroes(vector<int>& nums) {
+        int size = nums.size();
+        int countzero = 0;
+        for(int i = 0; i < size; i++){
+            if(nums[i] == 0){
+                countzero++;
+            }
+        }
+        vector<int> sorted;
+        for(int i = 0; i < size; i++){
+            if(nums[i] != 0){
+                sorted.push_back(nums[i]);
+            }
+        }
+        while(countzero--){
+            sorted.push_back(0);
+        }
+        for(int i = 0; i < size; i++){
+            nums[i] = sorted[i];
+        }
+    }
+};

count_negativenos.cpp

@@ -0,0 +1,20 @@
+class Solution {
+public:
+    int countNegatives(vector<vector<int>>& grid) {
+      int result=0;
+      int i=0;
+      int x=grid.size();
+      int j=grid[0].size()-1;
+      while(i<x&&j>=0)
+      {
+         if(grid[i][j]>=0)
+           i++;
+         else
+         {
+           result=result+x-i;
+           j--;  
+         }
+      }
+        return result;
+    }
+};

duplicate_sorted_array.cpp

@@ -0,0 +1,16 @@
+
+class Solution {
+public:
+    int removeDuplicates(vector<int>& nums) {
+        int curr = 0, left = 0, right = nums.size();
+        while( left < right )
+        {
+            while( left < right && nums[curr] == nums[left] )
+                ++left;
+            if( left < right && nums[curr] != nums[left] )
+                nums[curr+1] = nums[left];
+            ++curr;
+        }
+        return curr;
+    }
+};

longest_string.cpp

@@ -0,0 +1,22 @@
+class Solution {
+public:
+    int lengthOfLongestSubstring(string s) {
+        int str[CHAR_MAX];
+        for(int i = 0; i < CHAR_MAX; i++)
+            str[i] = -1;
+
+        size_t slength = s.length();
+        int maxlength = 0;
+        int start = 0;
+        for(int i = 0; i < slength; i++) {
+            if(str[s[i]] == -1)
+                str[s[i]] = i;
+            else {
+                start = max(str[s[i]] + 1, start);
+                str[s[i]] = i;
+            }
+            maxlength = max(maxlength, i-start+1);
+        }
+        return maxlength;
+    }
+};

maximum_subarray.cpp

@@ -0,0 +1,21 @@
+class Solution {
+public:
+    int maxSubArray(vector<int>& nums) {
+        int size=nums.size();
+        int maxlength=nums[0];
+        int arr[size];
+        arr[0]=nums[0];
+        for(int i=1;i<size;i++){
+            if(arr[i-1]>0){
+                arr[i]=arr[i-1]+nums[i];
+            }
+            else{
+                arr[i]=nums[i];
+            }
+            if(arr[i]>maxlength){
+                maxlength=arr[i];
+            }
+        }
+        return maxlength;
+    }
+};

missing_no.cpp

@@ -0,0 +1,12 @@
+class Solution {
+public:
+    int missingNumber(vector<int>& nums) {
+        int n1=0,n2=0;
+       for(int i=0;i<nums.size();i++) 
+       {
+          n1+=nums[i];
+          n2+=i+1;
+       }
+        return n2-n1;
+    }
+};

monotonic_array.cpp

@@ -0,0 +1,24 @@
+class Solution {
+public:
+
+    bool isMonotonicIncreasing(vector<int>& A){
+        for(int i = 0; i < A.size()-1; i++){
+            if(A[i] > A[i+1]){
+                return false;
+            }
+        }
+        return true;
+    }
+    bool isMonotonicDecreasing(vector<int>& A){
+        for(int i = 0; i < A.size()-1; i++){
+            if(A[i] < A[i+1]){
+                return false;
+            }
+        }
+        return true;
+    } 
+
+    bool isMonotonic(vector<int>& A) {
+        return isMonotonicIncreasing(A) || isMonotonicDecreasing(A);
+    }
+};

palindrome.cpp

@@ -0,0 +1,34 @@
+class Solution {
+public:
+    bool isPalindrome(string s) {
+      int l = 0, h = s.length()-1; 
+
+
+    for (int i = 0; i <= h; i++) 
+        s[i] = tolower(s[i]); 
+
+
+    while (l < h) 
+    { 
+
+
+        while( !((s[l] >= 'a' && s[l] <= 'z') || (s[l] >='0' && s[l] <= '9')) && l < h){
+            //cout << "s[l] : " << s[l] << endl;
+            l++; 
+        }
+
+        while( !((s[h] >= 'a' && s[h] <= 'z') || (s[h] >='0'&& s[h] <= '9')) && l < h){
+            h--; 
+        } 
+
+        if (s[l] != s[h]) {
+           //cout << s[l] << " " << " l:" << l << " " << s[h] << endl;
+           return false;
+        }
+        cout << s[l] << " " << " l:" << l << " " << s[h] << endl;
+       l++;
+       h--; 
+    }   
+    return true;
+    }
+};

pivote_index.cpp

@@ -0,0 +1,21 @@
+class Solution {
+public:
+    int pivotIndex(vector<int>& nums) {
+        int leftsum, rightsum;
+        int totalsum = 0;
+        for(int i = 0; i < nums.size(); i++){
+            totalsum += nums[i];
+        }
+        for(int i = 0; i < nums.size(); i++){
+            leftsum = 0;
+            for(int j = 0; j < i; j++){
+                leftsum += nums[j];
+            }
+            rightsum = totalsum - leftsum - nums[i]; 
+            if(leftsum == rightsum){
+                return i;
+            }
+        }
+        return -1;
+    }
+};

product_of_array.cpp

@@ -0,0 +1,21 @@
+class Solution {
+public:
+    vector<int> productExceptSelf(vector<int>& nums) {
+        int size = nums.size();
+        vector<int> left(size);
+        vector<int> right(size);
+        vector<int> finalans(size);
+        left[0] = 1;
+        for(int i = 1; i < size; i++ ){
+            left[i] = nums[i-1]*left[i-1];
+        }
+        right[size - 1]= 1;
+        for(int i = size - 2; i >= 0; i--){
+            right[i] = nums[i+1]*right[i+1];
+        }
+        for(int i = 0; i < size; i++){
+            finalans[i] = left[i]*right[i]; 
+        }
+        return finalans;
+    }
+};

revere_only_letters.cpp

@@ -0,0 +1,24 @@
+class Solution {
+public:
+    string reverseOnlyLetters(string S) {
+      int start=0;
+      int end=S.size();
+
+      while(start<end){
+        if(isalpha(S[start]) && isalpha(S[end]){
+            char m=S[start];
+            S[start]=S[end];
+            S[end]=m;
+            start++;
+            end--;
+        }
+        else if(isalpha(S[start]) && !isalpha(S[end])){
+                end--;
+        }
+        else if(!isalpha(S[start])){
+             start++;
+        }
+     }
+      return S;
+    }
+};s

rotate_array.cpp

@@ -0,0 +1,21 @@
+class Solution {
+public:
+    void reverse(vector<int>& v, int begin, int end){
+        while(begin < end){
+            int temp = v[begin];
+            v[begin] = v[end];
+            v[end] = temp;
+            begin++;
+            end--;
+        }
+    }
+    void rotate(vector<int>& nums, int k) {
+        k = k%nums.size();
+        // REVERSE THE WHOLE ARRAY
+        reverse(nums, 0, nums.size()-1);
+        // REVERSE THE ARRAY TILL K;
+        reverse(nums, 0, k-1);
+        // REVERSE THE ARRAY FROM K+1 TO THE END
+        reverse(nums, k, nums.size()-1);
+    }
+};

spiral_matrix.cpp

@@ -0,0 +1,34 @@
+class Solution {
+public:
+    vector<int> ans;
+    void printResult(int x, int y, int n, int m, vector<vector<int>>& matrix){
+        for(int right=y; right<=m; right++){
+            ans.push_back(matrix[x][right]);
+        }
+        for(int down=x+1; down<=n; down++){
+            ans.push_back(matrix[down][m]);
+        }
+        if(x != n) for(int left=m-1; left>=y; left--){
+            ans.push_back(matrix[n][left]);
+        }
+        if(y != m) for(int top=n-1; top>x; top--) {
+            ans.push_back(matrix[top][y]);
+        }
+    }
+    vector<int> spiralOrder(vector<vector<int>>& matrix) {
+        if(matrix.size() == 0){
+            return ans;
+        }
+        int n = matrix.size();
+        int m = matrix[0].size();
+        int curr = 0;
+        int N = n-1;
+        int M = m-1;
+        while(ans.size() < n*m){
+            printResult(curr, curr, N-curr, M-curr, matrix);
+            curr++;
+        }
+
+        return ans;
+    }
+};

target_array.cpp

@@ -0,0 +1,10 @@
+class Solution {
+public:
+    vector<int> createTargetArray(vector<int>& nums, vector<int>& index) {
+        vector <int> target;
+        for(int i = 0; i < index.size(); i++){
+            target.insert(target.begin()+index[i], nums[i]);
+        } 
+        return target;
+    }
+};

xor_operation.cpp

@@ -0,0 +1,12 @@
+class Solution {
+public:
+    int xorOperation(int n, int start) {
+        int nums[n];
+        int result=0;
+        for(int i=0; i < n; i++){
+            nums[i]=(start+2*i);
+            result=result^nums[i];
+        }
+        return result;
+    }
+};