def per(num, base):
    res = ""
    while num > 0:
        res += str(num % base)
        num //= base
    return res[::-1]


ans = []
for n in range(1, 1000):
    bn = per(n, 2)
    bn = bn + str(bn.count("1") % 2)
    bn = bn + str(bn.count("1") % 2)
    r = int(bn, 2)
    if r > 253:
        ans.append(n)
print(min(ans))

64

def per(num, base):
    res = ""
    while num > 0:
        res += str(num % base)
        num //= base
    return res[::-1]


ans = []
for n in range(1, 1000):
    bn = per(n, 2)
    if n % 2 == 0:
        bn = "11" + bn + "11"
    else:
        bn = "11" + bn + "00"
    r = int(bn, 2)
    if r > 105:
        ans.append(r)
print(min(ans))

115

def notNear(slovo, subalf):
    for ltr in subalf:
        if ltr + '2' in slovo or '2' + ltr in slovo:
            return False
    return True
    


alf = '012345678'
k = 0
for q in '12345678':
    for w in alf:
        for e in alf:
            for r in alf:
                for t in alf:
                    slovo = q + w + e + r + t
                    if slovo.count('3') == 2 and notNear(slovo, '1357'):
                        k += 1
print(k)

3352

def notNear(slovo, subalf):
    for ltr in subalf:
        if ltr + '2' in slovo or '2' + ltr in slovo:
            return False
    return True
    


alf = sorted('акцент')
nomer = 0
ans = []
for q in alf:
    for w in alf:
        for e in alf:
            for r in alf:
                for t in alf:
                    nomer += 1
                    slovo = q + w + e + r + t
                    if q not in 'аек' and slovo.count('т') >= 1:
                        ans.append(nomer)
print(ans[0])

3893

from ipaddress import ip_network

ans = []
for ip in ip_network("102.162.200.51/255.255.255.0", strict=False):
    ans.append(ip)
print(ans[-2])

102.162.200.254

from ipaddress import ip_network

ans = []
for ip in ip_network("210.185.140.126/255.255.255.252", strict=False):
    ans.append(ip)
print(ans[0])

210.185.140.124

from ipaddress import ip_network

ans = []
for ip in ip_network("188.163.128.179/255.255.240.0", strict=False):
    ans.append(ip)
print(ans[1])

188.163.128.1

for x in "0123456789abcdefghijkl":
    res = int(f'63{x}89875', 22) + int(f'17{x}51', 22) + int(f'75{x}3', 22)
    if res % 21 == 0:
        print(res // 21)

729719487
731437533
733155579

num = 4*16**25 + 2*8**30 - 64**10
base = 2
k = 0
while num > 0:
    ost = num % base
    if ost == 0:
        k += 1
    num //= base
print(k)

71

num = 5*7776**2013 + 4*1296**2015 - 3*216**2017 + 2*36**2017 - 6**2019 + 2021
base = 36
sm = 0
while num > 0:
    ost = num % base
    if ost > 9:
        sm += ost
    num //= base
print(sm)

70483

def k0(num, base):
    k = 0
    while num > 0:
        if num % base == 0:
            k += 1
        num //= base
    return k


max0 = 0
minx = 0
for x in range(1, 2031):
    num = 5**150 + 5**100 - x
    k = k0(num, 5)
    if k > max0:
        max0 = k
        minx = x
print(minx)

625

def dl(n, m):
    return n % m == 0


def checka(a):
    for x in range(1, 500):
        f = dl(x, a) or (dl(x, 23) <= (not (x in range(15, 31))))
        if f == 0:
            return False
    return True


ans = []
for a in range(1, 500):
    if checka(a):
        ans.append(a)
print(max(ans))

23

def checka(a):
    for x in range(1, 100):
        for y in range(1, 100):
            f = (y > 10) or (x * a > y + x)
            if f == 0:
                return False
    return True


ans = []
for a in range(1, 100):
    if checka(a):
        ans.append(a)
print(min(ans))

12

from functools import lru_cache

def move(k1, k2):
    res = [(k1+4, k2),
           (k1, k2+4),
           (k1*2, k2),
           (k1, k2*2)]
    return res


@lru_cache(None)
def game(k1, k2):
    if k1 + k2 >= 154:
        return 'w'
    if any(game(*m) == 'w' for m in move(k1, k2)):
        return 'p1'
    if all(game(*m) == 'p1' for m in move(k1, k2)):  # в задании 19 меняем на any при неудачном первом ходе Пети
        return 'v1'
    if any(game(*m) == 'v1' for m in move(k1, k2)):
        return 'p2'
    if all(game(*m) == 'p1' or game(*m) == 'p2' for m in move(k1, k2)):
        return 'v2'
    

for s in range(1, 143):
    if game(11, s) == 'v2':
        print(s, end=' ')

60 61

def f(start, stop):
    if start > stop:
        return 0
    if start == stop:
        return 1
    if start < stop:
        res = f(start+1, stop)
        r3 = start // 100
        r2 = start // 10 % 10
        r1 = start % 10
        if r2 < r1:
            new_ch = r3*100 + r1*10 + r2
            res += f(new_ch, stop)
        return res
    

print(f(100, 150))

35

def isPrime(num):
    if num < 4:
        return True
    for d in range(2, int(num**0.5) + 1):
        if num % d == 0:
            return False
    return True


def check(num):
    for d in range(2, int(num**0.5) + 1):
        if num % d == 0:
            par = num // d
            if isPrime(d) and isPrime(par) and str(d).count('1') > 0 and str(d).count('6') and str(par).count('1') > 0 and str(par).count('6'):
                return max(d, par)
    return 0
        

k = 0
for num in range(7_513_049, 8_000_000):
    res = check(num)
    if res > 0:
        k += 1
        print(num, res)
        if k == 5:
            break

7513309 123169
7514761 16301
7514789 46103
7514909 11369
7517219 12263

print("x y z w") #вывод названий столбцов
#перебор всех вариантов x,y,z,w
for x in range(2):
    for y in range(2):
        for z in range(2):
            for w in range(2):
                f = x and (z <= w) and not y #переписали функцию
                if f == 1: #выводим только те строки, где f = 1 (как в таблице)
                    print(x, y, z, w) #дальше руками

x y z w
1 0 0 0
1 0 0 1
1 0 1 1

#обязательно использовать функцию per!
def per(num, base):
    res = ''
    while num > 0:
        res += str(num % base)
        num //= base
    return res[::-1]


ans = [] #в список будем складывать ответы
for n in range(1, 1000):
    bn = per(n, 3) #1. перевод числа в 2 СС или 3 СС или куда скажут
    #сумма цифр в троичной записи: sm = bn.count('1') + bn.count('2')*2
    if n % 3 != 0: #какое-то условие на n или bn
        #что-то делаем с bn
        #последние две цифры bn: bn[-2:]
        #дописать 11 справа: bn = bn + '11'
        #дописать 00 слева:  bn = '00' + bn
        #заменить левые два разряда на 10: bn = '10' + bn[2:]
        bn = '1' + bn + bn[-3:]
    else:
        #что-то другое делаем с bn
        sm = bn.count('1') + bn.count('2')*2
        sm *= 8
        bn = bn + per(sm, 3)
    R = int(bn, 3) #перевод обратно в 10 СС из 3 СС
    if abs(R - 1220) < 50:#какое-то условие на R
        #добавляем в список то, что просят найти (либо N либо R)
        ans.append(R)
print(ans) #выводим макс/мин значение из списка

[1177, 1205, 1261, 1239]

def per(num, base):
    s = ""
    while num > 0:
        s += str(num % base)
        num //= base
    return s[::-1]
ans = []
for n in range(1, 1000):
    bn = per(n, 2)
    if n % 2 == 0:
        bn = "10" + bn
    else:
        bn = "1" + bn + "01"
    r = int(bn, 2)
    if r < 30:
        ans.append(n)
print(max(ans))

6

def per(num,base):
    s=""
    while num >0:
        s+=str(num%base)
        num//=base
    return s[::-1]
ans=[]
for n in range(1,1000):
    bn=per(n,3)
    if n%3==0:
        bn="1"+bn+"02"
    else:
        ost=(n%3)*4
        bn=bn+per(ost,3)
    r=int(bn,3)
    if r < 100:
        ans.append(n)
print(max(ans))

10

def per(num,base):
    s=""
    while num>0:
        s+=str(num%base)
        num//=base
    return s[::-1]
ans=[]
for n in range(1,1000):
    bn=per(n,4)
    if n%4==0:
        bn=bn+bn[:3]
    else:
        ost=(n%4)*4
        bn=bn+per(ost,4)
    r=int(bn,4)
    if r>291:
        ans.append(r)
print(min(ans))

296

def per(num, base):
    s = ""
    while num > 0:
        s += str(num % base)
        num //= base
    return s[::-1]
ans = []
for n in range(1, 20000):
    bn = per(n, 2)
    bn = bn + bn[-1]
    bn = bn + str(bn.count("1") % 2)
    r = int(bn, 2)
    if r < 13500:
        ans.append(r)
print(max(ans))

13497

import turtle

k = 20  # коэффициент масштабирования, чтобы рисунок был больше и виднее
turtle.tracer(0)  # отключаем анимацию, чтобы рисовать быстрее
turtle.screensize(2000, 2000)  # устанавливаем размер экрана, чтобы было достаточно места для рисунка

for i in range(3):
    turtle.forward(32*k) 
    turtle.right(90)
    turtle.forward(38*k)
    turtle.right(90)

turtle.penup()
turtle.forward(25*k)
turtle.right(90)
turtle.forward(21*k)
turtle.left(90)
turtle.pendown()

for i in range(3):
    turtle.forward(29*k)
    turtle.right(90)
    turtle.back(18*k)
    turtle.right(90)


turtle.penup()  # поднимаем хвост, чтобы не рисовать линии при перемещении
for x in range(-25, 40):
    for y in range(-40, 5):
        turtle.setpos(x*k, y*k)  # устанавливаем позицию черепашки в точку (x*k, y*k)
        turtle.dot(5, 'red')  # рисуем красную точку диаметром 5 пикселей в текущей позиции черепашки

turtle.update()  # обновляем экран, чтобы отобразить все нарисованные точки и линии
turtle.mainloop()  # чтобы окно оставалось открытым

alf = "дгиашэ" #в виде строки задаем алфавит, который будем перебирать
k = 0 #счетчик кол-ва слов
for q in alf: #перебираем одну букву
    for w in alf: #вторую
        for e in alf: #и т.д.
            for r in alf:
                for t in alf:
                    #т.к. слово из 5 букв, то 5 циклов
                    slovo = q+w+e+r+t
                    if q not in 'иаэ' and t not in 'дгш':
                        k += 1
print(k)

1944

def netPovt(): #проверка, что буквы не повторяются
    for b in slovo: #берем каждую букву в слове
        if slovo.count(b) > 1: #если она повторяется, то не подходит слово
            return False
    return True #True только после проверки всех букв, т.е. после цикла


alf = sorted('победа') #чтобы по алфавиту слова шли, используем sorted
nomer = 0 #номер слова
for q in alf:
    for w in alf:
        for e in alf:
            for r in alf:
                for t in alf:
                    for y in alf:
                        nomer += 1 #каждое новое слово имеет номер на 1 больше прошлого
                        slovo = q+w+e+r+t+y
                        if q == 'о' and netPovt() and nomer % 2 == 0:
                            print(nomer)

def netPovt(): #функция из прошлого примера
    for b in slovo:
        if slovo.count(b) > 1:
            return False
    return True


def isNear(sub_alf): #функция для проверки рядом стоящих пар
    #sub_alf - символы, которые не должны стоять рядом. Например, четные цифры
    for b1 in sub_alf: #перебор символов
            for b2 in sub_alf: #тк ищем пары символов, то два цикла
                if (b1+b2) in slovo: #если какая-то пара символов нашлась в слове, то не подходит
                    return False
    return True


alf = '0123456789' #числа - это те же слова, в алфавите все цифры перечисляем
k = 0
for q in alf[1:]: #КЛЮЧЕВОЕ ОТЛИЧИЕ!! числа не начинаются с 0.
    for w in alf:
        for e in alf:
            for r in alf:
                slovo = q+w+e+r
                if netPovt() and isNear('02468') and isNear('13579'): #проверили сначала четные, потом нечетные
                    k += 1
print(k)

720

from ipaddress import ip_network

for ip in ip_network('210.185.140.126/255.255.255.252', strict=False):
    print(ip)

210.185.140.124
210.185.140.125
210.185.140.126
210.185.140.127

from itertools import product, repeat
a = "ABCDEXZ"
res=[]
for word in product(a,repeat = 4):
    w=''.join(word)
    if w[0] in "XZ" and w[1] in "XZ" and w[2] in "ABCDE" and w[3] in "ABCDE":
        res.append(w)
print(len(res))

100

from itertools import product, repeat
a = "АНДРЕЙ"
res=[]
for word in product(a,repeat = 7):
    w=''.join(word)
    if w[0] not in 'Й' and w.count('А') == 1 and w.count('Й') == 1:
       res.append(w)
print(len(res))

36864

from itertools import *
def notNear():
    for x in product("ЯОА", repeat=2):
        x = ''.join(x)
        if x in w :
            return 0
    return 1
a = "ЯРОСЛАВ"
res = []
for word in permutations(a, r=5):
    w = ''.join(word)
    if notNear() and (w.count('Я') + w.count('О')+ w.count('А') < w.count('Р')+ w.count('С')+ w.count('В')+ w.count('Л')):
        res.append(w)
print(len(res))

1224

from itertools import product, repeat
a = "ВИШНЯ"
res=[]
for word in product(a,repeat = 6):
    w=''.join(word)
    if w[0] not in 'Ш' and w[-1] not in 'ИЯ' and w.count('В') <= 1:
        res.append(w)
print(len(res))

4352

from itertools import product
a = sorted(['Р', 'Е', 'К', 'А'])
count = 0
for word in product(a, repeat=4):
    count += 1
    w = ''.join(word)
    if w.count('А') == 0:
        print(count)
        break

86

from itertools import product
ans = []
n = 0
a = sorted("престол")
for word in product(a, repeat=5):
    w = "".join(word)
    n += 1
    if w[-1] in "ео" and n % 2 != 0 and w.count("р") + w.count("п") + w.count("с") + w.count("т")+w.count("л") <= 3:
        ans.append(n)
print(len(ans))

1776

k = 0
alf = "012345678"
for q in "12345678":
    for w in alf:
        for e in alf:
            for r in alf:
                for t in alf:
                    for y in alf:
                        for u in alf:
                            s =q+w+e+r+t+y+u
                            if s[0] not in "246" and not (s[-1] == s[-2] == s[-3]):
                                k += 1
print(k)

2624400

from ipaddress import ip_network

#в for указываем {узел & маска} и через / саму маску
for ip in ip_network(f"190.202.83.62/255.255.252.0", strict=False):
    print(ip)
    #самый первый адрес - наименьший (берем +1!!!)
    #самый последний адрес - наибольший (берем -1!!!)

from ipaddress import ip_network

#в for указываем {узел & маска} и через / саму маску
for ip in ip_network(f"111.222.0.124/255.255.224.0", strict=False):
    ip2 = bin(int(ip))[2:].zfill(32) #перевод ip в 2 СС
    #после перевода получаем строку из 0 и 1, делаем с ней что хотим
    if ip2.count('0') * ip2.count('1') % 2 != 0:
        print(ip)

from ipaddress import ip_network
k = 0
for ip in ip_network("172.16.96.0/255.255.224.0"):
    ip_bin = bin(int(ip))[2:].zfill(32)
    if ip_bin.count("1") % 2 == 0:
        k += 1
print(k)

4096

from ipaddress import ip_network
for ip in ip_network("190.202.83.62/255.255.252.0", strict=False):
    ip2 = bin(int(ip))[2:].zfill(32)
print(ip)

190.202.83.255

from ipaddress import ip_network
ans=[]
for ip in ip_network("172.95.116.174/255.255.192.0",strict=False):
    ip2=bin(int(ip))[2:].zfill(32)
    if ip2.count("1")%5==0:
        ans.append(ip)
print(min(ans))

172.95.64.15

from ipaddress import ip_network
for ip in ip_network("45.172.106.203/255.255.252.0", strict=False):
    print(ip)
    break

45.172.104.0

from ipaddress import ip_network
k = 0
for ip in ip_network("222.121.128.0/255.255.224.0",strict=False):
    ip_bin = bin(int(ip))[2:].zfill(32)
    if ip_bin[-1]==ip_bin[-2]:
        k += 1
print(k)

4096

from ipaddress import ip_network
k = 0
for ip in ip_network("172.140.68.0/255.255.248.0",strict=False):
    ip_bin = bin(int(ip))[2:].zfill(32)
    if ip_bin.count("0") > 15:
        k += 1
print(k)

1981

from ipaddress import ip_network
k = 0
for ip in ip_network("123.222.111.192/255.255.255.248",strict=False):
    ip_bin = bin(int(ip))[2:].zfill(32)
    lus = ip_bin[24:]
    if lus.count("0") % 3 != 0:
        k += 1
print(k)

6

for x in "0123456789ABCD": #всегда выбираем наименьшую СС
    res = int(f"4B3{x}1C7", 14) + int(f"5{x}G83F7", 17)
    #в кавычках пишем число, которое дано. x берем в фигурные скобки
    #после запятой обязательно указываем СС
    if res % 15 == 0:
        print(res // 15) #частное от деления!!

11401190

num = 5*729**2024 + 3*243**1413 - 7*81**169 - 2*9**107 + 3017
base = 27
summa = 0 #сумма цифр
while num > 0: #перевод в 27 СС
    ost = num % base #считаем остаток
    if ost % 2 == 0 and ost <= 25: #учитываем только четные <=25
        summa += ost #складываем остатки, т.е. цифры
    num //= base
print(summa)

26

f = 15625**16 - 3125**3 * 25**19 + 625**4 - 2005
k = 0
while f > 0:
    ost = f % 25
    if ost == 0:
        k += 1
    f //= 25
print(k)

18

n = 14**1402 + 28**501 - 14**51 - 1400
k =  0
while n > 0:
    ost = n % 14
    if ost == 12:
        k += 1
    n //= 14
print(k)

8

def kolnul(num, base): #функция для подсчета нулей
    k = 0
    while num > 0:
        if num % base == 0:
            k += 1
        num //= base
    return k


mk0 = 0 #максимальное кол-во нулей
mx = 0 #максимальный x
for x in range(1, 2031):
    num = 7**170 + 7**100 - x
    k0 = kolnul(num, 7) #считаем кол-во нулей в 7 СС
    if k0 >= mk0: #ищем максимальное кол-во нулей
        mk0 = k0
        mx = x
print(mx)
#если бы просили наименьший x, то писали бы
#if k > mk0

1715

def k0(num, base):
    k = 0
    while num > 0:
        if num % base == 0:
            k += 1
        num //= base
    return k


ans = []
for x in range(1, 2031):
    num = 3**100 - x
    k = k0(num, 3)
    if k == 5:
        ans.append(x)
print(max(ans))

2024

def k0(num, base):
    k = 0
    while num > 0:
        if num % base == 4:
            k += 1
        num //= base
    return k


ans = []
for x in range(1, 5556):
    num = 5**150 + 5**135 - x
    k = k0(num, 5)
    if k == 134:
        ans.append(x)
print(max(ans))

3126

def k0(num, base, zifr):
    k = 0
    while num > 0:
        if num % base == zifr:
            k += 1
        num //= base
    return k


ans = []
for x in range(1, 10001):
    num = 6**900 + 6**10 - x
    k3 = k0(num, 6, 3)
    k5 = k0(num, 6, 5)
    if k3 == k5:
        ans.append(x)
print(max(ans))

9591

def checka(a):
    for x in range(200):
        for y in range(200):
            f = (x > a) or (y > a) or (x + 2*y < 80)
            if f == 0:
                return False
    return True


for a in range(200):
    if checka(a) == True:
        print(a, end=' ')

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

def checka(a):
    for x in range(300):
        f = (((x & 117) != 0) and ((x & 91) == 0)) <= (not ((x & a) == 0))
        if f == 0:
            return False
    return True


for a in range(300):
    if checka(a) == True:
        print(a, end=' ')

36 37 38 39 44 45 46 47 52 53 54 55 60 61 62 63 100 101 102 103 108 109 110 111 116 117 118 119 124 125 126 127 164 165 166 167 172 173 174 175 180 181 182 183 188 189 190 191 228 229 230 231 236 237 238 239 244 245 246 247 252 253 254 255 292 293 294 295

def d(n, m): #реализация функции ДЕЛ(n, m)
    return n % m == 0


for a in range(1, 700): #сначала перебор а
    flag = 1 #флаг = 1, значит а подходит
    for x in range(1, 700): #тот же диапазон, как у а
        f = d(x, 128) <= ((not d(x, a)) <= (not d(x, 80))) #переписали функцию
        if f == 0: #если ложь, то а не подходит
            flag = 0 #флаг = 0, значит а не подходит
    if flag == 1: #после перебора x проверили, что а подходит
        print(a)

1
2
4
5
8
10
16
20
32
40
64
80
128
160
320
640

for a in range(100):
    flag = True
    for x in range(100):
        for y in range(100):
            f = (x > a) or (y > a) or (x + 2*y < 80)
            if f == 0:
                flag = False
                break
    if flag == True:
        print(a, end=' ')

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

ans = []
for a in range(0, 200):
    flag = 1
    for x in range(0, 200):
        for y in range(0, 200):
            f = (x < a) or (y < a) or (x + 2 * y > 50)
            if f == 0:
                flag = 0
                break
    if flag == 1:
        ans.append(a)
print(min(ans))

17

ans=[]
def DEL(n, m):
    return n % m == 0
for a in range(1, 1500):
    flag = 1
    for x in range(1, 1500):
        f = (a + x < 123) <= ((DEL(x, 5)) <= (not DEL(x, 7)))
        if f == 0:
            flag = 0
    if flag == 1:
        ans.append(a)
print(min(ans))

88

ans = []
for a in range(0, 500):
    flag = 1
    for x in range(0, 500):
        for y in range(0, 500):
            f = (x >= 27) or (2 * x < 3 * y) or ((x + 2) * (y - 3) < a)
            if f == 0:
                flag = 0
                break
    if flag == 1:
        ans.append(a)
print(min(ans))

393

ans=[]
for a in range(0,200):
    flag =1
    for x in range(0,200):
        f =((x & 103 == 0) and (x & 94 != 0)) <= (x & a !=0)
        if f == 0:
            flag = 0
            break
    if flag == 1:
        ans.append(a)
print(min(ans))

24

from functools import lru_cache #импортируем кэш

@lru_cache(None) #включаем кэширование
def f(n): #переписываем функцию
    if n < 10:
        return n
    if n >= 10:
        return 3*n + f(n-3) #f(n-3) -> значит используются предыдущие значения
    

for i in range(6500): f(i) #сначала считаем f(0), f(1), ..., f(6500), чтобы они были в кэше

print((f(6250) + 2*f(6244))//f(6238)) #лучше использовать // вместо /

3

from functools import lru_cache #импортируем кэш

@lru_cache(None) #включаем кэширование
def f(n): #переписываем функцию
    if n > 80000:
        return 100
    if n <= 80000:
        return f(n+1) * n #f(n+1) -> значит используются следующие значения
    
#здесь перебор в обратном порядке, тк f использует СЛЕДУЮЩИЕ значения, вместо предыдущих, как было в первом примере
#при этом диапазон выбираю исходя из условий в функции, на print не смотрю
for i in range(81000, 0, -1): f(i)

print((f(50) // 100 + f(53))//f(55))

3797874

from functools import lru_cache

@lru_cache(None)
def f(n):
    return g(n-1) + g(n-3)

@lru_cache(None)
def g(n):
    if n <= 9:
        return 3*n
    if n > 9:
        return g(n-4) + 2

#основная задача - определить, какую функцию считать первой
for i in range(45000): g(i)
for i in range(45000): f(i) #тк f зависит от g, то f считаем последней

print(f(42999))

43032

from functools import lru_cache

@lru_cache(None)
def f(n):
    if n <= 3:
        return 1
    if n > 3:
        return (n+3)*f(n-2)

for i in range(2500): f(i)
print(f(2028)//f(2024))

4120899

from functools import lru_cache
@lru_cache(None)
def f(n):
    if n < 52:
        return n
    if n >= 52:
        return 3*f(n-2)-n
for n in range(20000): f(n)
print(f(15127)//f(15099))

4782968

from functools import lru_cache
@lru_cache(None)
def f(n):
    if n==1:
        return 1
    if n > 1:
        return 2*n+f(n-1)
for i in range(60000): f(i)
print(f(57693))

3328539941

from functools import lru_cache
@lru_cache(None)
def f(n):
    if n < 10:
        return n
    if n > 9:
        return 3 * n + g(n - 2)
@lru_cache(None)
def g(n):
    if n < 10:
        return n
    if n > 9:
        return n - 2 + f(n - 1)
for n in range(1000):g(n)
for n in range(1000, 0, -1):f(n)
print(f(2204)-g(2200))

12487

from functools import lru_cache
@lru_cache(None)
def f(n):
    if n >= 2010:
        return n
    if n < 2010:
        return f(n+3)+f(n+2)+f(n+1)
for n in range(2500): f(n)
print((f(2000)-2*(f(2002)+f(2003)))//f(2004))

1

from functools import lru_cache
@lru_cache(None)
def f(n):
    if n>3000:
        return n
    if n<=3000:
        return (2 *n+4)*f(n+2)
for n in range(3500,0,-1):f(n)
print(f(20)//f(28))

6150144

from functools import lru_cache
@lru_cache(None)
def f(n):
    return g(n-1) + g(n-3)
@lru_cache(None)
def g(n):
    if n <= 9:
        return 3 * n
    return g(n - 4) + 2
for n in range(50000): f(n)
for n in range(50000, 0, -1): g(n)
print(f(42999))

43032

from functools import lru_cache
def move(k):
    return [k+2, k+4, k*2] #указываем возможные ходы

@lru_cache(None)
def game(k):
    if k >= 125: #условия победы
        return 'w'
    if any(game(m) == 'w' for m in move(k)):
        return 'p1'
    if all(game(m) == 'p1' for m in move(k)):
        return 'v1'
    if any(game(m) == 'v1' for m in move(k)):
        return 'p2'
    if all(game(m) == 'p2' or game(m) == 'p1' for m in move(k)):
        return 'v2'


for s in range(1, 120):
    if game(s) == 'v2': #v1 для №19, p2 для №20, v2 для №21
        print(s)

55
56

from functools import lru_cache

def move(k1, k2): #все варианты пар
    return [(k1+3, k2), 
            (k1, k2+3), 
            (k1*3, k2), 
            (k1, k2*3)]


@lru_cache(None)
def game(k1, k2):
    if k1 + k2 >= 77: #сумма не меньше 77
        return 'w'
    if any(game(*x) == 'w' for x in move(k1, k2)): #теперь везде *x !!!!!!!
        return 'p1'
    if all(game(*x) == 'p1' for x in move(k1, k2)): #теперь везде *x !!!!!!!
        return 'v1'
    if any(game(*x) == 'v1' for x in move(k1, k2)): #теперь везде *x !!!!!!!
        return 'p2'
    if all(game(*x) == 'p2' or game(*x) == 'p1' for x in move(k1, k2)): #теперь везде *x !!!!!!!
        return 'v2'
    

for s in range(1, 65):
    if game(12, s) == 'v2': #в первой кучи известно, что 12 камней
        print(s)

17
19

def f(start, stop):
    if start > stop or start == 10: #НЕ содержит 10
        return 0
    if start == stop:
        return 1
    if start < stop:
        return f(start+1, stop) + f(start+2, stop) + f(start*2, stop)


print (f(3, 7) * f(7, 20)) 
#СОДЕРЖИТ 7: идем от 3 до 7, потом от 7 до 20

def f (start,stop):
    if start>stop or start==27:
        return 0
    if start==stop:
        return 1
    if start<stop:
        return f(start+3,stop)+f(start+5,stop)+f(start**2,stop)
print(f(3,16)*f(16,51))

225

def f (start,stop):
    if start>stop or start==56:
        return 0
    if start==stop:
        return 1
    if start<stop:
        return f(start+3,stop)+f(start+7,stop)+f(start*3,stop)
print(f(12,40)*f(40,72)*f(72,89))

324

def f (start,stop):
    if start<stop or start==24:
        return 0
    if start==stop:
        return 1
    if start>stop:
        return f(start-1,stop)+f(start-4,stop)+f(start//2,stop)
print(f(34,30)*f(30,20)*f(20,9))

264

def f (start,stop):
    if start>stop or start==35:
        return 0
    if start==stop:
        return 1
    if start<stop:
        return f(start+1,stop)+f(start+2,stop)+f(start*2,stop)
print(f(7,13)*f(13,15)*f(15,51))

174034068

with open("24_19717.txt") as f:
    line = f.readline()

lptr = 0
rptr = 0
max_len = 0
kz = 0

while rptr < len(line):
    if line[rptr] == 'M':
        kz += 1
    while kz > 278:
        if line[lptr] == 'M':
            kz -= 1
        lptr += 1
    cur_len = rptr - lptr + 1
    if cur_len > max_len: max_len = cur_len
    rptr += 1
print(max_len)

2471

with open('24_26549.txt') as f:
    line = f.readline()

lptr = rptr = 0
mlen = 0
k2 = 0
ky = 0

lptr = 0
mlen = 0
k2 = 0
ky = 0

for rptr in range(len(line)):
    if line[rptr] == 'Y':
        ky += 1
    if line[rptr-3:rptr+1] == '2025':
        k2 += 1
    while k2 > 50:
        if line[lptr] == 'Y':
            ky -= 1
        if line[lptr:lptr+4] == '2025':
            k2 -= 1
        lptr += 1
    if line[rptr-3:rptr+1] == '2025' and k2 == 50 and ky >= 140:
        mlen = max(mlen, rptr - lptr + 1)

print(mlen)

938

with open("24_27634.txt") as f:
    line = f.readline()

rptr = lptr = 0
kz = 0
mlen = 10**10

while rptr < len(line):
    if line[rptr] == 'Z':
        kz += 1
    while kz >= 270:
        mlen = min(mlen, rptr - lptr + 1)
        if line[lptr] == 'Z':
            kz -= 1
        lptr += 1
    rptr += 1
print(mlen)

1058

import re

with open("24_21981.txt") as f:
    line = f.readline()

num = "[1-9A-F][0-9A-F]*"
mask = f"({num})"

res = [x.group() for x in re.finditer(mask, line)]

print(len(max(res, key=lambda x: len(x) if x.count('B') == 10 else 0)))

333

from re import finditer


file = open("24_22356.txt")
line = file.readline()
file.close()

num = "([123456789AB][0123456789AB]*|[13579B])"
mask = f'{num}'
res = [i.group() for i in finditer(mask, line)]
mx = 0
mx_exp = 0
for x in res:
    if len(x) > mx:
        mx = len(x)
        mx_exp = x
    if len(x) == mx:
        if x > mx_exp:
            mx_exp = x
#print(mx, mx_exp, sep='\n')
print(line.find(mx_exp))

8499457

import re


with open("24_22361.txt") as f:
    line = f.readline()

num = "[1234567][01234567]*[0246]"
mask = f"({num})"
max_len = 0
max_expr = ""

res = [x.group() for x in re.finditer(mask, line)]
for x in res:
    if len(x) > max_len:
        max_len = len(x)
        max_expr = x
    elif len(x) == max_len:
        if int(x) < int(max_expr):
            max_expr = x

print(max_expr)
print(line.find(max_expr))

10235647074152360
2494915

from re import finditer


file = open("24_22362.txt")
line = file.readline()
file.close()

num = "([123456789AB][0123456789AB]*[0369]|[0369])"
mask = f'{num}'
res = [i.group() for i in finditer(mask, line)]
mx = 0
mx_exp = 0
for x in res:
    if len(x) > mx:
        mx = len(x)
        mx_exp = x
print(mx, mx_exp, sep='\n')

109
94B2008316297540136540892709165728304060159478230173286045907261084395032516408970957406823102739401685000240

from fnmatch import fnmatch  # импортируем функцию для проверки маски
for num in range(9874, 10**10 + 1, 9874):  # перебираем числа, кратные 9874, от самого маленького до 10^10
    if fnmatch(str(num), '89*6?7?9?'):  # проверяем, соответствует ли число маске '89*6?7?9?'
        print(num, num // 9874)

8901677598 901527
8905627198 901927
8912617990 902635
8941667298 905577
8952607690 906685
8970607992 908508
8988647790 910335

def getsum(num):  # функция для подсчета суммы цифр числа
    s = 0
    while num > 0:
        s += num % 10
        num //= 10
    return s


def check(num):
    res = []  # список для хранения делителей, сумма цифр которых равна 13
    for d in range(2, int(num**0.5) + 1):       # перебираем делители от 2 до квадратного корня из num
        if num % d == 0:            # если d является делителем num
            if getsum(d) == 13:     # проверяем, равна ли сумма цифр d числу 13
                res.append(d)       # добавляем делитель в список
            par = num // d          # другой делитель, который парный с d
            if par != d and getsum(par) == 13:  # проверяем другой делитель, исключая квадратные числа
                res.append(par)     # добавляем другой делитель в список, если он подходит
    if len(res):
        return min(res)
    else:
        return 0


k = 0
for num in range(700_001, 800_000):  # перебираем числа, большие 700000
    mdel = check(num)
    if mdel != 0:         # проверяем каждое число с помощью функции check
        k += 1            # если число подходит, увеличиваем счетчик
        print(num, mdel)  # выводим число и его подходящий делитель
        if k == 5:        # если нашли 5 таких чисел, останавливаемся
            break

700002 58
700004 139
700005 2029
700010 350005
700011 193

def isprime(num):  # функция для проверки, является ли число простым
    if num < 4:
        return True
    for d in range(2, int(num**0.5) + 1):
        if num % d == 0:
            return False
    return True


def kol3(num):  # функция для подсчета количества цифр 3 в числе
    count = 0
    while num > 0:
        if num % 10 == 3:
            count += 1
        num //= 10
    return count


def check(num):
    for d in range(2, int(num**0.5) + 1):       # перебираем делители от 2 до квадратного корня из num
        if num % d == 0:            # если d является делителем num
            par = num // d          # другой делитель, который парный с d
            if isprime(d) and kol3(d) == 2 and \
               isprime(par) and kol3(par) == 2:  
                return par         # если оба делителя простые, возвращаем True
    return 0               # если не нашли подходящих делителей, возвращаем False
        

k = 0
for num in range(8_996_453, 9_500_000):  # перебираем числа, большие 8996453
    res = check(num)
    if res != 0:         # проверяем каждое число с помощью функции check
        k += 1
        print(num, res)  # выводим число и его подходящий делитель
        if k == 5:
            break

9001609 24133
9002887 38639
9006149 38653
9012167 3853
9012373 23531

def isprime(num):  # функция для проверки, является ли число простым
    if num < 4:
        return True
    for d in range(2, int(num**0.5) + 1):
        if num % d == 0:
            return False
    return True


def findM(num):
    res = []
    for d in range(2, int(num**0.5) + 1):       # перебираем делители от 2 до квадратного корня из num
        if num % d == 0:            # если d является делителем num
            par = num // d          # другой делитель, который парный с d
            if isprime(d):
                res.append(d)       # если d простой, добавляем его в список
            if par != d and isprime(par):
                res.append(par)     # если другой делитель простой, добавляем его в список, исключая квадратные числа
    if len(res):
        return min(res) + max(res), len(res)  # если нашли простые делители, возвращаем сумму наименьшего и наибольшего, а также их количество
    else:
        return 0, 0                   # если не нашли простых делителей, возвращаем 0 и 0
    

k = 0
for num in range(7_800_001, 8_000_000):  # перебираем числа, большие 7800001
    M, kol = findM(num)
    if M % 100 == 63 and M % kol == 0:  # проверяем каждое число с помощью функции findM
        k += 1
        print(num, M)  # выводим число, если его наименьший и наибольший простые делители в сумме дают 149 и их количество равно 2
        if k == 5:
            break

7800610 780063
7801042 8463
7801312 1863
7801916 8163
7802032 69663

def findD(num):
    res = []
    for d in range(2, int(num**0.5) + 1):       # перебираем делители от 2 до квадратного корня из num
        if num % d == 0:            # если d является делителем num
            par = num // d          # другой делитель, который парный с d
            if d != 11 and d % 100 == 11:  # проверяем, что d заканчивается на 11
                res.append(d)       # если d подходит, добавляем его в список
            if par != d and par % 100 == 11:  # проверяем другой делитель
                res.append(par)     # если другой делитель подходит, добавляем его в список
    if len(res):
        return min(res)  # если нашли подходящие делители, возвращаем наименьший из них
    else:
        return 0          # если не нашли подходящих делителей, возвращаем 0
    

k = 0
for num in range(1_350_051, 1_500_000):  # перебираем числа, большие 1350051
    D = findD(num)
    if D != 0:  # проверяем каждое число с помощью функции findD
        k += 1
        print(num, D)  # выводим число и его наименьший делитель, который заканчивается на 11
        if k == 5:
            break

1350051 311
1350055 270011
1350062 511
1350063 40911
1350066 225011

with open('26_27779.txt') as f:
    n = int(f.readline())     # читаем первое число из файла, которое задает количество строк
    data = [int(line) for line in f]  # читаем остальные строки и сохраняем их в список data

data.sort(reverse=True)  # сортируем список data по убыванию
last_korz = data[0]      # берем наибольший корж - это первый элемент отсортированного списка
k = 1  # счетчик количества коржей

for i in range(1, n):    # перебираем остальные элементы списка
    if data[i] <= last_korz - 8:
        last_korz = data[i]   # обновляем последний корж
        k += 1       # увеличиваем счетчик количества коржей
        
print(k, last_korz)  # выводим количество коржей и размер последнего коржа

1159 57

with open('26_27636.txt') as f:
    s, n = [int(x) for x in f.readline().split()]  # читаем грузоподъемность и количество строк
    data = [int(line) for line in f]  # читаем остальные строки и сохраняем их в список data

data.sort()  # сортируем список data по возрастанию
k = 0        # счетчик количества грузов
cur_sum = 0  # текущая сумма грузов

for weight in data:  # перебираем веса грузов в отсортированном списке
    if cur_sum + weight <= s:   # если текущая сумма грузов плюс вес нового груза не превышает грузоподъемность
        cur_sum += weight       # добавляем вес груза к текущей сумме
        k += 1  # увеличиваем счетчик количества грузов
    else:
        break   # если груз не помещается, прекращаем перебор

print(n - k, sum(data) - cur_sum)   # выводим количество грузов и сумму оставшихся грузов

7347 472188

def parseChar(line):    # функция для разбивки char на цвет, освещенность и размер
    return [line[0], line[1], line[2:]]


def dist(p1, p2):   # функция для нахождения расстояния между двумя точками
    x1, y1 = p1['x'], p1['y']
    x2, y2 = p2['x'], p2['y']
    return ((x1-x2)**2 + (y1-y2)**2)**0.5


def cent(cl_p):     # функция для нахождения центра кластера
    minl = 10**10   # задаем начальное значение для минимальной суммы расстояний
    top_k = []      # переменная для хранения точки, которая будет центром кластера
    for k in cl_p:
        sum_d = 0   # переменная для хранения суммы расстояний от точки k до всех остальных точек в кластере
        for o in cl_p:
            d = dist(k, o)  # считаем расстояние от точки k до другой точки o в кластере
            sum_d += d      # добавляем это расстояние к сумме расстояний для точки k
        if sum_d < minl:    # если сумма расстояний для точки k меньше минимальной суммы
            minl = sum_d    # обновляем минимальную сумму расстояний
            top_k = k       # обновляем точку, которая будет центром кластера
    return top_k


def getRGdist(cl_p, centr): # функция для нахождения расстояния от центра кластера до нужной точки и ее координат
    min_d = 10**10  # задаем начальное значение для минимального расстояния
    for p in cl_p:
        if p['color'] == 'M' and p['size'] == 'III':  # проверяем, что точка - красный гигант
            d = dist(centr, p)  # считаем расстояние от центра кластера до точки p
            if d < min_d:       # если это расстояние меньше минимального расстояния
                min_d = d       # обновляем минимальное расстояние
                x = p['x']      # обновляем координату x нужной точки
                y = p['y']      # обновляем координату y нужной точки
    return [min_d, x, y]


f = open('27_A_29357.txt').readlines()  # открываем файл и читаем все строки в список
p = []          # список для хранения точек
cl = [[],[]]    # список для хранения двух кластеров точек

for line in f:  # перебираем каждую строку в файле
    x, y, char = line.split()   # разбиваем строку на x, y и char
    char = parseChar(char)      # разбиваем char на цвет, освещенность и размер
    #point = [x, y, *char]
    #создаем словарь для каждой точки, чтобы было удобнее обращаться к ее характеристикам
    point = {"x" : float(x), "y" : float(y), "color" : char[0], "light" : char[1], "size" : char[2]} 
    p.append(point)


# для деления точек на кластеры нужно построить в excel точечную диаграмму
# для точек из файла и посмотреть, как их можно разделить на 2 кластера. 
# В данном случае, по оси y видно, что точки можно разделить на 2 кластера, 
# если провести горизонтальную линию примерно на уровне y=10. 
# Поэтому, в коде ниже, мы проверяем координату y каждой точки и добавляем ее в соответствующий кластер.


for pnt in p:
    x, y = pnt['x'], pnt['y']
    if y > 10:
        cl[0].append(pnt)
    else:
        cl[1].append(pnt)

cl.sort(key=lambda x: len(x))       # сортируем кластеры по количеству точек
centr = [cent(cl[0]), cent(cl[1])]  # находим центры кластеров
a1, x1, y1 = getRGdist(cl[0], centr[0])  # находим расстояние от центра кластера до нужной точки и ее координаты
print(int(x1*10000), int(y1*10000))
print(len(cl[0]))
print(len(cl[1]))
print(centr[0])

44694 69754
114
121
{'x': 4.960398, 'y': 7.34545, 'color': 'O', 'light': '8', 'size': 'I'}

def parseChar(line):    # функция для разбивки char на цвет, освещенность и размер
    return [line[0], line[1], line[2:]]


def dist(p1, p2):   # функция для нахождения расстояния между двумя точками
    x1, y1 = p1['x'], p1['y']
    x2, y2 = p2['x'], p2['y']
    return ((x1-x2)**2 + (y1-y2)**2)**0.5


def cent(cl_p):     # функция для нахождения центра кластера
    minl = 10**10   # задаем начальное значение для минимальной суммы расстояний
    top_k = []      # переменная для хранения точки, которая будет центром кластера
    for k in cl_p:
        sum_d = 0   # переменная для хранения суммы расстояний от точки k до всех остальных точек в кластере
        for o in cl_p:
            d = dist(k, o)  # считаем расстояние от точки k до другой точки o в кластере
            sum_d += d      # добавляем это расстояние к сумме расстояний для точки k
        if sum_d < minl:    # если сумма расстояний для точки k меньше минимальной суммы
            minl = sum_d    # обновляем минимальную сумму расстояний
            top_k = k       # обновляем точку, которая будет центром кластера
    return top_k


def kOrangeGiants(cl_p):    # функция для подсчета количества оранжевых гигантов в кластере
    k = 0
    for p in cl_p:
        if p['color'] == 'K' and p['size'] == 'III':
            k += 1
    return k


def maxYelGnomeDist(cl_p):  # функция для нахождения максимального расстояния между желтыми карликами в кластере
    yel_gnome = []
    for p in cl_p:
        if p['color'] == 'G' and p['size'] == 'V':  # проверяем, что точка - желтый карлик
            yel_gnome.append(p)

    max_dist = 0    # переменная для хранения максимального расстояния между желтыми карликами
    for i in range(len(yel_gnome)):  # перебираем все пары желтых карликов в кластере
        for j in range(i+1, len(yel_gnome)):
            d = dist(yel_gnome[i], yel_gnome[j])
            if d > max_dist:  # ищем наибольшее расстояние между желтыми карликами
                max_dist = d
    return max_dist


f = open('27_B_29357.txt').readlines()  # открываем файл и читаем все строки в список
p = []          # список для хранения точек
cl = [[],[], []]    # список для хранения трех кластеров точек

for line in f:  # перебираем каждую строку в файле
    x, y, char = line.split()   # разбиваем строку на x, y и char
    char = parseChar(char)      # разбиваем char на цвет, освещенность и размер
    #point = [x, y, *char]
    #создаем словарь для каждой точки, чтобы было удобнее обращаться к ее характеристикам
    point = {"x" : float(x), "y" : float(y), "color" : char[0], "light" : char[1], "size" : char[2]} 
    p.append(point)


for pnt in p:
    x, y = pnt['x'], pnt['y']
    if y < 30:
        cl[0].append(pnt)
    elif x < 16:
        cl[1].append(pnt)
    else:
        cl[2].append(pnt)

cl.sort(key=kOrangeGiants)          # сортируем кластеры по количеству оранжевых гигантов
centr = [cent(cl[0]), cent(cl[1]), cent(cl[2])]         # находим центры кластеров

B1 = dist(centr[0], centr[2])       # находим расстояние между центрами кластеров с наибольшим и наименьшим количеством оранжевых гигантов
B2 = max(maxYelGnomeDist(cluster) for cluster in cl)    # находим максимальное расстояние между желтыми карликами во всех кластерах

print(int(B1*10000), int(B2*10000))

138716 34029

ID	Артикул	Операция
1	114	Продажа
2	97	Продажа

ID	Артикул	Наименование
1	314	Шкаф IKEA
2	115	Стул СТМ
3	114	Холод. LG
4	97	СВЧ Samsung

ID	Артикул	Операция	Наименование
1	114	Продажа	=ВПР(B2; Товар!A:C; 3; 0)
2	97	Продажа	=ВПР(B3; Товар!A:C; 3; 0)

ID	Артикул	Операция	Наименование
1	114	Продажа	Холод. LG
2	97	Продажа	СВЧ Samsung

Функция	Назначение
forward(distance: float)	движение вперед на расстояние, равное `distance`
back(distance: float)	назад
right(angle: float)	поворот пр.ч.с. на угол `angle`
left(angle: float)	поворот п.ч.с.
penup()	поднять хвост
pendown()	опустить хвост

Функция	Назначение
tracer(0)	делает отрисовку мгновенной
screensize(2000, 2000)	установка размера экрана
setpos(x, y)	перемещение в точку (x, y)
dot(5, 'red')	ставим точку размера 5, красного цвета
update()	тоже для мгновенной отрисовки
mainloop()	оставляет экран открытым, иначе он сразу закроется

Тип задачи	Что делать
1. Найти количество вхождений слова	Ctrl + F → ввести слово → посмотреть количество найденных совпадений (или пролистать все, если редактор не показывает число).
2. Найти слова, начинающиеся на определённые буквы	Ctrl + H (или Ctrl + F → Расширенный поиск) →включить Подстановочные знаки → шаблон <абв*(в Word) или использовать регулярные выражения в LibreOffice.
3. Найти слова, заканчивающиеся на определённые буквы	Расширенный поиск → Подстановочные знаки → шаблон *ость> (для окончания «ость»).
4. Найти слова, содержащие определённую часть	Ctrl + F → ввести нужную часть слова (например, лог).
5. Найти слова определённой длины	Подстановочные знаки → например — слова из 5 букв (? = одна буква).
6. Найти слова с двумя условиями (например, начинаются на “по” и заканчиваются на “ть”)	Подстановочные знаки → <по*ть>.
7. Найти целое слово, а не часть другого	В параметрах поиска поставить галочку Только слово целиком.
8. Учесть или не учитывать регистр	При необходимости включить Учитывать регистр. Если в условии про заглавные/строчные ничего нет — оставить выключенным.
9. Найти слово после замены букв (например, е/ё)	Выполнить поиск по обоим вариантам (е и ё) либо использовать шаблон, если редактор поддерживает его.
10. Подсчитать слова, удовлетворяющие нескольким признакам	Использовать расширенный поиск с шаблоном, затем просмотреть количество найденных совпадений.

Что нужно найти	Что вводить
Любое слово	<*>
Слова, начинающиеся на «при»	<при*>
Слова, заканчивающиеся на «ость»	<*ость>
Слова ровно из 6 букв	<??????>
Слова, начинающиеся на «с» и заканчивающиеся на «ть»	<с*ть>
Любое слово, содержащее «ова»	ова

Обозначение	Цвет	Обозначение	размеров
O	голубой	I	сверхгигант
B	бело-голубой	II	яркий гигант
A	белый	III	гигант
F	жёлто-белый	IV	субгигант
G	жёлтый	V	карлик
K	оранжевый	VI	субкарлик
M	красный	VII	белый карлик

Вариант от 18.06.26¶

Задание 5¶

Задание 8¶

Задание 13¶

Задание 14¶

Задание 15¶

Задание 19¶

Задание 23¶

Задание 25¶

Шаблоны¶

Задание 2¶

Задание 3¶

Задание 5¶

Пример 2¶

Пример 3¶

Пример 4¶

Пример 5¶

Задание 6¶

Задание 8¶

Прототип 1. Количество слов¶

Прототип 2. Слова по алфавиту¶

Прототип 3. Числа¶

Пример 4¶

Пример 5¶

Пример 6¶

Пример 7¶

Пример 8¶

Пример 9¶

Пример 10¶

Пример 11¶

Задание 10¶

Задание 13¶

Прототип 1. Наибольший/наименьший адрес¶

Прототип 2. Работа с двоичной записью IP¶

Пример 3¶

Пример 4¶

Пример 5¶

Пример 6¶

Пример 7¶

Пример 8¶

Пример 9¶

Задание 14¶

Прототип 1. Сложение в разных СС¶

Прототип 2. Количество цифр в записи¶

Пример 2¶

Пример 3¶

Прототип 3. Перевод с неизвестным x¶

Пример 2¶

Пример 3¶

Пример 4¶

Задание 15¶

Новая реализация¶

Еще пример¶

Прототип 1. Найти число А¶

Еще пример¶

Прототип 2. Отрезки¶

Пример 5¶

Пример 6¶

Пример 7¶

Пример 8¶

Задание 16¶

Прототип 1. Предыдущие значения¶

Прототип 2. Следующие значения¶

Прототип 3. Две функции¶

Пример 4¶

Пример 5¶

Пример 6¶

Пример 7¶

Пример 8¶

Пример 9¶

Пример 10¶

Аналитическое решение¶

Задание 19-21¶

Прототип 1. Одна куча¶

Прототип 2. Две кучи¶

Задание 22¶

Задание 23¶

Пример 2¶

Пример 3¶

Пример 4¶