import numpy as np
from collections import Counter

def euclidean_distance(a, b):
    return np.sqrt(np.sum((a-b) ** 2))

class KNN:
    def __init__(self, k=3):
        self.k = k

    def fit(self, X, y):
        self.X_train = X
        self.y_train = y

    def predict(self, X):
        return [self._predict(x) for x in X]

    def _predict(self, x):
        
        distances = [euclidean_distance(x, x_train) for x_train in self.X_train]
        
        k_indics = np.argsort(distances)[:self.k]
        
        k_nearest_labels = [self.y_train[i] for i in k_indics]
 
        most_common = Counter(k_nearest_labels).most_common(1)
        return most_common[0][0]

import random

def fitness(x):
    return x**2


def decode(chromosome, a, b, bits):
    value =int(chromosome, 2)
    return a + (b - a) * value / (2**bits - 1)


def random_chromosome(bits):
    return ''.join(random.choice('01') for_in range(bits))


def selection(population, scores):
    k = 3 
    selected = random.choices(list(zip(population, scores)), k=k)
    selected.sort(key=lambda x: x[1], reverse=True)
    return selected[0][0]

def crossover(p1, p2, rate=0.7):
    if random.random() < rate:
        point = random.randint(1, len(p1) - 1)
        return p1[:point] + p2[point:], p2[:point] + p1[point:]
    return p1, p2


def mutate(chromosome, rate=0.01):
    return ''.join(
        bit if random.random() > rate else ('1' if bit == '0' else '0')
        for bit in chromosome
    )


bits = 10
bounds = (-10, 10)
population_size = 20
generations = 50

population = [random_chromosome(bits) for _ in range(population_size)]


for gen in range(generations):
    decoded = [decode(c, *bounds, bits) for c in population]
    scores=[fitness(d) for d in decoded]
    
    
    best_idx = scores.index(max(scores))
    print(f"{gen}: x = {decoded[best_idx]:.3f}, f(x) = {scores[best_idx]:.3f}")
    
    
    select = [selection(population, scores) for _ in range(population_size)]
    
    
    children = [ ]
    for i in range(0, population_size, 2):
        p1, p2 = select[i], select[i+1]
        c1, c2 =crossover(p1, p2)
        c1, c2 =mutate(c1), mutate(c2)
        children.extend([c1, c2])
    
    population = children

def is_prime(n):
    if n <= 1:
        return False
    if n <= 3:
        return True
    if n % 2 == 0 or n % 3 == 0:
        return False
    i = 5
    while i * i <= n:
        if n % i == 0 or n % (i + 2) == 0:
            return False
        i += 6
    return True

def next_prime(n):
    candidate = n + 1
    while not is_prime(candidate):
        candidate += 1
    return candidate

def sum_with_next_prime(num):
    if is_prime(num):
        next = next_prime(num)
        result =num +next
        print(f"{num} is a prime Sum with the next prime {next} is: {result}")
    else:
        print(f"{num} is not a prime")

number=int(input("Enter a number: "))
sum_with_next_prime(number)

import math

def sieve_of_eratosthenes(n):
    is_prime=[True] *(n + 1)
    is_prime[0]=False
    is_prime[1] = False

    for p in range(2, int(math.sqrt(n)) + 1):
        if is_prime[p]:
            for multiple in range(p * p, n + 1, p):
                is_prime[multiple]=False

    primes= [ ]
    for i in range(2,n + 1):
        if is_prime[i]:
            primes.append(i)

    return primes

n = int(input("Find all prime numbers up to: "))
primes = sieve_of_eratosthenes(n)
print(f"Prime numbers up to {n} are:")
print(primes)

def quick_sort(arr):
    if len(arr)<=1:
        return arr

    pivot = arr[0]
    smaller =[x for x in arr[1:] if x < pivot]
    greater_or_equal= [x for x in arr[1:] if x >= pivot]

    return quick_sort(smaller) + [pivot] + quick_sort(greater_or_equal)