Live online classes on Google Meet for students worldwide · Offline classes in Chandigarh, Mohali and Panchkula — coming soon

+91 62830 97869 +91 94652 65663
  1. Home
  2. Courses
  3. Data Structures & Algorithms

Live Online Course · Problem Solving & Interview Preparation

Data Structures & Algorithms

Master DSA for Placements

A rigorous, pattern-driven program that takes you from complexity analysis to graphs and dynamic programming in C++, Java or Python. You learn to recognize the pattern behind a problem, code a correct and efficient solution, and explain it clearly under the conditions of real online assessments and technical interviews.

  • 3 months · 12 weeks
  • Live online · worldwide
  • Level: Intermediate
  • ₹24,000 + GST (India) / ₹30,000 + GST (outside India)
  • Certificate of Completion
Enroll now View curriculum

Course overview

Think in patterns, not in memorized answers

Data Structures & Algorithms (DSA) is the shared language of technical hiring. Whether you take a campus placement test, an off-campus online assessment or a product-company interview loop, you will be asked to read an unfamiliar problem, choose the right way to organize the data, design an efficient algorithm and write working code within a time limit. This course is built to make you confident at exactly that.

Rather than racing through hundreds of disconnected questions, the program is organized around problem-solving patterns: prefix sums, two pointers, sliding window, binary search on the answer, recursion and backtracking, monotonic stacks, tree and graph traversals, greedy choices and dynamic programming. For every pattern you learn why it works, how to recognize the signals in a problem statement, what it costs in time and memory, and where it breaks down. That understanding transfers to questions you have never seen before, which is what assessments and interviews actually test.

You may code in C++, Java or Python. Concepts are taught in a language-neutral way using diagrams, pseudocode and step-by-step dry runs, and implementation guidance covers the standard libraries of all three languages: the C++ STL, the Java Collections Framework and Python’s built-in and standard-library data structures. You pick one language at the start and write all your assignments, projects and mock assessments in it.

Every concept is taught in live online classes and immediately practiced: guided problem solving in class, curated problem sets between classes, timed contests, hands-on mini-implementations such as an LRU cache, a trie-based autocomplete and a Dijkstra route finder, and a capstone project. The final weeks shift to placement readiness: online-assessment patterns, mock coding tests, interview communication, structured revision and mock interviews.

Duration3 months · 12 weeks
ModeLive online · worldwide
LevelIntermediate
LanguagesC++, Java or Python
TimingsIST · choose your slot
Hands-on work6 builds + capstone
Course fee₹24,000 + GST (India) / ₹30,000 + GST (outside India)
CredentialCertificate of Completion

Who should join

Who this course is for

The course is designed for learners who can already write basic programs and now want the depth, speed and confidence that coding assessments and technical interviews demand. It is particularly valuable for:

  • Undergraduate and postgraduate students in B.Tech/B.E., BCA, MCA, B.Sc. or M.Sc. (Computer Science, IT and related branches) preparing for campus placement drives and internship selections.
  • Final-year students and recent graduates preparing for off-campus hiring, where an online coding assessment is usually the first filter.
  • Early-career professionals in IT services, testing, support or non-core roles who want to move into software-engineering roles where DSA interviews are standard.
  • Self-taught and bootcamp developers who can build applications but find algorithmic interview questions difficult.
  • Aspiring competitive programmers who want a structured foundation in algorithms before taking part in contests regularly.
  • Learners preparing for competitive exams such as GATE (Computer Science) who want to strengthen the programming, data structures and algorithms portions of their preparation.

Prerequisites

  • Comfort writing simple programs in at least one of C++, Java or Python: variables, conditionals, loops, functions, arrays or lists, strings and basic input/output.
  • School-level mathematics. Logarithms, exponents and basic counting are revisited in Week 1.
  • No prior knowledge of data structures or algorithms is required; we build every topic from first principles.
  • Willingness to practice consistently between classes. Progress in DSA comes from deliberate practice.

What you need

  • A laptop or desktop computer (Windows, macOS or Linux) that can run a code editor and a compiler or interpreter.
  • A stable internet connection suitable for live video classes, and a modern web browser.
  • A headset or earphones with a microphone, so you can ask questions and take part in mock interviews.
  • A notebook or digital whiteboard for dry runs and recursion trees.
  • Free accounts on GitHub and on a coding-practice platform. We help you set these up in Week 1.

New to programming? Build your fundamentals first with our Python, C & C++ or Java course, then join this program. Not sure which fits you? Message us on WhatsApp before you enroll. The minimum learner age is 10, and learners under 18 can join with the verifiable consent of a parent or legal guardian, collected during registration (see our Privacy Policy).

Learning outcomes

What you will be able to do

By the end of the program, learners who complete the course requirements will be able to:

  • Analyze the time and space complexity of iterative and recursive code, and use input constraints to choose a target complexity before writing code.
  • Recognize and apply core array patterns (prefix sums, difference arrays, two pointers and sliding window) to replace brute-force nested loops.
  • Implement merge sort, quick sort and counting sort, and explain their complexity, stability and worst-case behavior.
  • Apply binary search without off-by-one errors, including lower/upper bounds and binary search on the answer space.
  • Write correct recursive and backtracking solutions (subsets, permutations, N-Queens, Sudoku) and prune the search space.
  • Use hashing and string algorithms (rolling hash, KMP prefix function and Z-function) to solve lookup and pattern-matching problems efficiently.
  • Build linked lists, stacks, queues, heaps and tries from scratch, and use their standard-library equivalents fluently in your chosen language.
  • Solve tree problems with the right traversal: BST operations, lowest common ancestor, height, diameter and path sums.
  • Model problems as graphs and apply BFS, DFS, topological sort, union-find, Dijkstra’s algorithm and minimum spanning trees.
  • Justify a greedy strategy with an exchange argument, and recognize when greedy fails and dynamic programming is required.
  • Design dynamic-programming solutions by defining states and transitions (1D, 2D, knapsack, LIS/LCS, grid and tree DP) and optimize their memory.
  • Answer range-query problems using segment trees and Fenwick trees at an introductory level.
  • Approach a timed online assessment with a repeatable strategy for reading, prioritizing, coding and testing.
  • Explain a solution in an interview: clarify requirements, move from brute force to an optimized approach, state the complexity and dry-run edge cases aloud.

Week-by-week curriculum

12-week curriculum

The syllabus moves from foundations to advanced patterns in a deliberate order: each week builds on the last, and every topic is practiced through live problem solving, a curated problem set and a weekly assignment. The final weeks combine advanced topics with your capstone project, revision and placement preparation.

Week 1Complexity Analysis, Math & Bit ManipulationThink in growth rates before you write a single line of code
  • Orientation: choosing C++, Java or Python; setting up your editor, compiler and practice-platform accounts
  • Asymptotic notation: Big-O, Big-Omega and Big-Theta; best, average and worst cases
  • Analyzing loops, nested loops and logarithmic loops; amortized analysis of dynamic arrays
  • A first look at recurrence relations and the Master theorem (intuition and common cases), applied again to recursion in Week 3 and to merge sort in Week 4
  • Space complexity: auxiliary space, in-place algorithms and the recursion call stack
  • Reading input constraints to decide which complexity will pass before you start coding
  • Number theory essentials: divisibility, GCD and LCM with Euclid’s algorithm, primality checks and the Sieve of Eratosthenes
  • Modular arithmetic, fast (binary) exponentiation and integer-overflow pitfalls in each language
  • Bit manipulation: AND, OR, XOR and shifts; checking, setting and clearing bits; counting set bits; XOR tricks; enumerating subsets with bitmasks

Outcome: You can estimate the running time and memory of any code snippet, predict whether it fits the constraints, and use math and bit tricks to simplify problems.

Week 2Arrays, Prefix Sums, Two Pointers & Sliding WindowThe patterns behind most array questions in online assessments
  • Arrays in memory: static versus dynamic arrays (vector, ArrayList, list) and the cost of each operation
  • In-place techniques: reversal, rotation, partitioning and removing duplicates
  • Prefix sums and difference arrays for fast range sums and range updates; 2D prefix sums for matrices
  • Kadane’s algorithm for the maximum subarray sum
  • Two pointers on sorted data: pair and triplet sums, container with most water, merging sorted arrays
  • Three-way partitioning (the Dutch national flag problem)
  • Sliding window: fixed-size windows and variable-size windows (longest substring without repeating characters, minimum window substring)
  • Matrix traversal patterns: spiral order, in-place rotation and searching a row- and column-sorted matrix

Outcome: You can spot when a quadratic brute force can be replaced by a linear-time prefix-sum, two-pointer or sliding-window solution, and explain why it is correct.

Week 3Recursion & BacktrackingBreak problems down, then explore every choice efficiently
  • How recursion works: base case, recursive case, the call stack and stack overflow
  • Drawing recursion trees and writing recurrences for your own functions
  • Classic recursion: power, reversal, palindrome checks and the Tower of Hanoi
  • Generating subsets, subsequences and permutations, with and without duplicates
  • The backtracking template: choose, explore, un-choose
  • Combination Sum, N-Queens, Sudoku solver, word search in a grid and rat-in-a-maze
  • Pruning and early termination to cut down the search space
  • Introduction to memoization: the bridge from recursion to dynamic programming

Outcome: You can write clean recursive solutions, draw and cost their recursion trees, and solve constraint-search problems with backtracking.

Week 4Sorting Algorithms & Binary SearchOrder your data, then search it in logarithmic time
  • Elementary sorts (bubble, selection, insertion) and why they are quadratic
  • Merge sort: divide and conquer, stable merging and counting inversions
  • Quick sort: Lomuto and Hoare partitioning, randomized pivots and worst-case behavior; Quickselect for the k-th smallest element
  • Counting sort and non-comparison sorting; what stability means and when it matters
  • Custom comparators: sorting objects and tuples in C++, Java and Python
  • Binary search done right: loop invariants, lower and upper bounds, first and last occurrence
  • Searching rotated sorted arrays, finding peak elements and searching in 2D matrices
  • Binary search on the answer: monotonic predicates in book allocation, minimum shipping capacity, minimum eating speed and integer square-root problems

Outcome: You can choose and implement the right sorting algorithm, justify its complexity and stability, and apply binary search, including on the answer space, without boundary errors.

Week 5Hashing & StringsConstant-time lookups and efficient pattern matching
  • Hash tables under the hood: hash functions, collisions, chaining versus open addressing, load factor and rehashing
  • Using hash maps and hash sets (unordered_map, HashMap, dict, set) effectively, and their worst cases
  • Frequency counting, two-sum variants, grouping anagrams and the longest consecutive sequence
  • Prefix sums combined with hash maps: counting subarrays with a given sum or XOR
  • String fundamentals: immutability, string builders, character arithmetic and palindrome checks
  • Rolling hash and the Rabin–Karp algorithm
  • KMP: the prefix function (LPS array) and linear-time pattern search (introduction)
  • The Z-algorithm for pattern matching (introduction)

Outcome: You can use hashing to turn quadratic searches into linear ones and apply string-matching algorithms to search and compare text efficiently.

Week 6Linked Lists, Stacks & QueuesPointer manipulation and order-based structures, including the monotonic stack
  • Singly, doubly and circular linked lists: insertion, deletion and traversal
  • Fast and slow pointers: middle of a list, cycle detection (Floyd’s algorithm) and intersection points
  • Reversing a list iteratively and recursively, reversing in groups of k, and merging sorted lists
  • Stacks: array- and list-based implementations; balanced parentheses; infix-to-postfix conversion and expression evaluation
  • Monotonic stack: next greater and next smaller element, stock span and largest rectangle in a histogram
  • Queues, circular queues and deques; implementing a queue with stacks and a stack with queues
  • Monotonic deque: sliding-window maximum
  • Design problems: a min-stack and an introduction to LRU cache design
  • Mid-course checkpoint: a timed contest on the patterns from Weeks 1–6, followed by a walkthrough of every problem

Outcome: You can manipulate pointers confidently and use stacks, queues and monotonic structures to solve “next element” and window problems in linear time.

Week 7Trees & Binary Search TreesHierarchical data and recursive thinking at scale
  • Tree terminology, binary-tree representation and construction
  • Depth-first traversals (preorder, inorder, postorder), both recursive and iterative
  • Level-order traversal (BFS), zig-zag traversal and left, right, top and bottom views
  • Height, diameter, balanced-tree checks and maximum path sum
  • Binary search trees: search, insert, delete, validate, k-th smallest, floor and ceiling
  • Lowest common ancestor (LCA) in binary trees and in BSTs
  • Building trees from traversals; serializing and deserializing a binary tree
  • Balanced BSTs in overview (AVL and red-black trees) and the ordered sets and maps built on them (std::set, std::map, TreeMap)

Outcome: You can solve tree problems by choosing the right traversal and deciding exactly what each recursive call should return.

Week 8Heaps, Priority Queues, Tries & GreedyAlways pick the best next option, and know when that is correct
  • Binary heaps: array representation, heapify, push and pop, and heap sort
  • Priority queues in each language: priority_queue (C++), PriorityQueue (Java) and heapq (Python)
  • Top-K elements, k-th largest element, merging k sorted lists and the running median with two heaps
  • Tries: insert, search, prefix queries, word counts and autocomplete
  • The greedy method: the greedy-choice property and exchange arguments
  • Activity selection, interval scheduling, merging intervals and minimum platforms
  • Fractional knapsack, job sequencing with deadlines and Huffman coding (concept)
  • When greedy fails: counterexamples that lead naturally to dynamic programming

Outcome: You can use heaps and tries for efficient ordering and prefix search, and defend (or reject) a greedy strategy with a clear argument.

Week 9GraphsModel relationships and networks, then traverse them
  • Graph representations: adjacency list versus adjacency matrix; directed, undirected and weighted graphs
  • Breadth-first search (BFS), depth-first search (DFS) and connected components
  • Grid graphs: counting islands, flood fill and multi-source BFS
  • Cycle detection in directed and undirected graphs; checking whether a graph is bipartite
  • Topological sort with Kahn’s algorithm and with DFS; course-schedule and dependency problems
  • Disjoint Set Union (union-find) with path compression and union by rank
  • Shortest paths: BFS for unweighted graphs, Dijkstra’s algorithm with a priority queue, and Bellman–Ford for negative edge weights (overview)
  • Minimum spanning trees with Kruskal’s and Prim’s algorithms

Outcome: You can translate a word problem into a graph, choose the right traversal or shortest-path algorithm, and implement it correctly and efficiently.

Week 10Dynamic Programming IStates, transitions and the art of never repeating work
  • From recursion to memoization to tabulation: a repeatable framework for any DP problem
  • Defining states and transitions; choosing base cases and the iteration order
  • 1D DP: climbing stairs, house robber, minimum-cost paths and coin change (fewest coins and number of ways)
  • 2D DP on grids: unique paths, minimum path sum and paths with obstacles
  • 0/1 knapsack and its family: subset sum, equal-sum partition and target sum
  • Unbounded knapsack: rod cutting and coin change revisited
  • Space optimization with rolling arrays
  • Reconstructing the actual solution, not just the optimal value

Outcome: You can identify a DP problem, define its state precisely, write both memoized and tabulated solutions and reduce their memory use.

Week 11Dynamic Programming II, Range Queries & Capstone Kick-offAdvanced DP patterns, segment and Fenwick trees, and your capstone plan
  • Subsequence DP: longest increasing subsequence (the quadratic approach and the O(n log n) approach) and longest common subsequence
  • String DP: edit distance, longest common substring and longest palindromic subsequence
  • Interval DP: matrix-chain multiplication and related partition problems (introduction)
  • DP on trees: maximum independent set (house robber on a tree) and computing diameters with DP
  • Bitmask DP (introduction): the traveling salesman problem on small inputs
  • Segment trees: build, point update and range query (sum and minimum); lazy propagation in overview
  • Fenwick trees (binary indexed trees): prefix sums with updates
  • Capstone kick-off: choosing a brief, writing a short design note and planning your tests

Outcome: You can tackle advanced DP patterns, answer range queries with segment or Fenwick trees, and have a scoped, trainer-reviewed plan for your capstone.

Week 12Placement Readiness, Mock Interviews & CapstoneRevise, simulate the real thing and present your work
  • Online-assessment patterns: timed coding problems with hidden test cases, multiple-choice questions on output prediction and complexity, and debugging tasks
  • Timed contests under exam conditions, followed by detailed walkthroughs of every problem
  • Mock coding assessments with post-test analysis of accuracy, speed and recurring mistakes
  • Interview communication: asking clarifying questions, presenting a brute-force approach first, optimizing out loud and stating complexity
  • Testing like an interviewer: dry runs and edge cases (empty input, a single element, duplicates, negative values and overflow)
  • Pattern-wise revision sprint and building your personal revision sheet
  • Mock technical interviews with structured feedback
  • Capstone presentation, code review and final submission
  • Career guidance: presenting DSA practice and projects on your resume and planning your next steps after the course

Outcome: You approach online assessments and technical interviews with a tested strategy and a revision system, and you have a capstone project you can explain in depth.

The trainer may adjust the order, pace or depth of individual topics to suit each batch, while covering the syllabus above.

Real-world projects

Hands-on builds and capstone

Solving problems on a practice platform proves you can apply an algorithm. Building something with it proves you understand it. Alongside the weekly problem sets you complete six hands-on builds that turn textbook data structures into working software, followed by a capstone that ties the whole course together. Every build is written in your chosen language, versioned on GitHub and reviewed with feedback on correctness, complexity and code quality.

PROJECT 01

LRU Cache

Implement a Least-Recently-Used cache that supports get and put in constant time by combining a hash map with a doubly linked list. Add capacity-based eviction, unit tests for edge cases and a short write-up comparing LRU with an LFU (least-frequently-used) policy.

  • Hashing
  • Doubly linked list
  • Design
  • Unit testing
PROJECT 02

Autocomplete with a Trie

Build a search-as-you-type engine over a word list. Store words and their frequencies in a trie, return the top suggestions for any prefix using a heap, and support deletion and case-insensitive matching.

  • Trie
  • Heaps
  • Strings
  • Ranking
PROJECT 03

Route Finder with Dijkstra

Model a city map as a weighted graph, compute the shortest route between two places with Dijkstra’s algorithm and reconstruct the full path. Compare it with BFS on an unweighted version of the map, then extend it to route around closed roads.

  • Graphs
  • Dijkstra’s algorithm
  • Priority queue
  • Path reconstruction
PROJECT 04

Task Scheduler with Heaps

Simulate a job scheduler that orders tasks by priority and deadline using a priority queue, respects task dependencies with a topological sort, detects impossible (cyclic) schedules and reports the order and waiting time of every task.

  • Heaps
  • Topological sort
  • Greedy
  • Simulation
PROJECT 05

Algorithm Visualizer

Instrument sorting and searching algorithms to record every comparison and swap, then replay the steps in the console or with a simple graphics library in your language. Use the recorded counts to compare algorithms on sorted, reversed and random inputs.

  • Sorting
  • Binary search
  • Instrumentation
  • Complexity analysis
PROJECT 06

Pattern Workbook & Solutions Repository

Throughout the course you solve curated problem sets organized by pattern. You maintain them in a structured GitHub repository with clean solutions, complexity notes, edge cases and a one-line “how I recognized the pattern” summary for each problem. It becomes your personal revision system before assessments.

  • Curated problem sets
  • Git & GitHub
  • Documentation
  • Revision
CAPSTONE PROJECT

Mini Search Engine, or a capstone brief of your choice

Index a collection of documents with an inverted index (hashing), offer prefix autocomplete (trie), rank results by relevance (heap) and suggest spelling corrections using edit distance (dynamic programming). Alternative briefs include a campus navigation and event-planning system (shortest paths, minimum spanning tree and interval scheduling) or a proposal of your own that the trainer approves in Week 11.

You submit working code with tests, a short design document and a complexity report, and you present a live walkthrough in Week 12, explaining your design decisions the way you would in a technical interview. Submission of the capstone is required for the Certificate of Completion.

  • Inverted index
  • Trie
  • Heaps
  • Dynamic programming
  • Graphs
  • Testing
  • Technical presentation

Tools & technologies

Languages, libraries and tools you will use

DSA is about thinking, but professional habits matter too. You will work with the same languages, standard libraries, debugging techniques and version-control workflow that engineers use every day.

Languages & standard libraries

  • C++ with the STL
  • Java with the Collections Framework
  • Python 3
  • vector, unordered_map, set, priority_queue
  • ArrayList, HashMap, TreeMap, ArrayDeque, PriorityQueue
  • list, dict, set, collections.deque, heapq, bisect

Editors, compilers & debuggers

  • Visual Studio Code
  • IntelliJ IDEA
  • PyCharm
  • GCC / g++ or Clang
  • OpenJDK
  • CPython
  • GDB and IDE debuggers

Practice & assessment platforms

  • LeetCode
  • Codeforces
  • CodeChef
  • HackerRank
  • GeeksforGeeks
  • AtCoder

Testing & verification

  • Hand-written edge cases
  • Stress testing against brute force
  • Random test generators
  • Assertions
  • GoogleTest
  • JUnit
  • pytest

Version control & portfolio

  • Git
  • GitHub
  • README documentation
  • Markdown

Visualization & dry-run aids

  • VisuAlgo
  • Python Tutor
  • Digital whiteboard
  • Recursion-tree diagrams

Free editions or free tiers of the tools above are sufficient for this course. Product and platform names are trademarks of their respective owners; AwT Academy is not affiliated with or endorsed by them.

Learning experience

How you will learn

The program is taught live, so you can ask questions the moment you are stuck and see how an experienced problem solver thinks through a problem, including the dead ends. Every session pairs explanation with practice.

Live classes & hands-on practice

Interactive live sessions where concepts are explained with diagrams and dry runs, then coded and tested together in class.

Study material & assignments

Structured notes, pattern summaries, curated problem sets and weekly assignments that reinforce each topic.

Doubt-solving

Time for questions is built into live classes, and at the start of your batch the team explains how to raise doubts between sessions.

Interview preparation

Online-assessment practice, timed contests, mock coding tests and mock technical interviews with structured feedback.

Career guidance

Guidance on presenting your projects and practice on your resume and GitHub, and on planning your preparation for the roles you are targeting.

Community

Be a part of a growing tech community of learners who practice, discuss approaches and keep each other accountable.

A typical week

  1. Learn the pattern

    A live session introduces the week’s data structure or technique: intuition, proof of correctness and complexity.

  2. Solve together

    Guided problem solving in class, moving from brute force to the optimized approach with live coding and dry runs.

  3. Practice independently

    A curated problem set and an assignment, from warm-up questions to assessment-level problems.

  4. Review & reflect

    Walkthroughs, doubt-solving and feedback, then you record what you learned in your pattern workbook.

Schedule and time zones

All sessions are scheduled in Indian Standard Time (IST, UTC+5:30). When you register, you choose a preferred slot (Morning, Afternoon, Evening, Weekend or Flexible), and our team confirms the batch start date and final timings before your batch begins. Learners outside India should choose the slot that best matches their local time zone.

Class modes

Live Online Open

Live, interactive classes on Google Meet, open to learners anywhere in the world (a Google account may be needed to join). The same curriculum, trainer-led sessions, projects and certificate requirements apply to every online learner. The fee depends only on your country of residence: ₹24,000 + GST in India, ₹30,000 + GST outside India.

Enroll in the online batch

Offline (classroom) Coming soon

Classroom batches are planned for learners in Chandigarh, Mohali and Panchkula only. No launch date has been announced, and offline seats cannot be booked or paid for yet. Message or call us to be informed when offline batches open.

Get notified about offline batches

Class etiquette and integrity. Your class link is personal and must not be shared. Learners must not record, distribute screenshots of or redistribute live sessions or course materials. We do not promise that every session is recorded; if the academy makes a recording available for a session, it is for your personal study only. See our Terms & Conditions for the full code of conduct.

Certification & assessment

Certificate of Completion

On completing the course requirements, you receive an AwT Academy Certificate of Completion for the Data Structures & Algorithms program. To qualify, you need:

  • At least 75% live-session attendance.
  • Submission of the required assignments.
  • Submission of the final (capstone) project.

How your progress is assessed

Assessment components of the Data Structures and Algorithms course
ComponentWhat it involvesWhy it matters
Weekly assignmentsPattern-based problems in your chosen language, each with a complexity analysis and test cases.Builds consistency and shows whether you can apply each week’s pattern on your own.
Project reviewsReview of your hands-on builds for correctness, efficiency, code quality and documentation.Turns theory into working software and gives you portfolio pieces to discuss in interviews.
Capstone evaluationCode, tests, design document and complexity report, plus a live walkthrough of your decisions.Demonstrates end-to-end problem solving and the ability to explain your work clearly.
Contests & mock assessmentsTimed problem solving under exam conditions, with walkthroughs and individual feedback.Practice and feedback that prepare you for real online assessments and interviews.

Contests and mock assessments are for practice and feedback; they are not additional certificate requirements. The Certificate of Completion is issued by AwT Academy and confirms that you completed this training program. It is not a university degree, an accredited qualification or a government-issued certificate.

Career paths

Where strong DSA skills take you

Algorithmic problem solving is widely tested in hiring for software-engineering roles, from campus drives to experienced-hire interviews. The skills you build here prepare you for the coding assessments and technical rounds of roles and paths such as:

  • Software Development Engineer (SDE) / Software Engineer: the roles where DSA interviews are most common.
  • Software Engineering Intern: internship selections usually begin with a coding assessment.
  • Backend Developer: efficient data handling, caching and scalable logic.
  • Full-Stack Developer: many product teams run algorithm rounds for full-stack roles too.
  • Graduate / Associate Engineer roles in IT services companies, which commonly use aptitude and coding tests.
  • Competitive programmer: a solid base for contests and coding competitions.
  • Data and ML engineering tracks: when combined with our AI & Machine Learning or Data Science & Data Analytics courses.
  • GATE (Computer Science) preparation: a strong base for the programming, data structures and algorithms portions of the syllabus.

What interviewers and assessments actually test

Hiring stages, what they evaluate and how this course prepares you
StageWhat is evaluatedHow this course prepares you
Online coding assessmentCorrect, efficient code under time pressure, judged against hidden test cases; often MCQs on output prediction and complexity.Timed contests, mock assessments, constraint-based complexity planning and edge-case testing.
Technical interview: problem solvingHow you clarify the problem, explore approaches, move from brute force to optimal and analyze trade-offs.Pattern recognition training and live “think aloud” problem solving in every class.
Technical interview: codingClean, readable, bug-free code; sensible naming; handling edge cases; dry-running your own code.Code reviews on assignments and projects, testing techniques and mock interviews.
Project discussionYour understanding of what you built: design decisions, data-structure choices and limitations.Hands-on builds and a capstone you present and defend in a live walkthrough.
Behavioral / HR roundCommunication, motivation, teamwork and clarity about your goals.Career guidance and structured practice explaining your work and learning journey.

An honest note on outcomes. AwT Academy does not guarantee jobs, internships, placements or salaries. We provide career guidance and interview preparation; your results depend on your effort, consistent practice and the hiring market.

Your trainer

Learn from an experienced technical trainer

Portrait of Manish Mishra, Managing Director & Head of AwT Academy

Manish Mishra

Managing Director & Head, AwT Academy

Technical Trainer | AI/ML Educator

Manish Mishra is the Managing Director & Head of AwT Academy and leads its technical training. He has worked at Intel, IBM and Microsoft, has trained 25,000+ students over 5 years of training experience, has reached 68+ colleges and is GATE qualified twice. In this course he teaches the patterns, the reasoning behind them and the interview communication that turns a correct solution into a convincing one.

Intel logoWorked atIntel
IBM logoWorked atIBM
Microsoft logoWorked atMicrosoft
Public-sector experienceWorked with Ministry of Labour and Skill Development
Students trained25,000+
Training hours10,000+
Colleges reached68+
Training experience5 Years
GATEQualified Twice

Company names and logos identify the trainer’s past employers only. They, and the reference to the trainer’s work with the Ministry, do not imply any partnership with, accreditation or approval of, or endorsement of AwT Academy by these organizations or any government body.

Learn more about our leadership and team

Fees & payment

Course fee

One transparent fee covers the complete 3-month program. The fee is the same for every AwT Academy course and depends only on your country of residence: learners in India pay ₹24,000 + GST (₹28,320 in total), and learners outside India pay ₹30,000 + GST (₹35,400 in total).

Fee breakdown for the Data Structures and Algorithms course
ItemAmount (INR)
Course fee (exclusive of GST)₹24,000 (India) · ₹30,000 (outside India)
GST @ 18%₹4,320 (India) · ₹5,400 (outside India)
Total payable₹28,320 (India) · ₹35,400 (outside India)
  • Prices are exclusive of GST, which is levied at the rate prescribed under Indian law (currently 18%).
  • A GST-compliant tax invoice is issued to your registered email address. You can enter your GSTIN during registration for an invoice in your business’s name.
  • All payments are charged in Indian Rupees (INR). For international cards, any currency conversion and bank charges are set by your bank.
  • Your fee tier is determined by the country of residence you declare at registration, and the registration form applies the correct fee automatically. Misdeclaration may lead to cancellation or a demand for the difference.
  • Fees are per learner and cannot be transferred to another person.

What’s included

  • Live online classes for the full 12-week curriculum
  • Study material, pattern notes and weekly assignments
  • Curated problem sets for every topic
  • Doubt-solving during live classes
  • Six hands-on builds and a capstone project with reviews
  • Timed contests and mock coding assessments
  • Interview preparation and mock technical interviews
  • Career guidance
  • Membership of a growing tech community
  • Certificate of Completion on meeting the requirements

How payment works

  1. Register

    Fill in the registration form: choose this course, Live Online mode and your preferred timing, then complete a quick security check.

  2. Pay securely

    Pay ₹28,320 (India) or ₹35,400 (outside India) in INR through Razorpay using UPI, cards, net banking or wallets. International cards are accepted where your bank supports them.

  3. Payment verified

    Your registration is submitted only after Razorpay confirms your payment. Your seat is confirmed once the payment is captured and verified.

  4. Get ready

    You see a receipt on screen and Razorpay emails a payment confirmation. We share your batch start date and final timings before the batch begins.

Your payment details stay with Razorpay. Payments are processed by Razorpay, a PCI-DSS compliant gateway. AwT Academy never sees or stores your card number, CVV, UPI PIN or net-banking password. See our security practices.

Refunds & cancellations at a glance

Summary of the refund and cancellation policy
SituationWhat you receive
You cancel before the batch starts or within the first 4 days from the batch start date100% refund of the full amount paid (course fee + GST).
You cancel on day 5, 6 or 7 from the batch start dateRefund of 50% of the course fee plus the GST attributable to that 50%.
You cancel from day 8 after the batch start dateNo refund. A one-time transfer to a later batch may be granted at the academy’s discretion, subject to seat availability, to be used within 6 months.
The academy cancels the batch or postpones its start by more than 30 days100% refund of the amount paid (including GST), or a free transfer. You choose.

This is a summary. The Refund & Cancellation Policy is the governing document and explains course switches, failed or duplicate payments, timelines and how to request a refund.

Questions & answers

Frequently asked questions

Which programming language should I use: C++, Java or Python?

Any of the three. Choose the language you are most comfortable with, or the one your target companies or college placement cell recommend. C++ is popular in competitive programming for its speed and the STL; Java is widely used in enterprise development and interviews; Python is concise and readable, though you need to be careful with performance on tight limits. All three are widely accepted in coding assessments and interviews.

Concepts are taught in a language-neutral way, and implementation guidance covers the standard libraries of all three. You write your assignments, projects and capstone in the language you choose.

Do I need to know programming before joining?

Yes. This is an Intermediate-level course, so you should be comfortable writing simple programs (variables, conditionals, loops, functions, arrays or lists, and strings) in C++, Java or Python. You do not need any prior knowledge of data structures or algorithms. If you are new to programming, start with our Python, C & C++ or Java course.

How is this course different from the Java or C & C++ courses?

The Java course (“Programming & DSA”) teaches the Java language in depth and then applies it to data structures. The C & C++ course (“Programming & Problem Solving”) builds language fundamentals and problem-solving skills. This course assumes you already know the basics of one language and spends the full 12 weeks on DSA: problem-solving patterns, graphs, dynamic programming, range queries, timed contests, mock assessments and interview preparation, in your choice of C++, Java or Python.

When does the next batch start, and what are the class timings?

Batch start dates and final class timings are communicated after you register and before the batch begins. All timings are in Indian Standard Time (IST). During registration you choose a preferred slot (Morning, Afternoon, Evening, Weekend or Flexible), and our team confirms the final schedule with you.

The academy may reschedule individual sessions with notice. If the academy postpones a batch start by more than 30 days, you may choose a full refund or a transfer.

Can I join from outside India?

Yes. Live online classes on Google Meet are open to learners worldwide. The fee is ₹24,000 + GST (₹28,320 in total) for learners resident in India, or ₹30,000 + GST (₹35,400 in total) for learners resident outside India, charged in Indian Rupees through Razorpay. The registration form applies the correct fee automatically from the country you select. International cards are accepted where your bank supports them, and any currency conversion and bank charges are set by your bank. Choose the IST slot that best suits your time zone when you register.

Will live sessions be recorded?

The course is designed around live participation, and we do not promise that every session is recorded. If the academy makes a recording available for a session, it is for your personal study only. Learners must not record, distribute screenshots of or redistribute sessions or course materials, and class links are personal and must not be shared.

Are offline (classroom) batches available?

Offline batches are coming soon and will be available only to learners in Chandigarh, Mohali and Panchkula. No launch date has been announced, and offline seats cannot be booked or paid for yet. If you would like to be informed when they open, message us on WhatsApp or call +91 62830 97869 or +91 94652 65663. Live online batches are open now.

What do I need to do to earn the Certificate of Completion?

You need at least 75% live-session attendance and must submit the required assignments and the final (capstone) project. The Certificate of Completion is issued by AwT Academy and confirms that you completed this training program; it is not a university degree or a government-issued qualification.

Do you guarantee a job, internship or placement?

No. AwT Academy does not guarantee jobs, internships, placements or salaries. We provide rigorous DSA training, interview preparation, mock assessments and career guidance; your outcomes depend on your effort, your consistency in practice and the hiring market.

How do I pay, and when is my seat confirmed?

Register and pay online on the registration page through Razorpay, using UPI, cards, net banking or wallets. Your registration is submitted only after Razorpay confirms the payment, and your seat is confirmed once the payment is captured and verified. You receive an on-screen receipt and a payment confirmation email from Razorpay, followed by a GST-compliant tax invoice at your registered email address.

If a payment fails but money is debited, it is automatically reversed by your bank or Razorpay, typically within 5–7 working days. Duplicate payments for the same registration are refunded in full.

What is the refund and cancellation policy?

If you cancel before the batch starts or within the first 4 days from the batch start date, you receive a 100% refund of the full amount paid (course fee + GST). On day 5, 6 or 7 from the batch start date, you receive 50% of the course fee plus the GST attributable to it. From day 8 onward there is no refund, although a one-time transfer may be granted at the academy’s discretion. If the academy cancels a batch or postpones its start by more than 30 days, you receive a 100% refund or a free transfer, as you choose.

To request a refund, WhatsApp or call +91 62830 97869 or +91 94652 65663 with your Registration ID, Razorpay Payment ID, registered name and email, and the reason. Requests are acknowledged within 48 hours and decided within 7 working days. Approved refunds are initiated within 7 working days of approval, to the original payment method only, and usually reach your bank account 5–10 working days after initiation (international cards may take longer and are refunded in INR). Full details are in the Refund & Cancellation Policy.

Can I switch to a different course or a later batch?

Yes, within limits. You can switch to another course in the same fee tier free of charge, once, before the batch starts or within the first 4 days of the batch. After that, a one-time transfer may be granted at the academy’s discretion, subject to seat availability, and must be used within 6 months. Fees cannot be transferred to another person.

Keep learning

Related courses

Strengthen your programming foundations or go deeper into a language alongside your DSA preparation.

Python

From Basics to Advanced

Go from your first line of code to building real applications, automations and data tools with Python — the language behind AI, data science and modern back-ends.

3 Months Live Online ₹24,000 + GST (India)
View details Enroll now

C & C++

Programming & Problem Solving

Build rock-solid programming fundamentals — memory, pointers, OOP and the C++ STL — and sharpen the problem-solving skills that coding interviews and competitive programming demand.

3 Months Live Online ₹24,000 + GST (India)
View details Enroll now

Java

Programming & DSA

Master core and advanced Java — OOP, collections, exceptions, multithreading — and apply it to data structures and algorithms the way top product companies test it.

3 Months Live Online ₹24,000 + GST (India)
View details Enroll now

Take the Next Step Today!

Join upcoming batches of Data Structures & Algorithms: live online, open to learners worldwide. Register now and we will share your batch start date and timings before the batch begins.

Enroll now Talk to us