int solve(vector<vector<int>>& grid) {
        int n=grid.size(),m=grid[0].size();
        int dirx[4]={-1,1,0,0};
        int diry[4]={0,0,-1,1};
        queue<pair<int,int>> q;
        int cnt=0,cnt2=0;
        vector<vector<int>> vis(n,vector<int>(m,-1));
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(grid[i][j]==2){
                    q.push({i,j});
                    vis[i][j]=1;
                    cnt2++;
                }else if(grid[i][j]==1){
                     cnt++;
                }
            }
        }
       
        int len=0;
        while(q.size()){
           
            int sz=q.size();
            if(cnt==0) return len;
            for(int l=0;l<sz;l++){
               
               
                pair<int,int> 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<n and y>=0 and y<m and vis[x][y]==-1 and grid[x][y]==1){
                        q.push({x,y});
                        vis[x][y]=1;
                        cnt--;
                    }  
                }  
            }
           
            len++;
        }
        if(cnt>0) return -1;
        return 0;
    }
int main() {
 
  int n,m;
  cin>>n>>m;
  vector<vector<int>> v(n,vector<int>(m));
  for(int i=0;i<n;i++)
  for(int j=0;j<m;j++)
     cin>>v[i][j];
    
  cout<<solve(v);    
 
 
    }

Virus Spread ✅

#include <bits/stdc++.h>
using namespace std;
#define MAXN 30005
vector<int> adj[MAXN];
int value[MAXN];
int xor_from_root[MAXN];
bool visited[MAXN];
void dfs(int node, int xor_val) {
    visited[node] = true;
    xor_from_root[node] = xor_val ^ value[node];
    
    for (int neighbor : adj[node]) {
        if (!visited[neighbor]) {
            dfs(neighbor, xor_from_root[node]);
        }
    }
}
void solve(int N, int Q, vector<int>& values, vector<pair<int, int>>& edges, vector<tuple<int, int, int>>& queries) {
    for (int i = 1; i <= N; ++i) {
        value[i] = values[i - 1];
    }
    
    for (auto& edge : edges) {
        int a, b;
        tie(a, b) = edge;
        adj[a].push_back(b);
        adj[b].push_back(a);
    }
    
    memset(visited, false, sizeof(visited));
    dfs(1, 0);
    
    for (auto& query : queries) {
        int u, v, k;
        tie(u, v, k) = query;
        
        int path_xor = xor_from_root[u] ^ xor_from_root[v];
        bool found = false;

        if (path_xor == k) {
            found = true;
        } else {
            for (int i = 1; i <= N; ++i) {
                if ((xor_from_root[u] ^ xor_from_root[v] ^ value[i]) == k) {
                    found = true;
                    break;
                }
            }
        }

        if (found) {
            cout << "YES" << endl;
        } else {
            cout << "NO" << endl;
        }
    }
}
int main() {
    int N, Q;
    cin >> N >> Q;
    
    vector<int> values(N);
    for (int i = 0; i < N; ++i) {
        cin >> values[i];
    }
    
    vector<pair<int, int>> edges(N - 1);
    for (int i = 0; i < N - 1; ++i) {
        int a, b;
        cin >> a >> b;
        edges[i] = {a, b};
    }
    
    vector<tuple<int, int, int>> queries(Q);
    for (int i = 0; i < Q; ++i) {
        int u, v, k;
        cin >> u >> v >> k;
        queries[i] = {u, v, k};
    }
    
    solve(N, Q, values, edges, queries);
    
    return 0;
}

XOR Tree ✅

Salesforce hiring for below roles :

AMTS role :

Btech 2024 grads with 7 CGPA and above



Apply Here for Referral :
https://forms.gle/D4MMFK6tY4jB8QCu8

Wissen Technology is hiring for Java Developer

Eligibility : 2024 passouts , CS/IT Btech/ Mtech , 7.5 CGPA or higher

Send your resume for referral to :
abhay.tripathi@wissen.com
Or
trupthi.shetty@wissen.com

CarbonMarketsHQ is hiring for Software Engineering Intern

Batches : 2027, 2026, 2025  passouts eligible

Stipend : 10 - 30 k

Remote

https://wellfound.com/jobs/3069069-software-engineering-intern-climate-tech

Zemetric hiring for UI / UX Design

20 - 40 k per month

https://wellfound.com/jobs/3067305-ui-ux-design-intern

def solve(L, R):
    def first_digit(n):
        while n >= 10:
            n //= 10
        return n
   
    count = 0
    for number in range(L, R + 1):
        if first_digit(number) == number % 10:
            count += 1
   
    return count

Unsafe Password ✅

IBM ✅

IBM
def closedPaths(number):
Python ✅

#include<bits/stdc++.h>
#define ll long long
using namespace std;
vector<pair<ll,ll>>solve(ll n,ll m) 
{
    vector<pair<ll,ll>>path;
    ll x=0,y=0;
    ll dx=1,dy=1; 
    while(1) 
    {
        path.push_back({x, y});
        ll nx=x+dx;
        ll ny=y+dy;
        if(nx<0 or nx>=n) dx=-dx;
        if(ny<0 or ny>=m) dy=-dy;
        x+=dx;
        y+=dy;
        if((x==0 && y==0) or (x==0 && y==m-1) or (x==n-1 && y==0) or (x==n-1 && y==m-1)) 
        {
            path.push_back({x,y});
            break;
        }
    }
    return path;
}
signed main()
{
    ll n,m; cin>>n>>m;
    auto ans=solve(n,m);
    for(ll i=0;i<ans.size();i++) 
    {
        cout<<ans[i].first<<" "<<ans[i].second;
        if(i!=ans.size()-1) cout<<", ";
    }

   
}

A Ray of Light
Culfit ✅

#include <bits/stdc++.h>
#define ll long long
using namespace std;
class FenwickTree {
public:
    FenwickTree(ll n) : bit(n + 1, 0) {}

    void update(ll index, ll value) {
        for (; index < bit.size(); index += index & -index) {
            bit[index] += value;
        }
    }

    ll query(ll index) const {
        ll sum = 0;
        for (; index > 0; index -= index & -index) {
            sum += bit[index];
        }
        return sum;
    }

    ll rangeQuery(ll left, ll right) const {
        return query(right) - query(left - 1);
    }

private:
    vector<ll> bit;
};
ll solve(vector<ll>& a) 
{
    ll n=a.size()-1;
    vector<ll>compressed(n+1);
    vector<ll>values(a.begin()+1,a.end());
    sort(values.begin(),values.end());
    values.erase(unique(values.begin(),values.end()),values.end());
    for (ll i=1;i<=n;i++) 
    {
        a[i]=lower_bound(values.begin(),values.end(),a[i])-values.begin()+1;
    }
    FenwickTree fenwick(n);
    ll count=0;
    for (ll j=2;j<=n;j++) 
    {
        if (a[j]<j) count+=fenwick.query(a[j]-1);
        if (a[j-1]<j-1) fenwick.update(a[j-1],1);
    }
    return count;
}
signed main() 
{
    ll n; cin>>n;
    vector<ll>a(n+1);
    for (ll i=1;i<=n;i++)  cin >> a[i];
    cout <<solve(a)<<endl;
    return 0;
}

Pairs of equality
Culfit ✅

#include <iostream>
#include <vector>
using namespace std;
const int MOD = 1e9 + 7;
int countValidSeries(int n, int m, vector<int>& f) {
    vector<vector<int>> dp(n + 1, vector<int>(m + 1, 0));
    if (f[0] == 0) {
        for (int j = 1; j <= m; ++j) {
            dp[1][j] = 1;
        }
    } else {
        dp[1][f[0]] = 1;
    }
    for (int i = 2; i <= n; ++i) {
        if (f[i-1] == 0) {
            for (int j = 1; j <= m; ++j) {
                dp[i][j] = dp[i-1][j];
                if (j > 1) dp[i][j] = (dp[i][j] + dp[i-1][j-1]) % MOD;
                if (j < m) dp[i][j] = (dp[i][j] + dp[i-1][j+1]) % MOD;
            }
        } else {
            int j = f[i-1];
            dp[i][j] = dp[i-1][j];
            if (j > 1) dp[i][j] = (dp[i][j] + dp[i-1][j-1]) % MOD;
            if (j < m) dp[i][j] = (dp[i][j] + dp[i-1][j+1]) % MOD;
        }
    }
    int result = 0;
    for (int j = 1; j <= m; ++j) {
        result = (result + dp[n][j]) % MOD;
    }
    return result;
}

Flight Series Counter ✅