Merge branch 'opencodeiiita:main' into main

Author: capricemoto

Problems/Binary-Search/Day-06/sol/Aiyaan_Mahajan/Q2sol.cpp

@@ -0,0 +1,77 @@
+/*
+DAY 6
+Q2  Rudolf and Snowflakes (hard version)
+.*/
+/*
+
+n is valid if it equals 1+k+k^2+k^3+......+k^d  and d>=2
+
+*/
+
+#include<bits/stdc++.h>
+using namespace std;
+using i64 = long long;
+using u64 = unsigned long long;
+const i64 Mod = 1e9 + 7;
+const i64 Inf = 1e8;
+const int Len = 2e5 + 5;
+map<i64,int> mp;
+ 
+void solve(void)
+{
+    i64 n;
+    cin >> n;
+    if(mp[n])
+    {
+        cout << "YES\n";
+        return;
+    }
+    n--;
+    i64 l = 2,r = 1e9;
+    while(l <= r)
+    {
+        i64 mid = (l + r) >> 1;
+        if(mid * (mid + 1ll) == n)
+        {
+            cout << "YES\n";
+            return;
+        }
+        else if(mid * (mid + 1ll) > n)
+        {
+            r = mid - 1;
+        }
+        else l = mid + 1;
+    }
+    cout << "NO\n";
+}
+ 
+int main(void)
+{
+    i64 n = 1e6,nn = 1e18;
+    for(i64 i = 2;i <= n;i++)
+    {
+        i64 tmp = i * i,now = 1 + i + i * i;
+        while(now <= nn)
+        {
+            mp[now] = 1;
+            i64 tt = nn / tmp;
+            if(i > tt)break;
+            tmp *= i;
+            now += tmp;
+        }
+    }
+    int t;
+    cin >> t;
+    while(t--)solve();
+    cout.flush();
+    return 0;
+}
+
+
+
+
+
+// SC = O(M)
+/*
+My submission : https://codeforces.com/contest/1846/submission/356068357
+*/

Problems/Binary-Search/Day-06/sol/Vishva/soln1.cpp

@@ -0,0 +1,71 @@
+#include<bits/stdc++.h>
+#include<queue>
+using namespace std;
+typedef unordered_map<int, int> umii;
+typedef unordered_map<long long, long long> umll;
+typedef unordered_map<char, long long> umci;
+typedef vector<pair<int, int>> vpi;
+typedef vector<int> vi;
+typedef long long ll;
+typedef vector<long long> vll;
+typedef unordered_map<int , bool> umib;
+#define sum(v) accumulate(v.begin(), v.end(), 0)
+#define endl '\n'
+#define f0(i, n) for(long long i = 0; i < n; i++)
+#define f1(i, n) for(long long i = 1; i < n; i++)
+#define as(v) sort(v.begin(), v.end())
+#define all(x) (x).begin(), (x).end()
+#define pb push_back
+template<class T> umll frequency(vector<T> &v) {umll freq;for(auto &x:v) freq[x]++; return freq;}
+template<class T> umci S_frequency(vector<T> &v) {umci freq;for(auto &x:v) freq[x]++; return freq;}
+template <class T> void input(vector<T> &v){for(auto &x:v)cin>>x;}
+ll power(ll x, ll y){ ll res = 1; while (y > 0){ if (y & 1) res = (ll)(res*x); y = y>>1; x = (ll)(x*x); } return res; }
+void pvll(const vector<long long> &arr){for(auto it : arr){cout << it << " ";}cout << endl;}
+void pvi(const vector<int> &arr){for(auto it : arr){cout << it << " ";}cout << endl;}
+
+
+// submission link:- https://codeforces.com/contest/2014/submission/356192778
+
+
+
+void solve(){
+
+//-------------INPUT-------------
+    ll n; 
+    cin >> n;
+    vll v(n);
+    ll sum=0;
+
+    input(v);
+    f0(i,n){
+        sum+=v[i];
+    }
+    sort(all(v));
+    // i will sort this and pick the middle one to check
+    if(n<3)
+    {
+        cout << -1 << endl;
+        return;
+    }
+    // formulated here 
+    ll ans = 2*v[n/2]*n-sum+1;
+
+    cout << max(0LL,ans) << endl;
+
+  //time conplexity is simple o(n) here 
+  // robin needs to appear by all chance then x==0 else 
+
+
+
+
+//-------------CODE--------------
+    
+
+
+}
+
+
+int main(){
+    int tt; cin >> tt; while(tt--)
+{solve();};
+}

Problems/Binary-Search/Day-07/sol/Abhigyan/Solution1.cpp

@@ -0,0 +1,44 @@
+// https://codeforces.com/contest/1538/submission/356243914
+// Given an array of n integers,find all pairs (ai,aj): i<j where  l≤ai+aj≤r
+
+#include <bits/stdc++.h>
+using namespace std;
+
+using ll = long long;
+#define all(x) (x).begin(), (x).end()
+
+const int MOD = 1e9 + 7; 
+const ll INF = 1e18;
+
+void solve() {
+    ll n,l,r;
+    cin>>n>>l>>r;
+    vector<ll> a(n);
+    for(auto &x: a) cin>>x;
+    //sort the array for Binary search
+    sort(all(a));
+    ll prs=0;
+    //first find all pairs A with sum <= r then those pairs B with sum less than l
+    for(int i=0;i<n;i++){
+        int p =upper_bound(all(a),r-a[i])-a.begin();
+        int q =upper_bound(all(a),l-1-a[i])-a.begin();
+        prs+=p-1; prs-=q-1;
+        if(a[i]+a[i]>=l && a[i]+a[i]<=r) prs--; //to remove self pair e.g. (ai,ai) absurd
+    }
+    //ans is (A-B)/2, divided by 2 to remove repeated pairs as order doesn't matter
+    cout<<prs/2<<endl;
+}
+// T.C.: O(n*logn); S.C.: O(1)
+int main() {
+    // Fast I/O
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int t;
+    cin >> t;
+    while (t--) {
+        solve();
+    }
+    
+    return 0;
+}

Problems/Binary-Search/Day-07/sol/Abhigyan/Solution2.cpp

@@ -0,0 +1,75 @@
+// submission: https://codeforces.com/contest/1777/submission/356260631
+
+/* Given n students of a school and m topics 1,2,3,…,m from which the quiz questions will be formed. 
+The i-th student is considered proficient in a topic T if (ai%T)=0.
+Otherwise, he is a rookie in that topic. We are asked to find the team formation of any no. of students 
+such that for every topic there is a member of the team proficient in this topic. Whilst minimizing the 
+maximum difference between the smartness of any two students and output this difference */
+
+#include <bits/stdc++.h>
+using namespace std;
+
+using ll = long long;
+#define all(x) (x).begin(), (x).end()
+
+const int MOD = 1e9 + 7; // 998244353
+const ll INF = 1e18;
+const int maxval=100005;
+vector<int> divisors[maxval];
+
+void precompute(){
+    for(int i=1;i<maxval;i++){
+        for(int j=i;j<maxval;j+=i) divisors[j].push_back(i);
+    }
+}
+
+void solve() {
+    int n,m;
+    cin>>n>>m;
+    vector<int> a(n);
+    for(auto &x: a) cin>>x;
+    sort(all(a));
+    int cov_topics=0, min_dif=INT_MAX, l=0;//left
+    vector<int> cnt(m+1,0);
+
+    //we take 2 pointers left and right
+    for(int r=0;r<n;r++){
+        // Add current student's topics to the window
+        for(int topic: divisors[a[r]]){
+            if(topic>m) break; //since divisors[] also keeps sorted divisors, if one is greater than m, then all subsequent will be so
+            if(cnt[topic]==0) cov_topics++; //increment cov_topics for every unique topic
+            cnt[topic]++;
+        }
+
+        /* While covered_topics == m (i.e., the team is valid): 
+            Update the minimum difference: ans = min(ans, a[right] - a[left]).
+            Move the left pointer forward to try and shrink the window. 
+            Remove the left student's factors from the count.*/
+        while(cov_topics==m){
+            min_dif=min(min_dif,a[r]-a[l]);
+            for(int topic: divisors[a[l]]){
+                if(topic>m) break;
+                cnt[topic]--;
+                if(cnt[topic]==0) cov_topics--;
+            }
+            l++;
+        }
+    }
+    if(min_dif==INT_MAX) cout<<-1<<endl; //means no team can cover all the m topics
+    else cout<<min_dif<<endl;
+
+}
+
+int main() {
+    // Fast I/O
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+    precompute();
+    int t;
+    cin >> t;
+    while (t--) {
+        solve();
+    }
+    
+    return 0;
+}