vol of cylinder- c++

comment down. ur questions names..👇👇👇👇

Mostly lots of groups are posting wrong answers..

So pls make crt answers...follow our channel ✅

#include <bits/stdc++.h>
using namespace std;

int maxTripletSum(int arr[], int n) {
    int maxA = INT_MIN, maxB = INT_MIN, maxC = INT_MIN;

    for (int i = 0; i < n; i++) {
        if (arr[i] > maxA) {
            maxC = maxB;
            maxB = maxA;
            maxA = arr[i];
        } else if (arr[i] > maxB) {
            maxC = maxB;
            maxB = arr[i];
        } else if (arr[i] > maxC) {
            maxC = arr[i];
        }
    }

    return (maxA + maxB + maxC);
}

int main() {
    int arr[] = {10, 20, 4, 1, 100, 70};
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << "Maximum triplet sum is " << maxTripletSum(arr, n) << endl;
    return 0;
}

Maximum Triplet Sum ✅
Infosys

#include <iostream>
#include <vector>
#include <numeric>
#define MOD 1000000007
using namespace std;
long long mod_inv(long long x, long long mod) {
    long long result = 1;
    long long power = mod - 2;
    while (power) {
        if (power % 2) {
            result = result * x % mod;
        }
        x = x * x % mod;
        power /= 2;
    }
    return result;
}

vector<long long> factorial(int n, long long mod) {
    vector<long long> fact(n + 1, 1);
    for (int i = 2; i <= n; ++i) {
        fact[i] = fact[i - 1] * i % mod;
    }
    return fact;
}
long long binomial_coeff(int n, int k, const vector<long long>& fact, long long mod) {
    if (k > n || k < 0) {
        return 0;
    }
    return fact[n] * mod_inv(fact[k], mod) % mod * mod_inv(fact[n - k], mod) % mod;
}
long long count_ways(int N, int K, const vector<int>& A) {
    int sum_A = accumulate(A.begin(), A.end(), 0);
    int M = K - sum_A;
    vector<long long> fact = factorial(M + N - 1, MOD);
    return binomial_coeff(M + N - 1, N - 1, fact, MOD);
}

int main() {
    int N, K;
    cin >> N >> K;
    vector<int> A(N);
    for (int i = 0; i < N; ++i) {
        cin >> A[i];
    }
    cout << count_ways(N, K, A) << endl;
    return 0;
}

DISTURBUTING BOOKS ✅
Infosys

def max_beauty_sum(A, intervals):
    N = len(A)
    dp = [0] * (N + 1)
    last_non_overlapping = [0] * (N + 1)
    
    interval_beauty = []
    for start, end in intervals:
        distinct = set(A[start-1:end])
        beauty = sum(distinct)
        interval_beauty.append((start, end, beauty))
    interval_beauty.sort(key=lambda x: x[1])
    
    for start, end, beauty in interval_beauty:
        prev_end = last_non_overlapping[start-1]
        dp[end] = max(dp[end], dp[prev_end] + beauty)
        
        for i in range(end, N + 1):
            last_non_overlapping[i] = max(last_non_overlapping[i], end)
    
    return max(dp)

def main():
    import sys
    input = sys.stdin.read
    data = input().split()
    
    index = 0
    N = int(data[index])
    index += 1
    Q = int(data[index])
    index += 1
    C = int(data[index])
    index += 1
    A = []
    for _ in range(N):
        A.append(int(data[index]))
        index += 1
    
    intervals = []
    for _ in range(Q):
        l = int(data[index])
        index += 1
        r = int(data[index])
        index += 1
        intervals.append((l, r))
    
    result = max_beauty_sum(A, intervals)
    print(result)

if __name__ == "__main__":
    main()

Max Intervals✅
Infosys

Guys pls wait i will try to send...asap maximum answers....❤️

kerp sharing  @coding_000✅

#include <iostream>
#include <vector>
#include <numeric>
#define MOD 1000000007
using namespace std;
long long mod_inv(long long x, long long mod) {
    long long result = 1;
    long long power = mod - 2;
    while (power) {
        if (power % 2) {
            result = result * x % mod;
        }
        x = x * x % mod;
        power /= 2;
    }
    return result;
}

vector<long long> factorial(int n, long long mod) {
    vector<long long> fact(n + 1, 1);
    for (int i = 2; i <= n; ++i) {
        fact[i] = fact[i - 1] * i % mod;
    }
    return fact;
}
long long binomial_coeff(int n, int k, const vector<long long>& fact, long long mod) {
    if (k > n || k < 0) {
        return 0;
    }
    return fact[n] * mod_inv(fact[k], mod) % mod * mod_inv(fact[n - k], mod) % mod;
}
long long count_ways(int N, int K, const vector<int>& A) {
    int sum_A = accumulate(A.begin(), A.end(), 0);
    int M = K - sum_A;
    vector<long long> fact = factorial(M + N - 1, MOD);
    return binomial_coeff(M + N - 1, N - 1, fact, MOD);
}

int main() {
    int N, K;
    cin >> N >> K;
    vector<int> A(N);
    for (int i = 0; i < N; ++i) {
        cin >> A[i];
    }
    cout << count_ways(N, K, A) << endl;
    return 0;
}

Distributing Books✅

from math import gcd
from collections import defaultdict

def lcm(a, b):
    return abs(a * b) // gcd(a, b)

def find_minimum_subgraph(N, values, edges):

    total_lcm = values[0]
    for i in range(1, N):
        total_lcm = lcm(total_lcm, values[i])
    
    graph = defaultdict(list)
    for u, v in edges:
        graph[u-1].append(v-1)
        graph[v-1].append(u-1)
    
    min_size = N
    subtree_lcm = values.copy()
    
    def dfs(node, parent):
        nonlocal min_size
        size = 1
        current_lcm = values[node]
        
        for child in graph[node]:
            if child != parent:
                child_size, child_lcm = dfs(child, node)
                size += child_size
                current_lcm = lcm(current_lcm, child_lcm)
        
        if current_lcm == total_lcm:
            min_size = min(min_size, size)
            return 0, total_lcm
        
        return size, current_lcm
    
    dfs(0, -1)
    return min_size

tree cutting✅
Infosys

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const vector<pair<int, int>> directions = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

int InvasionTime(int N, int M, vector<string>& Q) {
    vector<vector<char>> grid(N, vector<char>(M));
    queue<pair<int, int>> q;
    int enemyCount = 0;
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < M; ++j) {
            grid[i][j] = Q[i][j];
            if (grid[i][j] == 'A') {
                q.push({i, j});
            } else if (grid[i][j] == 'E') {
                ++enemyCount;
            }
        }
    }
    if (enemyCount == 0) {
        return 0;
    }

    int time = 0;
    while (!q.empty()) {
        int size = q.size();
        ++time;

        for (int i = 0; i < size; ++i) {
            int x = q.front().first;
            int y = q.front().second;
            q.pop();

            for (const auto& dir : directions) {
                int nx = x + dir.first;
                int ny = y + dir.second;

                if (nx >= 0 && ny >= 0 && nx < N && ny < M && grid[nx][ny] == 'E') {
                    grid[nx][ny] = 'A';
                    q.push({nx, ny});
                    --enemyCount;

                    if (enemyCount == 0) {
                        return time;
                    }
                }
            }
        }
    }

    return -1;
}

int main() {
    int N, M;
    cin >> N >> M;
    cin.ignore(); 

    vector<string> Q(N);
    for (int i = 0; i < N; ++i) {
        getline(cin, Q[i]);
    }

    cout << InvasionTime(N, M, Q) << endl;

    return 0;
}

Army invasion ✅
Infosys

Task Management
Infosys ✅

max triple sum ✅

#include <bits/stdc++.h>
#define ll long long 
using namespace std;

ll mod(ll x, ll m) {
    if (x < m) return 0;
    return x % m;
}

bool check(ll l, ll r, ll k, vector<ll>& a) {
    unordered_map<ll, ll> mp;
    for (ll i = l; i <= r; i++) mp[i]++;
    for (auto it : mp) {
        if (it.second != k) return false;
    }
    return true;
}

ll sumQueries(ll q) {
    ll sum = 0;
    for (ll i = 1; i <= q; i++) sum += i;
    return sum;
}

vector<ll> processQueries(ll n, ll q, vector<vector<ll>>& queries) {
    vector<ll> res(q);
    ll t = 0, tt = 0;
    ll L, R;
    for (ll i = 0; i < q; i++) {
        L = mod((t + queries[i][0]), n) + 1;
        R = mod((tt + queries[i][1]), n) + 1;
        t = L;
        tt = R;
        res[i] = {L, R};
    }
    return res;
}

ll solve(ll n, ll k, vector<ll>& a, ll q, vector<vector<ll>>& queries) {
    if (k == 1) {
        return sumQueries(q);
    }
    vector<ll> p(q);
    vector<ll> processedQueries = processQueries(n, q, queries);
    ll sum = 0;
    ll m = 1e9 + 7;
    for (ll i = 0; i < q; i++) {
        if (check(processedQueries[i].first, processedQueries[i].second, k, a)) {
            p[i] = i + 1;
        }
        sum = (sum + p[i]) % m;
    }
    return sum % m;
}

signed main() {
    ll n, k; cin >> n >> k;
    vector<ll> a(n);
    for (ll i = 0; i < n; i++) cin >> a[i];
    ll q; cin >> q;
    ll two; cin >> two;
    vector<vector<ll>> queries(q, vector<ll>(2));
    for (ll i = 0; i < q; i++) {
        ll x, y; cin >> x >> y;
        queries[i][0] = x;
        queries[i][1] = y;
    }
    cout << solve(n, k, a, q, queries);
    return 0;
}

Online K occurences queries✅
Infosys

#include <bits/stdc++.h>
#define ll long long  
using namespace std;
ll mod(ll x,ll mod)
{
    if(x<mod) return 0;
    return x%mod;
}
bool check(ll l,ll r,ll k,vector<ll>&a)
{
    unordered_map<ll,ll>mpp;
    for(ll i=l;i<=r;i++) mpp[i]++;
    for(auto it:mpp)
    {
       if(it.second!=k) return false;
    }
    return true;
}
ll solve(ll n,ll k,vector<ll>&a,ll q,vector<vector<ll>>&queries)
{
    if(k==1)
    {
        ll sum=0;
        for(ll i=1;i<=q;i++) sum+=i;
        return sum;
    }
    vector<ll>p(q);
    ll t=0,tt=0;
    ll L,R;
    for(ll i=0;i<q;i++)
    {    
        L=mod((t+queries[i][0]),n)+1;
        R=mod((tt+queries[i][1]),n)+1;
        t=L;
        tt=R;
        if(check(L,R,k,a)) p[i]=i+1;
    }
    ll sum=0;
    ll m=1e9+7;
    for(auto  it:p) sum=(sum+it)%m;
    return sum%m;
}
signed main() 
{
    ll n,k; cin>>n>>k;
    vector<ll>a(n);
    for(ll i=0;i<n;i++) cin>>a[i];
    ll q; cin>>q;
    ll two; cin>>two;
    vector<vector<ll>>queries(q,vector<ll>(2));
    for(ll i=0;i<q;i++)
    {
        ll x,y; cin>>x>>y;
        queries[i][0]=x;
        queries[i][1]=y;
        //cout<<x<<" "<<y<<endl;
    }
    cout<<solve(n,k,a,q,queries);
    return 0;
}

K occurance ✅

chair game ✔️✔️

#include <bits/stdc++.h>
#define ll long long  
using namespace std;
ll mod=1e9+7;
ll C(vector<ll>&a,ll n)
{

    ll count=0;
    for(ll i=0;i<n-1;i++) 
    {
        if(((a[i]*a[i+1])-(a[i]+a[i+1]))%2==0) count++;
    }
    return count;
}

void generate(ll n,ll m,ll k,vector<ll>&current,ll&count) 
{
    if (current.size()==n) 
    {
        if (C(current,n)==k) 
        {
            count=(count+1)%mod;
        }
        return;
    }
    for (ll i=1;i<=m;i++) 
    {
        current.push_back(i);
        generate(n,m,k,current,count);
        current.pop_back();
    }
}
ll solve(ll n,ll m,ll k)
{
    vector<ll>current;
    ll count=0;
    generate(n,m,k,current,count);
    return count%mod;
}
signed main() 
{
    ll n,m,k; cin>>n>>m>>k;
    cout<<solve(n,m,k);
    return 0;
}

Perfectly even ✅