Proc 3

def Mean(X, Y):
    AMean = (X + Y) / 2
    GMean = (X * Y) ** 0.5
    return AMean, GMean

# Заданные значения
A = 10
B = 20
C = 30
D = 40

# Вычисление среднего арифметического и среднего геометрического для пар (A, B), (A, C), (A, D)
AMean_AB, GMean_AB = Mean(A, B)
AMean_AC, GMean_AC = Mean(A, C)
AMean_AD, GMean_AD = Mean(A, D)

# Вывод результатов
print("Среднее арифметическое и среднее геометрическое для пар (A, B):", AMean_AB, GMean_AB)
print("Среднее арифметическое и среднее геометрическое для пар (A, C):", AMean_AC, GMean_AC)
print("Среднее арифметическое и среднее геометрическое для пар (A, D):", AMean_AD, GMean_AD)

Proc 4

import math

def TrianglePS(a):
    P = 3 * a
    S = (a ** 2) * math.sqrt(3) / 4
    return P, S

# Заданные значения сторон трех равносторонних треугольников
a1 = 5
a2 = 7
a3 = 10

# Вычисление периметров и площадей трех треугольников
P1, S1 = TrianglePS(a1)
P2, S2 = TrianglePS(a2)
P3, S3 = TrianglePS(a3)

# Вывод результатов
print("Периметр и площадь для треугольника со стороной", a1, ":", P1, S1)
print("Периметр и площадь для треугольника со стороной", a2, ":", P2, S2)
print("Периметр и площадь для треугольника со стороной", a3, ":", P3, S3)

Proc 5

def RectPS(x1, y1, x2, y2):
    width = abs(x2 - x1)
    height = abs(y2 - y1)
    P = 2 * (width + height)
    S = width * height
    return P, S

# Заданные значения координат противоположных вершин трех прямоугольников
rect1 = (0, 0, 4, 3)
rect2 = (-1, -1, 2, 4)
rect3 = (-3, -2, 3, 5)

# Вычисление периметров и площадей трех прямоугольников
P1, S1 = RectPS(*rect1)
P2, S2 = RectPS(*rect2)
P3, S3 = RectPS(*rect3)

# Вывод результатов
print("Периметр и площадь для прямоугольника с координатами", rect1, ":", P1, S1)
print("Периметр и площадь для прямоугольника с координатами", rect2, ":", P2, S2)
print("Периметр и площадь для прямоугольника с координатами", rect3, ":", P3, S3)

Proc 6

def DigitCountSum(K):
    count = 0
    sum = 0
    while K > 0:
        count += 1
        sum += K % 10
        K //= 10
    return count, sum

# Заданные целые числа
num1 = 12345
num2 = 987654321
num3 = 100
num4 = 999
num5 = 0

# Вычисление количества и суммы цифр для каждого числа
C1, S1 = DigitCountSum(num1)
C2, S2 = DigitCountSum(num2)
C3, S3 = DigitCountSum(num3)
C4, S4 = DigitCountSum(num4)
C5, S5 = DigitCountSum(num5)

# Вывод результатов
print("Количество и сумма цифр числа", num1, ":", C1, S1)
print("Количество и сумма цифр числа", num2, ":", C2, S2)
print("Количество и сумма цифр числа", num3, ":", C3, S3)
print("Количество и сумма цифр числа", num4, ":", C4, S4)
print("Количество и сумма цифр числа", num5, ":", C5, S5)

Proc 7

def InvertDigits(K):
    result = 0
    while K > 0:
        digit = K % 10
        result = result * 10 + digit
        K //= 10
    K = result

# Заданные целые числа
num1 = 12345
num2 = 67890
num3 = 987654321
num4 = 54321
num5 = 9876543210

# Меняем порядок следования цифр на обратный для каждого числа
InvertDigits(num1)
InvertDigits(num2)
InvertDigits(num3)
InvertDigits(num4)
InvertDigits(num5)

# Вывод результатов
print("Число", num1, "с обратным порядком цифр:", num1)
print("Число", num2, "с обратным порядком цифр:", num2)
print("Число", num3, "с обратным порядком цифр:", num3)
print("Число", num4, "с обратным порядком цифр:", num4)
print("Число", num5, "с обратным порядком цифр:", num5)

Proc8

def AddRightDigit(D, K):
    K = K * 10 + D
    print("Результат добавления цифры", D, ":", K)

# Заданные цифры
D1 = 5
D2 = 7

# Заданное целое число
K = 123

# Добавляем цифры D1 и D2 к числу K
AddRightDigit(D1, K)
AddRightDigit(D2, K)

Proc 9

def AddLeftDigit(D, K):
    K = int(str(D) + str(K))
    print("Результат добавления цифры", D, ":", K)

# Заданные цифры
D1 = 4
D2 = 7

# Заданное целое число
K = 123

# Добавляем цифры D1 и D2 к числу K
AddLeftDigit(D1, K)
AddLeftDigit(D2, K)

Proc 10

def Swap(X, Y):
    Temp = X
    X = Y
    Y = Temp

# Заданные переменные
A = 1
B = 2
C = 3
D = 4

# Поменять значения переменных согласно заданным парам
Swap(A, B)
Swap(C, D)
Swap(B, C)

# Вывести новые значения переменных
print("Новые значения переменных A, B, C, D:", A, B, C, D)

Proc 11

def Minmax(X, Y):
    if X > Y:
        X, Y = Y, X

# Заданные переменные
A = 1
B = 2
C = 3
D = 4

# Найти минимальное и максимальное из чисел A, B, C, D
Minmax(A, B)
Minmax(C, D)
Minmax(A, C)
Minmax(B, D)

# Вывести минимальное и максимальное значение
print("Минимальное значение:", A)
print("Максимальное значение:", D)

Proc 12

def SortInc(A, B, C):
    if A > B:
        A, B = B, A
    if B > C:
        B, C = C, B
    if A > B:
        A, B = B, A
    # Значения переменных A, B, C уже упорядочены по возрастанию

# Первый набор чисел
A1 = 3
B1 = 1
C1 = 2

# Второй набор чисел
A2 = 6
B2 = 4
C2 = 5

# Упорядочить первый набор чисел по возрастанию
SortInc(A1, B1, C1)

# Упорядочить второй набор чисел по возрастанию
SortInc(A2, B2, C2)

# Вывести упорядоченные наборы чисел
print("Упорядоченный первый набор чисел:", A1, B1, C1)
print("Упорядоченный второй набор чисел:", A2, B2, C2)

Proc 13

def SortDec(A, B, C):
    if A < B:
        A, B = B, A
    if B < C:
        B, C = C, B
    if A < B:
        A, B = B, A
    return A, B, C

# Первый набор чисел
A1 = 3
B1 = 1
C1 = 2

# Второй набор чисел
A2 = 6
B2 = 4
C2 = 5

# Упорядочить первый набор чисел по убыванию
A1, B1, C1 = SortDec(A1, B1, C1)

# Упорядочить второй набор чисел по убыванию
A2, B2, C2 = SortDec(A2, B2, C2)

# Вывести упорядоченные наборы чисел
print("Упорядоченный первый набор чисел:", A1, B1, C1)
print("Упорядоченный второй набор чисел:", A2, B2, C2)

Proc 14

def ShiftRight3(A, B, C):
    temp = A
    A = C
    C = B
    B = temp
    return A, B, C

# Первый набор чисел
A1 = 1
B1 = 2
C1 = 3

# Второй набор чисел
A2 = 4
B2 = 5
C2 = 6

# Выполнить правый циклический сдвиг для первого набора чисел
A1, B1, C1 = ShiftRight3(A1, B1, C1)

# Выполнить правый циклический сдвиг для второго набора чисел
A2, B2, C2 = ShiftRight3(A2, B2, C2)

# Вывести результаты сдвига
print("Результат сдвига для первого набора чисел:", A1, B1, C1)
print("Результат сдвига для второго набора чисел:", A2, B2, C2)

Proc15

def ShiftLeft3(A, B, C):
    temp = A
    A = B
    B = C
    C = temp
    return A, B, C

# Первый набор чисел
A1 = 1
B1 = 2
C1 = 3

# Второй набор чисел
A2 = 4
B2 = 5
C2 = 6

# Выполнить левый циклический сдвиг для первого набора чисел
A1, B1, C1 = ShiftLeft3(A1, B1, C1)

# Выполнить левый циклический сдвиг для второго набора чисел
A2, B2, C2 = ShiftLeft3(A2, B2, C2)

# Вывести результаты сдвига
print("Результат сдвига для первого набора чисел:", A1, B1, C1)
print("Результат сдвига для второго набора чисел:", A2, B2, C2)

Proc 16

def Sign(X):
    if X < 0:
        return -1
    elif X == 0:
        return 0
    else:
        return 1

# Заданные вещественные числа
A = -2.5
B = 3.8

# Вычислить значения функции Sign для A и B
sign_A = Sign(A)
sign_B = Sign(B)

# Вычислить значение выражения Sign(A) + Sign(B)
result = sign_A + sign_B

# Вывести результат
print("Значение выражения Sign(A) + Sign(B) =", result)

Proc 17

def RootsCount(A, B, C):
    D = B**2 - 4*A*C
    if D > 0:
        return 2
    elif D == 0:
        return 1
    else:
        return 0

В этой функции мы сначала вычисляем дискриминант D согласно формуле D = B**2 - 4*A*C. Затем мы проверяем значение D и возвращаем соответствующее количество корней: 2, если D > 0, 1, если D == 0, и 0, если D < 0.

Чтобы найти количество корней для каждого из трех квадратных уравнений с данными коэффициентами, мы можем вызвать функцию RootsCount три раза, передавая различные значения коэффициентов A, B и C. Например:

equation1_roots = RootsCount(1, -2, 1)
equation2_roots = RootsCount(2, 5, -3)
equation3_roots = RootsCount(3, 4, 2)

print("Количество корней уравнения 1:", equation1_roots)
print("Количество корней уравнения 2:", equation2_roots)
print("Количество корней уравнения 3:", equation3_roots)

Proc18

def CircleS(R):
    pi = 3.14
    S = pi * R**2
    return S

Чтобы найти площади трех кругов с заданными радиусами, можно вызвать функцию CircleS три раза, передавая разные значения радиусов:

radius1 = 2.5
radius2 = 4.7
radius3 = 3.0

area1 = CircleS(radius1)
area2 = CircleS(radius2)
area3 = CircleS(radius3)

print("Площадь первого круга:", area1)
print("Площадь второго круга:", area2)
print("Площадь третьего круга:", area3)

Proc19

def RingS(R1, R2):
    outer_area = 3.14 * R1**2
    inner_area = 3.14 * R2**2
    ring_area = outer_area - inner_area
    return ring_area

```python
outer_radius1 = 10
inner_radius1 = 5
area1 = RingS(outer_radius1, inner_radius1)

outer_radius2 = 15
inner_radius2 = 8
area2 = RingS(outer_radius2, inner_radius2)

outer_radius3 = 20
inner_radius3 = 12
area3 = RingS(outer_radius3, inner_radius3)
`

Proc20

def TriangleP(a, h):
    b = ((a / 2) ** 2 + h ** 2) ** 0.5
    perimeter = a + 2 * b
    return perimeter

В данной функции мы сначала находим значение боковой стороны \( b \) с помощью теоремы Пифагора. Затем, используя найденное значение \( b \), мы вычисляем периметр треугольника по формуле: \( \text{периметр} = a + 2b \).

Теперь, чтобы найти периметры трех треугольников, для которых даны основания и высоты, мы можем вызвать функцию TriangleP три раза, передавая ей соответствующие значения основания \( a \) и высоты \( h \). Например:

perimeter1 = TriangleP(5, 3)
perimeter2 = TriangleP(8, 4)
perimeter3 = TriangleP(10, 6)

В результате, переменные perimeter1, perimeter2 и perimeter3 будут содержать периметры трех треугольников соответственно.

Proc21

def SumRange(A, B):
    if A > B:
        return 0
    else:
        sum = 0
        for i in range(A, B+1):
            sum += i
        return sum

Эта функция проверяет, если \( A > B \), то возвращает 0, так как сумма чисел от \( A \) до \( B \) не имеет смысла, если \( A \) больше \( B \). В противном случае, функция использует цикл для нахождения суммы всех целых чисел от \( A \) до \( B \) включительно и возвращает эту сумму.

Чтобы найти суммы чисел от \( A \) до \( B \) и от \( B \) до \( C \), можно вызвать функцию SumRange дважды:

sum1 = SumRange(A, B)
sum2 = SumRange(B, C)

Proc22

def Calc(A, B, Op):
    if Op == 1:
        result = A - B
    elif Op == 2:
        result = A * B
    elif Op == 3:
        result = A / B
    else:
        result = A + B
    return result

result1 = Calc(A, B, N1)
result2 = Calc(A, B, N2)
result3 = Calc(A, B, N3)

В этом решении мы определяем функцию Calc с параметрами A, B и Op. Внутри функции мы используем условные операторы if-elif-else для выполнения соответствующей арифметической операции в зависимости от значения Op. Результат операции сохраняется в переменной result, которая затем возвращается из функции.

Затем мы вызываем функцию Calc три раза, передавая ей значения A, B и соответствующие значения N1, N2 и N3. Результаты операций сохраняются в переменных result1, result2 и result3.

Proc23

def Quarter(x, y):
    if x > 0 and y > 0:
        return 1
    elif x < 0 and y > 0:
        return 2
    elif x < 0 and y < 0:
        return 3
    elif x > 0 and y < 0:
        return 4
    else:
        return "Точка лежит на одной из осей"

В данной функции используется условная конструкция if-elif-else для определения номера координатной четверти, в которой находится точка. Если обе координаты положительны, то точка находится в первой четверти. Если x отрицательно, а y положительно, то точка находится во второй четверти. Если обе координаты отрицательны, то точка находится в третьей четверти. Если x положительно, а y отрицательно, то точка находится в четвертой четверти. Если точка лежит на одной из осей, то возвращается соответствующее сообщение.

Пример использования функции для трех точек с ненулевыми координатами:

point1 = (2, 3)
point2 = (-4, 5)
point3 = (-1, -2)

print(Quarter(*point1)) # Вывод: 1
print(Quarter(*point2)) # Вывод: 2
print(Quarter(*point3)) # Вывод: 3
В данном примере функция Quarter вызывается для каждой из трех точек, передавая ей координаты точки в виде аргументов. Результатом вызова функции будет номер соответствующей координатной четверти для каждой точки.
`