Welcome to my fridge door!

>> Upload a folder to an empty GitHub repo:

cd path/to/your/folder
git init
git remote add origin https://github.com/your-username/your-repo-name.git
git add .
git commit -m "Initial commit"
git branch -M main
git push -u origin main


>> Clone a repo into an empty folder:

cd path/to/your/empty-folder
git clone https://github.com/your-username/your-repo.git


>> Remove folder after added by mistake (ex.: .idea):

git rm -r --cached .idea
git commit -m "Stop tracking .idea"
git push

>> Publish a page:

The main HTML file should be in root named index.html

1. Go to your repository on GitHub.
2. Click Settings → Pages (or scroll to the “GitHub Pages” section).
3. Under Source, select the branch: main (or master), and folder: /root.
4. Click Save.
5. GitHub will provide a URL, e.g., https://YOUR_USERNAME.github.io/python-cs-notes/
• Wait a few minutes for GitHub Pages to process.

1. Python List (list)
Built-in Python type: list

Can hold elements of any type, even mixed types:

lst = [1, "hello", 3.14, True]
Dynamic size: You can append, remove, or insert elements at any time.
Flexible but slower for large numerical computations because each element is a full Python object.

lst = [1, 2, 3]
lst.append(4)
lst[0] = 10
Implementation: Array of pointers to Python objects.



2. Array (array module or numpy array)
array.array: Built-in module for arrays of same type (numbers/characters).

import array
arr = array.array('i', [1, 2, 3, 4]) # 'i' = signed int
numpy.array: Part of NumPy library, optimized for numerical operations, supports multidimensional arrays.


import numpy as np
arr = np.array([1, 2, 3, 4])
All elements must have the same type (homogeneous).

Faster for math/large data than Python lists.

Supports vectorized operations:

arr = np.array([1, 2, 3])
arr + 5 # array([6, 7, 8])
arr * 2 # array([2, 4, 6])

x = "global x" # Global

def outer():
x = "enclosing x" # Enclosing

def inner():
x = "local x" # Local
print(x)

inner()

outer()
print(x) # Prints the global x

local x
global x

1. Single Responsibility Principle (SRP) – One class, one job
    Class: Teacher
    Responsibility: Teach students
    What it shouldn’t do: Fix the school’s computers
    Why: Only one reason to change—teaching. If you make it fix computers too, changes in IT affect teaching.
Implementation:
    Keep teaching tasks in Teacher.
    Put IT-related work in a separate ITSupport class.
    One reason to change = one class.


2. Open/Closed Principle (OCP) – Open for extension, closed for modification
    Class: RemoteControl
    Behavior: Controls TV functions (volume, channels)
    Extending: Add voice control or streaming buttons without changing existing buttons
    Why: You can add new features without touching the original design.
Implementation:
    Use extensible design: e.g., allow adding new buttons/features without modifying existing ones.
    New functionality = new class or method, not editing old ones.


3. Liskov Substitution Principle (LSP) – Subtypes must work like their base type
    Class: Car
    Subclass: SportsCar
    Behavior: Drive, stop, turn
    Why: A SportsCar can replace a Car anywhere, behaving as expected. If it breaks normal car behavior, it violates LSP.
Implementation:
    Ensure all subclasses behave like the base class.
    Don’t override methods in a way that breaks expectations.
    Anyone using Car should seamlessly use SportsCar.


4. Interface Segregation Principle (ISP) – Many small interfaces > one big interface
    Class: Smartphone
    Interfaces: Calling, Camera, MusicPlayer
    Why: A person who just wants to make calls doesn’t need to implement camera or music features.
    Idea: Split big interfaces into small, focused ones.
Implementation:
    Split big interfaces into small, focused interfaces: Calling, Camera, Music.
    Classes only implement the interfaces they need, avoiding unnecessary methods.


5. Dependency Inversion Principle (DIP) – Depend on abstractions, not concretes
    Class: TV
    Depends on: PowerSource (abstract idea of electricity)
    Why: It doesn’t care if it’s a battery, plug, or solar—high-level module depends on abstraction, not concrete implementation.
Implementation:
    Depend on abstract concepts (like PowerSource) rather than concrete types.
    You can swap battery, plug, solar panel without changing the TV class.

i and j stick together and move 1 index ahead, they swap if j is bigger
This runs multiple times until no more sorts are needed

Index i starts at 0
j starts at 1
j compares to i and swaps if smaller, it does not scan the whole arr like in selection
i moves ahead until len - 1

Index i stays at the start
Index j scans the whole array and finds the smallest
If it is smaller than i, swap
i is moved 1 ahead until it reaches len - 1

Big-O Notation (O-notation)
    Read as: "Big O of f(n)"
    Meaning: Describes the worst-case complexity (upper bound).
    Example: If an algorithm is O(n²), it means in the worst case, the runtime grows no faster than n².

Omega Notation (Ω-notation)
    Read as: "Omega of f(n)"
    Meaning: Describes the best-case complexity (lower bound).
    Example: If an algorithm is Ω(n), it means it takes at least linear time in the best case.

Theta Notation (Θ-notation)
    Read as: "Theta of f(n)"
    Meaning: Describes the average or tight bound (both upper and lower).
    Example: If an algorithm is Θ(n log n), it means its runtime grows like n log n on average and tightly bounded there.

A binary tree is a data structure where each node has at most two children:
Left child
Right child
The top node is called the root.
Nodes with no children are called leaves.

10 → root
5 → left child of 10
20 → right child of 10
Each node can have 0, 1, or 2 children.


>>> Binary Search Tree (BST)
A BST is a binary tree where for every node:
Left child ≤ parent
Right child ≥ parent
This property makes searching efficient.

Search: To find 15 → compare with root 10 → go right → 20 → go left → 15.
Time complexity: O(log n) in a balanced tree


>>> Min-Heap
A Min-Heap is a binary tree (usually implemented as an array) where:
A complete binary tree where:
Parent ≤ children
Minimum element at root
Used in priority queues.

• The smallest element is always at the root.
• Every parent node is less than or equal to its children.
• It's a complete binary tree (all levels filled except possibly the last, which is filled left to right).

In array form:
[1, 3, 5, 4, 8, 6]

"Min-Heap of size k" — What does that mean?
It means:
• You're using a Min-Heap that stores at most k elements at any time.
• This is common in algorithms where you want to track the smallest (or largest) k elements from a larger set.


>>> Max-Heap
A complete binary tree where:
Parent ≥ children
Maximum element at root
Used when you want largest element quickly.

>>><<<
BST → Organized phonebook (searchable by value)
Min-Heap → Queue where the smallest task is always on top
Max-Heap → Queue where the largest task is always on top
>>><<<

class Solution(object):
def sortArray(self, nums):
"""
:type nums: List[int]
:rtype: List[int]
"""

if len(nums) == 1:
return nums

pivot = len(nums) // 2
left = self.sortArray(nums[:pivot])
right = self.sortArray(nums[pivot:])

result = []
i = j = 0
while i < len(left) and j < len(right):
if left[i] <= right[j]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j += 1
result += left[i:]
result += right[j:]

return result

sol = Solution()
print(sol.sortArray([5,2,3,1]))

The recusrion breaks nums down to lists with 1 num inside and then after the recursion the code is run for each stack call to compare

sortArray([5,2,3,1])
LEFT
sortArray([5,2])
sortArray([5]) → returns [5]
sortArray([2]) → returns [2]
merge [5] and [2] → [2,5]
RIGHT
sortArray([3,1])
sortArray([3]) → returns [3]
sortArray([1]) → returns [1]
merge [3] and [1] → [1,3]

merge [2,5] and [1,3] → [1,2,3,5]

>> The final stage merge goes like this:
Step 0: Initial arrays
left = [2, 5]
right = [1, 3]
merged = []

Step 1: Compare 2 and 1 → take 1
merged = [1]
left = [2, 5]
right = [3]

Step 2: Compare 2 and 3 → take 2
merged = [1, 2]
left = [5]
right = [3]

Step 3: Compare 5 and 3 → take 3
merged = [1, 2, 3]
left = [5]
right = []

Step 4: Right empty → take remaining 5
merged = [1, 2, 3, 5]

no pivots

The array is split in half, recursively, and then merged.
We just talk about dividing and merging, not a pivot.

class Solution(object):
def sortArray(self, nums):

if len(nums) <= 1:
return nums # Base case: already sorted

mid = len(nums) // 2
pivot = nums[mid] # Choose middle element as pivot
left = []
right = []

for i, num in enumerate(nums):
if i == mid:
continue # Skip the pivot itself
if num <= pivot:
left.append(num)
else:
right.append(num)

# Recursively sort left and right, then combine with pivot
return self.sortArray(left) + [pivot] + self.sortArray(right)


sol = Solution()
print(sol.sortArray([5, 2, 3, 1]))


Pivot: Middle element of the array.
Partition: All elements ≤ pivot go left, all > pivot go right.
Skip the pivot when partitioning.
Recursively sort left and right subarrays.
Combine: sorted left + pivot + sorted right.

Let’s see what happens if the middle element is the biggest in Quick Sort.

Suppose the array is:

[1, 2, 5, 3]
Middle element = 5 (pivot)
Step 1: Partition around pivot (5)
Left (≤ pivot): [1, 2, 3]
Right (> pivot): []
So after partitioning:

[1, 2, 3] | 5 | []


In Quick Sort, the pivot can be any element of the array. Pick any element at random. Works well in practice to avoid consistently bad cases.
import random
pivot_index = random.randint(0, len(arr)-1)
pivot = arr[pivot_index]

1. What is a Closure?
A closure is a function that “remembers” the variables from its enclosing scope, even after that outer function has finished executing.
In simpler terms: a function along with the environment in which it was created.
Closures allow you to retain state without using global variables or classes.

2. Components of a Closure
To have a closure in Python, you need:

An outer function that defines some local variables.
An inner function that uses those variables.
The outer function returns the inner function.

3. Example: Simple Closure

def outer(x):
def inner(y):
return x + y # 'x' comes from the outer scope
return inner

add_five = outer(5) # outer() returns inner()
print(add_five(10)) # Output: 15

Explanation:
x = 5 lives in the outer function.
inner() remembers x even after outer() has finished.
Calling add_five(10) adds 10 to the remembered 5 → 15.

add_five is a closure — it “closes over” x.

4. Why Closures Are Useful
Maintain state between function calls without globals.

Can be used to create factory functions (functions that generate other functions).
Enable decorators and functional programming patterns in Python.

5. Another Example: Multiplier Factory

def make_multiplier(factor):
def multiply(x):
return x * factor
return multiply

double = make_multiplier(2)
triple = make_multiplier(3)

print(double(5)) # 10
print(triple(5)) # 15

Each returned function remembers its own factor.
No global variables required.

In many languages (like JavaScript, Scheme, or Haskell), a closure is a function plus a persistent environment that keeps references to variables even after the outer function has returned.

>>> Python (reference)
# Print numbers 0 to 4

for i in range(5):
print(i)


>>> C / C++

#include
int main() {
for (int i = 0; i < 5; i++) {
printf("%d\n", i);
}
return 0;
}

>>> Java

public class Main {
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
System.out.println(i);
}
}
}

>>> JavaScript

// Traditional for loop
for (let i = 0; i < 5; i++) {
console.log(i);
}

// For-of loop (over arrays)
const arr = [10, 20, 30];
for (const val of arr) {
console.log(val);
}

>>> Go

package main

import "fmt"

func main() {
for i := 0; i < 5; i++ {
fmt.Println(i)
}
}

>>> Ruby
# Using a range
(0..4).each do |i|
puts i
end

>>> PHP

for ($i = 0; $i < 5; $i++) {
echo $i . "\n";
}
?>

>>>SQL (pseudo “loop” in PL/pgSQL)

DO $$
DECLARE
i INT;
BEGIN
FOR i IN 0..4 LOOP
RAISE NOTICE '%', i;
END LOOP;
END $$;

>>> Python (reference)
# Print numbers 0 to 4

i = 0
while i < 5:
print(i)
i += 1

>>> C / C++

#include

int main() {
int i = 0;
while (i < 5) {
printf("%d\n", i);
i++;
}
return 0;
}

>>> Java

public class Main {
public static void main(String[] args) {
int i = 0;
while (i < 5) {
System.out.println(i);
i++;
}
}
}

>>> JavaScript

let i = 0;
while (i < 5) {
console.log(i);
i++;
}

>>> Go

package main

import "fmt"

func main() {
i := 0
for i < 5 { // Go doesn’t have a separate while; "for cond" works as while
fmt.Println(i)
i++
}
}

>>> Ruby

i = 0
while i < 5
puts i
i += 1
end

>>> PHP

$i = 0;
while ($i < 5) {
echo $i . "\n";
$i++;
}
?>

>>> SQL (PL/pgSQL)

DO $$
DECLARE
i INT := 0;
BEGIN
WHILE i < 5 LOOP
RAISE NOTICE '%', i;
i := i + 1;
END LOOP;
END $$;
WHILE loop in PostgreSQL PL/pgSQL.

void function in SQL (and programming in general) is a function that does not return any value.

C Example:
void sayHello() {
printf("Hello!\n");
}
It just prints something — no return value.

Python equivalent:
Copy code
def say_hello():
print("Hello!") # No return

0 -> 0
1 -> 1
2 -> 10
3 -> 11
4 -> 100
5 -> 101
6 -> 110
7 -> 111
8 -> 1000
9 -> 1001
10 -> 1010
11 -> 1011
12 -> 1100
13 -> 1101
14 -> 1110
15 -> 1111
16 -> 10000
17 -> 10001
18 -> 10010
19 -> 10011
20 -> 10100

0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F
10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 1A, 1B, 1C, 1D, 1E, 1F
20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 2A, 2B, 2C, 2D, 2E, 2F
30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 3A, 3B, 3C, 3D, 3E, 3F
40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 4A, 4B, 4C, 4D, 4E, 4F
50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 5A, 5B, 5C, 5D, 5E, 5F
60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 6A, 6B, 6C, 6D, 6E, 6F
70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 7A, 7B, 7C, 7D, 7E, 7F
80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 8A, 8B, 8C, 8D, 8E, 8F
90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 9A, 9B, 9C, 9D, 9E, 9F
A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, AA, AB, AC, AD, AE, AF
B0, B1, B2, B3, B4, B5, B6, B7, B8, B9, BA, BB, BC, BD, BE, BF
C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, CA, CB, CC, CD, CE, CF
D0, D1, D2, D3, D4, D5, D6, D7, D8, D9, DA, DB, DC, DD, DE, DF
E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, EA, EB, EC, ED, EE, EF
F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, FA, FB, FC, FD, FE, FF

In hex 10 is actually 16 in decimal, while A = 10

>>
In programming and math, 0x at the beginning of a number indicates that the number is in hexadecimal (base 16).

0x1A → hex number 1A → decimal 26
0xFF → hex number FF → decimal 255

>
Hexadecimal (hex) is used a lot in computing because it’s a human-friendly way to represent binary numbers. Let’s break it down clearly.

1. Bit
Bit = binary digit
The smallest unit of digital information.
Can be 0 or 1.

2. Byte
Byte = 8 bits
Can store 1 character (like a letter, number, or symbol).
Example:
A in ASCII = 01000001 (8 bits → 1 byte)

3. Larger Units
These are multiples of bytes. Computers often use powers of 2:

Kilobyte (KB)    
1,024 bytes    ~1 thousand bytes

Megabyte (MB)    
1,024 KB = 1,048,576 bytes    ~1 million bytes

Gigabyte (GB)    
1,024 MB = 1,073,741,824 bytes    ~1 billion bytes

Terabyte (TB)    
1,024 GB    ~1 trillion bytes

Petabyte (PB)    
1,024 TB    Huge, used in servers/cloud storage
___

Elementary Cells
An elementary cell is the basic storage unit in a computer’s memory.

Think of it as a tiny container that can hold one piece of information.

In digital computers, each cell can exist in only two states, because it’s built using switches (transistors) that are either on or off.

States
A state is the possible condition of an elementary cell.

Since each cell can be on or off, it has 2 possible states:

0 → off
1 → on

These states are the basis of binary representation in computers.

How it scales
1 cell (1 bit) → 2 states → can store 0 or 1
2 cells (2 bits) → 2**2 = 4 states → can store 0–3
3 cells (3 bits) → 2**3 = 8 states → can store 0–7
8 cells (1 byte) → 2**8 = 256 states → can store 0–255

Think of it as “I need 2 in binary from the next column.”

>>
Always look to the left for the first 1 if you need to borrow.
Convert that 1 into a 0, and fill all zeros you passed with 1 (since you’re “breaking them down” to borrow 1 for the original column).
Then do the subtraction column by column from right to left.

Binary=Concatenate 4-bit binary equivalents of each hex digit.

0 ->    0000
1 ->    0001
2 ->    0010
3 ->    0011
4 ->    0100
5 ->    0101
6 ->    0110
7 ->    0111
8 ->    1000
9 ->    1001
A ->    1010
B ->    1011
C ->    1100
D ->    1101
E ->    1110
F ->    1111

Variables can have only two values. The values are truth values, "true" and "false". It is often denoted as 1 and 0, respectively.

There are three basic operations in Boolean Algebra:
A AND B. This operation results in true value only if both A and B are true.
A OR B. This operation results in true value only if at least one of A or B is true.
NOT A. This operation negates the value of A. If A is true, then NOT A is false, and if A is false, then NOT A is true.

>>
Double Negation Law
As in elementary algebra, we also have double negation law:

NOT (NOT A) = A

De Morgan's Laws
There are also two important laws, called De Morgan's laws:

NOT (A or B) = (NOT A) and (NOT B)
NOT (A and B) = (NOT A) or (NOT B)

>>
Absorption Law: X OR (X AND Y) = X