import requests

available_currencies = {
    "USD": "Доллар США",
    "EUR": "Евро",
    "RUB": "Российский рубль",
    "KZT": "Казахский тенге",
    "UAH": "Украинская гривна",
}

def display_available_currencies():
    print("Доступные валюты:")
    for code, name in available_currencies.items():
        print(f"{code}: {name}")

def get_exchange_rate(base_currency, target_currency):
    url = f"https://api.exchangerate-api.com/v4/latest/{base_currency}"
    response = requests.get(url)
    data = response.json()
    rate = data["rates"].get(target_currency)

    if rate:
        return rate
    else:
        return None

def convert_currency(amount, base_currency, target_currency):
    rate = get_exchange_rate(base_currency, target_currency)
    if rate:
        return amount * rate
    else:
        print(f"Невозможно конвертировать {base_currency} в {target_currency}")

display_available_currencies()

amount = float(input("Введите сумму: "))
base_currency = input("Из какой валюты? (например, USD): ").upper()
target_currency = input("В какую валюту конвертировать? (например, RUB): ").upper()

converted_amount = convert_currency(amount, base_currency, target_currency)

if converted_amount:
    print(f"{amount} {base_currency} = {converted_amount:.2f} {target_currency}")

import curses
import random
import time

stdscr = curses.initscr()
curses.curs_set(0)
sh, sw = stdscr.getmaxyx()
w = curses.newwin(sh, sw, 0, 0)
w.keypad(1)
w.timeout(100)

cat_x = sw // 2
cat_y = sh - 1
fish_x = random.randint(1, sw - 1)
fish_y = 0
score = 0

while True:
    w.clear()
    w.border(0)
    w.addstr(cat_y, cat_x, "😺")
    w.addstr(fish_y, fish_x, "🐟")
    w.addstr(0, 2, f"Score: {score}")

    key = w.getch()
    if key == curses.KEY_LEFT and cat_x > 1:
        cat_x -= 1
    elif key == curses.KEY_RIGHT and cat_x < sw - 2:
        cat_x += 1

    fish_y += 1
    if fish_y == sh:
        fish_y = 0
        fish_x = random.randint(1, sw - 1)

    if fish_y == cat_y and fish_x == cat_x:
        score += 1
        fish_y = 0
        fish_x = random.randint(1, sw - 1)

    w.refresh()
    time.sleep(0.1)

curses.endwin()

import nltk
from nltk.chat.util import Chat, reflections
import random


pairs = [
    [
        r"Привет|Здравствуй|Добрый день",
        ["Привет! Как тебя зовут?", 
         "Здравствуйте! Как вас зовут?"]
    ],
    [
        r"Меня зовут (.*)",
        ["Приятно познакомиться, %1! Как я могу помочь вам сегодня?", 
         "Здравствуйте, %1! Как проходит ваш день?"]
    ],
    [
        r"(.*) как дела?",
        ["У меня всё отлично, спасибо! А у вас?", 
         "Отлично, как и всегда! А как у вас?"]
    ],
    [
        r"(.*) помощь(.*)",
        ["Конечно! В чем именно вам нужна помощь?", 
         "Я здесь, чтобы помочь вам. Какой вопрос у вас?"]
    ],
    [
        r"(.*) факт(.*)",
        ["Знаете ли вы, что дождевые черви имеют пять сердец?", 
         "Вот интересный факт: звезды могут быть на расстоянии до 13 миллиардов световых лет от нас!"]
    ],
    [
        r"(.*) шутка(.*)",
        ["Почему программисты не любят природу? Потому что в ней слишком много багов!",
         "Какой лучший способ описать программиста? Они делают как будто знают, что делают!"]
    ],
    [
        r"(.*) игра(.*)",
        ["Давайте сыграем в 'Угадай число'! Задумайте число от 1 до 10. Я буду пытаться угадать его. Готовы? (да/нет)"]
    ],
    [
        r"да",
        ["Отлично! Ваше число? (помните, от 1 до 10)"]
    ],
    [
        r"(.*)",
        ["Извините, я не понимаю. Можете переформулировать?", 
         "Пожалуйста, уточните ваш вопрос. Я здесь, чтобы помочь!"]
    ]
]


chatbot = Chat(pairs, reflections)

def chat():
    print("Добро пожаловать в чат! Пишите 'Выход', чтобы завершить.")
    
    user_name = ""
    while True:
        user_input = input("Вы: ")
        if user_input.lower() == 'выход':
            print("Чат завершен.")
            break
        
        bot_response = chatbot.respond(user_input)
        print(f"Бот: {bot_response}")

chat()

import cv2
import matplotlib.pyplot as plt


def face_recognition():
    face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
    video_capture = cv2.VideoCapture(0)

    while True:
        ret, frame = video_capture.read()
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        faces = face_cascade.detectMultiScale(gray, 1.1, 4)

        for (x, y, w, h) in faces:
            cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 0, 0), 2)

        plt.imshow(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
        plt.axis('off')
        plt.show(block=False)
        plt.pause(0.001)
        plt.clf()

        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

    video_capture.release()
    cv2.destroyAllWindows()

face_recognition()

import pygame
import random

pygame.init()

WIDTH, HEIGHT = 800, 600
WHITE = (255, 255, 255)
BLUE = (0, 0, 128)

screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Снегопад")

class Snowflake:
    def init(self):
        self.x = random.randint(0, WIDTH)
        self.y = random.randint(-HEIGHT, 0)
        self.size = random.randint(2, 6)
        self.speed = random.uniform(1, 3)
        self.wind = random.uniform(-0.5, 0.5)

    def fall(self):
        self.y += self.speed
        self.x += self.wind
        
        if self.y > HEIGHT:
            self.y = random.randint(-50, -10)
            self.x = random.randint(0, WIDTH)

        if self.x < 0:
            self.x = 0
        elif self.x > WIDTH:
            self.x = WIDTH

    def draw(self):
        pygame.draw.circle(screen, WHITE, (int(self.x), int(self.y)), self.size)

snowflakes = [Snowflake() for _ in range(200)]

running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    screen.fill(BLUE)
    for snowflake in snowflakes:
        snowflake.fall()
        snowflake.draw()

    pygame.display.flip()
    pygame.time.delay(10)

pygame.quit()

import tkinter as tk
from tkinter import messagebox

questions = [
    {
        "question": "Какое число должно быть следующим в ряду: 2, 4, 8, 16?",
        "options": ["32", "24", "20", "18"],
        "answer": "32"
    },
    {
        "question": "Найдите лишнее слово: Кошка, Собака, Ягода, Курица",
        "options": ["Кошка", "Собака", "Ягода", "Курица"],
        "answer": "Ягода"
    },
    {
        "question": "Продолжите последовательность: 1, 1, 2, 3, 5, 8, ?",
        "options": ["10", "12", "13", "21"],
        "answer": "13"
    },
    {
        "question": "Сколько букв в русском алфавите?",
        "options": ["30", "31", "32", "33"],
        "answer": "33"
    },
    {
        "question": "Как называется фигура с 8 сторонами?",
        "options": ["Гексагон", "Гептагон", "Октагон", "Декагон"],
        "answer": "Октагон"
    }
]

class IQTestApp:
    def init(self, root):
        self.root = root
        self.root.title("IQ Test")
        self.score = 0
        self.current_question = 0
        self.setup_ui()

    def setup_ui(self):
        self.question_label = tk.Label(self.root, text="", wraplength=400, font=("Arial", 14))
        self.question_label.pack(pady=20)

        self.option_buttons = []
        for i in range(4):
            btn = tk.Button(self.root, text="", width=30, command=lambda idx=i: self.check_answer(idx))
            btn.pack(pady=5)
            self.option_buttons.append(btn)

        self.next_button = tk.Button(self.root, text="Следующий вопрос", command=self.next_question)
        self.next_button.pack(pady=20)
        
        self.display_question()

    def display_question(self):
        q = questions[self.current_question]
        self.question_label.config(text=q["question"])
        for i, option in enumerate(q["options"]):
            self.option_buttons[i].config(text=option)

    def check_answer(self, selected_idx):
        selected_option = questions[self.current_question]["options"][selected_idx]
        if selected_option == questions[self.current_question]["answer"]:
            self.score += 1
        self.next_question()

    def next_question(self):
        self.current_question += 1
        if self.current_question < len(questions):
            self.display_question()
        else:
            iq_score = 80 + self.score * 10
            messagebox.showinfo("Результат", f"Вы ответили правильно на {self.score} из {len(questions)} вопросов.\nВаш IQ: {iq_score}")
            self.root.quit()

root = tk.Tk()
app = IQTestApp(root)
root.mainloop()

import pygame
import time

WIDTH, HEIGHT = 800, 200
text = 'Любой текст'

pygame.init()
screen = pygame.display.set_mode((WIDTH, HEIGHT))
font = pygame.font.Font(None, 50)
clock = pygame.time.Clock()

displayed_text = ''
i = 0

running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    if i < len(text):
        displayed_text += text[i]
        i += 1
        screen.fill((0, 0, 0))
        rendered_text = font.render(displayed_text, True, (255, 255, 255))
        screen.blit(rendered_text, (50, HEIGHT // 2))
        pygame.display.flip()
        time.sleep(0.1)

    clock.tick(30)

pygame.quit()

import cv2
import numpy as np
import pyautogui


def record_screen(output_file='video.mp4', fps=20.0):
    screen_size = pyautogui.size()
    
    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
    
    out = cv2.VideoWriter(output_file, fourcc, fps, screen_size)
    
    print("Запись началась. Нажмите 'q', чтобы остановить.")
    
    while True:
        screenshot = pyautogui.screenshot()
        frame = cv2.cvtColor(np.array(screenshot), cv2.COLOR_RGB2BGR)
        
        cv2.imshow("Recording...", frame)
        
        out.write(frame)
        
        if cv2.waitKey(1) & 0xFF == ord('q'):
            print("Запись завершена")
            break
        
    out.release()
    cv2.destroyAllWindows()

if name == "main":
    record_screen()

import tkinter as tk
from tkinter import messagebox
import pyautogui


def take_screenshot():
    try:
        filename = "screenshot.png"
        
        screenshot = pyautogui.screenshot()
        screenshot.save(filename)
        
        messagebox.showinfo(f"Скриншот сохранен как {filename}")
        
    except Exception as e:
        messagebox.showerror("Ошибка", f"Не удалось сделать скриншот: {e}")


root = tk.Tk()
root.title("Скриншотер")
root.geometry("300x200")


btn_screenshot = tk.Button(root, text="Скрин", command=take_screenshot, font=("Arial", 24), bg="lightblue", width=10, height=2)
btn_screenshot.pack(pady=50)


root.mainloop()

import re


def check_password_strength(password):
    if len(password) < 8:
        return "Пароль слишком короткий. Минимальная длина - 8 символов."
    
    if not re.search(r'[A-Z]', password):
        return "Пароль должен содержать хотя бы одну заглавную букву."
    
    if not re.search(r'[a-z]', password):
        return "Пароль должен содержать хотя бы одну строчную букву."
    
    if not re.search(r'\d', password):
        return "Пароль должен содержать хотя бы одну цифру."
    
    if not re.search(r'[@$!%*?&]', password):
        return "Пароль должен содержать хотя бы один специальный символ (например, @$!%*?&)."
    
    common_words = ["password", "123456", "qwerty"]
    
    if any(word in password.lower() for word in common_words):
        return "Пароль не должен содержать распространённые слова или последовательности символов."
    
    return "Пароль надежный"


password = input("Введите пароль: ")
result = check_password_strength(password)
print(result)

from tkinter import *
import time
import pyautogui
import threading

tk = Tk()

tk.geometry('200x200')
tk.title('спамер')


def spam():
    while True:
        pyautogui.typewrite('77')
        pyautogui.press('7')
        time.sleep(1)


def start_spam():
    thread = threading.Thread(target=spam)
    thread.daemon = True
    thread.start()

button = Button(tk, text='ЗАПУСК СПАМЕРА', font=('Arial', 14), command=start_spam)
button.pack(pady=20)

tk.mainloop()

import tkinter as tk
from pynput import keyboard

class KeyPressCounterApp:
    def init(self, root):
        self.root = root
        self.root.title("Счётчик нажатий клавиш")
        self.root.geometry("400x300")
        
        self.key_count = 0

        self.label = tk.Label(self.root, text="Нажатий: 0", font=("Arial", 30))
        self.label.pack(pady=80)

        self.listener = keyboard.Listener(on_press=self.on_key_press)
        self.listener.start()

        self.root.protocol("WM_DELETE_WINDOW", self.on_close)


    def on_key_press(self, key):
        self.key_count += 1
        self.label.config(text=f"Нажатий: {self.key_count}")


    def on_close(self):
        self.listener.stop()
        self.root.destroy()

if name == "main":
    root = tk.Tk()
    app = KeyPressCounterApp(root)
    root.mainloop()