GeeksForGeeks - POTD | GFG POTD Answer
کانال بسته
1 218
مشترکین
اطلاعاتی وجود ندارد24 ساعت
-97 روز
-5730 روز
آرشیو پست ها
class Solution{
public:
int minimumNumber(int n,vector &arr){
int ans = 0;
for(int x: arr) ans = __gcd(ans, x);
return ans;
}
};
class Solution{
public:
vector smallerSum(int n,vector &arr){
// Code here
vectorarr1(arr.begin(),arr.end());
vectorsumarr(n,0);vectorans(n,0);
sort(arr1.begin(),arr1.end());
sumarr[0]=arr1[0];
for(int i=1;i
class Solution{
public:
int prefixSuffixString(vector &s1,vector s2){
unordered_mapmp;
for(auto i:s2){
mp[i]++;
}
int count=0;
for(int i=0;i0){
count++;
mp[a]--;
}}
if(mp.find(b)!=mp.end()){
if(mp[b]>0){
count++;
mp[b]--;
}
};
}
}
return count;
}
};
/*
// node structure:
struct Node
{
int data;
Node* left;
Node* right;
};
*/
class Solution{
public:
Node* ParentFind(Node *root,int home,unordered_map &parent)
{
queue q;
q.push(root);
parent[root]=NULL;
while(!q.empty())
{
Node *p=q.front();
q.pop();
if(p->data==home)
return p;
if(p->left)
{
q.push(p->left);
parent[p->left]=p;
}
if(p->right)
{
q.push(p->right);
parent[p->right]=p;
}
}
return NULL;
}
void CalculateLadoos(Node *strt,int k,int &ans,unordered_map &parent)
{
ans+=strt->data;
unordered_map vis;
queue> q;
q.push({strt,0});
vis[strt]=1;
while(!q.empty())
{
Node *temp=q.front().first;
int steps=q.front().second;
q.pop();
if(steps==k)break;
if(temp->left && vis.find(temp->left)==vis.end())
{
q.push({temp->left,steps+1});
vis[temp->left]=1;
ans+=temp->left->data;
}
if(temp->right && vis.find(temp->right)==vis.end())
{
q.push({temp->right,steps+1});
vis[temp->right]=1;
ans+=temp->right->data;
}
if(parent[temp] != NULL && vis.find(parent[temp])==vis.end())
{
vis[parent[temp]]=1;
q.push({parent[temp],steps+1});
ans+=parent[temp]->data;
}
}
}
int ladoos(Node* root, int home, int k)
{
unordered_map parent;
Node *strt=ParentFind(root,home,parent);
int ans=0;
CalculateLadoos(strt,k,ans,parent);
return ans;
}
};
class Solution{
public:
bool wifiRange(int N, string S, int X){
int k = -1;
for(int i=0;ik+1)return false;
k = i+X;
}
}
return k>=N-1;
}
};
class Solution {
public:
map sum, bst, len;
int ans;
int find_sum(Node* root)
{
if(root == NULL)
return 0;
return sum[root] = find_sum(root->left) + find_sum(root->right) + root->data;
}
pair> is_bst(Node* root)
{
if(root == NULL)
return {2, {0, 0}};
int small = root->data, big = root->data;
pair> left = is_bst(root->left);
pair> right = is_bst(root->right);
if(left.first == 0 || right.first == 0)
{
bst[root] = 0;
return {0, {0, 0}};
}
if(left.first != 2)
{
if(root->data <= left.second.second)
{
bst[root] = 0;
return {0, {0, 0}};
}
small = left.second.first;
}
if(right.first != 2)
{
if(root->data >= right.second.first)
{
bst[root] = 0;
return {0, {0, 0}};
}
big = right.second.second;
}
bst[root] = 1;
return {1, {small, big}};
}
int find_len(Node* root)
{
if(root == NULL)
return 0;
return len[root] = 1 + find_len(root->left) + find_len(root->right);
}
void mine(Node* root, int tar)
{
if(root == NULL)
return;
if(sum[root] == tar && bst[root])
{
ans = min(ans, len[root]);
return;
}
mine(root->left, tar);
mine(root->right, tar);
return;
}
int minSubtreeSumBST(int target, Node *root) {
ans = 1e9;
find_sum(root);
is_bst(root);
find_len(root);
mine(root, target);
if(ans == 1e9)
return -1;
return ans;
}
};
/*
struct Job
{
int id; // Job Id
int dead; // Deadline of job
int profit; // Profit if job is over before or on deadline
};
*/
class Solution
{
public:
vector JobScheduling(Job arr[], int n)
{
vector>v;
for(int i=0;i=1;--it){
if(!vis[it]){
vis[it]=true;
++cnt;
ans+=f;
break;
}
}
}
return {cnt,ans};
}
};
class Solution {
public:
long long solve(int N, vector &A, vector &B) {
vector AEvenOdd[2], BEvenOdd[2];
long long sum1 = 0, sum2 = 0;
for(int i = 0; i < N; ++i) {
sum1 += A[i];
sum2 += B[i];
if(abs(A[i]) % 2 == 0)
AEvenOdd[0].push_back(A[i]);
else
AEvenOdd[1].push_back(A[i]);
if(abs(B[i]) % 2 == 0)
BEvenOdd[0].push_back(B[i]);
else
BEvenOdd[1].push_back(B[i]);
}
if(sum1 != sum2 || (AEvenOdd[0].size() != BEvenOdd[0].size()))
return -1;
long long ans = 0;
for(int i = 0; i < 2; ++i) {
sort(AEvenOdd[i].begin(), AEvenOdd[i].end());
sort(BEvenOdd[i].begin(), BEvenOdd[i].end());
for(int j = 0; j < AEvenOdd[i].size(); ++j) {
ans += abs(AEvenOdd[i][j] - BEvenOdd[i][j]) / 2;
}
}
return ans / 2;
}
};
class Solution {
public:
int totalTime(int n, vector &arr, vector &time) {
unordered_mapm;
int sum=0;m[arr[0]]++;
for(int i=1;i
