class Matryoshka:
    def __init__(self, size, color):
        self.size = size
        self.color = color
        self.contents = []
    
    def add_doll(self, doll):
        if doll.size < self.size:
            self.contents.append(doll)
        else:
            print(f"Cannot add doll of size {doll.size} into size {self.size} doll")
    
    def remove_smallest(self):
        if not self.contents:
            print("No dolls to remove")
            return None
        
        # Find the smallest doll recursively
        smallest = self._find_smallest()
        if smallest:
            self._remove_doll(smallest)
            return smallest
        return None
    
    def _find_smallest(self):
        if not self.contents:
            return self
        smallest = self
        for doll in self.contents:
            result = doll._find_smallest()
            if result.size < smallest.size:
                smallest = result
        return smallest
    
    def _remove_doll(self, target):
        if self.contents:
            for i, doll in enumerate(self.contents):
                if doll == target:
                    self.contents.pop(i)
                    return
                elif doll._remove_doll(target):
                    return
    
    def display(self, level=0):
        indent = "  " * level
        print(f"{indent}{self.color} ({self.size})")
        for doll in self.contents:
            doll.display(level + 1)

def main():
    # Create nesting of 4 Matryoshka dolls (largest to smallest)
    large = Matryoshka(4, "Red")
    medium = Matryoshka(3, "Blue")
    small = Matryoshka(2, "Green")
    tiny = Matryoshka(1, "Yellow")
    
    # Build the nesting
    large.add_doll(medium)
    medium.add_doll(small)
    small.add_doll(tiny)
    
    # Display initial nesting
    print("Initial nesting:")
    large.display()
    print()
    
    # Remove the smallest doll
    removed = large.remove_smallest()
    if removed:
        print(f"Removed: {removed.color} ({removed.size})")
    
    # Display updated nesting
    print("\nUpdated nesting:")
    large.display()

if __name__ == "__main__":
    main()

Initial nesting:
  Red (4)
    Blue (3)
      Green (2)
        Yellow (1)

Removed: Yellow (1)

Updated nesting:
  Red (4)
    Blue (3)
      Green (2)

import threading
import time
import random

class Philosopher:
    def __init__(self, name, left_fork, right_fork):
        self.name = name
        self.left_fork = left_fork
        self.right_fork = right_fork
        self.eating = False
    
    def eat(self):
        print(f"{self.name} is trying to eat...")
        # Pick up left fork
        self.left_fork.acquire()
        print(f"{self.name} picked up left fork")
        
        # Pick up right fork
        self.right_fork.acquire()
        print(f"{self.name} picked up right fork")
        
        # Eat
        self.eating = True
        print(f"{self.name} is eating")
        time.sleep(random.uniform(1, 3))
        
        # Release forks
        self.right_fork.release()
        self.left_fork.release()
        print(f"{self.name} finished eating")
        self.eating = False

def philosopher_thread(philosopher, num_philosophers):
    while True:
        # Think
        print(f"{philosopher.name} is thinking")
        time.sleep(random.uniform(1, 3))
        
        # Try to eat
        philosopher.eat()

# Main simulation
if __name__ == "__main__":
    # Create 5 forks (semaphores)
    forks = [threading.Semaphore(1) for _ in range(5)]
    
    # Create 5 philosophers
    philosophers = [
        Philosopher("Philosopher 1", forks[0], forks[1]),
        Philosopher("Philosopher 2", forks[1], forks[2]),
        Philosopher("Philosopher 3", forks[2], forks[3]),
        Philosopher("Philosopher 4", forks[3], forks[4]),
        Philosopher("Philosopher 5", forks[4], forks[0])
    ]
    
    # Start threads for each philosopher
    threads = []
    for i, philosopher in enumerate(philosophers):
        thread = threading.Thread(target=philosopher_thread, args=(philosopher, len(philosophers)))
        threads.append(thread)
        thread.start()
    
    # Wait for all threads to complete (infinite loop)
    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        print("Simulation ended")

% 1. Load the cameraman image
img = imread('cameraman.tif');

% 2. Convert to grayscale if necessary
if size(img, 3) == 3
    img = rgb2gray(img);
end

% 3. Apply Gaussian blur with 5x5 kernel
blurred = imgaussfilt(img, 2); % sigma=2 for 5x5 kernel

% 4. Perform edge detection using Sobel operator
edges = edge(blurred, 'sobel');

% 5. Display all images in subplots
figure;
subplot(1,3,1);
imshow(img);
title('Original Image');
axis off;

subplot(1,3,2);
imshow(blurred);
title('Gaussian Blurred');
axis off;

subplot(1,3,3);
imshow(edges);
title('Edge Detected (Sobel)');
axis off;

% 6. Save the edge-detected image
imwrite(edges, 'edge_result.png');

disp('Image processing completed. Results saved.')

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torch.utils.data import DataLoader, TensorDataset
import numpy as np

# 1. Set random seed for reproducibility
torch.manual_seed(42)

# 2. Generate synthetic data
X = torch.randn(100, 10)  # 100 samples, 10 features
y = torch.randint(0, 2, (100,))  # Binary labels

# Create dataset and dataloader
dataset = TensorDataset(X, y)
dataloader = DataLoader(dataset, batch_size=16, shuffle=True)

# 3. Define neural network
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(10, 128)
        self.fc2 = nn.Linear(128, 1)
    
    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = torch.sigmoid(self.fc2(x))
        return x

model = SimpleNN()
criterion = nn.BCELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 4. Training loop
for epoch in range(10):
    model.train()
    total_loss = 0
    correct_predictions = 0
    total_samples = 0
    
    for batch_X, batch_y in dataloader:
        optimizer.zero_grad()
        
        # Forward pass
        outputs = model(batch_X).squeeze()
        loss = criterion(outputs, batch_y.float())
        
        # Backward pass
        loss.backward()
        optimizer.step()
        
        total_loss += loss.item()
        
        # Calculate accuracy
        predictions = (outputs > 0.5).float()
        correct_predictions += (predictions == batch_y.float()).sum().item()
        total_samples += batch_y.size(0)
    
    # Print results
    avg_loss = total_loss / len(dataloader)
    accuracy = correct_predictions / total_samples
    print(f"Epoch {epoch+1}, Loss: {avg_loss:.4f}, Accuracy: {accuracy:.4f}")

# 5. Save the model
torch.save(model.state_dict(), 'simple_nn.pth')
print("Model saved as 'simple_nn.pth'")

import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import mnist
from tensorflow.keras.utils import to_categorical

# 1. Load and preprocess data
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# Normalize pixel values to range [0, 1]
x_train = x_train.astype('float32') / 255.0
x_test = x_test.astype('float32') / 255.0

# Reshape data for the model
x_train = x_train.reshape(-1, 28*28)
x_test = x_test.reshape(-1, 28*28)

# Convert labels to categorical (one-hot encoding)
y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)

# 2. Create sequential model
model = models.Sequential()
model.add(layers.Dense(128, activation='relu', input_shape=(784,)))
model.add(layers.Dense(10, activation='softmax'))

# 3. Compile model
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# 4. Train model
history = model.fit(x_train, y_train,
                    epochs=5,
                    validation_split=0.2,
                    verbose=1)

# 5. Evaluate model
test_loss, test_accuracy = model.evaluate(x_test, y_test, verbose=0)
print(f"Test Accuracy: {test_accuracy:.4f}")

# 6. Save model
model.save('mnist_model.h5')
print("Model saved as 'mnist_model.h5'")

# 1. Create a list of integers from 1 to 10
numbers = list(range(1, 11))
print("Original list:", numbers)

# 2. List comprehension - squares of even numbers
squares_of_evens = [x**2 for x in numbers if x % 2 == 0]
print("Squares of even numbers:", squares_of_evens)

# 3. List slicing
print("\nList slicing examples:")
print("First 5 elements:", numbers[:5])
print("Last 3 elements:", numbers[-3:])
print("Every second element:", numbers[::2])

# 4. Modifying list elements
print("\nModifying list elements:")
numbers[0] = 100  # Change first element
numbers[-1] = 200  # Change last element
print("After modifications:", numbers)

# 5. Nested lists
print("\nNested lists:")
nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print("Accessing nested elements:")
print("First row:", nested_list[0])
print("Element at position [1][2]:", nested_list[1][2])

# 6. Using enumerate()
print("\nUsing enumerate():")
for index, value in enumerate(numbers):
    print(f"Index {index}: {value}")

# 7. Using zip() with two lists
print("\nUsing zip() with two lists:")
names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]
for name, age in zip(names, ages):
    print(f"{name} is {age} years old")

# 8. List operations
print("\nList operations:")
fruits = ['apple', 'banana']
print("Initial fruits:", fruits)

# Append
fruits.append('orange')
print("After append:", fruits)

# Extend
fruits.extend(['grape', 'kiwi'])
print("After extend:", fruits)

# Insert
fruits.insert(1, 'mango')
print("After insert:", fruits)

# Remove
fruits.remove('grape')
print("After remove:", fruits)

# Pop
popped_item = fruits.pop()
print(f"Popped item: {popped_item}, Remaining: {fruits}")

# Sort
fruits.sort()
print("After sorting:", fruits)

# 9. Using count() and index()
print("\nUsing count() and index():")
numbers_with_duplicates = [1, 2, 2, 3, 2, 4]
print("Numbers with duplicates:", numbers_with_duplicates)
print("Count of 2:", numbers_with_duplicates.count(2))
print("Index of first 2:", numbers_with_duplicates.index(2))

# 10. Joining strings in a list
print("\nJoining strings:")
words = ['Hello', 'world', 'from', 'Python']
sentence = ' '.join(words)
print("Joined sentence:", sentence)

# Additional example: list of dictionaries
print("\nList of dictionaries:")
students = [
    {'name': 'Alice', 'grade': 85},
    {'name': 'Bob', 'grade': 92},
    {'name': 'Charlie', 'grade': 78}
]

print("Students data:")
for student in students:
    print(f"{student['name']}: {student['grade']}")

# Example: filtering with list comprehension
print("\nFiltering students with grade > 80:")
high_performers = [student for student in students if student['grade'] > 80]
for student in high_performers:
    print(f"{student['name']}: {student['grade']}")

import json
from collections import Counter, defaultdict
from itertools import combinations, permutations
import pandas as pd
from typing import Dict, List, Any, Optional
from pydantic import BaseModel, Field
import numpy as np

# 1. Create nested dictionary representing employee database
employee_db = {
    'employees': [
        {
            'id': 1,
            'name': 'Alice Johnson',
            'department': 'Engineering',
            'salary': 85000,
            'projects': ['Project A', 'Project B'],
            'skills': {'Python': 8, 'JavaScript': 6, 'SQL': 7},
            'hobbies': ['reading', 'hiking']
        },
        {
            'id': 2,
            'name': 'Bob Smith',
            'department': 'Marketing',
            'salary': 75000,
            'projects': ['Project C'],
            'skills': {'Photoshop': 9, 'SEO': 8, 'Copywriting': 7},
            'hobbies': ['gaming', 'cooking']
        },
        {
            'id': 3,
            'name': 'Charlie Brown',
            'department': 'Engineering',
            'salary': 92000,
            'projects': ['Project A', 'Project D'],
            'skills': {'Python': 9, 'C++': 7, 'Linux': 8},
            'hobbies': ['coding', 'swimming']
        }
    ]
}

# 2. JSON serialization and deserialization
print("JSON Serialization:")
json_data = json.dumps(employee_db, indent=2)
print(json_data)

print("\nJSON Deserialization:")
loaded_data = json.loads(json_data)
print(f"Loaded data type: {type(loaded_data)}")

# 3. Student class with methods
class Student(BaseModel):
    name: str
    age: int
    grades: List[float]
    major: str = Field(..., alias='major')
    
    def average_grade(self) -> float:
        return sum(self.grades) / len(self.grades)
    
    def is_honors_student(self) -> bool:
        return self.average_grade() >= 3.5
    
    def get_skill_level(self, skill: str) -> Optional[int]:
        if hasattr(self, 'skills') and skill in self.skills:
            return self.skills[skill]
        return None

# 4. Using Counter to analyze data
print("\nUsing Counter to analyze skills:")
all_skills = []
for emp in employee_db['employees']:
    all_skills.extend(emp['skills'].keys())
skill_counter = Counter(all_skills)
print("Skill frequencies:", skill_counter)

# 5. Using defaultdict for grouping data
print("\nUsing defaultdict to group employees by department:")
dept_groups = defaultdict(list)
for emp in employee_db['employees']:
    dept_groups[emp['department']].append(emp['name'])

for dept, names in dept_groups.items():
    print(f"{dept}: {names}")

# 6. Generator function for processing large datasets
def large_dataset_generator(size: int):
    """Generator that yields numbers from 1 to size"""
    for i in range(1, size + 1):
        yield i * 2  # Double each number

print("\nUsing generator to process large dataset:")
gen = large_dataset_generator(1000)
print("First 10 values from generator:", [next(gen) for _ in range(10)])

# 7. Using itertools for combinations and permutations

print("\nUsing itertools for combinations and permutations:")
data = ['A', 'B', 'C', 'D']
print("Combinations of 2 elements:", list(combinations(data, 2)))
print("Permutations of 3 elements:", list(permutations(data, 3)))

# 8. Handling missing data with pandas
print("\nHandling missing data with pandas:")
df = pd.DataFrame([
    {'name': 'Alice', 'age': 25, 'city': 'New York'},
    {'name': 'Bob', 'age': 30, 'city': None},
    {'name': 'Charlie', 'age': None, 'city': 'London'}
])

print("Original DataFrame:")
print(df)

# Fill missing values
df_filled = df.fillna({'age': df['age'].median(), 'city': 'Unknown'})
print("\nAfter filling missing values:")
print(df_filled)

# Drop rows with missing values
df_dropped = df.dropna()
print("\nAfter dropping rows with missing values:")
print(df_dropped)

# 9. Converting between data formats
print("\nConverting between data formats:")

# Dictionary to list of tuples
dict_to_list = [(k, v) for k, v in employee_db['employees'][0].items()]
print("Dictionary to list of tuples:", dict_to_list[:5])

# List to DataFrame
df_from_list = pd.DataFrame(employee_db['employees'])
print("\nList to DataFrame:")
print(df_from_list)

# DataFrame to JSON
json_from_df = df_from_list.to_json(orient='records')
print("\nDataFrame to JSON:")
print(json_from_df)

# 10. Data validation with Pydantic
print("\nData validation with Pydantic:")
try:
    student1 = Student(
        name="David Wilson",
        age=22,
        grades=[85, 90, 78],
        major="Computer Science"
    )
    print("Valid student:", student1)
    print(f"Average grade: {student1.average_grade():.2f}")
    print(f"Honors student: {student1.is_honors_student()}")
except Exception as e:
    print("Validation error:", str(e))

# Advanced example: filtering and transforming data
print("\nAdvanced data transformation:")
# Filter engineering employees with high salaries
engineering_high_salary = [
    emp for emp in employee_db['employees']
    if emp['department'] == 'Engineering' and emp['salary'] > 80000
]

print("Engineering employees with salary > $80,000:")
for emp in engineering_high_salary:
    print(f"{emp['name']}: ${emp['salary']}")

# Calculate average salary by department
dept_salaries = defaultdict(list)
for emp in employee_db['employees']:
    dept_salaries[emp['department']].append(emp['salary'])

avg_dept_salary = {dept: sum(salaries)/len(salaries) 
                   for dept, salaries in dept_salaries.items()}
print("\nAverage salary by department:", avg_dept_salary)

# Complex data analysis using numpy
print("\nComplex data analysis using numpy:")
all_salaries = np.array([emp['salary'] for emp in employee_db['employees']])
print(f"Total employees: {len(all_salaries)}")
print(f"Average salary: ${np.mean(all_salaries):.2f}")
print(f"Median salary: ${np.median(all_salaries):.2f}")
print(f"Standard deviation: ${np.std(all_salaries):.2f}")

import cv2
import numpy as np
import matplotlib.pyplot as plt
from pathlib import Path

# 1. Load image and display basic information
def load_and_display_info(image_path):
    img = cv2.imread(image_path)
    if img is None:
        raise FileNotFoundError(f"Image not found: {image_path}")
    
    print("Image loaded successfully")
    print(f"Shape: {img.shape}")
    print(f"Data type: {img.dtype}")
    print(f"Dimensions: {len(img.shape)}")
    
    return img

# 2. Display image in different formats
def display_images(images, titles, figsize=(15, 10)):
    fig, axes = plt.subplots(2, 4, figsize=figsize)
    axes = axes.ravel()
    
    for i, (img, title) in enumerate(zip(images, titles)):
        if len(img.shape) == 2:  # Grayscale
            axes[i].imshow(img, cmap='gray')
        else:  # Color
            axes[i].imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
        axes[i].set_title(title)
        axes[i].axis('off')
    
    plt.tight_layout()
    plt.show()

# 3. Convert color spaces
def convert_color_spaces(img):
    # RGB to Grayscale
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # RGB to HSV
    hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
    
    # Grayscale to RGB
    gray_rgb = cv2.cvtColor(gray, cv2.COLOR_GRAY2BGR)
    
    return gray, hsv, gray_rgb

# 4. Apply different filters
def apply_filters(img):
    # Gaussian blur
    gaussian = cv2.GaussianBlur(img, (5, 5), 0)
    
    # Median filter
    median = cv2.medianBlur(img, 5)
    
    # Bilateral filter
    bilateral = cv2.bilateralFilter(img, 9, 75, 75)
    
    return gaussian, median, bilateral

# 5. Edge detection
def edge_detection(img):
    # Convert to grayscale first
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # Canny edge detection
    canny = cv2.Canny(gray, 100, 200)
    
    # Sobel edge detection
    sobel_x = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
    sobel_y = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
    sobel = np.sqrt(sobel_x**2 + sobel_y**2)
    
    return canny, sobel

# 6. Morphological operations
def morphological_operations(img):
    # Convert to grayscale
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # Threshold to create binary image
    _, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
    
    # Erosion
    kernel = np.ones((5, 5), np.uint8)
    erosion = cv2.erode(binary, kernel, iterations=1)
    
    # Dilation
    dilation = cv2.dilate(binary, kernel, iterations=1)
    
    # Opening (erosion followed by dilation)
    opening = cv2.morphologyEx(binary, cv2.MORPH_OPEN, kernel)
    
    # Closing (dilation followed by erosion)
    closing = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, kernel)
    
    return erosion, dilation, opening, closing

# 7. Thresholding methods
def thresholding_methods(img):
    # Convert to grayscale
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # Simple thresholding
    _, thresh_simple = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
    
    # Adaptive thresholding
    thresh_adaptive = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_MEAN_C, 
                                          cv2.THRESH_BINARY, 11, 2)

# Otsu's thresholding
    _, thresh_otsu = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
    
    return thresh_simple, thresh_adaptive, thresh_otsu

# 8. Image transformations
def image_transformations(img):
    # Get image dimensions
    h, w = img.shape[:2]
    
    # Rotation
    rotation_matrix = cv2.getRotationMatrix2D((w/2, h/2), 45, 1.0)
    rotated = cv2.warpAffine(img, rotation_matrix, (w, h))
    
    # Scaling
    scaled = cv2.resize(img, None, fx=0.5, fy=0.5, interpolation=cv2.INTER_LINEAR)
    
    # Translation
    tx, ty = 100, 50
    translation_matrix = np.float32([[1, 0, tx], [0, 1, ty]])
    translated = cv2.warpAffine(img, translation_matrix, (w, h))
    
    return rotated, scaled, translated

# 9. Feature detection
def feature_detection(img):
    # Convert to grayscale
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # SIFT feature detection
    try:
        sift = cv2.SIFT_create()
        keypoints_sift, descriptors_sift = sift.detectAndCompute(gray, None)
        img_sift = cv2.drawKeypoints(img, keypoints_sift, None, color=(255, 0, 0))
    except:
        print("SIFT not available")
        img_sift = img.copy()
    
    # ORB feature detection
    orb = cv2.ORB_create()
    keypoints_orb, descriptors_orb = orb.detectAndCompute(gray, None)
    img_orb = cv2.drawKeypoints(img, keypoints_orb, None, color=(0, 0, 255))
    
    return img_sift, img_orb

# 10. Contour detection
def detect_contours(img):
    # Convert to grayscale
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # Threshold to get binary image
    _, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
    
    # Find contours
    contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    
    # Draw contours on original image
    contour_img = img.copy()
    cv2.drawContours(contour_img, contours, -1, (0, 255, 0), 2)
    
    return contour_img, len(contours)

# Main function to demonstrate all techniques
def main():
    # Load image
    image_path = "example.jpg"  # Replace with actual image path
    try:
        img = load_and_display_info(image_path)
    except Exception as e:
        print(f"Error loading image: {e}")
        return
    
    # Create output directory
    output_dir = Path("output_images")
    output_dir.mkdir(exist_ok=True)
    
    # 1. Display original image
    original_images = [img]
    original_titles = ["Original Image"]
    
    # 2. Convert color spaces
    gray, hsv, gray_rgb = convert_color_spaces(img)
    color_conversion_images = [gray, hsv, gray_rgb]
    color_conversion_titles = ["Grayscale", "HSV", "Grayscale RGB"]
    
    # 3. Apply filters
    gaussian, median, bilateral = apply_filters(img)
    filter_images = [gaussian, median, bilateral]
    filter_titles = ["Gaussian Blur", "Median Filter", "Bilateral Filter"]
    
    # 4. Edge detection
    canny, sobel = edge_detection(img)
    edge_images = [canny, sobel]
    edge_titles = ["Canny Edges", "Sobel Edges"]
    
    # 5. Morphological operations
    erosion, dilation, opening, closing = morphological_operations(img)
    morph_images = [erosion, dilation, opening, closing]
    morph_titles = ["Erosion", "Dilation", "Opening", "Closing"]
    
    # 6. Thresholding methods
    simple, adaptive, otsu = thresholding_methods(img)
    threshold_images = [simple, adaptive, otsu]
    threshold_titles = ["Simple Threshold", "Adaptive Threshold", "Otsu's Threshold"]
    
    # 7. Image transformations
    rotated, scaled, translated = image_transformations(img)
    transform_images = [rotated, scaled, translated]
    transform_titles = ["Rotated", "Scaled", "Translated"]
    
    # 8. Feature detection
    sift_img, orb_img = feature_detection(img)
    feature_images = [sift_img, orb_img]
    feature_titles = ["SIFT Features", "ORB Features"]
    
    # 9. Contour detection
    contour_img, num_contours = detect_contours(img)
    contour_images = [contour_img]
    contour_titles = [f"Contours ({num_contours} detected)"]
    
    # Combine all images for display

import os
import subprocess
import shutil
import tempfile
import psutil
from pathlib import Path
import sys

# 1. List files and directories with detailed information
def list_directory_details():
    print("Directory contents with details:")
    for entry in os.scandir('.'):
        try:
            stat = entry.stat()
            print(f"{entry.name:<20} {stat.st_size:>8} bytes, "
                  f"modified: {stat.st_mtime}")
        except Exception as e:
            print(f"{entry.name}: Error - {e}")

# 2. Create directory and move file
def create_and_move_file():
    # Create new directory
    new_dir = "test_directory"
    os.makedirs(new_dir, exist_ok=True)
    
    # Create a test file
    test_file = "test_file.txt"
    with open(test_file, 'w') as f:
        f.write("This is a test file.")
    
    # Move file to new directory
    destination = os.path.join(new_dir, test_file)
    shutil.move(test_file, destination)
    
    print(f"Moved {test_file} to {destination}")

# 3. Execute system command and capture output
def execute_system_command():
    # List processes using ps command
    result = subprocess.run(['ps', '-eo', 'pid,comm'], 
                          capture_output=True, text=True)
    
    print("\nRunning processes:")
    print(result.stdout)

# 4. Get user information
def get_user_info():
    print(f"\nCurrent user: {os.getlogin()}")
    print(f"Home directory: {os.path.expanduser('~')}")
    print(f"Current working directory: {os.getcwd()}")

# 5. Check if process is running
def check_process_running(process_name):
    for proc in psutil.process_iter(['name']):
        try:
            if process_name.lower() in proc.info['name'].lower():
                return True
        except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
            pass
    return False

# 6. Environment variables
def manage_environment_variables():
    # Get environment variables
    print(f"\nPATH variable: {os.environ.get('PATH')}")
    print(f"HOME variable: {os.environ.get('HOME')}")
    
    # Set a new environment variable
    os.environ['TEST_VAR'] = 'Hello from Python'
    print(f"Set TEST_VAR: {os.environ.get('TEST_VAR')}")

# 7. Temporary files
def use_temporary_files():
    # Create temporary file
    with tempfile.NamedTemporaryFile(delete=False) as temp:
        temp.write(b"This is a temporary file.")
        temp_path = temp.name
    
    print(f"Created temporary file: {temp_path}")
    
    # Clean up
    os.unlink(temp_path)
    print("Temporary file deleted.")

# Main function to demonstrate all techniques
def main():
    print("=== Operating System Operations Demo ===\n")
    
    # 1. List directory details
    list_directory_details()
    
    # 2. Create directory and move file
    create_and_move_file()
    
    # 3. Execute system command
    execute_system_command()
    
    # 4. Get user info
    get_user_info()
    
    # 5. Check if process is running
    print(f"\nIs Python running? {check_process_running('python')}")
    
    # 6. Manage environment variables
    manage_environment_variables()
    
    # 7. Use temporary files
    use_temporary_files()
    
    print("\nAll operations completed successfully.")

if __name__ == "__main__":
    main()

def quicksort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)

# Example usage
arr = [3, 6, 8, 10, 1, 2, 1]
print(quicksort(arr))  # Output: [1, 1, 2, 3, 6, 8, 10]

def dfs(graph, start, visited=None):
    if visited is None:
        visited = set()
    visited.add(start)
    print(start, end=' ')

    for neighbor in graph[start]:
        if neighbor not in visited:
            dfs(graph, neighbor, visited)

# Example usage
graph = {
    'A': ['B', 'C'],
    'B': ['D', 'E'],
    'C': ['F'],
    'D': [],
    'E': ['F'],
    'F': []
}
dfs(graph, 'A')  # Output: A B D E F C

import heapq
from collections import defaultdict
import sys

def dijkstra(graph, start):
    # Priority queue: (distance, node)
    pq = [(0, start)]
    distances = {start: 0}
    visited = set()
    
    while pq:
        current_dist, current_node = heapq.heappop(pq)
        
        if current_node in visited:
            continue
        visited.add(current_node)
        
        for neighbor, weight in graph[current_node]:
            if neighbor not in distances or distances[neighbor] > current_dist + weight:
                distances[neighbor] = current_dist + weight
                heapq.heappush(pq, (distances[neighbor], neighbor))
    
    return distances

# Example usage
graph = defaultdict(list)
graph['A'] = [('B', 4), ('C', 2)]
graph['B'] = [('C', 1), ('D', 5)]
graph['C'] = [('D', 8)]
graph['D'] = []

distances = dijkstra(graph, 'A')
print(distances)  # Output: {'A': 0, 'B': 4, 'C': 2, 'D': 6}

def tower_of_hanoi(n, source, auxiliary, target):
    if n == 1:
        print(f"Move disk 1 from {source} to {target}")
        return
    tower_of_hanoi(n - 1, source, target, auxiliary)
    print(f"Move disk {n} from {source} to {target}")
    tower_of_hanoi(n - 1, auxiliary, source, target)

# Example usage
tower_of_hanoi(3, 'A', 'B', 'C')

import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import cifar10
from tensorflow.keras.utils import to_categorical

# Load and preprocess data
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
y_train, y_test = to_categorical(y_train), to_categorical(y_test)

# Build CNN model
model = models.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.Flatten(),
    layers.Dense(64, activation='relu'),
    layers.Dense(10, activation='softmax')
])

# Compile and train
model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

model.fit(x_train, y_train, epochs=10, validation_data=(x_test, y_test))

# Evaluate
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"Test Accuracy: {test_acc}")

import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import imdb
from tensorflow.keras.preprocessing.sequence import pad_sequences

# Load and preprocess data
vocab_size = 10000
max_length = 250
(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=vocab_size)
x_train = pad_sequences(x_train, maxlen=max_length)
x_test = pad_sequences(x_test, maxlen=max_length)

# Build RNN model
model = models.Sequential([
    layers.Embedding(vocab_size, 128, input_length=max_length),
    layers.SimpleRNN(64, return_sequences=False),
    layers.Dense(32, activation='relu'),
    layers.Dense(1, activation='sigmoid')
])

# Compile and train
model.compile(optimizer='adam',
              loss='binary_crossentropy',
              metrics=['accuracy'])

model.fit(x_train, y_train, epochs=5, validation_data=(x_test, y_test))

# Evaluate
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"Test Accuracy: {test_acc}")