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

Аналитическое решение:

Для решения этой задачи нужно учесть все условия, которые были представлены:

В латинском алфавите 26 букв, 6 из них гласные. Учитывая, что буквы могут быть как строчными, так и заглавными, у нас получается 12 гласных букв. Цифр от 0 до 9 включительно - 10.

Теперь мы можем вычислить максимальное количество логинов, используя принцип умножения:

Первый символ может быть одной из 12 гласных букв.

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

Четвертый символ должен быть одной из 10 цифр.

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

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

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

# Импортируем модуль string, который содержит различные константы для работы со строками
import string

# Создаем строку гласных (как заглавных, так и строчных)
vowels = ’aeiouyAEIOUY’

# Создаем строку, которая содержит все английские буквы (заглавные и строчные) и цифры
letters_and_digits = string.ascii_letters + string.digits

# Создаем строку, которая содержит все цифры от 0 до 9
digits = string.digits

# Инициализируем счетчик на ноль, этот счетчик будет использоваться для подсчета количества строк
count = 0

# Перебираем все гласные
for v in vowels:
    # Перебираем все буквы и цифры для второго символа
    for l1 in letters_and_digits:
        # Перебираем все буквы и цифры для третьего символа
        for l2 in letters_and_digits:
            # Перебираем все цифры для четвертого символа
            for d in digits:
                # Увеличиваем счетчик на 1 для каждой сгенерированной строки
                count += 1

# Печатаем итоговое количество строк
print(count)

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

Всего можно составить таких слов , так как на 6 мест у нас есть 6 букв для расстановки.

Из них нужно вычесть те варианты, при которых две гласные стоят рядом. Вариантов поставить две гласные рядом всего два: ИА и АИ, комбинацию из двух букв можно разместить в 5-и местах, останется ещё 4 места и 4 буквы, значит количество вариантов расставить их будет равно .

Итоговая формула будет выглядеть вот так:

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

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

a = "ПРИКАЗ" # Наше слово
c = 0 # Итоговый счётчик
# Переборы для букв слова
for i in a:
    for j in a:
        for n in a:
            for k in a:
                for m in a:
                    for l in a:
                        s = i + j + n + k + m + l # Формируем слово
                        # Проверка, что каждая буква встречается единожды и что гласные не стоят рядом
                        if (s.count("П") == 1) and (s.count("Р") == 1) and (s.count("И") == 1) and (s.count("К") == 1) and (s.count("А") == 1) and (s.count("З") == 1) and (not "ИИ" in s) and (not "АИ" in s) and (not "ИА" in s) and (not "АА" in s):
                            c += 1
print(c) # Вывод ответа

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

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

from itertools import permutations # Импортируем permutations из модуля itertools. permutations - перестановки
count = 0 # Итоговый счётчик
for x in permutations("ПРИКАЗ"): # Проход по всевозможным перестановкам букв слова ПРИКАЗ
    s = "".join(x) # Формируем слово
    if "ИА" not in s and "АИ" not in s: # Проверка по условию
        count += 1
print(count) # Вывод ответа

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

Нам нужно создать 8-буквенные слова, начинающиеся и заканчивающиеся гласной буквой.

Первую и последнюю позицию можно занять способами.

Найдем количество способ, которым можно расставить 6 букв в центре. Рассмотрим 4 случая: количество букв «Н» 0, 1, 2 и 3.

1) Буква «Н» встречается 0 раз, тогда в центр можно поставить любые из трех букв на каждую позицию: .

2) Буква «Н» встречается 1 раз, тогда в центр можно поставить любые из трех букв на 5 позиций. Также букву «Н» на 6 мест можно разместить шестью разными способами: .

3) Буква «Н» встречается 2 раза, тогда в центр можно поставить любые из трех букв на 4 позиции. Также две буквы «Н» на 6 мест можно разместить 15-ю разными способами: .

4) Буква «Н» встречается 3 раза, тогда в центр можно поставить любые из трех букв на 3 позиции. Также три буквы «Н» на 6 мест можно разместить 20-ю разными способами: .

Общее число слов:

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

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

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:
                        for x7 in alf:
                            for x8 in alf:
                                w = x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 # Формируем слово
                                if w.count("Н") <= 3 and w[0] in "ИА" and w[-1] in "ИА": # Проверка по условию
                                    ans.add(w) # Добавим слово в множество
print(len(ans)) # Выведем нужное количество

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

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

from itertools import product

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

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

Если число делится на 5, то оно оканчивается либо на 5, либо на 0.

Если число оканчивается на 5, то число имеет вид: ЧНЧНЧНЧ5, где Ч – четное число, Н – нечетное число. Кроме 5 существует 4 нечетных числа. Четных чисел в таком случае 5. Но! Важно учесть, что число не может начинаться с 0, поэтому для первого цифры числа будет не 5 вариантов. а 4.

Получаем, количество вариантов: .

Если число оканчивается на 0, то число имеет вид: НЧНЧНЧН0, где Ч – четное число, Н – нечетное число. Кроме 0 существует 4 четных числа. Нечетных чисел в таком случае 5.

Получаем, количество вариантов: .

Итоговое число слов: .

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

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

#создаем строки с вариантами цифр числа
a = "0123456789"
a1 = "123456789"
d5 = "05"
ch = "02468"
nch = "13579"
# Создаем контейнер
pairs = set()
# Ввод счетчика
c = 0
for m in ch:
    for n in ch:
        pairs.add(m + n) # Все комбинации чётных чисел
for m in nch:
    for n in nch:
        pairs.add(m + n) # Все комбинации нечётных чисел
# Подчёт количества чисел
for i in a1:
    for j in a:
        for n in a:
            for k in a:
                for m in a:
                    for l in a:
                        for h in a:
                            for v in d5:
                                s = i + j + n + k + m + l + h + v # Формируем число
                                if all(s.count(i) <= 1 for i in s) and all(s.count(t) == 0 for t in pairs):
                                    c += 1
print(c)

# Различность цифр проверяет первое условие
# Наличие двух рядом стоящих чётных/нечётных цифр проверяет второе условие, тут мы сначала создаём массив для таких пар, составляем их с помощью вложенных циклов, а потом проверяем условием уже при составлении числа
# Проверки делимости на 5 тут нет, т.к. в качестве последней цифры либо 5, либо 0

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

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

from itertools import permutations

ans = set() # Множество подходящих слов
alf = "0123456789" # Цифры к задаче
# Получим все комбинации из 8 цифр из заданного алфавита
for w in permutations(alf, 8):
    w = "".join(w) # join объединит цифры
    if w[0] != "0" and w[-1] in "05": # Проверяем по условию
        f = 1 # Флаг для проверки условия с комбинациями
        for i in range(len(w) - 1):
            if int(w[i]) % 2 == int(w[i + 1]) % 2: # Если в слове есть гласная + гласная или согласная + согласная
                f = 0
                break
        if f: # Если условие с комбинациями соблюдено
            ans.add(w) # Добавим слово в множество
print(len(ans)) # Выведем нужное количество

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

На первое место мы можем поставить одну из 6 букв, на второе уже одну из 5, на третье – одну из 4, и так далее. Поэтому ответом будет

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

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

c = 0 # Счётчик слов
a = "ВЫЧМАТ" # Алфавит к задаче

for x1 in a:
    for x2 in a:
        for x3 in a:
            for x4 in a:
                for x5 in a:
                    for x6 in a:
                        s = x1 + x2 + x3 + x4 + x5 + x6 # Формируем слово
                        if (len(set(s)) == len(s)): # Если все буквы различны
                            c += 1 # Увеличим счётчик
print(c)

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

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

from itertools import permutations

c = 0 # Счётчик слов
a = "ВЫЧМАТ" # Алфавит к задаче

for s in permutations(a): # Пройдёмся по всем словам
    c += 1 # Увеличим счётчик

print(c)

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

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

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

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

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

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

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

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

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

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

ans = set() # Множество подходящих слов
alf = "ПРОГА" # Алфавит к задаче

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 # Формируем слово
                    if w.count("Г") <= 2: # Проверка по условию
                        ans.add(w) # Добавим слово в множество
print(len(ans)) # Выведем нужное количество

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

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

from itertools import product

ans = set() # Множество подходящих слов
alf = "ПРОГА" # Алфавит к задаче
# Получим все 5-буквенные слова из заданного алфавита
for w in product(alf, repeat = 5):
    w = "".join(w) # join объединит буквы
    if w.count("Г") <= 2: # Проверяем по условию
        ans.add(w) # Добавим слово в множество
print(len(ans)) # Выведем нужное количество

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

Рассмотрим пример, в котором буква А стоит на первой позиции, тогда на остальных 5 позициях может стоять любая из трех оставшихся букв.

Буква А может стоять в слове на любой из 6 позиций, тогда всего слов, подходящих под условие:

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

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

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 # Формируем слово
                        if w.count("А") == 1: # Проверка по условию
                            ans.add(w) # Добавим слово в множество
print(len(ans)) # Выведем нужное количество

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

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

from itertools import product

ans = set() # Множество подходящих слов
alf = "КВАС" # Алфавит к задаче
# Получим все 6-буквенные слова из заданного алфавита
for w in product(alf, repeat = 6):
    w = "".join(w) # join объединит буквы
    if w.count("А") == 1: # Проверяем по условию
        ans.add(w) # Добавим слово в множество
print(len(ans)) # Выведем нужное количество

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

На втором, пятом, шестом и седьмом месте могут стоять 5 букв, никаких ограничений нет.

На первом месте может стоять только гласная буквы, их две - У и А.

На третьем месте может стоять одна из двух букв - А или К, значит два варианта.

На четвертом месте могут стоять только согласные буквы, их три - С,М,К.

На восьмом месте может стоять только одна буква - У.

Итого: последовательностей.

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

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

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:
                        for x7 in alf:
                            for x8 in alf:
                                w = x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 # Формируем слово
                                if w[2] in "АК" and w[3] in "СМК" and w[0] in "УА" and w[-1] == "У": # Проверка по условию
                                    ans.add(w) # Добавим слово в множество
print(len(ans)) # Выведем нужное количество

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

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

from itertools import product

ans = set() # Множество подходящих слов
alf = "СУМКА" # Алфавит к задаче
# Получим все 8-буквенные слова из заданного алфавита
for w in product(alf, repeat = 8):
    w = "".join(w) # join объединит буквы
    if w[2] in "АК" and w[3] in "СМК" and w[0] in "УА" and w[-1] == "У": # Проверяем по условию
        ans.add(w) # Добавим слово в множество
print(len(ans)) # Выведем нужное количество

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

Всего существует вариантов кодовых слов.

1. Найдем количество слов без буквы М, в таком случае у нас есть набор из пяти букв на пять мест .

2. Найдем количество слов с одной буквой М:

М * * * * на месте * может быть любая буква из набора Ж,А,С,И,Н: М 5 5 5 5 вариантов для случая, когда буква М стоит на первом месте. Она может стоять на любом из пяти мест, следовательно, = 3125 слова с одной буквой М.

Так как нам нужно найти количество слов с двумя и более буквами М, то нам достаточно из всех вариантов вычесть слова без буквы М и слова с одной буквой М:

слов.

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

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

ans = set() # Множество подходящих слов
alf = "ЖАСМИН" # Алфавит к задаче

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 # Формируем слово
                    if w.count("М") >= 2: # Проверка по условию
                        ans.add(w) # Добавим слово в множество
print(len(ans)) # Выведем нужное количество

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

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

from itertools import product

ans = set() # Множество подходящих слов
alf = "ЖАСМИН" # Алфавит к задаче
# Получим все 5-буквенные слова из заданного алфавита
for w in product(alf, repeat = 5):
    w = "".join(w) # join объединит буквы
    if w.count("М") >= 2: # Проверяем по условию
        ans.add(w) # Добавим слово в множество
print(len(ans)) # Выведем нужное количество

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

Всего позиций 6, две из них отводится под букву Ч, а на оставшихся четырех местах может находиться любая буква из пятибуквенного набора Ж,Е,М,У,Г:

Ч Ч * * * * Р Р 5 5 5 5 вариантов слов, когда буква Ч стоит на первой и второй позиции.

Теперь нужно найти количество перестановок двух букв Ч, это считается по формуле: перестановок, где 6 - это сколькими способами мы можем выбрать место для первой буквы Ч, 5 - сколькими способами мы можем выбрать место для второй буквы Ч(5, так как одно место уже занято), поэтому всего вариантов , но так как буквы одинаковые, то нужно поделить еще на 2!, чтобы исключить повторение.

Тогда общее количество слов: .

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

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

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 # Формируем слово
                        if w.count("Ч") == 2: # Проверка по условию
                            ans.add(w) # Добавим слово в множество
print(len(ans)) # Выведем нужное количество

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

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

from itertools import product

ans = set() # Множество подходящих слов
alf = "ЖЕМЧУГ" # Алфавит к задаче
# Получим все 6-буквенные слова из заданного алфавита
for w in product(alf, repeat = 6):
    w = "".join(w) # join объединит буквы
    if w.count("Ч") == 2: # Проверяем по условию
        ans.add(w) # Добавим слово в множество
print(len(ans)) # Выведем нужное количество

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

Восьмиричная система счисления содержит 8 цифр: 0,1,2,3,4,5,6,7. Четыре четные цифры и четыре нечетные цифры.

Рассмотрим два случая, когда число начинается с нечетной цифры и когда с четной:

1. Н Ч Н Ч Н Ч Н, в таком случае (не забывая про то, что все цифры различны), получим чисел.

2. Ч Н Ч Н Ч Н Ч, тут надо помнить, что на первом месте не может стоять 0, тогда числа.

Итого: 576+432 = 1008 чисел.

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

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

ans = set() # Множество подходящих слов
alf = "01234567" # Цифры к задаче

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:
                            w = x1 + x2 + x3 + x4 + x5 + x6 + x7 # Формируем комбинацию
                            if len(w) == len(set(w)) and w[0] != "0": # Проверка по условию
                                f = 1 # Флаг будет 1, если в комбинации происходит чередование чётных и нечётных цифр
                                for i in range(len(w) - 1):
                                    if int(w[i]) % 2 == int(w[i + 1]) % 2:
                                        f = 0
                                        break
                                if f:
                                    ans.add(w) # Добавим слово в множество
print(len(ans)) # Выведем нужное количество

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

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

from itertools import permutations

ans = set() # Множество подходящих слов
alf = "01234567" # Цифры к задаче
# Получим все 7-буквенные слова из заданного алфавита
for w in permutations(alf, 7):
    w = "".join(w) # join объединит буквы
    if w[0] != "0": # Проверка по условию
        f = 1 # Флаг будет 1, если в комбинации происходит чередование чётных и нечётных цифр
        for i in range(len(w) - 1):
            if int(w[i]) % 2 == int(w[i + 1]) % 2:
                f = 0
                break
        if f:
            ans.add(w) # Добавим слово в множество
print(len(ans)) # Выведем нужное количество

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

Найдем слова без буквы Б, в таком случае на каждой из семи позиций может стоять любая буква из шестибуквенного набора В,Е,Р,Л,Ю,Д, слов.

Найдем слова с одной буквой Б; есть три варианта расстановки, так как эта буква не может стоять на первом и последнем месте:

* Б * * *

* * Б * *

* * * Б *

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

5 Б 5 6 6

6 5 Б 5 6

6 6 5 Б 5

Итого: 7776 + = 10476.

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

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

ans = set() # Множество подходящих слов
alf = "ВЕРБЛЮД" # Алфавит к задаче

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 # Формируем слово
                    if w.count("Б") <= 1 and w[0] != "Б" and w[-1] != "Б": # Проверка по условию
                        if "БЮ" not in w and "ЮБ" not in w:
                            ans.add(w) # Добавим слово в множество
print(len(ans)) # Выведем нужное количество

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

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

from itertools import product

ans = set() # Множество подходящих слов
alf = "ВЕРБЛЮД" # Алфавит к задаче
# Получим все 5-буквенные слова из заданного алфавита
for w in product(alf, repeat = 5):
    w = "".join(w) # join объединит буквы
    if w.count("Б") <= 1 and w[0] != "Б" and w[-1] != "Б": # Проверяем по условию
        if "БЮ" not in w and "ЮБ" not in w:
            ans.add(w) # Добавим слово в множество
print(len(ans)) # Выведем нужное количество

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

В предложенном алфавите согласных букв больше чем гласных, при этом они должны чередоваться между собой. Значит, слово не может начинаться с гласной. Получаем, что набор букв должен выглядеть как «СГСГС», где С - согласная, а Г - гласная.

Так как каждая буква должна появляться в слове только 1 раз, получаем число возможных вариантов:

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

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

s1 = "ПРК" # Согласные к задаче
s2 = "АЕ" # Гласные к задаче
cnt = 0 # Счётчик подходящих слов
# Слово, удовлетворяющее условие может выглядеть только следующим образом: СГСГС, где С - согласная буква, а Г - гласная буква.
for i in s1:
    for j in s2:
        for k in s1:
            for l in s2:
                for m in s1:
                    t = [i, j, k, l, m] # Формируем слово
                    tmp = set(t)
                    if len(tmp) == 5: # Если все буквы различны
                        cnt += 1 # Увеличим счётчик
print(cnt) # Выводим ответ

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

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

from itertools import permutations

count = set() # Множество подходящих слов

gl = "АЕ" # Гласные к задаче

for x in permutations("ПАРЕК"):
    s = "".join(x) # join объединит буквы
    # Проверка, что в слове нет подряд идуших гласных или согласных букв
    if all((s[i] in gl) != (s[i+1] in gl) for i in range(len(s)-1)):
        count.add(s) # Добавим слово в множество
print(len(count)) # Выведем нужное количество

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

Общее кол-во слов с учётом перестановок повторяющихся букв К и А:

Пусть КК = X, АА = Y(будто бы это одна буква), тогда количество слов с комбинациями КК и АА:

Количество слов с КК и без АА(набор букв Н, П, А, А, X): - 24(где встречается АА) = 36

Количество слов с АА и без КК — тоже 36.

Ответ: .

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

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

s = "КАПКАН" # Алфавит к задаче
# Создаём множество, чтобы не учитывались повторы слов
cnt = set() # Множество подходящих слов
for i in s:
    for j in s:
        for k in s:
            for l in s:
                for m in s:
                    for n in s:
                        st = i + j + k + l + m + n # Формируем слово
                        # Проверяем количество букв
                        if st.count("К") == 2 and st.count("А") == 2 and st.count("П") == 1 and st.count("Н") == 1:
                            # Так как по две у нас только буквы КК и АА, то проверяем только комбинации с ними
                            if ("КК" not in st) and ("АА" not in st):
                                cnt.add(st) # Добавим слово в множество
print(len(cnt)) # Выведем нужное количество

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

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

from itertools import permutations

count = set() # Множество подходящих слов

for x in permutations("КАПКАН"):
    s = "".join(x) # join объединит буквы
    if "АА" not in s and "КК" not in s: # Проверяем по условию
        count.add(s) # Добавим слово в множество
print(len(count)) # Выведем нужное количество

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

Буква Й может занять одно из 6 мест (все, кроме первого). Буква А может занять одно из 6 оставшихся мест. Для остальных 5 мест доступны 4 буквы.

Итого количество подходящих слов: .

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

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

s = "АНДРЕЙ" # Алфавит к задаче
s1 = "АНДРЕ"
cnt = 0 # Счётчик подходящих слов
for i in s1:
    for j in s:
        for k in s:
            for l in s:
                for m in s:
                    for n in s:
                        for o in s:
                            st = i + j + k + l + m + n + o # Формируем слово
                            if st.count("А") == 1 and st.count("Й") == 1: # Проверка по условию
                                cnt += 1 # Увеличим счётчик
print(cnt) # Вывод ответа

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

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

from itertools import product

count = set() # Множество подходящих слов
# Получим все 7-буквенные слова из заданного алфавита
for x in product("АНДРЕЙ", repeat = 7):
    s = "".join(x) # join объединит буквы
    if s[0] != "Й" and s.count("Й") == 1 and s.count("А") == 1: # Проверяем по условию
        count.add(s) # Добавим слово в множество
print(len(count)) # Выведем нужное количество

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

Пусть буква П встречается более 6 раз, то есть 7, 8 или 9.

Число способов поставить букву П на 7 позиций из 9 равно: . Кроме буквы П в слове ПОЧЕМУ есть 5 букв. Тогда, число возможных слов в таком случае .

Число способов поставить букву П на 8 позиций из 9 равно: . Кроме буквы П в слове ПОЧЕМУ есть 5 букв. Тогда, число возможных слов в таком случае .

Число способов поставить букву П на 9 позиций из 9 равно 1 и всего есть одно слово со всеми буквами П.

Общее число слов, когда буква П встречается более 6 раз: .

Общее число слов, которые можно составить из букв слова ПОЧЕМУ: .

Тогда число слов, где буква П используется не более 6 раз: .

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

Для решения задачи используем полный перебор всех возможных 9-буквенных слов, составленных из букв «ПОЧЕМУ». Идея заключается в том, чтобы с помощью 9 вложенных циклов поочерёдно выбирать букву на каждой позиции слова и проверять условие по количеству букв «П».

Шаги решения: 1. Задаём переменную-счётчик count для подсчёта подходящих слов.

2. Определяем строку s = ’ПОЧЕМУ’ как алфавит доступных букв.

3. Организуем 9 вложенных циклов, где каждая переменная цикла (a, b, c, d, e, f, g, h, k) отвечает за выбор буквы на соответствующей позиции слова.

4. Внутри самого глубокого цикла формируем слово st = a + b + c + d + e + f + g + h + k.

5. Проверяем условие: количество букв «П» в слове не больше 6 с помощью st.count(’П’) <= 6.

6. Если условие выполняется, увеличиваем счётчик count += 1.

count = 0           # переменная-счётчик допустимых слов
s = ’ПОЧЕМУ’        # набор доступных букв

# Перебираем все возможные буквы для первой позиции
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:
                                # Перебор букв для девятой позиции
                                for k in s:
                                    # Формируем слово из выбранных букв
                                    st = a + b + c + d + e + f + g + h + k
                                    # Проверяем ограничение: "П" встречается не более 6 раз
                                    if st.count(’П’) <= 6:
                                        # Если условие выполнено, увеличиваем счётчик
                                        count += 1

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

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

Шаги решения: 1. Импортируем функцию product из модуля itertools.

2. Создаём пустое множество count = set() для хранения уникальных слов.

3. С помощью product(’ПОЧЕМУ’, repeat=9) перебираем все кортежи длиной 9, представляющие слова.

4. Преобразуем кортеж в строку через s = ”.join(x).

5. Проверяем, что количество букв «П» не больше 6 с помощью s.count(’П’) <= 6.

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

7. В конце выводим количество уникальных слов с помощью len(count).

from itertools import product # импортируем функцию product

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

# Перебор всех 9-буквенных комбинаций с повторениями
for x in product(’ПОЧЕМУ’, repeat = 9):
    # Преобразуем кортеж символов в строку
    s = ’’.join(x)
    # Проверяем, что букв "П" не более 6
    if s.count(’П’) <= 6:
        # Если условие выполнено, добавляем слово во множество
        count.add(s)

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

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

Случай 1: Последняя цифра 3 (нечётная)

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

Если первая цифра нечётная (1 или 3): 2 варианта. Остаётся 4 чётных на 6 позиций: . На каждую позицию для нечетных можно выбрать одну из двух букв, на каждую позицию для четных - одну из трех. Вариантов: .

Всего для случая 1: .

Случай 2: Последняя цифра 4 (чётная)

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

Если первая цифра нечётная (1 или 3): 2 варианта. Остаётся 3 чётных на 6 позиций: .На каждую позицию для нечетных можно выбрать одну из двух букв, на каждую позицию для четных - одну из трех. Вариантов: .

Всего для случая 2: .

Итоговое количество: .

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

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

Сначала создаём строку a = ’01234’, которая содержит все возможные цифры пятиричной системы. Создаём пустое множество count = set() для хранения уникальных чисел, удовлетворяющих условиям.

Далее используем 8 вложенных циклов for, по одному на каждую цифру числа:

1. for x1 in ’1234’ — выбираем первую цифру числа. Она не может быть нулём, поэтому перебираем только ’1’, ’2’, ’3’, ’4’.

2. for x2 in a, for x3 in a, ..., for x7 in a — для остальных цифр (со 2-й по 7-ю) выбираем любую цифру из ’0’, ’1’, ’2’, ’3’, ’4’.

3. for x8 in ’34’ — последняя цифра должна быть больше 2, поэтому перебираем только ’3’ и ’4’.

Внутри циклов формируем строку s = x1+x2+x3+x4+x5+x6+x7+x8, которая представляет текущее число.

Затем проверяем условие равного количества чётных и нечётных цифр. Для этого создаём список всех чётных цифр числа с помощью list comprehension: [i for i in s if int(i) % 2 == 0]. Аналогично для нечётных: [i for i in s if int(i) % 2 != 0]. Если их длины равны, добавляем число в множество count.

После завершения перебора всех комбинаций выводим размер множества len(count) — это и будет количество допустимых чисел.

# Создаём строку с возможными цифрами пятиричной системы
a = ’01234’

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

# Перебираем первую цифру числа (не может быть 0)
for x1 in ’1234’:
    # Перебираем вторую цифру числа
    for x2 in a:
        # Перебираем третью цифру числа
        for x3 in a:
            # Перебираем четвёртую цифру числа
            for x4 in a:
                # Перебираем пятую цифру числа
                for x5 in a:
                    # Перебираем шестую цифру числа
                    for x6 in a:
                        # Перебираем седьмую цифру числа
                        for x7 in a:
                            # Перебираем последнюю цифру числа (должна быть > 2)
                            for x8 in ’34’:
                                # Формируем строку числа из выбранных цифр
                                s = x1+x2+x3+x4+x5+x6+x7+x8
                                # Проверяем условие: количество чётных и нечётных цифр одинаково
                                if len([i for i in s if int(i) % 2 == 0]) == len([i for i in s if int(i) % 2 != 0]):
                                    # Добавляем число в множество
                                    count.add(s)
# Выводим количество допустимых чисел
print(len(count))

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

Для упрощения перебора всех комбинаций используем модуль itertools, который позволяет генерировать декартово произведение цифр с помощью функции product. Генерируем все 8-значные комбинации цифр ’0’-’4’.

1. Преобразуем кортеж x в строку s с помощью ’’.join(x).

2. Проверяем условие, что первая цифра не ноль: s[0] != ’0’.

3. Проверяем, что последняя цифра > 2: int(s[7]) > 2.

4. Подсчитываем количество чётных цифр в числе с помощью цикла for a in s: if int(a) % 2 == 0: count += 1 . 5. Если количество чётных цифр равно 4 (значит, и нечётных тоже 4), увеличиваем общий счётчик k.

В конце выводим k — количество чисел, удовлетворяющих условиям задачи.

import itertools

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

# Перебор всех 8-значных комбинаций цифр ’0’-’4’
for x in itertools.product(’01234’, repeat = 8):
    # Преобразуем кортеж в строку числа
    s = ’’.join(x)
    # Проверяем первую цифру (не 0) и последнюю (>2)
    if s[0] != ’0’ and int(s[7]) > 2:
        # Считаем количество чётных цифр
        count = 0
        for a in s:
            if int(a) % 2 == 0:
                count += 1
        # Если чётных цифр 4, число подходит
        if count == 4:
            k += 1

# Выводим результат
print(k)

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

У нас в распоряжении 2 гласные и 3 согласные буквы. Чтобы соблюсти условия, нам надо расставить гласные и согласные в таком порядке:

ГСГСГ либо СГСГС

Так как согласных букв у нас больше, то нам подхожит только второй вариант Значит, кол-во возможных кодов будет составлять:

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

Для решения задачи через циклы мы будем формировать все 5-буквенные слова из букв Т, А, Р, У, Х, используя каждую букву ровно один раз, и проверять условие, что две гласные или две согласные не стоят подряд. Алгоритм реализуется следующим образом:

Сначала создаём строки sogl = ’ТРХ’ и gl = ’АУ’, которые содержат согласные и гласные буквы соответственно. Создаём пустое множество count = set() для хранения уникальных слов, удовлетворяющих условиям.

Поскольку слово должно чередовать согласные и гласные и состоять из 5 букв, возможная структура слова — СГСГС, где С — согласная, а Г — гласная. Для перебора всех вариантов используем 5 вложенных циклов:

1. for x1 in sogl — выбираем первую букву (согласная).

2. for x2 in gl — выбираем вторую букву (гласная).

3. for x3 in sogl — выбираем третью букву (согласная).

4. for x4 in gl — выбираем четвёртую букву (гласная).

5. for x5 in sogl — выбираем пятую букву (согласная).

Внутри циклов формируем слово s = x1+x2+x3+x4+x5. Затем проверяем, что все буквы различны: len(set(s)) == len(s). Если условие выполняется, добавляем слово в множество count.

После завершения перебора выводим len(count) — количество допустимых слов.

# Согласные буквы
sogl = ’ТРХ’
# Гласные буквы
gl = ’АУ’
# Множество для хранения всех уникальных слов
count = set()
# Перебор всех слов по шаблону СГСГС
for x1 in sogl:  # первая буква (согласная)
    for x2 in gl:  # вторая буква (гласная)
        for x3 in sogl:  # третья буква (согласная)
            for x4 in gl:  # четвёртая буква (гласная)
                for x5 in sogl:  # пятая буква (согласная)
                    # Формируем слово
                    s = x1+x2+x3+x4+x5
                    # Проверяем, что все буквы уникальны
                    if len(set(s)) == len(s):
                        # Добавляем слово в множество
                        count.add(s)
# Выводим количество допустимых слов
print(len(count))

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

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

1. Импортируем функцию permutations из модуля itertools.

2. Создаём пустое множество count = set() для хранения слов, удовлетворяющих условиям.

3. Задаём строку гласных gl = ’АУ’ для проверки соседних букв.

4. Перебираем все перестановки букв ’ТАРУХ’ длиной 5 и преобразуем каждую в строку s = ’’.join(x).

5. Проверяем условие, что нет подряд стоящих двух гласных или двух согласных: all((s[i] in gl) != (s[i+1] in gl) for i in range(len(s)-1)). Если оно выполняется, добавляем слово в множество count.

6. После перебора выводим размер множества len(count) — количество допустимых слов.

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

# Множество для хранения всех уникальных слов
count = set()
# Гласные буквы
gl = ’АУ’

# Перебор всех перестановок букв
for x in permutations(’ТАРУХ’):
    # Преобразуем кортеж в строку
    s = ’’.join(x)
    # Проверяем, что нет подряд стоящих двух гласных или двух согласных
    if all((s[i] in gl) != (s[i+1] in gl) for i in range(len(s)-1)):
        # Добавляем слово в множество
        count.add(s)

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

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

У нас в распоряжении 2 гласные и 3 согласные буквы. Чтобы соблюсти условия, нам надо расставить гласные и согласные в следующих порядках:

ГСССГ

ГССГС

ГСГСС

СГСГС

ССГСГ

СГССГ

Рассмотрим одну комбинацию: на первое место можно поставить одну из 2 гласных букв, на второе место одну из 3 согласных букв, на третье место можно поставить одну из 2 согласных букв, на четвёртое место можем поставить последную согласную букву, на последнее место ставим оставшуюся гласную букву. В итоге, слов. В каждой комбинации можно составить по 12 слов. Расстановок таких у нас 6. Значит, кол-во кодов:

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

Для решения задачи через циклы мы будем поэтапно формировать все 5-буквенные коды из букв "О "М "А "Р "Г"и проверять их на выполнение двух условий: все буквы различны и две гласные буквы не стоят рядом. Алгоритм реализуется следующим образом:

Сначала создаём строку a = ’ОМАРГ’, которая содержит все буквы алфавита. Создаём пустое множество count = set() для хранения уникальных кодов.

Далее используем 5 вложенных циклов for, по одному на каждую букву кода:

1. for x1 in a — выбираем первую букву кода.

2. for x2 in a, ..., for x5 in a — выбираем вторую, третью, четвёртую и пятую буквы кода соответственно.

Внутри циклов формируем строку s = x1+x2+x3+x4+x5, которая представляет текущий код.

Затем проверяем условия:

- Нет соседних гласных "АО"или "ОА"→ ’АО’ not in s and ’ОА’ not in s.

- Все буквы различны → len(set(s)) == len(s). set() — множество, оно хранит только уникальные элементы, поэтому если длина множества равна длине строки, все буквы разные.

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

После завершения перебора всех комбинаций выводим размер множества len(count) — это и будет количество допустимых кодов.

# Создаём строку с доступными буквами
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. Все буквы различны
                    if ’АО’ not in s and ’ОА’ not in s and len(set(s)) == len(s):
                        # Добавляем код в множество
                        count.add(s)

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

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

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

1. Перебираем все перестановки букв ’ОМАРГ’ с помощью for x in permutations(’ОМАРГ’).

2. Преобразуем кортеж x в строку s = ’’.join(x).

3. Проверяем условие, что соседние буквы не образуют сочетания "АО"или "ОА"→ ’АО’ not in s and ’ОА’ not in s.

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

В конце выводим len(count) — количество допустимых кодов.

from itertools import permutations

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

# Перебираем все перестановки букв ’ОМАРГ’
for x in permutations(’ОМАРГ’):
    # Преобразуем кортеж в строку кода
    s = ’’.join(x)
    # Проверяем условие: соседние буквы не образуют "АО" или "ОА"
    if ’АО’ not in s and ’ОА’ not in s:
        # Добавляем код в множество
        count.add(s)

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

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

Расставим буквы, зная, что "У"стоит только после согласной буквы. На 1 позиции "У"стоять не может, но может на 2-ой. Значит, на первой позиции будет одна из 3-ех согласных. На 3-ей и дальше может быть любая из 4 оставшихся букв (кроме "У"). Далее будем передвигать "У"по каждой поизици и считать комбинации.

У

У

У

У

Итого кол-во кодов равно 768.

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

Для решения задачи через циклы мы будем формировать все возможные 5-буквенные слова из букв ’КАНУЛ’ и проверять два условия: в слове ровно одна буква У, а она стоит после согласной (К, Н, Л).

Сначала создаём строку a = ’КАНУЛ’ с доступными буквами. Создаём пустое множество count = set() для хранения уникальных слов, удовлетворяющих условиям.

Используем 5 вложенных циклов for, по одному на каждую позицию слова:

1. for x1 in ’КАНЛ’ — первая буква слова. Она не может быть У, так как У должна идти после согласной.

2. for x2 in a, for x3 in a, for x4 in a, for x5 in a — выбираем любую букву из всех доступных для остальных позиций.

Внутри циклов формируем строку s = x1+x2+x3+x4+x5, которая представляет текущее слово.

Затем проверяем два условия:

- s.count(’У’) == 1 — в слове ровно одна буква У.

- ’КУ’ in s or ’НУ’ in s or ’ЛУ’ in s — буква У идёт после согласной (К, Н или Л).

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

После завершения перебора всех комбинаций выводим размер множества len(count) — это количество допустимых слов.

# Строка с доступными буквами
a = ’КАНУЛ’

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

# Перебор первой буквы (не может быть У)
for x1 in ’КАНЛ’:
    # Перебор второй буквы
    for x2 in a:
        # Перебор третьей буквы
        for x3 in a:
            # Перебор четвёртой буквы
            for x4 in a:
                # Перебор пятой буквы
                for x5 in a:
                    # Формируем слово из выбранных букв
                    s = x1+x2+x3+x4+x5
                    # Проверяем условия:
                    # 1. Ровно одна буква У
                    # 2. У идёт после согласной (К, Н, Л)
                    if s.count(’У’) == 1 and (’КУ’ in s or ’НУ’ in s or ’ЛУ’ in s):
                        # Добавляем слово в множество
                        count.add(s)

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

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

Для упрощения перебора всех комбинаций используем функцию product из модуля itertools, которая создаёт декартово произведение букв, то есть все возможные 5-буквенные слова.

1. Преобразуем полученный кортеж x в строку s = ’’.join(x).

2. Проверяем условие одной буквы У: s.count(’У’) == 1.

3. Проверяем условие, что У идёт после согласной: ’КУ’ in s or ’НУ’ in s or ’ЛУ’ in s.

4. Если оба условия выполнены, добавляем слово в множество count.

В конце выводим количество слов len(count).

from itertools import product

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

# Перебор всех 5-буквенных комбинаций букв ’КАНУЛ’
for x in product(’КАНУЛ’, repeat=5):
    # Преобразуем кортеж в строку слова
    s = ’’.join(x)
    # Проверяем условия:
    # 1. Ровно одна буква У
    # 2. У идёт после согласной (К, Н, Л)
    if s.count(’У’) == 1 and (’КУ’ in s or ’НУ’ in s or ’ЛУ’ in s):
        # Добавляем слово в множество
        count.add(s)

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