Coding | EXAMS | IBM ACCENTURE | VIRTUSA | IBM | AMAZON | TCS | EPAM | WILEY EDGE | TECH MAHINDRA | JPMORGAN | HCL | WIPRO

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

#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

#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

Mostly lots of groups are posting wrong answers.. So pls make crt answers...follow our channel ✅

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

vol of cylinder- c++

Flower shop - python ✅

def count_not_divisible(K, L, R):     def sieve_of_eratosthenes(n):         is_prime = [True] * (n + 1)         primes = []         for p in range(2, n + 1):             if is_prime[p]:                 primes.append(p)                 for multiple in range(p * p, n + 1, p):                     is_prime[multiple] = False         return primes     def count_divisible_up_to(x, primes):         from itertools import combinations         count = 0         for i in range(1, len(primes) + 1):             for comb in combinations(primes, i):                 lcm = 1                 for num in comb:                     lcm *= num                     if lcm > x:                         break                 if lcm > x:                     continue                 if i % 2 == 1:                     count += x // lcm                 else:                     count -= x // lcm         return count     def count_not_divisible_up_to(x, primes):         if x == 0:             return 0         return x - count_divisible_up_to(x, primes)     L = int(L)     R = int(R)     primes = sieve_of_eratosthenes(K)         count_R = count_not_divisible_up_to(R, primes)     count_L_minus_1 = count_not_divisible_up_to(L - 1, primes)     return count_R - count_L_minus_1 K = int(input().strip()) L = input().strip() R = input().strip() result = count_not_divisible(K, L, R) print(result) Divisible string ✅ Infosys

#include <bits/stdc++.h> using namespace std; #define int long long int32_t main() {     int N, M;     cin >> N >> M;     vector<vector<int>> grid(N, vector<int>(M));     for (int i = 0; i < N; ++i)     {         for (int j = 0; j < M; ++j)         {             cin >> grid[i][j];         }     }     vector<vector<long long>> dp(N, vector<long long>(M, 0));     vector<vector<long long>> dogDistance(N, vector<long long>(M, LLONG_MAX));     if (grid[0][0] == 0)     {         dogDistance[0][0] = 0;     }     dp[0][0] = grid[0][0];     for (int i = 0; i < N; ++i)     {         for (int j = 0; j < M; ++j)         {             if (i == 0 && j == 0)                 continue;             if (i > 0)             {                 dp[i][j] = max(dp[i][j], dp[i - 1][j] + grid[i][j] - dogDistance[i - 1][j]);                 dogDistance[i][j] = min(dogDistance[i][j], dogDistance[i - 1][j] + 2);             }             if (j > 0)             {                 dp[i][j] = max(dp[i][j], dp[i][j - 1] + grid[i][j] - dogDistance[i][j - 1]);                 dogDistance[i][j] = min(dogDistance[i][j], dogDistance[i][j - 1] + 2);             }             if (grid[i][j] == 0)             {                 dogDistance[i][j] = 0;             }         }     }     cout << dp[N - 1][M - 1] << endl;     return 0; } Lost in orange ✅- c++

swapping code - python3✅

from collections import defaultdict, deque def dfs_count(node, parent, adj, A, mod_target):     count = 0     stack = [(node, parent)]     while stack:         current, parent = stack.pop()         if A[current] % 3 == mod_target:             count += 1         for neighbor in adj[current]:             if neighbor != parent:                 stack.append((neighbor, current))     return count def solve(N, M, A, E, Q, Queries):     adj = defaultdict(list)     for u, v in E:         adj[u-1].append(v-1)         adj[v-1].append(u-1)         total_result = 0     for query in Queries:         if query[0] == 1:             _, U, X = query             U -= 1             A[U] = X         elif query[0] == 2:                 _, U, X = query             U -= 1              mod_target = X % 3             count = dfs_count(U, -1, adj, A, mod_target)             total_result += count         return total_result % (10**9 + 7) Path Queries On MOD Share our channel @Coding_000❤️

Now start and share ur questiona below...👇👇👇 Send your Coding Questions here 👇 https://t.me/exams_discussion

Unmute this channel and share this channel to all your friends... Start at 11:22 ✅

Guys wait don`t start i will upload all...

const int MODULO = 1e9 + 7;

int main() {
    int numElements, divisor;
    cin >> numElements >> divisor;
    vector<int> elements(numElements);
    for (int i = 0; i < numElements; i++) {
        cin >> elements[i];
    }
   
    vector<vector<vector<long long>>> dp(divisor, vector<vector<long long>>(divisor, vector<long long>(divisor, 0)));
    dp[0][0][0] = 1; 
    
    for (int value : elements) {
        vector<vector<vector<long long>>> newDp(divisor, vector<vector<long long>>(divisor, vector<long long>(divisor, 0)));
        
        for (int rSum = 0; rSum < divisor; rSum++) {
            for (int gSum = 0; gSum < divisor; gSum++) {
                for (int bSum = 0; bSum < divisor; bSum++) {
                    if (dp[rSum][gSum][bSum] > 0) {
                        newDp[(rSum + value) % divisor][gSum][bSum] = (newDp[(rSum + value) % divisor][gSum][bSum] + dp[rSum][gSum][bSum]) % MODULO;
                        newDp[rSum][(gSum + value) % divisor][bSum] = (newDp[rSum][(gSum + value) % divisor][bSum] + dp[rSum][gSum][bSum]) % MODULO;
                        newDp[rSum][gSum][(bSum + value) % divisor] = (newDp[rSum][gSum][(bSum + value) % divisor] + dp[rSum][gSum][bSum]) % MODULO;
                    }
                }
            }
        }
        
        dp = newDp;
    }
    
    long long result = 0;
    for (int rSum = 0; rSum < divisor; rSum++) {
        for (int gSum = 0; gSum < divisor; gSum++) {
            int bSum = (divisor - rSum - gSum) % divisor;
            if (bSum < 0) bSum += divisor;
            result = (result + dp[rSum][gSum][bSum]) % MODULO;
        }
    }
    
    cout << result << endl;
    return 0;
}

RGB COUNTING CODE C++✅

Lost in orange code✅ SHare @coding_000✅❤️

Send your Coding Questions here 👇 https://t.me/exams_discussion