8.02 Подсчет количества слов/чисел

Решение аналитически:

Есть три вариации, при которых удовлетворяется условие: ЧНННЧ, ННННЧ, ЧНННН, где Н - нечётная цифра, Ч - чётная цифра. Рассмотрим первый случай: на первое место можно поставить одну из 4 цифр (число не может начинаться с 0). На остальные места - можно поставить по одной из 5 цифр. В итоге, чисел. Во втором случае, на все места можно расставить по одной из 5 цифр, в итоге во втором варианте будет следующее количество чисел: . В третьем варианте будет такое же количество чисел как и в первом. Осталось просуммировать полученные числа:

Решение программой с помощью циклов:

Напишем программу для перебора всевозможных 5-буквенных слов из заданных цифр. Для этого организуем вложенных циклов (по одному на каждую позицию в слове). Каждый цикл перебирает цифры заданной строки, формируя все возможные комбинации. Запишем количество подходящих слов.

s = "0123456789" # Все цифры
s1 = "02468" # Чётные
s2 = "13579" # Нечётные

k = 0 # Счётчик подходящих сочетаний
# Первая цифра любая, вторая, третья и четвёртая - нечётные, последняя любая
for a in "123456789":
    for b in s2:
        for c in s2:
            for d in s2:
                for e in s:
                    if a in s1 or e in s1: # Проверка по условию
                        k += 1 # Увеличим счётчик
print(k) # Выведем нужное количество

Решение программой с помощью модуля itertools:

Для решения задачи с помощью модуля itertools воспользуемся функцией product. Она генерирует все возможные слова из заданного алфавита. Запишем количество подходящих слов.

from itertools import product

count = set() # Множество подходящих слов
a = "0123456789" # Все цифры
nch = "13579" # Нечётные
ch = "02468" # Чётные
for x in product(a, nch, nch, nch, a): # Первая цифра любая, вторая, третья и четвёртая - нечётные, последняя любая
    s = "".join(x) # join объединяет буквы
    if s[0] != "0": # 0 не может быть первым
        if (s[0] in ch) or (s[-1] in ch): # Проверка по условию
            count.add(s) # Добавим в множество
print(len(count)) # Выведем нужную длину

Решение аналитически:

Всего слов, в которых буква Н встречается 0 раз: .

Для того чтобы посчитать количество слов, в которых буква Н встречается 1 раз рассмотрим пример. Пусть буква Н стоит на первой позиции, тогда на остальных семи позициях может стоять любая из 3х букв.

Всего мест где может стоять буква Н восемь. Следовательно всего слов, в которых буква Н встречается 1 раз: .

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

Вторая буква Н может стоять на любой из 7 позиций, если первая стоит на первой. Если первая Н стоит на второй позиции, то у второй буквы Н всего 6 вариантов, так как если поставить вторую букву Н на первую позицию, то получим дубликат.

Посчитав по аналогии число перестановок Н получаем, что всего слов, в которых буква Н встречается 2 раз: .

По аналогии получаем, что всего вариантов размещения трех Н в 8-буквенном слове 56, тогда всего слов, в которых буква Н встречается 3 раз: .

Осталось посчитать сумму полученных значений:

Решение программой с помощью циклов:

Напишем программу для перебора всевозможных 8-буквенных слов из заданных букв. Для этого организуем вложенных циклов (по одному на каждую позицию в слове). Каждый цикл перебирает буквы заданной строки, формируя все возможные комбинации. Запишем количество подходящих слов.

s = "ИНФА"

k = 0 # Счётчик подходящих слов
for a in s:
    for b in s:
        for c in s:
            for d in s:
                for e in s:
                    for f in s:
                        for g in s:
                            for h in s:
                                w = a + b + c + d + e + f + g + h # Формируем слово
                                if w.count("Н") <= 3: # Проверка по условию
                                    k += 1 # Увеличим счётчик

print(k) # Выведем нужное количество

Решение программой с помощью модуля itertools:

Для решения задачи с помощью модуля itertools воспользуемся функцией product. Она генерирует все возможные слова из заданного алфавита. Запишем количество подходящих слов.

from itertools import product

count = set() # Множество подходящих слов
# Получим все 8-буквенные слова из заданного алфавита
for x in product("ИНФА", repeat = 8):
    s = "".join(x) # join объединяет буквы
    if s.count("Н") <= 3: # Проверка по условию
        count.add(s) # Добавим в множество
print(len(count)) # Выведем нужное количество

Решение руками

На первой и второй позиции могут стоять всего 2 буквы, на четвертой и пятой могут встречаться 4 буквы. Так как буквы которые встречаются на 1, 2, 4 и 5 позициях не могут встретится на третьей позиции, то там можно использовать только одну букву E. Тогда всего различных кодовых слов может использовать Олег: .

Решение через циклы
Составим программу для перебора всех возможных кодовых слов. Для этого организуем 5 вложенных циклов, где каждый цикл отвечает за свою букву, причём порядок циклов совпадает с порядком букв в слове. Первые два цикла перебирают буквы GY, третий цикл задаёт букву E, четвёртый и пятый – буквы из ABCD. После формирования слова увеличиваем счётчик ответа, дополнительные проверки не нужны.

a = ’GY’  # буквы для первых двух позиций
a1 = ’E’  # буква для третьей позиции
a2 = ’ABCD’  # буквы для двух последних позиций

c = 0
for x1 in a:  # первая буква
    for x2 in a:  # вторая буква
        for x3 in a1:  # третья буква
            for x4 in a2:  # четвёртая буква
                for x5 in a2:  # пятая буква
                    # формируем слово (хотя это необязательно)
                    s = x1 + x2 + x3 + x4 + x5

                    c += 1  # увеличиваем счётчик слов

print(c)  # количество кодовых слов

Решение через itertools
Для перебора всех 5-буквенных комбинаций используем функцию product из модуля itertools. Она строит все слова из букв ABCDEGY, при чём каждая буква может встречаться более одного раза или не встречаться вовсе. После этого накладываем условия, используя индексацию: первые две позиции содержат буквы из GY, третья равна E, последние две – из ABCD.

from itertools import product

count = 0  # счётчик количества подходящих слов
for w in product(’ABCDEGY’, repeat=5):  # перебираем все комбинации
    s = ’’.join(w)  # формируем слово

    # проверяем соответствие условию задачи
    if s[0] in ’GY’ and s[1] in ’GY’ and s[2] == ’E’ and s[3] in ’ABCD’ and s[4] in ’ABCD’:
        count += 1  # если условия пройдены, увеличиваем ответ
print(count)  # количество кодовых слов

Решение через циклы
Составим программу для перебора всех семизначных чисел в пятеричной системе. Для этого организуем 7 вложенных циклов, где каждый цикл отвечает за свою цифру, причём порядок циклов совпадает с порядком цифр в числе. Чтобы избежать случая, когда первый ноль является незначащим, и число становится шестизначным, первая цифра перебирается из 1,2,3,4, остальные – из 0,1,2,3,4. После формирования числа проверяем два условия: что цифра 3 встречается ровно три раза (используя метод ), и что ни одна запрещённая комбинация 1 рядом с чётной цифрой не встречается. Для проверки последнего используем функцию , которая возвращает , если ни одна из запрещённых комбинаций не встречается. Если условия выполняются, увеличиваем счётчик ответа.

s = ’01234’  # допустимые цифры
m = [’12’, ’21’, ’10’, ’01’, ’14’, ’41’]  # запрещённые комбинации: 1 рядом с чётной цифрой

k = 0  # счётчик подходящих чисел
for a in ’1234’:  # первая цифра не может быть 0
    for b in s:
        for c in s:
            for d in s:
                for e in s:
                    for f in s:
                        for g in s:
                            n = a + b + c + d + e + f + g  # формируем число
                            # проверяем условия
                            if n.count(’3’) == 3 and all(x not in n for x in m):
                                k += 1  # увеличиваем счётчик

print(k)  # выводим количество подходящих чисел

Решение через itertools
Для перебора всех семизначных комбинаций используем функцию product из модуля itertools, которая строит все возможные комбинации заданной длины, где каждая буква может использоваться сколько угодно раз или не использоваться вовсе. После формирования числа преобразуем кортеж в строку, а затем проверяем условия через индексацию и all, аналогично способу с циклами, и увеличиваем счётчик.

from itertools import product  # импортируем product для перебора

count = 0  # счётчик подходящих чисел
m = [’12’, ’21’, ’10’, ’01’, ’14’, ’41’]  # запрещённые комбинации: 1 рядом с чётной цифрой

for x in product(’01234’, repeat=7):  # перебираем все 7-значные числа
    s = ’’.join(x)  # формируем число
    if s[0] != ’0’ and s.count(’3’) == 3 and all(x not in s for x in m):
        count += 1  # увеличиваем счётчик, если условия выполняются

print(count)  # выводим количество подходящих чисел

Решение через циклы
Составим программу для перебора всех восьмизначных чисел. Для этого организуем 8 вложенных циклов, где каждый цикл отвечает за свою цифру числа. Первый цикл перебирает цифры от 1 до 5, чтобы число не начиналось с нуля, остальные – от 0 до 5. После формирования числа мы проверяем условия:

1. В числе не более четырёх цифр 2 – проверяем через count.
2. Вычисляем сумму чётных цифр и сумму нечётных цифр числа через списочное выражение с условием.
3. Проверяем, что произведение суммы чётных на сумму нечётных цифр больше 256. Если все условия выполняются, увеличиваем счётчик ответа.

s = ’012345’  # все цифры шестеричной системы
k = 0  # счётчик подходящих чисел

# перебираем числа, задав каждую цифру
for a in ’12345’:  # первая цифра - не 0
    for b in s:
        for c in s:
            for d in s:
                for e in s:
                    for f in s:
                        for g in s:
                            for h in s:
                                n = a + b + c + d + e + f + g + h  # формируем число
                                sm0 = sum([int(i) for i in n if int(i) % 2 == 0])  # сумма чётных цифр
                                sm1 = sum([int(i) for i in n if int(i) % 2 == 1])  # сумма нечётных цифр
                                if n.count(’2’) <= 4 and sm0 * sm1 > 256:  # проверяем условия
                                    k += 1  # увеличиваем счётчик
print(k)  # выводим количество чисел

Решение через itertools
Для перебора всех восьмизначных чисел используем функцию product из модуля itertools, которая строит все последовательности длины 8 из цифр 0–5, где цифры могут повторяться или не встречаться вовсе. После формирования числа преобразуем кортеж в строку. Затем проверяем условия:

1. Первая цифра не равна нулю, иначе число будет семизначным.
2. В числе не более четырёх цифр 2 – проверяем через count.
3. Вычисляем сумму чётных и сумму нечётных цифр с помощью генераторов. Проверяем, что произведение суммы чётных на сумму нечётных цифр больше 256.

Если все условия выполняются, добавляем число во множество count, после отработки цикла выводим длину count.

from itertools import product

count = set()  # множество для хранения подходящих чисел
chet = ’024’  # чётные цифры шестеричной системы
nechet = ’135’  # нечётные цифры шестеричной системы

for x in product(’012345’, repeat=8):  # перебираем все 8-значные комбинации
    s = ’’.join(x)  # формируем число
    if s[0] != ’0’ and s.count(’2’) <= 4:  # первая цифра не 0 и не более четырёх двоек
        sm_chet = sum(int(i) for i in s if int(i) % 2 == 0)  # сумма чётных цифр
        sm_nechet = sum(int(i) for i in s if int(i) % 2 != 0)  # сумма нечётных цифр
        if sm_chet * sm_nechet > 256:  # проверяем условие на произведение
            count.add(s)  # добавляем число в множество
print(len(count))  # выводим количество подходящих чисел

Решение руками

Всего у нас 7 уникальных букв, которые можно переставить 7! способами: перестановок.

Код не может начинаться с Ь. Буква Ь может занимать одну из оставшихся 6 позиций. Количество перестановок, где Ь не на первом месте: перестановок.

Фиксируем РОСА как один блок: Тогда у нас есть блок РОСА и оставшиеся буквы: П, Б, Ь (4 элемента, "РОСА первый, П, Б, Ь - оставшиеся три). Эти 4 элемента можно переставить перестановки. Из них часть имеет Ь на первом месте. Если РОСА начинается с позиции 2, 3 или 4, то Ь может быть на первом месте. Количество таких случаев:

Для РОСА на позиции 2: первая буква — Ь, остальные П, Б (2 варианта).

Для РОСА на позиции 3: первая буква — Ь, вторая — П или Б (2 варианта).

Для РОСА на позиции 4: аналогично, 2 варианта.

Итого: перестановок, где Ь на первом месте и есть РОСА. Таким образом, количество запрещённых перестановок (с РОСА и без Ь на первом месте): .

Из общего числа перестановок без Ь на первом месте вычитаем количество перестановок, содержащих РОСА и удовлетворяющих всем ограничениям: .

Решение через циклы
Составим программу для перебора всех семибуквенных кодов из букв П, Р, О, С, Ь, Б, А. Для этого можно организовать 7 вложенных циклов, где каждый цикл отвечает за одну букву, причём порядок циклов совпадает с порядком букв слова. После формирования кода проверяем три условия: первая буква не равна Ь, все буквы уникальны (для проверки используем all с условием w.count(i) == 1, что возвращает True, если каждая буква встречается ровно один раз), и код не содержит последовательность РОСА. Если все условия выполнены, увеличиваем счётчик ответа.

s = "ПРОСЬБА"  # доступные буквы

k = 0  # счётчик подходящих кодов
for a in s:
    for b in s:
        for c in s:
            for d in s:
                for e in s:
                    for f in s:
                        for g in s:
                            w = a + b + c + d + e + f + g  # формируем слово

                            # проверяем, что первая буква не Ь, все буквы уникальны и нет последовательности "РОСА"
                            if a != "Ь" and all(w.count(i) == 1 for i in w) and "РОСА" not in w:
                                k += 1  # увеличиваем счётчик
print(k)  # выводим количество кодов

Решение через itertools
Для перебора всех семибуквенных комбинаций удобно использовать функцию permutations из модуля itertools, которая строит перестановки, при чём каждый символ заданной строки используется по одному разу. После формирования слова преобразуем кортеж в строку, проверяем, что первая буква не Ь и что строка не содержит РОСА. Если все условия выполнены, увеличиваем счётчик ответа.

from itertools import permutations

count = set()  # множество подходящих кодов
for x in permutations("ПРОСЬБА"):  # перебираем все перестановки
    s = "".join(x)  # формируем строку из кортежа
    if s[0] != "Ь" and "РОСА" not in s:  # проверяем условия
        count.add(s)  # добавляем подходящее слово в множество
print(len(count))  # количество подходящих кодов

Решение руками

Длина у логина 4, значит, нужно перемножить 4 числа, каждое из которых означает количество возможных букв на каждое место.

Первый множитель — 12(6 гласных букв, каждая может быть как строчной, так и заглавной)

Второй множитель и третий множитель — 62(26 букв, каждая может быть как строчной, так и заглавной, а также десятичные цифры)

Четвёртый множитель — 10(десятичные цифры)

Вычисляем — 12*62*62*10 = 461280

Решение через циклы
Напишем программу для перебора всех 4-символьных логинов с учётом условий: первая буква – гласная (строчная или заглавная), вторая и третья могут быть любыми буквами латинского алфавита или цифрами, четвёртая – только цифра. Для этого организуем 4 вложенных цикла, формирующих все комбинации. Каждый раз при составлении логина увеличиваем счётчик.

abc = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
ds = "0123456789"
k = 0  # счётчик допустимых логинов

# Перебор всех логинов по условиям
for a in "aeiouyAEIOUY":  # первая буква гласная
    for b in abc + ds:  # вторая буква - любая буква или цифра
        for c in abc + ds:  # третья буква - любая буква или цифра
            for d in ds:  # четвёртая - цифра
                k += 1  # увеличиваем счётчик
print(k)  # вывод количества допустимых логинов

Решение через itertools
Для решения с помощью модуля itertools используем функцию product, которая генерирует все комбинации заданной длины с повторениями. Первая буква берётся из строки гласных (строчных и заглавных), вторая и третья – из букв латинского алфавита и цифр, четвёртая – из цифр. В итоге все условия соблюдены за счёт правильного перебора. Каждое слово добавляется во множество, чтобы исключить дубликаты. В конце выводим количество элементов в множестве.

import string
from itertools import product

letters = string.ascii_letters  # все латинские буквы
digits = "0123456789"
count = set()  # множество для хранения уникальных логинов

# Первая буква - гласная
for x1 in product("aeiouyAEIOUY", repeat=1):
    s1 = "".join(x1)
    # Вторая и третья буквы - любые буквы или цифры
    for x2x3 in product(letters + digits, repeat=2):
        s2s3 = "".join(x2x3)
        # Четвёртая буква - цифра
        for x4 in product(digits, repeat=1):
            s4 = "".join(x4)
            count.add(s1 + s2s3 + s4)  # добавляем логин в множество
print(len(count))  # выводим количество уникальных логинов

Решение руками

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

Решение через циклы
Составим программу для перебора всех пятибуквенных слов из букв К, О, Н, Ф, Е, Т, А. Для этого можно организовать 5 вложенных циклов, где каждый цикл отвечает за одну букву, причём порядок циклов совпадает с порядком букв слова. После формирования слова проверяем условие, что в слове встречается не менее двух гласных (для проверки используем генератор sum(s.count(i) for i in gl) >= 2, что возвращает , если количество гласных в слове не меньше двух). Если условие выполнено, увеличиваем счётчик ответа, добавляя слово в множество (используем , чтобы не учитывать одинаковые слова).

a = "КОНФЕТА"  # допустимые буквы
count = set()  # множество подходящих слов, чтобы не было повторов
gl = "ОЕА"  # гласные буквы

# организуем 5 вложенных циклов, где каждый цикл отвечает за одну букву слова
for x1 in a:  # первая буква
    for x2 in a:  # вторая буква
        for x3 in a:  # третья буква
            for x4 in a:  # четвёртая буква
                for x5 in a:  # пятая буква
                    s = x1 + x2 + x3 + x4 + x5  # формируем слово

                    # проверяем условие: в слове хотя бы две гласные
                    # используем sum и count по всем гласным: суммируем количество каждой гласной
                    if sum(s.count(i) for i in gl) >= 2:
                        count.add(s)  # если условие выполнено, добавляем слово в множество

print(len(count))  # выводим количество подходящих слов

Решение через itertools
Для перебора всех пятибуквенных комбинаций удобно использовать функцию product из модуля itertools, которая строит все возможные комбинации заданной длины, где каждая буква может использоваться несколько раз или не использоваться вовсе. После формирования слова преобразуем кортеж в строку, проверяем, что в нём встречается не менее двух гласных, используя генератор sum(s.count(i) for i in gl) >= 2. Если условие выполнено, увеличиваем счётчик ответа.

from itertools import product

gl = "ОЕА"  # гласные буквы
ans = []  # список подходящих слов

for i in product("КОНФЕТА", repeat=5):  # перебираем все 5-буквенные комбинации
    s = "".join(i)  # преобразуем кортеж в строку
    count_gl = sum(s.count(j) for j in gl)  # считаем количество гласных

    if count_gl >= 2:  # если гласных не менее двух
        ans.append(s)  # увеличиваем счётчик, добавляя слово в список

print(len(ans))  # количество подходящих слов

Решение руками

На первое место слова мы можем поставить одну из 5 букв. На второе место можно поставить одну из 5 букв. На третье место можем расположить одну из 2 букв. На чётвертое место мы можем поставить только одну букву, ту, что мы ставили на второе место. На пятое место мы можем поставить только одну букву, ту, что мы ставили на первое место. В итоге, количество подходящих слов равно:

Решение через циклы
Составим программу для перебора всех возможных слов. Поскольку нам нужны палиндромы, можно организовать 3 вложенных цикла: первый задаёт первую и последнюю буквы, второй – вторую и предпоследнюю, а третий – центральную. Формируется именно палиндром, потому что строки собираются зеркально: слово имеет вид . Проверка в таком случае сводится только к тому, чтобы центральная буква была гласной, потому что «палиндромность» обеспечивается автоматически, а это условие уже соблюдено циклом, ведь может принимать только гласные буквы. Добавляем составленное слово в множество, чтобы избежать повторений. После отработки циклов выводим длину множества, после чего получая ответ.

a = "УСПЕХ"  # допустимые буквы
count = set()  # множество для подходящих слов

for x1 in a:  # первая и последняя буквы
    for x2 in a:  # вторая и предпоследняя буквы
        for x3 in "УЕ":  # центральная буква, только гласная
            s = x1 + x2 + x3 + x2 + x1  # составляем слово
            count.add(s)  # добавляем слово в множество
print(len(count))  # выводим количество слов

Решение через itertools
Для перебора всех возможных слов удобно использовать функцию из модуля , которая строит все 5-буквенные комбинации с повторениями. После формирования строки проверяем два условия. Во-первых, слово совпадает со своей обратной записью (s == s[::-1]), то есть оно является палиндром. Во-вторых, центральная буква находится в списке гласных. Если оба условия выполнены, добавляем слово в список, в конце выводим его длину.

from itertools import product

ans = []  # список подходящих слов
gl = "УЕ"  # задаём гласные буквы

for i in product("УСПЕХ", repeat=5):  # перебор всех 5-буквенных слов
    s = "".join(i)  # формируем строку

    # проверяем условие на палиндром и гласную в середине
    if s == s[::-1] and s[2] in gl:
        ans.append(s)
print(len(ans))  # количество слов

Решение руками

В пятизначном числе цифра 4 может находиться на одной из 5 позиций:

4 на 1-й позиции: 4 _ _ _ _

4 на 2-й позиции: _ 4 _ _ _

4 на 3-й позиции: _ _ 4 _ _

4 на 4-й позиции: _ _ _ 4 _

4 на 5-й позиции: _ _ _ _ 4

Рассмотрим каждую из позиций.

1 позиция: Сосед справа не может быть нечётной - 7 вариантов. Остальные цифры любые, кроме 4 (15 вариантов). Итого: . Аналогичным образом считается 5 позиция.

2 позиция: Соседи справа и слева не могут быть нечётными - каждый по 7 вариантов. Остальные цифры любые, кроме 4. Итого: . Аналогичным образом считаются 3 и 4 позиция.

Суммируем все случаи 23625(1-я позиция) + 11025(2-я) + 11025(3-я) + 11025(4-я) + 23625(5-я) = 80325.

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

Напишем программу для перебора всех 5-значных чисел в шестнадцатеричной системе (от 0 до F). Для этого организуем 5 вложенных циклов, формирующих все комбинации цифр. После составления числа проверяем условия: число содержит ровно одну цифру 4 (используем метод count), а каждая соседняя с ней цифра является чётной. Для проверки второго условия рассматриваем три случая расположения четвёрки:

1. В начале числа: проверяем цифру после 4;
2. В конце числа: проверяем цифру перед 4;
3. В любом другом месте: проверяем цифры до и после 4.

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

a = "0123456789ABCDEF"
count = set()

# Перебор всех 5-значных чисел
for x1 in a:
    for x2 in a:
        for x3 in a:
            for x4 in a:
                for x5 in a:
                    s = x1 + x2 + x3 + x4 + x5
                    if s.count("4") == 1:
                        ind = s.index("4")
                        if ind == 0:  # если 4 в начале
                            if int(s[ind + 1], 16) % 2 == 0:
                                count.add(s)
                        elif ind == 4:  # если 4 в конце
                            if int(s[ind - 1], 16) % 2 == 0:
                                count.add(s)
                        else:  # если 4 ни в начале, ни в конце
                            if int(s[ind - 1], 16) % 2 == 0 and int(s[ind + 1], 16) % 2 == 0:
                                count.add(s)
print(len(count))  # вывод количества чисел, удовлетворяющих условиям

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

Используем функцию product, которая генерирует все 5-значные комбинации из символов 0–F. Каждое число проверяем на наличие ровно одной цифры 4 и на то, чтобы все соседние с 4 цифры были чётными. Проверка аналогична решению через циклы. Все подходящие числа добавляем в список, и в конце выводим длину списка.

from itertools import product

ans = []

# Перебор всех 5-значных чисел
for i in product("0123456789ABCDEF", repeat=5):
    s = "".join(i)
    if s.count("4") == 1:
        ind = s.index("4")
        if ind == 0:  # если 4 в начале
            if int(s[ind + 1], 16) % 2 == 0:
                ans.append(s)
        elif ind == 4:  # если 4 в конце
            if int(s[ind - 1], 16) % 2 == 0:
                ans.append(s)
        else:  # если 4 ни в начале, ни в конце
            if int(s[ind - 1], 16) % 2 == 0 and int(s[ind + 1], 16) % 2 == 0:
                ans.append(s)
print(len(ans))  # вывод количества чисел, удовлетворяющих условиям

Решение руками

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

В таком случае, места в слове можно разбить на 2:

1) 3 места с нечётными номерами (1, 3, 5)

2) 3 места с чётными номерами (2, 4, 6)

Тогда достаточно будет найти количество вариантов получить алфавитный порядок на местах одной из чётностей, а другой вариант будет таким же.

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

Составим следующую таблицу, буквы из верхней строки стоят на первом месте, буквы из левого столбца – на втором месте:

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

Тогда общее количество слов получим произведением , так как нужно расставить буквы в алфавитном порядке два раза, в итоге получим способов, что и будет ответом.

Решение через циклы
Составим программу для перебора всех возможных 6-буквенных слов. Поскольку буквы на позициях одинаковой чётности должны быть в алфавитном порядке, организуем 6 вложенных циклов: первые, третьи и пятые буквы – для нечётных позиций, вторые, четвёртые и шестые – для чётных. Проверка на алфавитный порядок выполняется через сравнение s[0] <= s[2] <= s[4] и s[1] <= s[3] <= s[5]. Python сравнивает строки по порядковым номерам символов в таблице ASCII, что соответствует алфавитному порядку. Если условие выполнено, добавляем слово в множество для исключения повторений.

a = "МАШИНА"  # допустимые буквы
count = set()  # множество для подходящих слов

# перебираем все 6-буквенные комбинации с повторениями
for x1 in a:  # 1-я буква (нечётная позиция)
    for x2 in a:  # 2-я буква (чётная позиция)
        for x3 in a:  # 3-я буква (нечётная позиция)
            for x4 in a:  # 4-я буква (чётная позиция)
                for x5 in a:  # 5-я буква (нечётная позиция)
                    for x6 in a:  # 6-я буква (чётная позиция)
                        s = x1 + x2 + x3 + x4 + x5 + x6  # формируем слово
                        # проверяем условие: буквы на нечётных и чётных позициях в алфавитном порядке
                        if (s[0] <= s[2] <= s[4]) and (s[1] <= s[3] <= s[5]):
                            count.add(s)  # добавляем подходящее слово в множество
print(len(count))  # выводим количество слов

Решение через itertools
Для перебора всех возможных слов удобно использовать функцию product из модуля itertools, которая строит все 6-буквенные комбинации с повторениями. После формирования строки буквы на нечётных позициях (1, 3, 5) записываем в s1, а на чётных (2, 4, 6) – в s2. Далее проверяем, что буквы в s1 и s2 совпадают с тем порядком, который получился бы при их сортировке, то есть стоят в алфавитном порядке. Если условие выполнено, добавляем слово в список, а в конце выводим количество уникальных слов.

from itertools import product

ans = []  # список подходящих слов

for i in product("МАШИНА", repeat=6):  # перебор всех 6-буквенных слов с повторениями
    s = "".join(i)  # формируем строку
    s1 = s[0::2]  # буквы на нечётных позициях (1,3,5)
    s2 = s[1::2]  # буквы на чётных позициях (2,4,6)

    # проверяем условие: буквы на нечётных и чётных позициях в алфавитном порядке
    if s1 == "".join(sorted(s1)) and s2 == "".join(sorted(s2)):
        ans.append(s)
print(len(set(ans)))  # количество уникальных слов

Решение руками

Всего вариантов составления слов из 5 букв, в которых каждая из букв встречается по 1 разу: перестановок.

Вариантов составления таких слов, но начинающихся с Ь: перестановок.

Рассмотрим варианты составления таких слов, но с Ь после гласной буквы. Разместить пару гласная + Ь можно на одном из 4 мест, при этом вариантов гласных в паре - 2, а вариантов для оставшихся букв . Итого: .

Тогда нужных по условию слов будет: .

Решение через циклы
Составляем программу для перебора всех 5-буквенных комбинаций. Проверяем три условия: первая буква не «Ь» (используем индексацию), все буквы уникальны (используем set, количество уникальных букв должно быть 5) и «Ь» не стоит после гласной (используем конструкцию not in, чтобы избежать комбинаций АЬ и ОЬ). Если все условия выполнены, добавляем слово в множество, чтобы избежать повторов. В конце выводим длину множества.

a = "ОЛЬГА"  # допустимые буквы
count = set()  # множество для подходящих слов

for x1 in a:
    for x2 in a:
        for x3 in a:
            for x4 in a:
                for x5 in a:
                    s = x1 + x2 + x3 + x4 + x5  # формируем слово
                    # проверяем три условия:
                    # 1) первая буква не Ь
                    # 2) каждую букву можно использовать 1 раз
                    # 3) Ь не стоит после гласной (А или О)
                    if s[0] != "Ь" and len(set(s)) == 5 and "ОЬ" not in s and "АЬ" not in s:
                        count.add(s)
print(len(count))  # выводим количество подходящих слов

Решение через itertools
Используем permutations для перебора всех перестановок букв, что гарантирует использование каждой буквы ровно 1 раз. Для каждой строки проверяем, что первая буква не «Ь» и что «Ь» не стоит после гласной, аналогично решению с циклами. Если условия соблюдены, добавляем слово в список. В конце считаем количество слов.

from itertools import permutations

ans = []  # список подходящих слов
gl = "ОА"  # гласные буквы

for p in permutations("ОЛЬГА", 5):
    s = "".join(p)  # формируем строку

    # проверка условия: первая буква не Ь и Ь не после гласной
    if s[0] != "Ь" and "ОЬ" not in s and "АЬ" not in s:
        ans.append(s)

print(len(ans))  # количество подходящих слов

Решение руками

Рассмотрим различные расположения слова НОСБ: *НОСБ*******, **НОСБ******, ***НОСБ*****, ****НОСБ****, *****НОСБ***, ******НОСБ**, *******НОСБ*. Так как на первой позиции может стоять только гласная, а одна буква О находится в слове НОСБ, то всего букв на первой позиции может стоять 4.

Тогда, например, для *НОСБ******* всего слов будет: . Так как всего вариантов перестановок может быть 7, то умножаем это число на 7: . Так как в слове встречается две буквы О, то чтобы исключить повторения, нужно еще разделить это число на 2:

Решение через циклы
Составляем программу для перебора всех слов из оставшихся 8 букв, полученных удалением сочетания НОСБ из изначального слова. Первая буква выбирается только из гласных (Е, И, О, А). Проверяем, что буквы не повторяются, используя множество (его длина должна совпадать с длиной слова, тогда нет повторяющихся букв). Каждое слово добавляем в множество , чтобы убрать дубликаты. Поскольку слово НОСБ может стоять в середине на 7 разных позициях, итоговый результат умножаем на 7.

# оставляем буквы слова "ЕДИНОБОРСТВА", исключив НОСБ,
# так как оно фиксировано
a = "ЕДИОРТВА"
count = set()  # множество для уникальных слов
for x1 in "ЕИОА":  # первая буква - гласная
    for x2 in a:
        for x3 in a:
            for x4 in a:
                for x5 in a:
                    for x6 in a:
                        for x7 in a:
                            for x8 in a:
                                s = x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8

                                # по условию у нас перестановки,
                                # то есть каждая буква используется 1 раз
                                if len(set(s)) == len(s):
                                    count.add(s)

# умножаем на 7, потому что НОСБ можно расположить на 7 позиций
print(len(count) * 7)

Решение через itertools
С помощью permutations строим все перестановки оставшихся 8 букв. Проверяем, что первая буква – одна из гласных. Если условие выполнено, добавляем строку в множество. После перебора берём размер множества и умножаем на 7 (так как сочетание НОСБ может занимать 7 различных позиций).

from itertools import permutations

count = set()  # множество для уникальных слов

# составляем перестановки оставшихся букв
for x in permutations("ЕДИОРТВА"):
    s = "".join(x)

    # проверяем, что первая буква гласная
    if s[0] in "ЕИОА":
        count.add(s)

# умножаем на 7, это количество перестановок для НОСБ
print(len(count) * 7)

Сначала найдем слова в которых буквы А нет совсем: .

Теперь найдем все слова, в которых буква А встречается 1 раз, так как буква А может стоять только после согласной, то рассматривать будем сразу парой (* обозначает любую букву кроме А):

Эта пара может распологаться в слове в 4 местах: с 1 позиции, со 2, с 3 и с 4. Следовательно таких слов .

Теперь найдем все слова в которых буква А встречается дважды, так как буква А может стоять только после согласной, то рассматривать будем сразу парами (* обозначает любую букву кроме А):

В таком случае существует всего 3 различных варианта перестановок пар (первый вариант указан выше):

Следовательно таких слов .

Большее число раз буква А встречаться не может. Тогда найдем сумму всех значений: .

Решение через циклы
Составляем программу для перебора всех возможных 5-буквенных слов из букв слова ЗАПРЕТ. Первая буква не может быть А, потому что А должна идти только после согласной. Далее перебираем все варианты и проверяем условия: запрещаем АА, чтобы буквы А не стояли подряд, и запрещаем ЕА, так как А не может идти после гласной. Если условия выполнены, увеличиваем ответ. В итоге получаем количество допустимых слов.

a = "ЗАПРЕТ"  # допустимые буквы
a1 = "ЗПРЕТ"  # первой буквой не может быть А
n = 0

# перебираем все 5-буквенные слова
for x in a1:  # задаём первую букву, это не А
    for y in a:  # задаём остальные буквы
        for z in a:
            for w in a:
                for k in a:
                    s = x + y + z + w + k  # составляем слово

                    # запрещаем "АА" и "ЕА"
                    if not ("АА" in s) and not ("ЕА" in s):
                        n += 1

print(n)  # выводим ответ

Решение через itertools
С помощью product из модуля itertools перебираем все возможные 5-буквенные комбинации из букв слова ЗАПРЕТ. Так как буква может встречаться несколько раз или не встречаться вовсе, product подходит идеально. Данная функция перебирает все варианты с повторениями. Для каждой строки проверяем условия: первая буква не может быть А, последовательности АА и ЕА не должны встречаться. Если условия выполнены, увеличиваем ответ. В итоге получаем количество допустимых слов.

from itertools import product

s = "ЗАПРЕТ"
n = 0

# строим все 5-буквенные комбинации
for x in product(s, repeat=5):
    word = "".join(x)  # превращаем кортеж в строку

    # проверяем, что первая буква не "А", нет "АА" и нет "ЕА"
    if word[0] != "А" and not ("АА" in word) and not ("ЕА" in word):
        n += 1  # увеличиваем ответ

print(n)  # выводим ответ

Решение аналитически

Найдем все слова, в которых О стоит на 1 месте, за ней может стоять только согласная, на остальных трех позициях буквы могут стоять в произвольном порядке, так как гласная осталась всего 1 и она точно не будет соседствовать с другой гласной. Тогда таких слов всего .

В случае когда О стоит на последнем месте, мы просто может развернуть предыдущую комбинацию и получим тоже 18 слов.

Итого, ответ

Решение программой с помощью циклов

Напишем программу для перебора всевозможных 5-буквенных слов из букв Л, О, П, У, Х. Для этого организуем 5 вложенных циклов (по одному на каждую позицию в слове). Каждый цикл перебирает буквы заданной строки, формируя все возможные комбинации.

После составления очередного слова необходимо его проверить на соответствие условиям:

1. Все буквы уникальны → len(set(w)) == 5. set() – это множество, оно хранит только уникальные элементы, поэтому set(w) преобразует слово в множество, удаляя дубликаты. Если длина множества равна 5, значит, все буквы встречаются ровно один раз.

2. Буква О только на первом или последнем месте → будем проверять что буквы О нет на остльных позициях. Используем срез строки и проверим позиции 2, 3 и 4 (индексы 1, 2, 3), исключая крайние, на наличие среди них буквы О.

3. Нет соседних гласных ("О"и "У") → будем проверять что в составленном слове нет сочетаний ОУ или УО.

Если слово проходит все проверки, счетчик допустимых вариантов увеличивается.

s = "ЛОПУХ" # доступные буквы
k = 0 # счётчик допустимых слов

# Перебор всех возможных 5-буквенных комбинаций
for a in s:
    for b in s:
        for c in s:
            for d in s:
                for e in s:
                    w = a + b + c + d + e # формируем слово
                    # Проверяем условия:
                    # 1. Нет "ОУ" или "УО" (гласные не стоят рядом)
                    # 2. Все буквы уникальны (длина множества = 5)
                    # 3. Буква "О" не в середине (только на 1-й или 5-й позиции)
                    if ("ОУ" not in w and "УО" not in w
                            and len(set(w)) == 5
                                and "О" not in w[1:4]):  # w[1:4] — буквы на позициях 1, 2, 3
                        k += 1 # если условия выполнены, увеличиваем счётчик
print(k) # вывод результата

Решение программой с помощью модуля itertools

Для решения задачи с помощью модуля itertools воспользуемся функцией permutations. Она генерирует все возможные перестановки без повторений из заданного алфавита – лучший вариант для решения задачи, так как по условия каждая буква может встречаться ровно один раз, следовательно нет необходмости делать дополнительную проверку.

Условия «Буква О только на первом или последнем месте» и «две гласные буквы не могут стоять рядом» записываются в программе аналогично решению с помощью циклов.

from itertools import permutations # Импорт функции для генерации перестановок

s = "ЛОПУХ" # Исходный набор букв
n = 0 # Счётчик допустимых слов

# Перебираем все возможные перестановки из 5 букв
for x in permutations(s):
    w = "".join(x) # Преобразуем перестановку в строку

    # Проверяем условия:
    # 1. Нет "ОУ" или "УО" (гласные не стоят рядом)
    # 2. Буква "О" не в середине (только на 1-й или 5-й позиции)
    if not("ОУ" in w) and not("УО" in w) and not("О" in w[1:4]):
        n += 1 # Увеличиваем счётчик, если условия выполнены

print(n) # Выводим количество допустимых слов

Найдем слова с двумя буквами Ш; есть 10 вариантов расстановки, так как эта буква не может стоять на последнем месте. Так как рядом с Ш не может стоять буква М, то слева и справа от Ш можно поставить только одну из четырех букв, исключая М, а на другие оставшиеся места - одну из пяти.

Итого: .

Решение программой (циклы)
Составляем программу для перебора всех 6-буквенных слов из букв РОМАШК. Для каждого слова проверяем условия: методом count убеждаемся, что буква Ш встречается ровно два раза, с помощью индексации проверяем, что последняя буква не Ш, с помощью оператора in исключаем подстроки ШМ и МШ. Если все условия выполнены, добавляем слово в множество, чтобы убрать дубликаты. В конце выводим длину множества, что и будет количеством допустимых слов.

ans = set()  # множество для хранения подходящих слов
alf = "РОМАШК"  # допустимые буквы

for x1 in alf:
    for x2 in alf:
        for x3 in alf:
            for x4 in alf:
                for x5 in alf:
                    for x6 in alf:
                        # задаём слово
                        w = x1 + x2 + x3 + x4 + x5 + x6

                        # проверяем все условия:
                        # 1) ровно две буквы "Ш"
                        # 2) последняя буква не "Ш"
                        # 3) "Ш" не стоит рядом с "М"
                        if w.count("Ш") == 2 and w[-1] != "Ш" and "ШМ" not in w and "МШ" not in w:
                            ans.add(w)  # добавляем подходящее слово в множество

print(len(ans))  # выводим количество неповторяющихся подходящих слов

Решение программой (itertools)
Для решения задачи с помощью модуля воспользуемся функцией . Она генерирует все возможные слова с повторениями из заданного алфавита. Это удобно, так как буквы кроме Ш могут встречаться любое количество раз, а Ш должна встречаться ровно два раза. Остальные условия проверяются аналогично решению с циклами. Если слово удовлетворяет всем условиям, добавляем его в множество, чтобы исключить дубликаты.

from itertools import product

ans = set()  # множество для хранения подходящих слов
alf = "РОМАШК"  # допустимые буквы

# перебираем все 6-буквенные слова с повторениями
for w in product(alf, repeat=6):
    w = "".join(w)  # преобразуем кортеж в слово

    # проверяем условия задачи
    if w.count("Ш") == 2 and w[-1] != "Ш" and "ШМ" not in w and "МШ" not in w:
        ans.add(w)  # добавляем подходящее слово

print(len(ans))  # выводим количество неповторяющихся подходящих слов

Так как в алфавите всего 7 букв, при этом первая точно должна быть согласная, то на первом месте может быть только 4 варианта и буквы не могут повторяться, то далее идут просто оставшиеся буквы, то есть: случаев.

Решение программой (циклы):
Составляем программу для перебора всех 4-буквенных слов из алфавита, в котором 7 букв, из которых 4 согласные. Так как конкретные буквы нам не важны, будем использовать русские: согласные – «БВГД», гласные – «АУО». Для каждого слова проверяем условия: все буквы должны быть различными – для этого используем множество и сравниваем длину слова с длиной множества (если их длина совпадает, в слове нет повторяющихся букв); также проверяем, что первая буква согласная, используя индексацию. Если оба условия выполняются, добавляем слово в множество, чтобы убрать дубликаты. В конце выводим длину множества, что и будет количеством допустимых слов.

ans = set()  # множество для хранения неповторяющихся подходящих слов
# Смоделируем марсианский алфавит, в котором 7 букв и 4 согласные
alf = "АУОБВГД"

# через циклы задаём каждую из 4-х букв
for x1 in alf:
    for x2 in alf:
        for x3 in alf:
            for x4 in alf:
                w = x1 + x2 + x3 + x4  # составляем слово

                # проверяем, что все буквы различны и первая буква согласная
                if len(w) == len(set(w)) and w[0] in "БВГД":
                    ans.add(w)  # добавляем подходящее слово

print(len(ans))

Решение программой (itertools):
Для решения задачи с помощью модуля itertools воспользуемся функцией permutations. Она генерирует все возможные перестановки из 7 букв длиной 4, что удобно, так как все буквы должны быть различными. Условие про первую букву проверяем аналогично решению с циклами: с помощью индексации убеждаемся, что первая буква – согласная (Б, В, Г, Д). Если слово удовлетворяет всем условиям, добавляем его в множество, чтобы исключить дубликаты. В конце выводим длину множества, что и будет количеством допустимых слов.

from itertools import permutations

ans = set()  # множество для хранения неповторяющихся подходящих слов

# Смоделируем марсианский алфавит, в котором 7 букв и 4 согласные
alf = "АУОБВГД"

# перебираем все перестановки длины 4
for w in permutations(alf, 4):
    w = "".join(w)  # преобразуем кортеж в слово

    # проверяем, что первая буква согласная
    if w[0] in "БВГД":
        ans.add(w)  # добавляем подходящее слово

print(len(ans))

Всего вариантов без учета ограничений будет . Из данного общего количества надо вычесть случаи, когда буква П встречается 7,8 и 9 раз. Рассмотрим данные случаи отдельно

Когда буква П встречается 7 раз – случаев.

Когда буква П встречается 8 раз – случаев.

И когда П встречается 9 раз всего 1 случай.

Вычитаем наши случаи из общего количества – .

Решение программой (циклы):
Составляем программу для перебора всех 9-буквенных слов из заданных букв, используя вложенные циклы. Переходим к условию – так как буква П может встречаться не более 6 раз, для каждого слова проверяем, сколько раз она встречается, используя метод . Если условие выполнено, добавляем слово в множество, чтобы исключить дубликаты. После отработки всех циклов длина множества показывает количество допустимых слов.

ans = set()  # множество для хранения неповторяющихся подходящих слов
alf = "ПОБЕДА"  # допустимые буквы

# задаём каждую из 9 букв через циклы
for x1 in alf:
    for x2 in alf:
        for x3 in alf:
            for x4 in alf:
                for x5 in alf:
                    for x6 in alf:
                        for x7 in alf:
                            for x8 in alf:
                                for x9 in alf:
                                    # составляем слово
                                    w = x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9

                                    # проверяем, что буква П встречается не более 6 раз
                                    if w.count("П") <= 6:
                                        ans.add(w)  # добавляем подходящее слово

print(len(ans))  # выводим ответ

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

from itertools import product

ans = set()  # множество для хранения неповторяющихся подходящих слов
alf = "ПОБЕДА"  # допустимые буквы

# перебираем все слова длины 9
for w in product(alf, repeat=9):
    w = "".join(w)  # преобразуем кортеж в слово

    # проверяем, что буква П встречается не более 6 раз
    if w.count("П") <= 6:
        ans.add(w)  # добавляем подходящее слово

print(len(ans))  # выводим ответ

Решение руками

Существует всего 2 варианта расстановки цифр:

Четных цифр всего 5, но 0 не может стоять на 1 месте. Нечетных также 5, среди них нет ограничений. Тогда получаем: .

Решение через циклы
Составляем программу для перебора всех 8-значных чисел, в которых ни одна чётная цифра не стоит рядом с другой чётной, а ни одна нечётная — рядом с другой нечётной. Всего существуют два возможных шаблона чередования цифр: ЧНЧНЧНЧН и НЧНЧНЧНЧ, где Ч — чётная цифра, а Н — нечётная. Для каждого числа проверяем, что первая цифра не равна нулю в случае, если число начинается с чётной цифры (так как число станет семизначным), и формируем число по шаблону, перебирая все варианты цифр через циклы. Если число соответствует шаблону, добавляем его в множество, чтобы исключить дубликаты. В конце длина множества показывает количество допустимых чисел.

chet = "02468"
nechet = "13579"

count = set()
# составляем число вида ЧНЧНЧНЧН, где Ч - четная цифра, а Н - нечётная цифра
for x1 in "2468":  # число не может начинаться с 0
    for x2 in nechet:
        for x3 in chet:
            for x4 in nechet:
                for x5 in chet:
                    for x6 in nechet:
                        for x7 in chet:
                            for x8 in nechet:
                                s = x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8
                                count.add(s)
# составляем число вида НЧНЧНЧНЧ, где Ч - четная цифра, а Н - нечётная цифра
for x1 in nechet:
    for x2 in chet:
        for x3 in nechet:
            for x4 in chet:
                for x5 in nechet:
                    for x6 in chet:
                        for x7 in nechet:
                            for x8 in chet:
                                s = x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8
                                count.add(s)
print(len(count))

Решение через itertools
Для решения задачи с помощью модуля itertools мы используем функцию product, которая генерирует все возможные 8-значные последовательности цифр с повторениями. Каждое число представлено как кортеж цифр, и сначала проверяем, что оно не начинается с нуля (чтобы число не стало семизначным). Далее идёт проверка условия чередования чётных и нечётных цифр: проходим по всем парам соседних цифр и сравниваем их чётность. Если находим пару с одинаковой чётностью, число не подходит, и проверка прерывается. Если все соседние цифры чередуются корректно, счётчик увеличивается на единицу. В конце выводим значение счётчика, которое соответствует количеству всех допустимых 8-значных чисел.

from itertools import product

count = 0  # счётчик допустимых чисел

# генерируем все 8-значные последовательности цифр
for num in product("0123456789", repeat=8):
    if num[0] == "0":  # пропускаем числа, начинающиеся с нуля
        continue

    # проверяем чередование четных и нечетных цифр
    ok = True
    for i in range(7):
        # проверяем чётность соседних цифр
        if int(num[i]) % 2 == int(num[i + 1]) % 2:
            ok = False
            break

    if ok:
        count += 1  # увеличиваем счётчик, если число подходит

print(count)  # выводим ответ

Решение руками:

Случай 1: Код не содержит букву И

Каждая из 5 позиций может быть заполнена любой из 8 букв. кодов.

Случай 2: Код содержит ровно одну букву И

Буква И может стоять только на 2-й, 3-й или 4-й позиции (так как она не может быть на 1-й или 5-й).

И на 2-й позиции (_ И _ _ _):

1-я позиция: Не может быть Е (чтобы не было ЕИ). Доступно 7 букв (все, кроме И и Е).

3-я позиция: Не может быть Е (чтобы не было ИЕ). Доступно 7 букв.

4-я и 5-я позиции: Любые 8 букв (включая Е, но без И).

Количество кодов: кодов. Аналогичным образом считаемся И на 3-й позиции (_ _ И _ _), И на 4-й позиции (_ _ _ И _).

Итого для случая с одной буквой И: 3136(2-я позиция) + 3136(3-я позиция) + 3136(4-я позиция) = 9408 кодов.

Общее количество кодов: 32768(без И) + 9408(с одной И) = 42176 кодов.

Решение программой (циклы):
Составляем программу для перебора всех 5-буквенных кодов из букв ФЕСТИВАЛЬ, где буква И может встречаться не более одного раза, при этом она не может стоять на первой или последней позиции и не может быть рядом с буквой Е. Для каждого кода проверяем эти условия с помощью count и проверки подстрок ЕИ и ИЕ. Если код подходит, добавляем его в множество, чтобы исключить дубликаты, в конце выводим длину множества, что и будет количеством допустимых кодов.

ans = set()  # множество для хранения всех допустимых 5-буквенных кодов
alf = "ФЕСТИВАЛЬ"  # доступные буквы

# Перебираем все возможные комбинации из 5 букв через вложенные циклы
for x1 in alf:
    for x2 in alf:
        for x3 in alf:
            for x4 in alf:
                for x5 in alf:
                    w = x1 + x2 + x3 + x4 + x5  # формируем код

                    # Проверяем условия:
                    # 1. Буква И встречается не более одного раза
                    # 2. Буква И не на первой и не на последней позиции
                    # 3. Буква И не рядом с буквой Е
                    if w.count("И") <= 1 and w[0] != "И" and w[-1] != "И" and "ЕИ" not in w and "ИЕ" not in w:
                        ans.add(w)  # добавляем код во множество, чтобы исключить дубликаты
print(len(ans))  # выводим количество допустимых кодов

Решение программой (itertools):
Для решения задачи с помощью модуля воспользуемся функцией , которая генерирует все возможные комбинации букв ФЕСТИВАЛЬ длины 5. Каждую комбинацию преобразуем в строку, проверяем те же условия аналогично решению с циклами. Если код удовлетворяет условиям, добавляем его в множество. В конце выводим длину множества, что и будет количеством допустимых кодов.

from itertools import product

ans = set()  # множество для хранения всех допустимых 5-буквенных кодов
alf = "ФЕСТИВАЛЬ"  # доступные буквы

# Используем product для перебора всех возможных 5-буквенных комбинаций
for w in product(alf, repeat=5):
    w = "".join(w)  # преобразуем кортеж в строку

    # Проверяем условия:
    # 1. Буква И встречается не более одного раза
    # 2. Буква И не на первой и не на последней позиции
    # 3. Буква И не рядом с буквой Е
    if w.count("И") <= 1 and w[0] != "И" and w[-1] != "И" and "ЕИ" not in w and "ИЕ" not in w:
        ans.add(w)  # добавляем код во множество, чтобы исключить дубликаты
print(len(ans))  # выводим количество допустимых кодов