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;
+}