КЕГЭ ИНФОРМАТИКА
Published: 2021-05-25 01:25:34

#Выбор ЯП для ЕГЭ.
Вообще нет разницы, но я бы советовал выбрать Python в силу своей простоты и компактности. Имба для ЕГЭ.
Можешь изучить базовый синтаксис тут:
[Базовый синтаксис от Роди](https://www.youtube.com/watch?v=0JY9YhnFwo4)
[Базовый синтаксис от Александра Романовича](https://www.youtube.com/watch?v=jDmn_zKuAMo)
#Задание 1 (1-3 мин.)
Ну тут все просто. Смотришь на граф, смотришь на матрицу смежности, решаешь.

#Задание 2 (1 мин.)
Классное задание. Легко прогается. Код шаблонный и выглядит следующим образом:

```
print('x y z')                                          # тут мы просто делаем удобный вывод
for x in range(2):                                      # запускаем фор для каждой переменной
    for y in range(2):                                  #
        for z in range(2):                              #
            if not (((not y) or (not z)) <= (z == x)):  # переписываем формулу из условия
                print(x, y, z)                          # выводим переменные
                                                        # все, смотрим вывод и таблицу в задаче, сопоставляем
                                                        #------------------------------------------------------
                                                        # вывод выглядит так:
                                                        # x y z
                                                        # 0 0 1
                                                        # 1 0 0
                                                        # 1 1 0
```
Код работает для любого количества переменных. Если нужно две переменные *(хотя я думаю, что у тебя не будет проблем решить подобную задачу руками)*, то делаешь 2 цикла, если четыре — соответственно 4 цикла.

#Задание 3 (миллион лет)
Самое тупое задание в ЕГЭ по информатике. Пялимся на таблицу минут 10, находим ответ.

#Задание 4 (1-3 мин.)
**Условие Фано**. Не слышал о таком? Тогда почему ты вообще сдаешь информатику? Открываем пэинт/ножницы или рисуем на черновике. Как тебе удобнее.

#Задание 5 (1-2 мин.)
Классное задание, которое легко решается с помощью калькулятора. Включаем режим программиста, решаем.
![image](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/2ouaw0ye34d7zbil5zio.png)

#Задание 6 (1 мин.)
Крутое задание, чтобы сделать его ручками, но мы слишком ленивые. Запускаем фор, немного изменяем программу и получаем ответ.
```
 for i in range(999):       # фор любого размера (чем больше, тем лучше)
    k = i                   # вместо int(input()) пишем i
    n = 1001                # остальную часть кода оставляем неизменной
    s = -1001               #
    while s + n < 501:      #
        n += k * 4          #
        s += n              #
    if s == 20:             # кроме этой. тут мы пишем условие вывода
        print(i)            # выводим i
```

#Задание 7 (1-2 мин.)
Норм задание. Учим формулы, считаем на калькуляторе.

#Задание 8 (1-2 мин.)
Тут есть классное решение кодом (не ожидали, да?)

#Задание 9 (1-3 мин.)
Еее, бесплатные баллы. Запускаем эксель и делаем.

#Задание 10 (10 сек.)
Тут нечего говорить. Задание добавили, чтобы если ты ничего не учил, то хотя бы один первичный балл получил.
Открываешь файл, нажимаешь комбинацию клавиш ***ctrl+f*** и вбиваешь слово. В параметрах поисках можешь поставить "только слово целиком".

#Задание 11 (1-3 мин.)
В этом задание главное правильно читать условие. Обрати внимание на фразы "целое количество байт", "минимально возможным количеством бит" и так далее. Считай на калькуляторе, тебе все можно!

#Задание 12 (1-2 мин.)
Пишем код. Точнее переписываем его с алгоритмического языка на нормальный.
```
                                    # Какая строка получится в результате применения приведённой ниже программы к строке, состоящей из 84 единиц?
                                    # НАЧАЛО
                                    #    ПОКА нашлось (11111)
                                    #        заменить (222, 1)
                                    #        заменить (111, 2)
                                    #    КОНЕЦ ПОКА
                                    # КОНЕЦ
                                    #
s = '1' * 84                        # задаем строку
while '11111' in s:                 # переписываем условие
    s = s.replace('222', '1', 1)    # функция s.replace(что заменить, на что заменить, сколько раз)
    s = s.replace('111', '2', 1)    #
print(s)                            # вывод полученной строки
```

#Задание 13 (1-3 мин.)
Открываешь пэинт/ножницы, рисуешь. Тут главное не запутаться.

#Задание 14 (1-2 мин.)

#Задание 15 (2-3 мин.)
Тут несколько типов заданий. Условно их можно разделить на два типа: отрезки и другие.
##Отрезки

```
                                                        # P = [7, 14] и Q = [9, 11]. Укажите наибольшую 
                                                        # возможную длину промежутка A,
                                                        # для которого формула
                                                        # ((x ∈ P) ~ (x ∈ Q)) → ¬(x ∈ A)
                                                        #
p1, p2, q1, q2 = 7, 14, 9, 11                           # отмечаем края отрезков
P = [i / 10 for i in range(p1 * 10, p2 * 10 + 1)]       # делаем отрезок вида [7.0, 7.1, 7.2, ..., 14.0]
Q = [i / 10 for i in range(q1 * 10, q2 * 10 + 1)]       # делаем отрезок вида [9.0, 9.1, 9.2, ..., 11.0]
                                                        #
                                                        #
def f(x, A):                                            # заводим функцию
    return ((x in P) == (x in Q)) <= (x not in A)       # перепечатываем из условия
                                                        #
                                                        #
A = set([i / 10 for i in range(10, 201)])               # заводим множество без повторений (set) А вида [1.0, 1.1, ..., 20.0]
                                                        #
for x in [i / 10 for i in range(10, 201)]:              # перебираем те же самые значения х
    if not f(x, A):                                     # если нашли НЕ подходящее значение
        A.remove(x)                                     # удаляем его
                                                        #
print(sorted(A))                                        # оно там чет жесть выводит, поэтому сортируем
                                                        # смотрим вывод и отвечаем на вопрос, поставленный в задаче
                                                        # не забываем следить, порвался отрезок или нет
                                                        # если отрезок порвался, то это два отрезка
                                                        # следовательно выбираем наибольший/наименьший (см. условие задачи)
```
**НО ЭТО АЛГОРИТМ ДЛЯ НАИБОЛЬШЕГО ОТРЕЗКА, В АЛГОРИТМЕ НА НАИМЕНЬШИЕ ЕСТЬ НЕБОЛЬШИЕ ОТЛИЧИЯ**
А именно:
Мы меняем две строчки.
Вместо
```
A = set([i / 10 for i in range(10,201)])
```
создаем просто пустое A
```
A = set()
```

Вместо удаления икса
```
A.remove(x)
```
Делаем добавление этого икса
```
A.add(x)
```

**НЕ ЗАБЫВАЕМ, ЧТО НАМ МОГУТ ПОПАСТЬСЯ РВАННЫЕ ОТРЕЗКИ**

Что же делать с задачами, где задаются *два* выражения? Не пугаемся, кодом это тоже работает. Просто задаем две **отдельные** функции, два **отдельных** сета и два **отдельных** фора.

```
                                                    # Р = [30, 45] и Q = [40, 55].
                                                    # Какова наименьшая возможная длина интервала A,
                                                    # что обе приведённые ниже формулы истинны при любом значении переменной х:
                                                    # ( ¬(x ∈ A) → (¬(x ∈ P))
                                                    # ((x ∈ Q)→ (x ∈ A))
                                                    #
def f1(x, A1):                                      # первая функция
    return ((x not in A1) <= (x not in P))          #
                                                    #
def f2(x,A2):                                       # вторая функция
    return((x in Q) <= (x in A2))                   #
                                                    #
                                                    #
p1, p2, q1, q2 = 30, 45, 40, 55                     #
                                                    #
P = [i / 10 for i in range(p1 * 10, p2 * 10 + 1)]   #
Q = [i / 10 for i in range(q1 * 10, q2 * 10 + 1)]   #
                                                    #
A1 = set()                                          # первый сет
A2 = set()                                          # второй сет
                                                    #
for x in [i / 10 for i in range(200, 600)]:         # первый цикл (для первого сета)
    if not f1(x, A1):                               #
        A1.add(x)                                   #
                                                    #
for x in [i / 10 for i in range(200, 600)]:         # второй цикл (для второго сета)
    if not f2(x, A2):                               #
        A2.add(x)                                   #
                                                    #
print('1', sorted(A1))                              # на выводе получаем
print('2', sorted(A2))                              # два отрезка, которые пересекаются
                                                    # [30;45]
                                                    # [40;55]
```

Еще есть задачи на две переменные. Тут совсем ничего не понятно, просто посмотрите код.
```
import itertools                                                        


def f(x, y, A):
    return ((x in A) <= (x * x <= 81)) and ((y * y <= 36) <= (y in A))


A = set(range(-100, 100))

for x, y in itertools.product(range(-100, 100), repeat=2):
    if not f(x, y, A):
        A.remove(x)
```
Итертулс импортируем для перебора **всех** комбинаций *x* и *y*.
Не нравятся мне эти дурацкие задачи с двумя переменными.
##Функции
Для выполнения этого типа заданий нужно, как ни странно, задать функцию.
```
                                                                    # ¬ДЕЛ(x, А) → (ДЕЛ(x, 6) → ¬ДЕЛ(x, 9))
                                                                    # найти A max
                                                                    #
def f(a, b):                                                        # задаем функцию (в нашем случае дел)
    return a % b == 0                                               #
                                                                    #
                                                                    #
A = 1                                                               # начальное значение А
while True:                                                         # бесконечный цикл
    for x in range(1,1000000):                                      # перебираем иксы
        if not ((not f(x, A)) <= ((f(x, 6)) <= (not (f(x, 9))))):   # действуем от обратного (если не сработала, то
            break                                                   # выходим из цикла)
    else:                                                           # иначе (если не вышли)
        print(A)                                                    # принтим А
    A += 1                                                          # увеличиваем А
                                                                    # если нужно max значение, то ждем, пока не перестанет
                                                                    # выводить, если min, то первое число - наш ответ
```
##Неравенства
Аналогично с *функциями*
```
                                                            # (x · y < 100) ∨ (y ≥ A) ∨ (x > A)
                                                            # найти max A при любых x и y
                                                            #
A = 1                                                       # начальное значение A
while True:                                                 # бесконечный цикл
    for x in range(3000):                                   # перебор иксов
        for y in range(3000):                               # перебор игреков
            if not ((x * y < 100) or (y >= A) or (x > A)):  # действуем от обратного (если не сработала, то
                break                                       # выходим из цикла). прошу обратить ваше внимание
        else:                                               # на конструкцию из break'ов и continue
            continue                                        #
        break                                               #
    else:                                                   # иначе (если не вышли)
        print(A)                                            # принтим А
    A += 1                                                  # увеличиваем А
                                                            # если нужно max значение, то ждем, пока не перестанет
                                                            # выводить, если min, то первое число - наш ответ
```
#Задание 16 (1-2 мин.)
Хочешь считай ручками, но мне легче переписать условие.

#Задание 17 (1-3 мин.)

#Задание 18 (2-3 мин.)

#Задания 19-21 (5 мин.)

#Задание 22 (1 мин.)
Тут все точно также, как и в **задании 6**. Хочешь решать ручками? Решай. Я просто перепишу код и запущу фор.

#Задание 23

#Задание 24

#Задание 25

#Задание 26

#Задание 27

#Где решать задачки?
[Школково](https://informatika.shkolkovo.net)
[Поляков](https://kpolyakov.spb.ru)
[РешуЕГЭ](https://ege.sdamgia.ru)
[КомпЕГЭ](https://kompege.ru)