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

using namespace std;

void dfs(int node, int parent, const vector<vector<int>> &adj, const vector<int> &A, int length, int &maxLength) {
maxLength = max(maxLength, length);
for (int neighbor : adj[node]) {
if (neighbor == parent) continue;
if ((A[node] ^ A[neighbor]) < min(A[node], A[neighbor])) {
dfs(neighbor, node, adj, A, length + 1, maxLength);
}
}
}

int main() {
int N;
cin >> N;
vector<int> A(N), P(N);
for (int i = 0; i < N; ++i) cin >> A[i];
for (int i = 1; i < N; ++i) cin >> P[i];

vector<vector<int>> adj(N);
for (int i = 1; i < N; ++i) {
int parent = P[i];
adj[parent].push_back(i);
adj[i].push_back(parent);
}

int maxLength = 0;
dfs(0, -1, adj, A, 1, maxLength);

cout << maxLength << endl;
return 0;
}
Nodes

Coins game

All codes are available

To easily find out ur codes

Once check it 👇👇


https://www.instagram.com/allcoding1_official?igsh=ZHJpNXdpeWh1d2No

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

using namespace std;

int maxTreeScore(int node_count, int edge_count, vector<pair<int, int>>& edges, vector<int>& colors) {
// Step 1: Parse input and create adjacency list
unordered_map<int, vector<int>> adjacency_list;
for (const auto& edge : edges) {
int start = edge.first;
int end = edge.second;
adjacency_list[start].push_back(end);
adjacency_list[end].push_back(start);
}

// Step 2: Calculate depth of each node using BFS
vector<int> node_depth(node_count + 1, -1);
node_depth[1] = 0;
queue<int> bfs_queue;
bfs_queue.push(1);

while (!bfs_queue.empty()) {
int current_node = bfs_queue.front();
bfs_queue.pop();
int current_depth = node_depth[current_node];

for (int neighbor : adjacency_list[current_node]) {
if (node_depth[neighbor] == -1) { // unvisited
node_depth[neighbor] = current_depth + 1;
bfs_queue.push(neighbor);
}
}
}

// Step 3: Group nodes by depth
unordered_map<int, vector<int>> nodes_grouped_by_depth;
for (int node = 1; node <= node_count; ++node) {
nodes_grouped_by_depth[node_depth[node]].push_back(node);
}

// Step 4: Calculate distinct colors per depth
unordered_map<int, int> distinct_colors_at_depth;
for (const auto& pair : nodes_grouped_by_depth) {
int depth = pair.first;
const vector<int>& nodes = pair.second;
unordered_set<int> unique_colors;
for (int node : nodes) {
unique_colors.insert(colors[node - 1]);
}
distinct_colors_at_depth[depth] = unique_colors.size();
}

// Step 5: Dynamic programming to calculate max score
int max_depth = max_element(nodes_grouped_by_depth.begin(), nodes_grouped_by_depth.end(),
[](const auto& a, const auto& b) {
return a.first < b.first;
})->first;
vector<int> dp_score(max_depth + 2, 0);

for (int depth = max_depth; depth >= 0; --depth) {
// Option 1: Move to the next depth without adding score
dp_score[depth] = dp_score[depth + 1];

// Option 2: Add the distinct colors to score and move to depth depth + unique_colors_count
if (distinct_colors_at_depth.find(depth) != distinct_colors_at_depth.end()) {
int unique_colors_count = distinct_colors_at_depth[depth];
if (depth + unique_colors_count <= max_depth) {
dp_score[depth] = max(dp_score[depth], dp_score[depth + unique_colors_count] + unique_colors_count);
} else {
dp_score[depth] = max(dp_score[depth], unique_colors_count);
}
}
}

return dp_score[0];
}
diving in a tree , all test cases are passing

@allcoding1

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>

using namespace std;

const int MOD = 1000000007;

int minLampsToLightRoad(int num_positions, int num_lamps, vector<int>& lamp_positions, vector<int>& left_reach, vector<int>& right_reach, vector<pair<int, int>>& queries) {
// Step 1: Create intervals for each lamp
vector<pair<int, int>> intervals;
for (int i = 0; i < num_lamps; ++i) {
intervals.push_back({lamp_positions[i] - left_reach[i], lamp_positions[i] + right_reach[i]});
}

// Step 2: Sort intervals based on starting position
sort(intervals.begin(), intervals.end());

// Precompute the farthest reach for each starting point
vector<pair<int, int>> max_reach_from_start;
int current_max_reach = -1;
for (const auto& interval : intervals) {
int start = interval.first;
int end = interval.second;
if (max_reach_from_start.empty() start > max_reach_from_start.back().first) {
max_reach_from_start.push_back({start, end});
}
current_max_reach = max(current_max_reach, end);
max_reach_from_start.back().second = current_max_reach;
}

auto min_lamps_needed = [&](int query_left, int query_right) {
int count = 0;
int max_reach = query_left;

while (max_reach <= query_right) {
auto it = upper_bound(max_reach_from_start.begin(), max_reach_from_start.end(), make_pair(max_reach, INT_MAX));
if (it == max_reach_from_start.begin() prev(it)->first > max_reach) {
return -1;
}

int next_max_reach = prev(it)->second;
if (next_max_reach <= max_reach) {
return -1;
}

max_reach = next_max_reach + 1;
count++;

if (max_reach > query_right) {
break;
}
}

return max_reach > query_right ? count : -1;
};

// Step 3: Process each query and sum up the results
int result_sum = 0;
for (const auto& query : queries) {
int result = min_lamps_needed(query.first, query.second);
if (result != -1) {
result_sum += result;
result_sum %= MOD;
}
}

return result_sum;
}

lightning lamp code , all cases are passing

@allcoding1

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

using namespace std;

void dfs(int node, int parent, const vector<vector<int>>& tree, const vector<int>& A, int depth, int& maxDepth) {
maxDepth = max(maxDepth, depth);

for (int child : tree[node]) {
if (child != parent) {
if ((A[node] ^ A[child]) < A[node] && (A[node] ^ A[child]) < A[child]) {
dfs(child, node, tree, A, depth + 1, maxDepth);
}
}
}
}

int main() {
int N;
cin >> N;

vector<int> A(N + 1);
vector<int> P(N + 1);
vector<vector<int>> tree(N + 1);

// Read values array
for (int i = 1; i <= N; ++i) {
cin >> A[i];
}

// Read parent array and buildthe tree
for (int i = 2; i <= N; ++i) { // P[1] is root with P[1] = 0, so start from 2
cin >> P[i];
tree[P[i]].push_back(i);
tree[i].push_back(P[i]);
}

int maxDepth = 0;
dfs(1, 0, tree, A, 1, maxDepth);

cout << maxDepth << endl;

return 0;
}

@allcoding1

Maximum code are python

def main():
    import sys
    input = sys.stdin.read
    data = input().split('\n')
   
    S = data[0].strip()
    N = int(data[1].strip())
    W = []
    for i in range(N):
        W.append(data[2 + i].strip())
   
    freqS = get_frequency(S)
   
    count = 0
    for w in W:
        if is_valid_anagram_subsequence(freqS, w):
            count += 1
   
    print(count)

def get_frequency(S):
    freq = [0] * 26
    for c in S:
        freq[ord(c) - ord('a')] += 1
    return freq

def is_valid_anagram_subsequence(freqS, w):
    freqW = [0] * 26
    for c in w:
        freqW[ord(c) - ord('a')] += 1
   
    for i in range(26):
        if freqW[i] > freqS[i]:
            return False
   
    return True

if name == "main":
    main()


// MInimal subarray length

@allcoding1

def GetAnswer(N, A, B, P):
dp = [0] * (N + 1)
max_d = 0

for i in range(N - 1, -1, -1):
max_p = P[i]
min_p = P[i]

for j in range(1, B + 1):
if i + j <= N:
max_p = max(max_p, P[i + j - 1])
min_p = min(min_p, P[i + j - 1])

max_d = max(max_d, max_p - min_p)

if i + 1 == N:
dp[i] = max(dp[i], max_d)
else:
dp[i] = max(dp[i], max_d, dp[i + 1])

return dp[0]

import sys
input = sys.stdin.read
data = input().split()
N = int(data[0])
A = int(data[1])
B = int(data[2])
P = list(map(int, data[3:]))

result = GetAnswer(N, A, B, P)
print(result)


// XOR formaating code

@allcoding1

public static int solve(int N, int[] A) {
int t = 0;
for (int num : A) {
t += num;
}

int x = 0;
int y = 0;

for (int i = 0; i < N; i++) {
int res = t - x - A[i];
if (x == res) {
y++;
}
x += A[i];
}

return y;
}

//Equilibrium Point

@allcoding1

def f(S):
n = len(S)
lf, rf = {}, {}
ls, rs = set(), set()

# Initialize the rf map and rs with the entire string S
for c in S:
rf[c] = rf.get(c, 0) + 1
rs.add(c)

mx = 0

# Traverse the string and adjust the ls and rs sets and maps
for i in range(n - 1):
c = S[i]
lf[c] = lf.get(c, 0) + 1
rf[c] -= 1
if rf[c] == 0:
rs.remove(c)

ls.add(c)

cs = len(ls) + len(rs)
mx = max(mx, cs)

return n - mx


// spilit screen

@allcoding1_official

All codes are available

To easily find out ur codes

Once check it 👇👇


https://www.instagram.com/allcoding1_official?igsh=ZHJpNXdpeWh1d2No

LI Gcd Code in python


Infosys

@allcoding1

LI.GCD code in another way of solving

Infosys

@allcoding1

Latin Alpha Numerals

Accenture Hackdiva Code

@allcoding1

Nodes code in python

Accenture Hackdiva Code

@allcoding1

Athletes code
Accenture Hackdiva

🎯Wells Fargo Hiring Fresher For Analytics Associate

Location: Hyderabad
Qualification: Bachelors / Master’s degree
Work Experience : Fresher - 1 Year
Salary : 10 - 11 LPA
Apply Now:- https://wd1.myworkdaysite.com/recruiting/wf/WellsFargoJobs/job/Hyderabad-India/Analytics-Associate_R-381215

Telegram:- @allcoding1

Mitsogo is hiring Fresher

Apply link 👇

https://boards.greenhouse.io/mitsogoinc/jobs/4045384008?gh_src=eacea7cc8us