def bubble_sort(arr):
    n = len(arr)
    
    # Проходим по всем элементам массива
    for i in range(n):
        
        # Последние i элементов уже отсортированы,
        # поэтому мы можем их пропустить
        for j in range(n - i - 1):
            
            # Если текущий элемент больше следующего,
            # меняем их местами
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    
    return arr

import random
import numpy as np

# Определение функции для подбора
def func(x, a, b, c):
    return a * np.sin(b * x) + c

# Генерация начальной популяции
def generate_population(population_size, num_params):
    population = []
    for i in range(population_size):
        individual = []
        for j in range(num_params):
            individual.append(random.uniform(-10, 10))
        population.append(individual)
    return population

# Определение функции приспособленности (fitness function)
def fitness_function(individual, x, y):
    a, b, c = individual
    y_pred = func(x, a, b, c)
    error = np.mean(np.abs(y - y_pred))
    fitness = 1 / (error + 1e-6)
    return fitness

# Определение оператора скрещивания (crossover operator)
def crossover(parent1, parent2):
    child = []
    for i in range(len(parent1)):
        if random.random() < 0.5:
            child.append(parent1[i])
        else:
            child.append(parent2[i])
    return child

# Определение оператора мутации (mutation operator)
def mutate(individual, mutation_rate):
    for i in range(len(individual)):
        if random.random() < mutation_rate:
            individual[i] += random.uniform(-1, 1)
    return individual

# Определение генетического алгоритма
def genetic_algorithm(x, y, population_size=100, num_generations=100, mutation_rate=0.1):
    num_params = 3
    population = generate_population(population_size, num_params)

    for i in range(num_generations):
        # Вычисление приспособленности для каждого индивида
        fitness_scores = []
        for individual in population:
            fitness_scores.append(fitness_function(individual, x, y))

        # Выбор родителей
        parent1, parent2 = random.choices(population, weights=fitness_scores, k=2)

        # Скрещивание родителей и мутация потомства
        child = crossover(parent1, parent2)
        child = mutate(child, mutation_rate)

        # Замена наименее приспособленного индивида потомством
        fitness_scores = []
        for individual in population:
            fitness_scores.append(fitness_function(individual, x, y))
        min_fitness_idx = np.argmin(fitness_scores)
        population[min_fitness_idx] = child

    # Возвращение наилучшего индивида
    fitness_scores = []
    for individual in population:
        fitness_scores.append(fitness_function(individual, x, y))
    best_individual_idx = np.argmax(fitness_scores)
    return population[best_individual_idx]

# Пример использования
x = np.linspace(-10, 10, 100)
y = func(x, 2, 3, 1) + np.random.normal(0, 1, 100)
best_individual = genetic_algorithm(x, y)
print("Best individual:", best_individual)

import java.util.Arrays;
import java.util.Random;

public class GeneticAlgorithm {
    private static final double MUTATION_RATE = 0.1;
    private static final int POPULATION_SIZE = 100;
    private static final int NUM_GENERATIONS = 100;

    public static double[] geneticAlgorithm(int[][] points) {
        int numPoints = points.length;
        double[][] population = initializePopulation(numPoints);
        double[] fitness = calculateFitness(population, points);
        for (int i = 0; i < NUM_GENERATIONS; i++) {
            double[][] newPopulation = new double[POPULATION_SIZE][numPoints + 1];
            for (int j = 0; j < POPULATION_SIZE; j++) {
                double[] parent1 = selectParent(population, fitness);
                double[] parent2 = selectParent(population, fitness);
                double[] child = crossover(parent1, parent2);
                child = mutate(child);
                newPopulation[j] = child;
            }
            population = newPopulation;
            fitness = calculateFitness(population, points);
        }
        double[] bestIndividual = getBestIndividual(population, fitness);
        return bestIndividual;
    }

    private static double[][] initializePopulation(int numPoints) {
        double[][] population = new double[POPULATION_SIZE][numPoints + 1];
        for (int i = 0; i < POPULATION_SIZE; i++) {
            for (int j = 0; j < numPoints; j++) {
                population[i][j] = getRandomCoefficient();
            }
            population[i][numPoints] = getRandomConstant();
        }
        return population;
    }

    private static double getRandomCoefficient() {
        Random random = new Random();
        return random.nextDouble() * 10 - 5;
    }

    private static double getRandomConstant() {
        Random random = new Random();
        return random.nextDouble() * 100 - 50;
    }

    private static double[] calculateFitness(double[][] population, int[][] points) {
        double[] fitness = new double[POPULATION_SIZE];
        for (int i = 0; i < POPULATION_SIZE; i++) {
            double[] individual = population[i];
            double error = calculateError(individual, points);
            fitness[i] = 1 / (error + 1);
        }
        return fitness;
    }

    private static double calculateError(double[] individual, int[][] points) {
        double error = 0;
        for (int i = 0; i < points.length; i++) {
            int x = points[i][0];
            int y = points[i][1];
            double predictedY = evaluateFunction(individual, x);
            error += Math.pow(predictedY - y, 2);
        }
        return error;
    }

    private static double evaluateFunction(double[] individual, double x) {
        double y = 0;
        for (int i = 0; i < individual.length - 1; i++) {
            y += individual[i] * Math.pow(x, i);
        }
        y += individual[individual.length - 1];
        return y;
    }

    private static double[] selectParent(double[][] population, double[] fitness) {
        Random random = new Random();
        int index1 = random.nextInt(POPULATION_SIZE);
        int index2 = random.nextInt(POPULATION_SIZE);
        if (fitness[index1] > fitness[index2]) {
            return population[index1];
        } else {
            return population[index2];
        }
    }

    private static double[] crossover(double[] parent1, double[] parent2) {
        double[] child = new double[parent1.length];
        Random random = new Random();
        int crossoverPoint = random.nextInt(parent1.length);
        for (int i = 0; i < crossoverPoint; i++) {
            child[i] = parent1[i];
        }
        for (int i = crossoverPoint; i < parent1.length; i++) {
            child[i] = parent2[i];
        }
        return child;
    }

    private static double[] mutate(double[] child) {
        Random random = new Random();
        for (int i = 0; i < child.length; i++) {
            if (random.nextDouble() < MUTATION_RATE) {
                child[i] += random.nextDouble() * 2 - 1;
            }
        }
        return child;
    }

    private static double[] getBestIndividual(double[][] population, double[] fitness) {
        int index = 0;
        for (int i = 1; i < POPULATION_SIZE; i++) {
            if (fitness[i] > fitness[index]) {
                index = i;
            }
        }
        return population[index];
    }

    public static void main(String[] args) {
        int[][] points = {{0, 1}, {1, 4}, {2, 9}, {3, 16}, {4, 25}};
        double[] bestIndividual = geneticAlgorithm(points);
        System.out.println("Best individual: " + Arrays.toString(bestIndividual));
    }
}

#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>
#include <cmath>

using namespace std;

class Individual{
public:
    vector<int> chromosome;
    int fitness;
    Individual(int chromosomeLength){
        for(int i = 0; i < chromosomeLength; i++){
            chromosome.push_back(rand()%2);
        }
        fitness = -1;
    }
};

class Population{
public:
    vector<Individual> individuals;
    Population(int populationSize, int chromosomeLength){
        for(int i = 0; i < populationSize; i++){
            individuals.push_back(Individual(chromosomeLength));
        }
    }
};

class GeneticAlgorithm{
public:
    double mutationRate;
    int tournamentSize;
    bool elitism;
    GeneticAlgorithm(double mutationRate, int tournamentSize, bool elitism){
        this->mutationRate = mutationRate;
        this->tournamentSize = tournamentSize;
        this->elitism = elitism;
    }
    void evaluate(Individual &individual){
        int fitness = 0;
        for(int i = 0; i < individual.chromosome.size(); i++){
            if(individual.chromosome[i] == 1){
                fitness++;
            }
        }
        individual.fitness = fitness;
    }
    void evaluatePopulation(Population &population){
        for(int i = 0; i < population.individuals.size(); i++){
            evaluate(population.individuals[i]);
        }
    }
    Individual tournamentSelection(Population &population){
        Population tournamentPopulation(0, 0);
        for(int i = 0; i < tournamentSize; i++){
            int randomIndex = rand()%population.individuals.size();
            tournamentPopulation.individuals.push_back(population.individuals[randomIndex]);
        }
        Individual fittest = tournamentPopulation.individuals[0];
        for(int i = 0; i < tournamentPopulation.individuals.size(); i++){
            if(tournamentPopulation.individuals[i].fitness > fittest.fitness){
                fittest = tournamentPopulation.individuals[i];
            }
        }
        return fittest;
    }
    void crossover(Individual &parent1, Individual &parent2, Individual &child){
        int crossoverPoint = rand()%parent1.chromosome.size();
        for(int i = 0; i < crossoverPoint; i++){
            child.chromosome[i] = parent1.chromosome[i];
        }
        for(int i = crossoverPoint; i < parent1.chromosome.size(); i++){
            child.chromosome[i] = parent2.chromosome[i];
        }
    }
    void mutate(Individual &individual){
        for(int i = 0; i < individual.chromosome.size(); i++){
            if((double)rand()/RAND_MAX < mutationRate){
                individual.chromosome[i] = 1 - individual.chromosome[i];
            }
        }
    }
    Individual getFittest(Population &population){
        Individual fittest = population.individuals[0];
        for(int i = 0; i < population.individuals.size(); i++){
            if(population.individuals[i].fitness > fittest.fitness){
                fittest = population.individuals[i];
            }
        }
        return fittest;
    }
    Population evolvePopulation(Population &population){
        Population newPopulation(0, population.individuals[0].chromosome.size());
        if(elitism){
            Individual fittest = getFittest(population);
            newPopulation.individuals.push_back(fittest);
        }
        while(newPopulation.individuals.size() < population.individuals.size()){
            Individual parent1 = tournamentSelection(population);
            Individual parent2 = tournamentSelection(population);
            Individual child(0);
            crossover(parent1, parent2, child);
            mutate(child);
            newPopulation.individuals.push_back(child);
        }
        return newPopulation;
    }
};

int main(){
    srand(time(NULL));
    int populationSize = 100;
    int chromosomeLength = 50;
    int numGenerations= 200;
    double mutationRate = 0.01;
    int tournamentSize = 5;
    bool elitism = true;
    Population population(populationSize, chromosomeLength);
    GeneticAlgorithm ga(mutationRate, tournamentSize, elitism);
    for(int i = 0; i < numGenerations; i++){
        ga.evaluatePopulation(population);
        cout << "Generation " << i << ": Fittest individual has fitness " << ga.getFittest(population).fitness << endl;
        population = ga.evolvePopulation(population);
    }
    cout << "Solution found:" << endl;
    Individual fittest = ga.getFittest(population);
    for(int i = 0; i < fittest.chromosome.size(); i++){
        cout << fittest.chromosome[i];
    }
    cout << endl;
    return 0;
}

import openai
openai.api_key = "YOUR_API_KEY"

def generate_answer(prompt):
    response = openai.Completion.create(
        engine="text-davinci-002",
        prompt=prompt,
        max_tokens=1024,
        n=1,
        stop=None,
        temperature=0.5,
    )

    answer = response.choices[0].text.strip()
    return answer

import cv2

# загрузка изображения
image = cv2.imread("image.jpg")

# загрузка модели YOLO
net = cv2.dnn.readNetFromDarknet("yolov3.cfg", "yolov3.weights")

# получение имен слоев модели
layer_names = net.getLayerNames()
output_layers = [layer_names[i[0] - 1] for i in net.getUnconnectedOutLayers()]

# задание цветов для каждого класса объектов
colors = [[0, 0, 255], [0, 255, 0], [255, 0, 0]]

# обнаружение объектов на изображении
blob = cv2.dnn.blobFromImage(image, 1/255.0, (416, 416), swapRB=True, crop=False)
net.setInput(blob)
outs = net.forward(output_layers)

# подсчет количества людей
count = 0
for out in outs:
    for detection in out:
        scores = detection[5:]
        class_id = np.argmax(scores)
        confidence = scores[class_id]
        if class_id == 0 and confidence > 0.5:
            count += 1
            center_x = int(detection[0] * image.shape[1])
            center_y = int(detection[1] * image.shape[0])
            w = int(detection[2] * image.shape[1])
            h = int(detection[3] * image.shape[0])
            x = int(center_x - w/2)
            y = int(center_y - h/2)
            cv2.rectangle(image, (x,y), (x+w,y+h), colors[class_id], 2)

# вывод результата
print("Количество людей на изображении: ", count)
cv2.imshow("Detection result", image)
cv2.waitKey(0)

import cv2

# Загрузка файлов весов и конфигурации модели YOLOv3
net = cv2.dnn.readNet("yolov3.weights", "yolov3.cfg")

# Загрузка изображения
image = cv2.imread("image.jpg")

# Получение размеров изображения
height, width, _ = image.shape

# Создание списка имен классов
classes = []
with open("coco.names", "r") as f:
    classes = [line.strip() for line in f.readlines()]

# Получение индексов классов "человек"
person_indices = [classes.index("person")]

# Создание входного бинарного блоба для модели YOLOv3
blob = cv2.dnn.blobFromImage(image, 1 / 255.0, (416, 416), swapRB=True, crop=False)

# Запуск прямого прохода через модель для обнаружения объектов
net.setInput(blob)
layer_outputs = net.forward(net.getUnconnectedOutLayersNames())

# Инициализация списка обнаруженных фигур людей
people = []

# Проход по каждому выходному слою модели
for output in layer_outputs:
    # Проход по каждому обнаруженному объекту на выходном слое
    for detection in output:
        # Получение вероятности и индекса класса обнаруженного объекта
        scores = detection[5:]
        class_index = scores.argmax() + 5

        # Проверка, что обнаруженный объект - человек
        if class_index in person_indices:
            # Получение координат ограничивающего прямоугольника
            box = detection[0:4] * np.array([width, height, width, height])
            x_center, y_center, box_width, box_height = box.astype("int")
            x, y = int(x_center - (box_width / 2)), int(y_center - (box_height / 2))

            # Добавление ограничивающего прямоугольника в список людей
            people.append((x, y, int(box_width), int(box_height)))

# Отрисовка ограничивающих прямоугольников на изображении
for (x, y, w, h) in people:
    cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)

# Вывод количества найденных людей на изображении
cv2.putText(image, f"Number of people: {len(people)}", (10, height - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)

# Отображение изображения с ограничивающими прямоугольниками и количеством найденных людей
cv2.imshow("Image", image)
cv2.waitKey(0)

import cv2
import numpy as np
import tensorflow as tf

# Загрузка модели TensorFlow
model = tf.saved_model.load('path/to/saved_model')

# Загрузка изображения
img = cv2.imread('path/to/image')

# Преобразование изображения в массив numpy и нормализация
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img = cv2.resize(img, (300, 300))
img = img.astype('float32')
img = img / 255.0
img = np.expand_dims(img, axis=0)

# Обнаружение объектов на изображении
detections = model(img)

# Извлечение координат и классов обнаруженных объектов
boxes = detections['detection_boxes'][0].numpy()
classes = detections['detection_classes'][0].numpy().astype(np.uint32)
scores = detections['detection_scores'][0].numpy()

# Отображение результатов
for i in range(len(boxes)):
    if classes[i] == 1 and scores[i] > 0.5:
        ymin, xmin, ymax, xmax = boxes[i]
        xmin = int(xmin * img.shape[2])
        xmax = int(xmax * img.shape[2])
        ymin = int(ymin * img.shape[1])
        ymax = int(ymax * img.shape[1])
        cv2.rectangle(img, (xmin, ymin), (xmax, ymax), (0, 255, 0), 2)

# Вывод количества обнаруженных людей на изображении
num_people = np.count_nonzero(classes == 1)
cv2.putText(img, f'People: {num_people}', (10, img.shape[0] - 10), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)

# Отображение изображения с прямоугольниками и количеством людей
cv2.imshow('Image', img)
cv2.waitKey(0)
cv2.destroyAllWindows()

import torch
import torchvision
import cv2

# Загружаем предварительно обученную модель Faster R-CNN
model = torchvision.models.detection.fasterrcnn_resnet50_fpn(pretrained=True)

# Переводим модель в режим оценки (evaluation mode)
model.eval()

# Загружаем изображение
image = cv2.imread("Crowd-of-Diverse-People_800x528.jpg")

# Преобразуем изображение в тензор PyTorch
image_tensor = torchvision.transforms.functional.to_tensor(image)

# Добавляем размерность пакета (batch dimension) к тензору изображения
image_tensor = image_tensor.unsqueeze(0)

# Выполняем предсказание
with torch.no_grad():
    outputs = model(image_tensor)

# Получаем предсказанные координаты ограничительных прямоугольников
boxes = outputs[0]["boxes"].numpy()

# Получаем предсказанные оценки уверенности (scores)
scores = outputs[0]["scores"].numpy()

# Отфильтровываем ограничительные прямоугольники с низкими оценками
threshold = 0.5
boxes = boxes[scores >= threshold]

# Рисуем ограничительные прямоугольники на изображении
for box in boxes:
    x1, y1, x2, y2 = box.astype(int)
    cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)

# Вывод количества обнаруженных людей на изображении
num_people = len(boxes)
cv2.putText(image, f'People: {num_people}', (10, image.shape[0] - 10), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)

# Отображение изображения с прямоугольниками и количеством людей
cv2.imshow('Image', image)
cv2.waitKey(0)
cv2.destroyAllWindows()