Prasad Raju G

AlgoX

2026-06-08T00:00:00+00:00

AlgoX brings STL-style data structures and algorithms to Python with a native C backend.

![Project Status](https://img.shields.io/badge/status-under%20development-orange)

What is AlgoX?

AlgoX is a C-powered algorithms and data structures library for Python. It provides STL-inspired containers, generic algorithms, and low-overhead implementations designed for performance, learning, and experimentation.

TrueML

2026-06-08T00:00:00+00:00

Why Choose a No-Abstraction Philosophy?

Most machine learning frameworks present a black-box contract: data goes in, a trained model comes out. sklearn.linear_model.LinearRegression().fit(X, y) conceals the forward pass, the loss evaluation, the gradient computation, and the parameter update behind a single method call. While convenient for production, this opacity is antithetical to understanding.

TrueML adopts the opposite stance: zero abstraction. Every mathematical operation in the learning pipeline is a first-class function you invoke explicitly. The library provides the primitive operations; you write the protocol.

How Does the Four-Step Pipeline Work?

Every supervised learning experiment in TrueML follows this canonical sequence:

┌─────────────────────────────────────────────────────────┐
│                     TRAINING LOOP                       │
│                                                         │
│  1. FORWARD     y_pred = model.forward(X)               │
│       ŷ = Xw + b                                        │
│                                                         │
│  2. LOSS        error = loss_fn(y, y_pred)              │
│       L = |y – ŷ|                                       │
│                                                         │
│  3. GRADIENT    dw, db = loss_fn.grad(X, error)         │
│       ∂L/∂w = (1/n) Xᵀ · ∂L/∂ŷ                          │
│                                                         │
│  4. BACKWARD      model.backward(dw, db)                │
│       w ← w – η · ∂L/∂w                                 │
└─────────────────────────────────────────────────────────┘

There is no .fit(). There is no hidden state. The user controls every step.

Why is Statelessness a Core Design Principle?

TrueML models are stateless with respect to data. They hold parameters (weights, bias) but never cache a training example. This means:

No accidental leakage: a model cannot remember a previous batch.
Explicit dataflow: you always know what data produced what gradient.
Composability: any step can be replaced, inspected, or debugged in isolation.

If you want to log gradients before the update, you print them. If you want to try a custom update rule, you write it yourself. The library does not abstract away what you need to see.

Who is This Library Built For?

Researchers who want to read every line of their training loop.
Students learning how gradients actually flow through a linear model.
Practitioners who need a minimal, auditable baseline before layering complexity.

Gen-CLI

2026-05-08T00:00:00+00:00

Gen-CLI is a Python-based command-line tool for generating boilerplate code and framework templates for multiple programming languages.

What are the key features of Gen-CLI?

Single-file boilerplate generation for multiple languages
Project scaffolding using framework templates
Colorful directory tree visualization
Environment diagnostics with gen doctor
Dry-run mode for previewing outputs
Overwrite support for existing files/directories

How do I install Gen-CLI?

How to install using PyPI pip?

pip install gen-cli

How to install from source?

git clone https://github.com/iamprasadraju/gen-cli.git
cd gen-cli

# Install for usage
pip install -e .

# Install for development (includes tests, linting tools)
pip install -e .[dev]

How to install using uv?

uv sync

How can I verify my installation?

gen --version

How do I quickly start using Gen-CLI?

# Generate a C boilerplate file
gen c

# Generate a Python boilerplate file
gen py

# Generate a Flask project
gen flask

# List available languages and frameworks
gen list

# Show directory tree
gen tree

# Check your environment
gen doctor

What commands are available?

How to check the version (`gen --version`)?

Show the installed version of gen-cli.

gen --version
gen -v

Output: gen-cli version 1.0.0

How to get help (`gen --help`)?

Show the help message with all available commands and options.

gen --help
gen -h

How to list available templates (`gen list`)?

List all available language templates and framework templates.

gen list

Output:

Available Languages
-------------------
  • .py
  • .c
  • .cpp
  • .go
  • .js
  • .rs
  • .html
  • .java

Available Frameworks
--------------------
  • flask
  • codeforces

How to diagnose my environment (`gen doctor`)?

Check your environment and configuration for potential issues.

gen doctor

Output:

Gen CLI Doctor
----------------------------------------
✓ Python Version: 3.13.12
✓ Platform: Darwin 24.0.0
✓ Working Directory: /Users/user/project
✓ PATH directories: 17 found

All checks passed

How to visualize my directory (`gen tree`)?

Display a colorful tree view of your directory structure.

gen tree                    # current directory, depth 2, no hidden
gen tree -a                 # include hidden files/dirs
gen tree -3                 # depth of 3 levels
gen tree -3 src             # depth 3 of specific directory
gen tree -2 -a .            # depth 2, include hidden, current dir

Tree options:

Flag	Description
`-N`	Set depth (e.g., `-2`, `-3`)
`-a`, `--all`	Include hidden files/dirs

Colors:

Bold blue — directories
Green — regular files
Dim/gray — hidden files and connectors

How do I generate language boilerplate?

Generate a boilerplate file for a specific language.

gen c           # creates main.c
gen py          # creates main.py
gen js          # creates main.js
gen go          # creates main.go
gen rs          # creates main.rs
gen cpp         # creates main.cpp
gen java        # creates main.java
gen html        # creates main.html

Options:

Flag	Description
`--dryrun`	Preview the file content without creating it
`--overwrite`	Overwrite existing file

Examples:

gen c --dryrun              # preview main.c content
gen py --overwrite          # overwrite main.py if exists
gen js --dryrun --overwrite # dry run (overwrite ignored)

When file already exists:

gen c
main.c already exists
Use --overwrite to replace: gen c --overwrite

How do I generate framework projects?

Generate a full project from a framework template.

gen flask                   # prompts for project name
gen flask myapp             # creates myapp/ directly
gen codeforces              # prompts for project name
gen codeforces solutions    # creates solutions/ directly

Options:

Flag	Description
`--dryrun`	Preview project structure without creating
`--overwrite`	Remove existing directory and regenerate

Examples:

gen flask --dryrun          # preview flask project tree
gen flask myapp --dryrun    # preview tree for 'myapp'
gen flask myapp --overwrite # overwrite myapp/ if exists

When directory already exists:

gen flask myapp
Directory 'myapp' already exists
Use --overwrite to replace: gen flask myapp --overwrite

Which programming languages are supported?

Command	Output File
`gen c`	`main.c`
`gen py`	`main.py`
`gen js`	`main.js`
`gen go`	`main.go`
`gen rs`	`main.rs`
`gen cpp`	`main.cpp`
`gen java`	`main.java`
`gen html`	`main.html`

Which frameworks are supported?

Command	Description
`gen flask`	Flask web application
`gen codeforces`	Codeforces competitive programming setup

How are errors handled?

Gen-CLI provides clear error messages for common issues:

# Unknown command
gen xyz
→ Unknown command: xyz
  Usage: gen [list|doctor|tree|<lang>|<framework>] [-v|--version] [-h|--help]

# Unknown flag
gen c --invalid
→ Unknown flag: --invalid
  Usage: gen [list|doctor|<lang>|<framework>] [-v|--version] [-h|--help]

# Invalid tree depth format
gen tree 3
→ Invalid depth format: '3'
  Use '-' prefix for depth, e.g., 'gen tree -3' or 'gen tree -3 src'

# Path not found
gen tree nonexistent
→ Path not found: nonexistent

How do I set up for development?

How to configure the setup?

uv sync --all-extras

How to run tests?

# Run all tests
uv run pytest tests -v

# Run specific test file
uv run pytest tests/test_cli.py -v

How to run the CLI from source?

uv run gen <command>

What does the project structure look like?

gen-cli/
├── src/
│   └── gen/
│       ├── __init__.py
│       ├── cli.py              # Main CLI entry point
│       ├── paths.py            # Template path resolution
│       ├── commands/
│       │   ├── __init__.py
│       │   ├── doctor.py       # Environment diagnostics
│       │   ├── helper.py       # Help messages
│       │   ├── list_.py        # Template listing & tree view
│       │   └── template.py     # Template generation helpers
│       ├── core/
│       │   ├── __init__.py
│       │   └── render.py       # Jinja2 template rendering
│       └── templates/          # Built-in templates
│           ├── lang/           # Language boilerplate files
│           └── frameworks/     # Framework project templates
├── tests/
│   └── test_*.py               # Unit tests
├── pyproject.toml
└── README.md

What is the license?

MIT License

Who is the author?

Prasad Raju G

Book - Mathematics for Machine learning

2026-05-02T00:00:00+00:00

What is the Mathematics for Machine Learning Book About?

Book url

stateDiagram-v2
    direction LR
    Data --> Model
    Model --> Learning

Machine learning is about designing algorithms that automatically extract valuable information from data.

The goal is to find good models that generalize well to yet unseen data.

How Are Vectors Used in Machine Learning?

Any data represented as vectors.

Three ways to think about vectors:

a vector as an array of numbers (a computer science view)
a vector as an arrow with a direction and magnitude (a physics view)
a vector as an object that obeys addition and scaling (a mathematical view)

How Do Machine Learning Models Learn From Data?

Learning component of machine learning - Training the model means to use the data available to optimize (gradient descent) some parameters of the model with respect to a utility function (loss function) that evaluates how well the model predicts the training data.

$^{*}\text{Note:}$ Performing well on data that we have already seen (training data) may only mean that we found a good way to memorize the data.

What Are the Core Mathematical Pillars of Machine Learning?

Linear algebra - The study of vectors and matrices is called linear algebra. Numerical data as vectors and represent a table of such data as a matrix.

Vectors and matrices represent datasets, features, and model parameters in ML algorithms like neural networks. Key operations include matrix multiplication, inversion, eigenvalues/eigenvectors (used in PCA for dimensionality reduction), and projections (essential for SVM).

Calculus - Gradients and partial derivatives enable optimization techniques like gradient descent to minimize loss functions. Concepts like chain rule and Jacobian matrices support backpropagation in deep learning.

Probability and Statistics - These handle uncertainty, data distributions, and inference. Core ideas include probability distributions, Bayes’ theorem, maximum likelihood estimation (MLE), hypothesis testing, bias-variance tradeoff, and metrics like mean squared error.

Optimization - Techniques such as gradient descent variants (e.g., stochastic, Adam) rely on calculus to iteratively update model weights. Convex optimization ensures reliable convergence in many ML problems.

Stats 110

2026-04-17T00:00:00+00:00

What is Statistics and How does it Differ from Mathematics?

My Notes for stats110 course

Mathematics is logic of certainty
Statistics is the logic of uncertainty

Tic Tac Toe

2026-04-16T00:00:00+00:00

Endless Tic-Tac-Toe

A graphical Tic-Tac-Toe game built with Python and Pygame, featuring a pixel-art aesthetic and a classic two-player experience.

What are its features?

Human vs Human — Two players take turns on the same machine (hot-seat).
Human vs AI — (Work in progress, not yet playable.)
3×3 Grid — Turn-based play with alternating X and O.
Win & Draw Detection — Automatically detects all 8 winning lines and board fills.
Confetti Celebration — Particle effects when a player wins.
Pixel-Art Styling — Custom pixel fonts for a retro look.
Play Again — Quick restart from the result screen.

How do you get started?

What are the prerequisites?

Python 3.13 or higher

How do you install it?

pip install -r requirements.txt

Or with uv:

uv sync

How do you run the game?

python game.py

How do you play?

Left-click a cell to place your mark (X or O).
Click “Play Again!” after a win or draw to start a new game.

How is the project structured?

├── game.py          — Entry point and main game loop
├── board.py         — Game board, grid rendering, move logic, win/draw detection
├── effects.py       — Confetti particle system for win celebrations
├── assets/          — Fonts and images
│   ├── PixeloidSans.ttf
│   ├── PixeloidSans-Bold.ttf
│   └── tic-tac-toe.png
├── requirements.txt — Runtime dependency (pygame)
└── pyproject.toml   — Project metadata and Python version

What technologies were used?

Python 3.13+
Pygame — Game framework
Ruff — Linting
uv — Package management

What are the current limitations?

Human vs AI mode is a stub and not yet functional. Selecting it will cause a runtime error. Only Human vs Human is fully implemented.

What is the future roadmap?

Implement AI opponent (random move / minimax)
Add menu improvements and game state polish
Online multiplayer (future stretch goal)

Git Guide

2026-04-16T00:00:00+00:00

What is the Best Git Branch Naming Convention?
How Do You Write an Effective Git Commit Message?

What is the Best Git Branch Naming Convention?

git branch <category/reference/description-in-kebab-case>

A git branch should start with a category. Pick one of these: feature, bugfix, hotfix, or test.

feature is for adding, refactoring or removing a feature
bugfix is for fixing a bug
hotfix is for changing code with a temporary solution and/or without following the usual process (usually because of an emergency).
test is for experimenting outside of an issue/ticket
doc is for adding, changing or removing documentation

How to Include Issue References?

After the category, there should be a “/” followed by the reference of the issue/ticket/task you are working on. If there’s no reference, just add no-ref. With task it is meant as benchmarking task e.g. batch_integration.

How to Write a Branch Description?

After the reference, there should be another “/” followed by a description which sums up the purpose of this specific branch. This description should be short and “kebab-cased”.

By default, you can use the title of the issue/ticket you are working on. Just replace any special character by “-”.

What are Some Examples of Git Branch Names?

You need to add, refactor or remove a feature: git branch feature/issue-42/create-new-button-component
You need to fix a bug: git branch bugfix/issue-342/button-overlap-form-on-mobile
You need to fix a bug really fast (possibly with a temporary solution): git branch hotfix/no-ref/registration-form-not-working
You need to experiment outside of an issue/ticket: git branch test/no-ref/refactor-components-with-atomic-design

*Reference

How Do You Write an Effective Git Commit Message?

Type	Use Case
`feat`	Adding a new feature for the user.
`fix`	Fixing a bug.
`docs`	Documentation-only changes.
`style`	Formatting, missing semi-colons; no code logic change.
`refactor`	Code changes that neither fix a bug nor add a feature.
`perf`	Changes that improve performance.
`test`	Adding or correcting tests.
`chore`	Routine tasks like updating dependencies or build tools.

Why Are Git Commit Messages So Important?

When you are applying for jobs, employers will look through your projects on GitHub and they will look through your commit history. Having good commits as a novice developer will help you stand out.
Having a good commit message history will allow you (or other developers working on your code) to quickly see what changes were made and why. This is useful if a bug is found in the code that needs to be fixed!
Having a good commit message history will also be helpful if you come back to a project you were working on after stepping away from it for a while. You likely won’t remember your thought process and changes made when initially writing out the code.

What is the Difference Between Bad and Good Commits?

When it comes to writing commits, it is crucial to know how to write them effectively. Here’s an example of a bad commit message:

fix a bug

Even though it describes what you did, the message is too vague, which leaves the other developers on your team confused. A good commit message will explain the why behind your changes. In other words, a commit message describes what problem your changes solve and how it solves them.

Effective commits consist of two separate parts: a subject, and a body:

Subject

A brief summary of the change you made to the project.

This is the change I made to the codebase

Note: Commit subject character limit GitHub has a 72-character limit, so we recommend keeping your commits’ subjects within this amount.

What Should Be in the Commit Message Body?

A concise yet clear description of what you did.

Describe the problem your commit solves and how.

Now that we learned the secret to creating a good commit message, let’s try and fix the commit message from earlier:

Add missing link and alt text to the company's logo

Screen readers won't read the images to users with disabilities without this information.

Ahh, that’s better! :) Now, developers can gain a better understanding of this commit message because it does the following:

Provides a subject that specifies your code’s action (e.g., “Add missing link and alt text to the company’s logo”).
Contains a body that provides a concise yet clear description of why the commit needed to be made (e.g., “Screen readers won’t read the images to users with disabilities without this information.”).
Separates the subject from the body with a new/blank line. This is a best practice we highly recommend following. It makes commit messages easier for other developers to read.

Some teams of developers might have their own convention for commit messages in specific formats. However, they still follow the same principles as this lesson outlined.

How Do You Commit with a Subject and Body?

Up until now, you’ve been told to commit with git commit -m <message>. To make a commit with subject and body in message, the simplest way is to type git commit without the -m flag and message argument.

When Should You Make a Git Commit?

A good way to view a commit is like a “snapshot” of your code at the moment that it was made. That version of your code up to that point will be saved for you to revert back to or look back at.

When writing code, it’s considered best practice to commit every time you have a meaningful change in the code. This will create a timeline of your progress and show that your finished code didn’t appear out of nowhere.

In other words, make a commit if you get a piece of code you are working on to function like you want it to, fix a typo, or fix a bug. As you gain experience, you will develop a better feel for what should be committed!

There will come a time when you are working on a project and you FINALLY get something just right (this would be a good time to commit), and then maybe 30 seconds to a few days later it breaks. You have no idea what you changed, everything looks to be the same and you don’t remember editing that line, but alas, it isn’t working how you want it anymore. You’d be able to go back through your commit history and either revert your code back to the last commit you made when you first got that part working or go back and see what your code looked like at that point in time.

*Reference

Learning Stats

2026-04-14T00:00:00+00:00

A collection of courses and resources that I find interesting while learning statistics.

What are the best courses for learning statistics?

1. Statistics 110: Probability - Youtube Link

Taught by Joseph Blitzstein

Stat 110 is an introduction to probability as a language and set of tools for understanding statistics, science, risk, and randomness. The ideas and methods are useful in statistics, science, engineering, economics, finance, and everyday life. Topics include the following. Basics: sample spaces and events, conditioning, Bayes’ Theorem. Random variables and their distributions: distributions, moment generating functions, expectation, variance, covariance, correlation, conditional expectation. Univariate distributions: Normal, t, Binomial, Negative Binomial, Poisson, Beta, Gamma. Multivariate distributions: joint, conditional, and marginal distributions, independence, transformations, Multinomial, Multivariate Normal. Limit theorems: law of large numbers, central limit theorem. Markov chains: transition probabilities, stationary distributions, reversibility, convergence. The prerequisites are calculus (mainly single variable) and familiarity with matrices.

2. MIT 18.650 Statistics for Applications, Fall 2016 - Youtube Link

Taught by Philippe Rigollet

This course offers an in-depth exploration of the theoretical foundations for statistical methods that are useful in many applications. The goal is to understand the role of mathematics in the research and development of efficient statistical methods.

Which books are recommended for statistical learning?

1. An Introduction To Statistical Learning With Applications In Python

Read Book

Mac Setup

2026-04-11T00:00:00+00:00

Step-by-step instructions to setup new Mac

Which CLI tools are essential for a new Mac?

Xcode Command Line Tools xcode-select –-install it comes with clang, gcc, clang++, g++, git and more …

List of Xcode Command Line Tools

   ls /Library/Developer/CommandLineTools/usr/bin/

Homebrew is a free and open-source software package management system that simplifies the installation of software on Apple’s operating system, macOS, as well as Linux. official Homebrew site
Git Already comes with Xcode CLT
Gen CLI (My own CLI tool)pip install gen-cli
opencode is an open source agent that helps you write code in your terminal, IDE, or desktop.
tmux (short for Terminal Multiplexer) is a command-line tool that lets you manage multiple terminal sessions within a single window. brew install tmux

What software and applications should I install?

Zen Browser is a free, open-source web browser based on Mozilla Firefox. It combines Firefox’s privacy and plugin ecosystem with the sleek, modern, vertical-tab interface popularized by the Arc browser.
OBS Free and open source software for video recording and live streaming.
Zed is a Rust based code editor.
Windsurf is a free and open-source code editor. (for unlimited inline autocomplete)
Discord is a free voice and text communication application and digital distribution platform.
Spotify is a popular digital audio streaming service for music listening.
Obsidian stores notes privately on your device as markdown files.
Battery Toolkit Control the platform power state of your Apple Silicon Mac. Battery Toolkit allows specifying a hard limit past which battery charging will be turned off.
MacDroid the ultimate solution for transferring files between Android and Mac.
Rectangle Move and resize windows in macOS using keyboard shortcuts or snap areas.
Mos is a free, open-source macOS utility that makes wheel scrolling feel closer to a trackpad, without getting in your way.
BetterDisplay is a macOS utility that allows you to customize your display settings. (external display)
Stas is a free, open-source macOS system monitor that lives in your menu bar - track CPU, GPU, RAM, disk, network, sensors, battery and more on Apple Silicon and Intel Macs.
Lidless tiny macOS menu-bar app that keeps your Mac running even with the lid closed — so coding agents (Claude Code, Codex, etc.) keep working while you move around.

How do I install core programming languages?

Python brew install python
Ruby brew install ruby
C Already comes With Xcode CLT i.e gcc and clang
C++ Already comes With Xcode CLT i.e g++ and clang++

or (3, 4)

llvm brew install llvm clang and clang++ compiler (Recommended)

Which Python libraries are required for machine learning and data science?

Numpy the fundamental package for scientific computing with Python.pip install numpy
Pandas is a fast, powerful, flexible and easy to use open source data analysis and manipulation tool, built on top of the Python programming language. pip install pandas
Scikit-learn is an open source machine learning library that supports supervised and unsupervised learning. It also provides various tools for model fitting, data preprocessing, model selection, model evaluation, and many other utilities. pip install scikit-learn
Seaborn is a Python data visualization library based on matplotlib. It provides a high-level interface for drawing attractive and informative statistical graphics. pip install seaborn
Matplotlib is a comprehensive library for creating static, animated, and interactive visualizations in Python. pip install matplotlib
Pytorch is an open-source optimized tensor library for deep learning using GPUs and CPUs Deep learning library pip install torch
Tensorflow is an open-source, end-to-end machine learning platform developed by Google, specializing in deep neural networks, numerical computation, and large-scale machine learning. pip install tensorflow
Scipy is a collection of mathematical algorithms and convenience functions built on NumPy . It adds significant power to Python. pip install scipy
Jupyter Notebook is the latest web-based interactive development environment for notebooks, code, and data. Its flexible interface allows users to configure and arrange workflows in data science, scientific computing, computational journalism, and machine learning. A modular design invites extensions to expand and enrich functionality. pip install notebook
OpenCV is a library of programming functions mainly for real-time computer vision pip install opencv-python

requirements.txt

In-built Datastructures in Python, C++, C

2026-03-08T00:00:00+00:00

A quick reference for common data structure operations. Use this as your go-to guide.

What is in this Guide?

Python

C++ (STL)

C Language

What are the In-Built Data Structures in Python?

How do you use a List [] in Python?

Definition: Ordered, mutable sequence that allows duplicate elements. Elements are indexed starting from 0. Supports dynamic resizing.

Operation	Time	Space
Access by index	O(1)	-
Append	O(1)*	-
Insert at index	O(n)	O(1)
Remove at index	O(n)	-
Remove by value	O(n)	-
Search	O(n)	-
Sort	O(n log n)	O(n)

*Amortized

# Creation
lst = [1, 2, 3]
lst = list(range(5))
lst = [0] * 5           # [0, 0, 0, 0, 0]

# Add
lst.append(x)           # O(1) - add to end
lst.insert(i, x)        # O(n) - insert at index
lst.extend(iterable)    # O(k) - add multiple

# Remove
lst.pop()              # O(1) - remove last
lst.pop(i)              # O(n) - remove at index
lst.remove(x)           # O(n) - remove first occurrence
lst.clear()             # O(n)

# Access
lst[i]                 # O(1)
lst[-1]                # last element

# Search
lst.index(x)           # O(n) - first index
lst.count(x)           # O(n) - count
x in lst               # O(n) - membership

# Sort/Reverse
lst.sort()             # O(n log n)
sorted(lst)            # O(n log n)
lst.reverse()          # O(n)
lst[::-1]              # O(n) - reversed copy

# Stack using list
stack = []
stack.append(1)    # push - O(1)
stack.pop()        # pop - O(1)
stack[-1]          # peek - O(1)

Interview Questions:

Q: When would you use list instead of array?
A: Use list when you need dynamic sizing, mixed types, or built-in methods. Use array module when you need memory efficiency for large numeric data of the same type.

Q: What is the time complexity of append() vs insert()?
A: append() is O(1) amortized - adds to end. insert() is O(n) - requires shifting all elements.

Q: How does list handle dynamic resizing?
A: Python list uses over-allocation. When full, allocates ~12.5% more space. This amortizes resize cost to O(1) for append.

Q: Difference between remove() and pop()?
A: remove() removes first occurrence of value (O(n)), raises ValueError if not found. pop() removes and returns element at index.

Q: How would you implement a stack using list?
A: Use append() for push, pop() for pop. Top of stack is last element.

When should you use a Tuple ()?

Definition: Ordered, immutable sequence. Once created, cannot be modified. Used for fixed collections.

Operation	Time	Space
Access by index	O(1)	-
Search	O(n)	-
Length	O(1)	-

# Creation
t = (1, 2, 3)
t = 1, 2, 3           # parentheses optional
t = (1,)              # single element needs comma
t = tuple([1, 2, 3])

# Access - same as list
t[0], t[-1], t[1:3]

# Unpack
a, b, c = t
first, *rest = t      # rest is [2, 3]

# Operations
len(t), t.index(x), t.count(x)

# Tuple as dict key
d = {(1, 2): "point"}

# Multiple return values
def func():
    return 1, 2
a, b = func()

Interview Questions:

Q: Why is tuple immutable? What are the benefits?
A: Immutability provides hashability (can be dict keys), memory efficiency, and thread safety.

Q: Can tuple contain mutable objects? What happens?
A: Yes, tuple can contain mutable objects like lists. The tuple itself can’t change, but contents can.

Q: Difference between tuple and list?
A: Tuple is immutable (faster, less memory, hashable), used for fixed data. List is mutable.

Q: How does tuple hash work?
A: Only works if all elements are hashable. Hash is computed from contents.

Q: Use cases where tuple is preferred over list?
A: Function return values, dictionary keys, fixed records (coordinates).

How does a Set {} work?

Definition: Unordered collection of unique elements. No duplicates. Provides O(1) average-case lookup.

Operation	Time (Avg)	Time (Worst)	Space
Add	O(1)	O(n)	-
Remove	O(1)	O(n)	-
Search/Membership	O(1)	O(n)	-
Union	O(n+m)	-	O(n+m)
Intersection	O(min(n,m))	O(n*m)	-

# Creation
s = {1, 2, 3}
s = set([1, 2, 3])
s = set()             # empty set (not {})

# Add/Remove
s.add(x)             # O(1)
s.remove(x)           # O(1) - raises KeyError if not found
s.discard(x)          # O(1) - no error if not found
s.pop()               # O(1) - remove random element

# Set operations
A | B                 # union - O(n+m)
A & B                 # intersection - O(min(n,m))
A - B                 # difference - O(n)
A ^ B                 # symmetric difference - O(n+m)

# Common elements
list1 = [1, 2, 3, 4]
list2 = [3, 4, 5, 6]
common = list(set(list1) & set(list2))

# Remove duplicates, preserve order
lst = [1, 2, 2, 3, 1, 4]
unique = list(dict.fromkeys(lst))

Interview Questions:

Q: How is set implemented internally in Python?
A: Python set uses a hash table. Elements are hashed, collisions handled using open addressing.

Q: What is the difference between set and frozenset?
A: set is mutable, frozenset is immutable and hashable.

Q: How to find common elements between two lists?
A: Convert both to sets and use intersection.

Q: Why set doesn’t support indexing?
A: Sets are hash tables - order is determined by hash values.

Q: How would you remove duplicates from a list while preserving order?
A: Use dict.fromkeys() or loop through with seen set.

How to manage key-value pairs with a Dictionary {}?

Definition: Collection of key-value pairs where each key is unique. Provides O(1) average-case lookup.

Operation	Time (Avg)	Time (Worst)	Space
Access by key	O(1)	O(n)	-
Insert	O(1)	O(n)	-
Delete	O(1)	O(n)	-
Search	O(1)	O(n)	-
Get	O(1)	O(n)	-

# Creation
d = {'a': 1, 'b': 2}
d = dict(a=1, b=2)
d = dict(zip(keys, values))

# Access
d['key']              # O(1) - raises KeyError if missing
d.get('key')          # O(1) - returns None
d.get('key', default) # O(1) - returns default

# Add/Update
d['key'] = value     # O(1)
d.update({'k1': v1, 'k2': v2})  # O(k)

# Remove
del d['key']          # O(1)
value = d.pop('key') # O(1)
d.popitem()           # O(1) - removes last item

# defaultdict
from collections import defaultdict
dd = defaultdict(list)
dd['key'].append(1)

# Merge (Python 3.9+)
d3 = d1 | d2

Interview Questions:

Q: How is dictionary implemented in Python?
A: Python dict uses a hash table with open addressing. Uses hash to compute index, handles collisions via probing.

Q: What is hash collision and how does Python handle it?
A: When two keys hash to same index. Python uses open addressing - probes for next empty slot.

Q: Difference between get() and []?
A: get() returns None/default if key not found. [] raises KeyError.

Q: How does dictionary maintain insertion order (Python 3.7+)?
A: Python 3.7+ maintains insertion order using compact array.

Q: What is the difference between dict and collections.defaultdict?
A: Regular dict raises KeyError for missing keys. defaultdict provides default values.

Q: How would you merge two dictionaries in Python?
A: Use | operator (Python 3.9+), update(), or {**d1, **d2}.

When to use the Array module?

Definition: Homogeneous array of numeric values stored more efficiently than lists.

Operation	Time	Space
Access by index	O(1)	-
Append	O(1)*	-
Insert	O(n)	-
Delete	O(n)	-

*Amortized

from array import array

# Type codes: 'b','B','h','H','i','I','f','d'
arr = array('i', [1, 2, 3])
arr.append(4)    # O(1)
arr[0]           # O(1)

What advanced structures does the Collections Module offer?

deque: Double-ended queue - O(1) add/remove at both ends

Operation	Time
appendleft	O(1)
appendright	O(1)
popleft	O(1)
popright	O(1)
rotate	O(k)

from collections import deque
dq = deque([1, 2, 3])
dq.appendleft(0)      # O(1)
dq.appendright(4)    # O(1)
dq.popleft()         # O(1)
dq.rotate(n)          # O(k)

Counter: Count hashable items

Operation	Time
Access	O(1)
Most common	O(n log k)

from collections import Counter
c = Counter(['a', 'b', 'a', 'c', 'a'])
c['a']                # O(1) - 3
c.most_common(2)     # O(n log k)

namedtuple: Tuple with named fields

from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(1, 2)
p.x, p.y             # O(1)

defaultdict: Dict with default values - same complexity as dict

from collections import defaultdict
dd = defaultdict(int)
dd['key'].append(1)  # O(1)

What does the C++ (STL) provide?

How do you use a Vector `<vector>`?

Definition: Dynamic array that can resize automatically. Provides random access.

Operation	Time	Space
Access by index	O(1)	-
push_back	O(1)*	-
pop_back	O(1)	-
insert at position	O(n)	-
erase at position	O(n)	-
Search	O(n)	-
Sort	O(n log n)	O(n)

*Amortized

#include <vector>
using namespace std;

vector<int> v;
vector<int> v = {1, 2, 3};
vector<int> v(5);
vector<int> v(5, 10);

v[i], v.at(i)           // O(1)
v.front(), v.back()     // O(1)
v.push_back(x);         // O(1)*
v.pop_back();           // O(1)
v.insert(it, x);        // O(n)
v.erase(it);            // O(n)
v.size(), v.empty()     // O(1)
v.capacity()           // O(1)
v.reserve(n);          // O(n)

Interview Questions:

Q: What is amortized O(1) for push_back?
A: Most push_back calls are O(1), but occasionally reallocates and copies all elements. This rare cost is amortized.

Q: Difference between vector and array?
A: Array has fixed size at compile time. Vector has dynamic size.

Q: When should you use reserve()?
A: When you know approximate size beforehand. Prevents multiple reallocations.

Q: Capacity vs size?
A: size = elements. capacity = memory allocated. size <= capacity.

How does a Deque `<deque>` operate?

Definition: Double-ended queue allowing O(1) insertion/deletion at both front and back.

Operation	Time
push_front	O(1)
push_back	O(1)
pop_front	O(1)
pop_back	O(1)
Access	O(1)
Insert at position	O(n)

#include <deque>
using namespace std;

deque<int> dq = {1, 2, 3};
dq.push_front(0);      // O(1)
dq.push_back(4);       // O(1)
dq.pop_front();        // O(1)
dq.pop_back();         // O(1)
dq[0], dq.at(0)       // O(1)

Interview Questions:

Q: How is deque different from vector?
A: Deque allows O(1) at both ends. Vector only at back.

Q: Internal structure?
A: Uses multiple fixed-size arrays (chunks) mapped together.

When is a List `<list>` useful in C++?

Definition: Doubly linked list with O(1) insertion/deletion anywhere. No random access.

Operation	Time
push_front	O(1)
push_back	O(1)
pop_front	O(1)
pop_back	O(1)
insert at iterator	O(1)
erase at iterator	O(1)
Access by index	O(n)
Search	O(n)

#include <list>
using namespace std;

list<int> lst = {1, 2, 3};
lst.push_front(0);           // O(1)
lst.push_back(4);            // O(1)
lst.insert(++lst.begin(), 5); // O(1) with iterator
lst.remove(2);               // O(n)
lst.reverse();              // O(n)
lst.sort();                 // O(n log n)

Interview Questions:

Q: When to use list over vector?
A: When frequent insertion/deletion in middle, or at front.

Q: Time complexity of inserting in middle?
A: O(1) if you have iterator. O(n) to find position.

How to use a fixed-size Array `<array>`?

Definition: Fixed-size container wrapping C-style array.

Operation	Time
Access	O(1)
fill	O(n)

#include <array>
using namespace std;

array<int, 5> arr = {1, 2, 3, 4, 5};
arr[0], arr.at(0)      // O(1)
arr.fill(0);          // O(n)
arr.size()            // O(1) - compile time

How do you implement a Stack `<stack>`?

Definition: LIFO adapter with push, pop, top operations.

Operation	Time
push	O(1)
pop	O(1)
top	O(1)
empty	O(1)
size	O(1)

#include <stack>
using namespace std;

stack<int> st;
st.push(x);         // O(1)
st.top();          // O(1)
st.pop();          // O(1)
st.empty();        // O(1)
st.size();         // O(1)

Interview Questions:

Q: Basic operations of stack?
A: push, pop, top, empty, size - all O(1).

Q: Applications of stack?
A: DFS, expression evaluation, parenthesis matching, undo/redo.

How to manage FIFO with a Queue `<queue>`?

Definition: FIFO adapter with enqueue at back, dequeue at front.

Operation	Time
push	O(1)
pop	O(1)
front	O(1)
back	O(1)
empty	O(1)
size	O(1)

#include <queue>
using namespace std;

queue<int> q;
q.push(x);          // O(1)
q.front();         // O(1)
q.back();          // O(1)
q.pop();           // O(1)
q.empty();         // O(1)
q.size();          // O(1)

Interview Questions:

Q: Applications of queue?
A: BFS, task scheduling, print job queue.

When to use a Priority Queue `<queue>`?

Definition: Heap-based, max/min element at top.

Operation	Time
push	O(log n)
pop	O(log n)
top	O(1)
empty	O(1)
size	O(1)

#include <queue>
using namespace std;

priority_queue<int> pq;
priority_queue<int, vector<int>, greater<int>> pq;

pq.push(x);        // O(log n)
pq.top();         // O(1)
pq.pop();         // O(log n)

Interview Questions:

Q: Time complexity of push and pop?
A: Both O(log n).

Q: Applications?
A: Dijkstra’s, Huffman coding, top-k elements.

How does a Set `<set>` maintain order?

Definition: Sorted unique elements. Implemented as a Red-Black tree.

Operation	Time
insert	O(log n)
erase	O(log n)
find	O(log n)
count	O(log n)
lower_bound	O(log n)
upper_bound	O(log n)

#include <set>
using namespace std;

set<int> s = {3, 1, 4, 1, 5, 9};
s.insert(x);                    // O(log n)
s.erase(x);                     // O(log n)
s.find(x) != s.end()           // O(log n)
s.count(x)                      // O(log n)
s.lower_bound(x)              // O(log n)
s.upper_bound(x)              // O(log n)

Interview Questions:

Q: Time complexity?
A: All operations O(log n) due to tree structure.

What is a Multiset `<multiset>`?

Definition: Sorted container allowing duplicate elements.

Operation	Time
insert	O(log n)
erase	O(log n)*
find	O(log n)
count	O(log n + k)

*Each occurrence

#include <set>
using namespace std;

multiset<int> ms = {1, 2, 2, 3};
ms.insert(2);       // O(log n)
ms.count(2);      // O(log n + k)

How does a Map `<map>` handle key-value pairs?

Definition: Sorted key-value pairs. Implemented as a Red-Black tree.

Operation	Time
insert	O(log n)
erase	O(log n)
find	O(log n)
access by key	O(log n)
operator[]	O(log n)
at()	O(log n)

#include <map>
using namespace std;

map<string, int> m;
m["key"] = value;              // O(log n)
m.at("key");                   // O(log n)
m.insert({"key", value});     // O(log n)
m.find("key") != m.end()      // O(log n)
m.erase("key");                // O(log n)
for(auto [k, v] : m) {}       // O(n)

Interview Questions:

Q: vs unordered_map?
A: map is O(log n) sorted. unordered_map is O(1) average.

When is a Multimap `<multimap>` useful?

Definition: Sorted key-value pairs allowing duplicate keys.

Operation	Time
insert	O(log n)
erase	O(log n)
find	O(log n)
equal_range	O(log n + k)

#include <map>
using namespace std;

multimap<string, int> mm;
mm.insert({"fruit", 1});       // O(log n)
mm.insert({"fruit", 2});      // O(log n)
mm.equal_range("fruit");     // O(log n + k)

How does an Unordered Set `<unordered_set>` improve lookup?

Definition: Hash-based set. Provides O(1) average lookup.

Operation	Time (Avg)	Time (Worst)
insert	O(1)	O(n)
erase	O(1)	O(n)
find	O(1)	O(n)
count	O(1)	O(n)

#include <unordered_set>
using namespace std;

unordered_set<int> us = {3, 1, 4, 5};
us.insert(x);                  // O(1) avg
us.find(x) != us.end()       // O(1) avg
us.erase(x);                  // O(1) avg

Interview Questions:

Q: Load factor?
A: Ratio of elements to buckets. Lower = less collisions, more memory.

How fast is an Unordered Map `<unordered_map>`?

Definition: Hash-based map. Provides O(1) average lookup.

Operation	Time (Avg)	Time (Worst)
insert	O(1)	O(n)
erase	O(1)	O(n)
find	O(1)	O(n)
access	O(1)	O(n)

#include <unordered_map>
using namespace std;

unordered_map<string, int> um;
um["key"] = value;            // O(1) avg
um.at("key");                 // O(1) avg
um.find("key") != um.end()  // O(1) avg

Interview Questions:

Q: Hash collisions?
A: Uses chaining or probing. Falls back to rehashing.

How do you use Pair & Tuple in C++?

Operation	Time
Access	O(1)
Make	O(1)

#include <utility>
#include <tuple>

pair<int, string> p = {1, "hello"};
p.first, p.second              // O(1)

tuple<int, string, double> t = {1, "hi", 2.5};
get<0>(t)                     // O(1)
tie(a, b, c) = t;            // O(k)

How do you manipulate a String `<string>` in C++?

Operation	Time
Access	O(1)
Concatenate	O(n+m)
Substring	O(m)
Find	O(n*m)
Replace	O(n+m)
Size/Length	O(1)

#include <string>
using namespace std;

string s = "hello";
s += " world";               // O(m) amortized
s.size(), s.length()        // O(1)
s.find("lo")               // O(n*m)
s.substr(2, 3)            // O(m)
s.replace(0, 5, "bye")     // O(n+m)

What Data Structures exist in C Language?

How do C Arrays work?

Definition: Contiguous memory block with elements of same type. Fixed size.

Operation	Time	Notes
Access by index	O(1)	Formula: base + index * size
Search	O(n)	Linear
Sort	O(n log n)	Requires algorithm

int arr[5];
int arr[5] = {1, 2, 3, 4, 5};
int arr[] = {1, 2, 3};

arr[0] = 10;          // O(1)
int x = arr[4];       // O(1)

int matrix[2][3] = { {1,2,3}, {4,5,6} };

void func(int *arr, int size) {}
#define ARRAY_SIZE(arr) (sizeof(arr)/sizeof(arr[0]))

Interview Questions:

Q: Contiguous memory enables?
A: O(1) random access, good cache locality.

Q: Array decay?
A: Array decays to pointer when passed, loses size info.

How are Strings implemented in C?

Definition: Null-terminated character array.

Operation	Time
Access char	O(1)
strlen	O(n)
strcpy	O(n)
strcat	O(n+m)
strcmp	O(n)
strchr	O(n)
strstr	O(n*m)

#include <string.h>

char s[] = "hello";
char *s = "hello";

strlen(s)                  // O(n)
strcpy(dest, src)         // O(n)
strcat(dest, src)         // O(n+m)
strcmp(s1, s2)            // O(n)
strncpy(dest, src, n)     // O(n)

Interview Questions:

Q: Buffer overflow?
A: Writing beyond array bounds, security vulnerability.

Q: Safe copy?
A: Use strncpy with null termination, or snprintf.

How do you define a Struct?

Definition: Composite type grouping different types.

Operation	Time
Access member	O(1)
Copy	O(n)
Size	O(1)

struct Point {
    int x;
    int y;
};

struct Point p1 = {1, 2};
p1.x = 10;                 // O(1)

typedef struct {
    int x;
    int y;
} Point;

Interview Questions:

Q: Padding?
A: Compiler adds padding for alignment. Size may be larger.

What is the purpose of a Union?

Definition: All members share same memory location.

union Data {
    int i;
    float f;
    char c;
};

union Data d;
d.i = 10;                  // O(1)

How to use an Enum?

Definition: Named integer constants.

enum Day {SUN, MON, TUE};
enum Color {RED = 1, GREEN = 2};

How do Pointers work in C?

Definition: Variable storing a memory address.

Operation	Time
Dereference	O(1)
Address-of	O(1)
Arithmetic	O(1)
malloc	O(1)*
free	O(1)
realloc	O(n)*

*Amortized

int x = 10;
int *p = &x;              // O(1)
*p = 20;                  // O(1)

int *arr = malloc(n * sizeof(int));  // O(1)*
free(arr);                 // O(1)

void alloc(int **p) {
    *p = malloc(sizeof(int));  // O(1)*
}

Interview Questions:

Q: malloc vs calloc?
A: malloc: uninitialized. calloc: zero-initialized.

Q: Memory leak?
A: Memory allocated but never freed.

How do you manually implement a Linked List?

Operation	Time
Insert at head	O(1)
Insert at tail	O(1)*
Delete at head	O(1)
Search	O(n)
Access by index	O(n)

*If tail pointer maintained

struct Node {
    int data;
    struct Node *next;
};

struct Node *new = malloc(sizeof(struct Node));
new->data = 1;
new->next = head;
head = new;

for(struct Node *p = head; p; p = p->next)
    printf("%d ", p->data);

Where can I find a Quick Reference?

Need	Python	C++	C
Sequence, index	list	vector	array
Both ends	deque	deque	manual
Unique	set	unordered_set	-
Key-value	dict	unordered_map	-
Sorted	set	set	-
Stack	list/stack	stack	manual
Queue	deque	queue	manual
Priority	heapq	priority_queue	manual

What is the Complexity Summary?

Python

Structure	Access	Search	Insert	Delete
list	O(1)	O(n)	O(1)*	O(n)
tuple	O(1)	O(n)	N/A	N/A
set	-	O(1)*	O(1)*	O(1)*
dict	-	O(1)*	O(1)*	O(1)*

*Average **Worst case

C++ STL

Container	Access	Search	Insert	Delete
vector	O(1)	O(n)	O(1)*	O(n)
deque	O(1)	O(n)	O(1)	O(1)
list	O(n)	O(n)	O(1)	O(1)
set/map	-	O(log n)	O(log n)	O(log n)
unordered_set/map	-	O(1)*	O(1)*	O(1)*

*Average **Worst case

C

Structure	Access	Search	Notes
array	O(1)	O(n)	Fixed size
linked list	O(n)	O(n)	Dynamic

Prasad Raju G

AlgoX

What is AlgoX?

TrueML

Why Choose a No-Abstraction Philosophy?

How Does the Four-Step Pipeline Work?

Why is Statelessness a Core Design Principle?

Who is This Library Built For?

Gen-CLI

What are the key features of Gen-CLI?

How do I install Gen-CLI?

How to install using PyPI pip?

How to install from source?

How to install using uv?

How can I verify my installation?

How do I quickly start using Gen-CLI?

What commands are available?

How to check the version (gen --version)?

How to get help (gen --help)?

How to list available templates (gen list)?

How to diagnose my environment (gen doctor)?

How to visualize my directory (gen tree)?

How do I generate language boilerplate?

How do I generate framework projects?

Which programming languages are supported?

Which frameworks are supported?

How are errors handled?

How do I set up for development?

How to configure the setup?

How to run tests?

How to run the CLI from source?

What does the project structure look like?

What is the license?

Who is the author?

Book - Mathematics for Machine learning

What is the Mathematics for Machine Learning Book About?

How Are Vectors Used in Machine Learning?

How Do Machine Learning Models Learn From Data?

What Are the Core Mathematical Pillars of Machine Learning?

Stats 110

What is Statistics and How does it Differ from Mathematics?

Tic Tac Toe

Endless Tic-Tac-Toe

What are its features?

How do you get started?

What are the prerequisites?

How do you install it?

How do you run the game?

How do you play?

How is the project structured?

What technologies were used?

What are the current limitations?

What is the future roadmap?

Git Guide

What is the Best Git Branch Naming Convention?

How to Include Issue References?

How to Write a Branch Description?

What are Some Examples of Git Branch Names?

How Do You Write an Effective Git Commit Message?

Why Are Git Commit Messages So Important?

What is the Difference Between Bad and Good Commits?

What Should Be in the Commit Message Body?

How Do You Commit with a Subject and Body?

When Should You Make a Git Commit?

Learning Stats

What are the best courses for learning statistics?

1. Statistics 110: Probability - Youtube Link

2. MIT 18.650 Statistics for Applications, Fall 2016 - Youtube Link

Which books are recommended for statistical learning?

1. An Introduction To Statistical Learning With Applications In Python

Mac Setup

Which CLI tools are essential for a new Mac?

What software and applications should I install?

How do I install core programming languages?

Which Python libraries are required for machine learning and data science?

In-built Datastructures in Python, C++, C

What is in this Guide?

Python

C++ (STL)

C Language

How to check the version (`gen --version`)?

How to get help (`gen --help`)?

How to list available templates (`gen list`)?

How to diagnose my environment (`gen doctor`)?

How to visualize my directory (`gen tree`)?

How do you use a Vector `<vector>`?

How does a Deque `<deque>` operate?

When is a List `<list>` useful in C++?

How to use a fixed-size Array `<array>`?

How do you implement a Stack `<stack>`?

How to manage FIFO with a Queue `<queue>`?

When to use a Priority Queue `<queue>`?

How does a Set `<set>` maintain order?

What is a Multiset `<multiset>`?

How does a Map `<map>` handle key-value pairs?

When is a Multimap `<multimap>` useful?

How does an Unordered Set `<unordered_set>` improve lookup?

How fast is an Unordered Map `<unordered_map>`?

How do you manipulate a String `<string>` in C++?