allcoding1_official

Infosys Exam 2PM BE READY I WILL SHARE ANSWERS Loading..... Please share with your friends @allcoding1_official

Infosys Exam 2PM BE READY I WILL SHARE ANSWERS Please share with your friends

import java.util.*; class Main { public static long solve(int N, int M, int G, int[] A, int[] B) { if (N == 0 || M == 0) return 0; int maxL = 1; for (int offset = -(M - 1); offset < N; offset++) { int startA = Math.max(0, offset); int endA = Math.min(N - 1, offset + M - 1); int len = endA - startA + 1; if (len <= maxL) continue; int[] diffs = new int[len]; for (int k = 0; k < len; k++) { int idxA = startA + k; int idxB = idxA - offset; diffs[k] = A[idxA] - B[idxB]; } Map> shiftMap = new HashMap<>(); for (int k = 0; k < len; k++) { shiftMap.computeIfAbsent(diffs[k], x -> new ArrayList<>()).add(k); } for (int d : shiftMap.keySet()) { List exactIndices = shiftMap.get(d); int nExact = exactIndices.size(); for (int e = 0; e < nExact; e++) { int left = exactIndices.get(e); int right = exactIndices.get(e); int graceCount = 0; int curLen = 0; for (int k = left; k < len; k++) { if (diffs[k] == d) { curLen++; } else if (Math.abs(diffs[k] - d) <= G && graceCount == 0) { graceCount++; curLen++; } else { break; } } for (int k = left - 1; k >= 0; k--) { if (diffs[k] == d) { curLen++; } else if (Math.abs(diffs[k] - d) <= G && graceCount == 0) { graceCount++; curLen++; } else { break; } } maxL = Math.max(maxL, curLen); } } } return maxL; }

int solve(int n, int index, int maxSum) { auto getSum = [](long long peak, long long count, long long diff) { long long k = min(count, (peak - 1) / diff); long long sum = k * peak - diff * k * (k + 1) / 2; sum += (count - k); return sum; }; auto possible = [&](long long peak) { long long left = getSum(peak, index, 1); long long right = getSum(peak, n - index - 1, 2); long long total = peak + left + right; return total <= maxSum; }; long long low = 1; long long high = maxSum; long long ans = 1; while (low <= high) { long long mid = low + (high - low) / 2; if (possible(mid)) { ans = mid; low = mid + 1; } else { high = mid - 1; } } return (int)ans; }

import java.util.*; class Main { static final int MOD = 1000000007; public static int solve(int N, int F, int T) { int m = N - 2; // dp[s] = ways to obtain sum s using processed nodes long[] dp = new long[T + 1]; dp[0] = 1; for (int i = 0; i < m; i++) { long[] ndp = new long[T + 1]; for (int sum = 0; sum <= T; sum++) { if (dp[sum] == 0) continue; for (int v = 1; v <= F && sum + v <= T; v++) { ndp[sum + v] += dp[sum]; if (ndp[sum + v] >= MOD) ndp[sum + v] %= MOD; } } dp = ndp; } long waysPerPosition = 0; for (int a = 1; a <= F; a++) { for (int b = 1; b <= F; b++) { int need = T - a * b; if (need >= 0 && need <= T) { waysPerPosition += dp[need]; waysPerPosition %= MOD; } } } return (int) ((waysPerPosition * (N - 1)) % MOD); }

import java.util.*; class Main { public static int solve(int N, int[] arr) { int maxVal = 0; for (int x : arr) { if (x > maxVal) maxVal = x; } int[] freq = new int[maxVal + 1]; for (int x : arr) { freq[x]++; } int need = N / 2; int left = 1; int count = 0; int ans = Integer.MAX_VALUE; for (int right = 1; right <= maxVal; right++) { count += freq[right]; while (count >= need) { ans = Math.min(ans, right - left + 1); count -= freq[left]; left++; } } return ans; }

#include <bits/stdc++.h> using namespace std; long long sideSum(long long v, long long count, long long step) { if (count <= 0) return 0; long long full = min(count, (v - 1) / step); long long sum = full * v - step * full * (full + 1) / 2; sum += (count - full) * 1LL; return sum; } bool feasible(long long v, long long n, long long index, long long maxSum) { long long left = index; long long right = n - 1 - index; long long total = v + sideSum(v, left, 1) + sideSum(v, right, 2); return total <= maxSum; } int solve(int n, int index, int maxSum) { long long lo = 1, hi = maxSum, ans = 1; while (lo <= hi) { long long mid = lo + (hi - lo) / 2; if (feasible(mid, n, index, maxSum)) { ans = mid; lo = mid + 1; } else { hi = mid - 1; } } return (int)ans; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); int n; cin >> n; int index; cin >> index; int maxSum; cin >>

import java.util.*; class Main { public static int solve(int P, int M, int k, int[][] piles) { List best = new ArrayList<>(); for (int i = 0; i < P; i++) { ArrayList a = new ArrayList<>(); for (int j = 0; j < M; j++) { if (piles[i][j] != -1) a.add(piles[i][j]); } int n = a.size(); int[] mx = new int[n + 1]; Arrays.fill(mx, Integer.MIN_VALUE); mx[0] = 0; if (n > 0) { int[] pre = new int[n + 1]; for (int j = 0; j < n; j++) pre[j + 1] = pre[j] + a.get(j); for (int len = 1; len <= n; len++) { int bestSum = Integer.MIN_VALUE; for (int s = 0; s + len <= n; s++) { bestSum = Math.max(bestSum, pre[s + len] - pre[s]); } mx[len] = bestSum; } } best.add(mx); } int NEG = -1000000000; int[] dp = new int[k + 1]; Arrays.fill(dp, NEG); dp[0] = 0; for (int[] cur : best) { int[] ndp = new int[k + 1]; Arrays.fill(ndp, NEG); int lim = cur.length - 1; for (int used = 0; used <= k; used++) { if (dp[used] == NEG) continue; for (int take = 0; take <= lim && used + take <= k; take++) { ndp[used + take] = Math.max( ndp[used + take], dp[used] + cur[take] ); } } dp = ndp; } return dp[k]; }

👉Ashok IT AWS Devops Azure Devops 👉Naresh IT All courses 50 rupees Lifetime access Contact:- @meterials_available

👉Ashok IT AWS Devops Azure Devops 👉Naresh IT All courses 50 rupees Lifetime access Contact:- @meterials_available

n = int(raw_input()) k = int(raw_input()) m = int(raw_input()) intervals = [] for i in range(n): s, e, p = map(int, raw_input().split()) intervals.append((s, e, p)) # Sort by start time intervals.sort() # dp[c][i] = maximum profit using exactly c intervals, # ending with interval i dp = [[-1] * n for _ in range(k + 1)] ans = 0 for i in range(n): dp[1][i] = intervals[i][2] ans = max(ans, dp[1][i]) for c in range(2, k + 1): for i in range(n): s2, e2, p2 = intervals[i] best = -1 for j in range(i): s1, e1, p1 = intervals[j] if e1 <= s2 and (s2 - e1) % m == 0: if dp[c - 1][j] != -1: best = max(best, dp[c - 1][j] + p2) dp[c][i] = best if best > ans: ans = best print ans

MOD = 1000000007 N = int(raw_input()) K = int(raw_input()) ways = [0] * (N + 1) ans = [0] * (N + 1) prefWays = [0] * (N + 1) prefAns = [0] * (N + 1) ways[0] = 1 prefWays[0] = 1 for i in range(1, N + 1): l = max(0, i - K) r = i - 1 ways[i] = (prefWays[r] - (prefWays[l - 1] if l > 0 else 0)) % MOD ans[i] = ( prefAns[r] - (prefAns[l - 1] if l > 0 else 0) + ways[i] ) % MOD prefWays[i] = (prefWays[i - 1] + ways[i]) % MOD prefAns[i] = (prefAns[i - 1] + ans[i]) % MOD print ans[N] % MOD

import sys input = sys.stdin.readline def digit_sum(n: int) -> int: return sum(int(c) for c in str(n)) def solve(N: int, S: int) -> list: if S == 0: m = 0 else: num_digits = (S + 8) // 9 # ceil(S/9) first = S - 9 * (num_digits - 1) m = int(str(first) + '9' * (num_digits - 1)) if m <= N: return [1, m] else: return [0, -1] if name == "main": try: N = int(input()) S = int(input()) result = solve(N, S) print(" ".join(map(str, result))) except (EOFError, ValueError): pass

#include <bits/stdc++.h> using namespace std; long long solve(int N, int M, long long K, long long C, vector<vector<int>>& g) { vector<vector<long long>> dist(N, vector<long long>(M, LLONG_MAX)); dist[0][0] = g[0][0]; priority_queue<tuple<long long,int,int>, vector<tuple<long long,int,int>>, greater<>> pq; pq.push({dist[0][0], 0, 0}); while (!pq.empty()) { auto [d, r, c] = pq.top(); pq.pop(); if (d > dist[r][c]) continue; if (r == N-1 && c == M-1) break; for (int j = c+1; j < M; j++) { long long diff = llabs((long long)g[r][j] - g[r][c]); long long step = j - c; long long cost; if (step == 1) { cost = g[r][j] + (diff > K ? C : 0); } else { if (diff > K) continue; cost = g[r][j] + C * (step - 1); } long long nd = d + cost; if (nd < dist[r][j]) { dist[r][j] = nd; pq.push({nd, r, j}); } } for (int i = r+1; i < N; i++) { long long diff = llabs((long long)g[i][c] - g[r][c]); long long step = i - r; long long cost; if (step == 1) { cost = g[i][c] + (diff > K ? C : 0); } else { if (diff > K) continue; cost = g[i][c] + C * (step - 1); } long long nd = d + cost; if (nd < dist[i][c]) { dist[i][c] = nd; pq.push({nd, i, c}); } } } return dist[N-1][M-1]; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); int N; cin >> N; int M; cin >> M; long long K; cin >> K; long long C; cin >> C; vector<vector<int>> g(N, vector<int>(M)); for (int i = 0; i < N; i++) for (int j = 0; j < M; j++) cin >> g[i][j]; auto result = solve(N, M, K, C, g); cout << result << endl; return 0; }