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

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

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

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

3. Запишем последний октет IP-адреса компьютера в сети:

4. Сопоставим последний октет маски и адреса компьютера в сети:

10000000

00010001

Жирным выделена часть, отвечающая за адрес сети, следовательно остальные биты могут меняться, чтобы образовать различные IP-адреса компьютеров в этой сети. Всего таких адресов: .

Решение Python:

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

from ipaddress import ip_network

# Задаем сеть с указанным IP-адресом и маской
network = ip_network("10.18.134.0/255.255.255.128")

# Находим общее количество адресов в сети с вычетом двух (адрес сети и широковещательный)
total_addresses = network.num_addresses - 2

print(total_addresses)

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

Вспомним, что маска подсети условно делится на сетевую часть и на хостовую. Хостовая часть, это та, где стоят нули. Для того чтобы определить количество хостов, достаточно перевести маску в двоичную систему счисления и посчитать количество нулей. Количество нулей — это количество бит в которые можно закодировать адреса хостов.

Маска в двоичной системе счисления будет выглядеть следующим образом:

В ней 7 нулей, тогда всего хостов в сети может быть . Мы вычли 2, так как два адреса (адрес сети и широковещательный) не используют.

Решение Python:

Для определения количества возможных адресов компьютеров в сети нужно рассчитать общее число IP-адресов в подсети, которое зависит от маски. Маска 255.255.255.128 содержит 25 единичных бит, следовательно, на адреса узлов остаётся 7 бит. Это значит, что всего в сети может быть = 128 адресов. Получаем количество адресов в сети с помощью метода num_addresses. Из них два адреса - сетевой и широковещательный - использовать нельзя. Поэтому число доступных адресов для компьютеров в сети будет равно 128 - 2 = 126.

from ipaddress import ip_network

# Задаем сеть с указанным IP-адресом и маской
network = ip_network("88.147.254.128/255.255.255.128")

# Находим общее количество адресов в сети с вычетом двух (адрес сети и широковещательный)
total_addresses = network.num_addresses - 2

print(total_addresses)

Решение Python:

Для решения задачи необходимо определить минимальное количество адресов в сети, для которой IP-адрес узла равен 200.14.152.118, а адрес сети - 200.14.152.112. Для этого перебираются возможные маски подсети от 0 до 32 и для каждой проверяется, совпадает ли вычисленный адрес сети с данным (200.14.152.112). Когда совпадение найдено, количество адресов в сети вычисляется с помощью метода num_addresses, который учитывает и адрес сети, и широковещательный адрес. Минимальное значение среди найденных результатов и будет искомым наименьшим количеством возможных адресов в данной сети.

from ipaddress import *
# Создаем объект IP-адреса из строки "200.14.152.118"
ip = ip_address("200.14.152.118")
# Создаем объект IP-адреса, который будет использоваться как адрес сети, из строки ’200.14.152.112’
net = ip_address("200.14.152.112")
# Цикл по диапазону от 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-адреса и адреса сети в двоичной системе счисления:

Заметим, что 5 первых слева бита адреса сети совпадают с IP-адресом, а затем идут нули. То есть после поразрядной конъюнкции IP-адреса и маски последние 3 бита обнулились, значит, в маске на этих местах стояли нули: . Количество нулей в последнем байте маски равняется 3.

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

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

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

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

Решение Python:

Для нахождения наибольшего количества возможных адресов в сети необходимо определить маску подсети, которая соответствует данному адресу сети. Адрес сети получается из IP-адреса и маски, поэтому, зная IP-адрес узла и соответствующий адрес сети, можно установить, что маска равна 255.255.255.192. Далее сеть описывается функцией ip_network, которая позволяет легко вычислить количество адресов в ней. Для этого используется метод num_addresses, учитывающий все возможные IP-адреса в сети, включая сам адрес сети и широковещательный адрес. Полученное значение и будет наибольшим количеством адресов в данной сети.

from ipaddress import ip_network

# Задаем сеть с указанным адресом сети и определяем маску
network = ip_network("108.212.62.64/255.255.255.192")

# Находим общее количество адресов в сети (с учетом адреса сети и широковещательного)
total_addresses = network.num_addresses

print(total_addresses)

Решение Python:

Чтобы определить количество допустимых адресов компьютеров в подсети, необходимо воспользоваться свойством маски подсети: она задаёт, какая часть IP-адреса отводится под номера узлов. Маска 255.255.255.240 в двоичной записи содержит 28 единиц и 4 нуля, значит, под адреса компьютеров остаётся = 16 возможных комбинаций. Однако из них два адреса (адрес сети и широковещательный адрес) не могут быть назначены компьютерам, поэтому фактическое количество допустимых адресов равно 16 - 2 = 14.

import ipaddress

# Используем адрес 0.0.0.0 с маской 255.255.255.240
network = ipaddress.ip_network("0.0.0.0/255.255.255.240", strict=False)
# Выводим количество адресов
print(network.num_addresses - 2)

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

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

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

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

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

Решение Python:

Для определения количества допустимых адресов компьютеров в подсети нужно проанализировать маску 255.255.224.0. В двоичной записи она содержит 19 единиц и 13 нулей, то есть под адреса узлов остаётся 13 разрядов. Это означает, что всего в сети может быть = 8192 различных адреса. Так как два из них (адрес сети и широковещательный адрес) использовать нельзя, количество доступных для компьютеров адресов будет равно 8192 - 2 = 8190.

import ipaddress

# Используем адрес 0.0.0.0 с маской 255.255.255.240
network = ipaddress.ip_network("0.0.0.0/255.255.224.0", strict=False)
# Выводим количество адресов
print(network.num_addresses - 2)

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

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

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

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

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

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

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

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

Учитывая, что адрес сети получается в результате применения поразрядной конъюнкции к заданному IP-адресу узла и маске, запишем два последних байт маски: .

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

Решение Python:

Для определения количества возможных адресов в сети необходимо установить маску подсети, которая соответствует данному адресу сети. В условии указано, что адрес сети для IP-адреса 142.111.21.158 равен 142.111.21.144, следовательно, маска подсети имеет вид 255.255.255.240. Эта маска в двоичном виде содержит 28 единиц и 4 нуля, значит, под адреса узлов остаётся 4 бита. Общее число возможных адресов в такой сети вычисляется как = 16, и это количество включает как адрес сети, так и широковещательный адрес. Получаем количество адресов в сети с помощью метода num_addresses. Таким образом, общее число возможных адресов в сети равно 16.

from ipaddress import *

# Задаем сеть с указанной маской
network = ip_network("142.111.21.144/255.255.255.240")

# Общее количество адресов в сети
total_addresses = network.num_addresses

print(total_addresses)

Решение Python:

Для того чтобы найти наибольшее количество возможных адресов в сети, необходимо определить все маски подсети, при которых для IP-адреса 127.98.13.202 вычисленный адрес сети совпадает с данным адресом сети 127.98.13.192. Для этого перебираются все возможные значения длины маски от 0 до 32 и для каждой проверяется, совпадает ли результат применения маски с указанным адресом сети. Когда совпадение найдено, определяется количество адресов в данной сети с помощью метода num_addresses, который возвращает общее число IP-адресов, включая адрес сети и широковещательный. Так как требуется наибольшее количество адресов, из найденных вариантов выбирается максимальное значение.

from ipaddress import *
# Создаем объект IP-адреса из строки "127.98.13.202"
ip = ip_address("127.98.13.202")
# Создаем объект IP-адреса, который будет использоваться как адрес сети, из строки "127.98.13.192"
net = ip_address("127.98.13.192")
# Цикл по диапазону от 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» те места, где маска может иметь неоднозначное значение:

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

Решение Python:

Для того чтобы найти наименьшее количество адресов в сети, в которой находятся два узла с IP-адресами 151.111.55.71 и 151.111.55.99, необходимо определить минимально возможную маску подсети, при которой оба адреса будут принадлежать одной и той же сети. Для этого перебираются все значения маски от 0 до 32, и для каждого значения вычисляются адреса сетей, соответствующие обоим IP-адресам. Как только найдено совпадение адресов сети, определяется общее количество адресов в этой сети с помощью метода num_addresses. Так как нужно наименьшее возможное количество адресов, выбирается минимальное значение среди найденных, что и будет ответом.

from ipaddress import *
# Создаем объекты IP-адресов
ip1 = ip_address("151.111.55.71")
ip2 = ip_address("151.111.55.99")
# Цикл по диапазону от 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-адреса начинают различаться начиная с 27 бита слева. Значит, количество адресов в сети равно:

Решение Python:

Для решения задачи необходимо сначала определить все IP-адреса в заданной сети 164.148.22.144/255.255.255.240. Маска 255.255.255.240 задаёт сеть из 16 адресов, включая адрес сети и широковещательный. Далее каждый IP-адрес переводится в двоичное представление, после чего подсчитывается количество нулей в его записи. Если число нулей превышает 18, то такой адрес учитывается в счетчике. В результате перебора всех адресов в сети программа возвращает количество IP-адресов, удовлетворяющих условию.

from ipaddress import *
# Инициализируем счетчик
count = 0
# Создаем объект ip_network
net = ip_network("164.148.22.144/255.255.255.240")
# Перебираем ip адреса сети
for i in net:
# Если в двоичном представлении ip адреса больше 18 нулей
    if bin(int(i))[2:].count("0") > 18:
     # Увеличиваем счетчик
        count += 1
# Печатаем ответ
print(count)

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

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

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

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

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

Решение Python:

Для решения задачи нужно рассмотреть все IP-адреса, входящие в сеть 134.127.52.160 с маской 255.255.255.224. Такая маска в двоичной записи содержит 27 единиц и 5 нулей, значит, в сети всего = 32 IP-адреса (включая адрес сети и широковещательный). Далее каждый адрес переводится в двоичное представление, и для него подсчитывается количество единиц. Если сумма единиц в записи IP-адреса является чётной, то этот адрес учитывается в счетчике. В итоге программа перебирает все адреса сети и выводит количество тех, для которых выполняется условие чётности суммы единиц.

from ipaddress import *
# Инициализируем счетчик
count = 0
# Создаем объект ip_network
net = ip_network("134.127.52.160/255.255.255.224")
# Перебираем ip адреса сети
for i in net:
# Если в двоичном представлении ip адреса количество единиц четно
    if bin(int(i))[2:].count("1") % 2 == 0:
     # Увеличиваем счетчик
        count += 1
# Печатаем ответ
print(count)

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

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

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

Первоначально получаем, что количество единиц равно 13, то есть их сумма нечётна. Для того, чтобы сделать сумму четной, необходимо, чтобы в последних 5 битах была 1 единица, 3 единицы, либо 5 единицы.

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

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

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

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

Решение Python:

Для решения задачи необходимо определить все возможные маски подсети, при которых IP-адрес 230.5.60.68 принадлежит сети с адресом 230.5.60.64. Для этого перебираются все варианты длины маски от 0 до 32 и для каждой вычисляется адрес сети. Когда адрес сети совпадает с данным (230.5.60.64), определяется общее количество адресов в этой сети с помощью метода num_addresses. Так как реальные устройства можно назначать только на адреса узлов, из общего количества нужно вычесть два зарезервированных адреса — адрес сети и широковещательный. Среди найденных вариантов выбирается максимальное количество таких допустимых адресов, что и будет искомым числом физических устройств в сети.

from ipaddress import *
# Создаем объект IP-адреса из строки "230.5.60.68"
ip = ip_address("230.5.60.68")
# Создаем объект IP-адреса, который будет использоваться как адрес сети, из строки "230.5.60.64"
net = ip_address("230.5.60.64")
# Цикл по диапазону от 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 - 2)
# Ответом будет максимальное число в выводе

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

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

Тогда, последний байт маски сети равен:

где на месте может стоять как 0, так и 1. Так как нам нужно найти максимальное количество устройств, то поставим на место 0. Получаем, что в маске 6 нулей и количество физических устройств равно:

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

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

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

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

Одну единицу мы можем поставить тремя способами, три единицы – одним способом.

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

Решение Python:

Для решения задачи необходимо рассмотреть все IP-адреса, входящие в сеть 156.27.8.160 с маской 255.255.255.248. Данная маска в двоичной записи содержит 29 единиц и 3 нуля, то есть в сети всего = 8 IP-адресов (включая адрес сети и широковещательный). Каждый из этих адресов переводится в двоичное представление, после чего подсчитывается количество единиц. Если их сумма является чётной, увеличиваем счетчик на единицу. В итоге программа перебирает все IP-адреса сети и подсчитывает, для скольких из них сумма единиц в двоичной записи четная.

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

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

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

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

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

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

Решение Python:

Для решения задачи необходимо перебрать все IP-адреса, входящие в сеть 164.128.132.192 с маской 255.255.255.224. Данная маска в двоичном виде содержит 27 единиц и 5 нулей, то есть в сети всего = 32 IP-адреса (включая адрес сети и широковещательный). Каждый IP-адрес преобразуется в двоичное представление, и в нём подсчитывается количество нулей. Если число нулей строго больше 22, то такой адрес засчитывается в итоговый результат. Таким образом, программа перебирает все возможные адреса в сети и подсчитывает количество тех, которые удовлетворяют условию.

from ipaddress import *
# Создаем объект ip_network
net = ip_network("164.128.132.192/255.255.255.224")
# Инициализируем счетчик
c = 0
# Перебираем ip адреса сети
for i in net:
# Если количество нулей в двоичном представлении ip адреса больше 22
    if bin(int(i))[2:].count("0") > 22:
     # Увеличиваем счетчик
        c += 1
# Печатаем ответ
print(c)

Решение Python:

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

from ipaddress import *
# Создаем объекты IP-адресов
ip1 = ip_address("202.222.47.159")
ip2 = ip_address("202.222.47.141")
# Цикл по диапазону от 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.network_address and \
   ip2 != network2.network_address and ip1 != network1.broadcast_address and ip2 != network2.broadcast_address:
    # Если адрес сети совпадает, выводим количество адресов в этой сети
       print(network1.num_addresses)
# Ответом будет минимальное число в выводе

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

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

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

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

Решение Python:

Для определения наибольшего количества возможных адресов в сети, где узлу с IP-адресом 100.28.155.148 соответствует адрес сети 100.28.155.128, необходимо перебрать все возможные маски подсети от 0 до 32 и для каждой проверить, совпадает ли вычисленный адрес сети с заданным. Когда найдено совпадение, с помощью метода num_addresses определяется общее количество адресов в такой сети (включая адрес сети и широковещательный адрес). Так как требуется наибольшее количество адресов, из всех подходящих вариантов выбирается максимальное значение, которое и будет являться ответом.

from ipaddress import *
# Создаем объект IP-адреса из строки "100.28.155.148"
ip = ip_address("100.28.155.148")
# Создаем объект IP-адреса, который будет использоваться как адрес сети, из строки "100.28.155.128"
net = ip_address("100.28.155.128")
# Цикл по диапазону от 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» те места, где маска может иметь неоднозначное значение: .

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

Решение Python:

Для определения количества возможных адресов в сети, где узлу с IP-адресом 231.25.4.185 соответствует адрес сети 231.25.4.176, необходимо перебрать все возможные маски подсети от 0 до 32 и для каждой вычислить адрес сети. Когда найдено совпадение с заданным адресом, можно с помощью метода num_addresses определить общее количество адресов в сети, включая адрес сети и широковещательный адрес. Полученное значение и будет количеством возможных адресов в данной сети.

from ipaddress import *
# Создаем объект IP-адреса из строки "231.25.4.185"
ip = ip_address("231.25.4.185")
# Создаем объект IP-адреса, который будет использоваться как адрес сети, из строки "231.25.4.176"
net = ip_address("231.25.4.176")
# Цикл по диапазону от 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-адресу узла и маске, запишем последний байт маски:

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

Решение Python:

Чтобы решить задачу, нужно перебрать все IP-адреса внутри сети, заданной адресом 179.181.51.48 и маской 255.255.255.240, и проверить их двоичную запись. Для этого каждый адрес преобразуется в 32-битную двоичную строку и делится на байты по 8 бит. Далее в каждом байте проверяется, содержится ли последовательность 111. Если хотя бы в одном байте встречается такая последовательность, адрес не учитывается. Если же ни в одном байте 111 нет, то этот адрес подходит, и счетчик увеличивается на 1. В конце количество подходящих адресов и будет ответом.

from ipaddress import *
# Создаем объект сети
net = ip_network("179.181.51.48/255.255.255.240")
# Инициализируем счетчик
count = 0
# Проходим по всем IP-адресам в сети
for ip in net:
    # Преобразуем IP-адрес в двоичную строку
    binary_ip = bin(int(ip))[2:].zfill(32)  # Добавляем ведущие нули для получения 32 бит
    # Разбиваем на байты (8 бит)
    bytes_ip = [binary_ip[i:i+8] for i in range(0, 32, 8)]
    # Проверяем каждый байт на наличие "111"
    if all("111" not in i for i in bytes_ip):
        count += 1  # Увеличиваем счетчик, если ни один байт не содержит "111"
# Печатаем ответ
print(count)

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

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

Остается комбинация «xxx». Всего вариантов расставить 0 и 1 на три места – , но нам не подходит вариант 111. Поэтому, количество IP-адресов, в которых в двоичной записи IP-адреса не встречается 111, равно .

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

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

На месте символов «xxxx» могут стоять как 1, так и 0. Так как на этой стадии в адресе сети уже есть 15 единиц, то есть количество не кратно 2, то нам нужно добавить либо 1, либо 3 едицины.

Количество способов поставить 1 единицу на 4 места – 4. Количество способов поставить 3 единицы на 4 позиции: . Общее количество IP-адресов: .

Решение Python:

Чтобы решить задачу, нужно перебрать все IP-адреса внутри сети, заданной адресом 58.27.142.224 и маской 255.255.255.240. Каждый адрес переводим в двоичную запись и считаем количество единиц. Если это количество делится на 2 без остатка, то адрес удовлетворяет условию, и мы увеличиваем счетчик. В конце полученное значение счетчика и будет числом искомых IP-адресов в сети.

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

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

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

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

Первоначально получаем, что количество единиц равно 11, то есть их сумма нечетна. Для того, чтобы сделать сумму четной, необходимо, чтобы в последних 5 битах была 1 либо 3 единицы.

Одну единицу мы можем поставить тремя способами, три единицы – одним способом.

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

Решение Python:

Чтобы решить задачу, нужно перебрать все IP-адреса в сети, заданной адресом 156.27.8.160 и маской 255.255.255.248. Каждый адрес переводим в двоичную запись и считаем количество единиц. Если сумма этих единиц является четной, то такой адрес учитывается и увеличивает счетчик. В конце значение счетчика и будет количеством подходящих IP-адресов в данной сети.

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