Good bye 2020

Author: Pankajcoder1

Diff for: LeetCode/practice/152.Maximum_Product_Subarray.cpp

@@ -0,0 +1,17 @@
+class Solution {
+public:
+    int maxProduct(vector<int>& nums) {
+        int maxo=nums[0],mini=nums[0];
+        int ans=nums[0];
+        for(int i=1;i<nums.size();i++)
+        {
+            int temp=nums[i];
+            int temp_max=temp*maxo;
+            int temp_min=temp*mini;
+            maxo=max({temp,temp_min,temp_max});
+            mini=min({temp,temp_min,temp_max});
+            ans=max(ans,maxo);
+        }
+        return ans;
+    }
+};

Diff for: LeetCode/practice/204-Count_Primes.cpp

@@ -0,0 +1,23 @@
+class Solution {
+public:
+    int countPrimes(int n) {
+        int count=0;
+        vector<int> prime(n+1,0);
+        for(int i=2;i*i<n;i++)
+        {
+            if(prime[i]==0)
+            {
+                for(int j=i*i;j<n;j+=i)
+                    prime[j]=i;
+            }
+        }
+        for(int i=2;i<n;i++)
+        {
+            if(prime[i]==0)
+            {
+                count++;
+            }
+        }
+        return count;
+    }
+};

Diff for: LeetCode/practice/221-Maximal_Square.cpp

@@ -0,0 +1,23 @@
+class Solution {
+public:
+    int maximalSquare(vector<vector<char>>& matrix) {
+        int m=matrix[0].size();
+        int n=matrix.size();
+        vector<vector<int>> dp(n+1,vector<int>(m+1,0));
+        int ans=0;
+        for(int i=1;i<=n;i++)
+        {
+            for(int j=1;j<=m;j++)
+            {
+                if(matrix[i-1][j-1]=='1')
+                {
+                    dp[i][j]=1+min({dp[i-1][j],dp[i][j-1],dp[i-1][j-1]});
+                    ans=max(ans,dp[i][j]);
+                }
+                else
+                    dp[i][j]=0;
+            }
+        }
+        return ans*ans;
+    }
+};

Diff for: LeetCode/practice/263-Ugly_Number.cpp

@@ -0,0 +1,20 @@
+class Solution {
+public:
+    bool isUgly(int num) {
+        if(num==0)
+            return false;
+        while(num%2==0){
+            num/=2;
+        }
+        while(num%3==0){
+            num/=3;
+        }
+        while(num%5==0){
+            num/=5;
+        }
+        if(num==1)
+            return true;
+        else
+            return false;
+    }
+};

Diff for: LeetCode/practice/264-Ugly_Number_II.cpp

@@ -0,0 +1,31 @@
+class Solution {
+public:
+    int nthUglyNumber(int n) {
+        int i2=0,i3=0,i5=0;
+        int a=2,b=3,c=5;
+        vector<int> v(n);
+        v[0]=1;
+        int num=1;
+        while(num<n)
+        {
+            int mini=min({a,b,c});
+            v[num]=mini;
+            num++;
+            if(mini==a)
+            {
+                i2++;
+                a=2*v[i2];
+            }
+            if(mini==b)
+            {
+                i3++;
+                b=3*v[i3];
+            }
+            if(mini==c){
+                i5++;
+                c=5*v[i5];
+            }          
+        }
+        return v[n-1];
+    }
+};

Diff for: LeetCode/practice/279-Perfect_Squares.cpp

@@ -0,0 +1,20 @@
+class Solution {
+public:
+    int numSquares(int n) {
+        if(floor(sqrt(n))==ceil(sqrt(n)))
+            return 1;
+        while(n%4==0)
+        {
+            n/=4;
+        }
+        if(n%8==7)
+            return 4;
+        for(int i=1;i*i<=n;i++)
+        {
+            int temp=sqrt(n-(i*i));
+            if((temp*temp)==(n-(i*i)))
+                return 2;
+        }
+        return 3;
+    }
+};

Diff for: LeetCode/practice/300-Longest_Increasing_Subsequence.cpp

@@ -0,0 +1,16 @@
+class Solution {
+public:
+    int lengthOfLIS(vector<int>& nums) {
+        int n=nums.size();
+        vector<int> dp(n,1);
+        for(int i=1;i<n;i++)
+        {
+            for(int j=0;j<i;j++)
+            {
+                if(nums[i]>nums[j]&&dp[j]<dp[i]+1)
+                    dp[i]=max(dp[i],dp[j]+1);
+            }
+        }
+        return *max_element(dp.begin(),dp.end());
+    }
+};

Diff for: LeetCode/practice/304.Range_Sum_Query2D-Immutable.cpp

@@ -0,0 +1,28 @@
+class NumMatrix {
+     vector<vector<int>> dp;
+public:
+    NumMatrix(vector<vector<int>>& matrix) {
+        if(matrix.size() == 0) return;
+        int n=matrix.size();
+        int m=matrix[0].size();
+        dp=vector<vector<int>>(n+1,vector<int>(m+1,0));
+        for(int i=1;i<=n;i++)
+        {
+            for(int j=1;j<=m;j++)
+            {
+                dp[i][j]=matrix[i-1][j-1]+dp[i-1][j]+dp[i][j-1]-dp[i-1][j-1];
+                
+            }
+        }        
+    }
+    int sumRegion(int row1, int col1, int row2, int col2) {
+        // cout<<"row is "<<row1<<endl;
+        return dp[row2+1][col2+1]-dp[row2+1][col1]-dp[row1][col2+1]+dp[row1][col1];
+    }
+};
+
+/**
+ * Your NumMatrix object will be instantiated and called as such:
+ * NumMatrix* obj = new NumMatrix(matrix);
+ * int param_1 = obj->sumRegion(row1,col1,row2,col2);
+ */

Diff for: LeetCode/practice/628-Maxumum_Product_of_Three_Numbers.cpp

@@ -0,0 +1,12 @@
+class Solution {
+public:
+    int maximumProduct(vector<int>& nums) {
+        int n=nums.size();
+        sort(nums.begin(),nums.end(),greater<int>());
+        int ans=1;
+        ans=(nums[0]*nums[1]*nums[2]);
+        int temp=nums[n-1]*nums[n-2]*nums[0];
+        ans=max(ans,temp);
+        return ans;
+    }
+};

Diff for: LeetCode/practice/674-Longest_Continuous_Increasing_Subsequence.cpp

@@ -0,0 +1,23 @@
+class Solution {
+public:
+    int findLengthOfLCIS(vector<int>& nums) {
+        int count=0,maxo=1;
+        int n=nums.size();
+        if(n==1)
+            return 1;
+        if(n==0)
+            return 0;
+        count=1;
+        int temp=nums[0];
+        for(int i=1;i<n;i++)
+        {
+            if(nums[i]>temp)
+                count++;
+            else
+                count=1;
+            maxo=max(maxo,count);
+            temp=nums[i];
+        }
+        return maxo;
+    }
+};

Diff for: README.md

@@ -7,6 +7,7 @@ Contain file of my [competitive programming](https://en.wikipedia.org/wiki/Compe
 - [Atcoder](https://atcoder.jp/home)
 - [CSES](https://cses.fi/problemset/)
 - [Facebook hacker cup](https://www.facebook.com/codingcompetitions/hacker-cup)
+- [open kattis](https://open.kattis.com/)
 
 
 Executable codes to contest problems in [c++](https://medium.com/sololearn/reasons-to-love-c-11c7c2f23d88)

Diff for: codechef/practice/ARRGAME.cpp

@@ -0,0 +1,141 @@
+/*
+    written by Pankaj Kumar.
+    country:-INDIA
+*/
+#include <bits/stdc++.h>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+using namespace std;
+using namespace __gnu_pbds;
+typedef long long ll ;
+typedef vector<ll> vl;
+#define speed cin.tie(0);cout.tie(0);ios_base::sync_with_stdio(0);
+// define values.
+// #define mod 1000000007
+#define phi 1.618
+/*  Abbrevations  */
+#define ff first
+#define ss second
+#define mp make_pair
+#define line cout<<endl;
+#define pb push_back
+#define Endl "\n"
+// loops
+#define forin(arr,n) for(ll i=0;i<n;i++) cin>>arr[i];
+// Some print
+#define no cout<<"No"<<endl;
+#define yes cout<<"Yes"<<endl;
+// sort
+#define all(V) (V).begin(),(V).end()
+#define srt(V) sort(all(V))
+#define srtGreat(V) sort(all(V),greater<ll>())
+#define printv(v) for(ll i=0;i<ll(v.size());i++){cout<<v[i]<<" ";} line;
+// some extra
+#define sz(V) ll(V.size())
+/* ONLINE JUDGE */
+// #ifdef ONLINE_JUDGE
+//     freopen("input.txt", "r", stdin);freopen("output.txt", "w", stdout);
+// #endif
+// template
+template <typename T>
+T mymax(T x,T y)
+{
+    return (x>y)?x:y;
+}
+// function
+
+ll power(ll x,ll y,ll mod)
+{
+    ll res=1;
+    // x=x%mod;
+    while(y>0)
+    {
+        if(y%2==1)
+        {
+            res*=x;
+            // res=res%mod;
+        }
+        y/=2; x*=x; // x=x%mod;
+    }
+    return res;
+}
+ll str_to_num(string s)
+{
+    return stoi(s);
+}
+
+string num_to_str(ll num)
+{
+    return to_string(num);
+}
+// datatype definination
+#define ordered_set tree<ll,null_type,less<ll>,rb_tree_tag,tree_order_statistics_node_update>
+
+/* ascii value 
+A=65,Z=90,a=97,z=122
+*/
+/*  -----------------------------------------------------------------------------------*/
+
+ll solve()
+{
+    ll n;
+    cin>>n;
+    ll maxo=0;
+    ll count=0;
+    vl v(n);
+    forin(v,n);
+    vl ans;
+    for(ll i=0;i<n;i++)
+    {
+        if(v[i]==0)
+            count++;
+        else
+        {
+            if(count>0)
+                ans.pb(count);
+            count=0;
+        }
+    }
+    if(count>0)
+        ans.pb(count);
+    if(ans.size()==0)
+        no
+    else
+    {
+        srtGreat(ans);
+        if(ans.size()==1)
+        {
+            if(ans[0]&1)
+                yes
+            else
+                no
+        }
+        else
+        {
+            if(ans[0]&1&&(ans[0]+1)/2>ans[1])
+                yes
+            else
+                no
+        }
+    }
+    return 0;
+}
+
+int main()
+{
+    speed;
+    // freopen("input.txt","r",stdin);
+    // freopen("output.txt","w",stdout);
+    ll TestCase=1;
+    cin>>TestCase;
+    while(TestCase--)
+    {
+        solve();
+    }
+}
+
+/* stuff you should look before submission 
+* int overflow
+* special test case (n=0||n=1||n=2)
+* don't get stuck on one approach if you get wrong answer
+*/