IBM Oa Help | Oa Exam Helper
Kanalga Telegram’da o‘tish
We are here to clear All types of Exams Admin : @Codercpp001 (aka) KMK ✅ INTERVIEW HELP AVAILABLE 1-Coding Round 2-Aptitude and Reasoning Round 3-Communication round 4-Resume building 🎉Job updates will be posted here.
Ko'proq ko'rsatish1 163
Obunachilar
Ma'lumot yo'q24 soatlar
-47 kunlar
+430 kunlar
Postlar arxiv
const int MOD 1000000007;
int subsetSumCount(const vector<int>& A, int L, int R, int K) {
vector<int> dp(K+1, 0); dp[0] = 1;
for (int i=L; i<=R; ++i) { for (int j = K; j >= A[1];
--j) {
dp[j] = (dp[j] + dp[j- A[i]]) % MOD; }
}
return dp[K];}
int findXOR(int n, int Q,
const vector<int>& A, const vector<vector<int>>& B) {
int result = 0;
for (const auto& query: B) {
int L= query [0] - 1;
int R= query [1] -1;
int K = query[2];
int P=subsetSumCount(A,L,R,K);
result ^= P;
}
return result;
}
#include <iostream>
#include <vector>
#include <unordered_map>
#include <unordered_set>
using namespace std;
void dfs(int x, int y, vector<unordered_set<int>>& v, unordered_map<int, vector<int>>& t, vector<int>& a) {
unordered_set<int> s;
s.insert(a[x]);
for (int z : t[x]) {
if (z != y) {
dfs(z, x, v, t, a);
for (int elem : v[z]) {
s.insert(elem);
}
}
}
v[x] = s;
}
int find_sets(int n, vector<int>& a, vector<int>& p) {
unordered_map<int, vector<int>> t;
for (int i = 1; i < n; ++i) {
t[p[i]].push_back(i);
t[i].push_back(p[i]);
}
vector<unordered_set<int>> v(n);
dfs(0, -1, v, t, a);
int r = 0;
for (int i = 1; i < n; ++i) {
int y = p[i];
if (y < v.size()) {
unordered_set<int>& s1 = v[i];
unordered_set<int>& s2 = v[y];
unordered_set<int> s_diff;
for (int elem : s2) {
if (s1.find(elem) == s1.end()) {
s_diff.insert(elem);
}
}
if (s_diff.empty()) {
++r;
}
}
}
return r;
}
int main() {
int n;
cin >> n;
vector<int> a(n);
vector<int> p(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i < n; ++i) {
cin >> p[i];
}
int result = find_sets(n, a, p);
cout << result << endl;
return 0;
}. //Tree dupilcates
dp[i+1][0][0][(j + addv)%k][pv+1] += dp[i][1][0][j][pv];
dp[i+1][0][0][(j + addv)%k][pv+1] %= mod;
}
else{
dp[i+1][1][0][(j + addv)%k][pv+1] += dp[i][1][0][j][pv];
dp[i+1][1][0][(j + addv)%k][pv+1] %= mod;
}
// le = 0, re = 1
if(r[i] == '0'){
dp[i+1][0][1][j][pv-1] += dp[i][0][1][j][pv];
dp[i+1][0][1][j][pv-1] %= mod;
}
else{
dp[i+1][0][1][(j + addv)%k][pv+1] += dp[i][0][1][j][pv];
dp[i+1][0][1][(j + addv)%k][pv+1] %= mod;
dp[i+1][0][0][j][pv-1] += dp[i][0][1][j][pv];
dp[i+1][0][0][j][pv-1] %= mod;
}
// le = 0, re = 0
dp[i+1][0][0][j][pv-1] += dp[i][0][0][j][pv];
dp[i+1][0][0][j][pv-1] %= mod;
dp[i+1][0][0][(j + addv)%k][pv+1] += dp[i][0][0][j][pv];
dp[i+1][0][0][(j + addv)%k][pv+1] %= mod;
}
}
}
}
int ans = 0;
for(int i = 0; i <= n; i++){
for(int j = 0; j < 2; j++){
for(int z = 0; z < 2; z++){
ans += dp[n][j][z][0][i];
ans %= mod;
}
}
}
return ans;
}
int32_t main(){
cin.tie(0); cout.tie(0);
ios_base::sync_with_stdio(false);
int m, n, k;
cin>>m>>n>>k;
string l, r;
cin>>l>>r;
cout<
#include<bits/stdc++.h>
#define pb push_back
#define int long long
using namespace std;
const int mod = 1e9+7;
const int N = 1e2 + 5;
int get_ans(int m, int n, int k, string l, string r){
int dp[n+1][2][2][k][n+1];
for(int i = 0; i <= n; i++){
for(int j = 0; j < k; j++){
for(int pv = 0; pv <= n; pv++){
dp[i][0][0][j][pv] = dp[i][0][1][j][pv] = dp[i][1][0][j][pv] = dp[i][1][1][j][pv] = 0;
}
}
}
vector<int> add(n+1);
add[0] = (1%k);
for(int i = 1; i <= n; i++){
add[i] = (add[i-1] * 2)%k;
}
if(m == n) dp[1][1][1][(add[n-1])%k][1] = 1;
else{
dp[1][0][1][(add[n-1])%k][1] = 1;
for(int i = 1; i < n; i++){
if(l[i] == '1'){
dp[i+1][1][0][add[n - i - 1]%k][1] = 1;
break;
}
else dp[i+1][0][0][add[n - i - 1]%k][1] = 1;
}
}
string ll = "";
for(int i = m; i < n; i++){
ll += '0';
}
for(int i = 0; i < l.size(); i++){
ll += l[i];
}
l = ll;
for(int i = 0; i < n; i++){
int addv = add[(n - i - 1)];
for(int j = 0; j < k; j++){
for(int pv = 0; pv < n; pv++){
if(pv == 0){
// le = 1, re = 1
if(l[i] != r[i]){
dp[i+1][0][1][(j + addv)%k][pv+1] += dp[i][1][1][j][pv];
dp[i+1][0][1][(j + addv)%k][pv+1] %= mod;
}
else{
if(l[i] == '0'){
}
else{
dp[i+1][1][1][(j + addv)%k][pv+1] += dp[i][1][1][j][pv];
dp[i+1][1][1][(j + addv)%k][pv+1] %= mod;
}
}
// le = 1, re = 0
if(l[i] == '0'){
dp[i+1][0][0][(j + addv)%k][pv+1] += dp[i][1][0][j][pv];
dp[i+1][0][0][(j + addv)%k][pv+1] %= mod;
}
else{
dp[i+1][1][0][(j + addv)%k][pv+1] += dp[i][1][0][j][pv];
dp[i+1][1][0][(j + addv)%k][pv+1] %= mod;
}
// le = 0, re = 1
if(r[i] == '0'){
}
else{
dp[i+1][0][1][(j + addv)%k][pv+1] += dp[i][0][1][j][pv];
dp[i+1][0][1][(j + addv)%k][pv+1] %= mod;
}
// le = 0, re = 0
dp[i+1][0][0][(j + addv)%k][pv+1] += dp[i][0][0][j][pv];
dp[i+1][0][0][(j + addv)%k][pv+1] %= mod;
}
else{
// le = 1, re = 1
if(l[i] != r[i]){
dp[i+1][1][0][j][pv-1] += dp[i][1][1][j][pv];
dp[i+1][1][0][j][pv-1] %= mod;
dp[i+1][0][1][(j + addv)%k][pv+1] += dp[i][1][1][j][pv];
dp[i+1][0][1][(j + addv)%k][pv+1] %= mod;
}
else{
if(l[i] == '0'){
dp[i+1][1][1][j][pv-1] += dp[i][1][1][j][pv];
dp[i+1][1][1][j][pv-1] %= mod;
}
else{
dp[i+1][1][1][(j + addv)%k][pv+1] += dp[i][1][1][j][pv];
dp[i+1][1][1][(j + addv)%k][pv+1] %= mod;
}
}
// le = 1, re = 0
if(l[i] == '0'){
dp[i+1][1][0][j][pv-1] += dp[i][1][0][j][pv];
dp[i+1][1][0][j][pv-1] %= mod;
def is_palindrome(s):
return s == s[::-1]
def longest_palindrome_from_substrings(A):
palindromes = []
pairs = []
max_single_palindrome = ""
for s in A:
if is_palindrome(s):
palindromes.append(s)
if len(s) > len(max_single_palindrome):
max_single_palindrome = s
for i in range(len(A)):
for j in range(i + 1, len(A)):
combined1 = A[i] + A[j]
combined2 = A[j] + A[i]
if is_palindrome(combined1):
pairs.append(combined1)
if is_palindrome(combined2):
pairs.append(combined2)
longest_palindrome = max_single_palindrome
for p in pairs:
if len(p) > len(longest_palindrome):
longest_palindrome = p
return longest_palindrome
#include <bits/stdc++.h>
#define ll long long
using namespace std;
ll solve(string&s)
{
ll cnt1=0,cnt0=0;
for(auto&it:s)
{
if(it=='1') cnt1++;
else cnt0++;
}
ll n=s.size(),ans=0;
for(ll i=0;i<n;i++)
{
if(s[i]=='1')
{
if(cnt0==0)
{
ans=n-1-i+1;
break;
}
else{
cnt0--;
}
}
else
{
if(cnt1==0)
{
ans=n-1-i+1;
break;
}
else cnt1--;
}
}
return ans;
}
signed main()
{
string s; cin>>s;
cout<<solve(s);
return 0;
}
//swap and delete string
using namespace std;
int main() {
int tt = 1;
for (int t = 1; t <= tt; t++) {
int n;
cin >> n;
vector a(n);
vector prime(301, 0);
prime[1] = 1;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 2; i <= 300; i++) {
if (prime[i] == 0) {
for (int j = 2 * i; j <= 300; j += i) {
prime[j] = 1;
}
}
}
unordered_map count;
int cnt = 0;
map> map;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
int sum = a[i] + a[j];
if (prime[sum] == 0) {
cnt++;
count[a[i]]++;
count[a[j]]++;
map[a[i]].push_back(a[j]);
map[a[j]].push_back(a[i]);
}
}
}
vector> list(count.begin(), count.end());
sort(list.begin(), list.end(), [](const pair& entry1, const pair& entry2) {
return entry2.second > entry1.second;
});
count.clear();
for (auto& entry : list) {
count[entry.first] = entry.second;
}
int ans = 0;
while (cnt > 0) {
auto firstEntry = *count.begin();
cnt -= firstEntry.second;
ans++;
count[firstEntry.first] = 0;
for (int it : map[firstEntry.first]) {
count[it]--;
}
list.assign(count.begin(), count.end());
sort(list.begin(), list.end(), [](const pair& entry1, const pair& entry2) {
return entry2.second > entry1.second;
});
count.clear();
for (auto& entry : list) {
count[entry.first] = entry.second;
}
}
cout << n - ans << endl;
}
return 0;
}
import java.util.*;
public class PrimeSumOptimal {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int[] A = new int[N];
for (int i = 0; i < N; i++) {
A[i] = sc.nextInt();
}
System.out.println(maxNonPrimeSumSubset(A, N));
sc.close();
}
private static boolean[] isPrime;
private static void sieve(int maxLimit) {
isPrime = new boolean[maxLimit + 1];
Arrays.fill(isPrime, true);
isPrime[0] = isPrime[1] = false;
for (int p = 2; p * p <= maxLimit; p++) {
if (isPrime[p]) {
for (int i = p * p; i <= maxLimit; i += p) {
isPrime[i] = false;
}
}
}
}
private static boolean isPrime(int num) {
return isPrime[num];
}
private static int maxNonPrimeSumSubset(int[] A, int N) {
sieve(1000);
int maxSubsetSize = 0;
for (int bitmask = 0; bitmask < (1 << N); bitmask++) {
List<Integer> subset = new ArrayList<>();
for (int i = 0; i < N; i++) {
if ((bitmask & (1 << i)) != 0) {
subset.add(A[i]);
}
}
boolean validSubset = true;
int subsetSize = subset.size();
for (int i = 0; i < subsetSize && validSubset; i++) {
for (int j = i + 1; j < subsetSize; j++) {
if (isPrime(subset.get(i) + subset.get(j))) {
validSubset = false;
break;
}
}
}
if (validSubset) {
maxSubsetSize = Math.max(maxSubsetSize, subsetSize);
}
}
return maxSubsetSize;
}
}.
#include <bits/stdc++.h>
#define ll long long
using namespace std;
#define ll long long
ll solve(vector<ll>&a)
{
ll n=a.size();
vector<ll>dp(n, 1);
for (ll i=1;i<n;i++)
{
for (ll j=0;j<i;j++)
{
if (a[j]<a[i] && __gcd(a[j],a[i])>1) {
dp[i]=max(dp[i],dp[j]+1);
}
}
}
return *max_element(dp.begin(), dp.end());
}
signed main()
{
ll n; cin>>n;
vector<ll>a(n);
for(ll i=0;i<n;i++) cin>>a[i];
cout<<solve(a);
return 0;
}
#include <bits/stdc++.h>
#define int long long
using namespace std;
#define ll long long
ll solve(ll n,ll k,vector<ll>&a)
{
k++;
unordered_map<ll,ll>freq;
map<ll,vector<ll>>mpp;
for (ll i=0;i<n;i++)
{
freq[a[i]]++;
mpp[freq[a[i]]].push_back(a[i]);
}
ll ans=0;
for (auto it:mpp) ans+=it.second.size();
return ans;
}
signed main()
{
ll n,k; cin>>n>>k;
vector<ll>a(n);
for(ll i=0;i<n;i++) cin>>a[i];
cout<<solve(n,k,a);
return 0;
}
Sequence split ✅
const int MOD = 1000000007;
int subsetSumCount(const vector<int>& A, int L, int R, int K) {
vector<int> dp(K + 1, 0);
dp[0] = 1;
for (int i = L; i <= R; ++i) {
for (int j = K; j >= A[i]; --j) {
dp[j] = (dp[j] + dp[j - A[i]]) % MOD;
}
}
return dp[K];
}
int findXOR(int n, int Q, const vector<int>& A, const vector<vector<int>>& 😎 {
int result = 0;
for (const auto& query : 😎 {
int L = query[0] - 1;
int R = query[1] - 1;
int K = query[2];
int P = subsetSumCount(A, L, R, K);
result ^= P;
}
return result;
}
//subarray subset sum
#include <iostream>
#include <unordered_set>
#include <string>
using namespace std;
void generateSubstrings(const string &s, int len, unordered_set<string> &substrings) {
for (int i = 0; i <= s.size() - len; ++i) {
substrings.insert(s.substr(i, len));
}
}
string findMinimalString(const string &s) {
unordered_set<string> substrings;
for (int len = 1; ; ++len) {
substrings.clear();
generateSubstrings(s, len, substrings);
string candidate(len, 'a');
while (true) {
if (substrings.find(candidate) == substrings.end()) {
return candidate;
}
int pos = len - 1;
while (pos >= 0 && candidate[pos] == 'z') {
candidate[pos] = 'a';
--pos;
}
if (pos < 0) break;
++candidate[pos];
}
}
}
int main() {
string S;
cin >> S;
cout << findMinimalString(S) << endl;
return 0;
}.
