MAXIMUM ROTATION
PYTHON


def rl(layer, pos, dir, ol):
    n = len(layer)
    rot = [None] * n

    if dir == "clockwise":
        for i in range(n):
            rot[(i + pos) % n] = layer[i]
    else:
        for i in range(n):
            rot[(i - pos) % n] = layer[i]

    for i in range(n):
        if ol:
            rot[i] = chr(((ord(rot[i]) - ord('A') - 1) % 26) + ord('A'))
        else:
            rot[i] = chr(((ord(rot[i]) - ord('A') + 1) % 26) + ord('A'))

    return rot


def aq(pl, row, col, size):
    layers = []
    for layer in range(size // 2):
        cl = []
        for j in range(col + layer, col + size - layer):
            cl.append(pl[row + layer][j])
        for i in range(row + layer + 1, row + size - layer - 1):
            cl.append(pl[i][col + size - layer - 1])
        for j in range(col + size - layer - 1, col + layer - 1, -1):
            cl.append(pl[row + size - layer - 1][j])
        for i in range(row + size - layer - 2, row + layer, -1):
            cl.append(pl[i][col + layer])
        layers.append(cl)

    for lidx, layer in enumerate(layers):
        ol = (lidx + 1) % 2 == 1
        dir = "counterclockwise" if ol else "clockwise"
        pos = lidx + 1
        rotated_layer = rl(layer, pos, dir, ol)

        idx = 0
        for j in range(col + lidx, col + size - lidx):
            pl[row + lidx][j] = rotated_layer[idx]
            idx += 1
        for i in range(row + lidx + 1, row + size - lidx - 1):
            pl[i][col + size - lidx - 1] = rotated_layer[idx]
            idx += 1
        for j in range(col + size - lidx - 1, col + lidx - 1, -1):
            pl[row + size - lidx - 1][j] = rotated_layer[idx]
            idx += 1
        for i in range(row + size - lidx - 2, row + lidx, -1):
            pl[i][col + lidx] = rotated_layer[idx]
            idx += 1

def MAX_ROTATION(n, pl, queries):
    for row, col, size in queries:
        aq(pl, row, col, size)
    result = ''.join(''.join(row) for row in pl)
    return result


n = int(input())
pl = [list(input().strip().split()) for _ in range(n)]
q = int(input().strip())
queries = [tuple(map(int, input().strip().split())) for _ in range(q)]

result = MAX_ROTATION(n, pl, queries)
print(result, end="")

MAXIMUM ROTATION
PYTHON

☑️ ☑️ ☑️ ☑️

OFFICE ROSTERING
C++


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

int main()
{
    int n, m, k, d = 1, EXAMASSISTANCE = 0;
    cin >> n >> m;
    vector<set<int>> f(n);
    for (int i = 0, u, v; i < m; ++i)
    {
        cin >> u >> v;
        f[u].insert(v);
        f[v].insert(u);
    }

    cin >> k;
    vector<bool> w(n, true);
    EXAMASSISTANCE = n;
    while (EXAMASSISTANCE < k)
    {
        vector<bool> nw(n, false);
        for (int i = 0; i < n; ++i)
        {
            int cnt = 0;
            for (int fr : f[i]) cnt += w[fr];
            if (w[i] && cnt == 3) nw[i] = true;
            else if (!w[i] && cnt < 3) nw[i] = true;
        }

        w = nw;
        EXAMASSISTANCE += count(w.begin(), w.end(), true);
        ++d;
    }
    cout << d;
    return 0;
}


OFFICE ROSTERING
C++
☑️ ☑️ ☑️ ☑️

Equation Puzzle Code
C++
TCS CodeVita Season 12 Round 1 Zone 2


int main()
{
    string e1, e2;
    int r;
    cin >> e1 >> e2 >> r;
    int a1, b1, c1, d1, n1, a2, b2, c2, d2, n2;
    sscanf(e1.c_str(), "%dx+%dy+%dz+%dw<=%d", &a1, &b1, &c1, &d1, &n1);
    sscanf(e2.c_str(), "%dx+%dy+%dz+%dw<=%d", &a2, &b2, &c2, &d2, &n2);

    vector<vector<int>> combinations;
    for (int x = 0; x <= r; x++)
    {
        for (int y = 0; y + x <= r; y++)
        {
            for (int z = 0; z + x + y <= r; z++)
            {
                int w = r - x - y - z;
                combinations.push_back({x, y, z, w});
            }
        }
    }

    set<int> results;
    for (auto &vars1 : combinations)
    {
        int v1 = a1 * vars1[0] + b1 * vars1[1] + c1 * vars1[2] + d1 * vars1[3];
        if (v1 > n1) continue;

        for (auto &vars2 : combinations)
        {
            int v2 = a2 * vars2[0] + b2 * vars2[1] + c2 * vars2[2] + d2 * vars2[3];
            if (v2 > n2) continue;
            if (v1 == v2) results.insert(v1);
        }
    }

    cout << results.size() << endl;
    return 0;
}



Equation Puzzle Code
C++

☑️ ☑️ ☑️ ☑️

def rotate_layer(layer, positions, direction, odd_layer):
    n = len(layer)
    rotated = [None] * n

    if direction == "clockwise":
        for i in range(n):
            rotated[(i + positions) % n] = layer[i]
    else:  # counterclockwise
        for i in range(n):
            rotated[(i - positions) % n] = layer[i]

    for i in range(n):
        if odd_layer:
            rotated[i] = chr(((ord(rotated[i]) - ord('A') - 1) % 26) + ord('A'))
        else:
            rotated[i] = chr(((ord(rotated[i]) - ord('A') + 1) % 26) + ord('A'))

    return rotated


def apply_query(matrix, row, col, size):
    layers = []
    for layer in range(size // 2):
        current_layer = []
        for j in range(col + layer, col + size - layer):
            current_layer.append(matrix[row + layer][j])
        for i in range(row + layer + 1, row + size - layer - 1):
            current_layer.append(matrix[i][col + size - layer - 1])
        for j in range(col + size - layer - 1, col + layer - 1, -1):
            current_layer.append(matrix[row + size - layer - 1][j])
        for i in range(row + size - layer - 2, row + layer, -1):
            current_layer.append(matrix[i][col + layer])

        layers.append(current_layer)

    for layer_idx, layer in enumerate(layers):
        odd_layer = (layer_idx + 1) % 2 == 1
        direction = "counterclockwise" if odd_layer else "clockwise"
        positions = layer_idx + 1
        rotated_layer = rotate_layer(layer, positions, direction, odd_layer)

        idx = 0
        for j in range(col + layer_idx, col + size - layer_idx):
            matrix[row + layer_idx][j] = rotated_layer[idx]
            idx += 1
        for i in range(row + layer_idx + 1, row + size - layer_idx - 1):
            matrix[i][col + size - layer_idx - 1] = rotated_layer[idx]
            idx += 1
        for j in range(col + size - layer_idx - 1, col + layer_idx - 1, -1):
            matrix[row + size - layer_idx - 1][j] = rotated_layer[idx]
            idx += 1
        for i in range(row + size - layer_idx - 2, row + layer_idx, -1):
            matrix[i][col + layer_idx] = rotated_layer[idx]
            idx += 1


def process_matrix(n, matrix, queries):
    for row, col, size in queries:
        apply_query(matrix, row, col, size)
    result = ''.join(''.join(row) for row in matrix)
    return result


n = int(input())
matrix = [list(input().strip().split()) for _ in range(n)]
q = int(input().strip())
queries = [tuple(map(int, input().strip().split())) for _ in range(q)]

result = process_matrix(n, matrix, queries)
print(result, end="")

Matrix Rotation

📌Interactive Brokers is hiring for Junior Software Engineer

Experience: 0 - 1 year
Expected Salary: 9-16 LPA

💻Apply here: https://job-boards.greenhouse.io/ibkr/jobs/7735288002?Source=Linkedin

📌Phone pay Hiring
Role: Analyst

Qualifications:
- Bachelor’s degree in Data Science, Statistics, Business Analytics, or a related field. A master’s degree is a plus.

💻Apply Link: https://boards.greenhouse.io/embed/job_app?token=6268352003

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
    int M;
    cin >> M; 
    vector<vector<int>> matrix(M, vector<int>(M));
    for (int i = 0; i < M; ++i) {
        for (int j = 0; j < M; ++j) {
            cin >> matrix[i][j];
        }
    }
    for (int i = 0; i < M; ++i) {
        if (i % 2 == 0) {
            sort(matrix[i].begin(), matrix[i].end());
        } else {
            sort(matrix[i].begin(), matrix[i].end(), greater<int>());
        }
    }

    for (int j = 0; j < M; ++j) {
        vector<int> column(M);
        for (int i = 0; i < M; ++i) {
            column[i] = matrix[i][j];
        }

        if (j % 2 == 0) {
            sort(column.begin(), column.end());
        } else {
            sort(column.begin(), column.end(), greater<int>());
        }

        for (int i = 0; i < M; ++i) {
            matrix[i][j] = column[i];
        }
    }
    for (int i = M - 1; i >= 0; --i) {
        for (int j = 0; j < M; ++j) {
            cout << matrix[i][j] << " ";
        }
        cout << endl;
    }

    return 0;
}

BNP ✅

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
    int n;
    cin >> n;
    
    vector<int> p(n);
    for (int i = 0; i < n; ++i) {
        cin >> p[i];
    }

    vector<int> d(n, 1), c(n, 1);

    for (int i = 1; i < n; ++i) {
        for (int j = 0; j < i; ++j) {
            if (p[i] > p[j]) {
                if (d[i] < d[j] + 1) {
                    d[i] = d[j] + 1;
                    c[i] = c[j];
                } else if (d[i] == d[j] + 1) {
                    c[i] += c[j];
                }
            }
        }
    }

    int m = *max_element(d.begin(), d.end());
    int res = 0;
    for (int i = 0; i < n; ++i) {
        if (d[i] == m) {
            res += c[i];
        }
    }

    cout << res << endl;

    return 0;
}

BNP ✅

#include <iostream>
#include <string>
#include <vector>
using namespace std;
string solve(string a, string b, int c) {
    int d = a.length();
    vector<bool> e(c + 1, false);
    for (int f = 0; f < d; f++) {
        int g = (b[f] - a[f] + 26) % 26;
        bool h = false;
        for (int i = 1; i <= c; i++) {
            if (!e[i] && i == g) {
                h = true;
                e[i] = true;
                break;
            }
        }
        
        if (!h) {
            return "No";
        }
    }
    
    return "Yes";
}

int main() {
    string a, b;
    int c;
    cin >> a >> b >> c;
    cout << solve(a, b, c) << endl;
    return 0;
}

MAQ ✅

Adtran is hiring Software Engineer

For 2021, 2022 gards
Location: Hyderabad

https://adtran.wd3.myworkdayjobs.com/en-US/ADTRAN/job/Software-Engineer_R003741

#include <bits/stdc++.h>
using namespace std;
vector<int> solve(const string &s) {
int n = s.length();
vector<vector<int>> adj(n);
vector<int> result(n, 0);
for (int a = 0; a < n; a++) {
if (s[a] == '1') {
int b = 2 * a + 1;
int c = 2 * a + 2;
if (b < n && s[b] == '1') 
{
adj[a].push_back(b);
adj[b].push_back(a);
}
if (c < n && s[c] == '1')
{
adj[a].push_back(c);
adj[c].push_back(a);
}
}
}
auto bfs = [&](int start) {
vector<int> dist(n, -1);
queue<int> q;
q.push(start);
dist[start] = 0;
int maxDist = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int v : adj[u]) {
if (dist[v] == -1) {
dist[v] = dist[u] + 1;
maxDist = max(maxDist, dist[v]);
q.push(v);
}
}
}
return maxDist;
};
for (int a = 0; a < n; a++) 
{
if (s[a] == '1') 
{
result[a] = bfs(a);
}
}
vector<int> res;
for (int a = 0; a < n; a++) 
{
if (s[a] == '1') 
{
res.push_back(result[a]);
}
}
return res;
}
int main() {
string s;
cin >> s;
vector<int> res = solve(s);
for (int x : res) 
{
cout << x << " ";
}
cout << endl;
return 0;
}

Barclays ✅

Company Name : Zynga
Batch : 2023/2022/2021
Role : Software Engineer 1

Link : https://job-boards.greenhouse.io/zyngacareers/jobs/5379737004?gh_src=503a64f04us

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

vector<int> commonFootSteps(int fatherPos, int martinPos, int velFather, int steps) {
    vector<int> answer(2, 0);
    vector<int> temp(steps + 1, 0);

    for (int i = 0; i <= steps; i++)
        temp[i] = fatherPos + velFather * i - martinPos;

    for (int i = 0; i <= steps; i++) {
        if (temp[i] <= 0)
            continue;

        int v2 = temp[i];
        int count = 0;

        for (int j = i; j <= steps; j++) {
            if (temp[j] % v2 == 0)
                count++;
        }

        if (answer[0] <= count) {
            answer[0] = count;
            answer[1] = v2;
        }
    }

    return answer;
}

int main() {
    int x1, x2, v, n;
    cin >> x1 >> x2 >> v >> n;
    vector<int> result = commonFootSteps(x1, x2, v, n);

    for (int i : result)
        cout << i << " ";

    return 0;
}

Barcalys ✅

#include <iostream>
#include <string>
using namespace std;
string solve(int N, int T, string S) {
    for (int t = 0; t < T; ++t) {
    for (int i = 0; i < N - 1; ++i) {
    if (S[i] == 'M' && S[i + 1] == 'W') {
    swap(S[i], S[i + 1]);
    i++;
            }
        }
    }
    return S;
}

Tiger Analytics ✅

#include <iostream>
#include <vector>
int score(vector<int>& a) {
    int n = a.size(), s = 0;
    for (int i = 0; i < n - 1; ++i) {
        int x = a[i] + a[i + 1];
        if (x % 2 == 0) s += 5;
    }
    for (int i = 0; i < n - 2; ++i) {
        int y = a[i] + a[i + 1] + a[i + 2];
        int z = a[i] * a[i + 1] * a[i + 2];
        if (y % 2 != 0 && z % 2 == 0) s += 10;
    }
    return s;
}

Impetus ✅