Endi mavjud! Telegram Tadqiqoti 2025 — yilning asosiy insaytlari 
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 156
Obunachilar
Ma'lumot yo'q24 soatlar
Ma'lumot yo'q7 kunlar
+730 kunlar
Postlar arxiv
#include <iostream>
#include <vector>
#include <unordered_set>
#include <unordered_map>
struct Expert {
int id;
std::unordered_set<std::string> topics;
std::unordered_set<std::string> languages;
};
struct Customer {
std::string topic;
std::string language;
};
int assignCustomers(const std::vector<Customer>& customers, const std::vector<Expert>& experts) {
std::unordered_set<int> assignedCustomers;
int unhappyCustomers = 0;
for (const Customer& customer : customers) {
bool assigned = false;
for (const Expert& expert : experts) {
if (expert.topics.count(customer.topic) && expert.languages.count(customer.language) && assignedCustomers.find(expert.id) == assignedCustomers.end()) {
assignedCustomers.insert(expert.id);
assigned = true;
break;
}
}
if (!assigned) {
unhappyCustomers++;
}
}
return unhappyCustomers;
}
int main() {
int numExperts;
std::cin >> numExperts;
std::vector<Expert> experts;
for (int i = 0; i < numExperts; ++i) {
Expert expert;
std::cin >> expert.id;
int numTopics;
std::cin >> numTopics;
for (int j = 0; j < numTopics; ++j) {
std::string topic;
std::cin >> topic;
expert.topics.insert(topic);
}
int numLanguages;
std::cin >> numLanguages;
for (int j = 0; j < numLanguages; ++j) {
std::string language;
std::cin >> language;
expert.languages.insert(language);
}
experts.push_back(expert);
}
int numCustomers;
std::cin >> numCustomers;
std::vector<Customer> customers;
for (int i = 0; i < numCustomers; ++i) {
Customer customer;
std::cin >> customer.topic >> customer.language;
customers.push_back(customer);
}
int unhappyCount = assignCustomers(customers, experts);
std::cout << unhappyCount << std::endl;
return 0;
}
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,m;
cin>>n>>m;
vector<int>ans(n);
if(n<=m){
for(int i=0;i<n;i++){
ans[i]=i+1;
}
}
else{
int k=n/m;
// int r=n%m;
int j=0;
for(int i=0;i<n;i++){
ans[i]=j+1;
j++;
j%=m;
}
}
for(int i=0;i<n;i++){
cout<<ans[i]<<" ";
}
cout<<endl;
}
//king dream
int longestCipherLength(const string& s) {
int maxLength = -1;
int currentLength = 0;
bool hasUppercase = false;
for (char c : s) {
if (isupper(c)) {
hasUppercase = true;
currentLength++;
} else if (isdigit(c)) {
currentLength = 0;
} else {
currentLength++;
}
maxLength = max(maxLength, currentLength);
}
return hasUppercase ? maxLength : -1;
}
cipher
int solve(vector>& grid) {
int n=grid.size(),m=grid[0].size();
int dirx[4]={-1,1,0,0};
int diry[4]={0,0,-1,1};
queue> q;
int cnt=0,cnt2=0;
vector> vis(n,vector(m,-1));
for(int i=0;i p1=q.front();
q.pop();
int i=p1.first,j=p1.second;
for(int k=0;k<4;k++){
int x=i+dirx[k];
int y=j+diry[k];
if(x>=0 and x=0 and y0) return -1;
return 0;
}
int main() {
int n,m;
cin>>n>>m;
vector> v(n,vector(m));
for(int i=0;i>v[i][j];
cout<
#include <iostream>
#include <queue>
using namespace std;
class T {
public:
int x;
T* l;
T* r;
T(int x_, T* l_ = nullptr, T* r_ = nullptr) : x(x_), l(l_), r(r_) {}
T() : x(0), l(nullptr), r(nullptr) {}
};
T* extendT(T* node) {
if (!node) return node;
if (!node->l && !node->r) {
node->l = new T(node->x,nullptr,nullptr);
node->r = new T(node->x,nullptr,nullptr);
} else {
extendT(node->l);
extendT(node->r);
}
return node;
}
void printLevelOrder(T* root) {
if (!root) return;
queue<T*> q;
q.push(root);
while (!q.empty()) {
T* node = q.front();
q.pop();
cout << node->x << " ";
if (node->l) q.push(node->l);
if (node->r) q.push(node->r);
}
cout << endl;
}
int main() {
// Creating the specified binary T
T* root = new T(1);
root->l = new T(2);
root->r = new T(3);
root->l->l = new T(4);
root->l->r = new T(5);
root->r->l = new T(6);
cout << "Original T (Level-order traversal): ";
printLevelOrder(root);
root = extendT(root);
cout << "Extended T (Level-order traversal): ";
printLevelOrder(root);
return 0;
}
#include <iostream>
#include <vector>
using namespace std;
int solution(vector<string> &A) {
int RR = 0, GG = 0, RG = 0, GR = 0;
for (string &s : A) {
if (s == "RR") RR++;
else if (s == "GG") GG++;
else if (s == "RG") RG++;
else GR++;
}
if (RG || GR)
return RR + GG + 2 * min(RG, GR) + (RG != GR);
else
return max(RR, GG);
} // MICROSOFT TASK 1
int balloonGame(int n, int input2[])
{
int64_t dp[(1 << n)];
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
for (int i = 1; i < (1 << n); i++) {
int x = __builtin_popcount(i);
for (int j = 0; j < n; j++) {
if (i & (1 << j)) {
int pv = i ^ (1 << j);
int64_t nx = dp[pv] + (input2[j] + (x-1)) / x;
dp[i] = min(dp[i], nx);
}
}
}
return dp[(1 << n) - 1];
}
Balloon Game ✅
#include <iostream>
#include <vector>
using namespace std;
const int MOD = 10000007;
#define ll long long
#define vvll vector<vector<ll>>
vvll multiply(vvll& A, vvll& B ) {
int n = A.size();
vvll C(n, vector<ll>(n, 0));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
for (int k = 0; k < n; ++k) {
C[i][j] = (C[i][j] + A[i][k] * B[k][j]) % MOD;
}
}
}
return C;
}
vvll matrixExpo(vvll A, int power) {
int n = A.size();
vvll result(n, vector<ll>(n, 0));
for (int i = 0; i < n; ++i) {
result[i][i] = 1;
}
while (power > 0) {
if (power % 2 == 1) {
result = multiply(result, A);
}
A = multiply(A, A);
power /= 2;
}
return result;
}
int solve(vector<int>& input) {
int a = input[0], b = input[1], c = input[2], d = input[3], e = input[4], f = input[5], N = input[6];
if (N <= 1) return 1;
vvll T = {
{a, b, 0, 0, 0, 0},
{1, 0, 0, 0, 0, 0},
{0, 0, c, d, 0, 0},
{0, 0, 1, 0, 0, 0},
{0, 0, 0, 0, e, f},
{0, 0, 0, 1, 0, 0}
};
vector<ll> F = {1, 1, 1, 1, 1, 1};
vvll T_power = matrixExpo(T, N - 1);
ll result = 0;
for (int i = 0; i < 6; ++i) {
result = (result + T_power[0][i] * F[i]) % MOD;
}
return result;
}
int main() {
vector<int> input = {1, 1, 1, 1, 1, 1, 3};
cout << solve(input) << endl;
return 0;
}
//linear recurrence ivp
#include <iostream>
#include <vector>
using namespace std;
bool canTransform(vector<vector<int>>& gridA, vector<vector<int>>& gridB, int rows, int cols) {
for (int row = rows - 1; row >= 1; --row) {
for (int col = cols - 1; col >= 1; --col) {
if (gridA[row][col] != gridB[row][col]) {
int diff = (gridB[row][col] - gridA[row][col] + 3) % 3;
gridA[row][col] = gridB[row][col];
gridA[row-1][col] = (gridA[row-1][col] + 2 * diff) % 3;
gridA[row][col-1] = (gridA[row][col-1] + 2 * diff) % 3;
gridA[row-1][col-1] = (gridA[row-1][col-1] + diff) % 3;
}
}
}
for (int row = 0; row < rows; ++row) {
if (gridA[row][0] != gridB[row][0]) return false;
}
for (int col = 0; col < cols; ++col) {
if (gridA[0][col] != gridB[0][col]) return false;
}
return true;
}
int main() {
int testCases;
cin >> testCases;
while (testCases--) {
int rows, cols;
cin >> rows >> cols;
vector<vector<int>> gridA(rows, vector<int>(cols));
vector<vector<int>> gridB(rows, vector<int>(cols));
for (int row = 0; row < rows; ++row) {
for (int col = 0; col < cols; ++col) {
char value;
cin >> value;
gridA[row][col] = value - '0';
}
}
for (int row = 0; row < rows; ++row) {
for (int col = 0; col < cols; ++col) {
char value;
cin >> value;
gridB[row][col] = value - '0';
}
}
if (canTransform(gridA, gridB, rows, cols)) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
