02 Подсчет количества адресов в сети

Решение Python:

Чтобы решить задачу, нужно перебрать все IP-адреса в сети, заданной адресом 42.54.160.28 и маской 255.255.255.252. Каждый адрес переводим в двоичную форму и проверяем, содержится ли в его записи последовательность «1111». Если такой последовательности нет, то адрес учитывается и увеличивает счетчик. В конце значение счетчика и будет количеством искомых IP-адресов в данной сети.

from ipaddress import *
# Создаем объект ip_network
net = ip_network("42.54.160.28/255.255.255.252")
# Инициализируем счетчик
c = 0
# Перебираем ip адреса сети
for i in net:
# Если "1111" нет в двоичном представлении ip адреса
    if "1111" not in bin(int(i)):
     # Увеличиваем счетчик
        c += 1
# Печатаем ответ
print(c)

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

На месте первого «x» не может стоять 1, так как получится комбинация «1111». Поэтому, там ставим 0.

Остается один «x». Всего существует 2 варианта поставить туда 1 или 0.

Решение Python:

Чтобы найти наименьшее количество адресов в сети, в которой одновременно могут находиться узлы с IP-адресами 245.192.192.53 и 245.192.192.25, нужно перебрать все возможные варианты масок сети от 0 до 32. Для каждой маски вычисляем сеть, в которую попадает первый адрес, и сеть для второго адреса, а затем сравниваем их адреса сети. Если они совпадают, значит оба узла действительно находятся в одной сети. Для такой ситуации фиксируем количество адресов в сети и выбираем минимальное возможное значение. Именно оно и будет ответом.

from ipaddress import *
# Создаем объекты IP-адресов
ip1 = ip_address("245.192.192.53")
ip2 = ip_address("245.192.192.25")
# Цикл по диапазону от 0 до 32 (включительно), чтобы проверить все возможные маски подсети
for mask in range(33):
# Создаем объекты сетии, используя IP-адреса и текущую маску.
   network1 = ip_network(f"{ip1}/{mask}", 0)
   network2 = ip_network(f"{ip2}/{mask}", 0)
   # Проверяем, равны ли адреса сетей
   if network2.network_address == network1.network_address:
    # Если адрес сети совпадает, выводим количество адресов в этой сети
       print(network1.num_addresses)
# Ответом будет минимальное число в выводе

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

Запишем четвертый слева байт IP-адресов в двоичной системе счисления:

.

Нам необходимо, чтобы сеть, в которой находились данные IP-адреса была одинакова. Значит, четвертый байт будет выглядеть так: . Получаем количество адресов: .

Решение Python:

Чтобы найти наименьшее количество компьютеров в сети, в которой могут одновременно находиться узлы с адресами 240.70.200.155 и 240.70.200.152, нужно перебрать все возможные варианты масок от 0 до 32. Для каждой маски формируем сеть для обоих IP-адресов и проверяем, совпадает ли у них сетевой адрес. Если совпадает, значит оба узла действительно принадлежат одной подсети. При этом из общего количества адресов в такой сети нужно вычесть два зарезервированных — адрес сети и широковещательный адрес. Среди всех подходящих масок выбираем вариант с минимальным числом доступных компьютеров, что и будет искомым ответом.

from ipaddress import *
# Создаем объекты IP-адресов
ip1 = ip_address("240.70.200.155")
ip2 = ip_address("240.70.200.152")
# Цикл по диапазону от 0 до 32 (включительно), чтобы проверить все возможные маски подсети
for mask in range(33):
# Создаем объекты сетии, используя IP-адреса и текущую маску.
   network1 = ip_network(f"{ip1}/{mask}", 0)
   network2 = ip_network(f"{ip2}/{mask}", 0)
   # Проверяем, равны ли адреса сетей и не являются ли они широковещательными и адресами устройств.
   if network2.network_address == network1.network_address and ip1 != network1.broadcast_address and ip2 != network2.broadcast_address and ip1 != network1.network_address and ip2 != network2.network_address:
    # Если адрес сети совпадает, выводим количество адресов в этой сети (без учета двух)
       print(network1.num_addresses - 2)
# Ответом будет минимальное число в выводе

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

Запишем четвертый слева байт IP-адресов в двоичной системе счисления:

.

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

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

Рассмотрим таблицу, где IP-адрес сети и маска уже переведены в двоичную систему счисления:

Последние 4 бит, обозначенные через символ «x» мы можем изменять.

Первоначально получаем, что количество нулей равно 14. То есть на место символов «x» нужно поставить от 2 до 4 нулей, чтобы общее количество нулей было больше 15.

Два нуля на 4 места можно поставить способами.

Три нуля на 4 места можно поставить способами. Четыре нуля на 4 позиции можно поставить 1 способом.

Итого, всего IP-адресов, для которых количество нулей в двоичной записи IP-адреса больше 15 равно .

Решение Python:

Нужно определить количество IP-адресов в сети , для которых число нулей в двоичной записи адреса превышает .

Сначала создаём объект сети при помощи функции ‘ip_network()‘. Она автоматически определяет все IP-адреса, которые принадлежат указанной сети.

Далее организуем перебор всех адресов из сети. Для каждого адреса переводим его в целое число и затем в двоичную строку. После этого подсчитываем количество символов "0"в записи.

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

В конце выводим полученное значение.

from ipaddress import *  # Подключаем модуль для работы с IP-адресами и масками

# Создаём объект сети, указывая IP-адрес и маску
net = ip_network(’228.135.92.192/255.255.255.240’)

c = 0  # Счётчик подходящих IP-адресов

# Перебираем все IP-адреса в заданной сети
for i in net:
    # Для текущего адреса переводим его в число, затем в двоичную строку
    # Подсчитываем количество нулей и проверяем условие
    if bin(int(i))[2:].count(’0’) > 15:
        c += 1  # Если условие выполнено, увеличиваем счётчик

# Выводим итоговое количество адресов, удовлетворяющих условию
print(c)

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

Запишем IP-адреса в двоичной системе счисления:

IP-адреса начинают различаться начиная с 29 бита слева. Значит, количество адресов в сети равно: .

Решение Python:

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

Для этого будем перебирать все возможные маски сети от до . Для каждой маски формируем сети, которым принадлежат данные IP-адреса. Если для некоторой маски оба адреса попадают в одну и ту же сеть, то можно вычислить общее количество адресов в этой сети.

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

В конце выводится найденное количество адресов, которое и будет ответом задачи.

from ipaddress import *  # Импортируем модуль для работы с IP-адресами и сетями

# Создаём объекты IP-адресов для двух узлов
ip1 = ip_address(’24.110.109.185’)
ip2 = ip_address(’24.110.109.179’)

# Перебираем все возможные значения маски подсети от 0 до 32
for mask in range(33):
    # Формируем сеть для первого IP-адреса с текущей маской
    network1 = ip_network(f’{ip1}/{mask}’, 0)
    # Формируем сеть для второго IP-адреса с текущей маской
    network2 = ip_network(f’{ip2}/{mask}’, 0)

    # Проверяем, совпадают ли адреса сети для обоих узлов
    if network2.network_address == network1.network_address:
        # Если совпадают, выводим количество адресов в сети
        # Это кандидат на минимальное возможное количество
        print(network1.num_addresses)

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

Переводим IP-адрес и адрес сети в двоичную систему счисления, а также найдём маску сети:

Получаем, что в последнем байте маска имеет неоднозначную запись: .

Так как по условию задачи нам необходимо найти минимальное количество возможных адресов, то на место символа «x» ставим цифру 1. Получаем искомое количество адресов: .

Решение Python:

Необходимо определить минимальное количество возможных адресов в сети, если известен IP-адрес узла и соответствующий ему адрес сети .

Адрес сети всегда вычисляется с помощью маски подсети, применяемой к IP-адресу поразрядной конъюнкцией. Маска определяет, какая часть битов задаёт саму сеть, а какая — номер компьютера внутри неё.

Чтобы найти маску, при которой данный IP-адрес даёт в результате именно этот адрес сети, можно перебрать все возможные длины маски от до . Для каждой маски формируется сеть, проверяется её адрес, и если он совпадает с данным адресом сети, вычисляется общее количество адресов в такой сети.

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

from ipaddress import *  # Импортируем модуль для работы с IP-адресами и сетями

# Создаем объект IP-адреса узла
ip = ip_address(’149.127.136.165’)

# Создаем объект IP-адреса, который должен быть адресом сети
net = ip_address(’149.127.136.160’)

# Перебираем все возможные маски подсети от /0 до /32
for mask in range(33):
    # Формируем сеть для данного IP-адреса с текущей маской
    network = ip_network(f’{ip}/{mask}’, 0)

    # Проверяем, совпадает ли вычисленный адрес сети с данным адресом
    if net == network.network_address:
        # Если совпадает, выводим количество адресов в сети
        # Это кандидат на минимальное возможное значение
        print(network.num_addresses)

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

Запишем четвертый слева байт IP-адреса в двоичной системе счисления:

Аналогично запишем четвертый слева байт адреса сети, также в двоичной системе счисления:

Учитывая, что адрес сети получается в результате применения поразрядной конъюнкции к заданному IP-адресу узла и маске, запишем последний байт маски: . На месте «x» может стоять как 0, так и 1. Так как по условию требуется минимальное количество возможных адресов в этой сети, то на место «x» поставим 1. Получаем последний байт маски:

Так как в маске 5 нулей, то количество адресов в этой сети равно:

Решение Python:

Необходимо определить минимальное количество возможных адресов в сети, если известен IP-адрес узла и соответствующий ему адрес сети .

Адрес сети всегда вычисляется как результат поразрядной конъюнкции IP-адреса узла с маской подсети. Так как маска заранее неизвестна, то для поиска решения удобно перебрать все возможные маски длиной от до . Для каждой маски строится объект сети, вычисляется её адрес, и если он совпадает с данным адресом сети, то данная маска является подходящей.

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

from ipaddress import *  # Импортируем модуль для работы с IP-адресами и сетями

# Создаем объект IP-адреса узла
ip = ip_address(’135.120.117.213’)

# Создаем объект IP-адреса, который должен быть адресом сети
net = ip_address(’135.120.117.192’)

# Перебираем все возможные маски подсети от /0 до /32
for mask in range(33):
    # Формируем сеть на основе IP-адреса и текущей маски
    network = ip_network(f’{ip}/{mask}’, 0)

    # Проверяем, совпадает ли вычисленный адрес сети с данным
    if net == network.network_address:
        # Если совпадает, выводим количество адресов в этой сети
        # Среди всех таких значений выбирается минимальное
        print(network.num_addresses)

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

Запишем четвёртый байт IP-адреса и адреса сети в двоичной системе счисления:

Так как адрес адрес сети получается в результате применения поразрядной конъюнкции к заданному IP-адресу узла и маске, то маска имеет вид:

,

где вместо символа «x» может стоять как 0, так и 1. Однако заметим, что если поставить на место «x» 1, то получается, что узлу присвоен широковещательный адрес. Поэтому на место «x» можно поставить только 0. Таким образом, количество нулей в последнем байте маски равняется 4.

Следовательно, наименьшее количество возможных адресов в этой сети равняется .

 

Решение Python:

Необходимо определить минимальное количество возможных адресов в сети, если известен IP-адрес узла и соответствующий ему адрес сети .

Адрес сети всегда вычисляется как результат поразрядной конъюнкции IP-адреса узла с маской подсети. Так как маска заранее неизвестна, то для поиска решения удобно перебрать все возможные маски длиной от до . Для каждой маски строится объект сети, вычисляется её адрес, и если он совпадает с данным адресом сети, то данная маска является подходящей.

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

После этого среди всех подходящих масок выбирается та, которая задаёт сеть с минимальным количеством адресов. Это значение и будет являться ответом, при этом учитываются как адрес сети, так и широковещательный адрес.

from ipaddress import *
# Создаем объект IP-адреса из строки ’182.110.209.87’
ip = ip_address(’182.110.209.87’)
# Создаем объект IP-адреса, который будет использоваться как адрес сети, из строки ’182.110.209.80’
net = ip_address(’182.110.209.80’)
# Цикл по диапазону от 0 до 32 (включительно), чтобы проверить все возможные маски подсети
for mask in range(33):
# Создаем объект сети, используя IP-адрес и текущую маску.
   network = ip_network(f’{ip}/{mask}’, 0)
   # Проверяем, равен ли адрес сети текущей сети, заданной переменной ’net’ а также является ли адрес узла верным в этой сети (что он не является широковещательныи)
   if net == network.network_address and ip != network.broadcast_address:
    # Если адрес сети совпадает, выводим количество адресов в этой сети
       print(network.num_addresses)
# Наименьшее число и будет являться ответом

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

Запишем четвёртый байт IP-адреса и адреса сети в двоичной системе счисления:

Так как адрес адрес сети получается в результате применения поразрядной конъюнкции к заданному IP-адресу узла и маске, то маска имеет вид:

,

где вместо символа «x» может стоять как 0, так и 1. Так как по условию задачи требуется наибольшее количество адресов, то единиц должно быть по минимуму, значит, ставим вместо «x» нули. Таким образом, количество нулей в последнем байте маски равняется 5.

Следовательно, наибольшее количество возможных адресов в этой сети равняется .

Решение Python:

По условию задачи дан IP-адрес узла и соответствующий ему адрес сети . Маска сети определяется так, что при поразрядной конъюнкции IP-адреса и маски получается данный адрес сети. В данном случае это маска /27.

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

В языке Python для удобной работы с IP-адресами используется модуль ipaddress. Создаём объект сети с помощью функции ip_network(), указывая адрес сети и маску. После этого через свойство num_addresses получаем общее количество адресов в данной сети. Результат и будет ответом на задачу.

from ipaddress import *

# Определяем сеть с маской /27
network = ip_network(’108.212.62.224/27’)
# Получаем общее количество адресов в сети
total_addresses = network.num_addresses
# Печатаем результат
print(total_addresses)

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

1. Так как первые три числа маски равны 255, то в двоичном виде они записываются как 24 единицы, а значит, первые три числа определяют адрес сети.

2. Запишем число 240 в двоичном виде: .

   В этом числе стоят 4 нуля. Итого у нас есть 4 двоичных разряда для того, чтобы записать адрес компьютера.

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

Решение Python:

Для подсчёта количества адресов компьютеров в подсети используется маска сети. Маска определяет, какая часть IP-адреса относится к самой сети, а какая — к узлам в этой сети. В Python удобно работать с IP-адресами и масками через модуль ipaddress. Создаём объект сети с помощью функции ip_network(), указывая маску подсети. Метод num_addresses возвращает общее количество адресов в сети. Чтобы определить количество доступных адресов для компьютеров, из общего числа адресов исключаем два служебных адреса: адрес сети и широковещательный адрес.

from ipaddress import *

# Определяем адрес сети с маской 255.255.192.0
network = ip_network(’0.0.0.0/255.255.255.240’)
# Общее количество адресов в сети (без адреса сети и широковещательного)
total_hosts = network.num_addresses - 2
print(total_hosts)

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

1. Так как первые два числа маски равны 255, то в двоичном виде они записываются как 16 единиц, а значит, первые два числа определяют адрес сети.

2. Запишем число 192 в двоичном виде: .

   В этом числе стоят 6 нулей, еще 8 нулей мы получаем из последнего числа маски. Итого у нас есть 14 двоичных разрядов для того, чтобы записать адрес компьютера.

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

Решение Python:

Для определения количества адресов компьютеров в подсети необходимо учитывать маску сети, которая определяет, какие разряды IP-адреса являются общими для всей подсети. Адреса, относящиеся к хостам, вычисляются на основе оставшихся разрядов, не занятых маской. В Python для работы с IP-адресами и масками удобно использовать модуль ipaddress. Создаём объект сети с помощью функции ip_network(), указывая маску подсети. Метод num_addresses возвращает общее количество адресов в сети. Чтобы получить количество допустимых адресов для компьютеров, из общего числа вычитаются два служебных адреса: адрес сети и широковещательный адрес. В конце программа выводит число адресов, доступных для использования компьютерами.

from ipaddress import *

# Определяем адрес сети с маской 255.255.192.0
network = ip_network(’0.0.0.0/255.255.192.0’)
# Общее количество адресов в сети (без адреса сети и широковещательного)
total_hosts = network.num_addresses - 2
print(total_hosts)

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

Рассмотрим таблицу, где IP-адрес сети и маска уже переведены в двоичную систему счисления:

Последние 7 бит, обозначенные через символ «x» мы можем изменять.

Изначально количество нулей равно 12. То есть на место символов «x» нужно поставить от 1 до 7 нулей, чтобы общее количество нулей было больше 12.

Однако мы ищем в сети узлы, а значит, мы не можем поставить 7 нулей на свободное место. Найдем количество способов поставить 1, 2, 3, 4, 5 и 6 нулей:

Один нуль на 7 позиций можно поставить 7 способами.

Два нуля на 7 позиций можно поставить способам.

Три нуля на 7 позиций можно поставить способами.

Четыре нуля на 7 позиций можно поставить способами.

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

Шесть нулей на 7 позиций можно поставить способами.

Итого, всего IP-адресов, для которых количество нулей в двоичной записи IP-адреса больше 12 равно .

Решение программой:

Чтобы решить задачу, сначала определяем сеть с адресом 15.58.216.208 и маской 255.255.255.128, которая задаёт диапазон всех возможных IP-адресов внутри этой подсети. Далее последовательно перебираем все адреса в сети, исключая два зарезервированных — сетевой и широковещательный. Для каждого допустимого IP-адреса переводим его в двоичный вид длиной 32 бита и считаем количество нулей. Если нулей больше 12, увеличиваем счётчик. В конце выводим общее количество таких адресов, что и будет являться ответом.

from ipaddress import *
# Создаем объект сети
net = ip_network("15.58.216.208/255.255.255.128", strict = 0)
# Инициализируем счетчик
c = 0
# Перебираем адреса сети
for i in net:
# Если IP адрес НЕ широковещательный И НЕ сетевой
    if i != net.broadcast_address and i != net.network_address:
     # Если количество нулей в двоичной записи IP адреса больше 12
        if bin(int(i))[2:].zfill(32).count("0") > 12:
         # Увеличиваем счетчик
            c += 1
# Печатаем ответ
print(c)

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

Запишем IP-адреса в двоичной системе счисления:

IP-адреса различаются, начиная с 25 бита слева. Значит, минимальное количество адресов в сети равно: .

Решение программой

Чтобы найти минимальное количество адресов в сети, в которой находятся два узла с IP-адресами 210.178.98.142 и 210.178.98.123, перебираем все возможные маски от 0 до 32. Для каждой маски определяем адрес сети, к которой принадлежит первый IP-адрес, и адрес сети для второго IP-адреса. Если они совпадают, значит, оба узла находятся в одной подсети. При этом важно исключить ситуации, когда IP-адрес совпадает с адресом самой сети или с широковещательным адресом. Как только находим совпадающую сеть, фиксируем её размер (количество адресов). Минимальное возможное значение размера сети и будет искомым ответом.

from ipaddress import *
# Создаем объекты IP-адресов
ip1 = ip_address("210.178.98.142")
ip2 = ip_address("210.178.98.123")
# Цикл по диапазону от 0 до 32 (включительно), чтобы проверить все возможные маски подсети
for mask in range(33):
# Создаем объекты сети, используя IP-адреса и текущую маску.
   network1 = ip_network(f"{ip1}/{mask}", 0)
   network2 = ip_network(f"{ip2}/{mask}", 0)
   # Проверка что адреса не широковещательные и не являются адресами сети
   if ip1 != network1.network_address and ip1 != network1.broadcast_address and \
   ip2 != network2.network_address and ip2 != network2.broadcast_address:
       # Проверяем, находятся ли адреса в одной сети
       if network2.network_address == network1.network_address:
        # Если адрес сети совпадает, выводим количество адресов в этой сети
           print(network1.num_addresses)
# Ответом будет минимальное число в выводе

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

Переводем IP-адрес и адрес сети в двочную систему счисления, а также найдём маску сети:

Получаем, что в третьем байте маска имеет неоднозначную запись: .

Так как по условию задачи нам необходимо найти минимальное и максимальное количество возможных адресов, то сначала на место символа «x» ставим цифру 1. Получаем искомое минимальное количество адресов: .

А затем на место символа «x» ставим цифру 0. Получаем искомое максимальное количество адресов: .

Решение программой

Чтобы определить наибольшее и наименьшее количество возможных адресов в сети, в которой IP-адрес узла равен 10.43.180.188, а адрес сети равен 10.43.180.0, перебираем все возможные маски подсетей от 0 до 32. Для каждой маски формируем сеть и проверяем, совпадает ли её адрес сети с данным адресом 10.43.180.0. Если совпадает, фиксируем количество адресов в такой сети. В результате получаем несколько вариантов числа адресов, и среди них выбираем максимальное и минимальное. Эти два значения и являются искомым ответом.

from ipaddress import *
# Создаем объект IP-адреса
ip = ip_address("10.43.180.188")
# Создаем объект IP-адреса, который будет использоваться как адрес сети
net = ip_address("10.43.180.0")
# Цикл по диапазону от 0 до 32 (включительно), чтобы проверить все возможные маски подсети
for mask in range(33):
# Создаем объект сети, используя IP-адрес и текущую маску.
   network = ip_network(f"{ip}/{mask}", 0)
   # Проверяем, равен ли адрес сети текущей сети, заданной переменной "net"
   if net == network.network_address:
    # Если адрес сети совпадает, выводим количество адресов в этой сети
       print(network.num_addresses)
# Наибольшее и наименьшее числа будут являться ответом

Переведём IP-адрес и маску в двоичную систему счисления.

Получаем, что IP-адреса в сети имеют вид:

где на месте «x» может стоять либо 0, либо 1.

Если последние 4 бита равны 0, то подходящих IP-адресов:

Аналогично, если последние 4 бита равны 1, то подходящих IP-адресов:

Получаем общее число IP-адресов:

Решение программой:

Для решения задачи необходимо перебрать все IP-адреса в сети, заданной IP-адресом узла 113.116.181.173 и маской 255.255.255.128. Сначала формируем объект сети с помощью функции «ip_network()», которая автоматически определяет все возможные адреса в данной подсети. Далее последовательно проходим по каждому адресу и переводим его в двоичный вид с дополнением до 32 бит. После этого проверяем, совпадают ли последние четыре бита (т.е. являются ли они одинаковыми). Если условие выполняется, увеличиваем счетчик. В конце работы программы в переменной счетчика будет храниться количество IP-адресов в сети, которые оканчиваются на четыре одинаковых бита.

from ipaddress import *

# Создаем объект сети, используя IP-адрес и маску подсети
net = ip_network(f"113.116.181.173/255.255.255.128", 0)

count = 0  # Инициализируем счетчик для подсчета IP-адресов, удовлетворяющих условию.

# Проходим по всем IP-адресам в заданной сети.
for ip in net:
    # Преобразуем текущий IP-адрес в целое число, затем в двоичную строку.
    # Удаляем префикс "0b" и заполняем строку нулями слева до 32 бит.
    b = bin(int(ip))[2:].zfill(32)
    # Проверяем, равны ли последние четыре бита (последние 4 разряда двоичного представления).
    if b[-1] == b[-2] == b[-3] == b[-4]:
        count += 1  # Если условие выполнено, увеличиваем счетчик на 1.
# Выводим общее количество IP-адресов, которые удовлетворяют условию.
print(count)

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

Переведём IP-адрес и маску в двоичную систему счисления.

Получаем, что IP-адреса в сети имеют вид:

где на месте «x» может стоять либо 0, либо 1.

Но последние 4 бита должны быть равны 1010, поэтому IP-адреса в сети имеют вид:

В таком виде в адерсе сети уже есть 11 единиц, так как количество единиц должно быть кратно трем, то нужно добавить 1, 4, 7 либо 10 единиц.

1) Одну единицу на 10 мест можно поставить 10-ю способами;

2) Четыре единицы на 10 мест можно поставить

3) Семь единиц на 10 мест можно поставить

4) Десять единиц на 10 мест можно поставить одним способом.

Общее число IP-адресов:

Решение программой:

Для решения задачи нужно перебрать все IP-адреса в сети, заданной IP-адресом узла 142.206.189.107 и маской 255.255.192.0. Сначала создаём объект сети с помощью функции «ip_network()», которая определяет диапазон возможных адресов. Затем последовательно преобразуем каждый IP-адрес в двоичную строку длиной 32 бита и проверяем выполнение двух условий: количество единиц в записи адреса должно быть кратно 3, а последние четыре бита должны образовывать последовательность «1010». Если оба условия выполняются, увеличиваем счётчик. В конце работы программы в счётчике получаем количество IP-адресов, удовлетворяющих данным критериям.

from ipaddress import *

# Создаем объект сети, используя IP-адрес и маску подсети
net = ip_network(f"142.206.189.107/255.255.192.0", 0)

count = 0  # Инициализируем счетчик для подсчета IP-адресов, удовлетворяющих условиям.

# Проходим по всем IP-адресам в заданной сети.
for ip in net:
    # Преобразуем текущий IP-адрес в целое число, затем в двоичную строку.
    # Удаляем префикс "0b" и заполняем строку нулями слева до 32 бит.
    b = bin(int(ip))[2:].zfill(32)

    # Проверяем два условия:
    # 1. Количество единиц ("1") в двоичном представлении должно быть кратно 3.
    # 2. Последние четыре бита двоичного представления должны быть равны ’1010’.
    if b.count("1") % 3 == 0 and b[-4:] == "1010":
        count += 1  # Если оба условия выполнены, увеличиваем счетчик на 1.

# Выводим общее количество IP-адресов, которые удовлетворяют заданным условиям.
print(count)

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

Рассмотрим таблицу, где IP-адрес сети и маска уже переведены в двоичную систему счисления:

Последние 2 бита, обозначенные через символ «x» мы можем изменять.

Первоначально получаем, что количество единиц равно 14. То есть на место символов «x» нужно поставить либо 1 единицу, либо 2 единицы.

Однако мы ищем в сети узлы, а значит, мы не можем поставить 2 единицы на свободное место, иначе будет получен широковещательный IP-адрес.

Одну единицу на 2 позиции можно поставить 2 способами.

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

Решение программой:

Чтобы решить задачу, сначала определяем сеть с адресом 44.249.80.224 и маской 255.255.255.252, которая задаёт диапазон всех возможных IP-адресов внутри этой подсети. Далее последовательно перебираем все адреса в сети, исключая два зарезервированных — сетевой и широковещательный. Для каждого допустимого IP-адреса переводим его в двоичный вид длиной 32 бита и считаем количество нулей. Если единиц больше 14, увеличиваем счётчик. В конце выводим общее количество таких адресов, что и будет являться ответом.

from ipaddress import *
# Создаем объект сети
net = ip_network("44.249.80.224/255.255.255.252")
# Инициализируем счетчик
c = 0
# Перебираем IP адреса сети
for i in net:
# Если адрес НЕ широковещательный и НЕ сетевой
    if i != net.broadcast_address and i != net.network_address:
     # Если количество единиц в двоичной записи IP адреса больше 14
        if bin(int(i))[2:].zfill(32).count("1") > 14:
         # Увеличиваем счетчик
            c += 1
# Печатаем ответ
print(c)

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

Запишем IP-адреса в двоичной системе счисления:

IP-адреса начинают различаться начиная с 19 бита слева. Значит, в маске должно быть минимум 14 нулей, чтобы узлы были в одной сети. Поэтому минимальное количество адресов в сети равно: .

Решение программой

Для решения задачи необходимо определить наименьшую подсеть, в которой оба заданных IP-адреса находятся в одной сети. Это можно сделать, проверяя по очереди все возможные маски подсети от 0 до 32 и создавая объект сети для каждого IP-адреса с текущей маской. После этого нужно убедиться, что оба адреса находятся внутри сети и не являются адресом сети или широковещательным адресом. Если адреса принадлежат одной сети, количество узлов в этой подсети вычисляется с помощью свойства «num_addresses» объекта сети, за вычетом двух зарезервированных адресов: адреса сети и широковещательного адреса. Минимальное такое число и будет ответом.

from ipaddress import *

# Создаем объекты IP-адресов
ip1 = ip_address("113.141.112.42")
ip2 = ip_address("113.141.95.21")
# Цикл по диапазону от 0 до 32 (включительно), чтобы проверить все возможные маски подсети
for mask in range(33):
    # Создаем объекты сети, используя IP-адреса и текущую маску.
    network1 = ip_network(f"{ip1}/{mask}", 0)
    network2 = ip_network(f"{ip2}/{mask}", 0)
    # Проверка что адреса не широковещательные и не являются адресами сети
    if ip1 != network1.network_address and ip1 != network1.broadcast_address and ip2 != network2.network_address and ip2 != network2.broadcast_address:
        # Проверяем, находятся ли адреса в одной сети
        if network2.network_address == network1.network_address:
            # Если адрес сети совпадает, выводим количество адресов в этой сети (без учета широковещательного и адреса сети)
            print(network1.num_addresses - 2)
# Ответом будет минимальное число в выводе

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

Адрес сети определяется путем применения поразрядной конъюнкции к заданному IP-адресу узла и маске.

Переведем IP-адрес и маску в двоичную систему счисления:

Получаем, что IP-адреса в сети имеют вид:

где на месте «x» может стоять либо 0, либо 1.

Сейчас в общем виде IP-адреса находится 14 единиц и 4 нуля. Разница между ними равна 10, а должна быть минимум 21.

Ставить на все места нули не имеет смысла, так как таким образом разница не будет более 20.

Рассмотрим комбинации с единицами.

Нужно, чтобы выполнялось неравенство , где – количество единиц на месте всех «x» (тогда количество нулей соответственно равно ). В итоге решения неравенства получим .

Значит, нужно ставить 13 либо 14 единиц.

1) 13 единиц на 14 позиций можно поставить 14 способами.

2) 14 единиц на 14 позиций можно поставить 1 способом.

Общее число способов равно:

Решение программой:

Для решения задачи нужно перебрать все IP-адреса в заданной сети и для каждого адреса проанализировать его двоичное представление. Сначала преобразуем каждый IP-адрес в целое число, затем переведём его в двоичную строку длиной 32 бита. Далее считаем количество единиц и нулей, сравниваем их и проверяем условие, что разница превышает 20. Если условие выполняется, увеличиваем счётчик. В итоге получаем количество IP-адресов в сети, подходящих под условие, и выводим результат.

from ipaddress import *
# Создаем объект сети
net = ip_network("252.221.194.118/255.255.192.0", 0)
# Инициализируем счетчик
count = 0
# Перебираем IP адреса сети
for ip in net:
# Переводим IP адрес в двоичный формат, заполняя нулями дя 32 бит
    b = bin(int(ip))[2:].zfill(32)
    # Если разница между количеством нулей и единиц более 20
    if abs(b.count("1") - b.count("0")) > 20:
     # Увеличиваем счетчик
        count += 1
# Печатаем ответ
print(count)

Решение Python:

Для подсчета количества IP-адресов в сети, у которых сумма единиц в двоичной записи чётна, используем модуль ipaddress. Сначала создаем объект сети с помощью ip_network(), передавая IP-адрес узла и маску сети. Этот объект позволяет перебирать все IP-адреса в заданной сети. Затем при помощи цикла for перебираем каждый адрес сети. Для каждого адреса преобразуем его в целое число через int(), затем в двоичную строку через bin(). Подсчитываем количество единиц с помощью метода count("1") и проверяем, является ли это количество чётным с помощью остатка от деления на 2. Если условие выполнено, увеличиваем счетчик. После перебора всех адресов в сети значение счетчика будет равно количеству IP-адресов с чётной суммой единиц.

from ipaddress import * # Импортируем модуль для работы с IP-адресами

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

# Создаем объект сети с заданным IP-адресом и маской подсети
net = ip_network("192.168.32.160/255.255.255.240")

# Перебираем все IP-адреса в сети
for i in net:
    # Преобразуем IP-адрес в целое число, затем в двоичную строку
    # Считаем количество единиц в двоичной записи
    # Если количество единиц четное, учитываем этот адрес
    if bin(int(i))[2:].count("1") % 2 == 0:
        # Увеличиваем счетчик
        count += 1

# Выводим количество адресов с чётной суммой единиц
print(count)

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

Рассмотрим таблицу, где IP-адрес сети и маска уже переведены в двоичную систему счисления:

Последние 4 бита, обозначенные через символ «x» мы можем изменять.

Первоначально получаем, что количество единиц равно 12, то есть их сумма четна. Для того, чтобы сделать сумму четной, необходимо, чтобы в последних 4 битах было 0 единиц, 2 единицы, либо 4 единицы.

0 единиц мы можем поставить 1 способом.

2 единицы можно поставить способами.

4 единицы расставить на 4 позиций можно 1 способом.

Получаем, что в этой сети IP-адресов, для которых сумма единиц в двоичной записи IP-адреса четна.