Tutorials

The friendliest first language. Start here if you have never written code.

1 Introduction to Python What Python actually is, why it works well as a first language, how your code gets run, and how to print output and write comments. 8 min 2 Variables and Data Types How variables store values, the four types you will use most, checking types with type(), converting between them, and the naming rules that matter. 9 min 3 Input and Output Reading data from the user with input(), why it always gives you text, converting it to numbers, and formatting output cleanly with f-strings. 8 min 4 Operators Arithmetic, comparison, logical and assignment operators, the difference between / and //, and the precedence rules that decide evaluation order. 9 min 5 Making Decisions with if and else Writing conditions with if, elif and else, why Python treats indentation as part of the language, nested conditions, and how truthiness works. 9 min 6 Loops: for and while Repeating work with for and range(), looping until a condition changes with while, controlling loops using break and continue, and choosing between them. 9 min 7 Lists and Strings Storing many values in a list, indexing and slicing, the methods you will use most, and why strings behave like lists but cannot be changed. 10 min 8 Functions Defining your own functions, passing parameters, returning values, how scope works, default arguments, and why functions matter more than they first appear. 10 min

The language most Indian colleges teach first. Closer to the machine than anything else you will learn.

1 Introduction to C What C actually is, why almost every Indian engineering college starts with it, how compilation differs from interpretation, and your first program explained line by line. 9 min 2 Variables and Data Types How C stores numbers and characters, what int, float, char and double really mean, and why sizeof and format specifiers matter more than they first appear. 10 min 3 Input and Output in C printf format specifiers in detail, escape sequences, and an honest look at scanf and the traps that catch every beginner at least once. 10 min 4 Operators in C Arithmetic, relational, logical and bitwise operators, the real difference between i++ and ++i, and how precedence decides what your expression actually means. 10 min 5 Conditionals: if, else and switch How C decides what to run next, when switch beats a chain of else-if, the ternary operator, and the assignment-instead-of-comparison bug that catches everyone. 9 min 6 Loops: for, while and do-while The three loop forms in C, how to choose between them, what break and continue actually do, and how nested loops produce the pattern questions exams love. 10 min 7 Arrays and Strings Declaring and indexing arrays, why going out of bounds is dangerous rather than an error, how char arrays become strings, and what the null terminator really does. 11 min 8 Functions in C Writing your own functions, the difference between declaration and definition, why prototypes exist, what call by value really means, and how scope decides what a name refers to. 10 min

C with objects, containers and a huge standard library. The competitive-programming default.

1 Introduction to C++ What C++ adds on top of C, why that addition matters, how iostream replaces printf, and your first program compiled and run line by line. 9 min 2 Variables, Types and Input/Output The built-in types and their sizes, when auto helps and when it hides things, how cout and cin work, and the honest difference between endl and a newline character. 9 min 3 Conditionals and Loops Making decisions with if, else and switch, repeating work with for, while and do-while, and using the range-based for loop that C does not have. 9 min 4 Functions and References Writing functions, the real difference between passing by value and by reference, default arguments, and how overloading lets one name serve several types. 9 min 5 Vectors and Strings How std::vector and std::string manage their own memory, the operations you will use daily, and the concrete reasons they are safer than raw arrays and char buffers. 9 min 6 Classes and Objects The difference between struct and class, how constructors guarantee a valid object, what encapsulation actually buys you, and a complete worked example. 10 min

Verbose but predictable, and still what most campus placement tests expect.

1 Introduction to Java What the JVM actually does, why Indian colleges lean on Java for OOP papers, and your first program explained keyword by keyword before you compile and run it. 9 min 2 Variables and Types The eight primitive types and how they differ from objects, why String behaves oddly, when casting loses data, and what final really promises. 9 min 3 Input and Output Printing with println and printf, formatting numbers properly, and reading keyboard input with Scanner including the newline trap that catches everyone. 8 min 4 Control Flow Branching with if, else and switch, repeating with for, while and do-while, and looping over collections with the enhanced for. 9 min 5 Arrays and Strings Fixed-size arrays and the length field, when to switch to ArrayList, the String methods you will use daily, and why immutability matters more than it sounds. 9 min 6 Methods, Classes and Objects Writing methods, the real difference between static and instance members, defining classes with constructors, and why keeping fields private is worth the extra typing. 10 min

The part interviews actually test. Intuition first, formal notation second.

1 Time and Space Complexity, Explained Simply Why we measure algorithms by counting operations instead of stopwatch seconds, and what O(1), O(log n), O(n) and O(n squared) actually mean. 9 min 2 Arrays: How They Sit in Memory and Why That Matters What an array really is at the memory level, why indexing costs nothing, why inserting in the middle is expensive, and the traversal patterns you will reuse everywhere. 10 min 3 Searching: Linear Search and Binary Search How linear search works, how binary search halves the problem each step, exactly when binary search is allowed, and the off-by-one traps that break it. 9 min 4 Sorting Basics: Bubble, Selection and Insertion Sort How the three simple sorting algorithms actually work, which one is least bad in which situation, what stability means, and why all three are O(n squared). 10 min 5 Linked Lists: Nodes, Pointers and Trade-offs What a node really is, why linked lists exist at all, how the basic singly linked list operations work, and an honest comparison with arrays. 10 min 6 Stacks and Queues: LIFO and FIFO The two simplest restricted data structures, why limiting what you can do is useful, how to build both on top of arrays, and where they show up in real software. 9 min 7 Hashing: How Dictionaries Find Things Instantly The idea behind hash tables, why lookup is close to O(1), what collisions are and how they are handled, and when hashing beats sorting. 10 min 8 Recursion: Functions That Call Themselves Base cases and recursive cases, what the call stack is doing underneath, factorial and Fibonacci, why naive Fibonacci is so slow, and when to prefer a loop. 10 min