dz.py

import castom_funcs
# ПЕРВЫЙ СЕМИНАР
# ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
# Задача 2: Найдите сумму цифр трехзначного числа.
# print("\033[H\033[J")


# def numbersSumm():
#     numb = int(input('Введите трехзначное число:  '))
#     if (999 > numb > 99):
#         first = numb // 100
#         second = numb // 10 % 10
#         third = numb % 10
#         print(f"{numb} -> {first + second + third} ({first} + {second} + {third})")
#     else:
#         print("Число не является трехзначным!")
#         return numbersSumm()


# numbersSumm()
# ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
# Задача 4: Петя, Катя и Сережа делают из бумаги журавликов. Вместе они сделали S журавликов. Сколько журавликов сделал каждый ребенок, если известно, что Петя и Сережа сделали одинаковое количество журавликов, а Катя сделала в два раза больше журавликов, чем Петя и Сережа вместе?
# print("\033[H\033[J")


# def findPartssOfSix():
#     summ = int(
#         input("Введите общее количество сделанных журавликов, кратное 6:  "))
#     if (summ % 6 == 0):
#         print(
#             f"{summ} -> {summ//6*2} (Катя), {summ//6} (Сережа), {summ//6} (Петя)")
#     else:
#         (print("Введенное число не кратно 6"))
#         return findPartssOfSix()


# findPartssOfSix()
# ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
# Задача 6: Вы пользуетесь общественным транспортом? Вероятно, вы расплачивались за проезд и получали билет с номером. Счастливым
# билетом называют такой билет с шестизначным номером, где сумма первых трех цифр равна сумме последних трех.
# Т.е. билет с номером 385916 – счастливый, т.к. 3+8+5=9+1+6. Вам требуется написать программу, которая проверяет счастливость билета.

#       print("\033[H\033[J")
# def findPartssOfSix():
#     numb = (input('Введите номер билета:  '))
#     if (len(numb) == 6):
#         firstPart = (int(numb[0]) + int((numb[1])) + int(numb[2]))
#         lastPart = (int(numb[3]) + int((numb[4])) + int(numb[5]))
#         if firstPart == lastPart:
#             print(f"{numb} -> Yes")
#         else:
#             print(f"{numb} -> No")
#     else:
#         print("Некорректный номер")
#         return findPartssOfSix()


# findPartssOfSix()
# ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
# Задача 8: Требуется определить, можно ли от шоколадки размером n × m долек отломить k долек,
# если разрешается сделать один разлом по прямой между дольками (то есть разломить шоколадку на два прямоугольника).

# print("\033[H\033[J")


# def chocolateSlise():

#     aSide = int(input("Введите длину первой стороны шоколадки: "))
#     bSide = int(input("Введите длину второй стороны шоколадки: "))
#     xSlise = int(input
#                  ("Введите желаемое количество долек прямого разлома шоколадки: "))
#     if (aSide == 1 and bSide == 1):
#         print("Такую шоколадку аккуратно не сломать!")
#         return chocolateSlise()
#     elif (aSide <= 0 or bSide <= 0):
#         print("Неправильные значения, таких шоколадок быть не может!")
#         return chocolateSlise()
#     else:

#         if (aSide > bSide):
#             if (xSlise % aSide == 0 or xSlise % bSide == 0 and aSide*bSide-bSide >= xSlise >= bSide):
#                 print(
#                     f"Шоколадка ({aSide}*{bSide}), дольки в отломанном кусочке ({xSlise}) -> yes")
#             else:
#                 print(
#                     f"Шоколадка ({aSide}*{bSide}), дольки в отломанном кусочке ({xSlise}) -> no")
#         else:
#             if (xSlise % aSide == 0 or xSlise % bSide == 0 and aSide*bSide-aSide >= xSlise >= aSide):
#                 print(
#                     f"Шоколадка ({aSide}*{bSide}), дольки в отломанном кусочке ({xSlise}) -> yes")
#             else:
#                 print(
#                     f"Шоколадка ({aSide}*{bSide}), дольки в отломанном кусочке ({xSlise}) -> no")


# chocolateSlise()
# # ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------


# ВТОРОЙ СЕМИНАР
# ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
# Задача 10: На столе лежат n монеток. Некоторые из них лежат вверх решкой, а некоторые – гербом. Определите минимальное число монеток, которые нужно перевернуть, чтобы все монетки были повернуты
# вверх одной и той же стороной. Выведите минимальное количество монет, которые нужно перевернуть.
# print("\033[H\033[J")
# coins = int(input('Введите количество монет: '))
# eagles = 0
# count = 1
# for i in range(coins):
#     money = int(
#         input(f'Если {count} монета - орел, то введите 1. Если решка - 0: '))
#     if (money == 1):
#         eagles += 1
#     count += 1
# if (eagles == coins):
#     print('Все монеты - орлы, ничего делать не нужно.')
# elif (eagles == 0):
#     print('Все монеты - решки, ничего делать не нужно.')
# elif (eagles >= coins//2+1):
#     print(f'Переверните {eagles} монет с орлом, и все монеты станут орлами.')
# elif (eagles <= coins//2):
#     print(
#         f'Переверните {coins-eagles} монет с решкой, и все монеты станут решками.')
# ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
# Задача 12: Петя и Катя – брат и сестра. Петя – студент, а Катя – школьница. Петя помогает Кате по математике. Он задумывает два натуральных числа X и Y(X, Y≤1000), а Катя должна их отгадать.
# Для этого Петя делает две подсказки. Он называет сумму этих чисел S и их произведение P. Помогите Кате отгадать задуманные Петей числа.
# print("\033[H\033[J")


# def findNumbers():
#     done = 0
#     summ = int(input('Введите сумму чисел: '))
#     product = int(input('Введите произведение чисел: '))
#     for i in range(1, 1001):
#         for j in range(1, 1001):
#             if (summ == i+j and product == i*j):
#                 print(f'Загаданные числа найдены: {i} и {j}')
#                 done = 1
#                 return 1
#     if (done == 0):
#         return 0


# answer = findNumbers()
# while (answer == 0):
#     print('Неверные данные!')
#     findNumbers()
# ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
# Задача 14: Требуется вывести все целые степени двойки (т.е. числа вида 2k), не превосходящие числа N.

# print("\033[H\033[J")

# limit = int(input('Введите число: '))
# count = 0
# while (2**count <= limit):
#     print(2**count)
#     count += 1
# ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------


# ТРЕТИЙ СЕМИНАР
# ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
# Задача 16: Требуется вычислить, сколько раз встречается некоторое число X в массиве A[1..N]. Пользователь в первой строке вводит натуральное число N – количество элементов в массиве.
# В последующих  строках записаны N целых чисел Ai. Последняя строка содержит число X
# print("\033[H\033[J")


# def howManyTimesFind():
#     size = int(input("Введите количество элементов массива: "))
#     print("Введите значения элементов массива (через пробел): ")
#     massive = list(map(int, (input().split())))

#     if (len(massive) != size):
#         print('Количество введенных элементов не совпадает с заданным размером массива!')
#         return howManyTimesFind()

#     else:
#         x = int(input("Введите искомый элемент "))
#         find = 0

#         for i in range(len(massive)):
#             if massive[i] == x:
#                 find += 1
#     print(f'Элемент {x} встречается {find} раз')


# howManyTimesFind()
# ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
# Задача 18: Требуется найти в массиве A[1..N] самый близкий по
# величине элемент к заданному числу X. Пользователь в первой строке
# вводит натуральное число N – количество элементов в массиве. В
# последующих строках записаны N целых чисел Ai
# . Последняя строка содержит число X

# print("\033[H\033[J")
# massive = [0]*int(input("Введите количество элементов массива: "))
# print('Введите значение элементов массива: ')
# for i in range(len(massive)):
#     print(f'{i+1})')
#     massive[i] = int(input())
# print(massive)

# x = int(input("Введите число, с которым будем сравнивать элементы списка: "))
# min = (x - massive[0])
# index = 0
# for i in range(1, len(massive)):
#     count = (x - massive[i])
#     if count < min:
#         min = count
#         index = i
# print(
#     f'Число {massive[index]} в списке наиболее близко по величине к числу {x}')
# ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
# Задача 20: В настольной игре Скрабл (Scrabble) каждая буква имеет определенную
# ценность. В случае с английским алфавитом очки распределяются так:
# ● A, E, I, O, U, L, N, S, T, R – 1 очко;
# ● D, G – 2 очка;
# ● B, C, M, P – 3 очка;
# ● F, H, V, W, Y – 4 очка;
# ● K – 5 очков;
# ● J, X – 8 очков;
# ● Q, Z – 10 очков.

# А русские буквы оцениваются так:
# ● А, В, Е, И, Н, О, Р, С, Т – 1 очко;
# ● Д, К, Л, М, П, У – 2 очка;
# ● Б, Г, Ё, Ь, Я – 3 очка;
# ● Й, Ы – 4 очка;
# ● Ж, З, Х, Ц, Ч – 5 очков;
# ● Ш, Э, Ю – 8 очков;
# ● Ф, Щ, Ъ – 10 очков

# print("\033[H\033[J")

# dictionary = {1: "AEIOULNSTRАВЕИНОРСТ",
#               2: "DGДКЛМПУ",
#               3: "BCMPБГЁЬЯ",
#               4: "FHVWYЙЫ",
#               5: "KЖЗХЦЧ",
#               8: "JXШЭЮ",
#               10: "QZФЩЪ"}
# word = input("Введите слово: ").upper()
# summ = 0
# for i in word:
#     for k, v in dictionary.items():
#         if i in v:
#             summ += k
# print(f"Стоимость слова: {summ} очков.")
# ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------


# ЧЕТВЕРТЫЙ СЕМИНАР
# ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
# Задача 22: Даны два неупорядоченных набора целых чисел (может быть, с повторениями). Выдать без повторений в порядке возрастания все те числа, которые встречаются в обоих наборах.
# Пользователь вводит 2 числа. n — кол-во элементов первого множества. m — кол-во элементов второго множества. Затем пользователь вводит сами элементы множеств.
# print("\033[H\033[J")


# def ListsWithOrder():
#     first = int(input('Введите количество чисел для первого набора: '))
#     second = int(input('Введите количество чисел для второго набора: '))
#     list1 = input('Введите элементы первого набора через пробел: ').split()
#     list2 = input('Введите элементы второго набора через пробел: ').split()
#     if (len(list1) != first or len(list2) != second):
#         print('Вы ввели неверные данные!')
#         return ListsWithOrder()
#     else:
#         collect1 = set(sorted(list1))
#         collect2 = set(sorted(list2))
#         print("\033[H\033[J")
#         print(*collect1.intersection(collect2))


# ListsWithOrder()
# ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
# Задача 24: В фермерском хозяйстве в Карелии выращивают чернику. Она растёт на круглой грядке, причём кусты высажены только по окружности.
# Таким образом, у каждого куста есть ровно два соседних. Всего на грядке растёт N кустов.
# Эти кусты обладают разной урожайностью, поэтому ко времени сбора на них выросло различное число ягод — на i-ом кусте выросло ai ягод.
# В этом фермерском хозяйстве внедрена система автоматического сбора черники. Эта система состоит из управляющего модуля и нескольких собирающих модулей.
# Собирающий модуль за один заход, находясь непосредственно перед некоторым кустом, собирает ягоды с этого куста и с двух соседних с ним.
# Напишите программу для нахождения максимального числа ягод, которое может собрать за один заход собирающий модуль, находясь перед некоторым кустом заданной во входном файле грядки.
# print("\033[H\033[J")
# n = int(input("Введите количество кустов черники на грядке: "))

# lst = list(map(int, input(
#     'введите количество ягод на каждом кусте через пробел: ').split()))
# maxsum = 0

# for i in range(n):
#     sbor = sum(lst[i:i+3])
#     print(sbor)
#     if sbor > maxsum:
#         maxsum = sbor
#     if lst[-2]+lst[-1]+lst[0] > maxsum:
#         maxsum = lst[-2]+lst[-1]+lst[0]
#     if lst[-1]+lst[0]+lst[1] > maxsum:
#         maxsum = lst[-1]+lst[0]+lst[1]
# print(maxsum)
# ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

# ПЯТЫЙ СЕМИНАР
# ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
# Задача 26:  Напишите программу, которая на вход принимает два числа A и B, и возводит число А в целую степень B с помощью рекурсии.
# print("\033[H\033[J")
# a = int(input('Введите число: '))
# b = int(input('Введите степень для числа: '))
# print(castom_funcs.degre_of_input_number(a, b, a))
# Задача 28: Напишите рекурсивную функцию sum(a, b), возвращающую сумму двух целых неотрицательных чисел. Из всех арифметических операций допускаются только +1 и -1. Также нельзя использовать циклы.
# print("\033[H\033[J")
# a = int(input('Введите первое число: '))
# b = int(input('Введите второе число: '))
# print(castom_funcs.summ_of_2numbs_but_step1(a, b))
# ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

# ШЕСТОЙ СЕМИНАР
# ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
# Задача 30:  Заполните массив элементами арифметической прогрессии. Её первый элемент, разность и количество элементов
# нужно ввести с клавиатуры. Формула для получения n-го члена прогрессии: an = a1 + (n-1) * d.
# Каждое число вводится с новой строки.
# print("\033[H\033[J")
# first = int(input("Ведите первый элемент: "))
# many = int(input("Введите количество элементов: "))
# d = int(input("Введите разность: "))

# count = 1
# while count <= many:
#     a = first + (count-1)*d
#     print(a, end=" ")
#     count += 1
# ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
# Задача 32: Определить индексы элементов массива (списка),
# значения которых принадлежат заданному диапазону (т.е. не
# меньше заданного минимума и не больше заданного
# максимума)
# Ввод: [-5, 9, 0, 3, -1, -2, 1,
#        4, -2, 10, 2, 0, -9, 8, 10, -9,
#        0, -5, -5, 7]
# Вывод: [1, 9, 13, 14, 19]
# print("\033[H\033[J")
# lst_1 = [-5, 9, 0, 3, -1, -2, 1, 4, -2, 10, 2, 0, -9, 8, 10, -9,  0, -5, -5, 7]
# mn = int(input("введите мин границу "))
# mx = int(input('Введите максимальную границу '))
# lst_2 = []
# for i in range(len(lst_1)):
#     if mn <= lst_1[i] <= mx:
#         lst_2.append(i)
# print(lst_2)
# ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

# СЕДЬМОЙ СЕМИНАР
# ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
# Задача 34:  Винни-Пух попросил Вас посмотреть, есть ли в его стихах ритм. Поскольку разобраться
# в его кричалках не настолько просто, насколько легко он их придумывает, Вам стоит написать программу.
# Винни-Пух считает, что ритм есть, если число слогов (т.е. число гласных букв) в каждой фразе стихотворения одинаковое.
# Фраза может состоять из одного слова, если во фразе несколько слов, то они разделяются дефисами. Фразы отделяются друг от
# друга пробелами. Стихотворение  Винни-Пух вбивает в программу с клавиатуры. В ответе напишите “Парам пам-пам”, если с ритмом
# все в порядке и “Пам парам”, если с ритмом все не в порядке

# *Пример:*

# **Ввод:** пара-ра-рам рам-пам-папам па-ра-па-да
#     **Вывод:** Парам пам-пам
# lst = input().lower().split()
# lst_res = []

# for phrase in lst:    # В визуалайзере все работает, но в терминале почему-то нет. Не понимаю, в чем проблема!
#     sum1 = 0
#     for i in phrase:
#         if  i in 'аоуеиыэяю':
#             sum1 += 1
#     lst_res.append(sum1)
# for i in range(len(lst_res)-1):
#     if lst_res[i] == lst_res[i+1]:
#          continue
#     else:
#         break
#         print('Пам парам')
# else:
#     print('Парам пам-пам')
# ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
# Задача 36: Напишите функцию print_operation_table(operation, num_rows=6, num_columns=6),
# которая принимает в качестве аргумента функцию, вычисляющую элемент по номеру строки и столбца.
# Аргументы num_rows и num_columns указывают число строк и столбцов таблицы,
# которые должны быть распечатаны. Нумерация строк и столбцов идет с единицы (подумайте, почему не с нуля).
# Примечание: бинарной операцией называется любая операция, у которой ровно два аргумента, как, например, у операции умножения.

# # *Пример:*

# **Ввод:** `print_operation_table(lambda x, y: x * y) `
# **Вывод:**
# 1 2 3 4 5 6

# 2 4 6 8 10 12
# 3 6 9 12 15 18
# 4 8 12 16 20 24
# 5 10 15 20 25 30
# 6 12 18 24 30 36


# def print_operation_table(operation, num_rows, num_сolumns):
#     arr=[[operation(i,j) for i in range(1,num_rows+1)] for j in range(1, num_сolumns+1)]
#     for i in arr:
#         print(*[f"{x:>3}"for x in i])
# line = int(input("Введите количество строк: "))
# columns = int(input("Введите количество столбцов: "))
# print_operation_table(lambda x,y: x*y,line,columns)
# ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------


# ВОСЬМОЙ СЕМИНАР
# ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
# Задача №49. Решение в группах
# Создать телефонный справочник с
# возможностью импорта и экспорта данных в
# формате .txt. Фамилия, имя, отчество, номер
# телефона - данные, которые должны находиться
# в файле.
# 1. Программа должна выводить данные
# 2. Программа должна сохранять данные в
# текстовом файле
# 3. Пользователь может ввести одну из
# характеристик для поиска определенной
# записи(Например имя или фамилию
# человека)
# 4. Использование функций. Ваша программа
# не должна быть линейной1


import os


def show_contacts(file_name):
    os.system('CLS')
    with open(file_name, 'r') as file:
        data = sorted(file.readlines())

        for contact in data:
            print(contact, end='')

    print("", end="\n")

    input('\npress any key')


def add_contact(file_name):
    os.system('CLS')
    with open(file_name, 'a') as file:
        res = ''
        res += input('Input a surname of contact: ') + ' '
        res += input('Input a name of contact: ') + ' '
        res += input('Input a phone number of contact: ')

        file.write('\n' + res)

    input('Contact was successfully added! Press any key for return')


def search_contact(file_name):
    os.system('CLS')
    target = input('Input a name of contact for searching: ')

    with open(file_name, 'r') as file:
        contacts = file.readlines()

        for contact in contacts:
            if target in contact:
                print(contact)
                break
        else:
            print('there is no contacts with this name.')

    input('press any key')


def drawing():
    print('1 - show contacts')
    print('2 - add contact')
    print('3 - search contact')
    print('4 - delete contact')
    print('5 - change contact')
    print('6 - exit')


def delete_data(file_name):
    os.system('CLS')
    with open(file_name, 'r', encoding='utf-8') as data:
        tel_book = data.read()
        print(tel_book)
        print('')
        index_delete_data = int(input("Input string number to delete:"))-1
        tel_book_lines = tel_book.split('\n')
        del_tel_book_lines = tel_book_lines[index_delete_data]
        tel_book_lines.pop(index_delete_data)
    with open(file_name, 'w', encoding='utf-8') as data:
        data.write('\n'.join(tel_book_lines))
    input('press any key')


def change_data(file_name):
    os.system('CLS')
    with open(file_name, 'r+', encoding='utf-8') as data:
        tel_book = data.read()
        print("Current contacts are:")
        print()
        print(tel_book)
        print('')
        index_delete_data = int(input("Input string number to change:"))-1
        tel_book_lines = tel_book.split('\n')
        del_tel_book_lines = tel_book_lines[index_delete_data]
        tel_book_lines.pop(index_delete_data)
        res = ''
        res += input('Input a new surname of contact: ') + ' '
        res += input('Input a new name of contact: ') + ' '
        res += input('Input a new phone number of contact: ')
        tel_book_lines.append(res)
        data.write('\n'.join(tel_book_lines))
    input('press any key')


def main(file_name):
    while True:
        os.system('CLS')
        drawing()
        user_choice = int(input("Input a number from 1 to 6: "))

        if user_choice == 1:
            show_contacts(file_name)
        elif user_choice == 2:
            add_contact(file_name)
        elif user_choice == 3:
            search_contact(file_name)
        elif user_choice == 4:
            delete_data(file_name)
        elif user_choice == 5:
            change_data(file_name)
        elif user_choice == 6:
            print('Have a nice day!')
            return


main('test.txt')
# ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------