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

Допустим, что цифра "1"стоит на первой и второй позиции. Тогда, оставшиеся три числа мы можем разместить способами.

Найдём число способов, которыми мы можем поставить две цифры "1"на пять мест. .

Общее число вариантов равно .

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

ans = set()  # множество для шифров
alf = "1234"  # доступные цифры

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

Решение программой (itertools):
Для решения задачи с помощью модуля itertools воспользуемся функцией product. Она генерирует все комбинации заданной длины с повторениями из заданного алфавита. Функция product сохраняет алфавитный порядок, так как перебирает символы в том же порядке, в котором они указаны алфавите. Условие «цифра 1 встречается ровно два раза» записывается в программе аналогично решению с помощью циклов.

from itertools import product

ans = set()
alf = "1234"

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

    # проверяем, что "1" встречается ровно два раза
    if w.count("1") == 2:
        ans.add(w)  # добавляем подходящий шифр в ответ

print(len(ans))  # выводим количество уникальных шифров

На первом месте может стоять только одна из двух букв - Р или Л

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

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

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


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

s = "РОЯЛЬ"  # доступные буквы
ans = set()  # множество для хранения уникальных кодов

# Перебор всех возможных 6-буквенных комбинаций
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  # формируем код
                        # Проверяем условие: первая буква не гласная и не мягкий знак
                        if w[0] not in "ОЯЬ":
                            f1 = 1  # флаг
                            # Проверяем условие: нет двух одинаковых букв подряд
                            for i in range(len(w) - 1):
                                if w[i] == w[i + 1]:
                                    f1 = 0
                                    break
                            # Если все условия выполнены, добавляем слово в множество
                            if f1:
                                ans.add(w)

print(len(ans))  # вывод результата

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

from itertools import product  # импорт функции для перебора комбинаций

s = "РОЯЛЬ"  # доступные буквы
ans = set()  # множество для хранения уникальных кодов

# Перебор всех возможных 6-буквенных комбинаций
for w in product(s, repeat=6):
    w = "".join(w)  # преобразуем кортеж в строку
    # Проверяем условие: первая буква не гласная и не мягкий знак
    if w[0] not in "ОЯЬ":
        f1 = 1  # флаг
        # Проверяем условие: нет двух одинаковых букв подряд
        for i in range(len(w) - 1):
            if w[i] == w[i + 1]:
                f1 = 0
                break
        # Если все условия выполнены, добавляем слово в множество
        if f1:
            ans.add(w)

print(len(ans))  # вывод результата

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

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

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

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

Решение программой (циклы):
Составим программу для перебора всех возможных 6-буквенных кодовых слов, которые включают только буквы М, А, Т, Е, Р, И, К. Для этого организуем 6 вложенных циклов, по одному на каждую букву. Каждый цикл перебирает буквы из строки "МАТЕРИК формируя все возможные комбинации.
После формирования каждого слова проверяем условие: буква Р должна встречаться ровно два раза. Для этого используем метод count. Если комбинация проходит проверку, добавляем её в множество. После завершения циклов выводим длину множества, получая количество различных кодовых слов.

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

# Перебор всех возможных 6-буквенных комбинаций
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):
Для перебора всех возможных комбинаций символов используем функцию product из модуля itertools. Она формирует все последовательности указанной длины, позволяя включать буквы более одного раза или не включать вовсе.
Условие «буква Р появляется ровно 2 раза» записывается в программе аналогично решению с помощью циклов.

from itertools import product

ans = set()
alf = ’МАТЕРИК’

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

    # проверяем, что Р встречается ровно два раза
    if w.count(’Р’) == 2:
        ans.add(w)
print(len(ans))  # выводим количество уникальных кодовых слов

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

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

Решение программой (циклы):
Составим программу для перебора всех возможных 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

                    # проверяем условие: первая буква гласная, последняя согласная
                    if w[0] in ’ЯО’ and w[-1] in ’КР’:
                        ans.add(w)  # добавляем слово в ответ
print(len(ans))  # выводим количество уникальных слов

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

from itertools import product

ans = set()
alf = ’ЯКОРЬ’

# Генерируем все возможные 5-буквенные комбинации из букв
for w in product(alf, repeat=5):
    w = ’’.join(w)  # преобразуем кортеж в строку
    # проверяем условие: первая буква гласная, последняя согласная
    if w[0] in ’ЯО’ and w[-1] in ’КР’:
        ans.add(w)
print(len(ans))  # выводим количество уникальных слов

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

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

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

У * * * * * на месте * может быть любая буква из набора С,П,Е,Х: У 4 4 4 4 4 варианта для случая, когда буква У стоит на первом месте. Она может стоять на любом из шести мест, следовательно, = 6144 слова с одной буквой У.

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

слов.

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

ans = set()  # множество для кодовых слов
alf = ’УСПЕХ’  # доступные буквы

# Перебор всех возможных 6-буквенных комбинаций
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):
Для перебора всех возможных комбинаций символов используем функцию product из модуля itertools. Она формирует все последовательности указанной длины, позволяя включать буквы более одного раза или не включать вовсе.
Условие «буква У встречается не менее 2 раз» записывается в программе аналогично решению с помощью циклов.

from itertools import product

ans = set()  # множество для хранения уникальных подходящих слов
alf = ’УСПЕХ’  # допустимые буквы

# Генерируем все возможные 6-буквенные комбинации из букв
for w in product(alf, repeat=6):
    w = ’’.join(w)  # преобразуем кортеж в строку
    # проверяем условие: буква У встречается не менее двух раз
    if w.count(’У’) >= 2:
        ans.add(w)  # добавляем слов в ответ
print(len(ans))  # выводим количество уникальных кодовых слов

Всего существует последовательностей (поделили на 2!, так как буква Р используется в слове два раза, поэтому так мы исключаем повторения)

Найдем количество последовательнотсей с сочетанием букв АТ:

1. А Т * * * * * *

2. * А Т * * * * *

3. * * А Т * * * *

4. * * * A T * * *

5. * * * * A T * *

6. * * * * * A T *

7. * * * * * * A T

Получается есть 7 вариантов перестановок букв АТ, для каждого варианта постановки АТ существует
последовательностей, но не забываем поделить на 2!, чтобы исключить повторения из-за двух букв Р, значит 720/2 = 360 последовательностей.

Тогда существует последовательностей, которые содержат сочетание АТ.

Значит для вычисления итогового ответа достаточно вычесть из всех последовательностей последовательности с сочетанием букв АТ:
20160 - 2520 = 17640 последовательностей без сочетания букв АТ.

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

word = "РЕСТОРАН"  # Исходное слово
alf = set("РЕСТОРАН")  # Уникальные буквы
ans = set()  # Множество для хранения неповторяющихся слов

# Генерация всех 8-буквенных слов через вложенные циклы
for x1 in alf:  # 1-я буква
    for x2 in alf:  # 2-я буква
        for x3 in alf:  # 3-я буква
            for x4 in alf:  # 4-я буква
                for x5 in alf:  # 5-я буква
                    for x6 in alf:  # 6-я буква
                        for x7 in alf:  # 7-я буква
                            for x8 in alf:  # 8-я буква
                                w = x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8
                                if "АТ" not in w:  # Проверяем отсутствие подстроки АТ
                                    f = 1  # Флаг. 1 = слово подходит, 0 = не подходит
                                    for i in w:  # Проверяем совпадение количества букв
                                        if w.count(i) != word.count(i):
                                            f = 0  # Слово не подходит
                                            break
                                    if f:  # Если все условия выполнены
                                        ans.add(w)  # Запоминаем подходящее слово
print(len(ans))  # Выводим количество уникальных слов

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

from itertools import product

word = "РЕСТОРАН"  # Исходное слово
alf = set("РЕСТОРАН")  # Уникальные буквы
ans = set()  # Множество для неповторяющихся слов

# Перебор всех 8-буквенных комбинаций из букв множества "РЕСТОРАН"
for w in product(alf, repeat=8):
    w = "".join(w)  # Собираем строку из кортежа
    if "АТ" not in w:  # Проверяем отсутствие подстроки "АТ"
        f = 1  # Флаг. 1 = слово подходит, 0 = не подходит
        for i in w:  # Проверяем совпадение количества букв
            if w.count(i) != word.count(i):
                f = 0  # Слово не подходит
                break
        if f:  # Если все условия выполнены
            ans.add(w)  # Запоминаем подходящее слово
print(len(ans))  # Выводим количество уникальных слов

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

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

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

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

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

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

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
                            # проверяем условия на позиции 2, 4 и 7
                            if w[1] in ’АН’ and w[3] in ’РМН’ and w[-1] == ’О’:
                                ans.add(w)
print(len(ans))  # выводим количество неповторяющихся слов

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

from itertools import product

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

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

Найдем слова без буквы Л, в таком случае на каждой из шести позиций может стоять любая буква из пятибуквенного набора П,О,И,Н,А слов.

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

* Л * * * *

* * Л * * *

* * * Л * *

* * * * Л *

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

4 Л 4 5 5 5

5 4 Л 4 5 5

5 5 4 Л 4 5

5 5 5 4 Л 4

Итого: 15625 + = 23625.

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

ans = set()  # множество для кодов
alf = ’ПОЛИНА’  # допустимые буквы

# Перебор всех возможных 6-буквенных комбинаций
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 w[0] != ’Л’
                                and w[-1] != ’Л’
                                and ’ЛА’ not in w and ’АЛ’ not in w):
                            ans.add(w)
print(len(ans))  # выводим количество уникальных кодов

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

from itertools import product

ans = set()  # множество для хранения уникальных кодов
alf = ’ПОЛИНА’  # допустимые буквы

# Генерируем все возможные 6-буквенные комбинации из букв
for w in product(alf, repeat=6):
    w = ’’.join(w)  # преобразуем кортеж в строку
    # проверяем условия на букву Л
    if (w.count(’Л’) <= 1 and w[0] != ’Л’ and w[-1] != ’Л’
            and ’ЛА’ not in w and ’АЛ’ not in w):
        ans.add(w)  # добавляем код в ответ
print(len(ans))  # выводим количество уникальных кодов

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

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

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

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

Итого: 1440+2304 = 3744 чисел.

Решение программой (циклы):
Составим программу для перебора всех 7-значных чисел в девятеричной системе с различными цифрами, так чтобы чётные и нечётные цифры не стояли рядом. Для этого организуем 7 вложенных циклов, по одному на каждую цифру, каждый перебирает цифры из строки 012345678, формируя все комбинации. После формирования каждого числа проверяем условие, что все цифры различны с помощью множества. Все цифры уникальны, если len(set(w)) == 7 (длине числа), потому что set(w) оставляет только уникальные элементы, а равная длина множества и слова означает отсутствие повторов. Далее последовательность чётных и нечётных цифр проверяем через замену чётных цифр на 0 и нечётных на 1 и поиск подстрок 00 и 11 (00 – две идущие подряд чётные цифры, 11 – нечётные). Не забываем добавить, что первая цифра не может быть нулём.
Если число удовлетворяет всем условиям, добавляем его в множество. После завершения циклов выводим длину множества, получая количество допустимых чисел.

ans = set()  # множество для хранения допустимых чисел
alf = ’012345678’  # допустимые цифры

# 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  # формируем число
                            # проверяем, что первая цифра не 0 и все цифры различны
                            if w[0] != ’0’ and len(w) == len(set(w)):
                                # заменяем четные цифры на 0, нечетные на 1
                                w1 = w.replace(’2’, ’0’).replace(’4’, ’0’).replace(’6’, ’0’).replace(’8’, ’0’)
                                w1 = w1.replace(’3’, ’1’).replace(’5’, ’1’).replace(’7’, ’1’)
                                # проверяем, чтобы не было подряд двух четных или двух нечетных
                                if ’00’ not in w1 and ’11’ not in w1:
                                    ans.add(w)  # добавляем число в множество
print(len(ans))  # выводим количество подходящих чисел

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

from itertools import permutations

ans = set()  # множество для хранения допустимых чисел
alf = ’012345678’  # допустимые цифры

# перебираем все перестановки длины 7
for w in permutations(alf, 7):
    w = ’’.join(w)  # преобразуем кортеж в строку
    if w[0] != ’0’:  # первая цифра не 0
        # заменяем четные цифры на 0, нечетные на 1
        w1 = w.replace(’2’, ’0’).replace(’4’, ’0’).replace(’6’, ’0’).replace(’8’, ’0’)
        w1 = w1.replace(’3’, ’1’).replace(’5’, ’1’).replace(’7’, ’1’)
        # проверяем, чтобы не было подряд двух четных или двух нечетных
        if ’00’ not in w1 and ’11’ not in w1:
            ans.add(w)  # добавляем число в ответ
print(len(ans))  # выводим количество допустимых чисел

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

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

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

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

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

ans = set()  # множество для хранения уникальных слов
alf = ’ПРИВЕТ’  # допустимые буквы

# Перебор всех возможных 6-буквенных слов
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):
Для перебора всех возможных комбинаций символов используем функцию product из модуля itertools. Она формирует все последовательности длины 6, позволяя использовать буквы более одного раза или не использовать вовсе. Условие на букву Е записываем аналогично решению с циклами.

from itertools import product

ans = set()  # множество для хранения уникальных слов
alf = ’ПРИВЕТ’  # допустимые буквы

for w in product(alf, repeat=6):
    w = ’’.join(w)  # преобразуем кортеж в строку
    if w.count(’Е’) == 2:  # проверяем, что буква Е встречается ровно два раза
        ans.add(w)  # добавляем слово в множество
print(len(ans))  # выводим количество неповторяющихся подходящих слов

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

Из них нужно вычесть количество сочетаний, в которых присутствуют буквы А и Т рядом. Комбинаций из этих букв всего 2: АТ и ТА, всего существует 7 варианта разместить две буквы рядом в слове из 8 букв, поэтому итоговая формула будет выглядеть так:

Решение программой (циклы):
Составим программу для перебора всех 8-буквенных слов из букв Х,О,Г,В,А,Р,Т,С. Для этого организуем 8 вложенных циклов, по одному на каждую букву, каждый перебирает буквы из строки «ХОГВАРТС», формируя все комбинации. После формирования слова проверяем условия: все буквы должны быть различны (это делается через len(set(w)) == 8, так как множество хранит только уникальные символы, и если его длина совпадает с длиной слова, значит, повторов нет). Также проверяем, что буквы «А» и «Т» не стоят рядом, для этого достаточно убедиться, используя оператор in, что подстроки «АТ» и «ТА» отсутствуют в слове.
Если слово удовлетворяет всем условиям, добавляем его в множество. После завершения циклов выводим длину множества, получая количество допустимых слов.

ans = set()  # множество для хранения уникальных слов
alf = ’ХОГВАРТС’  # допустимые буквы

# 8 вложенных циклов для перебора всех комбинаций
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 len(w) == len(set(w)):  # проверяем, что все буквы различны
                                    if ’АТ’ not in w and ’ТА’ not in w:  # проверяем, что А и Т не рядом
                                        ans.add(w)  # добавляем слово в множество
print(len(ans))  # выводим количество допустимых слов

Решение программой (itertools):
Для перебора всех возможных комбинаций используем функцию permutations из модуля itertools. Она формирует все перестановки указанной длины, что удобно в данной задаче, так как буквы не повторяются. После этого проверяем условие на рядом стоящие буквы «А» и «Т» точно так же, как в решении с циклами. Если слово подходит, добавляем его в множество.

from itertools import permutations

ans = set()  # множество для хранения уникальных слов
alf = ’ХОГВАРТС’  # допустимые буквы

# перебираем все перестановки длины 8
for w in permutations(alf, 8):
    w = ’’.join(w)  # преобразуем кортеж в строку
    if ’АТ’ not in w and ’ТА’ not in w:  # проверяем, что А и Т не рядом
        ans.add(w)  # добавляем слово в множество
print(len(ans))  # выводим количество допустимых слов

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

Слово должно начинаться на согласную, поэтому на первое место можем поставить 3 буквы: Л, Б и М.

Слово должно оканчиваться гласной, поэтому на последнее место можем поставить 2 буквы: А и О.

На остальные места можем поставить все 6 букв.

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

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

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

Для начала воспользуемся формулой сочетаний: .

При помощи неё найдём количество вариантов расставить 3 буквы Р на 6 мест:

Аналогичным образом найдём, что расставить 4 буквы Р на 6 мест можно 15-ю способами, 5 букв Р – 6-ю способами и 6 букв Р – 1 способом.

На оставшиеся места всегда можно расставить 4 буквы – все кроме Р. Так при 3-х буквах Р останется 3 места, при 4-х – 2 места, при 5-и – 1 место и 0 мест при 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("Р") >= 3: # Проверка по условию
                            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("Р") >= 3: # Проверка по условию
        ans.add(w) # Добавим в множество
print(len(ans)) # Выведем нужную длину

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

Всего у нас уникальных букв 2: А и Н, значит на 4 места их можно расставить следующим образом:

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

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

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

for x1 in alf:
    for x2 in alf:
        for x3 in alf:
            for x4 in alf:
                w = x1 + x2 + x3 + x4 # Формируем слово
                ans.add(w) # Добавим в множество
print(len(ans)) # Выведем нужную длину

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

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

from itertools import product

ans = set() # Множество подходящих слов
alf = "АН" # Алфавит к задаче
# Получим все 4-буквенные слова из заданного алфавита
for w in product(alf, repeat = 4):
    w = "".join(w) # join объединяет буквы
    ans.add(w) # Добавим в множество

print(len(ans)) # Выведем нужную длину

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

Рассмотрим 3 случая:

1. Буква С встречается в слове один раз. Тогда, на местах со второго по шестое может стоять одна из двух букв. Значит, в таком случае можно составить слова. Вариантов, когда буква С встречается в слове один раз, всего три - буква С либо на первом, либо на втором, либо на третьем месте. Значит, для первого случая всего существует слов.

2. Буква С встречается в слове три раза. Такое возможно только при условии, что буква С стоит сразу на первом, втором и третьем месте. Значит, для букв О и Н остаются только четвёртое, пятое и шестое место. Всего таких слов .

3. Буква С вовсе не встречается в слове. Тогда на всех местах может стоять два варианта букв: либо О, либо Н. Таких слов .

Осталось просуммировать все результаты и получить конечный ответ: .

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

Напишем программу для перебора всевозможных 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 # Формируем слово
                        # С не может встречаться во 2-й половине слова
                        # На 3-х местах С может встречаться 0, 1, 2, 3 раза
                        # Нам не подходит только 2
                        if "С" not in w[-3:] and 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 объединяет буквы
    # С не может встречаться во 2-й половине слова
    # На 3-х местах С может встречаться 0, 1, 2, 3 раза,
    # Нам не подходит только 2
    if "С" not in w[-3:] and w.count("С") != 2: # Проверка по условию
        ans.add(w) # Добавим в множество
print(len(ans)) # Выведем нужную длину

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

Восьмеричная система счисления содержит цифры: 0, 1, 2, 3, 4, 5, 6, 7. Существует шесть вариантов расстановки цифры 1.

1 * * * * * *

* 1 * * * * *

* * 1 * * * *

* * * 1 * * *

* * * * 1 * *

* * * * * 1 *

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

1 7 6 5 4 3 2 1*7*6*5*4*3*2=5040

6 1 6 5 4 3 2 6*1*6*5*4*3*2=4320

6 6 1 5 4 3 2 6*6*1*5*4*3*2=4320

6 6 5 1 4 3 2 6*6*5*1*4*3*2=4320

6 6 5 4 1 3 2 6*6*5*4*1*3*2=4320

6 6 5 4 3 1 2 6*6*5*4*3*1*2=4320

Итого получаем: 5040 + 5*4320 = 26640.

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

Напишем программу для перебора всевозможных комбинаций из 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)): # Если все цифры различны
                                if w.count("1") == 1 and w[-1] != "1" and w[0] != "0": # Проверка по условию
                                    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.count("1") == 1 and w[-1] != "1" and w[0] != "0": # Проверка по условию
        ans.add(w) # Добавим в множество
print(len(ans)) # Выведем нужную длину

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

Пусть буква Д не встречается в слове вовсе. Тогда, количество возможных вариантов слов: 3*3*3*3*1=81.

Если буква Д стоит на первом месте, то вариантов слов 1*3*3*3*1=27. Число перестановок для буквы Д равно 4(букву Д на последнем месте рассмотрим отдельно). Итак, при постановке буквы Д на последнее место снимается ограничение на гласные буквы, поэтому количество вариантов: 3*3*3*3*1 = 81. Получаем, что число слов, где встречается одна Д равно 27*4 + 81=189.

Таким образом, Игорь может составить 189+81=270 слов.

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

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

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

Всего гласных букв в данном слове 2, согласных - 4. Тогда, на первом и последнем месте может стоять 4 варианта букв. На остальных местах - 6. Общее количество слов - 4*6*6*6*6*4 = 20736.

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

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

a = "ОБЛЖКА" # Алфавит к задаче
a1 = "БЛЖК" # Согласные из алфавита
count = 0 # Счётчик подходящих слов
for x1 in a1:
    for x2 in a:
        for x3 in a:
            for x4 in a:
                for x5 in a:
                    for x6 in a1:
                        s = x1 + x2 + x3 + x4 + x5 + x6 # Формируем слово
                        count += 1 # Увеличим счётчик
print(count) # Выводим нужное количество

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

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

from itertools import product
count = 0 # Счётчик подходящих слов
# Получим все 6-буквенные слова из заданного алфавита
for x in product("ОБЛЖКА", repeat = 6):
    s = "".join(x) # join объединяет буквы
    if s[0] in "БЛЖК" and s[-1] in "БЛЖК": # Проверка по условию
        count += 1 # Увеличим счётчик
print(count) # Выводим нужное количество

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

В слове МИРАЖ 3 согласных и 2 гласных буквы. Пусть в словах вовсе не встречается гласных букв. Таких слов существует: 3*3*3*3*3=243.

Пусть в словах встречается одна из гласных букв. Допустим, можно поставить букву И на первое место, тогда получается 1*3*3*3*3=81 слов. Всего вариантов размещения буквы И - 5. Всего слов с буквой И получается 81*5=405. Аналогично для буквы А. С одной гласной буквой получается 405*2=810 слов.

Пуст в словах встречаются обе гласные буквы. Всего 5 позиций, две из которых отводится для гласных букв. Если гласные буквы занимают первые две позиции, то слов получается 1*1*3*3*3=27. Количество перестановок гласных букв - 5*4=20. Всего слов получается 27*20=540.

Итого получаем 243+810+540 = 1593.

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

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

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

Пусть буква К не встречается в словах вовсе. Таких слов возможно 6*6*6*6*6*6*6=279936.

Пусть буква К стоит на второй позиции. Количество возможных слов при этом (при условии, что буква Л не стоит рядом) равно: 5*1*5*6*6*6*6=32400. Также буква К может стоять на третьем, четвертом, пятом и шестом месте. Значит, всего слов с буквой К: 32400*5=162000.

Таким образом, всего возможно слов: 162000+279936=441936.

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

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