Розділ 2: Числа та математика

Вітаю тебе у другому розділі нашого курсу! Ти вже зробив перші кроки у світі програмування на Python. Тепер давай дізнаємося, як Python може допомогти нам з математикою та числами.

Математика в програмуванні — це як супергерой! Вона допомагає:

• Створювати ігри з підрахунком очок
• Розробляти програми, які можуть швидко обчислювати
• Вирішувати складні завдання легко та швидко
• Програмувати роботів, які вміють вимірювати відстань

У цьому розділі ти дізнаєшся, як Python працює з числами та математичними операціями. Це буде весело і практично!

Готовий стати програмістом-математиком? Поїхали!

Пірнемо у світ чисел і математики в Python. Ти дізнаєшся, як Python працює з різними типами чисел, як виконувати математичні операції та вирішувати цікаві задачі за допомогою коду.

Різні типи чисел

У програмуванні, як і в математиці, ми працюємо з різними типами чисел. В Python є два основних типи:

1. Цілі числа (integers) - це числа без дробової частини, як 1, 42, -7, 1000.
2. Дробові числа (floats) - це числа з десятковою крапкою, як 3.14, 2.5, -0.5.

Подивимось, як це виглядає:

# Цілі числа
age = 10
temperature = -5
population = 7900000000

# Дробові числа
height = 1.75
weight = 45.5
pi = 3.14159

Як Python розуміє числа?

Коли ти пишеш число в коді, Python автоматично визначає його тип. Ось як ти можеш перевірити тип числа:

# Перевірка типу числа
x = 5
print(type(x))  # Виведе: <class 'int'>

y = 3.14
print(type(y))  # Виведе: <class 'float'>

Чим відрізняються цілі та дробові числа?

Цілі числа (int):

• Не мають десяткової крапки
• Можуть бути додатними, від'ємними або нулем
• У Python цілі числа можуть бути дуже великими (майже необмежено!)

Дробові числа (float):

• Мають десяткову крапку або записані в науковій нотації
• Наприклад: 3.14, 0.5, 2.0, 1e6 (1 мільйон)
• Мають обмежену точність (іноді можуть давати невеличкі похибки)

Перетворення між типами

Ти можеш легко перетворювати числа з одного типу в інший:

# З цілого в дробове
x = 5
x_float = float(x)
print(x_float)  # Виведе: 5.0

# З дробового в ціле (відкидає дробову частину!)
y = 7.8
y_int = int(y)
print(y_int)  # Виведе: 7

Зверни увагу, що при перетворенні дробового числа в ціле, Python просто відкидає дробову частину, а не округлює число. Тобто int(7.8) дасть 7, а не 8.

Числа в різних системах числення

В Python ти також можеш використовувати числа в різних системах числення:

# Десяткове число (звичайне)
decimal = 42
print(decimal)  # 42

# Двійкове число (починається з 0b)
binary = 0b101010
print(binary)  # 42

# Вісімкове число (починається з 0o)
octal = 0o52
print(octal)  # 42

# Шістнадцяткове число (починається з 0x)
hexadecimal = 0x2A
print(hexadecimal)  # 42

Всі ці числа представляють одне й те саме значення (42), але записані по-різному!

Спробуй сам:

1. Створи змінні з різними типами чисел та перевір їх тип за допомогою type()
2. Перетвори ціле число на дробове і навпаки
3. Спробуй записати якесь число в двійковій або шістнадцятковій системі

У Python ти можеш використовувати всі звичайні математичні операції, які вивчав у школі, і навіть більше! Давай розглянемо їх детальніше.

Основні математичні операції

Давай розглянемо кожну операцію детальніше:

Додавання і віднімання

Додавання і віднімання працюють точно так само, як ти звик:

# Додавання
sum = 5 + 3
print(sum)  # 8

# Віднімання
difference = 10 - 4
print(difference)  # 6

Множення

Множення чисел використовує символ зірочки *:

# Множення
product = 6 * 7
print(product)  # 42

# Множення з дробами
decimal_product = 1.5 * 2.5
print(decimal_product)  # 3.75

Ділення

В Python є два типи ділення:

# Звичайне ділення (завжди повертає дробове число)
division = 20 / 5
print(division)  # 4.0

# Навіть якщо ділиться без остачі, результат все одно дробовий
another_division = 10 / 2
print(another_division)  # 5.0

# Цілочисельне ділення (відкидає дробову частину)
integer_division = 7 // 2
print(integer_division)  # 3

# Остача від ділення
remainder = 7 % 2
print(remainder)  # 1

Цілочисельне ділення та остача

• // (подвійний слеш) - це цілочисельне ділення, яке повертає тільки цілу частину результату
• % (знак відсотка) - це операція знаходження остачі від ділення

Наприклад, якщо поділити 7 на 2:

• 7 // 2 = 3 (тому що 2 * 3 = 6, і це найбільше ціле число, яке можна отримати)
• 7 % 2 = 1 (тому що 7 = 2 * 3 + 1, і 1 - це остача)

Піднесення до степеня

Для піднесення числа до степеня використовуємо подвійну зірочку **:

# 2 в степені 3 (2³)
power = 2 ** 3
print(power)  # 8

# 5 в степені 2 (5²)
square = 5 ** 2
print(square)  # 25

# Корінь квадратний (піднесення до степеня 0.5)
square_root = 16 ** 0.5
print(square_root)  # 4.0

Пріоритет операцій

Як і в математиці, Python дотримується певного порядку виконання операцій:

1. Дужки ()
2. Піднесення до степеня **
3. Множення *, ділення /, цілочисельне ділення //, остача %
4. Додавання +, віднімання -

Наприклад:

# Без дужок
result1 = 2 + 3 * 4
print(result1)  # 14 (спочатку 3 * 4 = 12, потім 2 + 12 = 14)

# З дужками
result2 = (2 + 3) * 4
print(result2)  # 20 (спочатку 2 + 3 = 5, потім 5 * 4 = 20)

Комбінування операцій

Ти можеш об'єднувати різні операції в одному виразі:

# Складний вираз
complex_expression = (10 + 5) * 2 - 8 / 4
print(complex_expression)  # 28.0

Давай проаналізуємо цей вираз крок за кроком:

1. (10 + 5) = 15
2. 15 * 2 = 30
3. 8 / 4 = 2.0
4. 30 - 2.0 = 28.0

Операції присвоєння

Python має спеціальні оператори, які дозволяють одночасно виконувати операцію та оновлювати змінну:

# Звичайне присвоєння
x = 10

# Додати до поточного значення
x += 5  # Те саме, що x = x + 5
print(x)  # 15

# Відняти від поточного значення
x -= 3  # Те саме, що x = x - 3
print(x)  # 12

# Помножити поточне значення
x *= 2  # Те саме, що x = x * 2
print(x)  # 24

# Поділити поточне значення
x /= 4  # Те саме, що x = x / 4
print(x)  # 6.0

Математичні вирази з різними типами чисел

Коли ти змішуєш цілі та дробові числа в одному виразі, Python автоматично перетворює результат на дробове число:

# Ціле + ціле = ціле
a = 5 + 3
print(a, type(a))  # 8 <class 'int'>

# Ціле + дробове = дробове
b = 5 + 3.0
print(b, type(b))  # 8.0 <class 'float'>

# Ділення завжди дає дробове число
c = 10 / 5
print(c, type(c))  # 2.0 <class 'float'>

Спробуй сам:

1. Створи програму, яка обчислює площу прямокутника (довжина * ширина)
2. Напиши код, який обчислює середнє значення трьох чисел
3. Напиши програму, яка конвертує секунди у години та хвилини

А тепер давай познайомимося з більш складними математичними операціями. Python має спеціальний модуль math, який містить багато корисних математичних функцій.

Модуль math

Щоб використовувати функції з модуля math, треба спочатку його імпортувати:

import math

Після цього ти можеш використовувати різні математичні функції, наприклад:

Константи

import math

# Число пі
print(math.pi)  # 3.141592653589793

# Число e (основа натурального логарифма)
print(math.e)  # 2.718281828459045

Округлення чисел

Python має кілька способів округлення чисел:

# Звичайна функція round (вбудована в Python)
x = 3.75
print(round(x))      # 4  (округлення до найближчого цілого)
print(round(x, 1))   # 3.8 (округлення до 1 знака після коми)

# Функції з модуля math
import math

print(math.floor(3.75))  # 3  (округлення вниз)
print(math.ceil(3.75))   # 4  (округлення вгору)
print(math.trunc(3.75))  # 3  (відкидання дробової частини)

Корені та степені

import math

# Квадратний корінь
print(math.sqrt(16))      # 4.0
print(16 ** 0.5)# 4.0 (альтернативний спосіб)

# Інші степені
print(math.pow(2, 3))     # 8.0 (2 в степені 3)
print(2 ** 3)   # 8 (альтернативний спосіб)

Тригонометричні функції

import math

# Тригонометричні функції (аргументи в радіанах)
print(math.sin(math.pi / 2))  # 1.0 (синус 90 градусів)
print(math.cos(math.pi))      # -1.0 (косинус 180 градусів)
print(math.tan(math.pi / 4))  # 1.0 (тангенс 45 градусів)

# Перетворення градусів у радіани
angle_degrees = 90
angle_radians = math.radians(angle_degrees)
print(angle_radians)  # 1.5707963267948966 (це π/2)

# Перетворення радіанів у градуси
print(math.degrees(math.pi))  # 180.0

Логарифми

import math

# Натуральний логарифм (за основою e)
print(math.log(math.e))  # 1.0

# Десятковий логарифм
print(math.log10(100))   # 2.0

# Логарифм за довільною основою
print(math.log(8, 2))    # 3.0 (логарифм 8 за основою 2)

Абсолютне значення (модуль)

# Вбудована функція abs
print(abs(-5))  # 5

# Модуль з math
import math
print(math.fabs(-5.2))  # 5.2 (завжди повертає float)

Факторіал

import math

# Факторіал числа (n!)
print(math.factorial(5))  # 120 (5! = 5 * 4 * 3 * 2 * 1)

Приклади використання

Давай розглянемо кілька практичних прикладів:

Обчислення гіпотенузи прямокутного трикутника (теорема Піфагора)

import math

a = 3  # Перший катет
b = 4  # Другий катет

# Гіпотенуза = корінь з (a² + b²)
c = math.sqrt(a**2 + b**2)
print(f"Гіпотенуза трикутника з катетами {a} і {b} дорівнює {c}")  # 5.0

Обчислення площі круга

import math

radius = 5  # Радіус круга
area = math.pi * radius**2

print(f"Площа круга з радіусом {radius} дорівнює {area:.2f}")  # Приблизно 78.54

Обчислення відстані між точками на площині

import math

# Координати першої точки
x1, y1 = 1, 2

# Координати другої точки
x2, y2 = 4, 6

# Формула відстані: корінь з ((x2-x1)² + (y2-y1)²)
distance = math.sqrt((x2 - x1)**2 + (y2 - y1)**2)

print(f"Відстань між точками: {distance:.2f}")  # Приблизно 5.00

Спробуй сам:

1. Напиши програму для обчислення об'єму сфери (V = 4/3 * π * r³)
2. Створи програму, яка обчислює sin і cos для кута 45 градусів
3. Напиши код, який знаходить всі корені квадратного рівняння ax² + bx + c = 0

У програмуванні часто потрібно генерувати випадкові числа — для ігор, симуляцій, тестування чи інших цілей. Python має спеціальний модуль random для цього.

Модуль random

Щоб використовувати функції з модуля random, треба спочатку його імпортувати:

import random

Основні функції для генерації випадкових чисел

Випадкове число в діапазоні від 0 до 1

import random

# Випадкове дробове число від 0 до 1
random_float = random.random()
print(random_float)  # Наприклад: 0.7134543532

Випадкове ціле число в заданому діапазоні

import random

# Випадкове ціле число від 1 до 10 (включно)
random_int = random.randint(1, 10)
print(random_int)  # Наприклад: 7

Випадкове дробове число у вказаному діапазоні

import random

# Випадкове дробове число від 1.0 до 5.0
random_range = random.uniform(1.0, 5.0)
print(random_range)  # Наприклад: 3.2157123

Випадковий вибір зі списку

import random

# Список кольорів
colors = ["червоний", "синій", "зелений", "жовтий", "фіолетовий"]

# Випадковий вибір одного кольору
random_color = random.choice(colors)
print(random_color)  # Наприклад: зелений

Перемішування елементів списку

import random

# Список чисел
numbers = [1, 2, 3, 4, 5]

# Перемішуємо список
random.shuffle(numbers)
print(numbers)  # Наприклад: [3, 1, 5, 2, 4]

Практичні приклади використання випадкових чисел

Симуляція кидання гральних кубиків

import random

def roll_dice():
    return random.randint(1, 6)

# Кидаємо два кубики
dice1 = roll_dice()
dice2 = roll_dice()

print(f"Перший кубик: {dice1}")
print(f"Другий кубик: {dice2}")
print(f"Загальна сума: {dice1 + dice2}")

Проста гра "Вгадай число"

import random

# Комп'ютер загадує число від 1 до 10
secret_number = random.randint(1, 10)

# Користувач намагається вгадати
guess = int(input("Вгадай число від 1 до 10: "))

if guess == secret_number:
    print("Вітаю! Ти вгадав!")
else:
    print(f"На жаль, не вгадав. Загадане число було {secret_number}.")

Генерація випадкового пароля

import random
import string

# Визначаємо, які символи можуть бути в паролі
characters = string.ascii_letters + string.digits
# (це a-z, A-Z, 0-9)

# Генеруємо пароль з 8 символів
password = ""
for i in range(8):
    password += random.choice(characters)

print(f"Випадковий пароль: {password}")

Симуляція підкидання монети

import random

# Підкидаємо монету 10 разів
for i in range(10):
    # 1 - орел, 0 - решка
    coin = random.randint(0, 1)
    if coin == 1:
        print("Орел")
    else:
        print("Решка")

Спробуй сам:

1. Створи програму, яка симулює лотерею (вибирає 6 випадкових чисел від 1 до 49)
2. Напиши гру "Камінь, ножиці, папір" (комп'ютер робить випадковий вибір)
3. Створи програму, яка генерує випадкове питання з математики для тренування

Розрахунок площі та об'єму

Програмування чудово підходить для швидкого розрахунку геометричних величин. Давай розглянемо, як обчислювати площі та об'єми різних фігур!

Площа та периметр різних фігур

import math

# Площа прямокутника
def rectangle_area(length, width):
    area = length * width
    perimeter = 2 * (length + width)
    return area, perimeter

# Площа трикутника за формулою Герона
def triangle_area(a, b, c):
    # Півпериметр
    s = (a + b + c) / 2
    # Площа за формулою Герона
    area = math.sqrt(s * (s - a) * (s - b) * (s - c))
    perimeter = a + b + c
    return area, perimeter

# Площа та довжина кола
def circle_area(radius):
    area = math.pi * radius**2
    circumference = 2 * math.pi * radius
    return area, circumference

# Приклад використання
length = 5
width = 3
rect_area, rect_perimeter = rectangle_area(length, width)
print(f"Прямокутник {length}x{width}")
print(f"Площа: {rect_area}")
print(f"Периметр: {rect_perimeter}")

radius = 4
circle_area, circle_circumference = circle_area(radius)
print(f"\nКоло з радіусом {radius}")
print(f"Площа: {circle_area:.2f}")
print(f"Довжина кола: {circle_circumference:.2f}")

# Трикутник зі сторонами 3, 4, 5 (єгипетський трикутник)
a, b, c = 3, 4, 5
tri_area, tri_perimeter = triangle_area(a, b, c)
print(f"\nТрикутник зі сторонами {a}, {b}, {c}")
print(f"Площа: {tri_area}")
print(f"Периметр: {tri_perimeter}")

Об'єми тривимірних фігур

import math

# Об'єм куба
def cube_volume(side):
    volume = side**3
    surface_area = 6 * side**2
    return volume, surface_area

# Об'єм прямокутного паралелепіпеда
def rectangular_prism_volume(length, width, height):
    volume = length * width * height
    surface_area = 2 * (length * width + length * height + width * height)
    return volume, surface_area

# Об'єм циліндра
def cylinder_volume(radius, height):
    volume = math.pi * radius**2 * height
    surface_area = 2 * math.pi * radius * (radius + height)
    return volume, surface_area

# Об'єм сфери
def sphere_volume(radius):
    volume = (4/3) * math.pi * radius**3
    surface_area = 4 * math.pi * radius**2
    return volume, surface_area

# Приклад використання
side = 5
cube_vol, cube_sa = cube_volume(side)
print(f"Куб зі стороною {side}")
print(f"Об'єм: {cube_vol}")
print(f"Площа поверхні: {cube_sa}")

radius = 3
height = 7
cyl_vol, cyl_sa = cylinder_volume(radius, height)
print(f"\nЦиліндр з радіусом {radius} і висотою {height}")
print(f"Об'єм: {cyl_vol:.2f}")
print(f"Площа поверхні: {cyl_sa:.2f}")

radius = 4
sphere_vol, sphere_sa = sphere_volume(radius)
print(f"\nСфера з радіусом {radius}")
print(f"Об'єм: {sphere_vol:.2f}")
print(f"Площа поверхні: {sphere_sa:.2f}")

Конвертація одиниць вимірювання

У різних країнах використовують різні одиниці вимірювання. За допомогою Python можна легко конвертувати їх!

Конвертація довжини

# Конвертація різних одиниць довжини

# Функції для конвертації з базової одиниці (метри) в інші
def meters_to_kilometers(meters):
    return meters / 1000

def meters_to_centimeters(meters):
    return meters * 100

def meters_to_millimeters(meters):
    return meters * 1000

def meters_to_miles(meters):
    return meters * 0.000621371

def meters_to_feet(meters):
    return meters * 3.28084

def meters_to_inches(meters):
    return meters * 39.3701

# Універсальний конвертер довжини
def convert_length(value, from_unit, to_unit):
    # Спочатку переводимо в метри (базова одиниця)
    if from_unit == "км": meters = value * 1000
    elif from_unit == "м": meters = value
    elif from_unit == "см": meters = value / 100
    elif from_unit == "мм": meters = value / 1000
    elif from_unit == "милі": meters = value / 0.000621371
    elif from_unit == "фути": meters = value / 3.28084
    elif from_unit == "дюйми": meters = value / 39.3701
    else: return "Невідома вхідна одиниця"
    
    # Потім конвертуємо з метрів у потрібну одиницю
    if to_unit == "км": return meters / 1000
    elif to_unit == "м": return meters
    elif to_unit == "см": return meters * 100
    elif to_unit == "мм": return meters * 1000
    elif to_unit == "милі": return meters * 0.000621371
    elif to_unit == "фути": return meters * 3.28084
    elif to_unit == "дюйми": return meters * 39.3701
    else: return "Невідома вихідна одиниця"

# Приклад використання
value = 5
from_unit = "км"
to_unit = "милі"
result = convert_length(value, from_unit, to_unit)
print(f"{value} {from_unit} = {result:.4f} {to_unit}")

# Інтерактивний конвертер
def interactive_length_converter():
    print("Конвертер довжини")
    print("Доступні одиниці: км, м, см, мм, милі, фути, дюйми")
    
    value = float(input("Введи значення: "))
    from_unit = input("З якої одиниці конвертувати: ")
    to_unit = input("В яку одиницю конвертувати: ")
    
    result = convert_length(value, from_unit, to_unit)
    print(f"{value} {from_unit} = {result:.4f} {to_unit}")

# Розкоментуй рядок нижче, щоб запустити інтерактивний конвертер
# interactive_length_converter()

Конвертація ваги і температури

# Конвертація ваги і температури

# Функції для конвертації ваги
def kg_to_pounds(kg):
    return kg * 2.20462

def pounds_to_kg(pounds):
    return pounds / 2.20462

def kg_to_grams(kg):
    return kg * 1000

def grams_to_kg(grams):
    return grams / 1000

# Функції для конвертації температури
def celsius_to_fahrenheit(celsius):
    return celsius * 9/5 + 32

def fahrenheit_to_celsius(fahrenheit):
    return (fahrenheit - 32) * 5/9

def celsius_to_kelvin(celsius):
    return celsius + 273.15

def kelvin_to_celsius(kelvin):
    return kelvin - 273.15

# Приклади використання
weight_kg = 70
print(f"{weight_kg} кг = {kg_to_pounds(weight_kg):.2f} фунтів")

weight_pounds = 150
print(f"{weight_pounds} фунтів = {pounds_to_kg(weight_pounds):.2f} кг")

temp_c = 25
print(f"{temp_c}°C = {celsius_to_fahrenheit(temp_c):.1f}°F")
print(f"{temp_c}°C = {celsius_to_kelvin(temp_c):.2f} K")

temp_f = 98.6
print(f"{temp_f}°F = {fahrenheit_to_celsius(temp_f):.1f}°C")

Обчислення віку, часу тощо

У програмуванні часто потрібно робити обчислення, пов'язані з часом та датами. Ось кілька корисних прикладів:

Робота з часом

import time
import datetime

# Поточний час
current_time = time.time()  # Час у секундах з 1 січня 1970 року
print(f"Поточний час (в секундах з початку епохи): {current_time}")

# Поточна дата і час у зрозумілому форматі
now = datetime.datetime.now()
print(f"Поточна дата і час: {now}")
print(f"Рік: {now.year}, Місяць: {now.month}, День: {now.day}")
print(f"Година: {now.hour}, Хвилина: {now.minute}, Секунда: {now.second}")

# Форматування дати і часу
formatted_date = now.strftime("%d.%m.%Y")  # День.Місяць.Рік
formatted_time = now.strftime("%H:%M:%S")  # Година:Хвилина:Секунда
print(f"Форматована дата: {formatted_date}")
print(f"Форматований час: {formatted_time}")

# Конвертація секунд у дні, години, хвилини і секунди
def seconds_to_dhms(seconds):
    days = seconds // (24 * 3600)
    seconds %= (24 * 3600)
    hours = seconds // 3600
    seconds %= 3600
    minutes = seconds // 60
    seconds %= 60
    return days, hours, minutes, seconds

total_seconds = 123456
days, hours, minutes, seconds = seconds_to_dhms(total_seconds)
print(f"{total_seconds} секунд = {days} днів, {hours} годин, {minutes} хвилин, {seconds} секунд")

Обчислення віку і різниці між датами

from datetime import datetime, timedelta

# Створення дати
birthday = datetime(2010, 5, 15)  # 15 травня 2010 року
print(f"День народження: {birthday.strftime('%d.%m.%Y')}")

# Поточна дата
today = datetime.now()
print(f"Сьогодні: {today.strftime('%d.%m.%Y')}")

# Вік у роках (приблизно)
age_years = today.year - birthday.year
# Корекція, якщо день народження цього року ще не настав
if (today.month, today.day) < (birthday.month, birthday.day):
    age_years -= 1
print(f"Вік: {age_years} років")

# Різниця між датами у днях
delta = today - birthday
print(f"Кількість днів з дня народження: {delta.days}")

# Додавання днів до дати
future_date = today + timedelta(days=30)
print(f"Дата через 30 днів: {future_date.strftime('%d.%m.%Y')}")

# Обчислення дати через певну кількість місяців 
# (треба враховувати різну кількість днів у місяцях)
def add_months(date, months):
    month = date.month - 1 + months
    year = date.year + month // 12
    month = month % 12 + 1
    day = min(date.day, [31, 29 if year % 4 == 0 and (year % 100 != 0 or year % 400 == 0) else 28, 
                         31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month-1])
    return date.replace(year=year, month=month, day=day)

future_month = add_months(today, 3)
print(f"Дата через 3 місяці: {future_month.strftime('%d.%m.%Y')}")

Створення таймера та секундоміра

import time

# Простий таймер зворотного відліку
def countdown_timer(seconds):
    print(f"Таймер на {seconds} секунд запущено!")
    
    for i in range(seconds, 0, -1):
        print(f"Залишилось {i} сек...", end="\r")
        time.sleep(1)
    
    print("\nЧас вийшов!")

# Простий секундомір
def stopwatch():
    input("Натисни Enter, щоб запустити секундомір...")
    start_time = time.time()
    
    try:
        while True:
            elapsed = time.time() - start_time
            mins, secs = divmod(int(elapsed), 60)
            timer = f"{mins:02d}:{secs:02d}"
            print(timer, end="\r")
            time.sleep(0.1)
    except KeyboardInterrupt:
        end_time = time.time()
        elapsed = end_time - start_time
        print(f"\nЧас: {elapsed:.2f} секунд")

# Приклад використання таймера
# countdown_timer(5)

# Приклад використання секундоміра
# stopwatch()  # Для зупинки натисни Ctrl+C

Як перетворити математичну задачу на код

Перетворення математичної задачі на код — це навичка, яку треба розвивати. Давай розберемося, як це робити крок за кроком.

Стратегія розв'язання математичних задач:

1. Зрозумій задачу

   • Прочитай умову кілька разів
   • Визнач, що дано і що потрібно знайти
   • Виокрем ключову інформацію

2. Запиши формули

   • Визнач математичні формули, які використовуватимеш
   • Перевір, чи правильно розумієш всі змінні

3. Розбий на кроки

   • Розділи складну задачу на простіші кроки
   • Визнач послідовність дій

4. Пиши код

   • Перетвори кожен крок на код
   • Виконуй обчислення послідовно
   • Використовуй зрозумілі імена змінних

5. Перевір результат

   • Перевір розв'язок на простому прикладі
   • Переконайся, що відповідь має сенс

Приклад: розв'язання задачі на рух

Задача: Велосипедист їде з точки A в точку B зі швидкістю 15 км/год, а назад — зі швидкістю 10 км/год. Відстань між точками — 30 км. Скільки часу триватиме вся подорож?

Розв'язання:

1. Зрозуміти задачу

   • Дано: швидкість туди = 15 км/год, швидкість назад = 10 км/год, відстань = 30 км
   • Знайти: загальний час подорожі

2. Формули

   • Час = Відстань / Швидкість
   • Загальний час = Час(туди) + Час(назад)

3. Переведення в код:

# Дані задачі
distance = 30  # км
speed_forward = 15  # км/год
speed_back = 10  # км/год

# Обчислення часу в дорозі
time_forward = distance / speed_forward  # години
time_back = distance / speed_back  # години
total_time = time_forward + time_back  # години

# Переведення у години та хвилини
hours = int(total_time)
minutes = int((total_time - hours) * 60)

# Виведення результату
print(f"Час у дорозі туди: {time_forward} годин")
print(f"Час у дорозі назад: {time_back} годин")
print(f"Загальний час: {total_time} годин, або {hours} год {minutes} хв")

Результат: Загальний час: 5.0 годин (3 години туди і 2 години назад).

Покрокове рішення прикладів

Давай розглянемо ще кілька задач і розв'яжемо їх покроково.

Задача 1: Банківський відсоток

Задача: Ти поклав 1000 грн у банк під 5% річних на 3 роки. Скільки грошей буде на рахунку в кінці терміну, якщо відсотки нараховуються раз на рік?

Крок 1: Аналізуємо задачу

• Початкова сума: 1000 грн
• Відсоткова ставка: 5% річних
• Термін: 3 роки
• Потрібно знайти кінцеву суму

Крок 2: Визначаємо формулу

• Для простих відсотків: Sum = Initial * (1 + rate * years)
• Для складних відсотків: Sum = Initial * (1 + rate) ^ years

Крок 3: Пишемо код для обох варіантів

# Дані задачі
initial_amount = 1000  # початкова сума, грн
interest_rate = 0.05   # відсоткова ставка (5%)
years = 3              # термін, років

# Обчислення з простими відсотками
final_amount_simple = initial_amount * (1 + interest_rate * years)

# Обчислення зі складними відсотками
final_amount_compound = initial_amount * (1 + interest_rate) ** years

# Виведення результатів
print(f"Початкова сума: {initial_amount} грн")
print(f"Кінцева сума (прості відсотки): {final_amount_simple} грн")
print(f"Кінцева сума (складні відсотки): {final_amount_compound:.2f} грн")

Крок 4: Результат

• З простими відсотками: 1150 грн
• Зі складними відсотками: 1157.63 грн

Задача 2: Задача про суміші

Задача: У тебе є 300 г солоної води з концентрацією солі 10%. Скільки прісної води треба додати, щоб отримати розчин з концентрацією 4%?

Крок 1: Аналізуємо задачу

• Маємо: 300 г розчину з концентрацією 10%
• Додаємо х г прісної води
• Потрібно отримати розчин з концентрацією 4%

Крок 2: Визначаємо формулу

• Кількість солі: 300 г * 10% = 30 г
• Після додавання води кількість солі не зміниться
• Нова концентрація: 30 г / (300 г + х г) = 4%

Крок 3: Пишемо код

# Дані задачі
initial_solution = 300  # г
initial_concentration = 0.10  # 10%
target_concentration = 0.04  # 4%

# Обчислення кількості солі
salt_amount = initial_solution * initial_concentration

# Обчислення нової загальної маси розчину
# salt_amount / new_total = target_concentration
# new_total = salt_amount / target_concentration
new_total = salt_amount / target_concentration

# Кількість води, яку треба додати
water_to_add = new_total - initial_solution

# Виведення результату
print(f"Початковий розчин: {initial_solution} г з концентрацією {initial_concentration*100}%")
print(f"Кількість солі: {salt_amount} г")
print(f"Необхідно додати {water_to_add} г прісної води")
print(f"Підсумкова маса розчину: {new_total} г з концентрацією {target_concentration*100}%")

Крок 4: Результат

• Потрібно додати 450 г прісної води

Задача 3: Рух назустріч

Задача: З міст A і B, відстань між якими 150 км, одночасно виїхали назустріч один одному два велосипедисти. Швидкість першого — 15 км/год, другого — 20 км/год. Через скільки годин вони зустрінуться?

Крок 1: Аналізуємо задачу

• Відстань: 150 км
• Швидкість першого: 15 км/год
• Швидкість другого: 20 км/год
• Рухаються назустріч один одному

Крок 2: Визначаємо формулу

• При русі назустріч відстань зменшується зі швидкістю, що дорівнює сумі швидкостей
• Час зустрічі = Відстань / (Швидкість1 + Швидкість2)

Крок 3: Пишемо код

# Дані задачі
distance = 150  # км
speed1 = 15  # км/год
speed2 = 20  # км/год

# Обчислення часу зустрічі
total_speed = speed1 + speed2
meeting_time = distance / total_speed

# Виведення результату
print(f"Відстань між містами: {distance} км")
print(f"Швидкість першого велосипедиста: {speed1} км/год")
print(f"Швидкість другого велосипедиста: {speed2} км/год")
print(f"Час зустрічі: {meeting_time} годин")

# Обчислення відстані, яку проїхав кожен велосипедист до зустрічі
distance1 = speed1 * meeting_time
distance2 = speed2 * meeting_time
print(f"Перший велосипедист проїхав {distance1} км до зустрічі")
print(f"Другий велосипедист проїхав {distance2} км до зустрічі")
print(f"Перевірка: {distance1} + {distance2} = {distance1 + distance2} км")

Крок 4: Результат

• Час зустрічі: 4.29 години (або 4 години і 17 хвилин)
• Перший велосипедист проїхав 64.29 км
• Другий велосипедист проїхав 85.71 км
• Сума відстаней: 150 км, що підтверджує правильність розрахунків

В цьому розділі ми розглянемо неймовірні математичні трюки, які не лише допоможуть тобі виконувати обчислення швидше, але й можуть вразити твоїх друзів! Python допоможе нам перевірити ці трюки і створити цікаві математичні ігри.

Швидке обчислення

Ці трюки дозволяють швидко виконувати математичні операції в голові, а Python допоможе нам підтвердити, що вони працюють правильно.

Трюк 1: Множення на 11

Щоб швидко помножити двоцифрове число на 11:

1. Додай цифри числа
2. Постав суму між цими цифрами

Наприклад, 42 × 11:

• Цифри: 4 і 2
• Сума: 4 + 2 = 6
• Результат: 4(6)2 = 462

Перевіримо це на Python:

def multiply_by_11(number):
      if 10 <= number <= 99:  # Для двоцифрових чисел
          tens = number // 10  # Перша цифра
          ones = number % 10   # Друга цифра
          sum_digits = tens + ones
          
          if sum_digits < 10:
              return tens * 100 + sum_digits * 10 + ones
          else:
              # Якщо сума >= 10, перенесення до першої цифри
              return (tens + 1) * 100 + (sum_digits - 10) * 10 + ones
      else:
          return number * 11  # Для інших чисел - звичайне множення
  
# Перевіримо кілька прикладів
examples = [42, 57, 83, 95]
  
for num in examples:
      fast_result = multiply_by_11(num)
      actual_result = num * 11
      print(f"{num} × 11 = {fast_result} (Швидкий метод)")
      print(f"{num} × 11 = {actual_result} (Звичайне множення)")
      print(f"Результати {'співпадають' if fast_result == actual_result else 'не співпадають'}!")
      print()

Трюк 2: Множення на 9

Є кілька трюків для множення на 9:

Метод пальців: для чисел від 1 до 10

• Розведи 10 пальців перед собою
• Загни палець під номером числа, яке множиш на 9
• Кількість пальців зліва - цифра десятків, справа - цифра одиниць

Метод віднімання: для будь-яких чисел

• Помнож число на 10 (додай нуль)
• Відніми вихідне число

Перевіримо другий метод на Python:

def multiply_by_9(number):
      return number * 10 - number
  
# Перевіримо кілька прикладів
for num in range(1, 13):
      fast_result = multiply_by_9(num)
      actual_result = num * 9
      print(f"{num} × 9 = {fast_result} (Метод віднімання)")
      print(f"{num} × 9 = {actual_result} (Звичайне множення)")
      assert fast_result == actual_result  # Перевіряємо, що результати однакові

Трюк 3: Піднесення до квадрату чисел, що закінчуються на 5

Щоб швидко підносити до квадрату числа, що закінчуються на 5:

1. Множимо число десятків на наступне число
2. Дописуємо "25" в кінці

Наприклад, 35²:

• Перша частина: 3 × 4 = 12
• Результат: 12|25 = 1225

Перевіримо на Python:

def square_ending_with_5(number):
      if number % 10 != 5:
          return f"Трюк працює тільки для чисел, що закінчуються на 5"
          
      # Виділяємо першу частину числа (десятки)
      first_part = number // 10
      
      # Використовуємо формулу: (first_part * (first_part + 1)) * 100 + 25
      result = first_part * (first_part + 1) * 100 + 25
      return result
  
# Перевіримо кілька прикладів
examples = [5, 15, 25, 35, 45, 95]
  
for num in examples:
      fast_result = square_ending_with_5(num)
      actual_result = num ** 2
      print(f"{num}² = {fast_result} (Швидкий метод)")
      print(f"{num}² = {actual_result} (Звичайне піднесення до квадрату)")
      print(f"Результати {'співпадають' if fast_result == actual_result else 'не співпадають'}!")
      print()

Трюк 4: Швидке обчислення відсотків

Обчислення відсотків можна спростити, знаючи дещо про дроби:

10% від числа = число поділити на 10 (перенести кому на одну позицію вліво)

x% від числа = (x/100) × число = x × (число/100)

Приклад: 15% від 120

• 10% від 120 = 12
• 5% від 120 = 6 (половина від 10%)
• 15% від 120 = 12 + 6 = 18

Перевіримо на Python:

def calculate_percentage(percentage, number):
      # Обчислюємо стандартним способом
      standard_result = (percentage / 100) * number
      
      # Обчислюємо за допомогою трюку з 10%
      p10 = number / 10  # 10% від числа
      
      # Розбиваємо відсоток на складові
      tens = percentage // 10
      units = percentage % 10
      
      # Обчислюємо за частинами
      trick_result = (tens * p10) + (units * p10 / 10)
      
      return {
          "standard": standard_result,
          "trick": trick_result
      }
  
# Приклади
examples = [
      {"percentage": 15, "number": 120},
      {"percentage": 20, "number": 85},
      {"percentage": 35, "number": 200}
]
  
for example in examples:
      p = example["percentage"]
      n = example["number"]
      results = calculate_percentage(p, n)
      
      print(f"{p}% від {n}")
      print(f"Стандартний метод: {results['standard']}")
      print(f"Метод із 10%: {results['trick']}")
      print()

Трюк 5: Множення двоцифрових чисел на 5

Щоб швидко помножити двоцифрове число на 5:

1. Помнож число на 10
2. Поділи результат на 2

Приклад: 46 × 5

• 46 × 10 = 460
• 460 ÷ 2 = 230

def multiply_by_5(number):
      # Трюк: number × 5 = (number × 10) ÷ 2
      return (number * 10) // 2
  
# Перевіримо
for num in [14, 23, 46, 85, 92]:
      fast_result = multiply_by_5(num)
      actual_result = num * 5
      print(f"{num} × 5 = {fast_result} (Швидкий метод)")
      print(f"{num} × 5 = {actual_result} (Звичайне множення)")
      print()

Математичні ігри з числами

Використовуючи наші знання з математики та Python, ми можемо створити цікаві математичні ігри!

Гра 1: Відгадай правило послідовності

У цій грі ти маєш визначити закономірність і вгадати наступне число в послідовності.

import random
  
def sequence_game():
      # Різні типи послідовностей та їх правила
      sequences = [
          {"seq": [2, 4, 6, 8, 10], "rule": "Додай 2", "next": 12},
          {"seq": [1, 2, 4, 8, 16], "rule": "Помнож на 2", "next": 32},
          {"seq": [1, 4, 9, 16, 25], "rule": "Квадрати чисел", "next": 36},
          {"seq": [1, 1, 2, 3, 5, 8], "rule": "Числа Фібоначчі (сума двох попередніх)", "next": 13},
          {"seq": [3, 4, 7, 11, 18], "rule": "Сума двох попередніх", "next": 29},
          {"seq": [3, 6, 11, 18, 27], "rule": "Додай 3, потім 5, потім 7...", "next": 38}
      ]
      
      # Вибираємо випадкову послідовність
      sequence = random.choice(sequences)
      
      print("Гра: Відгадай наступне число в послідовності!")
      print(f"Послідовність: {', '.join(map(str, sequence['seq']))}, ...?")
      
      try:
          guess = int(input("Яке наступне число? "))
          
          if guess == sequence["next"]:
              print("Правильно! Вітаємо!")
          else:
              print(f"Не вгадав. Наступне число - {sequence['next']}")
          
          print(f"Правило послідовності: {sequence['rule']}")
          
      except ValueError:
          print("Введи ціле число!")
  
# Щоб запустити гру, розкоментуй наступний рядок
# sequence_game()

Гра 2: Математичний фокус "Вгадую твоє число"

Ця гра вразить твоїх друзів! Ти "вгадуєш" число, про яке думає людина, використовуючи прості математичні трюки.

def number_guessing_trick():
      print("Я вгадаю число, про яке ти думаєш!")
      print("Виконай наступні дії, але не кажи мені проміжні результати:")
      print("1. Загадай число від 1 до 100")
      print("2. Помнож його на 2")
      print("3. Додай 10")
      print("4. Поділи на 2")
      print("5. Відніми початкове число")
      
      input("Натисни Enter, коли будеш готовий...")
      
      print("Я знаю, що в тебе вийшло число 5!")
      
      # Пояснення:
      # Нехай x - початкове число
      # 1. x
      # 2. 2x
      # 3. 2x + 10
      # 4. (2x + 10) / 2 = x + 5
      # 5. (x + 5) - x = 5
      
      print("\nПояснення:")
      print("Якщо початкове число x, то після всіх дій отримуємо:")
      print("1. x")
      print("2. 2x")
      print("3. 2x + 10")
      print("4. (2x + 10) / 2 = x + 5")
      print("5. (x + 5) - x = 5")
      print("Результат завжди буде 5, незалежно від початкового числа!")
  
# Щоб запустити фокус, розкоментуй наступний рядок
# number_guessing_trick()

Гра 3: Магічні квадрати

Магічний квадрат - це таблиця з числами, де сума у кожному рядку, стовпці та по діагоналях однакова.

def check_magic_square(square):
      n = len(square)
      
      # Знаходимо "магічне число" (сума першого рядка)
      magic_sum = sum(square[0])
      
      # Перевіряємо всі рядки
      for row in square:
          if sum(row) != magic_sum:
              return False
      
      # Перевіряємо всі стовпці
      for col in range(n):
          column_sum = sum(square[row][col] for row in range(n))
          if column_sum != magic_sum:
              return False
      
      # Перевіряємо діагоналі
      diag1_sum = sum(square[i][i] for i in range(n))
      diag2_sum = sum(square[i][n-1-i] for i in range(n))
      
      if diag1_sum != magic_sum or diag2_sum != magic_sum:
          return False
      
      # Якщо всі перевірки пройдені успішно
      return True
  
def magic_square_game():
      # Приклад магічного квадрату 3×3
      magic_square = [
          [8, 1, 6],
          [3, 5, 7],
          [4, 9, 2]
      ]
      
      print("Гра: Магічний квадрат!")
      print("Магічний квадрат - це таблиця чисел, де сума в кожному рядку,")
      print("кожному стовпці і по двох діагоналях однакова.")
      print("\nОсь приклад магічного квадрату 3×3:")
      
      # Виведення квадрату
      for row in magic_square:
          print(row)
      
      # Знаходимо "магічне число"
      magic_sum = sum(magic_square[0])
      print(f"\nМагічне число: {magic_sum}")
      
      # Перевіряємо суми у кожному рядку
      print("\nСуми рядків:")
      for i, row in enumerate(magic_square):
          print(f"Рядок {i+1}: {row} = {sum(row)}")
      
      # Перевіряємо суми у кожному стовпці
      print("\nСуми стовпців:")
      for col in range(3):
          column = [magic_square[row][col] for row in range(3)]
          print(f"Стовпець {col+1}: {column} = {sum(column)}")
      
      # Перевіряємо суми по діагоналях
      print("\nСуми діагоналей:")
      diagonal1 = [magic_square[i][i] for i in range(3)]
      diagonal2 = [magic_square[i][2-i] for i in range(3)]
      print(f"Діагональ 1: {diagonal1} = {sum(diagonal1)}")
      print(f"Діагональ 2: {diagonal2} = {sum(diagonal2)}")
      
      print("\nТепер спробуй створити свій магічний квадрат!")
      print("Підказка: для квадрату 3×3 використовуй числа від 1 до 9 без повторень.")
  
# Щоб запустити гру, розкоментуй наступний рядок
# magic_square_game()

Гра 4: "Числова піраміда"

У цій грі ми будуємо числову піраміду, де кожне число - це сума двох чисел під ним.

def number_pyramid_game():
      import random
      
      print("Гра: Числова піраміда")
      print("У числовій піраміді кожне число є сумою двох чисел під ним.")
      print("Наприклад:")
      print("    15")
      print("   7  8")
      print("  3  4  4")
      print(" 1  2  2  2")
      
      # Створюємо основу піраміди (нижній рядок)
      base_size = 5
      base = [random.randint(1, 5) for _ in range(base_size)]
      
      # Будуємо піраміду
      pyramid = [base]
      for i in range(base_size - 1):
          new_row = []
          for j in range(len(pyramid[0]) - 1):
              new_row.append(pyramid[0][j] + pyramid[0][j+1])
          pyramid.insert(0, new_row)
              
      # Створюємо піраміду з пропусками для гри
      game_pyramid = [row.copy() for row in pyramid]
      
      # Ховаємо деякі числа
      num_hidden = 3
      hidden_positions = []
      
      while len(hidden_positions) < num_hidden:
          row = random.randint(0, len(pyramid) - 2)  # Не ховаємо з верхнього рядка
          col = random.randint(0, len(pyramid[row]) - 1)
          position = (row, col)
          
          if position not in hidden_positions:
              hidden_positions.append(position)
              game_pyramid[row][col] = "?"
      
      # Виводимо піраміду з пропусками
      print("\nЗаповни пропуски (?) у цій піраміді:")
      for row in game_pyramid:
          # Додаємо відступи для красивого відображення піраміди
          spaces = " " * (base_size - len(row))
          print(spaces + " ".join(str(x) for x in row))
      
      # Гра
      for i, (row, col) in enumerate(hidden_positions):
          while True:
              try:
                  guess = int(input(f"\nЯке число має бути замість '{i+1}-го ?' ? "))
                  
                  if guess == pyramid[row][col]:
                      print("Правильно!")
                      game_pyramid[row][col] = guess
                      # Оновлюємо піраміду
                      for r in game_pyramid:
                          spaces = " " * (base_size - len(r))
                          print(spaces + " ".join(str(x) for x in r))
                      break
                  else:
                      print("Неправильно. Спробуй ще раз.")
              except ValueError:
                  print("Введи ціле число!")
      
      print("\nВітаємо! Ти заповнив усі пропуски правильно!")
  
# Щоб запустити гру, розкоментуй наступний рядок
# number_pyramid_game()

Гра 5: "Щасливі числа"

Щасливе число - це число, яке при певних операціях дає в результаті 1.

def is_happy(number):
      """Перевіряє, чи є число щасливим."""
      seen = set()
      
      while number != 1 and number not in seen:
          seen.add(number)
          # Сума квадратів цифр
          number = sum(int(digit) ** 2 for digit in str(number))
      
      return number == 1
  
def next_happy_step(number):
      """Повертає наступний крок при перевірці на щасливе число."""
      return sum(int(digit) ** 2 for digit in str(number))
  
def happy_number_game():
      print("Гра: Щасливі числа")
      print("Число називається 'щасливим', якщо послідовність, отримана заміною")
      print("числа сумою квадратів його цифр, в кінці дає 1.")
      print("\nНаприклад, для числа 19:")
      print("1. 1² + 9² = 1 + 81 = 82")
      print("2. 8² + 2² = 64 + 4 = 68")
      print("3. 6² + 8² = 36 + 64 = 100")
      print("4. 1² + 0² + 0² = 1 + 0 + 0 = 1")
      print("Отже, 19 - щасливе число!")
      
      print("\nА от 4 - не щасливе число:")
      print("1. 4² = 16")
      print("2. 1² + 6² = 1 + 36 = 37")
      print("3. 3² + 7² = 9 + 49 = 58")
      print("4. 5² + 8² = 25 + 64 = 89")
      print("5. 8² + 9² = 64 + 81 = 145")
      print("6. 1² + 4² + 5² = 1 + 16 + 25 = 42")
      print("7. 4² + 2² = 16 + 4 = 20")
      print("8. 2² + 0² = 4 + 0 = 4")
      print("Отримали 4 знову, тому ми зациклились і ніколи не досягнемо 1.")
      
      try:
          number = int(input("\nВведи число для перевірки: "))
          
          print(f"Перевіряємо, чи є {number} щасливим числом...")
          
          current = number
          steps = [current]
          
          while current != 1 and current not in steps[:-1]:
              current = next_happy_step(current)
              steps.append(current)
          
          for i, step in enumerate(steps[:-1]):
              digits = ' + '.join(f"{digit}²" for digit in str(step))
              squares = ' + '.join(str(int(digit) ** 2) for digit in str(step))
              print(f"{i+1}. {digits} = {squares} = {steps[i+1]}")
          
          if is_happy(number):
              print(f"\n{number} - це щасливе число! 🎉")
          else:
              print(f"\n{number} - це НЕ щасливе число. Ми ніколи не дійдемо до 1.")
              
          # Виведемо перші кілька щасливих чисел
          happy_numbers = [n for n in range(1, 31) if is_happy(n)]
          print(f"\nПерші щасливі числа: {happy_numbers}")
      
      except ValueError:
          print("Будь ласка, введи ціле число!")
  
# Щоб запустити гру, розкоментуй наступний рядок
# happy_number_game()

Висновок

Математичні трюки не лише допомагають швидше виконувати обчислення, але й розвивають твоє математичне мислення та інтуїцію. Використовуючи Python, ми можемо перевіряти ці трюки та досліджувати цікаві закономірності у світі чисел.

Спробуй власноруч перевірити описані трюки та придумати свої власні математичні ігри. Пам'ятай: математика може бути не лише корисною, але й дуже захоплюючою!

Практика — найкращий спосіб закріпити знання з математики та програмування. Ось кілька завдань різного рівня складності:

Прості завдання

1. Обчислення площі та периметру:

Напиши програму, яка обчислює площу та периметр прямокутника. Користувач вводить довжину та ширину.

# Твій код тут
length = float(input("Введи довжину прямокутника: "))
width = float(input("Введи ширину прямокутника: "))

area = length * width
perimeter = 2 * (length + width)

print(f"Площа прямокутника: {area}")
print(f"Периметр прямокутника: {perimeter}")

2. Конвертер температури:

Створи програму, яка конвертує температуру з градусів Цельсія у Фаренгейти і навпаки. Користувач вводить температуру і вказує, в якій шкалі вона задана.

# Твій код тут
temperature = float(input("Введи температуру: "))
scale = input("В якій шкалі? (C для Цельсія, F для Фаренгейта): ").upper()

if scale == "C":
    # Конвертуємо з Цельсія у Фаренгейти
    converted = temperature * 9/5 + 32
    print(f"{temperature}°C = {converted}°F")
elif scale == "F":
    # Конвертуємо з Фаренгейта у Цельсії
    converted = (temperature - 32) * 5/9
    print(f"{temperature}°F = {converted}°C")
else:
    print("Невідома шкала! Використовуй C або F.")

3. Таблиця множення:

Напиши програму, яка виводить таблицю множення для заданого числа.

# Твій код тут
number = int(input("Введи число для таблиці множення: "))

print(f"Таблиця множення для числа {number}:")
for i in range(1, 11):
    result = number * i
    print(f"{number} × {i} = {result}")

Задачі середньої складності

4. Обчислення корнів квадратного рівняння:

Напиши програму, яка знаходить корені квадратного рівняння ax² + bx + c = 0. Користувач вводить коефіцієнти a, b, c.

import math

# Твій код тут
a = float(input("Введи коефіцієнт a: "))
b = float(input("Введи коефіцієнт b: "))
c = float(input("Введи коефіцієнт c: "))

if a == 0:
    # Лінійне рівняння bx + c = 0
    if b == 0:
        if c == 0:
            print("Рівняння має безліч розв'язків")
        else:
            print("Рівняння не має розв'язків")
    else:
        x = -c / b
        print(f"Це лінійне рівняння з розв'язком x = {x}")
else:
    # Обчислюємо дискримінант
    discriminant = b**2 - 4*a*c
    
    if discriminant > 0:
        # Два різних дійсних корені
        x1 = (-b + math.sqrt(discriminant)) / (2*a)
        x2 = (-b - math.sqrt(discriminant)) / (2*a)
        print(f"Два різних корені: x1 = {x1}, x2 = {x2}")
    elif discriminant == 0:
        # Один корінь (два однакових)
        x = -b / (2*a)
        print(f"Один корінь (два однакових): x = {x}")
    else:
        # Комплексні корені
        real_part = -b / (2*a)
        imaginary_part = math.sqrt(abs(discriminant)) / (2*a)
        print(f"Комплексні корені:")
        print(f"x1 = {real_part} + {imaginary_part}i")
        print(f"x2 = {real_part} - {imaginary_part}i")

5. Найбільший спільний дільник (НСД):

Напиши програму для знаходження найбільшого спільного дільника двох чисел за алгоритмом Евкліда.

# Твій код тут
def gcd(a, b):
    while b:
        a, b = b, a % b
    return a

num1 = int(input("Введи перше число: "))
num2 = int(input("Введи друге число: "))

result = gcd(num1, num2)
print(f"Найбільший спільний дільник {num1} і {num2} дорівнює {result}")

6. Перевірка на просте число:

Напиши програму, яка перевіряє, чи є задане число простим.

import math

# Твій код тут
def is_prime(n):
    if n <= 1:
        return False
    if n <= 3:
        return True
    if n % 2 == 0 or n % 3 == 0:
        return False
    
    # Перевіряємо дільники від 5 до квадратного кореня з n
    i = 5
    while i * i <= n:
        if n % i == 0 or n % (i + 2) == 0:
            return False
        i += 6
    
    return True

number = int(input("Введи число для перевірки: "))

if is_prime(number):
    print(f"{number} - просте число")
else:
    print(f"{number} - не просте число")

Творчі завдання

7. Калькулятор індексу маси тіла (ІМТ):

Напиши програму для обчислення ІМТ. Програма повинна також давати рекомендації щодо ваги.

# Твій код тут
def calculate_bmi(weight, height):
    # Переводимо зріст з сантиметрів у метри, якщо потрібно
    if height > 3:  # Якщо зріст введено в сантиметрах
        height = height / 100
    
    # Формула ІМТ: вага (кг) / зріст² (м)
    bmi = weight / (height ** 2)
    
    return bmi

def interpret_bmi(bmi):
    if bmi < 18.5:
        return "Недостатня вага", "Спробуй набрати вагу, дотримуючись здорового харчування"
    elif bmi < 25:
        return "Нормальна вага", "Твоя вага в нормі! Продовжуй підтримувати здоровий спосіб життя"
    elif bmi < 30:
        return "Надмірна вага", "Спробуй зменшити вагу за допомогою здорового харчування та фізичних вправ"
    else:
        return "Ожиріння", "Варто проконсультуватися з лікарем для розробки плану зниження ваги"

print("Калькулятор індексу маси тіла (ІМТ)")
weight = float(input("Введи свою вагу (кг): "))
height = float(input("Введи свій зріст (м або см): "))

bmi = calculate_bmi(weight, height)
category, recommendation = interpret_bmi(bmi)

print(f"Твій ІМТ: {bmi:.2f}")
print(f"Категорія: {category}")
print(f"Рекомендація: {recommendation}")

8. Генератор паролів:

Створи програму, яка генерує випадкові паролі заданої довжини і складності.

import random
import string

# Твій код тут
def generate_password(length, include_uppercase=True, include_numbers=True, include_symbols=True):
    # Визначаємо, які символи можна використовувати
    lowercase_letters = string.ascii_lowercase
    uppercase_letters = string.ascii_uppercase if include_uppercase else ""
    digits = string.digits if include_numbers else ""
    symbols = "!@#$%^&*()" if include_symbols else ""
    
    # Об'єднуємо всі дозволені символи
    all_characters = lowercase_letters + uppercase_letters + digits + symbols
    
    if not all_characters:
        return "Неможливо створити пароль: не вибрано жодного типу символів"
    
    # Переконуємося, що пароль містить хоча б один символ кожного типу
    password = []
    if include_uppercase:
        password.append(random.choice(uppercase_letters))
    if include_numbers:
        password.append(random.choice(digits))
    if include_symbols:
        password.append(random.choice(symbols))
    
    # Додаємо решту символів
    while len(password) < length:
        password.append(random.choice(all_characters))
    
    # Перемішуємо символи
    random.shuffle(password)
    
    # Об'єднуємо у рядок
    return ''.join(password)

print("Генератор паролів")
length = int(input("Введи довжину пароля: "))
include_uppercase = input("Включати великі літери? (так/ні): ").lower() == "так"
include_numbers = input("Включати цифри? (так/ні): ").lower() == "так"
include_symbols = input("Включати спеціальні символи? (так/ні): ").lower() == "так"

password = generate_password(length, include_uppercase, include_numbers, include_symbols)
print(f"Твій пароль: {password}")

9. Розв'язання системи лінійних рівнянь:

Напиши програму для розв'язання системи двох лінійних рівнянь з двома невідомими.

# Твій код тут
# Система рівнянь:
# a1*x + b1*y = c1
# a2*x + b2*y = c2

def solve_system(a1, b1, c1, a2, b2, c2):
    # Обчислюємо визначник системи
    determinant = a1*b2 - a2*b1
    
    if determinant == 0:
        return "Система не має єдиного розв'язку (паралельні прямі або прямі збігаються)"
    
    # Знаходимо розв'язки
    x = (c1*b2 - c2*b1) / determinant
    y = (a1*c2 - a2*c1) / determinant
    
    return x, y

print("Розв'язання системи лінійних рівнянь:")
print("a1*x + b1*y = c1")
print("a2*x + b2*y = c2")

a1 = float(input("Введи a1: "))
b1 = float(input("Введи b1: "))
c1 = float(input("Введи c1: "))
a2 = float(input("Введи a2: "))
b2 = float(input("Введи b2: "))
c2 = float(input("Введи c2: "))

result = solve_system(a1, b1, c1, a2, b2, c2)

if isinstance(result, tuple):
    x, y = result
    print(f"Розв'язок системи: x = {x}, y = {y}")
else:
    print(result)

Що ми вивчили

У цьому розділі ми:

1. Дослідили різні типи чисел у Python:

   • Цілі числа (int)
   • Дробові числа (float)
   • Перетворення між типами

2. Вивчили математичні операції:

   • Основні операції: додавання, віднімання, множення, ділення
   • Цілочисельне ділення та остача від ділення
   • Піднесення до степеня
   • Порядок виконання операцій

3. Познайомилися з додатковими математичними функціями:

   • Модуль math та його функції
   • Округлення, корені, тригонометричні функції
   • Константи (π, e)

4. Навчилися генерувати випадкові числа:

   • Модуль random
   • Випадкові числа в заданому діапазоні
   • Практичні приклади використання

5. Застосували математику для розв'язання реальних задач:

   • Обчислення площі та об'єму
   • Конвертація величин
   • Фінансові та часові обчислення

6. Розібралися у математичних трюках:

   • Швидке множення (на 9, 11, 5)
   • Піднесення до квадрату чисел, що закінчуються на 5
   • Обчислення відсотків

7. Створили математичні ігри:

   • Вгадування правила послідовності
   • Математичні фокуси
   • Магічні квадрати

Ключові поняття

Що далі?

Тепер, коли ти опанував основи роботи з числами та математикою в Python, ти готовий рухатися далі:

1. У наступному розділі ми вивчатимемо умовні оператори (if-else) та логічні вирази, які дозволяють програмі приймати рішення залежно від умов.

2. Використовуй набуті навички для:

   • Створення власних математичних ігор і головоломок
   • Розв'язання задач із шкільного курсу математики
   • Автоматизації розрахунків, які раніше робив вручну

3. Експериментуй з різними числовими типами та функціями, щоб краще зрозуміти їх поведінку.

4. Спробуй розв'язати складніші задачі, наприклад:

   • Знаходження всіх простих чисел у заданому діапазоні
   • Розрахунок складних відсотків для банківських вкладів
   • Створення програми для графічної візуалізації числових даних

Пам'ятай: програмування та математика йдуть пліч-о-пліч, і чим більше ти практикуєшся, тим краще в тебе виходитиме розв'язувати різноманітні задачі!