экзамен / gayd_dlya_nubov

Гайд на экзамен по информатике для нубов.

Задание №1)

Довольно простая с виду хуйня, но тут может быть наёбка. Тут как со всеми первыми задачами из ЕГЭ, простая залупа, но легко проебаться. Не стоит его спидранить. В нём даётся какая-то функция, которая принимает и отдаёт какие-то переменные. В первую очередь стоит обратить внимание на тип возвращаемого значения этой функции. Напомню, что их почти столько-же,

сколько есть типов переменных.

Напомню на всякий случай про типы переменных(соответственно и функций):

Int – целочисленный тип, т.е. в эту переменную записываются целые числа,

надеюсь, вам не надо объяснять что это за числа. Если это не так – выйдите в

окно.

Float – это числа с плавающей точкой, т.е. не целые. К примеру 14.88 или

1.312 . При использовании этого типа переменных необходимо в конце присваивания какого-то значения писать букву f, дабы компилятор отличал float от double. Допустим:

float zalupa = 10.0f

Это писать не очень удобно, запарно, по сему не используйте этот тип, но просто знайте про него.

Double – та-же хуйня, что и float, но исходя из названия – с двойной точностью(т.е. больше цыфор после точки записать может). В отличие от предыдущего говна никакие букавы при присваивании писать не надо.

Bool – хуй знает от куда такое название пошло, его не буллил вроде никто, но этот тип довольно тупой. Запоминает всего два значения 1/0 или же true/false.

Тут не думаю, что много объяснять надо, всё и так понятно.

Char – это тип символьных данных, т.е. переменная передаёт и запоминает символ, в целом понятно.

String – похожая тема на предыдущую, к сожалению передаёт и записывает не стринги а строку(9(. Т.е. набор символов.

Перейдём к самим функциям, типов функций есть 5(из тех, что вам сейчас нужны), это вышеперечисленные int, float, double и bool. Также к ним добавляется void.

Void, что в переводе с английского – пустота. Не сложно догадаться, что она нихуя не возвращает после себя. Так, если у нас есть функция:

void zalupa(int x, int y)

{

*какой-то код*

}

То при вызове её:

cout << zalupa;

Окно cmd вам выведет ваше успешное будущее(ничего).

Вообще, что такое функция?

А это шкатулка такая, в которую если положить что-то, то при вызове этой шкатулки – она превратиться во что-то другое.

Для начала объявляется тип функции, это то, в какой тип данных превратится эта шкатулка.

Затем объявляется название функции.

То, что кладётся в шкатулку – записывается в скобках и называется параметром функции, как правило это какие-либо переменные. Но их может и не быть, ибо функция может ничего и не делать с данными, а допустим просто что-то выводить.

К примеру:

void vivod()

{

cout << “была вызвана функция vivod”

}

И при вызове этой функции в окошке cmd просто появится надпись.

Но если функция нам нужна для того, чтобы она что-то считала, то ей необходимо присвоить тип данных отличный от void. Но чтобы она что-то оставляла после себя, необходимо написать волшебную функцию: return(*что выводить*);

Приведу пример функции:

double zalupa(double x; double y)

{

return (x + y) / (x * y);

}

Тут я создал функцию с именем zalupa, с типом возвращаемого значения double, с параметрами X и Y, которые также имеют тип данных double.

При её вызове, введя параметры a и b, она оставит после себя выражение:

(a + b) / (a * b)

Как её вызвать?

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

zalupa(1.5, 2.5);

Рассмотрим, какие процессы происходят при вызове этой функции. Мы пихнули в переменную X число 1.5, а в переменную Y – 2.5 . Далее сразу вернули выражение(я сразу подставлю числа в переменные):

Т.е. эта функция превратится в значение чё-то примерно равное 1.067 .

Но при простом вызове нихуя не произойдёт, для того, шоб оно вывелось на экран надо её соответственно отобразить подобным образом:

cout << zalupa(1.5, 2.5);

Кстати, ещё необходимо отметить, что числа с плавающей точкой на то и числа с плавающей точкой, что они записываются как 2.5 и 1.5 а не 2,5 и 1,5 .

Ибо тут легко проебаться, запихнув в функцию нецелочисленный параметр,

отделив целую часть запятой.

Также функция может возвращать что-то через параметры. Т.е. если мы хотим, чтобы void нихуя после себя не оставил, но что-то изменил, можно написать следующую функцию:

void zalupa(double x, double& y)

{

y = x + y;

}

И при вызове этой функции с параметрами a = 1.5 и a = 2.5:

double a = 1.5, b = 2.5;

zalupa(a, b); cout << b;

В функции X станет равным 1.5, а Y = 2.5, следовательно Y будет равен сумме X и Y. А т.к. мы отметили Y как выходной параметр, написав после объявления типа параметра символ - &, то по итогу эта переменная изменится, следовательно, изменится значение b. Так что произойдёт с a и b?

Т.к. a у нас обычный параметр, то ему нихуя не будет, но параметр b записан с этой пердюлькой, то он изменится, и станет равным x + y, т.е. a + b. По итогу в cmd мы увидим значение переменной b, которое будет равно 4.0 .

Так как эту хуйню решать?

Ну вроде теперь понятно, как работает код и как его читать, перейдём к условиям задачи, к примеру возьмём эту:

И так, у нас есть функция fun (реально ржака), с типом void, т.е. она после себя нихуя не оставляет. Но кодер-пидарас мало того, что точку с запятой забыл после присваивания значения переменной а в мейне, так и написал там return;. Компилятор сразу выдаст ошибку, по этому поводу. Но если бы тип возвращаемого значения был допустим int, а точка с запятой всё же была, то мы бы получили иной результат – 8. Также стоит отметить, что все эти переменные – локальные, т.е. если z в функции равен одному значению, то в мейне он может спокойно быть равен другому. Попробуем прочитать корректный код:

Несмотря на то, что параметр z у нас объявлен со знаком & в 3-ей строке, это ничего не даёт, ибо этот z не изменяется в функции. В мейне мы задаём переменным x, y и z значения 23, 10, и 5 соответственно(10 стр.). И в той же последовательности пихаем их в функцию(11 стр.). Раз функцию мы

вызвали, и уже поняли с какими параметрами, то переходим к самой функции. На строке 5 мы видим, как эта функция сразу превращается в какое-то значение, которое равно z + x % y. Кста, % - это остаток от деления. Итого получаем: 5 + 23 % 10, что равно 5 + 3, т.е. 8.

Рассмотрим ещё одно задание:

Тут у нас функция proc, с входным параметром x, и выходным y. В ней создаётся ещё переменная z. К x и y прибавляется по единице, z

приравнивается сумме x и y. На первый взгляд становится непонятно, а нахуя вообще в функции переменная z? Она ведь никак не передаётся никуда, и

зачем она там всралась? А она там и не нужна, тут видимо проверка на знание глобальных/локальных переменных. Т.к. это z объявляется внутри функции, а не вне, то функцию мейна не волнует чему там равно это z в

предыдущей функции. Итого, что мы получаем? А то, что при запихивании в функцию proc на место x – 3, а на место y – 4, эта волшебная функция прибавляет к x и y по единице, и на место z записывает их сумму. Но выходной параметр у нас всего один, и это y. Следовательно эта функция в нашем случае просто прибавляет к y единицу. По итогу получаем при выводе x = 3, y = 5, z = 5, а их сумма равна 13.

Алгоритм у всех этих заданий один, нужно просто внимательно посмотреть,

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

Донаты принимаю через: https://www.donationalerts.com/r/presfy

На карту сбер: 4276380152017556

На карту тиньк: 5536914053979864

На eth кошелёк: 0x6bd1c95bf741f53844357487802cc61d9e750bce

Задание №2)

Довольно интересное задание, тут уже необходимо самому что-нибудь написать, но в отличие от лаб – придётся писать на листочке(9(. Это немного сложнее делать, нежели на компе, ибо листочек молчаливый, и сразу не скажет тебе, где у тебя ошибки, что хуёво.

Разберём для начала первую часть: нужно написать функцию, которая тупо вычисляет длину биссектрисы, да и так, чтобы эта функция была с типом void. Насколько вы помните, это функция сама хуй что вернёт. По сему необходимо будет объявить ещё один параметр, да ещё и возвращаемый,

дабы мы могли как-то записать и вывести ответ.

Следовательно для начала напишем объявление этой функции:

void biss(double a, double b, double c, double& dlina)

{

}

Ну замечательно, мы объявили пустую функцию с 4-мя нецелочисленными параметрами, один из которых выходной – double& dlina.Далее осталось написать тело функции, ибо длина сама не посчитается, для этого просто раскладываем формулу в строку, и приравниваем переменную dlina этому выражению.

void biss(double a, double b, double c, double& dlina)

{

dlina = sqrt(b*c*(pow((b + c), 2)-pow(a, 2)))/(b+c);

}

По итогу получилась примерно такая ебень, тут главное не запутаться в действиях и скобках. Напомню, что функция pow(a, 2) из библиотеки

<cmath> возводит первое число в степень равную второму числу, а sqrt(a)

находит корень из числа a.

Ну с первой частью всё понятно, а как решать 2-ю?

Судя по формулировке – требуется написать функцию main с вводом сторон,

и шоб программа 3 раза вызвала вышенаписанную функцию.

Ну для начала напишем:

int main()

{

}

Теперь самое сложное позади, далее добавим туда 3 переменных со сторонами, каждая из них будет с типом double. Затем 3 вывода просьбы о вводе сторон, и 3 ввода этих сторон. Но чтобы этот пендосский c++ понял,

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

int main()

{

setlocale(LC_ALL, "rus"); // <--Вот она double a, b, c;

std::cout << “введите сторону a: ”; std::cin >> a;