#include<bits/stdc++.h>
using namespace std;

vector<int> solve(int Q, vector<vector<int>> queries) {
    vector<int> ans, a(10005, 0);

    for (vector<int>& query : queries) {
        int type = query[0], element = query[1];

        if (type == 0) {
            a[element] = 1;
        } else {
            if (a[element]) {
                ans.push_back(1);
                a[element] = 0;
            } else {
                ans.push_back(0);
            }
        }
    }

    return ans;
}

BST Queries ✅

Opening For GIS Executive( 0-2 Year Only)

Location - Corporate Office Noida West.

Email:- Support@dvertex.com

Reduce to one ✅
NPCI

📣 Job Title: Salesforce Developer (Freshers)

🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟

🏢 Company: VITTECH PVT LTD

📍Location: Pune

👉 Exp: 0- 1 Years

📩 Mail: megha@vittech.in

bool help(int n,unordered_set<char>&mpp)
{
    string s=to_string(n);
    for(auto it:s)
    {
        if(mpp.count(it)) return 1;
    }
    return 0;
}
int solve(vector<int>&a,int n)
{
    sort(a.begin(),a.end());
    int maxi=a[n-1];
    string s=to_string(maxi);
    unordered_set<char>mpp;
    for(auto it:s) mpp.insert(it);

    int ans=-1;
    for(int i=0;i<n-1;i++)
    {
        if(help(a[i],mpp)==0) ans=a[i];
    }
    if(ans==-1) return -1;
    return ans+maxi;
}

Microsoft ✅

Budget planning ✅

#include <bits/stdc++.h>


using namespace std;

int n;
int a[30];
int memo[1 << 23];
int inf = 100;

int solve(int flag){
  if(memo[flag] != -1) return memo[flag];
  if(flag == 1) return 1;

  int ret = inf;
  int b = __builtin_popcount(flag);
  for(int i = n - 1; i >= 0; i--){
    if(flag & (1 << i)){
      int next = (flag ^ (1 << i)) | (1 << (i - 1));
      for(int j=0;j<i;j++)for(int k=0;k<j+1;k++){
        if(a[j] + a[k] == a[i]){
          int tmp = solve(next | (1 << j) | (1 << k));
          if(tmp != inf){
            ret = min(ret, max(b, tmp));
          }
        }
      }
      break;
    }
  }

  return memo[flag] = ret;
}

int main(){
cin>>n;

  for(int i=0;i<n;i++)
  {cin>>a[i];
  }
  memset(memo, -1, sizeof(memo));
  int ans = solve(1 << (n - 1));
  if(ans == inf) ans = -1;
cout<<ans<<endl;
}

Minimum contrast ✅

#include<bits/stdc++.h>
using namespace std;

#define mod 1000000007
#define N 300009


int dp[59][59];
string s[N],t,p,ans;

int f(int i,int j)
{
    if(i==t.size())
        return p.size()-j;
    if(j==p.size())
        return t.size()-i;
    if(dp[i][j]!=-1)
        return dp[i][j];
    if(t[i]==p[j])
        return dp[i][j] = f(i+1,j+1);
    return dp[i][j] = 1 + min({ f(i+1,j), f(i,j+1), f(i+1,j+1)});
}

int main()
{
  ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
   int n;
   cin>>n;
   int i=0;
   while(i<n)
       cin>>s[i++];
    
     int q,best,j,k;
    
     cin>>q;
     while(q--)
     {
         cin>>t;
         best=INT_MAX;
         i=0;
         while(i<n)
         {
             p=s[i];
             j=0;
             while(j<t.size())
             {
                 k=0;
                 while(k<p.size())
                 {
                     dp[j][k]=-1;
                     k++;
                 }
                 j++;
             }
             j=f(0,0);
             if(j<best)
             {
                 best=j;
                 ans=p;
             }
             i++;
         }
         cout << ans << "\n";
     }
}

Auto Suggest ✅

#include <bits/stdc++.h>
using namespace std;

int min(int x, int y, int z)
{
    return min(min(x, y), z);
}

int levenshteinDist(string str1, string str2, int m, int n)
{
    int dp[m + 1][n + 1];

    for (int i = 0; i <= m; i++)
    {
        for (int j = 0; j <= n; j++)
        {
            if (i == 0)
                dp[i][j] = j;

            else if (j == 0)
                dp[i][j] = i;

            else if (str1[i - 1] == str2[j - 1])
                dp[i][j] = dp[i - 1][j - 1];

            else
                dp[i][j] = 1 + min(dp[i][j - 1],     
                                   dp[i - 1][j],     
                                   dp[i - 1][j - 1]);
        }
    }

    return dp[m][n];
}

int main()
{
    int n;
    cin >> n;
  
    vector<string> v(n);
    for (int i = 0; i < n; ++i)
    {
        cin >> v[i];
     
    }
    string s;
    cin >> s;
   
    int mindist = INT_MAX;
    string beststr = "zzzzzzzzzzz";

    for (int i = 0; i < n; ++i)
    {
        int heredist = levenshteinDist(s, v[i], s.size(), v[i].size());
        if (heredist < mindist)
        {
            mindist = heredist;
            beststr = v[i];
            continue;
        }
        if (heredist == mindist)
        {
            if (beststr > v[i])
            {
                // cout << beststr << " " << v[i] << "\n";
                beststr = v[i];
            }
            continue;
        }
    }

    cout << beststr;

    return 0;
}

#include <iostream>
#include <vector>
#include <unordered_set>
#include <algorithm>

using namespace std;

bool hasCommonDigits(int num1, int num2) {
unordered_set<char> digits1, digits2;
string str1 = to_string(num1);
string str2 = to_string(num2);

for (char digit : str1) {
digits1.insert(digit);
}

for (char digit : str2) {
digits2.insert(digit);
}

for (char digit : digits1) {
if (digits2.count(digit) > 0) {
return true;
}
}
return false;
}

int solution(vector<int>& A) {
sort(A.rbegin(), A.rend());

for (size_t i = 0; i < A.size(); ++i) {
bool hasCommon = false;
for (size_t j = i + 1; j < A.size(); ++j) {
if (!hasCommonDigits(A[i], A[j])) {
return A[i] + A[j];
}
}
}

return -1;
}. //microsoft task 1

def find_different_evenness_index(n, numbers):
    odd_count = even_count = 0
    odd_index = even_index = 0

    for i, num in enumerate(numbers):
        if num % 2 == 0:
            even_count += 1
            even_index = i + 1
        else:
            odd_count += 1
            odd_index = i + 1

    return odd_index if even_count > odd_count else even_index

n = int(input())
numbers = list(map(int, input().split()))

result = find_different_evenness_index(n, numbers)
print(result)

Accenture ✅

void solve(string s) {
    unordered_map<char, int> m;
    for (char c : s) {
        m[c]++;
    }

    string result = "";
    for (char c : s) {
        while (m[c] > 0) {
            result += c;
            m[c]--;
        }
    }

   
    cout << result << endl;
}. 

Count all occurrences of character  ✅
Nvidia

int lastStoneWeight(vector<int>& s) {
    priority_queue<int> q(s.begin(), s.end());
    while (q.size() > 1) {
        int a = q.top();
        q.pop();
        int b = q.top();
        q.pop();
        if (a != b) {
            q.push(a - b);
        }
    }
    return q.empty() ? 0 : q.top();
}   NVIDIA   :))

Smashing stones ✅