done adding 255 question solution

Author: MOHIT-IITP

01.cpp

@@ -0,0 +1,19 @@
+#include<bits/stdc++.h>
+using namespace std;
+vector<int> twoSum(vector<int>& nums, int target){
+  for(int i=0;i<nums.size()-1;i++){
+    for(int j=i+1;j<nums.size();j++){
+      if(nums[i]+nums[j]==target){
+        return {i,j};
+      }
+    }
+  }
+  return {};
+}
+
+int main(){
+  vector<int> nums({2,7,10,15});
+  twoSum(nums,9);
+  return 0;
+}
+// this code is done by mohit kumar

100.cpp

@@ -0,0 +1,18 @@
+#include<bits/stdc++.h>
+/*some of the ide does not support the upper include so the below code is important*/
+#include<iostream>
+using namespace std;
+
+int same(TreeNode*p , TreeNode*q){
+  if(!p && !q){
+    return true;
+  }
+  if(p && q && p->val == q->val){
+    return same(p->left,q->left) && same(p->right, q->right);
+  }
+}
+
+int main()
+{
+  return 0;
+}

1002.cpp

@@ -0,0 +1,10 @@
+#include<bits/stdc++.h>
+#include<iostream>
+
+using namespace std;
+
+int main()
+{
+  cout<<"hello world"<<endl;
+  return 0;
+}

1002.py

@@ -0,0 +1,14 @@
+# // print the common word in the list
+# leetcode dialy challenge
+def common(words):
+    res = []
+    for char in set(words[0]):
+# here we are including the minimum occurance of the character
+# like if b is not present in the third word then it min occurance will be 0
+        res += char*min([word.count(char) for word in words])
+    print(res)
+lst=["bella","label","roller"]
+common(lst)
+
+
+

1004.cpp

@@ -0,0 +1,33 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+class Solution{
+public:
+  int longestOnes(vector<int> & nums, int k){
+    int left=0,right=0;
+    int maxlen = 0;
+    int zeros=0;
+    int len = 0;
+    while(right<nums.size()){
+      if(nums[right]==0){zeros++;}
+      if(zeros>k){
+        if(nums[left]==0){
+          zeros--;
+        }
+        left++;
+      }
+      if(zeros<=k){
+        len = right-left+1;
+        maxlen = max(len , maxlen);
+      }
+      right ++;
+    }
+    return maxlen;
+
+  }
+}
+
+int main(){
+  return 0;
+}
+

1004_another.cpp

@@ -0,0 +1,27 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int longestOnes(vector<int> &nums, int k) {
+  int left = 0, right = 0, count = k, maxLen = 0;
+
+  while (right < nums.size()) {
+    if (nums[right] == 0) {
+      if (count > 0) {
+        count--;
+        right++;
+      } else {
+        maxLen = max(maxLen, right - left);
+        while (nums[left] == 1) {
+          left++;
+        }
+        left++;
+        right++;
+      }
+    } else {
+      right++;
+    }
+    return max(maxLen, right - left);
+  }
+}
+
+int main() { return 0; }

1008.cpp

@@ -0,0 +1,23 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+TreeNode* bstFromPreorder(vector<int>& preorder){
+  int index = 0;
+  return helper(preorder, index, INT_MAX);
+}
+TreeNode* helper(vector<int>& preorder, int& index, int bound){
+  if(index>=preorder.size() || preorder[index]>bound){
+    return nullptr;
+  }
+  int rootVal = preorder[index++];
+  TreeNode* node = new TreeNode(rootVal);
+  node->left = helper(preorder, index, rootVal);
+  node->right = helper(preorder,index, bound);
+  return node;
+}
+
+
+int main()
+{
+  return 0;
+}

101.cpp

@@ -0,0 +1,26 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+
+class Solution {
+public:
+    bool isSymmetric(TreeNode* root) {
+        if(root==NULL) return true;
+        return mirror(root->left, root->right);
+    }
+    bool mirror(TreeNode* left, TreeNode* right){
+        if(left==nullptr && right==nullptr){
+            return true;
+        }
+        if(left==nullptr || right==nullptr){
+            return false;
+        }
+        return (left->val == right->val) && mirror(left->left, right->right) && mirror(left->right, right->left);
+    }
+
+};
+
+int main()
+{
+  return 0;
+}

102.cpp

@@ -0,0 +1,33 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+vector<vector<int>> levelorder(TreeNode* root){
+  vector<vector<int>> ans;
+  if(root==NULL){
+    return ans;
+  }
+  queue<TreeNode*> q;
+  q.push(root);
+  while(!q.empty()){
+    int size= q.size();
+    vector<int> level;
+    for(int i =0;i<size;i++){
+      TreeNode* temp = q.front();
+      q.pop();
+      level.push_back(temp->val);
+      if(temp->left!=NULL){
+        q.push(temp->left);
+      }
+      if(temp->right!=NULL){
+        q.push(temp->right);
+      }
+    }
+    ans.push_back(level);
+  }
+  return ans;
+}
+
+int main()
+{
+  return 0;
+}

103.cpp

@@ -0,0 +1,35 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+vector<vector<int>> zigzagLevelOrder(TreeNode* root){
+  vector<vector<int>> res;
+  if(root == nullptr){
+    return ans;
+  }
+  queue<TreeNode*> q;
+  q.push(root);
+  while(!q.empty()){
+    int s = q.size();
+    vector<int> level;
+    for(int i = 0;i<s;i++){
+      TreeNode* node = q.front();
+      q.pop();
+      level.push_back(node->val);
+      if(node->left){
+        q.push(node->left);
+      }
+      if(node->right){
+        q.push(node->right);
+      }
+    }
+    if(ans.size()%2){
+      reverse(level.begin(), level.end());
+    }
+    ans.push_back(level);
+  }
+}
+
+int main()
+{
+  return 0;
+}

104.cpp

@@ -0,0 +1,54 @@
+#include<bits/stdc++.h>
+using namespace std;
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    vector<vector<int>> levelorder(TreeNode* root){
+        vector<vector<int>> ans;
+        if(root == nullptr){
+            return ans;
+        }
+        queue<TreeNode*> q;
+        q.push(root);
+        while(!q.empty())
+        {
+            vector<int> level;
+            int s = q.size();
+            for(int i =0;i<s;i++){
+                TreeNode* temp = q.front();
+                q.pop();
+                level.push_back(temp->val);
+                if(temp->left!=NULL){q.push(temp->left);}
+                if(temp->right!=NULL){q.push(temp->right);}
+            }
+            ans.push_back(level);
+        }
+        return ans;
+    }
+    int maxDepth(TreeNode* root) {
+        vector<vector<int>> res = levelorder(root);
+        return res.size();
+
+    }
+    // You can also do 
+    int maxDepth(TreeNode* root){
+        if(root==nullptr){
+            return 0;
+        }
+        return 1+max(maxDepth(root->left),maxDepth(root->right));
+    }
+};
+int main()
+{
+  return 0;
+}

1047.cpp

@@ -0,0 +1,29 @@
+#include<bits/stdc++.h>
+
+using namespace std;
+
+string removeDuplicate(string s){
+  stack<char> st;
+  string ans;
+  for(int i=0;i<s.size();i++){
+    if(st.empty() || s[i]!=st.top()){
+      st.push(s[i]);
+    }
+    else{
+      st.pop();
+    }
+  }
+  while(!st.empty()){
+    ans+=st.top();
+    st.pop();
+  }
+  reverse(ans.begin(), ans.end());
+  return ans;
+}
+
+int main()
+{
+  string s= "abbaca";
+  removeDuplicate(s);
+  return 0;
+}

105.cpp

@@ -0,0 +1,33 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder){
+  int n = preorder.size();
+  int index= 0;
+  return helper(preorder,inorder,0,n-1,index);
+
+}
+TreeNode* helper(vector<int>& preorder, vector<int>& inorder, int start, int end, int& index)
+{
+  if(start>end){
+    return NULL;
+  }
+  int rootVal = preorder[index];
+  int i = start;
+  for(;i<=n;i++){
+    if(inorder[i]==rootVal){
+      break;
+    }
+  }
+  index++;
+  TreeNode* root = new TreeNode(rootVal);
+  root->left = helper(preorder,inorder,start,i-1,index);
+  root->right = helper(preorder,inorder,i+1,end,index);
+
+  return root;
+}
+
+int main()
+{
+  return 0;
+}

1051.cpp

@@ -0,0 +1,27 @@
+#include<bits/stdc++.h>
+
+using namespace std;
+
+int heightChecker(vector<int> & heights){
+  int count =0;
+  int n = heights.size();
+  vector<int> check=heights;
+  sort(check.begin(),check.end());
+  for(int i =0;i<heights.size();i++){
+    if(check[i]==heights[i]){
+      count++;
+    }
+  }
+  return n-count;
+
+}
+
+int main()
+{
+  vector<int> heights({1,1,4,2,1,3});
+  int res = heightChecker(heights);
+  cout<<res;
+  return 0;
+}
+
+