25.03 Маски

Решение через циклы

count = 0
for x in "1234567890":
    count += (int("12" + "4" + x + "65") % 141 == 0) # проверка, что число удовлетворяет маске с пустой звёздочкой
    for y in "1234567890":
        count += (int("12" + y + "4" + x + "65") % 141 == 0) # проверка, что число удовлетворяет маске с одним символом в звёздочке
        for z in "1234567890":
            count += (int("12" + y + z + "4" + x + "65") % 141 == 0) # проверка, что число удовлетворяет маске с двумя символами в звёздочке
print(count)

Решение через срезы

count = 0
for x in range(124080,10**8+1,141): # для оптимизации делаем цикл с шагом 141 с числа кратного 141, таким образом, мы будем проходиться только по кратным 141 числам
    n = str(x)
    if ’12’ in n[:2] and n[-4] == ’4’ and ’65’ in n[-2:]: # проверка, что число удовлетворяет маске
        count += 1
print(count)

Решение через циклы

ans = 0
for x in range(10):
    for i in [0, 5]:
        #любое число, оканчивающееся на 0 или 5, делится на 5
        ans += 1
print(ans)

Решение через срезы

count = 0
for x in range(803210,10**6+1,5): # для оптимизации делаем цикл с шагом 5 с числа кратного 5, таким образом, мы будем проходиться только по кратным 5 числам
    n = str(x)
    if n[0] == ’8’ and ’321’ in n[2:5]: # проверка, что число удовлетворяет маске
        count += 1
print(count)

Решение через циклы

ans = 0
for x in range(10): # перебор вопроса
    for i in range(10): # перебор вопроса
        n = int(’9’ + str(x) + ’123’ + str(i)) # составляем число, удовлетворяющее маске
        if n % 7 == 0:
            ans += 1
print(ans)

Решение через срезы

count = 0
for x in range(901236,10**6+1,7): # для оптимизации делаем цикл с шагом 7 с числа кратного 7, таким образом, мы будем проходиться только по кратным 7 числам
    n = str(x)
    if n[0] == ’9’ and ’123’ in n[2:5]: # проверка, что число удовлетворяет маске
        count += 1
print(count)

Решение через циклы

ans = 0
# пустая звёздочка
if 2738 % 7 == 0: # составляем число, удовлетворяющее маске
    ans += 1
#односимвольная звёздочка
for w in range(10):
    s1 = ’2738’ + str(w) # составляем число, удовлетворяющее маске
    if int(s1) % 7 == 0:
        ans += 1
#двухсимвольная звёздочка
for w in range(10):
    for z in range(10):
        s2 = ’2738’ + str(w) + str(z) # составляем число, удовлетворяющее маске
        if int(s2) % 7 == 0:
            ans += 1
print(ans)

Решение через срезы

count = 0
for x in range(2744,10**6+1,7): # для оптимизации делаем цикл с шагом 7 с числа кратного 7, таким образом, мы будем проходиться только по кратным 7 числам
    n = str(x)
    if ’2738’ in n[:4]: # проверка, что число удовлетворяет маске
        count += 1
print(count)

Решение через циклы

ans = 0
for i in range(10):
    for j in range(10):
        # пустая звёздочка
        s = ’829’ + str(i) + ’17’ + str(j) # составляем число, удовлетворяющее маске
        if int(s) % 31 == 0:
            ans += 1
        #односимвольная звёздочка
        for w in range(1, 10): #число не начинается с 0
            s1 = str(w) + ’829’ + str(i) + ’17’ + str(j) # составляем число, удовлетворяющее маске
            if int(s1) % 31 == 0:
                ans += 1
        #двухсимвольная звёздочка
        for w in range(1, 10): #число не начинается с 0
            for z in range(10):
                s2 = str(w) + str(z) + ’829’ + str(i) + ’17’ + str(j) # составляем число, удовлетворяющее маске
                if int(s2) % 31 == 0:
                    ans += 1
print(ans)

Решение через срезы

count = 0
for x in range(8290175,10**9+1,31): # для оптимизации делаем цикл с шагом 31 с числа кратного 31, таким образом, мы будем проходиться только по кратным 31 числам
    n = str(x)
    if ’17’ in n[-3:-1] and ’829’ in n[-7:-4]: # проверка, что число удовлетворяет маске
        count += 1
print(count)

Решение через циклы

# тройки чисел, которые могут быть в числе, удовлетворяющем маске
# для оптимизации делаем цикл с шагом 2091 с числа кратного 2091, таким образом, мы будем проходиться только по кратным 2091 числам(НОК 123 и 17 равен 2091)
for i in range(123 * 17, 10 ** 7, 2091):
    s = str(i)
    if s[0] == ’1’ and s[-1] == ’5’ and len(s) > 4: # если число частично удовлетворяет маске
        fl = False
        for j in range(1, len(s) - 1): # проходимся по центру числа
            t = s[j:j + 3] # проверяем тройку подряд идущих символов
            if t[0] == ’2’ and t[-1] == ’3’: # если первый символ равен 2, а последний - 3 в текущей тройке
                fl = True # значит, что число полностью удовлетворяет маске
                break
        if fl:
            print(i, end=’ ’)

Решение через срезы

m = [’203’,’213’,’223’,’233’,’243’,’253’,’263’,’273’,’283’,’293’] # тройки чисел, которые могут быть в числе, удовлетворяющем маске
# для оптимизации делаем цикл с шагом 2091 с числа кратного 2091, таким образом, мы будем проходиться только по кратным 2091 числам(НОК 123 и 17 равен 2091)
for x in range(12546,10**7+1,2091):
    n = str(x)
    if n[0] == ’1’ and n[-1] == ’5’: # проверяем, что число удовлетворяет маске
        if any(i in n for i in m): # если хотя бы одна из троек символов есть в числе, значит, число полностью удовлетворяет маске
            print(x)

Решение через циклы

# пустая звёздочка
for i in ’0123456789’:
    s = ’8’ + i + ’0191’ # составляем число, удовлетворяющее маске
    if int(s) % 19 == 0 and int(s) % 2 != 0:
        print(s, end=’ ’)
    for j in ’0123456789’: # одна цифра в звёздочке
        t = s[:3] + j + s[3:] # составляем число, удовлетворяющее маске
        if int(t) % 19 == 0 and int(t) % 2 != 0:
            print(t, end=’ ’)

Решение через срезы

# для оптимизации делаем цикл с шагом 38 с нечётного числа кратного 19, таким образом, мы будем проходиться только по кратным 19 числам и не кратным 2
for x in range(800223,10**7+1,38):
    n = str(x)
    if n[0] == ’8’ and n[2] == ’0’ and ’191’ in n[-3:]: # проверяем, что число удовлетворяет маске
        print(x)

Решение через циклы:

Для решения данной задачи через циклы потребуется перебрать варианты в заданном диапазоне и с помощью условных операторов проверить, подходит ли число под заданную маску. Зададим цикл от числа, в котором будет минимально возможное число цифр (звёздочки меняем на пустоту и получаем 7 знаков), первая цифра в нашем числе - 9, меньше проверять смысла нет, если проанализировать заданную маску. Далее возьмём минимально возможное, кратное 111. Задаём цикл до максимального числа (по условию) с шагом 111, что автоматически учтёт кратность 111. Проверим каждое полученное число и выведем нужные.

# Для оптимизации делаем цикл с шагом 111 с числа кратного 111, таким образом, мы будем проходиться только по кратным 111 числам
# Возьмём минимальное число (уберём звёздочки и поставим первой 9), опираясь на маску
for i in range(9005208, 10 ** 7 + 1, 111):
    s = str(i) # Сделаем строку, чтобы проверить число, опираясь на индексы
    if s[0] == "9" and s[3] == "5" and s[4] == "1" and s[6] == "3": # Проверяем, что число удовлетворяет маске
        print(i, end=" ") # Выводим его

Решение через fnmatch:

Функция fnmatch позволяет проверить совпадение заданной строки с маской. В неё уже встроены обозначения звёздочки и знака вопроса, а значит нам нужно просто сделать перебор. Он будет полностью аналогичен перебору с циклов, но теперь мы будем использовать функцию для проверки маски. Выведем подходящие числа.

from fnmatch import fnmatch # Импортируем функцию
# Для оптимизации делаем цикл с шагом 111 с числа кратного 111, таким образом, мы будем проходиться только по кратным 111 числам
# Возьмём минимальное число (уберём звёздочки и поставим первой 9), опираясь на маску
for x in range(9005208, 10**7+1,111):
    if fnmatch(str(x), "9??5*1*?3"): # Проверяем, что число удовлетворяет маске. Функция всё сделает за нас.
        print(x) # Выводим подходящие числа

Решение через циклы

ans = 0
for i in range(1, 10):
    # пустая звёздочка
    s = str(i) + ’1231’ # составляем число, удовлетворяющее маске
    if int(s) % 11 == 0:
        ans += 1
    #односимвольная звёздочка
    for w in range(10):
        s1 = str(i) + ’123’ + str(w) + ’1’ # составляем число, удовлетворяющее маске
        if int(s1) % 11 == 0:
            ans += 1
    #двухсимвольная звёздочка
    for w in range(10):
        for z in range(10):
            s2 = str(i) + ’123’ + str(w) + str(z) + ’1’ # составляем число, удовлетворяющее маске
            if int(s2) % 11 == 0:
                ans += 1
print(ans)

Решение используя itertools

from itertools import product
ans = 0
for i in range(1, 10): # симулируем вопрос
    for k in range(0, 3):
        for j in product(’0123456789’, repeat=k): # симулируем звёздочку
            s = str(i) + ’123’ + ’’.join(j) + ’1’ # составляем число, удовлетворяющее маске
            if int(s) % 11 == 0:
                ans += 1
print(ans)

Решение через срезы

count = 0
# для оптимизации делаем цикл с шагом 11 с числа кратного 11, таким образом, мы будем проходиться только по кратным 11 числам
for x in range(11231,10**7+1,11):
    n = str(x)
    if ’123’ in n[1:4] and n[-1] == ’1’: # проверяем, что число удовлетворяет маске
        count += 1
print(count)

Решение через циклы

Сначала мы перебираем все возможные варианты для каждой позиции, где в маске стоит символ «?».

1. Для первого вопросительного знака мы пробегаемся по всем цифрам от 0 до 9.

2. Для второго вопросительного знака также перебираем цифры от 0 до 9.

3. На каждой итерации мы собираем строку, которая соответствует числу, вставляя выбранные цифры на места «?».

4. Полученную строку преобразуем в целое число.

5. Проверяем делимость этого числа на 29. Если условие выполняется, печатаем само число и результат деления на 29.

for a1 in ("0123456789"):  # Перебираем все цифры для первого ’?’
    for a2 in ("0123456789"):  # Перебираем все цифры для второго ’?’
        s = "34" + a1 + "8" + a2 + "97"  # Составляем строку числа
        n = int(s)  # Преобразуем строку в число
        if n % 29 == 0:  # Проверяем, делится ли число на 29
            print(n, n // 29)  # Выводим число и частное

Решение через fnmatch

В этом подходе мы используем встроенный модуль fnmatch, который позволяет сравнивать строки с шаблонами, содержащими символы «?» и «*».

1. Ограничиваем диапазон проверки числами от 3 000 000 до 4 000 000, так как маска «34?8?97» задаёт числа именно в этом промежутке.

2. Для каждого числа из диапазона преобразуем его в строку и проверяем, подходит ли оно под маску «34?8?97».

3. Если число подходит и делится на 29 без остатка, выводим его и частное.

# Импортируем модуль fnmatch для нужной функции
from fnmatch import *

# Нет смысла рассматривать числа вне данного промежутка,
# т.к они точно не подойдут
for i in range(3000000, 4000000):
    # fnmatch — функция, сравнивающая строку с указанной маской
    # Возвращает True, если строка подходит к маске
    if fnmatch(str(i), "34?8?97") and i % 29 == 0:
        print(i, i // 29)

Решение через срезы

Здесь мы используем оптимизацию: перебираем только числа, кратные 29.

1. Для этого начинаем цикл с числа 3 408 109 (это ближайшее к маске число, которое делится на 29) и идём до , увеличивая шаг на 29.

2. Каждое число переводим в строку.

3. Проверяем условия маски:

1) первые две цифры равны «34»;

2) четвёртая цифра равна «8»;

3) последние две цифры равны «97».

4. Если все условия выполняются, выводим число и частное от деления.

# для оптимизации пишем цикл с шагом 29, начиная с числа кратного 29,
# таким образом, мы будем проходиться только по кратным 29 числам
for x in range(3408109, 10**7 + 1, 29):
    n = str(x)
    if "34" in n[:2] and n[3] == "8" and "97" in n[-2:]:  # проверяем маску
        print(x, x // 29)

# Импортируем модуль fnmatch для нужной функции
from fnmatch import *
# для оптимизации делаем цикл с шагом 34, начиная с числа кратного 34, для того чтобы проходиться по числам кратным 34
for i in range(9282,10**5,34):
    # fnmatch — функция, сравнивающая строку с указанной маской
    # Возвращает True, если строка подходит к маске
    if fnmatch(str(i), ’*9*270*’):
        print(i, i//34)

Решение через циклы

# Импортируем модуль fnmatch для нужной функции
from fnmatch import *
# для оптимизации делаем цикл с шагом 37, начиная с числа кратного 37, для того чтобы проходиться по числам кратным 37
for i in range(340733,10**6+1,37):
    # fnmatch — функция, сравнивающая строку с указанной маской
    # Возвращает True, если строка подходит к маске
    if fnmatch(str(i), ’3*4?7?9’):
        print(i, i//37)

Решение через срезы

# для оптимизации делаем цикл с шагом 37, начиная с числа кратного 37, для того чтобы проходиться по числам кратным 37
for x in range(340733,10**6+1,37):
    n = str(x)
    if n[0] == ’3’ and n[-1] == ’9’ and n[-3] == ’7’ and n[-5] == ’4’: # проверяем, что число удовлетворяет маске
        print(x,x//37)

Решение через fnmatch

# Импортируем модуль fnmatch для нужной функции
from fnmatch import *

# Диапазон чисел очень большой,
# и чтобы не ждать, можно выставить шаг в цикле как 12345/
# Таким образом цикл быстро пройдёт, и даже не придётся проверять число на кратность,
# т.к. все числа в цикле кратны 12345 из-за шага в 12345
# (главное начать цикл либо с нуля, либо с кратного числа)
for i in range(12345, 10**10, 12345):
    # fnmatch — функция, сравнивающая строку с указанной маской
    # Возвращает True, если строка подходит к маске
    if fnmatch(str(i), ’21?498*4*’):
        print(i, i//12345)

Решение через срезы

# для оптимизации делаем цикл с шагом 12345, начиная с числа кратного 12345, для того чтобы проходиться по числам кратным 12345
for x in range(2110995,10**10+1,12345):
    n = str(x)
    if ’21’ in n[:2] and ’498’ in n[3:6] and ’4’ in n[6:]: # проверяем, что число удовлетворяет маске
        print(x,x//12345)

Решение через fnmatch

# Импортируем модуль fnmatch для нужной функции
from fnmatch import *

# Диапазон чисел очень большой,
# и чтобы не ждать, можно выставить шаг в цикле как 215.
# Таким образом цикл быстро пройдёт, и даже не придётся проверять число на кратность,
# т.к. все числа в цикле кратны 215 из-за шага в 215
# (главное начать цикл либо с нуля, либо с кратного числа)
for i in range(215, 10**9, 215):
    # fnmatch — функция, сравнивающая строку с указанной маской
    # Возвращает True, если строка подходит к маске
    if fnmatch(str(i), ’589?132*’):
        print(i, i//215)

Решение через срезы

# для оптимизации делаем цикл с шагом 12345, начиная с числа кратного 12345, для того чтобы проходиться по числам кратным 12345
for x in range(5890140,10**9+1,215):
    n = str(x)
    if ’589’ in n[:3] and ’132’ in n[4:7]: # проверка, что число удовлетворяет маске
        print(x,x//215)

Решение через циклы

# Импортируем модуль fnmatch для нужной функции
from fnmatch import *
# для оптимизации делаем цикл с шагом 2409, начиная с числа кратного 2409, для того чтобы проходиться по числам кратным 2409
for i in range(79497,10**6 + 1,2409):
    # fnmatch — функция, сравнивающая строку с указанной маской
    # Возвращает True, если строка подходит к маске
    if fnmatch(str(i), ’7*9??*1’):
        print(i)

Решение через срезы

m = [str(i) for i in range(900,1000)] # комбинации из трёх цифр, которые могут быть в числе полностью удовлетворяющим маске
# для оптимизации делаем цикл с шагом 2409, начиная с числа кратного 2409, для того чтобы проходиться по числам кратным 2409
for x in range(79497,10**6+1,2409):
    n = str(x)
    if n[0] == ’7’ and n[-1] == ’1’: # проверяем, что число частично удовлетворяет маске
        if any(i in n[1:-1] for i in m): # проверяем, что число полностью удовлетворяет маске
            print(x)

Решение через fnmatch

# Импортируем модуль fnmatch для нужной функции
from fnmatch import *
# для оптимизации делаем цикл с шагом 126, начиная с числа кратного 126, для того чтобы проходиться по числам кратным 126
for i in range(14238,10**6 + 1,126):
    # fnmatch — функция, сравнивающая строку с указанной маской
    # Возвращает True, если строка подходит к маске
    if fnmatch(str(i), ’?4*2?6’) and i % 19 != 0:
        print(i)

Решение через срезы

# для оптимизации делаем цикл с шагом 126, начиная с числа кратного 126, для того чтобы проходиться по числам кратным 126
for x in range(14238,10**6+1,126):
    n = str(x)
    if n[1] == ’4’ and n[-1] == ’6’ and n[-3] == ’2’ and x % 19 != 0: # проверяем, что число удовлетворяет маске и при не кратно 19
        print(x)

Решение через fnmatch

# Импортируем модуль fnmatch для нужной функции
from fnmatch import *

for i in range(500175,10**6 + 1,95):
    # fnmatch — функция, сравнивающая строку с указанной маской
    # Возвращает True, если строка подходит к маске
    if fnmatch(str(i), ’5??1*?0’) \
            and str(i).count(’5’) == 1 \
            and str(i).count(’1’) == 1 \
            and str(i).count(’0’) == 1:
        print(i)

Решение через срезы

# для оптимизации делаем цикл с шагом 95, начиная с числа кратного 95, для того чтобы проходиться по числам кратным 95
for x in range(500175,10**6+1,95):
    n = str(x)
    if n[0] == ’5’ and n[3] == ’1’ and n[-1] == ’0’: # проверки, что число удовлетряет маске и условию
        if n.count(’5’) == 1 and n.count(’1’) == 1 and n.count(’0’) == 1:
            print(x)

Решение через fnmatch

# Импортируем модуль fnmatch для нужной функции
from fnmatch import *
# для оптимизации делаем цикл с шагом 61, начиная с числа кратного 61, для того чтобы проходиться по числам кратным 61
for i in range(59231,10**6 + 1,61):
    # fnmatch — функция, сравнивающая строку с указанной маской
    # Возвращает True, если строка подходит к маске
    if fnmatch(str(i), ’5*9?*2?’) \
            and i % 2 != 0 \
            and i % 19 != 0:
        print(i)

Решение через срезы

m = [str(i) for i in range(90,100)] # комбинации, которые могут быть в числе, удовлетворяющем маске
# для оптимизации делаем цикл с шагом 61, начиная с числа кратного 61, для того чтобы проходиться по числам кратным 61
for x in range(59231,10**6+1,61):
    n = str(x)
    if n[0] == ’5’ and n[-2] == ’2’: # проверка, что число частично удовлетворяет маске
        if any(i in n[1:-2] for i in m) and x % 2 !=0 and x % 19 != 0: # проверка, что число полностью удовлетворяет маске и выполняет условия
            print(x)

# Импортируем модуль fnmatch для нужной функции
from fnmatch import *

# Диапазон чисел очень большой,
# и чтобы не ждать, можно выставить шаг в цикле как 2048/
# Таким образом цикл быстро пройдёт, и даже не придётся проверять число на кратность,
# т.к. все числа в цикле кратны 2048 из-за шага в 2048
# (главное начать цикл либо с нуля, либо с кратного числа)
for i in range(2048, 10**7 + 1, 2048):
    # fnmatch — функция, сравнивающая строку с указанной маской
    # Возвращает True, если строка подходит к маске
    if fnmatch(str(i), ’*6*?3*96’):
        print(i, i//2048)

Решение через fnmatch

# Импортируем модуль fnmatch для нужной функции
from fnmatch import *
# для оптимизации делаем цикл с шагом 49, начиная с числа кратного 49, для того чтобы проходиться по числам кратным 49
for i in range(560070,10**6 + 1,49):
    # fnmatch — функция, сравнивающая строку с указанной маской
    # Возвращает True, если строка подходит к маске
    if fnmatch(str(i), ’56??3*9’):
        print(i, i//49)

Решение через срезы

# для оптимизации делаем цикл с шагом 49, начиная с числа кратного 49, для того чтобы проходиться по числам кратным 49
for x in range(560070,10**6+1,49):
    n = str(x)
    if ’56’ in n[:2] and n[-1] == ’9’ and n[4] == ’3’: # проверка, что число удовлетворяет маске
        print(x,x//49)