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

В нашем наборе 3 гласных и 5 согласных.

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

1) Слова без гласных

Тут всё просто, считаем следующим образом — 5*5*5*5*5*5 = 15625

2) Слова с одной гласной

3*5*5*5*5*5 = 9375, умножаем на 6, тем самым рассматривая гласную на 6 позициях. Получаем 56250.

3) Слова с двумя гласными

Посчитаем перестановки гласных без повторов — 6*5/2! = 15

15 умножаем на 3*3*5*5*5*5, получаем 84375.

Итого, 15625+56250+84375 = 156250.

Решение через циклы
Составляем программу для перебора всех 6-буквенных слов из букв РОСТИЛАВ. Для каждой комбинации формируем слово через сложение букв из вложенных циклов, затем считаем количество гласных с помощью метода . Если их меньше трёх, увеличиваем ответ. В конце выводим значение счётчика, что и будет количеством всех слов, удовлетворяющих условию.

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:
                        w = a + b + c + d + e + f  # формируем слово
                        # Проверяем, что гласных меньше 3
                        if w.count("О") + w.count("И") + w.count("А") < 3:
                            k += 1  # увеличиваем счётчик, если слово подходит
print(k)  # выводим ответ

Решение через itertools
Используем функцию для генерации всех 6-буквенных комбинаций из букв РОСТИСЛАВ. Каждую комбинацию преобразуем в строку с помощью , затем считаем количество гласных. Если их меньше трёх, добавляем слово в множество, чтобы исключить дубликаты. В конце выводим длину множества, что и будет количеством всех допустимых слов.

from itertools import product

s = "РОСТИСЛАВ"  # набор допустимых букв
p = set()  # множество для хранения допустимых слов

for x in product(s, repeat=6):
    w = "".join(x)  # преобразуем кортеж в строку
    if w.count("О") + w.count("И") + w.count("А") < 3:
        p.add(w)  # добавляем слово в множество, если условие выполнено
print(len(p))  # выводим ответ

Всего восьмибуквенных слов 5*5*5*5*5*5*5*5 = 390625. Легче будет сначала сосчитать слова, где буква Ф встречается менее 3 раз, а затем отнять полученное количество от общего числа.

1) Буква Ф не встречается

Значит, в наборе будет доступно 4 буквы, вычисляем: 4*4*4*4*4*4*4*4 = 65536.

2) Буква Ф встречается 1 раз

Позиций, которые может занять буква Ф — 8, вычисляем кол-во слов, где буква Ф находится на одной конкретной позиции, и умножаем на 8:

8*(1*4*4*4*4*4*4*4) = 131072.

3) Буква Ф встречается 2 раза

Считаем количество перестановок двух букв Ф: 8*7/2!=28

Кол-во перестановок умножаем на количество слов, где буква Ф встречается на двух конкретных позициях:

28*(1*1*4*4*4*4*4*4) = 114688.

Считаем, сколько слов существуем с тремя и более буквами Ф: 390625 - 65536 - 131072 - 114688 = 79329.
Решение через циклы
Составим программу для перебора всех 8-буквенных комбинаций из букв слова ФАКЕЛ с помощью вложенных циклов. Для каждой комбинации формируем слово через конкатенацию букв и проверяем условие, что буква Ф встречается не менее трёх раз, используя метод count. Если условие выполняется, увеличиваем счётчик допустимых слов. В конце выводим значение счётчика, что и будет ответом.

s = "ФАКЕЛ"  # доступные буквы
k = 0  # счётчик допустимых слов

# Перебор всех возможных 8-буквенных комбинаций
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. Она генерирует все возможные комбинации с повторениями из букв ФАКЕЛ длиной 8. Именно это нам нужно, так как каждая буква может встречаться произвольное количество раз (включая полное отсутствие). Условие «буква Ф встречается не менее трёх раз» записывается в программе аналогично решению с помощью циклов. Если слово подходит, увеличиваем счётчик, в конце выводим его.

from itertools import product

s = "ФАКЕЛ"  # исходный набор букв
n = 0  # счётчик допустимых слов

for x in product(s, repeat=8):
    w = "".join(x)  # Преобразуем комбинацию в строку
    if w.count("Ф") >= 3:
        n += 1
print(n)

Можно составить следующие комбинации слов с сочетанием букв БУМ:

2 * _ * _ * _ * 5 * 4 * 3 * 2 * 1 = 240

2 * 4 * 1 * _ * _ * _ * 3 * 2 * 1 = 48

2 * 4 * 1 * 3 * _ * _ * _ * 2 * 1 = 48

2 * 4 * 1 * 3 * 2 * _ * _ * _ * 1 = 48

2 * 4 * 1 * 3 * 2 * 1 * _ * _ * _ = 48

В начале всегда выбор из двух оставшихся букв. На втором месте 8-3(БУМ)-1 гласная на третьей позиции. На третьей позиции — оставшаяся гласная. Дальше сочетания оставшихся букв.

Решение программой (циклы):
Программа перебирает все 9-буквенные комбинации из букв слова БЕЗУМСТВО. Для первой и третьей позиций выбираем только гласные, чтобы сразу исключить запрещённые варианты с согласными. На остальных позициях перебираем буквы всего алфавита. Для каждой комбинации формируем слово, проверяем, что оно содержит подстроку БУМ и все буквы различны (это удобно проверять через сравнение длины слова и множества его букв, если длины совпадают, то в слове нет повторяющихся букв). Если оба условия выполняются, добавляем слово в множество ans, чтобы исключить дубликаты. В конце выводим длину множества, что и будет количеством всех допустимых последовательностей.

ans = set()  # множество для хранения уникальных подходящих слов
alf = "БЕЗУМСТВО"  # допустимые буквы

# Перебор всех возможных 9-буквенных комбинаций
for x1 in "ЕУО":  # на 1-й позиции только гласная
    for x2 in alf:
        for x3 in "ЕУО":  # на 3-й позиции только гласная
            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  # формируем слово
                                    # Проверяем условия:
                                    # 1. В слове есть подстрока "БУМ"
                                    # 2. Все буквы используются ровно один раз (длина строки = длине множества)
                                    if "БУМ" in w and len(w) == len(set(w)):
                                        ans.add(w)  # добавляем подходящее слово в множество
print(len(ans))  # вывод результата

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

from itertools import permutations

ans = set()  # множество для хранения уникальных подходящих слов
alf = "БЕЗУМСТВО"  # допустимые буквы

# Перебор всех перестановок букв из 9-символьного алфавита
for w in permutations(alf, 9):
    w = "".join(w)  # формируем слово
    # Проверяем условия:
    # 1. В слове есть подстрока "БУМ"
    # 2. Первая буква не согласная
    # 3. Третья буква не согласная
    if "БУМ" in w and w[0] not in "БЗМСТВ" and w[2] not in "БЗМСТВ":
        ans.add(w)  # добавляем подходящее слово в множество
print(len(ans))  # вывод результата

Вычислить количество таких слов можно следующим путём: 8*8*5*1*1=320, где на первых двух позициях могут стоять любые буквы, в середине возможно 5 вариаций букв(согласные), а на последних двух позициях стоят те же буквы, что и в начале, поэтому иных вариантов мы не рассматриваем.

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

ans = set()  # множество допустимых слов
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. Средняя буква согласная
                    if w == w[::-1] and w[2] in "ЛГРТМ":
                        ans.add(w)  # добавляем слово в множество
print(len(ans))  # вывод результата

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

from itertools import product

ans = set()  # множество допустимых слов
alf = "АЛГОРИТМ"  # доступные буквы

# Перебор всех возможных комбинаций длины 5 (с повторениями)
for w in product(alf, repeat=5):
    w = "".join(w)  # формируем слово
    # Проверяем условия:
    # 1. Слово является палиндромом
    # 2. Средняя буква согласная
    if w == w[::-1] and w[2] in "ЛГРТМ":
        ans.add(w)  # добавляем слово в множество
print(len(ans))  # вывод результата

Решение программой (циклы):
Напишем программу для перебора всевозможных 7-буквенных слов, составленных из букв слова ДИАМЕТР с помощью вложенных циклов. Для каждого слова проверяем четыре условия: оно должно начинаться с гласной буквы (используем индексацию), оканчиваться сочетанием букв МИ (используем срез), содержать хотя бы одно сочетание букв ЕР (используем оператор in) и не содержать сочетания АДТ (используем not in). Если все условия выполняются, добавляем слово в множество, чтобы исключить повторения. В конце выводим количество элементов множества, это и есть ответ.

ans = set()  # множество допустимых слов
alf = "ДИАМЕТР"  # доступные буквы

# Перебор всех возможных 7-буквенных слов
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  # формируем слово
                            # Проверяем условия:
                            # 1. Первая буква должна быть гласной
                            # 2. Последние две буквы должны быть МИ
                            # 3. Слово должно содержать сочетание ЕР
                            # 4. Слово не должно содержать сочетание АДТ
                            if w[0] in "ИАЕ" and w[-2:] == "МИ" and "ЕР" in w and "АДТ" not in w:
                                ans.add(w)  # добавляем слово в множество
print(len(ans))  # вывод результата

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

from itertools import product

ans = set()  # множество допустимых слов
alf = "ДИАМЕТР"  # доступные буквы

# Перебор всех возможных комбинаций длины 7
for w in product(alf, repeat=7):
    w = "".join(w)  # формируем слово
    # Проверяем условия:
    # 1. Первая буква должна быть гласной (И, А, Е)
    # 2. Последние две буквы должны быть МИ
    # 3. Слово содержит сочетание ЕР
    # 4. Слово не содержит сочетание АДТ
    if w[0] in "ИАЕ" and w[-2:] == "МИ" and "ЕР" in w and "АДТ" not in w:
        ans.add(w)  # добавляем слово в множество
print(len(ans))  # вывод результата

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

В слове ЛУКОВИЦА помимо букв В содержится ещё 7 различных букв. По условию задачи нужно составить 6-тибуквенные слова. Если на первые две позиции поставить буквы В, то всего количество таких различных слов: .

Найдем количество способов переставить 2 буквы В на 6 позиций. Для этого воспользуемся формулой сочетаний: .

Получаем итоговое количество способов: .

Решение через циклы
Напишем программу для перебора всевозможных 6-буквенных слов, составленных из букв слова ЛУКОВИЦА с помощью вложенных циклов. Для каждого слова проверяем условие, используя метод count: буква В должна встречаться ровно два раза. Если условие выполняется, увеличиваем счётчик на единицу. В конце выводим значение счётчика, что и будет ответом.

a = "ЛУКОВИЦА"  # доступные буквы
count = 0  # счётчик подходящих слов

# Перебор всех возможных 6-буквенных слов
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  # формируем слово
                        # Проверяем условие:
                        # буква "В" встречается ровно 2 раза
                        if s.count("В") == 2:
                            count += 1  # увеличиваем счётчик
print(count)  # вывод результата

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

from itertools import product

count = 0  # счётчик подходящих слов
a = "ЛУКОВИЦА"  # доступные буквы

# Перебор всех возможных комбинаций длины 6
for x in product(a, repeat=6):
    s = "".join(x)  # формируем слово
    # Проверяем условие:
    # буква "В" встречается ровно 2 раза
    if s.count("В") == 2:
        count += 1  # увеличиваем счётчик
print(count)  # вывод результата

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

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

Теперь немного воспользуемся темой степеней и представим число как .

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

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

a = "ГОША" # Алфавит к задаче
n = 0 # Счётчик подходящих слов
for x in a:
    for y in a:
        for z in a:
            for w in a:
                for k in a:
                    for l in a:
                        for p in a:
                            n += 1 # Увеличим счётчик
# Посчитаем ответ к задаче с помощью деления
power = 0
while n > 1:
    n //= 2
    power += 1
print(power)

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

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

from itertools import product

s = "ГОША" # Алфавит к задаче
n = 0 # Счётчик слов
# Получим все 7-буквенные слова из заданного алфавита
for x in product(s, repeat = 7):
    n += 1 # Увеличим счётчик
# Посчитаем ответ к задаче с помощью деления
power = 0
while n > 1:
    n //= 2
    power += 1
print(power)

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

Всего существует два варианта: когда справа от слова ЕВКЛИД 4 буквы, а слева 2; когда справа 2 буквы, а слева 4. Рассмотрим каждый из них.

1. Если справа 4 буквы, то есть 5 способов расставить гласные: ИИИИ, ИИИЕ, ИИЕЕ, ИЕЕЕ, ЕЕЕЕ. Если слева 2 буквы, то есть 16 способов расставить гласные и согласные – . Получаем общее число для этого варианта: .

2. Если справа 2 буквы, то есть 3 способа расставить гласные: ИИ, ИЕ, ЕЕ. Если слева 4 буквы, то есть 384 способа расставить гласные и согласные – . Получаем общее число для этого варианта: .

Всего число вариантом слов: .

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

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

count = set() # Множество подходящих слов
# Идея решения заключается в том, чтобы исключить условие из задачи про ЕВКЛИД в слове, считая, по умолчанию, что оно выполнено. Таким образом, мы сокращаем перебор и уменьшаем время выполнения программы.
# Есть две вариации слова, которое удовлетворяет всем условиям: **ЕВКЛИД**** и ****ЕВКЛИД**, то есть 2 буквы слева и 4 справа или 4 буквы слева и 4 справа
gl = "ЕИ" # Гласные к задаче
sogl = "ВКЛД" # Согласные к задаче
a = "ЕВКЛИД" # Алфавит к задаче

for x1 in a:
    for x2 in a:
        for x3 in gl:
            for x4 in gl:
                for x5 in gl:
                    for x6 in gl:
                        s1 = x1+x2
                        s2 = x3+x4+x5+x6
                        # Если количество гласных равно количеству согласных в первой части
                        if len([i for i in s1 if i in gl]) == len([i for i in s1 if i in sogl]):
                            # Если гласные идут в обратном алфавитном порядке во второй части
                            if all(s2[i] >= s2[i + 1] for i in range(len(s2) - 1)):
                                count.add(s1 + s2) # Соединим слово и добавим в список

for x1 in a:
    for x2 in a:
        for x3 in a:
            for x4 in a:
                for x5 in gl:
                    for x6 in gl:
                        s1 = x1+x2+x3+x4
                        s2 = x5+x6
                         # Если количество гласных равно количеству согласных в первой части
                        if len([i for i in s1 if i in gl]) == len([i for i in s1 if i in sogl]):
                            # Если гласные идут в обратном алфавитном порядке во второй части
                            if all(s2[i] >= s2[i + 1] for i in range(len(s2) - 1)):
                                count.add(s1 + s2) # Соединим слово и добавим в список
print(len(count)) # Выведем нужную длину

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

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

from itertools import product

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

gl = "ЕИ" # Гласные к задаче
sogl = "ВКЛД" # Согласные к задаче
a = "ЕВКЛИД" # Алфавит к задаче
# Идея решения заключается в том, чтобы исключить условие из задачи про ЕВКЛИД в слове, считая, по умолчанию, что оно выполнено. Таким образом, мы сокращаем перебор и уменьшаем время выполнения программы.
# Есть две вариации слова, которое удовлетворяет всем условиям: **ЕВКЛИД**** и ****ЕВКЛИД**, то есть 2 буквы слева и 4 справа или 4 буквы слева и 4 справа
for x1 in product(a,repeat = 2): # Перебираем буквы для левой части
    for x2 in product(gl,repeat = 4): # Перебираем гласные буквы для правой части
        s1 = "".join(x1)
        s2 = "".join(x2)
        # Если количество гласных равно количеству согласных в первой части
        if len([i for i in s1 if i in gl]) == len([i for i in s1 if i in sogl]):
            # Если гласные идут в обратном алфавитном порядке во второй части
            if all(s2[i] >= s2[i + 1] for i in range(len(s2) - 1)):
                count.add(s1 + s2) # Соединим слово и добавим в список

for x1 in product(a,repeat = 4): # Перебираем буквы для левой части
    for x2 in product(gl,repeat = 2): # Перебираем гласные буквы для правой части
        s1 = "".join(x1) # join объединяет буквы
        s2 = "".join(x2) # join объединяет буквы
        # Если количество гласных равно количеству согласных в первой части
        if len([i for i in s1 if i in gl]) == len([i for i in s1 if i in sogl]):
            if all(s2[i] >= s2[i + 1] for i in range(len(s2) - 1)): # Если гласные идут в обратном алфавитном порядке во второй части
                count.add(s1 + s2) # Соединим слово и добавим в список
print(len(count)) # Выведем нужную длину

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

Найдем общее количество пятизначных чисел с цифрами из восьмеричной системы счисления: .

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

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

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

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

l = "01234567" # Алфавит к задаче
ans = 0 # Счётчик подходящих слов
for i in l:
    for j in l:
        for k in l:
            for x in l:
                for y in l:
                    s = i + j + k + x + y # Формируем слово
                    flag = False # Создадим переменную-флаг
                    if i != "0": # 0 не может быть первой цифрой
                        for b in range(len(s)-1):
                            if s[b] == s[b+1]: # Если нашлось сочетание одинаковых цифр
                                flag = True
                        if flag:
                            ans += 1 # Увеличим счётчик
print(ans)

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

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

from itertools import product

k = 0 # Счётчик слов
# Получим все комбинации из 5 цифр
for i in product("01234567", repeat = 5):
    s = "".join(i)
    a = [s[0] == s[1], s[1] == s[2], s[2] == s[3], s[3] == s[4]]
    if s[0] != ’0’ and sum(a) > 0: # Если нашлось сочетание одинаковых цифр и первая цифра не 0
        k += 1 # Увеличим счётчик
print(k)

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

Вариант 1: 3 согласные + 2 гласные

Возможные расположения (чтобы гласные не стояли рядом и не на первом месте):

С Г С Г С

С Г С С Г

С С Г С Г

Всего 3 варианта.

Выбор 3 из 5 согласных в алфавите: . Перестановки 3 согласных: .

Выбор 2 из 3 гласных в алфавите: . Перестановки 2 гласных: .

Итого слов для 1 варианта: .

Вариант 2: 4 согласные + 1 гласная

Выбор 4 из 5 согласных в алфавите: .

Выбор 1 из 3 гласных в алфавите: .

Позиции для гласной (не на первом месте): 4 варианта (позиции 2-5). Перестановки согласных: .

Итого: .

Вариант 3: 5 согласных + 0 гласных

Все 5 согласных можно переставить способами.

Суммируем все полученные варианты: 1080+1440+120=2640.

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

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

a = "МИРОСЛАВ" # Алфавит к задаче
g = "ИОА" # Гласные буквы к задаче
s = "МРСЛВ" # Согласные буквы к задаче
sochg = []
for i in g: # Запускаем два цикла для будущего определения отсутствия Г+Г
    for j in g:
        sochg.append(i+j) # В массив добавляем все возможные сочетания букв из списка гласных
count = 0 # Счётчик подходящих слов
for i in s:
    for j in a:
        for k in a:
            for l in a:
                for m in a:
                    w = i + j + k + l + m # Формируем слово
                    t = set(s) #
                    counts = len([i for i in w if i in s])
                    # Кол-во согласных
                    countg = len([i for i in w if i in g])
                    # Кол-во гласных
                    f = len([i for i in sochg if i in w])
                    #Кол-во сочетаний из списка sochg - Г+Г
                    # Если все буквы различны и согласных > гласных и нет определённых сочетаний
                    if len(set(w)) == 5 and counts > countg and f == 0:
                        count += 1 # Увеличим счётчик
print(count) # Выводим нужное количество

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

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

from itertools import permutations

count = set() # Множество подходящих слов
g = "ИОА" # Гласные буквы к задаче
s = "МРСЛВ" # Согласные буквы к задаче
for x in permutations("МИРОСЛАВ", r = 5):
    s = "".join(x) # join объединяет буквы
    count_sogl = len([i for i in s if i in sogl]) # Количество согласных букв в слове
    count_gl = len([i for i in s if i in gl]) # Количество гласных букв в слове
    # Проверка, что слово начинается не с гласной буквы
    # Что количество согласных больше чем количество гласных букв и то, что нет рядом стоящих гласных букв
    if s[0] not in gl and count_sogl > count_gl and all(x1+x2 not in s for x1 in gl for x2 in gl):
        count.add(s) # Добавим в множество
print(len(count)) # Выведем нужную длину

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

Нужно выбрать 2 позиции из 7 для гласных букв. Количество способов: способ расставить 2 гласные буквы в 7-буквенном слове.

На каждой из выбранных позиций может стоять любая из 2 гласных (У или А). Таким образом, варианта.

На каждой из оставшихся 5 позиций может стоять любая из 3 согласных (К, Р, Ж). Таким образом, варианта.

Умножаем количество способов для каждого шага: кодов.

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

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

s = "КРУЖА" # Самое главное - записать алфавит КРУЖА, а не КРУЖКА, т.к. в данном случае буква К является одним и тем же символом
n = 0 # Счётчик подходящих слов
for z in s:
    for x in s:
        for c in s:
            for v in s:
                for b in s:
                    for m in s:
                        for a in s:
                            slovo = z + x + c + v + b + m + a # Формируем слово
                            # В алфавите всего 2 гласных: У, A.
                            # Нас удовлетворяет только то условие, где кол-во гласных в слове = 2
                            if slovo.count("У") + slovo.count("А") == 2:
                                n += 1 # Увеличим счётчик
print(n)

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

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

from itertools import product

count = set() # Множество подходящих слов
for x in product("КРУЖКА", repeat = 7):
    s = "".join(x) # join объединяет буквы
    # Количество гласных букв в слове
    count_gl = len([i for i in s if i in "УА"])
    if count_gl == 2: # Если гласных две
        count.add(s) # Добавим в множество
print(len(count)) # Выведем нужную длину

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

Всего нам дано 8 букв, но буквы А и С повторяются дважды, они считаются одним и тем же символом, поэтому использовать мы можем всего 6 букв.

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

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

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

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

Остается только просуммировать получившиеся значения:

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

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

s = "РАСЧЁК" # Cамое главное - записать алфавит РАСЧЁК, а не РАСЧЁСКА, т.к. в данном случае буквы А;С являются одним и тем же символом
s6 = s5 = s4 = s3 = 0 # Счётчики слов
# Cлово из 6-ти букв
for z in s:
    for x in s:
        for c in s:
            for v in s:
                for b in s:
                    for m in s:
                        s6 += 1 # Увеличим счётчик
# Cлово из 5-ти букв
for z in s:
    for x in s:
        for c in s:
            for v in s:
                for b in s:
                    s5 += 1 # Увеличим счётчик
# Cлово из 4-х букв
for z in s:
    for x in s:
        for c in s:
            for v in s:
                s4 += 1 # Увеличим счётчик
# Cлово из 3-х букв
for z in s:
    for x in s:
        for c in s:
            s3 += 1 # Увеличим счётчик

print(s6 + s5 + s4 + s3) # Нам подходят все слова длиной от 3 до 6 включительно, значит, мы смело можем сложить все счётчики

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

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

from itertools import product

count = set() # Множество подходящих слов
for i in range(3, 7): # Все слова от 3 до 6 букв
    for x in product("РАСЧЁСКА", repeat = i):
        s = "".join(x) # join объединяет буквы
        count.add(s) # Добавим в множество
print(len(count)) # Выведем нужную длину

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

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

s = "УСЛОВИЕ" # Алфавит к задаче
sogl = "СЛВ" # Согласные к задаче
n = 0 # Счётчик слов
sochg = []
for i in sogl: # Запускаем два цикла для будущего определения отсутствия СОГЛ+СОГЛ
    for j in sogl:
        sochg.append(i+j) # В массив добавляем все возможные сочетания букв из списка согласных
for z in s:
    for x in s:
        for c in s:
            for v in s:
                for b in s:
                    for m in s:
                        for a in s:
                            slovo = z + x + c + v + b + m + a
                            f = len([i for i in sochg if i in slovo]) # Кол-во сочетаний из списка sochg - СОГЛ+СОГЛ
                            # Если все слова различны, нет определенных сочетаний, последняя буква не О, а первая не И
                            if f == 0 and slovo[-1] != "О" and slovo[0] != "И" and all(slovo.count(i) == 1 for i in s):
                                n += 1 # Увеличим счётчик
print(n)

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

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

from itertools import permutations

count = set()
sogl = "СЛВ" # Согласные буквы слова
for x in permutations("УСЛОВИЕ"):
    s = "".join(x) # join объединяет буквы
    # Проверка, что слово не начинается на И, не заканчивается на О и нет в слове рядом стоящих согласных букв
    if s[0] != "И" and s[-1] != "О" and all(x1 + x2 not in s for x1 in sogl for x2 in sogl):
        count.add(s) # Добавим в множество
print(len(count)) # Выведем нужную длину

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

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

s = "ВИШНЯ" # Алфавит к задаче
n = 0 # Счётчик слов
for z in s:
    for x in s:
        for c in s:
            for v in s:
                for b in s:
                    slovo = z + x + c + v + b # Формируем слово
                    # После Ш по условию идёт лишь гласная
                    # Значит комбинации вида Ш+СОГЛ должны отсутствовать
                    if ("ШВ" not in slovo) and ("ШН" not in slovo) and ("ШШ" not in slovo) and (slovo[-1] == "В" or slovo[-1] == "Ш" or slovo[-1] == "Н"):
                        n += 1 # Увеличим счётчик
print(n)

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

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

from itertools import product

s = "ВИШНЯ" # Алфавит к задаче
n = 0 # Счётчик слов
for x in product(s, repeat = 5):
    # После Ш по условию идёт лишь гласная
    # Значит комбинации вида Ш+СОГЛ должны отсутствовать
    if ("ШВ" not in "".join(x)) and ("ШН" not in "".join(x)) and ("ШШ" not in "".join(x)) and (x[-1] in "ВШН"):
        n += 1 # Увеличим счётчик
print(n)

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

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

s = "ОБОРОНА" # Алфавит к задаче
counter = set() # Множество подходящих слов
for z in s:
    for x in s:
        for c in s:
            for v in s:
                for b in s:
                    for m in s:
                        for a in s:
                            slovo = z + x + c + v + b + m + a # Формируем слово
                            # Т.к. у нас перестановки
                            # Мы должны каждую букву алфавита использовать столько раз
                            # Сколько она встречается в слово ОБОРОНА
                            if (slovo.count("Б") == 1 and slovo.count("Н") == 1 and slovo.count("Р") == 1 and slovo.count("А") == 1):
                                # Все возможные комбинации гласных путём перестановок
                                if (("ООО" in slovo) or ("АОО" in slovo) or ("ОАО" in slovo) or ("ООА" in slovo)):
                                    counter.add(slovo) # Добавим в множество
print(len(counter)) # Выведем нужную длину

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

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

from itertools import permutations

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

for w in permutations(alf, 7):
    w = "".join(w) # join объединяет буквы
    w1 = w.replace("А", "О")
    if "ООО" in w1: # Проверим сочетания А и О с помощью замены
        ans.add(w) # Добавим в множество
print(len(ans)) # Выведем нужную длину

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

Всего позиций 6, две из них отводится под букву О, а на оставшихся четырех местах может находиться любая буква из пятибуквенного набора Б,Г,И,Н,Я:

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

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

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

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

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

a = "БОГИНЯ" # Алфавит к задаче
n = 0 # Счётчик слов

for x in a:
    for y in a:
        for z in a:
            for w in a:
                for k in a:
                    for m in a:
                        s = x + y + z + w + k + m # Формируем слово
                        if s.count("О") == 2: # Проверка по условию
                            n += 1 # Увеличим счётчик
print(n)

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

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

from itertools import product

s = "БОГИНЯ" # Алфавит к задаче
n = 0 # Счётчик слов
# Получим все 6-буквенные слова из заданного алфавита
for x in product(s, repeat = 6):
    if ("".join(x).count("О") == 2): # Проверяем по условию
        n += 1 # Увеличим счётчик
print(n)

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

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

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

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

З * * * * * * на месте * может быть любая буква из набора Г,Р,О,А: И 4 4 4 4 4 4 варианта для случая, когда буква З стоит на первом месте. Она может стоять на любом из семи мест, следовательно, = 28672 слова с одной буквой З.

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

слов.

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

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

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

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

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

from itertools import product

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

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

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

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

* * Т * * *

* * * Т * *

* * * * Т *

* * * * * Т

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

4 3 Т 4 4 4

4 4 3 Т 4 4

4 4 4 3 Т 4

4 4 4 4 3 Т

Итого: 4096 + = 7168.

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

Напишем программу для перебора всевозможных 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 and "Т" not in w[:2] and "КТ" not in w: # Проверка по условию
                            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 and "Т" not in w[:2] and "КТ" not in w: # Проверка по условию
        ans.add(w) # Добавим слово в множество
print(len(ans)) # Выведем нужное количество

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

Гласных букв две - А и Е, согласных букв три - П,Р,Л.

1. Найдем количество слов с четырьмя гласными и двумя согласными:

С С Г Г Г Г 3 3 2 2 2 2 вариантов слов, когда две согласные стоят на первой и второй позиции.

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

2. Найдем количество слов с пятью гласными и одной согласной:

С Г Г Г Г Г 3 2 2 2 2 2 вариантов для случая, когда согласная стоит на первом месте. Она может стоять на любом из шести мест, следовательно, = 576 слов с одной согласной.

3. Найдем количество слов с шестью гласными: варианта.

Тогда общее количество слов: 2160+576 +64 = 2800.

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

Напишем программу для перебора всевозможных 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 # Формируем слово
                        gl = w.count("А") + w.count("Е") # Количество А и Е
                        if gl > len(w) - gl: # Проверка по условию
                            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 объединит буквы
    gl = w.count("А") + w.count("Е") # Количество А и Е
    if gl > len(w) - gl: # Проверяем по условию
        ans.add(w) # Добавим слово в множество
print(len(ans)) # Выведем нужное количество

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

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

На втором месте может стоять одна из четырех букв без буквы К,М или Ш, так как код не содержит двух одинаковых букв подряд

На третьем месте может стоять одна из четырех букв, то есть без буквы, стоящей на втором месте

Тогда количество последовательностей считается таким образом:

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

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

a = "КАМЫШ" # Наше слово
a1 = "КМШ" # Разрешенные буквы для первого места
c = 0 # Итоговый счётчик
# Перебор различных 7-буквенных слов
for x1 in a1:
    for x2 in a:
        for x3 in a:
            for x4 in a:
                for x5 in a:
                    for x6 in a:
                        for x7 in a:
                            s = x1 + x2 + x3 + x4 + x5 + x6 + x7 # Формируем слово
                            # Проверка по условию
                            if "АА" not in s and "КК" not in s and "ЫЫ" not in s and "ММ" not in s and "ШШ" not in s:
                                c += 1
print(c) # Вывод ответа

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

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

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