4–6 Months | 26 Weeks | 300–400+ Hours — Problem Solving • Data Structures • Algorithms • Competitive Programming • Coding Interviews • Software Engineering. Concept Classes + Coding Labs + Problem-Solving Sessions + Weekly Challenges + Mock Interviews + Capstone.
Core positioning: Don't just memorize algorithms. Learn how to analyze problems, choose the right data structure, design efficient solutions and write production-quality code.
Student journey: Programming Fundamentals → Problem Decomposition → Time & Space Complexity → Arrays & Strings → Linked Lists → Stacks & Queues → Hashing → Recursion → Trees → Heaps → Graphs → Sorting & Searching → Greedy → Backtracking → Dynamic Programming → Advanced Algorithms → Competitive Programming → Coding Interviews → Real-World Algorithm Design.
Primary language: Java (aligned with RIA Java Full Stack pathway); C++ / Python secondary.
Prepares you for roles including
- Software Engineer, Java/Full Stack/Backend/Python/C++ Developer
- Algorithm Engineer, Software Development Engineer, AI/ML Engineer, Data Engineer
- Embedded Software Engineer, Competitive Programmer
- Technical interviews at product-based software companies
Program architecture (17 phases)
- Phases 1–2 (Wk 1–3): Programming, problem solving, complexity analysis
- Phases 3–6 (Wk 4–8): Arrays, strings, linked lists, stack, queue, hashing
- Phases 7–10 (Wk 9–17): Recursion, backtracking, trees, heaps, graphs
- Phases 11–14 (Wk 18–23): Sorting, searching, greedy, dynamic programming
- Phases 15–17 (Wk 24–26): Advanced algorithms, competitive programming, interviews & capstone
Phase 1 — Programming & Problem Solving (Weeks 1–2)
Module 01 — Programming Fundamentals
- Java primary (C++/Python secondary): variables, types, operators, conditions, loops, functions, arrays, strings, I/O
Module 02 — Computational Thinking
- Problem → Input → Processing → Output; constraints, edge cases, decomposition, brute-force, optimize
Module 03 — Problem-Solving Methodology
- Understand → examples → constraints → brute-force → analyse complexity → optimize → code → test → review
Phase 2 — Complexity Analysis (Week 3)
Module 04 — Big-O Analysis
- Time: O(1), O(log n), O(n), O(n log n), O(n²), O(2ⁿ), O(n!)
- Space: auxiliary, input, recursion stack
Module 05 — Complexity Optimization
- Compare O(n²) vs O(n log n) vs O(n); trade memory for speed
Phase 3 — Arrays & Strings (Weeks 4–5)
Module 06 — Arrays
- Static/dynamic arrays, traversal, insertion, deletion, prefix sums
- Patterns: two pointers, sliding window, frequency counting, partitioning
Module 07 — Array Problem Solving
- Max subarray, duplicates, rotation, merge sorted, missing number, subarray/interval problems
Module 08 — Strings
- Manipulation, frequency maps, palindromes, anagrams, pattern matching
- Advanced awareness: string hashing, KMP, trie
Phase 4 — Linked Lists (Week 6)
Module 09 — Linked Lists
- Singly, doubly, circular; insert, delete, search, reverse, traverse
Module 10 — Linked List Algorithms
- Reverse, cycle detection, middle, merge, duplicates, intersection, palindrome
- Project: Custom Linked List Library
Phase 5 — Stacks & Queues (Week 7)
Module 11 — Stack
- Expression evaluation, parentheses, undo, call stack
- Next greater element, valid parentheses, min stack, infix/postfix
Module 12 — Queue
- Simple, circular, deque, priority queue; scheduling, buffering, BFS, task processing
Phase 6 — Hashing (Week 8)
Module 13 — Hash Tables
- Hash function, collisions, chaining, open addressing; Java HashMap, HashSet
Module 14 — Hashing Patterns
- Two Sum, frequency counting, group anagrams, longest consecutive sequence
- When hashing reduces O(n²) to O(n)
Phase 7 — Recursion & Backtracking (Weeks 9–10)
Module 15 — Recursion
- Base condition, call stack, divide and conquer; factorial, Fibonacci, tree traversal, binary search
Module 16 — Backtracking
- Choose → Explore → Undo; permutations, combinations, subsets, N-Queens, Sudoku
Phase 8 — Trees (Weeks 11–13)
Module 17 — Binary Trees
- Root, parent, child, leaf, height, depth; preorder, inorder, postorder, level order
Module 18 — Binary Search Trees
- Search, insert, delete; balanced trees, height, complexity
Module 19 — Advanced Trees
- AVL, red-black, segment trees, Fenwick trees, trie
- Project: File-system / directory indexing system
Phase 9 — Heaps & Priority Queues (Week 14)
Module 20 — Heap
- Min/max heap, insert, delete, heapify, extract; scheduling, top-K, median
Module 21 — Heap Algorithms
- K largest/smallest, Kth largest, merge K sorted lists, running median
Phase 10 — Graphs (Weeks 15–17)
Modules 22–23 — Graph Fundamentals & Traversal
- Adjacency matrix/list; directed, undirected, weighted graphs
- BFS (queue), DFS (stack/recursion); components, islands, cycle detection, path finding
Modules 24–26 — Shortest Path, MST & Advanced
- Dijkstra, Bellman-Ford, Floyd-Warshall; Kruskal, Prim, Union-Find
- Topological sort, SCC, bipartite, network flow awareness
- Project: Route Optimization System
Phase 11 — Sorting (Week 18)
Module 27 — Basic Sorting
- Bubble, selection, insertion — implement and analyse limitations
Module 28 — Efficient Sorting
- Merge, quick, heap sort; time, space, stability, in-place behaviour
Module 29 — Non-comparison Sorting
- Counting sort, radix sort, bucket sort
Phase 12 — Searching (Week 19)
Module 30 — Searching
- Linear O(n), binary O(log n); binary search on answer, rotated arrays, monotonic functions
Module 31 — Search Problems
- First/last occurrence, search rotated array, search range, min/max feasible value
Phase 13 — Greedy Algorithms (Week 20)
Module 32 — Greedy Strategy
- Activity selection, fractional knapsack, job scheduling, interval scheduling, minimum platforms
Module 33 — Greedy vs Dynamic Programming
- When greedy works vs when it fails
Phase 14 — Dynamic Programming (Weeks 21–23)
Module 34 — DP Fundamentals
- Overlapping subproblems, optimal substructure, state, transition, base case
Modules 35–36 — 1D & 2D DP
- Fibonacci, climbing stairs, house robber, coin change
- Grid paths, 0/1 knapsack, LCS, edit distance
Module 37 — Advanced DP
- Interval DP, tree DP, bitmask DP, digit DP awareness
- Project: Resource Optimization Engine
Phase 15 — Advanced Algorithms (Week 24)
Module 38 — Divide & Conquer
- Merge/quick sort, binary search, recurrence relations
Module 39 — Advanced Techniques
- Bit manipulation, prefix sums, difference arrays, monotonic stack/queue, sweep line awareness
Module 40 — String Algorithms
- KMP, Rabin-Karp, trie, string hashing
Phase 16 — Competitive Programming (Week 25)
Module 41 — Competitive Programming & Rasa Algorithm Challenge
- Fast I/O, constraint analysis, pattern recognition, optimization, edge cases
- Weekly contests; difficulty levels ⭐⭐ to ⭐⭐⭐⭐⭐
Phase 17 — Interview Preparation & Capstone (Week 26)
Modules 42–44 — Interview Prep
- Explain: problem, approach, alternatives, complexity, edge cases, code, testing
- Patterns: two pointers, sliding window, BFS/DFS, backtracking, heap, greedy, DP, prefix sum, monotonic stack
- 5 mock interview rounds: fundamentals, DS, algorithms, optimization, explanation
Real-world algorithm applications
- E-commerce search/ranking, banking/fraud graphs, healthcare scheduling, logistics routing, social graphs, AI optimization
RASA Algorithm Engineering Challenge — capstone options
- Option 1 — Delivery Route Optimizer: locations, road network, shortest path
- Option 2 — E-commerce Search Engine: hashing, trees, trie, sorting, ranking
- Option 3 — Social Network Analytics: BFS, DFS, recommendations
- Option 4 — Hospital Resource Optimization: greedy, priority queues, DP
- Option 5 — AI Recommendation Engine: hashing, similarity, graph relationships
- Option 6 — Smart Factory Scheduler: connects with Industrial Automation
Integration with RASA technology programmes
- Java Full Stack: Java → DSA → Spring Boot → React (programme)
- AI / ML: Python → DSA → Algorithms → ML (Data Science & AI)
- Robotics / Drone: C++/Python → DSA → path planning → autonomy
- Embedded / VLSI / Industrial: algorithms for scheduling, optimization, EDA
Labs, problem bank, portfolio, certification & assessment
Four DSA labs
- Coding Lab (Java/C++/Python), Algorithm Visualization, Problem-Solving Lab (10–20 weekly), Interview Lab
Rasa DSA Problem Bank — 600+ problems
- Beginner 100, Intermediate 150, Advanced 100, Interview 150, Competitive 100 — by topic, difficulty, pattern
15+ portfolio projects
- Custom ArrayList, linked list, stack, queue, HashMap, sorting/search engines, tree index, graph navigator, route optimizer, scheduling engine, recommendation engine, capstone system
Three RASA certification levels
- Level 1 — DSA Foundation Professional: programming + complexity + arrays + strings + linked lists + stack + queue + hashing
- Level 2 — Professional Algorithm Engineer: trees + graphs + heaps + sorting + searching + greedy + DP
- Level 3 — Advanced Algorithms & Problem-Solving Professional: advanced algorithms + competitive programming + real-world engineering
Assessment framework (100%)
- Programming + Complexity (10%), Arrays + Strings + Linked Lists (15%), Stack + Queue + Hashing (10%), Recursion + Backtracking (10%), Trees + Heaps (15%), Graphs (15%), Sorting + Searching (5%), Greedy + DP (15%), Advanced Algorithms (5%), Capstone + Coding Assessment (10%)
Six stages: THINK (decomposition) → ANALYSE (complexity) → STRUCTURE (data structure) → ALGORITHM (optimal solution) → IMPLEMENT (clean code) → OPTIMIZE (performance + scalability).
Toolkit: Java (primary), C++/Python, IntelliJ/VS Code, Git, JUnit, algorithm visualization, online judges, AI coding assistants (with validation discipline).
Enquire about this program · View full programme page
