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

На первое место Оксана ставит одну из букв, на второе — одну из оставшихся, т.к. одна буква уже использована. По той же логике, на третье — одну из оставшихся, на четвёртое — одну из оставшихся и на пятое одну из оставшихся букв. Всего Оксана может составить различных слов.
Решение кодом через циклы:

Для решения задачи с помощью циклов создаём пустое множество ans, куда будем добавлять все допустимые слова. Строка alf = ’МНОГТЧКИ’ содержит все доступные буквы. Используем 5 вложенных циклов, по одному на каждую позицию слова (x1, x2, x3, x4, x5). На каждой итерации формируем текущее слово: w = x1+x2+x3+x4+x5. Проверяем условие:

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

Если слово удовлетворяет условию, добавляем его в множество ans. После завершения перебора выводим количество элементов множества, что соответствует числу допустимых слов.

# Создаем множество для хранения уникальных слов
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 len(w) == len(set(w)):
                        ans.add(w)
# Выводим количество уникальных слов
print(len(ans))

Решение кодом через itertools:

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

from itertools import permutations

# Создаем множество для хранения уникальных слов
ans = set()
# Набор доступных букв
alf = ’МНОГТЧКИ’

# Перебираем все перестановки длины 5 без повторений
for x in permutations(alf, 5):
    ans.add(x)

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

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

Представим, что первые числа — чашки, а вторые числа — блюдца. Сколько различных вариаций чашка+блюдце можно составить?

Можно составить различных пар чисел (блюдец с чашкой).
Решение кодом через циклы:

Для решения задачи с помощью циклов создаём пустое множество ans, куда будем добавлять все допустимые пары чисел. Строки alf1 = ’0123456789’ и alf2 = ’13579’ содержат доступные цифры для первого и второго числа соответственно. Для первого числа используем два вложенных цикла по переменным x1 и x2, формируя число w1 = x1+x2. Для второго числа используем семь вложенных циклов по переменным y1, ..., y7, формируя число w2 = y1+y2+...+y7. Добавляем пару (w1, w2) в множество ans. После завершения перебора выводим количество элементов множества.

# Создаем множество для хранения уникальных пар чисел
ans = set()
# Цифры для первого числа
alf1 = ’0123456789’
# Цифры для второго числа (только нечётные)
alf2 = ’13579’

# Перебор всех возможных 2-значных чисел
for x1 in alf1:
    for x2 in alf1:
        w1 = x1 + x2 # Формируем первое число
        # Перебор всех возможных 7-значных чисел из нечётных цифр
        for y1 in alf2:
            for y2 in alf2:
                for y3 in alf2:
                    for y4 in alf2:
                        for y5 in alf2:
                            for y6 in alf2:
                                for y7 in alf2:
                                    w2 = y1 + y2 + y3 + y4 + y5 + y6 + y7
                                    # Добавляем пару чисел в множество
                                    ans.add((w1, w2))
# Выводим количество уникальных пар чисел
print(len(ans))

Решение кодом через itertools:

Используем модуль itertools и функцию product для генерации всех возможных комбинаций цифр с повторениями. Создаём пустое множество ans. Перебираем все пары чисел: для первого числа — все комбинации длины 2 из alf1, для второго числа — все комбинации длины 7 из alf2. Каждую пару добавляем в множество. После перебора выводим длину множества.

from itertools import product

# Создаем множество для хранения уникальных пар чисел
ans = set()
# Цифры для первого числа
alf1 = ’0123456789’
# Цифры для второго числа (только нечётные)
alf2 = ’13579’

# Перебираем все возможные 2-значные числа
for x in product(alf1, repeat=2):
    # Перебираем все возможные 7-значные числа из нечётных цифр
    for y in product(alf2, repeat=7):
        # Добавляем пару чисел в множество
        ans.add((x, y))

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

В первом числе друг может поставить на каждую из 3 позиций любую из 7 цифр. Значит первое число можно составить различными способами. Во втором числе на каждой из 5 позиций может стоять одна из 4 нечётных цифр. Значит второе число можно составить различными способами.

Представим, что первые числа — чашки, а вторые числа — блюдца. Сколько различных вариаций кружка+чашка можно составить?

Можно составить различных пар чисел (блюдец с чашкой).
Решение кодом через циклы:

Для решения задачи с помощью циклов создаём пустое множество ans, куда будем добавлять все допустимые пары чисел. Строки alf1 = ’1234567’ и alf2 = ’1357’ содержат доступные цифры для первого и второго числа соответственно. Для первого числа используем три вложенных цикла по переменным x1, x2, x3, формируя число w1 = x1+x2+x3. Для второго числа используем пять вложенных циклов по переменным y1, ..., y5, формируя число w2 = y1+y2+...+y5. Каждую пару (w1, w2) добавляем в множество ans. После завершения перебора выводим количество элементов множества.

# Создаем множество для хранения уникальных пар чисел
ans = set()
# Цифры для первого числа
alf1 = ’1234567’
# Цифры для второго числа (только нечётные)
alf2 = ’1357’

# Перебор всех возможных 3-значных чисел
for x1 in alf1:
    for x2 in alf1:
        for x3 in alf1:
            w1 = x1 + x2 + x3 # Формируем первое число
            # Перебор всех возможных 5-значных чисел из нечётных цифр
            for y1 in alf2:
                for y2 in alf2:
                    for y3 in alf2:
                        for y4 in alf2:
                            for y5 in alf2:
                                w2 = y1 + y2 + y3 + y4 + y5
                                # Добавляем пару чисел в множество
                                ans.add((w1, w2))
# Выводим количество уникальных пар чисел
print(len(ans))

Решение кодом через itertools:

Для решения задачи с помощью модуля itertools используем функцию product, которая генерирует все возможные комбинации с повторениями. Создаём пустое множество ans. Перебираем все комбинации длины 3 из alf1 для первого числа и все комбинации длины 5 из alf2 для второго числа. Каждую пару добавляем в множество. После перебора выводим размер множества.

from itertools import product

# Создаем множество для хранения уникальных пар чисел
ans = set()
# Цифры для первого числа
alf1 = ’1234567’
# Цифры для второго числа (только нечётные)
alf2 = ’1357’

# Перебор всех возможных 3-значных чисел
for x in product(alf1, repeat=3):
    # Перебор всех возможных 5-значных чисел из нечётных цифр
    for y in product(alf2, repeat=5):
        # Добавляем пару чисел в множество
        ans.add((x, y))

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

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

Для решения задачи создаём пустое множество ans, которое будет хранить все уникальные числа. Используем строку alf = ’0123456789’, которая содержит все доступные цифры. Далее организуем четыре вложенных цикла, каждый из которых перебирает одну цифру числа:

1. Первый цикл x1 выбирает первую цифру числа. Проверка условия осуществляется внутри цикла: если x1 != ’0’ и x1 != ’7’, число допускается для добавления.
2. Циклы x2, x3, x4 перебирают вторую, третью и четвёртую цифры числа без ограничений, так как повторение цифр разрешено и условие на первую цифру уже проверено.

После формирования числа w = x1 + x2 + x3 + x4 выполняется проверка условия: первая цифра не равна ’0’ и не равна ’7’. Если условие выполнено, число добавляется в множество ans. Множество гарантирует уникальность чисел, поэтому дубликаты автоматически исключаются. После завершения всех циклов выводим длину множества len(ans), которая и будет количеством допустимых четырёхзначных чисел.

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

# Перебор первой цифры числа
for x1 in alf:
    # Перебор второй цифры числа
    for x2 in alf:
        # Перебор третьей цифры числа
        for x3 in alf:
            # Перебор четвертой цифры числа
            for x4 in alf:
                # Формируем число
                w = x1 + x2 + x3 + x4
                # Проверяем условие: первая цифра не 0 и не 7
                if x1 != ’0’ and x1 != ’7’:
                    # Добавляем число в множество
                    ans.add(w)
# Выводим количество уникальных чисел
print(len(ans))

Решение кодом через itertools:

Для решения с использованием модуля itertools удобно использовать функцию product, которая создаёт все возможные комбинации с повторениями заданной длины. Строка alf = ’0123456789’ содержит все цифры. Функция product(alf, repeat=4) создаёт все 4-значные комбинации. Для каждой комбинации проверяем, что первая цифра () не равна ’0’ и не равна ’7’. Допустимые комбинации добавляем в множество ans. После перебора всех комбинаций выводим размер множества.

from itertools import product

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

# Перебор всех 4-значных комбинаций
for x in product(alf, repeat=4):
    # Проверяем условие: первая цифра не 0 и не 7
    if x[0] != ’0’ and x[0] != ’7’:
        # Добавляем число в множество
        ans.add(x)

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

Мы имеем 4 позиции, на которые можно поставить любую из 4 букв алфавита. При этом, нам надо чтобы в каждом слове была обязательно только одна буква К. Если мы поставим К на первую позицию, то на три остальных мы можем поставить любую из оставшихся трёх букв. Получается что всего слов с единственной К на первой позиции . Проделываем те же самые действия для оставшихся позиций буквы К, получается .
Решение кодом через циклы:

Для решения задачи создаём пустое множество ans, куда будем добавлять все допустимые слова. Строка alf = ’КРАБ’ содержит все доступные буквы. Используем 4 вложенных цикла, по одному на каждую позицию слова (x1, x2, x3, x4). На каждой итерации формируем текущее слово: w = x1+x2+x3+x4. Проверяем условие:

• Слово содержит ровно одну букву К: w.count(’К’) == 1.

Если условие выполнено, добавляем слово в множество ans. После завершения перебора выводим количество элементов множества, что соответствует числу допустимых слов.

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

# Перебор всех 4-буквенных комбинаций
for x1 in alf:
    for x2 in alf:
        for x3 in alf:
            for x4 in alf:
                # Формируем слово из текущей комбинации букв
                w = x1 + x2 + x3 + x4
                # Проверяем условие: буква К встречается ровно один раз
                if w.count(’К’) == 1:
                    ans.add(w)
# Выводим количество уникальных слов
print(len(ans))

Решение кодом через itertools:

Используем модуль itertools и функцию product для генерации всех возможных комбинаций длины 4 с повторениями. Создаём пустое множество ans. Для каждой комбинации проверяем, что буква К встречается ровно один раз (x.count(’К’) == 1). Если условие выполнено, добавляем комбинацию в множество. После перебора выводим длину множества.

from itertools import product

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

# Перебираем все возможные комбинации длины 4 с повторениями
for x in product(alf, repeat=4):
    # Проверяем условие: буква К встречается ровно один раз
    if x.count(’К’) == 1:
        ans.add(x)

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

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

.
Решение кодом через циклы:

Для решения задачи создаём пустое множество ans, куда будем добавлять все допустимые слова. Строка alf = ’КРАБ’ содержит все доступные буквы. Используем 5 вложенных циклов, по одному на каждую позицию слова (x1, x2, x3, x4, x5). На каждой итерации формируем текущее слово: w = x1 + x2 + x3 + x4 + x5. Так как условие позволяет использовать любую букву любое количество раз, дополнительных проверок не требуется. Добавляем слово в множество ans. После завершения перебора выводим количество элементов множества, что соответствует числу допустимых слов.

# Создаем множество для хранения уникальных слов
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
                    # Добавляем слово в множество, так как все комбинации допустимы
                    ans.add(w)
# Выводим количество уникальных слов
print(len(ans))

Решение кодом через itertools:

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

from itertools import product

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

# Перебираем все возможные комбинации длины 5 с повторениями
for x in product(alf, repeat=5):
    # Добавляем комбинацию в множество
    ans.add(x)

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

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

У нас имеется 4 позиции и 6 букв. Каждую букву можно использовать не более одного раза. Посчитаем количество вариантов размещения 6 букв на 4 позициях: .

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

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

ans = set() # Множество подходящих слов
alf = "PYTHON" # Алфавит к задаче
for x1 in alf:
    for x2 in alf:
        for x3 in alf:
            for x4 in alf:
                w = x1 + x2 + x3 + x4 # Формируем слово
                if len(w) == len(set(w)): # Если буквы не повторяются (set уберет повторяющиеся, если букв осталось столько, сколько и было - повторяющихся нет)
                    ans.add(w) # Добавим слово к множеству
print(len(ans)) # Вывод количества слов

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

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

from itertools import permutations
ans = set() # Множество подходящих слов
alf = "PYTHON" # Алфавит к задаче
for x in permutations(alf, 4): # Получим все 4-буквенные слова, перестановка букв означает, что ни одна из них не будет повторяться в пределах одного слова
    ans.add(x) # Добавим слово к множеству
print(len(ans)) # Вывод количества слов

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

У нас имеется 5 позиций и 4 буквы. Каждую букву можно использовать сколько угодно раз. Посчитаем количество вариантов размещения этих букв на 5 позициях: .

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

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

ans = set() # Множество подходящих слов
alf = ’ABCD’ # Алфавит к задаче
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 # Формируем слово
                    ans.add(w) # Добавим слово к множеству
print(len(ans)) # Вывод количества слов

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

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

from itertools import product
ans = set() # Множество подходящих слов
alf = "ABCD" # Алфавит к задаче
for x in product(alf, repeat = 5): # Получим все 5-буквенные слова
    ans.add(x) # Добавим слово к множеству
print(len(ans)) # Вывод количества слов

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

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

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

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

ans = set() # Множество подходящих слов
# Чтобы для программы буквы С были разными, одну из них сделаем маленькой
alf = "ГОТСМc" # Алфавит к задаче
for x1 in alf:
    for x2 in alf:
        for x3 in alf:
            for x4 in alf:
                w = x1 + x2 + x3 + x4 # Формируем слово
                # Если буквы не повторяются (set уберет повторяющиеся, если букв осталось столько, сколько и было - повторяющихся нет) и первая буква не О
                if len(w) == len(set(w)) and x1 in "ГТСМc":
                    ans.add(w) # Добавим слово к множеству
print(len(ans)) # Вывод количества слов

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

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

from itertools import permutations
ans = set() # Множество подходящих слов
# Чтобы для программы буквы С были разными, одну из них сделаем маленькой
alf = "ГОТСМc" # Алфавит к задаче
for x in permutations(alf, 4): # Получим все 4-буквенные слова, перестановка букв означает, что ни одна из них не будет повторяться в пределах одного слова
    if x[0] in "ГТСМc": # Первая буква не О
        ans.add(x) # Добавим слово к множеству
print(len(ans)) # Вывод количества слов

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

У нас имеется позиций и букв. Каждую букву можно использовать строго один раз. Посчитаем количество вариантов размещения этих букв на позициях (сначала расставим гласные по краям, а затем расставим остальные буквы): .

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

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

a = "ШКОЛКОВО" # Алфавит к задаче
gl = "О" # Гласные буквы слова
count = 0 # Счётчик подходящих слов
# переборы для наших букв
for x1 in gl:
    for x2 in a:
        for x3 in a:
            for x4 in a:
                for x5 in a:
                    for x6 in a:
                        for x7 in a:
                            for x8 in gl:
                                s = x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 # Формируем слово
                                # Проверка, что каждая буква встречается столько же раз, сколько раз записана эта буква в начальном слове
                                if all(s.count(i) == a.count(i) for i in s):
                                    count += 1 # Увеличиваем счётчик
print(count)

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

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

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

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

У нас имеется 10 позиций и 11 букв, 5 гласных и 6 согласных. Каждую букву можно использовать максимум один раз. Посчитаем количество вариантов размещения этих букв на 10 позициях (сначала записываем для четных позиций, потом для нечетных): .

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

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

from itertools import permutations
ans = set()
# Одинаковые буквы запишем в разном регистре
alf = "ИНФОРМАТиКа" # Алфавит из условия, сделаем буквы И разными, чтобы их различать
sogl = "НФРМТК" # Согласные буквы из нашего алфавита
for x in permutations(alf, 10): # Получим все 10-буквенные слова, перестановка букв означает, что ни одна из них не будет повторяться в пределах одного слова
    if x[1] in sogl and x[3] in sogl and x[5] in sogl and x[7] in sogl and x[9] in sogl: # Являются ли нужные буквы согласными
        ans.add(x) # Добавим слово к множеству
print(len(ans)) # Вывод количества слов

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

Из условия мы понимаем, что в слове должно быть 5 согласных букв и одна гласная. Допустим гласная стоит на первом месте, тогда всего таких вариантов 2 * 3 * 3 * 3 * 3 * 3. Но гласная может стоять не только на первом месте, поэтому умножаем это число на 6. Тогда получаем 2 * 3 * 3 * 3 * 3 * 3 * 6 = 2916

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

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

a = "МАШИН" # Алфавит к задаче
sogl = "МШН" # Согласные буквы нашего слова
gl = "АИ" # Гласные буквы нашего слова
count = 0 # Счётчик подходящих слов
for x1 in a:
    for x2 in a:
        for x3 in a:
            for x4 in a:
                for x5 in a:
                    for x6 in a:
                        s = x1 + x2 + x3 + x4 + x5 + x6 # Составляем слово
                        # Проверка, что есть хотя бы одна согласная буква и ровно одна гласная буква
                        if sum(s.count(i) for i in sogl) >= 1 and sum(s.count(i) for i in gl) == 1:
                            count += 1 # Увеличим счётчик
print(count) # Вывод количества слов

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

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

from itertools import product
ans = 0 # Счётчик подходящих слов
for i in product("МАШИН", repeat = 6): # Получим все 6-буквенные слова из заданного алфавита
    s = "".join(i)
    if s.count("М") >= 1 or s.count("Ш") >= 1 or s.count("Н") >= 1: # Есть ли в слове нужное количество букв
        k = s.count("А") + s.count("И")
        if k == 1: ans += 1 # Увеличим счётчик при соблюдении условия
print(ans) # Вывод количества слов

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

from itertools import product

ans = 0
for i in product(’ТОСЕР’, repeat=7):
    s = ’’.join(i)
    # Проверка на две буквы не могут стоять рядом
    if all(s.count(j * 2) == 0 for j in ’ТОСЕР’):
        # Очевидно, что С не может стоять на первом и последнем
        if s[0] != ’С’ and s[-1] != ’С’:
            # Проверка на букву С между ОЕ или ЕО
            flag = True
            for j in range(1, len(s) - 1):
                if s[j] == ’С’:
                    if (s[j - 1] == ’О’ and s[j + 1] == ’Е’) or \
                            (s[j - 1] == ’Е’ and s[j + 1] == ’О’):
                        # Если такая комбинация есть - проверяем дальше
                        continue
                    else:
                        # Если вокруг С стоит неподходящая - не подходит слово
                        flag = False
                        break
            if flag:
                ans += 1
print(ans)

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

a = ’ТОСЕР’ # наше слово
m = [x1+’С’+x2 for x1 in a for x2 in a if x1+x2 != ’ОЕ’ and x1+x2 != ’ЕО’] # запрещенные комбинации, которые не должны быть в слове если в слове есть С

count = set()
# перебор наших букв
for x1 in a:
    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 sum(s.count(i*2) for i in a) == 0: # проверяем, что нет рядом стоящих одинаковых букв
                                # проверяем, что не одной запрещенной комбинации в слове нет и при этом C не на первом и не на последнем месте
                                if all(i not in s for i in m) and s[0] != ’С’ and s[-1] != ’С’:
                                    count.add(s)

print(len(count))

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

Сперва посчитаем общее количество слов. Поскольку всего букв , а слово состоит из букв, оно равно .

Теперь посчитаем количество неподходящих слов, содержащих словосочетание БУРЖУИ. Словосочетание занимает букв, на оставшиеся буквы можно поставить любую из букв. Само словосочетание можно поставить на три позиции. Получим такую картину:

То есть, общее количество неподходящих слов равно .

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

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

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

a = "БУРЖАЗИЯ" # Алфавит
count = 0 # Счётчик количества подходящих слов
# перебор наших букв для слова
for x1 in a:
    for x2 in a:
        for x3 in a:
            for x4 in a:
                for x5 in a:
                    for x6 in a:
                        for x7 in a:
                            for x8 in a:
                                s = x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 # Составляем слово
                                if "БУРЖУИ" not in s: # Проверка по условию
                                    count += 1 # Увеличим счётчик
print(count)

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

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

from itertools import product
count = 0 # Счётчик количества подходящих слов
# Получим все 8-буквенные слова из заданного алфавита
for x in product("БУРЖАЗИЯ", repeat = 8):
    s = "".join(x) # join объединяет буквы
    if "БУРЖУИ" not in s:  # Проверка по условию
        count += 1 # Увеличим счётчик
print(count)

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

Посчитаем количество слов, в которых МЫШ встречается хотя бы один раз. Сочетание МЫШ может начинаться с 1-й, 2-й, 3-й, 4-й или 5-й позиции в 7-буквенном слове. Всего 5 возможных позиций:

МЫШxxxx,

xМЫШxxx,

xxМЫШxx,

xxxМЫШx,

xxxxМЫШ.

Для каждой из 5 позиций МЫШ, оставшиеся 4 буквы могут быть любыми из 4 возможных. Таким образом, для каждой позиции количество вариантов: . Умножаем количество позиций на количество вариантов для оставшихся букв: .

Однако оставшиеся буквы могли сформировать новое сочетание МЫШ, такие слова были посчитаны дважды, поэтому необходимо исключить из получившегося количества слов слова, в которых МЫШ встречается дважды. Слова с тремя МЫШ невозможны.

Возможные позиции для двух МЫШ:

МЫШМЫШx

МЫШxМЫШ

xМЫШМЫШ

Итого 3 варианта. На каждую свободную букву 4 варианта. Всего: слов.

Тогда итоговый ответ:

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

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

counter = 0 # Счётчик походящих слов
for a1 in ("МЫШИ"):
    for a2 in ("МЫШИ"):
        for a3 in ("МЫШИ"):
            for a4 in ("МЫШИ"):
                for a5 in ("МЫШИ"):
                    for a6 in ("МЫШИ"):
                        for a7 in ("МЫШИ"):
                            s = a1 + a2 + a3 + a4 + a5 + a6 + a7 # Формируем слово
                            if s.count("МЫШ") >= 1: # Проверяем главное условие задачи
                                counter += 1
print(counter)

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

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

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

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

Ставим на первое место 8 букв, на второе можно поставить 7 букв, на третье 6, на четвертое 5, на пятое 4. Ответ: 8*7*6*5*4.

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

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

a = "МНОГТЧКИ" # Алфавит
count = 0 # Счётчик подходящих слов
for x1 in a:
    for x2 in a:
        for x3 in a:
            for x4 in a:
                for x5 in a:
                    s = x1 + x2 + x3 + x4 + x5 # Составляем слово
                    if all(s.count(i) == 1 for i in s): # Проверяем, что каждая буква в слове встречается ровно 1 раз
                        count += 1 # Увеличим счётчик
print(count)

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

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

from itertools import permutations
count = 0 # Счётчик подходящих слов
# Получим все 5-буквенные слова, перестановка букв означает, что ни одна из них не будет повторяться в пределах одного слова
for x in permutations("МНОГТЧКИ", r = 5):
    s = "".join(x) # join обьединяет буквы
    count += 1 # Увеличим счётчик
print(count)

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

Рассмотрим каждую из ситуаций, в которых Т будет встречаться от 1 до 5 раз, а Й будет встречаться от 0 до 1 раза.

1 случай: Т - 1 раз

Если Й - 0 раз, то букву Т можно разместить на одно из 5 мест, для оставшихся 4 мест будет доступно 5 букв (все, кроме Т и Й), итого вариантов.

Если Й - 1 раз, то букву Т можно разместить на одно из 5 мест, Й - на одно из 4 мест, для оставшихся 3 мест будет доступно 5 букв, итого вариантов.

2 случай: Т - 2 раз

Если Й - 0 раз, то первую букву Т можно поставить на одно из 5 мест, вторую букву Т на одно из 4 мест, для оставшихся 3 мест будет доступно 5 букв. Итого, с учетом исключения вариантов, получившихся перестановкой букв Т между собой, получаем вариантов.

Если Й - 1 раз, то первую букву Т можно поставить на одно из 5 мест, вторую букву Т на одно из 4 мест, Й на одно из 3 мест, для оставшихся 2 мест будет доступно 5 букв. Итого, с учетом исключения вариантов, получившихся перестановкой букв Т между собой, получаем вариантов.

3 случай: Т - 3 раз

Если Й - 0 раз, то первую букву Т можно поставить на одно из 5 мест, вторую букву Т на одно из 4 мест, третью букву Т на одно из 3 мест, для оставшихся 2 мест будет доступно 5 букв. Итого, с учетом исключения вариантов, получившихся перестановкой букв Т между собой, получаем вариантов.

Если Й - 1 раз, то первую букву Т можно поставить на одно из 5 мест, вторую букву Т на одно из 4 мест, третью букву Т на одно из 3 мест, Й на одно из 2 мест, для оставшегося места будет доступно 5 букв. Итого, с учетом исключения вариантов, получившихся перестановкой букв Т между собой, получаем вариантов.

4 случай: Т - 4 раз

Если Й - 0 раз, то первую букву Т можно поставить на одно из 5 мест, вторую букву Т на одно из 4 мест, третью букву Т на одно из 3 мест, четвертую букву Т на одно из 2 мест, для оставшегося места будет доступно 5 букв. Итого, с учетом исключения вариантов, получившихся перестановкой букв Т между собой, получаем вариантов.

Если Й - 1 раз, то первую букву Т можно поставить на одно из 5 мест, вторую букву Т на одно из 4 мест, третью букву Т на одно из 3 мест, четвертую букву Т на одно из 2 мест, Й на одно оставшееся место. Итого, с учетом исключения вариантов, получившихся перестановкой букв Т между собой, получаем вариантов.

5 случай: Т - 5 раз - 1 возможный вариант

Суммируем все варианты: .

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

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

ans = 0 # Счётчик подходящих слов
for a1 in ("ТИМОФЕЙ"):
    for a2 in ("ТИМОФЕЙ"):
        for a3 in ("ТИМОФЕЙ"):
            for a4 in ("ТИМОФЕЙ"):
                for a5 in ("ТИМОФЕЙ"):
                    s = a1 + a2 + a3 + a4 + a5 # Формируем слово
                    if s.count("Т") >= 1 and s.count("Й") <= 1: # Проверка по условию
                        ans += 1 # Увеличим счётчик
print(ans)

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

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

from itertools import product
count = 0 # Счётчик подходящих слов
# Получим все 5-буквенные слова
for x in product("ТИМОФЕЙ", repeat = 5):
    s = "".join(x) # join объединит буквы
    if s.count("Т") >= 1 and s.count("Й") <= 1: # Проверка по условию
     count += 1 # Увеличим счётчик
print(count)

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

В нашем слове 6 согласных букв (ПЛНМТР) и 4 уникальных гласных букв (АИЕЯ). Нам нужно составить 7-буквенное слово, значит, для того чтобы условие выполнилось, нам нужно использовать каждую согласную букву ровно по одному разу. Количество перестановок согласных букв среди 6 мест равна: . На оставшееся место в любом слове мы можем расположить одну и 4 гласных букв. Количество слов, которое можно составить если гласная будет находиться на последнем месте: . Данное значение нужно умножить на количество вариантов слова, которые нам подходят. Всего таких вариантов слов 7. Умножаем количество слов в одно варианте на количество вариантов подходящих слов: .

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

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

a = set() # Множество подходящих слов
for a1 in ("ПЛАНИМЕТРИЯ"):
    for a2 in ("ПЛАНИМЕТРИЯ"):
        for a3 in ("ПЛАНИМЕТРИЯ"):
            for a4 in ("ПЛАНИМЕТРИЯ"):
                for a5 in ("ПЛАНИМЕТРИЯ"):
                    for a6 in ("ПЛАНИМЕТРИЯ"):
                        for a7 in ("ПЛАНИМЕТРИЯ"):
                            slovo = a1 + a2 + a3 + a4 + a5 + a6 + a7 # Формируем слово
                            if all(slovo.count(x) % 2 == 1 for x in "ПЛНМТР"): # Если каждая согласная буква в слове используется нечётное кол-во раз
                                a.add(slovo) # Добавим слово в множество
print(len(a)) # Вывод нужного количества

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

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

from itertools import product
count = set() # Множество подходящих слов
# Получим все 7-буквенные слова
for x in product("ПЛАНИМЕТРИЯ", repeat = 7):
    s = "".join(x) # join объединит буквы
    if all(s.count(i) % 2 != 0 for i in "ПЛНМТР"): # Если каждая согласная буква в слове используется нечётное кол-во раз
        count.add(s) # Добавим слово в множество
print(len(count)) # Вывод нужного количества

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

Начнем со слов длины 5: на 1 место можно поставить 4 буквы (все согласные), на второе - 6, на третье - 6, на четвертое - 6, на пятое - 2 (все гласные).

Слова длины 4: на 1 место можно поставить 4 буквы (все согласные), на второе - 6, на третье - 6, на четвертое - 2 (все гласные).

Слова длины 3: на 1 место можно поставить 4 буквы (все согласные), на второе - 6, на третье - 2 (все гласные).

Слова длины 2: на 1 место можно поставить 4 буквы (все согласные), на второе - 2 (все гласные).

Меньше букв нельзя, так как мы не выполним условие никак.

Получаем ответ: 4*6*6*6*2 + 4*6*6*2 + 4*6*2 + 4*2 = 2072.

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

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

a = "АБВГДЕ" # Наше слово
gl = "АЕ" # Гласные буквы слова
sogl = "БВГД" # Согласные буквы слова
count = set() # Множество подходящих слов
# Двухбуквенные слова
for x1 in sogl:
    for x2 in gl:
        s = x1 + x2 # Формируем слово и добавляем его в множество
        count.add(s)
# Трёхбуквенные слова
for x1 in sogl:
    for x2 in a:
        for x3 in gl:
            s = x1 + x2 + x3 # Формируем слово и добавляем его в множество
            count.add(s)
# Четырёхбуквенные слова
for x1 in sogl:
    for x2 in a:
        for x3 in a:
            for x4 in gl:
                s = x1 + x2 + x3 + x4 # Формируем слово и добавляем его в множество
                count.add(s)
# Пятибуквенные слова
for x1 in sogl:
    for x2 in a:
        for x3 in a:
            for x4 in a:
                for x5 in gl:
                    s = x1 + x2 + x3 + x4 + x5 # Формируем слово и добавляем его в множество
                    count.add(s)
print(len(count)) # Количество подходящих слов

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

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

from itertools import product
count = set() # Множество подходящих слов
for i in range(2,6): # С помощью product будем рассматривать слова различной длины
    for x in product("АБВГДЕ", repeat = i):
        s = "".join(x) # join объединит буквы
        if s[0] not in "АЕ" and s[-1] in "АЕ": # Проверка по условию
            count.add(s) # Добавляем слово в множество
print(len(count)) # Количество подходящих слов

Так как всего мест и каждая из букв может встречаться по раза, проиндексируем все буквы, то есть: , , , , и т.д. Получается, теперь каждая может встречаться в слове по разу, так как изначальное буквы могли по , а из каждой буквы мы сделали индексированных. Значит, на место можно поставить букв ( гласные), на последнее букв (букву с места нельзя использовать). Расставляем остальные буквы, будет: . Это ответ на задачу, если бы буквы были проиндексированы, но теперь нам надо убрать перестановки , , и т.д. Значит, делим на . Такое надо сделать для каждой из букв, значи получается ответ: