НОД – это математический термин, обозначающий наибольший общий делитель, который может идеально разделить два числа. НОД также известен как наибольший общий фактор(HCF).
Например, HCF / GCD двух чисел 54 и 24 равен 6. Поскольку 6 – это наибольший общий делитель, который полностью делит 54 и 24.
Разберемся как найти НОД двух чисел в Python. 
НОД с использованием функции gcd()
gcd() в python – это встроенная функция, предлагаемая математическим модулем для поиска наибольшего общего делителя двух чисел.
Синтаксис:
gcd(a, b)
Где a и b – два целых числа, которые передаются в качестве аргумента функции gcd().
Давайте создадим программу для печати НОД двух чисел, используя встроенную функцию math.gcd() в python.
math_fun.py
# create a program to print the gcd of two number in python using the math.gcd() function.
import math
print(" GCD of two number 0 and 0 is ", math.gcd(0, 0)) #math.gcd(a, b), a and b are the two integer number
print(" GCD of two number 0 and 48 is ", math.gcd(0, 48))
a = 60 # assign the number to variable a
b = 48 # assign the number to variable b
print(" GCD of two number 60 and 48 is ", math.gcd(a, b)) # pass the variable a and b to math.gcd() function.
print(" GCD of two number 48 and -12 is ", math.gcd(48, -12)) # pass the integer number
print(" GCD of two number -24 and -18 is ", math.gcd(-24, -18))
print(" GCD of two number -60 and 48 is ", math.gcd(-60, 48))
Выход:
В приведенном выше примере функция math.gcd() генерирует НОД двух заданных чисел. В функции gcd() a и b передаются в качестве аргумента, который возвращает наибольший общий делитель двух целых чисел, полностью разделяя числа.
НОД с использованием рекурсии
Рекурсия – это функция, потребляющая память, определенная в Python, которая вызывает себя через самореферентное выражение. Это означает, что функция будет постоянно вызывать и повторять себя до тех пор, пока не будет выполнено определенное условие для возврата наибольшего общего делителя числа.
Псевдокод алгоритма
Шаг 1: Возьмите два входа, x и y, от пользователя.
Шаг 2: Передайте входной номер в качестве аргумента рекурсивной функции.
Шаг 3: Если второе число равно нулю(0), возвращается первое число.
Шаг 4: В противном случае он рекурсивно вызывает функцию со вторым числом в качестве аргумента, пока не получит остаток, который делит второе число на первое число.
Шаг 5: Вызовите или назначьте gcd_fun() переменной.
Шаг 6: Отобразите НОД двух чисел.
Шаг 7: Выйдите из программы.
Разберемся с программой для нахождения НОД двух чисел с помощью рекурсии.
gcdRecur.py
# write a program to understand the GCD of two number in python using the recursion.
def gcd_fun(x, y):
if(y == 0): # it divide every number
return x # return x
else:
return gcd_fun(y, x % y)
x =int(input("Enter the first number: ")) # take first no.
y =int(input("Enter the second number: ")) # take second no.
num = gcd_fun(x, y) # call the gcd_fun() to find the result
print("GCD of two number is: ")
print(num) # call num
Выход:
Нахождение НОД с помощью цикла
Давайте создадим программу для нахождения НОД двух чисел в Python с помощью циклов.
gcdFile.py
def GCD_Loop( a, b):
if a > b: # define the if condition
temp = b
else:
temp = a
for i in range(1, temp + 1):
if(( a % i == 0) and(b % i == 0 )):
gcd = i
return gcd
x = int(input(" Enter the first number: ") ) # take first no.
y =int(input(" Enter the second number: ")) # take second no.
num = GCD_Loop(x, y) # call the gcd_fun() to find the result
print("GCD of two number is: ")
print(num) # call num
Выход:
Как мы видим в приведенной выше программе, мы берем два значения в качестве входных и передаем эти числа в функцию GCD_Loop(), чтобы вернуть GCD.
Алгоритм Евклида
Алгоритм Евклида – эффективный метод нахождения наибольшего общего делителя двух чисел. Это самый старый алгоритм, который делит большее число на меньшее и берет остаток. Опять же, он делит меньшее число от остатка, и этот алгоритм непрерывно делит число, пока остаток не станет 0.
Например, предположим, что мы хотим вычислить HCF двух чисел, 60 и 48. Затем мы делим 60 на 48; он возвращает остаток 12. Теперь мы снова делим число 24 на 12, а затем он возвращает остаток 0. Таким образом, мы получаем HCF равным 12.
Псевдокод алгоритма Евклида
Шаг 1: Есть два целых числа, например a и b.
Шаг 2: Если a = 0, то НОД(a, b) равен b.
Шаг 3: Если b = 0, НОД(a, b) равен a.
Шаг 4: Найти mod b.
Шаг 5: Предположим, что a = b и b = R.
Шаг 6: Повторяйте шаги 4 и 3, пока mod b не станет равным или большим 0.
Шаг 7: GCD = b и затем распечатайте результат.
Шаг 8: Остановите программу.
Найдем HCF или GCD двух чисел, используя алгоритм Евклида в python.
Euclid.py
# Create a program to find the GCD of two number in python using the Euclid's Algorithm.
def find_hcf(a,b):
while(b):
a, a = b, a % b
return a
a = int(input(" Enter the first number: ") ) # take first no.
b = int(input(" Enter the second number: ")) # take second no.
num = find_hcf(a, b) # call the find_hcf() to get the result
print(" The HCF of two number a and b is ")
print(num) # call num
Выход:
Изучаю Python вместе с вами, читаю, собираю и записываю информацию опытных программистов.
The greatest common divisor (GCD) of a and b is the largest number that divides both of them with no remainder.
One way to find the GCD of two numbers is Euclid’s algorithm, which is based on the observation that if r is the remainder when a is divided by b, then gcd(a, b) = gcd(b, r). As a base case, we can use gcd(a, 0) = a.
Write a function called gcd that takes parameters a and b and returns their greatest common divisor.
sampathsris
21.4k11 gold badges69 silver badges98 bronze badges
asked Jun 24, 2012 at 5:13
4
It’s in the standard library.
>>> from fractions import gcd
>>> gcd(20,8)
4
Source code from the inspect module in Python 2.7:
>>> print inspect.getsource(gcd)
def gcd(a, b):
"""Calculate the Greatest Common Divisor of a and b.
Unless b==0, the result will have the same sign as b (so that when
b is divided by it, the result comes out positive).
"""
while b:
a, b = b, a%b
return a
As of Python 3.5, gcd is in the math module; the one in fractions is deprecated. Moreover, inspect.getsource no longer returns explanatory source code for either method.
answered Jun 24, 2012 at 5:19
user545424user545424
15.6k11 gold badges57 silver badges70 bronze badges
18
The algorithms with m-n can runs awfully long.
This one performs much better:
def gcd(x, y):
while y != 0:
(x, y) = (y, x % y)
return x
answered Sep 22, 2013 at 13:13
netomnetom
3,3122 gold badges21 silver badges21 bronze badges
9
This version of code utilizes Euclid’s Algorithm for finding GCD.
def gcd_recursive(a, b):
if b == 0:
return a
else:
return gcd_recursive(b, a % b)
answered Feb 20, 2015 at 16:21
AnkushAnkush
4604 silver badges8 bronze badges
3
gcd = lambda m,n: m if not n else gcd(n,m%n)
answered Nov 2, 2015 at 8:48
Jonas ByströmJonas Byström
25k22 gold badges100 silver badges144 bronze badges
0
using recursion,
def gcd(a,b):
return a if not b else gcd(b, a%b)
using while,
def gcd(a,b):
while b:
a,b = b, a%b
return a
using lambda,
gcd = lambda a,b : a if not b else gcd(b, a%b)
>>> gcd(10,20)
>>> 10
answered Jan 31, 2019 at 8:16
1
def gcd(m,n):
return gcd(abs(m-n), min(m, n)) if (m-n) else n
answered Jun 29, 2013 at 5:48
dansalmodansalmo
11.4k5 gold badges58 silver badges52 bronze badges
2
Very concise solution using recursion:
def gcd(a, b):
if b == 0:
return a
return gcd(b, a%b)
answered May 16, 2018 at 12:02
a=int(raw_input('1st no n'))
b=int(raw_input('2nd no n'))
def gcd(m,n):
z=abs(m-n)
if (m-n)==0:
return n
else:
return gcd(z,min(m,n))
print gcd(a,b)
A different approach based on euclid’s algorithm.
answered Jun 29, 2013 at 4:51
def gcdRecur(a, b):
'''
a, b: positive integers
returns: a positive integer, the greatest common divisor of a & b.
'''
# Base case is when b = 0
if b == 0:
return a
# Recursive case
return gcdRecur(b, a % b)
Marko Gresak
7,9025 gold badges39 silver badges46 bronze badges
answered Nov 15, 2013 at 9:56
SHAMSSHAMS
191 bronze badge
I think another way is to use recursion. Here is my code:
def gcd(a, b):
if a > b:
c = a - b
gcd(b, c)
elif a < b:
c = b - a
gcd(a, c)
else:
return a
answered Oct 27, 2015 at 14:13
dexhunterdexhunter
5778 silver badges23 bronze badges
1
in python with recursion:
def gcd(a, b):
if a%b == 0:
return b
return gcd(b, a%b)
answered Jul 27, 2014 at 20:54
def gcd(a,b):
if b > a:
return gcd(b,a)
r = a%b
if r == 0:
return b
return gcd(r,b)
lennon310
12.4k11 gold badges43 silver badges61 bronze badges
answered Dec 3, 2014 at 19:41
For a>b:
def gcd(a, b):
if(a<b):
a,b=b,a
while(b!=0):
r,b=b,a%r
a=r
return a
For either a>b or a<b:
def gcd(a, b):
t = min(a, b)
# Keep looping until t divides both a & b evenly
while a % t != 0 or b % t != 0:
t -= 1
return t
answered Jan 25, 2015 at 17:55
2
I had to do something like this for a homework assignment using while loops. Not the most efficient way, but if you don’t want to use a function this works:
num1 = 20
num1_list = []
num2 = 40
num2_list = []
x = 1
y = 1
while x <= num1:
if num1 % x == 0:
num1_list.append(x)
x += 1
while y <= num2:
if num2 % y == 0:
num2_list.append(y)
y += 1
xy = list(set(num1_list).intersection(num2_list))
print(xy[-1])
answered Apr 16, 2019 at 16:21
def _grateest_common_devisor_euclid(p, q):
if q==0 :
return p
else:
reminder = p%q
return _grateest_common_devisor_euclid(q, reminder)
print(_grateest_common_devisor_euclid(8,3))
answered Jun 7, 2019 at 16:24
Sai prateekSai prateek
11.7k9 gold badges49 silver badges66 bronze badges
This code calculates the gcd of more than two numbers depending on the choice given by # the user, here user gives the number
numbers = [];
count = input ("HOW MANY NUMBERS YOU WANT TO CALCULATE GCD?n")
for i in range(0, count):
number = input("ENTER THE NUMBER : n")
numbers.append(number)
numbers_sorted = sorted(numbers)
print 'NUMBERS SORTED IN INCREASING ORDERn',numbers_sorted
gcd = numbers_sorted[0]
for i in range(1, count):
divisor = gcd
dividend = numbers_sorted[i]
remainder = dividend % divisor
if remainder == 0 :
gcd = divisor
else :
while not remainder == 0 :
dividend_one = divisor
divisor_one = remainder
remainder = dividend_one % divisor_one
gcd = divisor_one
print 'GCD OF ' ,count,'NUMBERS IS n', gcd
answered Jun 8, 2013 at 0:05
1
The value swapping didn’t work well for me. So I just set up a mirror-like situation for numbers that are entered in either a < b OR a > b:
def gcd(a, b):
if a > b:
r = a % b
if r == 0:
return b
else:
return gcd(b, r)
if a < b:
r = b % a
if r == 0:
return a
else:
return gcd(a, r)
print gcd(18, 2)
Delimitry
2,9474 gold badges29 silver badges39 bronze badges
answered Jun 18, 2013 at 20:03
troychroitroychroi
491 silver badge9 bronze badges
2
#This program will find the hcf of a given list of numbers.
A = [65, 20, 100, 85, 125] #creates and initializes the list of numbers
def greatest_common_divisor(_A):
iterator = 1
factor = 1
a_length = len(_A)
smallest = 99999
#get the smallest number
for number in _A: #iterate through array
if number < smallest: #if current not the smallest number
smallest = number #set to highest
while iterator <= smallest: #iterate from 1 ... smallest number
for index in range(0, a_length): #loop through array
if _A[index] % iterator != 0: #if the element is not equally divisible by 0
break #stop and go to next element
if index == (a_length - 1): #if we reach the last element of array
factor = iterator #it means that all of them are divisibe by 0
iterator += 1 #let's increment to check if array divisible by next iterator
#print the factor
print factor
print "The highest common factor of: ",
for element in A:
print element,
print " is: ",
greatest_common_devisor(A)
answered Mar 25, 2015 at 16:23
def gcdIter(a, b):
gcd= min (a,b)
for i in range(0,min(a,b)):
if (a%gcd==0 and b%gcd==0):
return gcd
break
gcd-=1
answered May 25, 2018 at 12:47
Par basPar bas
2132 silver badges2 bronze badges
3
Here’s the solution implementing the concept of Iteration:
def gcdIter(a, b):
'''
a, b: positive integers
returns: a positive integer, the greatest common divisor of a & b.
'''
if a > b:
result = b
result = a
if result == 1:
return 1
while result > 0:
if a % result == 0 and b % result == 0:
return result
result -= 1
answered Feb 15, 2019 at 21:40
Курс по Python: https://stepik.org/course/100707
На этом занятии я
хочу показать вам пример использования функций для решения одной частной задачи
– нахождения наибольшего общего делителя (НОД) для двух натуральных чисел a и b. Причем, мы не
просто напишем алгоритм, а еще выполним его тестирование с применением
тестирующей функции. То есть, это будет полноценный пример, показывающий
принцип разработки программ с использованием функций и тестов.
Но, вначале пару
слов о самом алгоритме Евклида, о принципе его работы. Сначала рассмотрим его
медленный, но простой вариант.
Например, пусть
даны два натуральных числа: a = 18 и b = 24. Чтобы
определить для них НОД, будем действовать, следующим образом. Из большего
значения вычтем меньшее и результат сохраним в переменной с большим значением,
то есть, в b. Фактически,
это означает, что мы выполняем операцию: b = b – a. Теперь у нас
два значения a = 18, b = 6. Для них
повторяем тот же самый процесс. Здесь большее уже переменная a, поэтому,
корректируем ее значение, вычитая меньшее. Получаем новую пару a = 12, b = 6. Опять
повторяем этот процесс и видим, что a = 6, b = 6 –
переменные равны. В этом случае останавливаем алгоритм и получаем, что НОД(18,
24) = 6, что, в общем то, верно.
Весь этот
алгоритм можно представить следующим псевдокодом:
пока
a != b
находим большее среди a и b
уменьшаем большее на величину меньшего
выводим
полученное значение величины a (или b)
Давайте его
опишем с помощью, следующей функции:
def get_nod(a, b): """Вычисляется НОД для натуральных чисел a и b по алгоритму Евклида. Возвращает вычисленный НОД. """ while a != b: if a > b: a -= b else: b -= a return a
Смотрите, здесь
вначале идет многострочная строка с описанием работы функции. Так рекомендуется
делать для ключевых функций программы, чтобы другие программисты могли быстро
понимать, как их применять на практике. А, далее, после описания следует сам
алгоритм Евклида.
Выполним эту
функцию со значениями аргументов 18 и 24:
res = get_nod(18, 24) print(res)
Видим в консоли верное
значение 6. Вот пример правильного оформления ключевых функций программы. Мало
того, встроенная функция:
позволяет
выводить описание указанных функций. И мы видим в консоли наше сформированное сообщение.
Это очень удобно, особенно при групповой работе над проектом.
После того, как
функция определена, ее следует протестировать и убедиться в корректности
возвращаемых результатов. Для этого тестировщик создает свою вспомогательную
функцию. Используя наши текущие знания, мы ее опишем, следующим образом:
def test_nod(func): # -- тест №1 ------------------------------- a = 28 b = 35 res = func(a, b) if res == 7: print("#test1 - ok") else: print("#test1 - fail") # -- тест №2 ------------------------------- a = 100 b = 1 res = func(a, b) if res == 1: print("#test2 - ok") else: print("#test2 - fail") # -- тест №3 ------------------------------- a = 2 b = 10000000 st = time.time() res = func(a, b) et = time.time() dt = et - st if res == 2 and dt < 1: print("#test3 - ok") else: print("#test3 - fail")
В первых двух
тестах мы проверяем корректность вычислений, а в третьем – еще и скорость
работы. Конечно, это довольно примитивное тестирование, показывающее лишь
принцип разработки программы, но для учебных целей вполне достаточно.
Далее, выполним
импорт нужного нам модуля time для вызова
функции time():
и в конце вызовем
тестирующую функцию для тестирования get_nod:
Смотрите, у нас
первые два теста прошли, а третий – не прошел, так как функция слишком долго
вычисляла результат.
Давайте поправим
ее и ускорим алгоритм Евклида. Как это можно сделать? Смотрите, если взять два
числа a = 2 и b = 100, то по
изначальному алгоритму мы будем делать многочисленные вычитания из b a, пока значения
не сравняются. То есть, мы здесь, фактически, вычисляем остаток от вхождения
двойки в сотню, а это есть не что иное, как операция:
b = b % a = 0
И никаких
циклических вычитаний! Это, очевидно, будет работать много быстрее. При этом,
как только получаем остаток равный нулю, то НОД – это значение меньшей
переменной, то есть, в нашем примере – a = 2.
То же самое для
предыдущих значений a = 18, b = 24. Получаем серию таких
вычислений:
b = 24 % 18 = 6
a = 18 % 6 = 0
Значит, НОД(18,
24) = 6. Видите, как это быстро и просто! На уровне псевдокода быстрый алгоритм
Евклида можно описать так:
пока
меньшее число больше 0
большему числу присваиваем остаток от деления на меньшее число
выводим большее
число
Реализуем его в
виде функции:
def get_fast_nod(a, b): """Вычисляется НОД для натуральных чисел a и b по быстрому алгоритму Евклида. Возвращает вычисленный НОД. """ if a < b: a, b = b, a while b != 0: a, b = b, a % b return a
Предлагаю, в
качестве самостоятельного задания, вам самим в деталях разобраться, как она
работает. А мы ее сразу протестируем:
Как видите, она
проходит все три наших теста.
Надеюсь, из
этого занятия мне удалось донести до вас общий принцип разработки и
тестирования ключевых программных функций. А также объяснить работу алгоритма
Евклида. Если все это понятно, то смело переходите к следующему уроку.
Курс по Python: https://stepik.org/course/100707
Видео по теме
Алгоритм Евклида – нахождение наибольшего общего делителя
Алгоритм Евклида – это алгоритм нахождения наибольшего общего делителя (НОД) пары целых чисел.
Наибольший общий делитель (НОД) – это число, которое делит без остатка два числа и делится само без остатка на любой другой делитель данных двух чисел. Проще говоря, это самое большое число, на которое можно без остатка разделить два числа, для которых ищется НОД.
Решение задачи на языке программирования Python
Алгоритм нахождения НОД делением
- Большее число делим на меньшее.
- Если делится без остатка, то меньшее число и есть НОД (следует выйти из цикла).
- Если есть остаток, то большее число заменяем на остаток от деления.
- Переходим к пункту 1.
Пример:
Найти НОД для 30 и 18.
30 / 18 = 1 (остаток 12)
18 / 12 = 1 (остаток 6)
12 / 6 = 2 (остаток 0)
Конец: НОД – это делитель 6.
НОД (30, 18) = 6
a = int(input()) b = int(input()) while a != 0 and b != 0: if a > b: a = a % b else: b = b % a print(a + b)
В цикле в переменную a или b записывается остаток от деления. Цикл завершается, когда хотя бы одна из переменных равна нулю. Это значит, что другая содержит НОД. Однако какая именно, мы не знаем. Поэтому для определения НОД находим сумму этих переменных. Поскольку в одной из переменных ноль, он не оказывает влияние на результат.
Если условием завершения цикла является равенство хотя бы одной из переменных нулю (a == 0 or b == 0), то условием продолжения его работы является обратное этому условие – обе переменные должны иметь отличные от нуля значения (a != 0 and b != 0).
Для того, чтобы вышеприведенная программа могла обрабатывать отрицательные числа, в логическом выражении при if должны сравниваться модули значений переменных: if abs(a) > abs(b):. Иначе большим числом может оказаться меньшее по модулю. В этом случае интерпретатор Питона в качестве остатка от деления выдает вещественное число. В результате это приводит к зацикливанию, так как низвести переменные до нуля становится как минимум маловероятным.
Алгоритм нахождения НОД вычитанием
- Из большего числа вычитаем меньшее.
- Если получается 0, значит, числа равны друг другу и являются НОД (следует выйти из цикла).
- Если результат вычитания не равен 0, то большее число заменяем на результат вычитания.
- Переходим к пункту 1.
Пример:
Найти НОД для 30 и 18.
30 – 18 = 12
18 – 12 = 6
12 – 6 = 6
6 – 6 = 0
Конец: НОД – это уменьшаемое или вычитаемое.
НОД (30, 18) = 6
a = int(input()) b = int(input()) while a != b: if a > b: a = a - b else: b = b - a print(a)
Функция, вычисляющая НОД
def gcd(m, n): while m != n: if m > n: m = m - n else: n = n - m return n a = int(input()) b = int(input()) print(gcd(a, b))
Функция gcd модуля math
В модуле math языка программирования Python есть функция gcd, вычисляющая наибольший общий делитель двух чисел.
>>> import math >>> math.gcd(30, 18) 6
Больше задач в PDF
|
2 / 2 / 0 Регистрация: 25.03.2018 Сообщений: 91 |
|
|
1 |
|
Наибольший общий делитель для списка натуральных чисел26.03.2018, 20:25. Показов 33595. Ответов 11
В модуле math есть функция math.gcd(a, b), возвращающая наибольший общий делитель (НОД) двух чисел. При помощи functools.reduce вычислите и напечатайте наибольший общий делитель для списка натуральных чисел, поступающих в стандартный поток ввода. Формат ввода Формат вывода
0 |
|
Просто Лис
5088 / 3255 / 1008 Регистрация: 17.05.2012 Сообщений: 9,534 Записей в блоге: 9 |
|
|
27.03.2018, 06:33 |
2 |
|
И? В чём сложности?
0 |
|
2 / 2 / 0 Регистрация: 25.03.2018 Сообщений: 91 |
|
|
27.03.2018, 16:06 [ТС] |
3 |
|
Рыжий Лис, не понял как это сделать
0 |
|
Просто Лис
5088 / 3255 / 1008 Регистрация: 17.05.2012 Сообщений: 9,534 Записей в блоге: 9 |
|
|
27.03.2018, 16:31 |
4 |
|
functools.reduce не знаете как воспользоваться?
0 |
|
2 / 2 / 0 Регистрация: 25.03.2018 Сообщений: 91 |
|
|
27.03.2018, 16:35 [ТС] |
5 |
|
Рыжий Лис, знал бы – не написал бы сюда
0 |
|
Рыжий Лис Просто Лис
5088 / 3255 / 1008 Регистрация: 17.05.2012 Сообщений: 9,534 Записей в блоге: 9 |
||||
|
27.03.2018, 16:44 |
6 |
|||
|
Аха-ха-ха:
0 |
|
2 / 2 / 0 Регистрация: 25.03.2018 Сообщений: 91 |
|
|
28.03.2018, 22:23 [ТС] |
7 |
|
Рыжий Лис, Answers do not match: out = 6, corr = 1
0 |
|
IRIP 513 / 145 / 27 Регистрация: 18.04.2015 Сообщений: 1,872 Записей в блоге: 15 |
||||
|
09.07.2018, 15:57 |
8 |
|||
|
Pavlin235, вот вроде решение
Добавлено через 6 минут
0 |
|
Garry Galler
5407 / 3831 / 1214 Регистрация: 28.10.2013 Сообщений: 9,554 Записей в блоге: 1 |
||||
|
09.07.2018, 16:32 |
9 |
|||
|
Как можно еще больше сократить это решение?
Но ТС нужна была не кастомная функция НОД, а функциональный подход с использованием reduce для списка.
0 |
|
IRIP 513 / 145 / 27 Регистрация: 18.04.2015 Сообщений: 1,872 Записей в блоге: 15 |
||||
|
09.07.2018, 16:50 |
10 |
|||
|
Но ТС нужна была не кастомная функция НОД, а функциональный подход с использованием reduce для списка вроде мы с ним по одной программе занимаемся… конкретно вот этот код как можно сократить, чтобы он сохранял свою работоспособность?
заменить везде число1 = число1 % число2 на число1 %= число2
0 |
|
Рюмка_на_столе 15 / 15 / 0 Регистрация: 05.01.2020 Сообщений: 8 |
||||
|
16.03.2020, 19:37 |
11 |
|||
3 |
|
57 / 54 / 3 Регистрация: 02.11.2019 Сообщений: 228 |
|
|
10.04.2020, 14:46 |
12 |
|
Рюмка_на_столе, супер! Просто жжешь!
0 |
