from collections import deque
class Node:
    def __init__(self, key):
        self.data = key
        self.left = None
        self.right = None
def insert_level_order(arr, root, i, n):
    if i < n:
        temp = Node(arr[i])
        root = temp
        root.left = insert_level_order(arr, root.left, 2 * i + 1, n)
        root.right = insert_level_order(arr, root.right, 2 * i + 2, n)
    return root
def level_with_highest_odd_sum(root):
    if not root:
        return 0
    queue = deque([root])
    level = 1
    max_odd_sum = -1
    max_odd_level = 0
    current_level = 1
    
    while queue:
        level_size = len(queue)
        odd_sum = 0
     
        for _ in range(level_size):
            node = queue.popleft()
            
            if node.data % 2 != 0:
                odd_sum += node.data
            
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)
        
        if odd_sum > max_odd_sum:
            max_odd_sum = odd_sum
            max_odd_level = current_level
        
        current_level += 1
    
    return max_odd_level

if __name__ == "__main__":
    N = int(input())  
    elements = list(map(int, input().split()))  
    
    root = None
    root = insert_level_order(elements, root, 0, N)
    
    result = level_with_highest_odd_sum(root)
    
    print(result)

Tesco ✅

#include <iostream>
#include <vector>
#include <queue>
#include <climits>

using namespace std;

struct Edge {
    int dest, weight;
};

vector<int> dijkstra(int start, int N, vector<vector<Edge>>& adj, int totalMoney) {
    vector<int> dist(N + 1, INT_MAX);  
    vector<int> parent(N + 1, -1);     
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
    
    dist[start] = 0;
    pq.push({0, start});
    
    while (!pq.empty()) {
        int curNode = pq.top().second;
        int curDist = pq.top().first;
        pq.pop();
        
        if (curDist > dist[curNode]) continue;
        
        for (Edge edge : adj[curNode]) {
            int nextNode = edge.dest;
            int nextDist = curDist + edge.weight;
            
            if (nextDist < dist[nextNode] && nextDist * 2 <= totalMoney) {
                dist[nextNode] = nextDist;
                parent[nextNode] = curNode;
                pq.push({nextDist, nextNode});
            }
        }
    }
    return parent;
}

void printPath(int node, vector<int>& parent) {
    if (parent[node] == -1) {
        cout << node << " ";
        return;
    }
    printPath(parent[node], parent);
    cout << node << " ";
}

int main() {
    int N, M, totalMoney;
    cin >> N >> M >> totalMoney;

    vector<vector<Edge>> adj(N + 1); 
    
    for (int i = 0; i < M; ++i) {
        int u, v, w;
        cin >> u >> v >> w;
        adj[u].push_back({v, w});
        adj[v].push_back({u, w});
    }

    vector<int> parent = dijkstra(1, N, adj, totalMoney);
    
    int farthestNode = 1;
    for (int i = 1; i <= N; ++i) {
        if (parent[i] != -1 && i != 1) {
            farthestNode = i;
        }
    }

    printPath(farthestNode, parent);
    
    while (farthestNode != 1) {
        farthestNode = parent[farthestNode];
        cout << farthestNode << " ";
    }

    return 0;
}

 

Tesco ✅

https://apply.workable.com/bahwan-cybertek-group/j/5EA67A4496/

Fresher - Developer

📌Company: SumaSoft

Role: Software Tester

Exp: 0-6 Months(Fresher) Immediate Joiner

Job Location: Pune / Aundh

For Software Tester Skill Required, #Testing #Python #Manual Testing #Automation testing #SQL

Must: Excellent Communication Skill.

✉️Share an email on
snehal.mane@sumasoft.net

Criteria - Freshers / B.E., B.Tech, MCA/2023 & 2024 passout

• Full Stack Developer (0-3 years Experienced .NET/SQL & Angular/React)

• Data Analyst / Data Engineer (0-3 years Experienced)

• Software Developer Freshers

🏢Address: Office No 501, 5th Floor, CityAvenue - By Kolte Patil Mumbai-Bangalore By Pass, near Hotel Sayaji, Wakad, Pune, Maharashtra 411057

📌Hiring React Native Developer

Send your resume to:
+91 89594-09296
☑rishusinfotech@gmail.com

AI/ML Intern: https://forms.gle/gN3JM478tS6f3ss59

ABB Hiring !!
Role - Associate Software Engineer
Exp - 0 to 2 year


Link - https://careers.abb/global/en/job/ABB1GLOBAL93176667EXTERNALENGLOBAL/Associate-Engineer

import java.util.*;
public class LibraryExplorer {
    public static boolean[] sieveOfEratosthenes(int N) {
        boolean[] isPrime = new boolean[N + 1];
        Arrays.fill(isPrime, true);
        isPrime[0] = isPrime[1] = false;  
        for (int i = 2; i * i <= N; i++) {
            if (isPrime[i]) {
                for (int j = i * i; j <= N; j += i) {
                    isPrime[j] = false;
                }
            }
        }
        return isPrime;
    }

    public static int maxBooksCollected(int N, int K, int[] A) {
        boolean[] primes = sieveOfEratosthenes(N);
        int totalBooks = 0;
        for (int i = 1; i <= N; i++) {
            if (primes[i]) {  
                totalBooks += Math.min(A[i - 1], K);  
            }
        }
        
        return totalBooks;
    }

Library exploration ✅

Drop Your CV - muthu.siva@xebia.com

https://jobs.standardchartered.com/job/Bangalore-2025-Intern-Tech-PSG-Tech-GBS-India/803430002/?feedId=363857&utm_source=lilimitedlistings

SCB Hiring Intern - Tech PSG

Internships available
We have the following internships available in Bangalore and Chennai:

•    UI Developer
•    Java Developer
•    SQL Developer
•    Automation tester
•    Performance Engineer
•    Data Science
•    Machine Learning
•    Cloud

Responsibilities
•    Analyse complex business problems and help arrive at technically innovative solutions.
•    Design user interactions on web pages
•    Develop back-end website applications.
•    Develop front-end website architecture.
•    Automation of test suite using Selenium 
•    Identify performance gaps in applications and tuning code to achieve desired performance goals.
•    Collaborate with globally distributed agile teams.

Preferred Skills
•    Proven problem-solving ability.
•    Strong foundational knowledge of Algorithms, Data Structures, OOP concepts and frameworks.
•    Curious learner, willing to learn and adapt to new technologies and frameworks.
•    Empowered mindset with ability to ask questions and seek clarifications.
•    Excellent communication skills that enable seamless interactions with colleagues globally
•    Strong analytical skills and impeccable attention to detail
•    Excellent verbal and written communication skills
•    Highly enthusiastic individual and considered a go-getter.
•    Strong networking and inter-personal skills

Eligibility
We welcome students from Engineering degrees and encourage students from diverse backgrounds to apply.   

We’re looking for team players with excellent academic achievements and extracurricular activities, who are agile, flexible problem solvers with strong technical abilities and open to learning the latest tech stack.
A strong foundational knowledge of Algorithms, Data Structures, OOP concepts and frameworks is preferred.

You need to be a final year student, able to intern from January 2025 to June 2025 and start full-time employment in July 2025.

#include <iostream>
#define MOD 1000000007
using namespace std;
int ff(int a) {
    int s = 0;
    while (a > 0) {
        s += a % 10;
        a /= 10;
    }
    return sum;
}
int solve(int N, int X) {
    int c = 0;
    int num = 0;
        while (c < N) {
        num++;  
        if (ff(num) == X) {
            c++;  
        }
    }
        return num % MOD;
}

Brainstorming Series ✅

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

bool dfs(char current, char start, string &path, map<char, set<char>> &adj, set<char> &used, int target) { 
    if (path.size() == target) { 
        if (adj[current].count(start)) { 
            path.push_back(start); 
            return true; 
        } 
        return false; 
    } 

    for (char next : adj[current]) { 
        if (!used.count(next)) { 
            used.insert(next); 
            path.push_back(next); 
            if (dfs(next, start, path, adj, used, target)) return true; 
            path.pop_back(); 
            used.erase(next); 
        } 
    } 
    return false; 
} 

string gemWord(int input1, string input2) { 
    set<char> unique_chars(input2.begin(), input2.end()); 
    if (unique_chars.size() < input1) return "No"; 

    map<char, set<char>> adj; 
    int n = input2.size(); 
    for (int i = 0; i < n - 1; ++i) { 
        adj[input2[i]].insert(input2[i + 1]); 
        adj[input2[i + 1]].insert(input2[i]); 
    } 

    string result; 
    bool found = false; 
    for (char ch : unique_chars) { 
        string path = ""; 
        set<char> used = {ch}; 
        path.push_back(ch); 
        if (dfs(ch, ch, path, adj, used, input1)) { 
            if (!found || path < result) { 
                result = path.substr(0, path.size() - 1); 
                found = true; 
            } 
        } 
    } 

    return found ? result : "No"; 
}

gem word 9/10✅