# Decimal to Binary
def decimal_to_binary(n):
    if n == 0:
        return "0"
    binary = ""
    while n > 0:
        binary = str(n % 2) + binary
        n = n // 2
    return binary

# Binary to Decimal
def binary_to_decimal(binary):
    decimal = 0
    for i, bit in enumerate(reversed(binary)):
        decimal += int(bit) * (2 ** i)
    return decimal

# Examples
print(decimal_to_binary(42))  # "101010"
print(binary_to_decimal("101010"))  # 42

# Run-Length Encoding
def rle_compress(data):
    compressed = []
    i = 0
    while i < len(data):
        count = 1
        while i + count < len(data) and data[i] == data[i + count]:
            count += 1
        compressed.append((data[i], count))
        i += count
    return compressed

# Example
data = "AAABBBCCDDDDD"
print(rle_compress(data))  # [('A', 3), ('B', 3), ('C', 2), ('D', 5)]

Layer 4: Application (HTTP, FTP, SMTP, DNS)
Layer 3: Transport (TCP, UDP)
Layer 2: Internet (IP, ICMP, ARP)
Layer 1: Network Access (Ethernet, Wi-Fi)

GET /index.html HTTP/1.1
Host: www.example.com
User-Agent: Mozilla/5.0
Accept: text/html

HTTP/1.1 200 OK
Content-Type: text/html
Content-Length: 1234

<html>...</html>

# Python Variables
name = "Alice"          # String
age = 16                # Integer
height = 5.5            # Float
is_student = True       # Boolean

# Lists (dynamic arrays)
grades = [90, 85, 92, 88]

# Dictionaries (key-value pairs)
student = {
    "name": "Alice",
    "age": 16,
    "grades": [90, 85, 92]
}

# If-Else
if age >= 18:
    print("Adult")
elif age >= 13:
    print("Teenager")
else:
    print("Child")

# For Loop
for i in range(10):
    print(i)

# While Loop
count = 0
while count < 10:
    print(count)
    count += 1

# Try-Except (Error Handling)
try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero")

# Function Definition
def calculate_average(numbers):
    """Calculate the average of a list of numbers."""
    if not numbers:
        return 0
    return sum(numbers) / len(numbers)

# Function Call
grades = [90, 85, 92, 88]
avg = calculate_average(grades)
print(f"Average: {avg:.2f}")

# Recursive Function
def factorial(n):
    """Calculate factorial recursively."""
    if n <= 1:
        return 1
    return n * factorial(n - 1)

# Sequencing: Execute steps in order
def make_sandwich():
    get_bread()
    add_spread()
    add_filling()
    close_sandwich()

# Selection: Choose between options
def get_grade(score):
    if score >= 90:
        return "A"
    elif score >= 80:
        return "B"
    else:
        return "C"

# Iteration: Repeat steps
def sum_list(numbers):
    total = 0
    for num in numbers:
        total += num
    return total

# O(1) - Constant Time
def get_first(items):
    return items[0]

# O(n) - Linear Time
def find_max(items):
    max_val = items[0]
    for item in items:
        if item > max_val:
            max_val = item
    return max_val

# O(n²) - Quadratic Time
def bubble_sort(items):
    n = len(items)
    for i in range(n):
        for j in range(0, n-i-1):
            if items[j] > items[j+1]:
                items[j], items[j+1] = items[j+1], items[j]
    return items

# Data Analysis with Python
import pandas as pd

# Load data
df = pd.read_csv("data.csv")

# Basic statistics
print(df.describe())

# Filtering
high_scores = df[df["score"] > 90]

# Grouping
average_by_group = df.groupby("group")["score"].mean()

# Linear Regression (simplified)
def predict(x, slope, intercept):
    return slope * x + intercept

# Training data
x = [1, 2, 3, 4, 5]
y = [2, 4, 5, 4, 5]

# Simple gradient descent
slope = 0
intercept = 0
learning_rate = 0.01

for _ in range(1000):
    for xi, yi in zip(x, y):
        prediction = predict(xi, slope, intercept)
        error = prediction - yi
        slope -= learning_rate * error * xi
        intercept -= learning_rate * error

print(f"Slope: {slope:.2f}, Intercept: {intercept:.2f}")