Track: Other

Other Roles

Online Assessment (OA) Format

• Multi-Section Test: 5 sections with strict time limits:
  1. Coding: 2 questions (e.g., basic greedy problem, medium string manipulation).
  2. Quantitative Aptitude: 7 hard mathematical questions.
  3. Advanced Coding: 1 very hard problem (e.g., grid-based DP and graphs).
  4. CS Fundamentals: Questions on stacks, hamming codes, dynamic programming, and round-robin scheduling.
  5. HR: Typed responses to situational questions (e.g., toughest time faced during a project).

Round Breakdown

1. Technical Rounds:

   • Accounting Standards: Focus on Indian Accounting Standards (e.g., Ind AS 21, Ind AS 23, Ind AS 116, Ind AS 115).
   • Algorithmic Problems: (e.g., Move zeros, Maximum product subarray).
   • Recursive Function: Implementing a recursive function in Python.
   • Java and Data Structures: (e.g., differences between linked list and array list, internal implementations of HashMap and TreeMap).
   • Concurrent Programming: (e.g., thread-safe linked list).
   • Low-Latency Systems: (e.g., garbage collectors, programming patterns for low-latency trading systems).

2. System Design Round: Designing an in-memory map in a basic assembly-like language.

3. HR Round: Discussion on previous work experience.

Key Questions Asked

• Ind AS 21, Ind AS 23, Ind AS 116, Ind AS 115 (accounting standards).
• Move zeros, Maximum product subarray (algorithms).
• Escrever função recursiva em Python (recursion).
• Differences between linked list and array list (data structures).
• Internal implementations of HashMap and TreeMap (Java internals).
• Design an in-memory map (system design).

Track: SDE-2

SDE-2

Round Breakdown

1. Technical Round: Focus on data structures and algorithms (specific questions not disclosed).
2. Software Development Lifecycle Round: Discussion on SDLC methodologies and best practices.

Key Topics Covered

• Data structures and algorithms.
• Software development lifecycle (SDLC).

Track: Intern

Intern

Online Assessment (OA) Format

• Aptitude Test with Negative Marking: Includes sections on logical reasoning, quantitative aptitude, and basic programming MCQs. The test is designed to filter candidates strictly, with negative marking for incorrect answers.
• Coding Round (Alternative OA): A 1-hour 50-minute test divided into four sections:
  1. Medium-Level Coding Questions: 2 problems (e.g., string manipulation, greedy algorithms).
  2. Maths and Aptitude MCQs: Multiple-choice questions testing mathematical and logical reasoning.
  3. Coding MCQs: Questions on programming concepts (e.g., data structures, algorithms).
  4. Essay-Type Questions: 2 descriptive questions requiring structured responses.

Round Breakdown

1. Technical Interviews (3-4 Rounds):
   • Round 1: Coding questions (e.g., Next smaller palindrome, difference between file system and DBMS).
   • Round 2: Problem-solving and project discussion (e.g., Missing number, First missing positive).
   • Round 3: Data structures and algorithms (e.g., list all data structures, ways to represent a graph, BST question, validate a sudoku).
   • Round 4 (Optional): System design or hypothetical scenario-based problem-solving (e.g., Design a solution for a given hypothetical scenario).

Key Questions Asked

• Next smaller palindrome (string manipulation).
• Difference between file system and DBMS (conceptual).
• Missing number, First missing positive (array algorithms).
• Validate a sudoku (problem-solving).
• Design a solution for a hypothetical scenario (system design basics).

Track: SDE-1 / New Grad

SDE-1 / New Grad

Online Assessment (OA) Format

• HackerRank Platform: 2-hour duration with 2 easy-to-medium coding questions.
  • Example topics: String manipulation, pattern-based number generation.
• Alternative OA: 2-hour test with 2 medium-level coding questions (e.g., string compression, smallest number based on I/D pattern).

Round Breakdown

1. Technical Rounds (3-6 Rounds):

   • Round 1 (OA): Coding problems (e.g., Find median of two sorted arrays, Find loop length in a linked list).
   • Round 2: Algorithmic problems (e.g., Find prime factors of a number, Shortest path in a graph with string-based nodes).
   • Round 3: Java fundamentals and coding (e.g., Next Greater Element, Find start and end position of an element in a sorted array, K concatenation maximum sum, Check if binary tree is BST).
   • Round 4: Java/SpringBoot concepts and algorithmic problem-solving (e.g., Autowiring in Spring, Multiple inheritance in Java, Polymorphism types, Fibonacci using memoization).
   • Round 5: Design patterns and SQL (e.g., Singleton design pattern, Thread-safe Singleton, SQL joins with ordering).
   • Round 6: Java Collections and project experience (e.g., Java Collections framework).

2. Managerial Round: Java basics (e.g., Major differences between Java 7 and Java 8, Garbage collection in Java).

3. System Design Round (Occasional): Focuses on scalable system design (e.g., Design a card game with multiple 52-card decks and multiple players).

Key Questions Asked

• Find median of two sorted arrays (arrays).
• Find loop length in a linked list (linked lists).
• String compression (string manipulation).
• Next Greater Element (stacks).
• Autowiring in Spring (Spring framework).
• Singleton design pattern (design patterns).
• Java Collections framework (Java internals).
• Major differences between Java 7 and Java 8 (Java fundamentals).

Track: Data Science / ML

Data Science / ML

Round Breakdown

1. Technical Round: Scenario-based end-to-end solution architecture and planning for data science projects (e.g., high-level architectural planning for data science projects).

Key Topics Covered

• End-to-end data science solution architecture.
• Business scenario-based problem-solving.