Send your resume to hr@technogenesis.in

import java.util.*;
public class Main {
    static int countMatches(List<String> grid1, List<String> grid2) {
        int count = 0;
        int m = grid1.size();
        int n = grid1.get(0).length();
        int[][] g1 = new int[m][n];
        int[][] g2 = new int[m][n];
        int[][] orMap = new int[m][n];
        for(int i=0; i<m; i++){
            char[] str1 = grid1.get(i).toCharArray();
            char[] str2 = grid2.get(i).toCharArray();
            for(int j=0; j<n; j++){
                g1[i][j] = str1[j] - '0';
                g2[i][j] = str2[j] - '0';
            }
        }
        for(int i=0; i<m; i++){
            for(int j=0; j<n; j++){
                orMap[i][j] = g1[i][j] | g2[i][j];
            }
        }
        for(int i=0; i<m; i++){
            for(int j=0; j<n; j++){
                if(orMap[i][j] == 1 && dfs(g1, g2, orMap, i, j)) count++;
            }
        }
        return count;
    }

    private static boolean dfs(int[][] g1, int[][] g2, int[][] orMap, int i, int j) {
        int m = orMap.length;
        int n = orMap[0].length;
        orMap[i][j] = 0;
        boolean up = true, down = true, left = true, right = true;
        if(i > 0 && orMap[i-1][j] == 1) up = dfs(g1, g2, orMap, i-1, j);
        if(i < m - 1 && orMap[i+1][j] == 1) down = dfs(g1, g2, orMap, i+1, j);
        if(j > 0 && orMap[i][j-1] == 1) left = dfs(g1, g2, orMap, i, j-1);
        if(j < n - 1 && orMap[i][j+1] == 1) right = dfs(g1, g2, orMap, i, j+1);

        return g1[i][j] == 1 && g2[i][j] == 1 && up && down && left && right;
    }

Pace Securities ✅

#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define all(x) x.begin(), x.end()
#define endl '\n'
#define int long long
#define MOD 1000000007

#define fastio ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
using namespace std;

int getMax(int i, int j, vector<vector<int>>& dp) {
    int maxValue = dp[i][j];
    if (j - 1 >= 0) maxValue = max(maxValue, dp[i][j - 1]);
    if (j + 1 < dp[0].size()) maxValue = max(maxValue, dp[i][j + 1]);
    return maxValue;
}

void calc(vector<vector<int>>& dp) {
    for (int i = dp.size() - 2; i >= 1; i--) {
        for (int j = 0; j < dp[0].size(); j++) {
            dp[i][j] += getMax(i + 1, j, dp);
        }
    }
}

int32_t main() {
    fastio
    int m, n;
    cin >> m >> n;
    vector<vector<int>> dp(m, vector<int>(n, 0));
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            cin >> dp[i][j];
        }
    }

    vector<vector<int>> opposite(m, vector<int>(n, 0));
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            opposite[i][j] = dp[m - i - 1][j];
        }
    }
    calc(dp);
    calc(opposite);

    int p, q;
    cin >> p >> q;
    int ans = dp[0][p] + getMax(1, p, dp);
    ans = max(ans, opposite[0][q] + getMax(1, q, opposite));

    cout << ans << endl;

    return 0;
}

#include <iostream>
#include <vector>

using namespace std;

int fun(int n) {
    int total = 0;
    while (n > 0) {
        total += n % 10;
        n /= 10;
    }
    return total;
}

int solve(int N) {
    int total_sum = 0;
    vector<int> elements;

    for (int i = 1; i <= N; ++i) {
        elements.push_back(i);
    }

    fun(N);

    while (elements.size() > 1) {
        vector<int> new_elements;
        for (size_t index = 0; index < elements.size(); ++index) {
            int value = elements[index];
            if (index % 2 == 1) {
                new_elements.push_back(value);
            } else {
                total_sum += value;
            }
        }
        elements = new_elements;
    }

    return total_sum;
}

Range Game ✅

char slowestKey(vector<vector> keyTimes){
long int n=keyTimes.size();
long int diff=keyTimes[0][1];
int ans=keyTimes[0][0];
for(int i=1;i<n;i++)
{
long int a=keyTimes[i][1]-keyTimes[i-1][1];
if(a>diff){
diff=a;
ans=keyTimes[i][0];
}
}
return (char)(ans+97);
}

Slowest Key pass ✅
JPMC

MasterCard hiring Data Engineers

Freshers eligible

Apply Here : https://mastercard.wd1.myworkdayjobs.com/CorporateCareers/job/Pune-India/Data-Engineer-II_R-212415

Eurofins hiring Associate Software Engineer

0-1 year experience
6-12 LPA CTC

Apply Here : https://jobs.smartrecruiters.com/Eurofins/744000018924766-associate-software-engineer-sharepoint

The world lost a gem #RIP💔

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
int n;
void dfs(int i, int j, vector<string>& highways, vector<vector<bool>>& visited) {
    if (i < 0 || i > 1 || j < 0 || j >= n || highways[i][j] == 'x' || visited[i][j])
        return;
    
    visited[i][j] = true;
        dfs(i, j + 1, highways, visited); 
    dfs(i, j - 1, highways, visited);
    dfs(1 - i, j, highways, visited); 
}
int countComponents(vector<string>& highways) {
    vector<vector<bool>> visited(2, vector<bool>(n, false));
    int components = 0;
    
    for (int i = 0; i < 2; ++i) {
        for (int j = 0; j < n; ++j) {
            if (!visited[i][j] && highways[i][j] == 'o') {
                components++;
                dfs(i, j, highways, visited);
            }
        }
    }
    
    return components;
}

int main() {
    cin >> n;
    
    vector<string> highways(2);
    cin >> highways[0] >> highways[1];
    
    int initialComponents = countComponents(highways);
        if (initialComponents >= 3) {
        cout << 0 << endl;
        return 0;
    }
    
    int criticalSegments = 0;
        for (int i = 0; i < 2; ++i) {
        for (int j = 0; j < n; ++j) { 
            if (highways[i][j] == 'o') {
                highways[i][j] = 'x';
                int newComponents = countComponents(highways);
                if (newComponents == 3) {
                    criticalSegments++;
                }
                highways[i][j] = 'o';
            }
        }
    }
    
    cout << criticalSegments << endl;
    
    return 0;
}

Road Network Breakdown ✅
Juspay

def encryptedFileName(n, k, s):
    a = sorted(set(s))
    m = len(s)
    i = m - 1
    while i >= 0 and s[i] == a[-1]:
        i -= 1
    if i == -1:
        res = a[0] * k
    else:
        nxt = a[a.index(s[i]) + 1]
        res = s[:i] + nxt
        res += a[0] * (k - len(res))
    print(res)

Encrypted file name update
Juspay ✅

https://onlinegdb.com/if0il1n-W

Looking the tree of space ✅
Juspay

def maxEnergy(s):
    d = e = m = 0
    for c in s:
        if c == 'D':
            d += 1
            m = max(m, d)
        else:
            e += 1
            if d > 0:
                d -= 1
    return m + e

Robot Battery Conversion ✅