Practise 13-Jun-2020

sureshmangs · sureshmangs · commit 0d516f0b5062 · 2020-06-13T12:37:17.000+05:30
diff --git a/competitive programming/codechef/EVENM.cpp b/competitive programming/codechef/EVENM.cpp
@@ -0,0 +1,74 @@
+/*
+Chef has an integer N and he wants to generate a matrix M with N rows (numbered 1 through N) and N columns (numbered 1 through N). He thinks that M would be delicious if:
+
+Each element of this matrix is an integer between 1 and N2 inclusive.
+All the elements of the matrix are pairwise distinct.
+For each square submatrix containing cells in rows r through r+a and in columns c through c+a (inclusive) for some valid integers r, c and a≥0:
+Mr,c+Mr+a,c+a is even
+Mr,c+a+Mr+a,c is even
+Can you help Chef generate a delicious matrix? It can be proved that a solution always exists. If there are multiple solutions, you may find any one.
+
+Input
+The first line of the input contains a single integer T denoting the number of test cases. The description of T test cases follows.
+The first and only line of each test case contains a single integer N.
+Output
+For each test case, print N lines describing a delicious matrix M. For each valid i, the i-th of these lines should contain N space-separated integers Mi,1,Mi,2,…,Mi,N.
+
+Constraints
+1≤T≤10
+1≤N≤103
+the sum of N over all test cases does not exceed 103
+Subtasks
+Subtask #1 (100 points): original constraints
+
+Example Input
+1
+2
+Example Output
+1 2
+4 3
+Explanation
+Example case 1: The matrix M has five square submatrices. Four of them ([1], [2], [4], [3]) have a=0, so they obviously satisfy all conditions. The last square submatrix is the whole matrix M, with r=c=a=1, and we can see that M1,1+M2,2=1+3=4 and M1,2+M2,1=2+4=6 are both even.
+*/
+
+
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    int t;
+    cin>>t;
+    while(t--){
+        int n;
+        cin>>n;
+        int cnt=1;
+        int a[n][n];
+        if(n%2!=0){
+            for(int i=0;i<n;i++){
+                for(int j=0;j<n;j++)
+                    a[i][j]=cnt++;
+            }
+        } else {
+             for(int i=0;i<n;i++){
+                if(i%2==0){
+                    for(int j=0;j<n;j++)
+                        a[i][j]=cnt++;
+                } else {
+                    for(int j=n-1;j>=0;j--)
+                        a[i][j]=cnt++;
+                }
+
+            }
+        }
+        for(int i=0;i<n;i++){
+            for(int j=0;j<n;j++)
+                cout<<a[i][j]<<" ";
+            cout<<endl;
+        }
+    }
+}
diff --git a/competitive programming/leetcode/2020-June-Challenge/Day-12-Insert Delete GetRandom O(1).cpp b/competitive programming/leetcode/2020-June-Challenge/Day-12-Insert Delete GetRandom O(1).cpp
@@ -0,0 +1,96 @@
+class RandomizedSet {
+public:
+    unordered_map<int, int> m;
+    vector<int>v;
+
+    /** Initialize your data structure here. */
+    RandomizedSet() {
+
+    }
+
+    /** Inserts a value to the set. Returns true if the set did not already contain the specified element. */
+    bool insert(int val) {
+        if(m.find(val)!=m.end())
+             return false;
+        v.push_back(val);
+        m.insert({val, v.size()-1});
+        return true;
+
+    }
+
+    /** Removes a value from the set. Returns true if the set contained the specified element. */
+    bool remove(int val) {
+        if(m.find(val)==m.end())
+            return false;
+        int pos=m[val];
+        v[pos]=v[v.size()-1];
+        m[v[pos]]=pos;
+        v.pop_back();
+        m.erase(val);
+        return true;
+    }
+
+    /** Get a random element from the set. */
+    int getRandom() {
+        return v[rand()%v.size()];
+    }
+};
+
+/**
+ * Your RandomizedSet object will be instantiated and called as such:
+ * RandomizedSet* obj = new RandomizedSet();
+ * bool param_1 = obj->insert(val);
+ * bool param_2 = obj->remove(val);
+ * int param_3 = obj->getRandom();
+ */
+
+
+
+
+
+
+ class RandomizedSet {
+public:
+    unordered_map<int, int> m;
+    vector<int>v;
+
+    /** Initialize your data structure here. */
+    RandomizedSet() {
+
+    }
+
+    /** Inserts a value to the set. Returns true if the set did not already contain the specified element. */
+    bool insert(int val) {
+        if(m.find(val)!=m.end())
+             return false;
+        v.push_back(val);
+        m.insert({val, v.size()-1});
+        return true;
+
+    }
+
+    /** Removes a value from the set. Returns true if the set contained the specified element. */
+    bool remove(int val) {
+        if(m.find(val)==m.end())
+            return false;
+        int pos=m[val];
+        v[pos]=v[v.size()-1];
+        m[v[pos]]=pos;
+        v.pop_back();
+        m.erase(val);
+        return true;
+    }
+
+    /** Get a random element from the set. */
+    int getRandom() {
+        return v[rand()%v.size()];
+    }
+};
+
+/**
+ * Your RandomizedSet object will be instantiated and called as such:
+ * RandomizedSet* obj = new RandomizedSet();
+ * bool param_1 = obj->insert(val);
+ * bool param_2 = obj->remove(val);
+ * int param_3 = obj->getRandom();
+ */
diff --git a/competitive programming/leetcode/380. Insert Delete GetRandom O(1).cpp b/competitive programming/leetcode/380. Insert Delete GetRandom O(1).cpp
@@ -0,0 +1,96 @@
+class RandomizedSet {
+public:
+    unordered_map<int, int> m;
+    vector<int>v;
+
+    /** Initialize your data structure here. */
+    RandomizedSet() {
+
+    }
+
+    /** Inserts a value to the set. Returns true if the set did not already contain the specified element. */
+    bool insert(int val) {
+        if(m.find(val)!=m.end())
+             return false;
+        v.push_back(val);
+        m.insert({val, v.size()-1});
+        return true;
+
+    }
+
+    /** Removes a value from the set. Returns true if the set contained the specified element. */
+    bool remove(int val) {
+        if(m.find(val)==m.end())
+            return false;
+        int pos=m[val];
+        v[pos]=v[v.size()-1];
+        m[v[pos]]=pos;
+        v.pop_back();
+        m.erase(val);
+        return true;
+    }
+
+    /** Get a random element from the set. */
+    int getRandom() {
+        return v[rand()%v.size()];
+    }
+};
+
+/**
+ * Your RandomizedSet object will be instantiated and called as such:
+ * RandomizedSet* obj = new RandomizedSet();
+ * bool param_1 = obj->insert(val);
+ * bool param_2 = obj->remove(val);
+ * int param_3 = obj->getRandom();
+ */
+
+
+
+
+
+
+ class RandomizedSet {
+public:
+    unordered_map<int, int> m;
+    vector<int>v;
+
+    /** Initialize your data structure here. */
+    RandomizedSet() {
+
+    }
+
+    /** Inserts a value to the set. Returns true if the set did not already contain the specified element. */
+    bool insert(int val) {
+        if(m.find(val)!=m.end())
+             return false;
+        v.push_back(val);
+        m.insert({val, v.size()-1});
+        return true;
+
+    }
+
+    /** Removes a value from the set. Returns true if the set contained the specified element. */
+    bool remove(int val) {
+        if(m.find(val)==m.end())
+            return false;
+        int pos=m[val];
+        v[pos]=v[v.size()-1];
+        m[v[pos]]=pos;
+        v.pop_back();
+        m.erase(val);
+        return true;
+    }
+
+    /** Get a random element from the set. */
+    int getRandom() {
+        return v[rand()%v.size()];
+    }
+};
+
+/**
+ * Your RandomizedSet object will be instantiated and called as such:
+ * RandomizedSet* obj = new RandomizedSet();
+ * bool param_1 = obj->insert(val);
+ * bool param_2 = obj->remove(val);
+ * int param_3 = obj->getRandom();
+ */
diff --git a/dynamic programming/boolean_patenthesization_recursive.cpp b/dynamic programming/boolean_patenthesization_recursive.cpp
@@ -0,0 +1,99 @@
+/*
+Given a boolean expression with following symbols.
+
+Symbols
+    'T' ---> true
+    'F' ---> false
+
+And following operators filled between symbols
+
+Operators
+    &   ---> boolean AND
+    |   ---> boolean OR
+    ^   ---> boolean XOR
+
+Count the number of ways we can parenthesize the expression so that the value of expression evaluates to true.
+
+For Example:
+The expression is "T | T & F ^ T", it evaluates true
+in 4 ways ((T|T)&(F^T)), (T|(T&(F^T))), (((T|T)&F)^T)
+and (T|((T&F)^T)).
+
+Return No_of_ways Mod 1003.
+
+Input:
+First line contains the test cases T.  1<=T<=500
+Each test case have two lines
+First is length of string N.  1<=N<=100
+Second line is string S (boolean expression).
+Output:
+No of ways Mod 1003.
+
+
+Example:
+Input:
+2
+7
+T|T&F^T
+5
+T^F|F
+
+Output:
+4
+2
+*/
+
+
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+int booleanParenthesis(string s, int i, int j, bool isTrue){
+    if(i>j) return 0;
+    if(i==j){
+        if(isTrue==true)
+             return s[i]=='T'?1:0;
+        else return s[i]=='F'?1:0;
+    }
+    int ans=0;
+    for(int k=i+1;k<j;k+=2){
+        int lt=booleanParenthesis(s, i, k-1, true);
+        int lf=booleanParenthesis(s, i, k-1, false);
+        int rt=booleanParenthesis(s, k+1, j, true);
+        int rf=booleanParenthesis(s, k+1, j, false);
+
+        if(s[k]=='&'){
+            if(isTrue=true)
+                ans+=lt*rt;
+            else ans+=lt*rf + lf*rt + lf*rf;
+        } else if(s[k]=='|'){
+            if(isTrue==true)
+                ans+=lt*rt + lt*rf + lf*rt;
+            else ans+=lf*rf;
+        } else if(s[k]=='^'){
+            if(isTrue==true)
+                ans+=lt*rf + lf*rt;
+            else ans+=lf*rf + lt*rt;
+        }
+    }
+    return ans;
+}
+
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    cout.tie(NULL);
+    int t;
+    cin>>t;
+    while(t--){
+        int n;
+        cin>>n;
+        string s;
+        cin>>s;
+        cout<<booleanParenthesis(s, 0, n-1, true)<<endl;
+    }
+
+return 0;
+}
diff --git a/dynamic programming/palindromic_partitioning_memoization.cpp b/dynamic programming/palindromic_partitioning_memoization.cpp
diff --git a/dynamic programming/palindromic_partitioning_recursive.cpp b/dynamic programming/palindromic_partitioning_recursive.cpp
