import random
from math import gcd

def modinv(a, m):
    for x in range(1, m):
        if (a * x) % m == 1:
            return x
    raise Exception('Modular inverse does not exist.')

def generate_keys():
    p = 17
    q = 23
    n = p * q
    phi = (p - 1) * (q - 1)
    e = 3
    while gcd(e, phi) != 1:
        e += 2
    d = modinv(e, phi)
    return (e, n), (d, n)

def encrypt(public_key, plaintext):
    e, n = public_key
    return [pow(ord(char), e, n) for char in plaintext]

def decrypt(private_key, ciphertext):
    d, n = private_key
    return ''.join([chr(pow(char, d, n)) for char in ciphertext])

public, private = generate_keys()

message = "Hi"
cipher = encrypt(public, message)
decrypted = decrypt(private, cipher)

print("Public key:", public)
print("Private key:", private)
print("Original:", message)
print("Encrypted:", cipher)
print("Decrypted:", decrypted)

import hashlib

data ="Hello,world!".encode()
hash_value = hashlib.sha256(data).hexdigest()

print("SHA-256 Hash:", hash_value)

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, classification_report

iris=load_iris()
X = iris.data
y = iris.target

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

model = KNeighborsClassifier(n_neighbors=3)
model.fit(X_train, y_train)

y_pred=model.predict(X_test)

accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy * 100:.2f}%")
print("\nClassification Report:")
print(classification_report(y_test, y_pred, target_names=iris.target_names))

import numpy as np

def initialize_centroids(X, k):
    indices = np.random.choice(len(X), size=k, replace=False)
    return X[indices]

def assign_clusters(X,centroids):
    distances = np.linalg.norm(X[:, np.newaxis] -centroids, axis=2)
    return np.argmin(distances, axis=1)

def update_centroids(X, labels, k):
    return np.array([X[labels== i].mean(axis=0) for i in range(k)])

def has_converged(old_centroids, new_centroids, tolerance=1e-4):
    shifts = np.linalg.norm(new_centroids - old_centroids, axis=1)
    return np.all(shifts < tolerance)

def kmeans(X, k, max_iterations=100):
    centroids=initialize_centroids(X, k)

    for _ in range(max_iterations):
        labels = assign_clusters(X, centroids)
        new_centroids = update_centroids(X, labels, k)

        if has_converged(centroids, new_centroids):
            break

        centroids=new_centroids

    return centroids, labels