0: Скажи что-нибудь, да вот он тебя слышит.

1: Сюда вот пошло походу.

2: Угу. Славате, господи, давай сначала её запу или нет? Сейчас, подожди.

3: Так вот, я сейчас в рокете ещё дополнительно напишу. Все, она поменялась, поменялась. Давай запускай трансляцию, она уже идёт, уже видит. Вот они, мы там, видишь, уже есть.

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

5: Ничё, я буду твоим зрителем.

6: Сейчас я выйду в YouTube отдельно. Угу. И здесь с этой нет, вот это нет, с 1. Ну вот. А как ты shift п тогда на этот?

7: Вот.

8: Сейчас, подожди 5 минут.

9: Сейчас я выйду. Угу.

10: Скажи что-нибудь слышно?

11: Приём, приём.

12: Отлично. Ну че, уже 1 зритель есть помимо меня, а помимо тебя ещё 1 есть? Скажи привет, выруби, выруби звук.

13: Так, ну мне, в принципе, наверное, ничего не надо больше. Народ подтянется. Да. Че мне начинать? Давай сейчас 3 минутки хотя бы, чтобы людей собралось больше, чем 1. Ну, давай.

14: Потому что как бы

15: Можно, конечно, 1 на 1 устроить лекцию, но это как-то

16: Печально немножко.

17: На фан встречу никто не пришёл.

18: Ты озвучивай там эти, пожалуйста, ещё вопросики, если будут. Спасибо.

19: Все хорошо, не буду прекрасно. Ладно, буду знать.

20: Буду знать, может, петличку подальше поставить, или это не спасёт. Прекрасно. Ну ладно.

21: Никого нет, a1 человек только уже, уже двое подошли, уже двое подошли. Класс.

22: Не, ну в конце Концов, мне как-то коины то начислят за за лекцию, за запись, а не за, а не за количество людей. Это как бы их проблемы.

23: Думаю, лучше тебя вряд ли кто-то расскажет.

24: Ну.

25: В любом случае будет de запись, да, трансляции это, конечно,

26: Может быть, начало подрежь. Ну, понятное дело, да.

27: Давай.

28: Средство.

29: Будет, будет, да, будет. Да. Подходи, подходи. У нас просто по всем этажам прошёл, а я написала в этот, в rocket, что на 17, да, просто, да, то есть.

30: Людей почти не было, поэтому мы сделали так, что на naughty презе я со звуком я буду рассказывать, так что присаживайся через сколько минут. Нет сейчас. А уже да ну нет, людей, никто не пришёл вообще.

31: Ну, там 2 или 3 человека на трансляции. Нет, подожди. Трое, трое онлайн есть. Ура. Трое онлайн. Только не Лиза, Лиза. Так тебе видно. Хорошо, да, значит.

32: Добро пожаловать, друзья. 4. Меня туда видно, тоже видно. Дин. Могу сделать, чтобы было видно. Да не надо, наверное. Не надо. Ну все, тогда я укрупню, и все, тебя не будет видно. Не переживай, садись ближе.

33: Да, значит, друзья, добро пожаловать. Кто здесь присутствует в этот холодный декабрьский вечер на трансляции или физически меня зовут Лиза. Я сегодня эту лекцию проведу для вас про проект десимал.

34: Уже была 1 лекция проведена, она была посвящена в 1 очередь побитовым операциям. И сегодня на основании этой лекции мне бы хотелось вам рассказать про вообще, про структуру проекта, про

35: Особенности того, как вообще его писать про особенности функций, да, с которыми нам нужно будет работать.

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

37: Амальгаму, наверное, можно, так сказать, разных проектов, разных подходов, скажем так, вообще к тому, как этот проект можно делать. Ну, начать мне бы хотелось со структуры в 1 очередь.

38: С того, как у нас этот децимал должен выглядеть и с тем, как с ним работать. Вот у нас децимал, да, представляет из себя, по факту массив, из 4 интов, это, в принципе, про это говорили тоже на

39: Прошлой лекции. То есть здесь по факту видно, что есть вот часть, да, которая хранит просто целое значение. Да, и дальше есть 2 поля, которые нам интереснее всего. Это вот порядок, да, то есть это по факту степень

40: Десятки, на которую делится наше вот это вот целое число, хранящееся в мантиссе. И знак. То есть это положительное число или отрицательное объявление по факту выглядит очень просто. То есть

41: Это стракт, базовый массив из интов и подписать, что это decimal, чтобы не писать каждый раз стракт с 21 десимал используется тайпдеф, то есть как бы это довольно-таки базовая.

42: Конструкция значения дециму у нас могут быть от 2 в - 90 8 96 до 2 в + 90 6. Нет, вру от от - 2, то есть не отрицательная степень, а число.

43: Отрицательно. То есть 2 в 96 плюс минус самое, вот самое важное, да, что мы сейчас вообще можем покрыть, что называется, это посмотрели, можно идти дальше. Это вот основные проблемы.

44: Этого типа, с которым мы сталкиваемся, если вы вспомните предыдущую лекцию, или если вы знаете, то как хранится число float, ну, тип float, да, они значительно отличаются.

45: Тем, что в случае флоуд, да, когда мы используем, когда у нас есть число с плавающей точкой, у нас вот эта вот степень, да, порядок обозначается во 2 степени, а в децимал это в 10 из за этого, для

46: Конвертации float, например в decimal и обратно мы не можем просто биты скопировать, там будут другие операции применены и вот из за вот этого несоответствия степеней, то есть это 10 степень или 2 возникает довольно-таки много проб.

47: 2 особенность заключается в том, что у нас число можно представить одно и то же несколькими разными способами. То есть вот как я здесь, например, привела пример, что у нас

48: Число, например, 12 можно представить как 12, порядок 0 120, порядок 1 или 1200, порядок 2, и опять же, при сравнении чисел нам тоже надо об этом думать, что у нас числа могут

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

50: Это вот оверфлоу во время проведения операции, скажем, там умножения деления может возникнуть ситуация и очень легко, когда у нас просто не хватает места в нашем с 21 децл.

51: И вот следующее, как бы важнее всего сейчас обсудить то, как мы можем этот, с этой проблемой бороться. Сделай, Дим, ты кто тут презу следующий, следующий слайд сделайте.

52: Значит, наша команда не делала преобразования во временный тип. Из за этого мы сильно так-таки пострадали. Можно, как это назвал 1 из предыдущих лекторов, пойти, конечно, по пути само

53: И не использовать вот эту более простую конструкцию. Но я вам прям настоятельно это рекомендую сделать. Есть как бы 2 возможных представления, да, самых, вернее, 2 самых популярных представления децимал для

54: Проведение арифметики это big decimal, то есть это буквально тот же самый децимал, но у нас там в 2 раза больше интовый, ну то есть массив интов в 2 раза больше или binary code decimal, я не?

55: Буду сейчас уделять много времени. Байнери, худ, децимал это своя история, но там идея довольно-таки простая, что мы, у нас есть набор, скажем так, массив из из четырехбитных

56: Единиц. Они называются ниббл. И по факту в 1 из таких вот четырехбитных единиц хранится, хранится как бы разряд десятичной системы. То есть по хорошему, в 4 битах мы

57: Можем хранить там числа от нуля до 15 включительно, да, а мы их храним от нуля до 9. И если больше, мы переносим это как бы в следующий условно разряд. Этот метод, он очень удобный, как бы для арифметики, он более поня.

58: Понятный чем big децем и там побитовые операции, но я вот алгоритм конвертации вам толком объяснить не смогу. Я знаю как он работает, я не знаю почему он работает, я скину потом презентацию и там в самом конце

59: Будет ссылка на на binary децимал там в википедии и на классный видос, который объясняет как бы как этот алгоритм работает, но вот сегодня мы с вами сфокусируемся именно на big decimal в него и из него.

60: Очень удобно преобразовывать. То есть преобразование с 20 очень удобно, просто скопировал поля, и там оверфлоу проверяется легко просто, что части там интов, они не нулевые, но из за этого

61: Мы с вами будем разбираться с арифметикой в двоичной системе. Это будет весело, но я думаю, что мы с вами с этим справимся.

62: Значит, на следующем слайде у нас, собственно, представлены самые вот такие базовые функции для работы с с неё, который вам надо написать в 1 очередь, вот этот вот

63: Набор функций, да, там 6 штук, которые подписаны как привет от ооп. Это вот самое базовое и самое важное. То есть у вас есть 3 поля, да, это знак масштаб, ну, этот порядок и, собственно,

64: Говоря ваша целая часть, и вот на это у вас есть по функции 1 из них, то есть это get sign установить какой-то знак, то есть get sign, получить знак сет сайн, поставить какой-то

65: Тоже самое с порядком внутри, понятно. Должна быть там проверка какая-то, что значение там знака и порядка валидные. Вот эта вся история дальше вот то опять же, то на что

66: Мы наткнулись то, на что я наткнулась, когда это писала Гетт бит и сет бит. Я опять же рекомендую сделать так, чтобы у вас 1 функция брала бит, то есть не из 1 чисто числа интового, а из всего.

67: Потому что вам тогда не надо будет думать, где там этот бит находится. Вы просто говорите, окей, у нас есть номер бита, там, где 0, это, например, единица, да, там чётное нечётное число. И поехали дальше по увеличению, мы получаем вот этот вот номер и

68: Исходя из него, мы узнаем, собственно говоря, а какой это beat, то есть что там стоит единичка или нолик мы сделали так, что у нас был в in, то есть просто извлекался бит из Инта и потом жонглирование и поиск того, где этот

69: Вот beat находится, отнимало очень много как бы строк кода, условно говоря.

70: Вот, ну и, собственно, в самой верхней функции из zero.

71: Хочу сказать, что 0 это любое число. То есть, если вы 0 делите на 10 в любой степени, это все равно 0. Поэтому, если вы проверяете на 0, тоже надо про это помнить.

72: Так, теперь давайте, собственно говоря, сейчас самая будет тяжёлая часть. Это арифметика.

73: Вот здесь вот слайд описывает чисто вам, чтобы вспомнить про побитовые операции. То есть у нас есть здесь список базовых операций, то есть это и или

74: И сдвиг влево, и сдвиг вправо. То есть побитовые операции у нас применяются чисто к битам. То есть если мы делаем побитово, и то у нас идёт как бы сравнение каждого бита. Я не хочу сейчас много времени этому уделять, просто вот заскриньте условно, если надо, этот

75: То, что вам пригодится очень дальше, когда мы будем разбирать, собственно говоря, как эту операцию проводить. И ещё 1 комментарий важный, который нам пригодится дальше, что если мы смещаем число влево, то мы умножаем число на 2, если мы

76: Смещаем число вправо, мы делим это число на 2.

77: Это нам понадобится при там, при арифметике очень даже, ну и в правом столбце там есть 2 таких наблюдения, которые вам может дальше пригодиться при работе с другими функциями.

78: Но вот, собственно биг децимал нам нужен в 1 очередь ради арифметики, потому что если мы, например, умножаем число 2 в 96 на 2, в 96, мы вылетаем сразу за границу.

79: Может там быть ситуация какая-то там, где непонятно, выйдем за границу или нет, вот чтобы с этим, чтобы про это все не думать, мы просто помещаем вот числа, которые нам надо, над которыми надо провести операцию в big Дец.

80: И потом мы с вами, то есть мы с вами напишем 4 функции, да, которые, ну, по крайней мере, обсудим 4 функции, да, арифметических, то есть это сложение, вычитание, умножение и деление, причём

81: Не обязательно. Если вы будете вызывать функцию как бы с 21 сложение, вы будете вызывать побитовое сложение. Если у вас, например, будет сложение чисел разных знаков, то это будет как бы побитовое вычитание. Вам тоже надо будет про это подумать.

82: Мы с вами поставим просто набор условий на вот эти вот побитовые операции, чтобы их внутри там не обрабатывать, а потом вы сделаете там обёртку, как вам уже надо. И, соответственно, потом вот вы эти условия выполнили.

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

84: С добавлением условия, что 1 число должно быть больше 2 и в побитовом делении нам просто надо убедиться, что 2 число не 0, чтобы там не возникало, не возникало тоже дальнейших проблем.

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

86: Просто можем по факту отдельно, условно умножить числа и отдельно умножить их степени, то есть просто сложить и тоже самое как бы с делением. То есть мы можем отдельно поделить числа и потом отдельно поделить их степени.

87: Вот, значит, здесь у нас есть с вами побитовое сложение, да?

88: Давайте начнём с такой базовой формулы. Мы, я тут сразу уже написала это на big демо.

89: Вот у нас есть начнём просто с простого цикла for, да, то есть мы проходимся по всем битам с младшего к старшему, то есть от единиц и дальше там по возрастанию. И мы проверяем. Окей, сложим бит.

90: Что получится. То есть вот у нас есть результирующий бит, и мы берём как бы его остаток от деления на 2. То есть буквально будет ли у нас вот в этом значении 0 или единица и ставим этот бит

91: Какая у нас здесь? Чего у нас здесь не хватает?

92: То есть?

93: Мы здесь, посмотрите, мы как бы складываем биты, и мы берём остаток отделения, но мы не проверяем, переходит ли у нас бит как бы в следующий разряд или не переходит. То есть если мы с вами сложим 1 + 1, у нас с вами получится 0 чудеса арифметики. Это надо

94: Править.

95: У нас с вами появится некоторая переменная, которая называется мемо. То есть это память некоторая, да, она будет хранить в себе. Было ли, как бы было, перешёл ли в следующий разряд или не перешёл, было ли переполнение, да, по факту, по факту.

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

97: Ага, то есть, в принципе, сейчас функция написана. Ну, давайте сделаем чуть получше. Условно говоря, мы можем сделать границы через сайзов, то есть сайзов.

98: Определяет размер типа вот у нас есть тип биг децимал, да, у нас там 8, то есть это массив из 8 интов. Если мы возьмём размер биг децимал и разделим его на раз.

99: Его как бы единиц. То есть это unsigned. Мы получим количество условно, размер массива, да, и - 1 из с учётом как бы того Инта, где там хранятся у нас порядок и zack, это вот

100: Но улучшение, которое мы можем сделать.

101: А, ну, собственно, вот и все. Тут особо делать то больше нечего. Сейчас следующее, что я хочу сделать. Да, вопрос. Знаки чисел мы тут не использовали никак.

102: Нет, в том-то. Вот и дело, что мы с вами обозначили. Сейчас мы с вами обозначили, что у нас знаки одинаковые. На потом ложении все и степень одинаковая. Мы обозначили это.

103: С самого начала мы сказали, что все у нас одинаковый порядок, у нас одинаковый знак. Если у нас разный знак и сожжения, это будет побитовое вычитание. Потом я скажу, вот сейчас мы поговорим про ошибки, я скажу о том, как свести порядок к 1 значению.

104: Это будет чуть дальше сначала нам надо поговорить про шифт значит шифт прекрасная операция то есть сдвиг он делается на вот 1 beat довольно-таки легко ой на 1 на 1 int то есть вот

105: Вот по факту все, что вам и надо, да, и вот здесь как бы идёт отметка, что есть ли у нас вот, вот эта операция по факту позволяет нам понять было, был ли у нас оверфлоу или не было, но вот сейчас

106: Вот этот код написан только для 1 Инта из всех там 8, которые у нас есть. Давайте это исправим.

107: Заведём опять же, ту же самую переменную мемори, и она будет хранить в себе, был ли вот этот сдвиг или не было. Вот мы заведём мемори и сделаем тоже самое, что сделали в прошлый раз. То есть

108: Мы сдвигаем число на 1, мы сохраняем в memory, то как бы overflow который у нас получился да и повторяем тоже самое для

109: Для всех дальнейших ячеек, то есть это 1, 2, 3 и так далее. Но дубликация кода, оно выглядит сейчас очень грустно. То есть у вас здесь то там написано условно 3 блока, а их там должно быть ещё 4, 4 штуки, чтобы все вот эти вот Инты покрыть.

110: Поэтому надо это получше написать. Напишем это через цикл.

111: Мы с вами знаем, что у нас интов 7 штук.

112: Вот этих вот как бы интовый ячеек, поэтому мы опять же у нас есть unsigned temp, то есть мы временно кладём значение, да, которое у нас лежит в итом, в итом элементе массива.

113: Мы сдвигаем массив, мы сдвигаем вот этот сори, мы сдвигаем вот этот инт на 1. В нашем случае мы добавляем мемори, который остался с предыдущего, как бы с предыдущей операции и затем

114: В memory кладём новое значение. То есть это то, насколько у нас случился оверфлоу в при проведении вот этой вот операции.

115: Вот, вот это вот сейчас словили. Давайте замедлимся. Несколько. Есть вопросы сейчас по вот этому шифту.

116: Пока нету. Когда, когда мы тебя потеряли на 1, ты говори, если есть вопросы, у тебя есть как это приоритет задать лектору вопрос лично.

117: Да, прерогатива.

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

119: Мы здесь с вами на самом деле обсуждаем общие как бы стратегии работы с вот этим вот децелом. То есть когда мы с вами говорили, вопрос там какой-то нет, я, я правильно понимаю, что shift мы используем для того, чтобы

120: Все число на 1, да, да. То есть сейчас то, что мы сейчас говорим, да, нам нужен шифт для того, чтобы умножить число на 2, на на какую-то степень и разделить число на какую-то степень двойки.

121: Дальше нам эти степени двойки очень пригодятся. Мы Любим степени двойки, мы хотим уметь с ними работать, и они очень как бы удобно обрабатываются на побитовых операциях. И вот когда мы говорили с вами про

122: Сложение там как раз-таки описывается то, как пройти по всем битам. То есть вы можете взять вот этот вот условно цикл и разобрать. Окей, вот мы можем вот таким вот образом пройтись по каждому биту.

123: Shift позволяет нам проходиться по каждому. Ну, это вот разговор про

124: Да, то есть это по всем вот этим вот кускам биг децима, условно говоря, и потом вам это же понадобится. То есть вы просто циклом как бы проходитесь по всем ячейкам, если это нужно, да, то есть не потерять биты, чтобы они переходили из 1 в другой.

125: Вот эту вот проверку. Ну да, то есть вот здесь очень важно не забывать про memory, то есть про то, что нам надо сохранить то, насколько случился вот этот сдвиг. То есть изначально мы задаём его как 0 потом

126: Мы временно кладём туда, у нас есть временная переменная, куда мы кладём битс 0. То есть вот 0 элемент массива, да, массива наших интов. Нам нужно это потому что когда мы

127: Будем сдвигать число, мы априори вот эти вот мы оверфлоу вот этот потеряем.

128: То есть, когда мы делаем шифт, мы просто, мы сдвигаем и вот эти числа они улетают.

129: Поэтому нам нужно сохраниться в темп, а потом в memory мы как бы сдвигаем. То есть мы сдвигаем на 32 - 1. То есть мы сделали сдвиг влево на 1, а чтобы сделать сдвиг, чтобы получить вот оверфлоу нам

130: Надо сдвинуть на то же самое расстояние. Ну как бы нам надо сдвинуть вправо, то есть отрезать вот этот кусок, который у нас остался, и это будет как бы 32 - 1.

131: Вот, и, соответственно, здесь у нас по факту циклом мы проходимся по вот этим 7 штукам, по вот этим 7 элементам, которые у нас есть в big децу можно было сделать 6, но мне кажется, что

132: 7 будет лучше для ну то есть там будет минимальная работа с overflow нашего типа big decimal, то есть у нас не будет проблемы, что за у нас прям границы, ну то есть вообще ничего не останется совсем места для вот этих вот.

133: Для memory. То есть что мемери какой-то улетит?

134: Вот мы проходимся по 7 элементам массива, из которых состоит биг. И мы делаем буквально тоже самое временно сохраняем элемент там итый элемент массива, да, делаем сдвиг.

135: И пририсовываем самое важное, вот этот вот memory, который был с предыдущего шага. То есть изначально он 0, а вот с предыдущего шага, он там какой-то остался, этот сдвиг. Окей, мы его как бы дописали и соответ

136: Дальше сдвинули мемори, как бы получили вот это overflow, да, я же правильно понимаю, что если у нас в том Инте в самом 1 крайнем правом

137: На краю Инта, когда мы сдвигали его влево, у нас там уже слева стояла какая-то единичка, чтобы нам просто её не потерять, мы её переложили таким образом. Следующий, ну, по факту, да, то есть мы, когда мы делаем шифт, мы теряя

138: Биты автоматически, чтобы этого не было, чтобы этого не было. Мы используем переменную мемори, она нам очень, очень нужна.

139: Вот здесь можно также красиво это написать через сайзов. Почему через сайзов? Это вы можете вот этот вот это сводит хардкодинг к минимуму.

140: Вы можете этот тип, например, если вам надо пройтись там по всем элементам, типа decimal, а не big decimal, вы в этом вот цикле фор заменяете просто типы, то есть вы заменяете биг децимал на decimal и все.

141: И у вас получается как бы цикл на вот эти вот 3 элемента, то есть в этом как бы плюс сайзов это для красоты в какой-то мере. То есть в принципе, вот shift был написан на вот этом шаге, когда

142: Мы зафиксировали там, что у нас 7 элементов, все шрифт, в общем то написан. Сейчас мы его делаем, добавляем ему художественных элементов.

143: Вот ту ту ту ту ту ту ту ту ту ту ту ту что дальше, дальше.

144: Дальше следующая очень полезная функция, которую мы с вами можем сделать, добавить к нашему шифту это добавить то, насколько он сдвинется это переменная, которую я назвала шифт велью, то есть вот здесь вот мы с вами писали, что shift

145: До единицы, да, то есть shift shift на единицу.

146: Помните, да, что вот здесь вот было написано как бы 1 и 32 - 1. Мы можем, в принципе, взять любое число, тут не будет это хорошо работать для чисел больше 32.

147: Там будут проблемы, но для наших нужд в общем то там 1 3 и хватит, нам больше особо ничего не надо. Ну вот у нас есть shift велью, да, какое-то значение, то есть просто int, который мы передаём, надо

148: Проверять кстати, хорошая мысль проверять, что он не отрицательный, нам подаётся, потому что отрицательный шифт я, честно говоря, не знаю, как будет выглядеть, то есть, если shift - 1, я, я понятия не имею, что там произойдёт, он может на вас сильно ругаться.

149: Вот, и здесь по факту мы делаем тоже самое, тот же самый сдвиг, но просто на другое значение и здесь будет как бы 32 минус. Вот это вот значение, на которое ты сдвигаешь.

150: Вот, значит, вопросы по шифту.

151: Это такая обскурная довольно история, но она нам нужна будет дальше для нормализации. Ну то есть дальше для работы с порядком. По факту многие, я видел, побиты в операции с 1 ментом, завязаны на том, что

152: Мы двигаем число влево и мы можем эту схему применять на БИК. И если мы весь БИК демо будем двигать влево, да, то есть вот сейчас то, что мы сейчас с вами сделаем, мы определяем как бы инструменты. Вот этот shift нам понадобится дальше для

153: Для работы с числами, то есть для арифметики, нам нужен шифт.

154: Нам очень нужен шифт и 1 применение шифта, которое, о котором мы сейчас с вами поговорим, это нормализация. Что значит нормализация? Это приведение к 1 масштабу.

155: Вот, мы, мы умеем, да, например, сравнивать числа, да, мы можем складывать числа или там вычитать, если у них один и тот же порядок, если у них порядок разный, то как бы сказать что-то про них сложно. Вот непонятно, например.

156: Например, как бы, как сравнить вот эти вот 3 числа, как бы, кто из них больше, кто из них меньше, вообще непонятно.

157: Поэтому нам надо как-то их привести к чему-то, как бы, то есть нам надо как бы 1 к 1 порядку свести, да, к 1 скейлу это напоминает немножко при, знаете, при сложении, вычитании дробей, при

158: При сравнении дробей вам нужен 1 знаменатель, чтобы эти дроби сравнить. Тут тоже самое. У нас просто дробь идёт с делением, как бы в знаменателе. У нас там степень десятки, то есть там 10, 100000 и так далее.

159: И нормализация нам нужна и как бы для арифметических операций и для сравнения больше она по моему нигде не пригождается, поэтому мы можем спокойно делать её тоже на big decimal.

160: И тогда она делается очень просто. У вас есть 2 числа, да, с разными масштабами, с разным порядком скейла. Вы можете 1 из этих чисел?

161: Умножать до 10, пока их порядок не сравняется.

162: А умножение на 10 это операция, которая очень легко раскладывается на базовые побитовые, на базовую побитовую арифметику.

163: То есть умножение на 10 мы можем представить так, что это как бы число, умноженное на 8, плюс число, умноженное на 2, да, то есть 2 и 8, 2 прекрасные степени двойки.

164: И мы с вами вот буквально на прошлом слайде разобрали как раз-таки инструменты, как нам удобно перемножать число, как нам удобно переумножать число на степень двойки. Вот мы с вами этот шифт, который нам нужен вот здесь вот мы его написали.

165: Соответственно, вот вам было описано вот эти вот 2 инструмента побитовое сложение и shift на нём, на вот этих 2 инструментах пишется и умножение тоже умножение на 10.

166: Вот, соответственно, как бы берете число, как бы сдвигаете его на 3, складываете его с тем же числом, сдвинутым на 1. Все у вас число умножено на 10.

167: Да, там вопрос какой-то есть первых парах нам нужно делить на 10 или нам нужно? Нет, деление на 10. Кстати, вам писать не надо. Если бы вы писали, например, без преобразования, типа, то тогда, может тогда вам понадобилось бы деление на 10 также.

168: Красиво деление. Деление на 10 не пишется у нас, опять же, мы писали вот это вот деление на 10, оно пишется просто как деление, я не знаю там красивых инструментов, но оно вам не надо, вам достаточно умножения.

169: И это умножение, ну, нам нужно чуть ли не исключительно для нормализации.

170: Вот в общем то к этой стадии у вас должно быть уже написаны базовые функции для работы с decimal и big decimal, это то есть set by set get, beat, сет и гет?

171: Scale и set и get sign. То есть знак это вот этот вот как бы набор у вас должен быть написан. Дальше у вас должно быть написано побитовое сложение и побитовое вычитание, они пишутся абсолютно одинаково.

172: Исключением знака вам очень нужен будет shift. То есть вот этот смещение влево вам. Я не помню, кстати, надо ли смещение даже вправо или не надо.

173: По моему, не надо, но, что называется, не цитируйте это и вот нормализация.

174: По моему, честно говоря, шифт права не нужен. Ну, если нужен будет, ну, если нужен будет, мы посмотрим. Но вот, по моему, нет. Смысл такой же, да, он по смыслу такой же, да, то есть это вот только в случае деления там смысл сильно поменяется.

175: Так вот, теперь давайте посмотрим. Сейчас начинается прям весёлая часть умножение.

176: Значит, вот, кстати, хочу ваше внимание обратить на вот эту вот запись.

177: Вы можете вот так вот в побитовом виде представлять числа для си, и это будет как бы понято. То есть вы пишите, например, вот это вот побитовое представление десятки. То есть вы пишите 0 английскую b и, да?

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

179: Побитовое умножение основано по факту на самом как бы базовом, на том же самом умножении, которое мы учили все в школе, как бы умножение столбиком по факту.

180: То есть вот здесь вот, да, я выписала, как это, собственно, умножение будет выглядеть. Нам удобнее работать с умножением немножко в другом виде. То есть мы можем, в принципе, вот так вот Написат.

181: Да, то есть мы берём условно, каждый раз мы просто умножаем число. Вот здесь у нас стоит, например, 0, да, окей, умножаем наше число на вот этот 0. То есть это просто нули дальше следующее со сдвигом 1 у нас идёт

182: Окей, умножение на 1. Значит мы пишем число. Дальше мы делаем сдвиг на ещё 1 и умножаем число на вот этот бит, который тут стоит, это тут бит 0.

183: Ага, значит тут все нули и дальше вот здесь у нас идёт, берём следующий бит, он единица, значит, мы выписываем вот это вот наше число, которое стоит как бы 1 со сдвигом 3, то есть

184: Тоже самое нам здесь удобнее, чем условно в десятичной системе, потому что нам не надо как бы умножение самого числа проводить. Мы либо записываем все нули, то есть мы ничего не прибавляем, либо мы берём наше число, которое сдвинуто на сколько-то

185: И все, что давайте мы с вами сейчас сделаем это немножко в обратном порядке. Это будет удобнее для просто базового, ну, для написания функции это будет удобнее, то есть

186: Нам как людям считать? Столбиком класса супер, а вот в коде чуть чуть покрасивее будет выглядеть, если мы пойдём в обратном порядке, давайте мы посмотрим на собственно 1 ну вот давайте так, последний бит десятки.

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

188: И мы сдвигаем наше число на 1.

189: То есть дальше мы смотрим. Окей, у нас есть нолик.

190: Значит умножение нуля на наше число мы делаем + 0, но + 0, как бы плюс ничто по факту и мы делаем снова сдвиг на 1 по факту. Теперь у нас вот, вот это число сдвинуто уже на 2

191: Вот помните, да, что вот умножение, как бы, вот 1 бита, 1 бита, десятки у нас должно быть сдвинуто на 3. Вот давайте мы посмотрим, сдвинется оно на 3 в итоге или не сдвинется. То есть мы 1 умножили на число, прибавили.

192: Сдвинули влево. Дальше смотрим следующий бит 0 умножили на наше число + 0 сдвинули на 1 влево. Смотрим следующий бит. Окей, это единица. Значит, мы прибавляем наше число.

193: Снова, то есть 1 число прибавляем и сдвигаем на 1 снова.

194: И смотрим на последний бит, там будет + 0, значит, ну то есть там прибавлять особо ничего не надо. И вот у нас получилось, что мы сделали как бы 3 шифта. 1, 2, 3.

195: По факту мы с вами сделали вот все вот эти вот операции в обратном порядке.

196: То есть сначала мы прибавили вот это число, потом мы прибавили вот это число, потом мы прибавили вот этот вот это число и вот это число. То есть нам удобнее как бы людям писать от наименьшего шифта к наибольшему, а на компьютере, мне кажется, ну вот в коде

197: Красивее будет, если будет от наибольшего шифта к наименьшему, потому что мы можем просто все число сразу двигать, вместо того чтобы прибавлять и двигать как бы каждый раз на сколько-то.

198: Значение вот наше число.

199: Вопросы. Давайте тут остановимся и зададим вопросы, если они есть.

200: Почему так сложно? Вот тебе вопрос. Можно ли нам без побитовых операций сделать какие-то преобразования? То есть, допустим, сделать сначала все операции 1 винтом, обычным способом, потом обновить

201: Сделать с другими.

202: Не, в теории можно. Простите, простите, простите, аудио, простите, петличка, в теории можно сделать что угодно, но смотрите, просто вот здесь мы с вами написали, вот мы с вами написали уже 2 инструмента, которые нам нужны. Это сложен

203: И shift.

204: Вы разбираетесь с этими и дальше в умножении используете их как бы по хорошему. У вас эти инструменты уже есть. Почему бы ими не воспользоваться? Вы можете их собрать снова заново. Почему, если вы захотите, я вас остановить не смогу. Мы же можем, например, написать

205: Алгоритм, который ты написала, да, не для. И сначала для обычного Инта можно, а потом применить уже всю логику. То есть, подожди, ты предлагаешь, я говорю, что в теории

206: Мы можем найти этот же алгоритм и для обычных винтов, а потом переписать его для, да, те же действия. Да, да, да, да, да. У нас будет другой shift, конечно, да, то есть это можно вполне сделать. То есть сначала вы можете, конечно, написать

207: Это для Инта спокойно, спокойно убедиться, что оно работает, и потом переписать его на big децел, используя те инструменты, которые у вас есть, просто вы заводите вот себе 2 функции сложение и shift и потом.

208: Когда вы меняете тип, вы меняете эти функции и все, а это действительно ты прав, что для отладки это будет проще, то есть сначала убедиться, что оно работает, а потом уже используя наши инструменты, это перевести на big дециму.

209: Вполне можно сделать так, да.

210: Ну, в любом случае, я вам презентацию скину. Если, если есть какие-то вопросы, дальше ещё можно мне написать либо в рокете, либо найти меня в школе, я тут тоже вожусь иногда.

211: И как бы вопросы задать мне можно будет лично тоже, в случае чего. Так, деление, друзья мои, это сейчас вот кульминация самая сложная часть после.

212: Этого все будет проще после. То есть это у нас самая такая, самый, самый тонкий момент.

213: Побитовое деление, операция довольно-таки сейчас ты расскажешь, там, закрыла лицо, ну, изображение закрыло этот, как его понятно. Ага. Значит,

214: Битовое деление это операция, которая будет использовать все наши предыдущие инструменты. Вот здесь вам надо будет запомнить про вам. Здесь. Видите, здесь уже есть у вас вычитание.

215: Вот это вычитание вам надо будет уже к тому моменту написать. Вот, значит, давайте, видите, значит, у нас есть вот эти вот блоки, да, которые, то есть я

216: Я здесь как бы отвела 3 разных блока справа, вот здесь вот я описала то, как это как бы будет выглядеть в виде Столбиков, да, и сразу хочу сказать, что этот алгоритм я взяла сле.

217: Лекции москвича, которая была, я не помню, честно говоря, его nick, которая где-то месяцев 9, наверное, назад была идея та же самая, то, что здесь происходит, это просто в побитовом виде деление столбиком.

218: И у нас с вами вот эта вот функция деления столбиком, она

219: Должна несколько, скажем так, у неё есть несколько важных элементов.

220: Во первых, вам надо подавать туда, то есть у вас результат будет состоять на самом деле из 2 чисел у вас будет, собственно, ваш результат, да, то есть это вот что мы с вами считаем.

221: И у вас будет остаток отделения, то есть вспоминаем обычное школьное деление столбиком у нас с вами, то есть мы с вами не можем уходить в точку, да, мы не будем уходить.

222: Вот в эти вот знаки у нас чисто целочисленное деление. Вот 1 вот. И нам надо написать 1 функцию деления, которая

223: Будет как раз-таки возвращать и остаток и результат. Это, кстати, вам понадобится, когда вы будете писать мод, там же у вас, знаете, у вас там есть функция деления с остатком. Вот уже убрали, убрали, да, вот убрали. Какая же

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

225: И алгоритм как бы обычного деления столбиком мы с вами смотрим. Окей, у нас есть число максимум мы можем сдвинуть на 2, да, вот сдвигаем число наше.

226: Минус там - 1000 со сдвигом в 2 остаётся остаток 10, 10, меньше 1000.

227: Значит, в результате у нас остаётся с вами результат, да, 100.

228: То есть наш результат с вами будет 100, потому что-то есть давайте вот это ещё раз точнее обсудим значит мы берём нашу 1000 да, мы максимум можем сдвинуть её влево на

229: Вот сдвинем её по максимуму.

230: Вычтем. Да, мы сдвигаем влево до тех пор, пока оно не стало больше, чем верхнее число. Ну,

231: Пока оно не стало максимальным числом, которое меньше левого числа. То есть у нас все-таки при вычитании мы с вами помним, что у нас 2 числа должны быть. То есть 1 число должно быть меньше, должно быть больше 2.

232: Обязательно. То есть мы сдвигаем 1000, то есть мы не можем сдвинуть на 3, потому что тогда результат будет больше, чем, собственно, число, на которое мы делим, мы сдвигаем пока вот это вот делитель меньше.

233: Чем делимое мы сдвигаем и мы вычитаем

234: У нас остаётся с вами, значит, вычесть нам удалось, поэтому мы пишем единицу в ответ. Это, это остаток, это, это пока что это не остаток, это наш результат.

235: Вот в результат мы пишем единичку и мы этот результат сдвигаем, потому что у нас осталось. То есть у нас остались ещё сдвиги ууу, 1000, которые, которые мы как бы делаем, сдвиги у нас остались, значит, мы

236: Сдвигаем на 1 дальше. Если мы сдвинем 1000 на 1, то есть мы возьмём как бы по факту сдвинем на 1 вправо.

237: То у нас число будет все равно больше 10 мы не можем вычесть, поэтому мы пишем 0 в результат.

238: Поскольку у нас число 1000 ещё на сколько-то сдвинуто, мы сдвигаем результат влево.

239: Дальше смотрим. 1000 у нас будет все равно больше, чем 10.

240: Поэтому результат у нас в результат мы дописываем 0.

241: И мы не сдвигаем, потому что мы как бы додвигались есть мы, то есть 1000 мы вернули на место.

242: Давайте повторим тоже самое, но теперь для следующей части вот у нас остался, как бы вот у нас осталось число 10, да, это по факту, кто у нас там 4.

243: Мы умножаем его на 10. Вот у нас есть число, да, которое нам надо посчитать. Сколько у нас будет вот это вот 10000, 100, разделённое на 1000.

244: Сколько это будет? Давайте смотреть максимум. Мы можем сдвинуть нашу 1000 на 1, потому что если мы сдвинем на 2, там уже будет 100000, а 100000 больше чем 10100, это не вариант.

245: Значит, мы сдвигаем 1000 на 1, и мы можем вычесть 1 раз. Окей, мы вычитаем в результат, мы подставляем единицу, поскольку у нас 1000 ещё сдвинута на сколько-то.

246: Мы 1000 сдвигаем вправо на 1, а результат сдвигаем влево на 1.

247: И делаем следующую проверку. Значит, у нас 100 все равно меньше 1000. Поэтому в последнем разряде минус человек у нас это в последнем разряде остаётся все равно 0.

248: То есть мы не можем там ничего написать. Это, это грустно. Я понимаю, это грустно и непросто, но я в вас верю, вы справитесь, это

249: Обязательно. Да, обязательно вы справитесь. Я в вас верю. Побитовые операции они напишите просто тоже самое для обычных, для обычных чисел. Конечно, напишите тоже самое для десятичных чисел.

250: Здесь по факту вот это вот умножение, там, ну вот деление в столбик, как бы разницы там нет особо, что десятичный это вид или двоичный. Ну просто мы делим все числа, которые там, там одни единицы, одни десятки, ну, в смысле одни.

251: Единицы и нолики. То есть там просто нет у нас других цифр. Это ж по факту тоже самое обычное деление, которое мы с вами знаем. Такое же деление столбиком. Это абсолютно, это абсолютно такое же деление столбиком. То есть они могут сначала написать для обычного числа

252: Потом, конечно, конечно, вы можете даже ручками это деление столбиком написать.

253: Сначала вы пишите просто ручками на листочке, в тетрадке, там ещё где-нибудь то, как это деление столбиком выглядит.

254: И пытаетесь его разобрать под алгоритм. Здесь я вам по факту, когда, когда вы чуть лучше будете как бы чувствовать этот алгоритм, вы можете вернуться к вот этой табличке. Вот в этой таблице просто описаны все операции, которые вы проводите.

255: Чувствовать хорошее слово. Ну вот, да, на самом деле это надо просто прочувствовать немножко, чуть чуть больше понимать, потому что руторе сейчас это сложно, если совсем не понимаешь, как деление делать. Я правильно? Да, что пока что

256: Только целочисленное деление. То есть мы целое число делим на целое получаем. Вот смотрите, самое то, что интересное, что это просто целочисленное деление, да, но каждый раз, когда мы применяем вот эту вот операцию, да, когда мы

257: Берём остаток, умножаем его на 10 и продолжаем дальше считать. У нас с вами увеличивается порядок.

258: И наше число по факту тоже должно увеличиться на 10, вернее, ну, в 10 раз. Вот посмотрите, вот здесь вот запись, да, которая есть у нас с вами было 3 деления, да, у нас с вами было деление.

259: И деление 2 как бы остатков, которые получилось при, ну вот при нашем делении. То есть всего мы эту функцию применили 3 раза, значит, у 1, как бы у 1 результата.

260: Как бы его мы умножаем на 100. То есть это

261: Как бы умножение на 10 дважды помните нормализацию, умножение на 10, оно вам здесь тоже понадобится. То есть у вас есть вот этот результат, вы умножаете его на 100, потом вы

262: Господи, нет, у вас есть вот этот результат 100, вы умножаете его на 10, как бы во 2 степени, то есть это, ну, 100 технически он немножко по другому выглядит. Потом вернись, потом мы берём как бы следующий результат. Вот.

263: Этот результат умножаем на 10 в 1 степени и потом мы берём, складываем вот этот результат. Тоже самое, как если бы мы с вами писали это для для десятич.

264: Как бы системы исчисления, то есть, например,

265: 36 / 5. Да, вот мы делим 36 на 5. У нас будет, получается, результат будет 7. Да, остаток будет 1. То есть это будет 35.

266: И 1. То есть результат у нас будет 7. Остаток будет 1, 7 целых пятёрок. И 1 не целая, да, 7 целых пятёрок, и 1 не целая. Дальше мы вот эту вот единицу, нам надо с ней что-то делать, мы умножаем её на

267: Она становится десяткой и дальше. Значит у нас с вами масштаб, порядок увеличивается на 1. То есть это будет по факту 7. То есть у нас будет в целой части, будет 70 в порядке будет 1.

268: Но это все ещё 7. Просто помните, как я в начале лекции говорила, что это у нас одно и то же число может представляться несколькими возможными вариантами. 70 делённое на 10. Это тоже самое, что просто 7 70, конечно, 70, делённое на 10.

269: Это тоже самое, что 7 делённое на 1.

270: Так вот, у нас остался с вами вот этот вот остаток 1. Мы умножили его на 10 и дальше делим на 5, продолжаем наше деление, продолжаем наше деление. Да, здесь мы нацело теперь можем поделить. То есть это будет 10 / 2

271: Ой, 10 / 5. Это будет результат 2. Значит, мы этот результат прибавляем. То есть у нас в целой части останется 72 в порядке у нас будет 1. То есть это 72 делённое на 10 72, делённое на 10 д.

272: Важный комментарий по поводу деления, что вы есть, знаете вот эти числа, которые называются периодичными дробями. Вот вы можете в какой-то момент все равно это вот единственная функция, в которой вы можете

273: Улететь в оверфлоу при использовании биг десмо.

274: Поэтому за этим внимательно следите. То есть вы можете в какой-то момент просто попасть в в цикл, да, вы сдвигаете число, вы делите, вы получаете абсолютно такой же результат, тот же самый остаток, и у вас получается как бесконечный цик.

275: Поэтому вот это единственная функция, где вам надо следить, чтобы не произошёл overflow.

276: Именно вот в течении её исполнения, по факту здесь у нас будет с вами как бы 2 функции. У нас будет 1 функция, которая деление с остатком. То есть это выделение результата и выделение остатка от деления. И потом у нас

277: У нас будет функция, которая как бы вызывает постоянно вот эту вот функцию деления с остатком до момента, ну, пока мы либо не достигли остатка, равного нулю, либо пока мы не достигли оверфлоу, то есть

278: Это вот как бы будет 2 условия стопа.

279: И каждый из вот этих вот как бы блоков, это по факту 1 вызов вот этой вот функции деления на на число с остатком.

280: Вот, значит, посмотрите на это ещё минутку, впитайте, и потом у нас будет все остальное уже проще. Разберитесь. Вот главное с вот этими побитыми операциями. Все остальное уже проще.

281: Значит.

282: Сейчас я хочу с вами обсудить немножко про конверторы, то есть конвертация в из типов.

283: Значит, конверторы у нас, нам нужно там 4 штуки конверторов всего лишь

284: И они пишутся, в общем то довольно-таки очевидно, здесь не написаны конвертеры из и в big decimal я думаю, что вы тоже справитесь, там идёт чисто копирование интов.

285: Значит.

286: From то есть в конвертерах вам нужно будет в каких-то местах просто проверять

287: Ну вот в случае конвертации из и в int вы просто проверяете что у вас нет как бы

288: То есть когда вы из decimal конвертируете в int, вы просто проверяете что у вас не все что у вас не заполнены битс 1 и 2, то есть что у вас нет не стоят значения там где у Инта занято как бы где у beta.

289: У Инта просто места нет.

290: Кстати вот важно отметить, что когда вы конвертируете из децил в int, вы отбрасываете дробную часть, отбрасывается она за счёт транкейт, у вас будет там функция которая называется

291: Она просто вот буквально вы, вы сдвигаете число, вы делите число на 10, по моему, пока оно не будет. Вот кстати, деление на 10 здесь понадобится, но его можно сделать просто

292: Через деление, которое мы с вами написали. То есть это не такая прям важная операция, чтобы на неё отдельно выводить функцию. То есть транкейт это просто деление на 10, пока у вас порядок не стал нулю равным.

293: Допустим, 12,34, 34/100. Это просто станет 12. То есть это без округления. Вы просто физически, это хранится у нас как 1234, да, и порядок 100, порядок 2, да?

294: Да, порядок 2. То есть это 1234, делённое на 100, да, ественно, дважды число делим на 10, уничтожая порядок в 0. Да, и это готовый результат. И это готовый результат. На остаток не смотрим. Остаток нам не нужен.

295: Вот, а вот с float история веселее, то есть если при конвертации из и в int, там буквально 1 функция и как бы

296: Все там 1 функция и проверка там что значений достаточно ну что типа место есть в битах, то вот флоуд там надо чуть больше внимания уделить, когда мы конвертируем из decimal во флоуд вот.

297: Те имплементации которые я видела это чисто мы берём, копируем целую часть из decimal во float, просто их приравниваем и потом мы делим вот делим пока делятся пока у нас.

298: Есть порядок, мы делим наше число на 10.

299: То есть мы делим вот этот вот флоут, который нам надо получить на 10. Это вот все, большинство имплементаций, которые я видела, так написано.

300: А конвертация из float в decimal вот её надо, её надо обсудить, помните, друзья мои, проект стринг плюс он нам тут понадобится.

301: Значит проблема у нас возникает при конвертации из float в десем в том, что

302: Flawed хранится по другому в побитовом виде, поэтому мы не можем просто биты скопировать, и это очень грустно, помимо этого у float есть проблема точности.

303: Как бы десятичная система счисления не очень красиво переезжает в двоичную, и из за этого у нас числа там 0 1 дессятая, да, не преобразуются красиво.

304: Они там получаются как бы числа с периодом, поэтому у нас с вами страдает точность.

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

306: С типом float, то у вас значимых чисел, значимых цифр не должно быть больше 10. Ой больше 7. То есть вам не нужно обрабатывать больше 7 значимых чисел. Что это значит, если у вас

307: У нас есть, например, вот такое вот число, да, там 34 и хвост.

308: Вот вы берете отсюда 7 цифр, да, и все. Вот в сумме 7 цифр и из целой части, и из дробной. Больше вам не надо, если у вас есть число, да, какое-то, которое будет больше.

309: Там 10 в 7 вы все равно берете чисто 7. Первые вот 7 значащих цифр. Все. И это очень, очень удобно извлекается с помощью научной нотации, она же её

310: Вы можете поступить умно, красиво и просто у вас есть функция с sprinter, то есть она копирует из из как бы, числа.

311: В строку и вы представляете её в научной нотации. Значит, тогда у вас остаются вот эти вот как бы 7 знаков.

312: И у вас остаётся порядок.

313: То есть у вас число, то есть у вас есть знак 7 цифр и порядок. И потом, используя с сканф, вы вот эти вот числа извлекаете, то есть удаляете вот эту вот точку.

314: Если она есть, ну хотя нет, она там будет, да, вы удаляете точку.

315: Берете 1 число, берете знак и берете порядок.

316: То есть здесь как бы мы с вами немножко окольными путями, но вот такой метод намного эффективнее, чем пытаться работать вот именно с числами.

317: То есть я советую здесь использовать именно инструментарий строк.

318: Какой вопрос? Как? Ну вот с целыми числами более менее понятно. А если как нам сохранить этот степень десятки, вот здесь перевести знак, считать вот этот знак?

319: Который + 0 1, да, то есть это, это у нас научная аннотация. Я, кстати, не помню, как будет выглядеть. Умножает число на 10, а мы в своём. Так, а вычитает тоже самое абсолютно. То есть у тебя, смотри, если у тебя там

320: Будет плюс, то ты умножаешь на 10. Если у тебя будет минус, то ты делишь на 10. Это я понял. Это у нас обычный клон. Вот мы записали, да. 3, 4, 5. Да, да, да, да, да. 3, 3, 3. Мы записали это в нашу целую часть нашего ааг.

321: А в как там масштаб scale? Мы что запишем? Как мы посчитаем наш скейл, который нужно сейчас?

322: Получается, мы схема это будет шестёрку, да?

323: 10 в степени 6 это будет. Подожди. 1, 2, по моему. 1, 2, 3, 4, 5. Нет, это будет, это будет не 10. В 6. Это будет 10 в 6 минус. Вот.

324: Это вот значение.

325: Да, то есть это будет как бы 6 минус вот это вот число.

326: 7 - 6, 6 минус это число, потому что если ты, ну, все зависит от того, сколько ты этих значащих выведешь. Если ты выводишь так, чтобы у тебя было там 6 значащих чисел после запятой, то у тебя как бы

327: То есть это то у тебя и будет, там будет 6 минус. Вот это значение, все зависит от того, как ты это напишешь. Вопрос с чата. Ага. Тут же, вот то, что больше 7 цифр нужно округление делать. Или string сам нам оно вот в том-то, и

328: Что оно все само делает, он это все сижка самостоятельно считает. Нам не надо ни про какое округление думать, ни про что вообще.

329: То есть, видите, вот там, например, было 27, да, он взял его и округлил.

330: То есть это стало, получается, ну, то есть там на хвосте, не не 2, a3, потому что правильно округлилось.

331: То есть оно, оно как бы внутренними внутренними инструментами округляется правильно? Само.

332: Вот у нас с вами осталось четверть, я в вас верю, мы справимся. Значит, сейчас у нас осталось сравнение и округление.

333: Про сравнение тут сказать не то чтобы можно много ах ты, оно съехало немножко но ничего, у нас есть 6 разных функций сравнения да, is less is лес, риквел и так далее да.

334: Как вы делаете сравнение? У вас есть функция. Я советую вам настоятельно сделать функцию компер, то есть сравнение, да, если у нас будет вывод 1, да, то у нас 1 число больше 2.

335: Если будет вывод 0, то они равны, а если - 1, то 1 число меньше 2.

336: Вот у вас есть 1 функция, она вам все обсчитает, и вы просто вот этот вызов 1 функции помещаете во все вот эти вот 6 операторов сравнения.

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

338: Чтобы порядок был одинаковый, нам нужно, что нам надо сделать?

339: Нормализацию нам надо провести нормализацию, нормализация у нас написана на big decimal, соответственно внутри комппер там тоже будет вот этот временный переход на big decimal.

340: То есть у вас будет переход на би, у вас будет нормализация и потом у вас будет побитовое сравнение.

341: Точно так же, как мы с вами, помните, проходились по всем битам, когда мы считали сумму, точно также мы проходимся вот там от нуля до, там это будет сколько там, 32 на 7, вот до вот этого значения.

342: Мы проходимся и сравниваем каждый из битов. Хотя, знаете, нет, в сравнении надо идти от наибольшего бита к наименьшему. И пока вы не нашли beat, который отличается, вы продолжаете сравнивать?

343: То есть у вас ещё раз, вам надо обязательно обеспечить, чтобы у чисел был одинаковый порядок, потому что иначе сравнение не будет правильно работать.

344: То есть вы можете, например,

345: Если вы не используете нормализацию, например, вот у вас есть число, там 120, да, и порядок будет 3. То есть это будет 0,12 по факту. А записано как 120, а записано как 120. И если вы сравните, это, например,

346: С двойкой, которая 2 и в порядок 0, то у вас получится, что двойка будет меньше чем 0,12, а это неправильно. То есть обязательно нужно убедиться, что у вас одинаковый порядок. А когда мы нормализуем, у нас получится 120 в степени 100

347: 20 в степени 2 и 200 в степени 2. И вот тогда уже можно о чем-то говорить.

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

349: Beat из целого, из целой части, мы её с вами написали, уже считаем это вот это то, что вам надо в 1 очередь написать функция, которая ставит биты, отмечает биты и проверяет биты вот во всем, во всем вашем числе и для

350: И для децем как бы и все, и на этом история про сравнение у нас закончена. То есть просто 1 число и там 1 цикл будет. То есть нормализация, цикл, все.

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

352: Оно отличается только в 1 очень как бы очень в 1 очень узком случае. Значит, чтобы округлить, мы с вами используем функцию транкейт. Помните, да, её она просто отбрасывает хвост.

353: Мы её с вами уже написали. То есть вот мы отбросили хвост, у нас осталось чисто целое число, порядок 0.

354: И дальше мы с вами извлекаем вот эту вот дробную часть.

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

356: И от неё там есть, соответственно, 3 возможных варианта, если эта дробная часть меньше 0 5.

357: То результат это будет просто вот наше число обрезанное. Если результат будет больше 0 5, то у нас это будет как бы обрезанное число + 1.

358: Вот 3 вариант. Если у нас вот эта вот дробная часть будет равна 0 5, то есть половине вот здесь вот как раз-таки вопрос есть банковское округление, нет банковского округления без

359: Банковского округления. Это будет просто результат. Обрезанное число + 1. Если есть банковское округление, то вы должны округлить к ближайшему целому числу. То есть, если вы округляете, например, полтора

360: То это будет 2. Если вы округляете 4 с половиной, то это будет 4.

361: То есть вы по факту единственное, что вам надо, дополнительное условие, которое на вас навешивает банковское округление, это просто что

362: Как бы чему равен остаток отделения вот этой, вот, вот этой целой части.

363: Если у нас число чётное, да, которое получилось, то мы не увеличиваем его. Если число нечётное, то мы увеличим его на 1 и как бы, и в общем то, и все. Тут как бы делать больше нечего с этим банковским округлением.

364: Это просто позволяет нам вот когда мы в бесконечность с вами улетаем, как бы минимизировать ошибку. То есть мы не всегда увеличиваем при при вот этой вот дробной, равной 0 5, а иногда мы увеличиваем иногда

365: Ну и так вот эти + 1 - 1 где-то там в бесконечности примерно сходятся к нулю.

366: Вот, вот и все. Я не помню, надо вам делать это или нет, но опять же, как видите, это 3 дополнительных строчки.

367: То есть просто как бы сравнение, почему именно такое разделение чётное, нечётное.

368: Ну, я не знаю, почему они, почему оно так написано, но это позволяет тебе добиться чередования удобного. Смотри, если ты при 0 5 постоянно в большую сторону округляешь, у тебя дисбаланс в сторону большего округления, да?

369: Да, то есть у тебя, когда ты с числами долго работаешь, у тебя будет большая погрешность накоплена, а так у тебя погрешность стремится, да, почему? Почему мы увеличиваем к чётному? Ну так.

370: Людям так захотелось. Вот и все. То есть тут, тут лучше. Я объяснения тебе, к сожалению, не придумаю. Вот. И на этом у нас с вами сейчас последний, последний этап. И здесь просто шаблон, который я хочу вам показать.

371: Который вам пригодится. И это написание Тестов.

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

373: В питоне тоже есть, да? Ну вот, вот в данном случае мы работаем с шарпом на питоне тоже, тоже самое. Абсолютно можно написать, что перед вами находится. Перед вами находится такой базовый шаблончик для создания Тестов.

374: То есть вот этот вот тип, да, нам не надо задумываться, да, о том, как у нас тесты должны выглядеть, как у нас должны выглядеть там числа после определённых операций. Нам достаточно просто посм.

375: Смотреть на то, как это написано в сишарпе.

376: И что мы вот по факту вот здесь вот у нас весь как бы блок Тестов.

377: Вот у нас есть 1 число decimal, мы выписываем его в консоль вот в таком вот виде, как бы мы написали его в сишном коде, то есть пишем, что у нас есть с 21 децимал, вот у нас есть имя переменной, да.

378: Вот оно, навар, имя переменной, которое передаётся как бы в аргументы функции. И она равна. Вот поехали, значит, список просто вот список буквально чиселок.

379: Да, это вот значение, которое, то есть есть вот этот вот очень удобный метод в сишарповский рый называется get bits. Он просто позволяет вам отдельно получить значение вот этих вот

380: То есть, чему равен каждый из этих винтов, они хранятся там абсолютно также, там абсолютно тоже самое расположение битов. То есть там также в 31 бите знак че там с 16 по 28, это порядок, все тоже самое.

381: И это нам крайне упрощает жизнь, потому что мы можем просто вот эти числа вывести буквально вот в консоль, как, как он там подаёт сишарп, вот мы просто так их и выводим. То есть вот мы взяли с вами 1 число, мы его как бы напи.

382: Вывели в консоль, берём какое-то 2 число, выводим его в консоль. Дальше у нас есть с вами результат, который получается в случае в случае дела

383: Выводим его точно так же.

384: Потом мы с вами заводим как бы нашу переменную с нашим результатом и пишем сюда. Вот функция, да, которая нам, нам нужна, да, которую нам нужно обсчитать. И потом мы пишем. Просто вот, пожалуйста, вернись.

385: Denis. Пожалуйста, нам обсчитай, пожалуйста, сравни нам вот эти вот Инты, каждый из интов вот этих вот 2 чисел у нас есть с 21 res, да, и ориджин орик, рес. То есть изначально

386: Вот ты их, пожалуйста, вот выпиши вот этот текст и потом как бы сравни возврат. Вот и все. По факту вы открываете там любой, любую среду онлайн.

387: Кто может вот этот сишарп код запустить? Вы пускаете его и у вас будет в консоли текст вот 1 из этих Тестов.

388: Как бы я видела прям целый, знаете, генератор у нас вот 1 наш тиммейт написал целый генератор Тестов. Вот можно, можно там автоматизировать это вот до конца жизни просто, но вот это вот самое

389: Базовая конструкция. Вот у вас идёт вывод в консоль вот этого куска Тестов. Да, удобнее всего, что у нас есть конкретные значения. Сишарповский мы можем сравнить.

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

391: И как бы, и все в сша же тоже есть эти транкейт округления, ну, должны быть, да, должны быть, потому что, говорю, у нас, у нас тесты были написаны прям на генераторе, то есть они должны быть в каком-то виде.

392: Понятно, что там умножение можно писать как оператор, а не через функцию, там тоже самое с вычитанием и сложением, и делением тоже. Ну вот собственно, друзья.

393: Дорогие, мы с вами достигли финиша.

394: Я вас поздравляю. Есть ли у вас какие-то вопросы? У вас есть прекрасная возможность сейчас попросить меня повторить что-нибудь?

395: Я понимаю, что это, это лекция действительно большая, это буквально обзорная экскурсия по всему проекту.

396: Есть какие-то вот тонкости, которые хотелось бы ещё раз обсудить вообще так работают по операции.

397: Битва, операция. Вот давай про битвы расскажешь. Ну, давай, переставь, пожалуйста, доску тогда. Нет. Да ты иди, я сейчас так.

398: Побитовая операция. Значит, у нас будет наше число состоять из 8 Витов, потому что мне лень рисовать 32. Я думаю, по давайте даже

399: Из 6 мне лень рисовать больше, понятно, что их там в случае Инта у нас 32 штуки.

400: Мы когда говорим про побитовые операции, нам нужно, у нас есть несколько вот базовых, которые мы сейчас с вами разберём, у нас есть или

401: Или у нас есть и у нас есть левый сдвиг, у нас есть правый сдвиг, и у нас есть не который, по моему, тильда.

402: Вот, кстати, на прошлой лекции про тильду не говорили, а очень зря. Она очень нужна нам, когда мы конвертируем инт.

403: Значит, идея, да, вот знаете, мы же можем писать вот такие вот истории, да, когда мы вот это используем в коде.

404: Да, то есть по факту у нас должно быть верно? Либо это условие, либо вот это условие, да, что делает вот эта операция, она нам возвращает, как бы, единственное, то есть это либо, то есть

405: Она означает либо ложь, либо правда, да, побитовые операции работают намного веселее, они применяются отдельно к каждому из битов. Вот у нас есть число, да, 0 1.

406: 0 1 1 0 1:00 1.

407: Какой ещё у нас тут комбинации? Нет? Ну вот только вот так вот, да? Ну давай вот так, нолик.

408: И у нас побитовые операции применяются вот к каждой вот этой вот паре.

409: Может ли быть вот такая вот ситуация? Вопрос, когда у нас нет beta, с которым мы можем сравнить?

410: Когда мы берём 2 типа, допустим, и, кстати, вот хороший вопрос, я про это не подумала, может быть, может быть, но если мы сравниваем 2 Инта, да, как в случае нашего проекта, такого быть не может, потому что он фиксированного размера, то есть

411: Если мы с вами, то есть если у нас число будет там условно 10100, 110, ну, в бинарном виде, то у нас просто дорисуется все нули здесь. То есть все вот здесь будет заполнено нулями.

412: Вот, кстати, не знаю, как будут себя вести сравнение 2 типов, разных размеров. Это надо, это надо смотреть. То есть вот это как бы самое важное отличие побитовых операций от просто логических, то есть они

413: Основаны на том же, но они чуть чуть по другому работают. И вот или, например, какая у нас таблица истинности для или

414: А или б. То есть, если у нас, если у нас 0, то здесь 0, во всех остальных случаях будет единица.

415: Это вот для 1 бита. И получается, что каждый из этих битов к нему будет применена вот эта функция. Давайте считать 1 бит какой будет?

416: Единиц слева. Вот этот единица, следующий бит. Единица. Следующий бит, 0, единица, единица, 0. Ага. То есть мы сравниваем-ка.

417: Из, то есть каждый из этих битов сравнивается, и они, и результат записывается в число.

418: Если мы говорим с вами про или наоборот про и подожди, а вот то, что мы сейчас уже знаем, мы его для сет бит как-то можем использовать?

419: Нет.

420: Сейчас будет, сейчас, сейчас будет гид бит. Готовьтесь на get beat. А хотя нет, слушай, нет, я вру тебе. И у нас или используется, или у нас используется. Вот смотрите, чтобы сде,

421: Он нам нужен для того, чтобы сделать сет бит, то есть по факту

422: Вот у нас есть с вами число, да, давайте, нам надо вот, вот наше, например, оригинальное число, нам здесь надо какой-то beat поставить, да, например, вот этот вот beat мы хотим поставить, да, значит у нас вот здесь вот

423: То есть мы должны составить число такое, что вот здесь вот будет бит, а нигде, кроме этого бита не будет.

424: Это у нас сет бит, то есть нам нужна вот такая вот как бы масочка.

425: Как мы эту масочку получим дальше? Это мы обсудим. То есть у нас на сет бит, я вот здесь напишу на сет бит, нам нужно и вот эта вот или операция, и ещё 1, которую мы сейчас

426: С вами обсудим. Догадайтесь, какая здесь 2 операция нужна?

427: Равно, нуу, равно это да. Ну вот смотри, тебе нужно прописать единицу, но в какое-то определённое, да, в какое-то определённое место эту единицу сдвинуть на определённое место ещё раз plus равно не, ну plus равно. Да, да, с равно понятно.

428: Хотя нет, там плюс тебе даже не нужен, ты можешь писать вот так вот в коде, там даже я это писала, что как бы палочка равно, то есть это он воспримет, как сделать или с той же операцией. То есть, смотри, если

429: Мы сделаем, а, например, вот так 100 это тоже самое, что

430: Это будет тоже самое, что, а, равняется, а, или что? Ну, подожди, прежде чем? Ася, ну, потом, да, это сейчас не до того объясни. Вот нам нужно прописать бит какой-то.

431: Положение, как нам в это положение, это beat поставить, как нам поставить бит в это положение? Вот давайте мы, как бы нам поставить бит в это положение

432: Хорошо, прекрасно, математически. Как поставить, перевести?

433: Нет, нет, мимо смотри, прекрасное свойство. Каждый раз, когда мы сдвигаем число влево, мы умножаем его на 2. Да, да, да, да. То есть давайте ещё раз. 1, 0 1.

434: 1, 0, 1 0. Нам надо поставить вот этот бит.

435: Вот у нас есть, как бы, мы знаем, как получить единичку, да, на 1, 2. Мы знаем, что вот у нас, у нас есть номер у каждого из битов, да, 0 1, 2, 3, 4, 5, 6. Как получить единик?

436: Единичку написать просто intro are равно единичке.

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

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

439: Вот используйте побитовые операции, ваш компьютер вам скажет спасибо, может, простит даже какие-то там другие ваши грехи ко мне.

440: Лучше, я надеюсь, я надеюсь, что вертор будет к вам за это лучше относиться, я надеюсь, то есть по факту. И вот то, что у вас получается, да, что вам надо, если надо

441: Сдвинуть. Получается 2 на 2 бит, то вы, ok, смотрите, вот у вас есть число

442: Давайте, как, как мы его назовём? Вот это вот давайте вал, вот у нас есть вот этот вал, да, который наш с 21 тип. Ну, давайте не с 21 интовый, да?

443: Чтобы, значит, чтобы ему дорисовать, значит, вот там давайте напишем вал на 100. Понятна вот эта запись, что она сделает, что она, что понятно, что эта запись сделает, то есть она

444: Она отмечает вот этот вот beat, то есть мы говорим, что это вот, вот это вот плюс побитовая или или с вот этим, то есть побитовая ещё раз сравнивает каждый из битов. Можешь прописать вот че получится снизу.

445: Угу. То есть 3 рядом у нас получится 1, если мы сделаем здесь и 1 0, 1, 1, 1, 1 0.

446: Вот это вот у нас тут нет маркера какого-нибудь цветного. Вот ещё есть такой, смотрите, как можем вот так вот можем сделать во вот что у нас новое появилось, это вот эта вот запись мы пишем, то он добавляет единичку.

447: Куда мы хотим? Да? А вот если мы, например, можешь 100 поменять на вот сейчас, да, сейчас. И мы это напишем не 100, мы сейчас напишем это, да, мы сейчас это напишем. Вот. А теперь давайте вот это мы сделаем получше, во первых,

448: Вот эту вот дупликацию давайте уберём, она нам не нужна.

449: Вау.

450: То есть просто вот, вот это, вот, вот этот товарищ вот сюда мигрировал.

451: Точно также вы можете писать plus равно a int надо int но это нет это не надо это просто я вам говорю что как это у вас же это это же функция да сет бит туда подаётся вот это число которое тебе надо изменить значит

452: У тебя оно уже определено, поэтому инт, писать не надо. Вот, вот это вот 1, да, что мы сделаем, уберём вот эту дубликацию. 2, что мы с вами сделаем, это, напишем вот так вот вал, вот это.

453: Будет 1 со сдвигом 2.

454: Тяжело. Ну вот смотри, у тебя 100 в двоичной системе. Это, по сути, единица, сдвинутая влево на 2 поля, либо хорошо.

455: Это сдвиг на 2. То есть это вот у нас вот, вот это вот, вот это вот превратилось вот в это вот это тоже самое, абсолютно, абсолютно тоже самое.

456: То есть это 110, 10, ну то есть это 1 с 2 сдвигами. И вот сюда вот вы можете любое число подставить.

457: Если в случае Инта здесь будет сдвиг больше, чем 32, это грустно, поэтому вам надо будет думать, вы выйдете за границы. Ну то есть у вас там ничего не останется, у вас там нули просто будут и все. А в отрицательном 31.

458: Ещё раз. Ну, если отрицательное значение будет, то 31.

459: Если отрицательно, если ты будешь менять в Инте знак, вдруг тебе захотелось в Инте знак поменять, то ты будешь сдвигать на 31, но нам это для проекта не надо. Вот именно конкретно, конкретно вот этот вот 31 бит, то

460: Он нам нужен только в случае set sing, когда ты знак ставишь. Вот тогда только тебе он нужен и все.

461: В большинстве случаев ты просто используешь вот этот вот int целый как буфер и все там какой номер тебе в общем то по барабану вот в случае big decimal да, если вам приходит значение больше больше.

462: 32, даже 31, по моему.

463: Если вам приходит значение больше 31, вы как бы делите на 32, пока у вас не останется остаток меньше, чем чем 32.

464: Вот у вас будет, то есть у вас будет понятно, да, что если у нас вот здесь вот как бы у нас 32 бита и вот здесь вот у нас 32 бита, и вот здесь у нас 32 бита.

465: Да, и вам надо отставить, например, какой-то там 56 бит.

466: Мы точно знаем, что он не вот здесь, правильно? Ну, потому что тут 32 всего. Окей. Делаем - 32. Что у нас останется? 24.

467: 24 меньше, чем 32. Значит, где-то он вот тут вот живёт, этот 24 бит.

468: Поскольку оно меньше чем 32, мы тут уже пишем вот эту вот запись.

469: Прикольно. Так и теперь и надо нолик прописать не единичку нолик. Вот прописать нолик сложнее, чем прописать единичку, друзья мои, поэтому.

470: Давайте мы сначала разберёмся с побитому и

471: Потому что мы понимаете, что если мы просто сюда поставим как бы нолик,

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

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

474: Из и поэтому давайте мы сначала с этим вопросы есть по или

475: Может, сразу, кстати, ты объяснишь? Подожди, подожди, друг дорогой, давай. Мне хочется сначала объяснить, и потому что оно по аналогии пишется.

476: Значит, если мы с вами берём

477: И логическое, и у нас, когда выдаёт единицу.

478: Когда оба верно?

479: Соответственно, вот давайте с вами просто составим, решим, что называется такое простое простое уравнение. Пример простой 0 1:00 1.

480: 1 0 поехали здесь, что будет мимо?

481: Здесь 0, здесь 0, здесь 0, здесь, здесь, здесь 0.

482: Подожди, а 0, 0, это же одинаково. Нет, это, это у тебя. Исключи обратно. Это то, что называешь пан или пропал. Я не помню, как называется имплика. Нет, не импликация. Я не помню, как она называется. Нет, исключающая. Или

483: Но либо когда-либо 1 верно, либо 2 не вместе, а это обратно от исключающего. Или нам это вообще не надо. Здесь вообще не надо. У нас есть и и полезнее, чем экзотика, которую мы сейчас

484: Обсуждаем, то есть тоже самое, как или только там у нас как бы сравнение по другому идёт между битами. То есть если у нас оба бита единички, то и в результате будет единичка теперь

485: Тильда или не прекрасная вещь, не она же тильда, она делает обратные от всех битов.

486: Вот если мы возьмём

487: Обратную, обратную от вот этого числа, что здесь будет? 1 бит какой

488: Обратно, то есть у нас единица становится ноликом, нолик становится единицей.

489: 0 1:00 1 1.

490: Угу.

491: Как нам это может быть полезно? Вот смотрите.

492: То, что мы сейчас с вами сделаем. Вот, используя тильду, кстати говоря, 1, 1, как нам, где тильда полезна, это при работе с конвертацией интов.

493: Значит, Инты хранятся в памяти следующим образом. Там где-то идёт че то плюс или - 1. Я не помню где именно, но идея основная заключается в том, что если у вас инт отрицательный, то у вас

494: Все биты хранятся в инвертированном виде в Инте. То есть, смотрите, если у вас будет, ну вот возьмём какое-то число, да, пусть у нас 4 бита в типе, да.

495: И вот это вот 5 будет знак. Пусть вот это там будет 0 100. Это у нас будет 1, 2, 4. То есть это будет 5, да, как нам сделать отрицательное, чтобы сделать отрицательной там где-то?

496: Будет минус или + 1. Я не помню, где именно вот здесь будет стоять единица.

497: А вот здесь вот у нас пойдут как бы инвертированные биты, то есть здесь будет 1 0, 1 0.

498: И + 1, да, здесь будет + 1.

499: 128 до 127. То есть, ну вот я говорю, вот где-то она там есть, я её не помню, где именно. То есть вы берете, как бы вот тильда нам нужна как раз-таки, чтобы получить вот это вот обратное число при конвертации Инта, потому что у нас вот это

500: Вот. Обратного хранения отрицательных чисел нет. У нас все числа хранятся как положительные знак. Да, да, да.

501: Ну это это а мы можем сначала просто int умножить на - 1 если на а. Ну кстати да это можно сделать это понятнее но тильда нам нужна чтобы поставить бит в 0 что мы?

502: Сделаем, значит, вопросы по и есть.

503: По и или тильда.

504: Вот смотрите, мы помните, что когда мы с вами ставили бит, да, давайте вспомним, как это выглядело ещё раз. Вот хотим мы вот этот вот 2 бит поставить, например, мы что делаем?

505: Нет, 2 бит мы берём, делаем такую вот запись, да, то есть это как бы вот это у нас как бы равно 1 сдвинутое на 2.

506: Да, а теперь, чтобы удалить бит, вот смотрите, вот я запишу результат. А теперь давайте этот же bite мы с вами удалим.

507: Мы с вами поняли, что если мы напишем снова или ничего как бы полезного не произойдёт, что мы можем сделать? Мы знаем, что у нас есть вот этот вот beat, который нам нужен, да, мы возьмём обратное от него, это будет

508: 1, 1 1 1 0 1 1 и возьмём и

509: Что это нам даёт? У нас есть вот этот вот наш бит, который нам интересен. Да, это единственный бит с нулём.

510: Согласны, когда мы применяем операцию и побитого, если у нас была единица, она так и останется единицей. Если у нас был нолик, он так и останется ноликом. То есть вот

511: Давайте ещё смотреть здесь, что будет стоять 1 здесь.

512: 0 здесь, здесь, а вот здесь вот вне зависимости от того, что стоит, здесь будет стоять нолик.

513: И вот здесь будет стоять, что 1, и вот здесь будет стоять нолик. Принудительно занулили, мы принудительно занулили за счёт вот этой вот как бы обратной как бы маски это будет как бы тильда 1.

514: Со сдвигом 2.

515: Чтоб поставить нолик на нужную позицию, мы сначала единицу сдвигаем на нужную позицию, а потом да, а потом её как бы инвертируем. То есть мы делаем маску так называемую

516: Прикольно, да, но такое оно красивенькое на самом деле. И, а теперь вот, значит, сет бит, мы с вами поняли, как делать, а как её, а вот get как get, будем делать, узнать, какой бит.

517: Вопрос аудитории как будем делать get beat есть идеи?

518: Не, нет, все биты не надо. 1 какой-то с любым номером. Какой номер вам вздумается, такой и берите. Ну вот давайте возьмём, хотим узнать, что на 4 бите, как узнаем.

519: Ну, также будем использовать вот эти вот

520: Мы подадим какую-то маску.

521: Ну, по факту у нас, значит, какой у нас бит, то нам интересен? 4, нам 4 бит интересен. Вот прекрасно. Значит, сначала мы, давайте мы сдвинем на 4. Вот у нас получается вот такая вот история.

522: И теперь нам надо выяснить. Можешь и тоже слева прописать, чтоб понятно было, что это маска. Окей?

523: И вот теперь нам надо понять, какую тут операцию надо применить.

524: Чтобы у нас вернулось какое-то число, если там стоит бит и 0, если там ничего не стоит.

525: Какая операция? У нас не так много вариантов. Ребят, у нас есть вариант. У нас 2 операции, которые применяются к 2 числам, это и, и, или в чате пишут, и в чате пишут, и чат прав.

526: Здесь у нас и почему? Потому что везде, то есть у нас все зануляется, потому что здесь как бы все нули единственное значение, которое, у которого есть хоть какой-то шанс не быть нулём, это там, где стоит единица, и оно зависит от того,

527: Собственно говоря, на что там, на вот этой позиции, на 4 стоит. Если там стоит единица, то нам вернётся, получается, че там 1000. Если тут стоит нолик, то вернётся нолик.

528: Если хочется ещё, чтобы тут возвращалась единица, там можно условие поставить, что если число, там, если результат больше нуля, если он не 0, то, пожалуйста, верни мне единицу, если

529: 0, то верни нолик. То есть у нас функция получает число и номер позиции, в котором мы хотим абсолютно верно. То есть у нас функция получает число, она получает позицию, это на гетти.

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

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

532: Мы с вами обсудили.

533: Таким образом, если мы сдвигаем все Инты, вот у нас 4 Инта там, да, есть, мы их сдвигаем влево, и мы хотим сделать так, чтобы у нас единичка из 1 Инта перепрыгнула в другой, in, да, мы, получается, делаем у 1 Инта г. Бит.

534: На 31 позиции, а в другом делаем сет бит на 0 позиции и все, что там было, 1 или нолик, они перескочат у нас соседний, да, по факту мы, сдвигая все 4 etta, не потеряем ни 1, ни 1 бита по факту.

535: Или можно просто брать даже там можно даже число брать. Вот давайте мы давай сейчас посмотрим вот это вот мне хочется, чтобы вы так этот код посмотрели.

536: Сейчас он там уедет назад, а я пока тут почищу. Давайте обсудим тогда, раз уж раз уж такая пляска пошла, обсудим с вами.

537: Как вот эту вот операцию, шифт код. Давайте с шифта обсудим что вы думаете по поводу? Да, вот shift.

538: Давайте, давайте возьмём более простые оо презентацию. Презентация будет, да, обязательно презентация будет, запись будет. Все будет, друзья мои, все для вас.

539: Ну, давайте вот этот посмотрим код, например.

540: По побитым операциям есть вопросы?

541: Давайте вот так просто переверну. Я надеюсь, что она там вместится. Оп, оп оп оп, оп оп, оп, прекрасно живём. Значит, это shift ещё раз. Что мы делаем?

542: Там идея как вот какая, значит, вот, вот этот вот как бы здесь написан просто для удобства изменения. Давайте мы без него, наверное, поначалу просто цикл, вот у нас есть 7, 7 битов, по которым нам надо пройтись.

543: Значит, у нас есть наше, наше какое-то интовое значение, да, я скажу, что у нас в bitter, ой, господи, в Инте у нас будет 4 бита сегодня, обычно их в 8 раз больше, но не сегодня. Вот у нас.

544: Есть какое-то число, да, и таких у нас как бы 7 штук разных, там 0 1, 0 1, 1, 0 0 1.

545: Там 0 1 1 0.

546: Пусть, пусть, пусть вот так вот, да, давайте в таком виде посмотрим пока что их 3 штуки и все понятно, да, что масштаб как бы увеличить легко, если их 7 будет тот же самый алгоритм просто для нашей простоты сейчас так сделаем. Вот давай.

547: Давайте просто по очереди пройдёмся, по тому, что этот код делает.

548: У нас есть некоторые, вот у нас есть как бы некоторое временное хранилище, да, вот этот темп.

549: Темп он будет хранить в себе 0 1 0 1 да, дальше что мы делаем? Вот это у нас будет beats нулевое Битц нулевое вот это у нас будет beats 1 вот это у нас.

550: Будет beats 2. Угу. Смотрим сначала битс нулевое.

551: Beats нулевое, мы с вами что с ним делаем, мы сдвигаем на 1, то есть оно будет равно, если мы вот это число сдвинем на 1, что у нас получится?

552: Нет.

553: Сдвинем на 1.

554: Получается, они вот так вот просто переедут. То есть у нас 1, 2, 3, а вот то, что тут останется, пустое место заполнится нулями. То есть здесь у нас будет 1 0, 1 0. Ага.

555: Дальше у нас.

556: Memoria memoria. У нас пустой пока.

557: Memoria пока пустой, но нам надо на всякий случай, ну, записать, есть ли там какие-то, может быть там что-то оставалось. Битс 0. Ну вот допишем мемори.

558: Ну, для, для счастья нашего, потому что мы не знаем, есть там что-то или нет, чтобы нам, как бы, чтобы нам упростить для себя жизнь. Мы просто эту команду делаем, чтобы она всегда, чтобы она всегда исполнялась в цикле, и дальше в вот.

559: Вот эта вот операция. Давайте вот её поймём. Мемори темп 32 - 1. В нашем случае это будет memory.

560: Равняется темп.

561: Сдвинуть вправо на 4 - 1.

562: Вот, давайте вот это разберём, когда мы делаем. Вот у нас есть число, да, 0 1, 0 1, когда мы делаем с вами сдвиг на 1.

563: Сколько чисел слева мы теряем?

564: Если мы сделаем сдвиг на 1 влево, сколько мы слева чисел теряем? То есть вот так вот двигаем число на 1. Сколько мы теряем чисел?

565: Сдвинулись. Сколько сдвинули, столько и потеряли. Конечно. Значит, если мы делаем сдвиг на 1, мы теряем нолик. Правильно? 1 в данном случае нолик. То есть мы теряем 1 значение, нам надо как-то его получить. У нас есть

566: Темп, который хранит в себе то, как этот beats выглядел раньше.

567: То есть нам надо с помощью какой-то операции извлечь вот эту вот как бы часть.

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

569: Количество битов.

570: Длина минус сдвиг.

571: То есть то, насколько мы сдвинули, потому что мы вот столько же потеря, правильно? Да, мы вот столько вот потеряли всего у нас длина 4.

572: Конечно, вот оттуда у нас это 32 - 1 и вылезает.

573: Ну, в данном случае у нас просто будет 4, потому что у нас длина меньше.

574: Вот, и и получается вот. И теперь мы поехали заново, а если мы с вами, например,

575: Давайте мы, я сейчас хочу вам вот какую демонстрацию провести, если мы сделаем сдвиг на 2, вот с этим вопросы есть? Ещё вот есть вопросы с тем, как вот это вот возникло

576: Чат, чат, друзья мои, остался там кто-нибудь вопросы есть? Пока нет. Прекрасно. Значит, если будут вопросы, ещё пишите, я пока что это стираю.

577: Вот, хочу вам кое-что продемонстрировать. Немножко другое. Если есть вопрос. Ну, сейчас он пока напишет вопрос. Ну, пишите, да, я отвечу сейчас, походу, если мы сделаем сдвиг на 2

578: Возьмём вот это вот число. Давайте мы давайте-ка мы с вами сдвинем на 2 Биц 1, то есть сдвинем на 2 бис 1, вот, b1 сдвинем на

579: 2 тогда у нас как бы как бы бит 1.

580: Будет равен 0 1 и memory чему будет равно?

581: То есть пусть у нас будет сейчас шифт на 2, а не на 1 мемори, чему будет равно.

582: Memory будет равно вот этому куску.

583: Который мы с вами отрезали. А, ну да, оно будет равно как бы 1 0.

584: То есть мы вот за счёт вот этой записи, то есть мы сюда пишем то, насколько мы сдвигаем за счёт вот этой записи, мы берём ту часть, которую мы отрезали.

585: То есть за счёт вот этого вот правого сдвига. И поскольку мы все число делаем, двигаем на 2, давайте посмотрим на Биц 2, мы же тоже его на 2 должны сдвинуть, правильно? Биц 2 сдвинем на 2.

586: Что, что у нас получится в итоге?

587: Чем у нас Биц 2 станет вот это вот число, если мы его на 2 сдвинем вправо, ну, влево наоборот.

588: 1 0.

589: 1 0. В номере остаётся 1 0. Если мы - 1 делаем от 32, получается - 2. Надо делать, чтобы 1 0 осталось в номере. Разве нет? Вот - 1.

590: Это минус то, насколько ты сдвигаешь вот здесь у нас шифт на 1. Если мы делаем шифт на 2, то мы вот здесь, соответственно, сдвигаем на 2 и вот здесь сдвигаем на 2. Это вот сейчас я покажу тебе

591: Вот оно, видишь?

592: Shift велью. Это то, насколько мы сдвигаем, это передаётся как бы как аргумент. Вот я хочу вам сейчас кое-что продемонстрировать. Очень, очень важное и очень полезное у нас от beats 2 остаётся вот эта часть, кстати, знаете,

593: Что мы вот здесь с вами ошиблись. Здесь будет не просто 0 1, да?

594: Но там ещё в конце будет 00 дорисовано, потому что мы сдвинули вот эти вот биты, оставшиеся заполнятся нулями мемори. У нас будет вида как бы 0, 0 10.

595: Beats 2 будет вида 1000 и у нас осталось с вами мемори, помните? Поэтому что мы делаем? Мы делаем как бы вот это вот или то есть у нас здесь появилось вот эти вот 2 пустых

596: Как бы 2 пустых нолика, и мы туда ставим по факту значения, которые есть в memory.

597: И это будет как бы

598: Вот так вот это будет 1010.

599: Прикольно. Оно такое, оно забавное, да.

600: Так, давайте вот этот вот 2 кусок кода посмотрим с вами кстати, вопросы какие в чате были, че пишет? Ну непонятно откуда взялся этот сдвиг, но ты показала то, что у нас есть shift.

601: Shift. Мы просто вот это вот демонстрация для случая, когда у нас шифт и что у нас, если не равен единице происходит, если мы хотим сдвинуть весна 2, да, например, опять же, как я говорила, больше 30, там 32 и больш.

602: Работать не будет. Вот эта вот функция не будет работать в этом случае. Правильно? По крайней мере. Ну давай другой способ покажу.

603: Он простой, но он медленный, конечно, такой будет. Ты просто предлагаешь каждый из битов, да? Ну, предлагаю сдвигать на 1 в цикле столько раз, насколько, ну, можно, можно, это можно, это можно, но

604: 90 битов сдвинуть влево. Мы повторяем 90 раз это нет, это все справедливо, но вам просто это не надо, потому что у вас большинство вот этих вот сдвигов можно там либо на 1, либо на 3.

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

606: Все остальное делается аналогично ну, давай, друг, дорогой.

607: Деление, пожалуйста, покажи мне.

608: Во сложение побитовое сложение.

609: Давайте возьмём без вот этого сайзоф для начала.

610: Вот сложение, как мы с вами делаем, сложение.

611: У нас есть с вами биты. Вот это вот я хочу стереть. Никто не против. Оставить надо ещё.

612: Сейчас последнее вот это вот просто пройдёмся ещё раз, потому что тут опять же, тот же са.

613: Механизм как бы взаимодействия с

614: Который нам пригодится. То есть вот это вот пройтись по битам, экскурсия по битам. Ребята, вот сейчас у нас с вами мы должны отработать с вами экскурсию по битам.

615: Вот смотрите, та же самая конструкция. Вот мы напишем с вами 2 числа каких-то

616: 0 1:00 0 1 0 1.

617: И вот у нас есть номер, да, у каждого из битов.

618: Вот начинаем экскурсию. У нас есть цикл, мы знаем, сколько тут битов. Понятно, почему мы знаем, сколько тут битов.

619: У нас их фиксированное количество в интах, но у нас там 7 интов, 32 штуки умножаем на 7. Вот оно, вот это наше 32 на 7 битов.

620: И от нуля до вот этого значения не включая. Вот мы и пошли, мы с вами же умеем теперь уже делать сет бит и get beat. Правильно вот это мы с вами научились. Давайте теперь это применим на практике. Вот мы, значит, берём

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

622: Число. А вот это у нас будет число б, как нам получить вот это значение?

623: Как нам получить вот этот вот beat?

624: Ну, делаем Гетт бит 0 позиции. Гетт, бит, Гетт бит. А 0, да, это вот этот бит, вот этот бит, как получим. Тоже самое, тоже самое.

625: Только на б плюс get beat б. От нуля.

626: И вот это все у нас будет как бы

627: Unsainted. Ресс, равно вот у нас есть какое-то чиселко, ну, unsainted там, честно говоря, по моему даже в чар это можно закинуть как бы тут, как хочется. Что у нас здесь в итоге?

628: Есть, то есть рес у нас чему равен рес, чему равен?

629: Если мы делаем 1 + 1, ну он переполняется. Нет, это unsigned, а получается это не beat.

630: Чему он? Друзья, давайте торжество программирования. 1 + 1, 2, 2. Ну, в двоичном коде это будет 1. Ну, это да, нам на самом деле это даже не важно, это 2.

631: Если это 2, то у нас должно перейти, как бы должна перейти единица в следующий разряд, да, значит у нас будет с вами какое-то мемо.

632: Мему, и эта мема будет хранить в себе то, что переходит в следующий разряд, и это делается за счёт деления нацело на 2.

633: Вот это вот просто деление нацело.

634: И сейчас, то есть как бы оно равно мемо, равно единице. Теперь это комментарий, что вот у нас мемо равно единичке.

635: А, то есть мы сложили 0 индекс, а 0 индекс п получили 1 0. Ну мы, мы смотри, мы сложили биты на 0 позиции, там 1 и там

636: 1, 1 + 1 равно 2. Ну, получается, 1 и 0. Ну, 1 и 0, можно так сказать, 1 и 0. Прекрасно. А знаете, как я хочу сделать? А я вот хочу сделать, чтобы у меня было

637: Вот так вот здесь вот так вот я хочу, чтобы сделать, чтобы 1 важную вещь продемонстрировать вам дальше. Значит здесь что останется? То есть у нас будет в результате здесь что-то нолик, здесь нолик.

638: Будет. То есть если у нас число нечётное будет, то здесь будет стоять единица.

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

640: Raven, get beat, get beat, a1 позиция плюс get.

641: Beat б. На 1 позиции, а ещё плюс мема.

642: Потому что надо не забывать про перенос в разряде. Там 1 будет, да, там будет 1. То есть максимум, который мы с вами можем добиться здесь это 3. Понятно почему. Потому что здесь может быть единичка. Здесь может быть единичка.

643: Здесь может быть единичка. Вот в следующем примере, вот как раз-таки вот мы сейчас до туда дойдём, да, вот здесь мы с вами понимаем, что будет тоже самое, да, что это будет как бы рес, это будет get by

644: A2 плюс get beat b2 плюс мема то есть здесь у нас мема будет, здесь у нас мема будет равно.

645: Мема будет равно двойке. Ой, господи, вру, простите, будет равно единичке.

646: То есть мы вот эти вот получаем, да, рез, получается, вторые. Нет здесь мемы, здесь мемы ещё пустое, а теперь мемы мы давайте заполним.

647: Мем мема будет равно как бы вот этот вот рез на 2. Знаете, я что самое важное, то вам забыла показать, что нам бы надо ещё beat отметить, сет бит по хорошему, по хоро.

648: Нам бы надо сделать везде здесь сет, бит какой-то у нас там будет.

649: Боже правый, как там пишется? Указатели в си? Я уже забыла рес нет Пуц со звёздочкой. А нет, если ты засовываешь, то адрес даёшь. А этот, господи, амперсант.

650: Спасибо. Как-то усложняешь? В смысле усложняю сет бит та же самая функция. Мы должны использовать инструменты, которые есть на 2 этот, на 2 мы ставим рез.

651: Остатком. A2. Давайте вот эту строку разберём, потому что её, она тоже вам нужна. Сет, бит. Понятно, что такое. Угу.

652: Тебе то понятно, ты уже год как сдал проект, значит, вот это вот у нас сет бит, вот у нас есть число, да, мы передаём его через указатель, чтоб мы могли вот этот децимал там, ну, чтобы мы могли там beat поставить очень

653: Важно его передать через указатель. Мы говорим, куда ставим, и мы говорим, что ставим.

654: Если у нас будет остаток, равный единице, то это означает, что в этом бите должно что-то стоять.

655: Если у нас остаток будет равен нолик, то, значит, ставить нечего. То есть у нас остаток будет. В каком случае у нас будет вот рез, определение с остатком на 2. В каком случае это будет единица?

656: Когда он равен 2, и когда он, а нет, в смысле 3, и когда он равен единице, конечно, когда он равен 3, либо когда он равен единице, то есть если 3, то будет 0, если 3, то вот будет поставлена единица, если будет 1, то будет

657: Оставлена тоже единица. То есть вот это, например, случай, когда рес равен единице, потому что здесь мемори, а вот эти 2 бита нулевые.

658: А вот здесь вот у нас будет с вами мемори равно нулю. Вот эти 2 бита равны по единице. Это чётное число, значит как бы 1 + 1 остаток.

659: От двойки отделения двойки будет 0. Значит сюда встаёт нолик. А вот здесь вот у нас мемории будет равно единичке. Получается, здесь будет memory 1 этот бит 1 и этот бит тоже 1.

660: И останется, соответственно, здесь единичка.

661: И ещё в memory будет 1, который переходит сюда же.

662: То так.

663: Сколько там времени сейчас?

664: Ну так-то 21, 27 аауч, мне надо уже домой ехать, а то я до академа никогда не доберусь. Ну, в принципе, 2 часа с хвостом.

665: Давай упомянем зрителям, что есть примеры побитовых операций, сложения, отрицания, умножения, деления в сети. Конечно. Да, обычных. Примеры, примеры вот этих вот побитовых операций можно найти в интернете.

666: То, что мы сейчас с вами разобрали, вот самое как бы важное, ну вот 1 из самых важных, как бы, аспектов этой лекции, это как мы операции с интами, да, как мы можем перейти от них к операциям с

667: Из big decimal и вот эти вот все истории про сайзов.

668: Они были как бы сделаны, чтобы вы увидели, насколько просто перейти от децимал к big decimal.

669: Буквально там минимальными изменениями это делается.

670: Даже если мы возьмём вот этот кусок здесь, вместо того, чтобы поставить семёрку, вы ставите тройку и это работает для decimal, а не для big decimal не знаю зачем вам это надо побитовые операции, надо делать все как бы. Ну по крайней мере в этой, в этой имплементации на big decimal, иначе.

671: Вам будет грустно.

672: Но в общем то вот здесь как бы 2 таких базовых цикла вы либо проходитесь по всем битам, либо вы проходитесь по всем интам и проводите именно какие-то с ними операции.

673: Либо там сложение, либо вычитание, либо деление по факту. Вы же в делении, например, будете идти по каждому биту делителя.

674: И вы этот будете делитель, как бы двигать пока можете.

675: Нет, нет, это умножение, умножение. Вы идёте по, по битам 2 числа в делении, там вы делаете шифт, пока можете, ну, там надо чуть умнее поставить условия, ну, в общем то, там, да, через

676: Все это делать.

677: Разберутся, да, друзья, если, значит, преза будет, запись будет, презу могу хоть сейчас отправить. Она у меня есть, как бы, уже в пдфке. Если есть вопросы, вы можете написать.

678: Мне в рокете, я отвечу.

679: Можно договориться со мной. Я буду появляться по четвергам в школе. Если есть какие-то вопросы, вы можете меня найти, я вам на эти вопросы отвечу, потому что проект действительно непростой, и вы материал этот можете ещё

680: Пистолет разбирать из презы. Проще начать писать. Ну проще. Ну справедливо. Последнее наставление просто напишите. В 1 очередь напишите Гетт бит сет, бит Гетт.

681: Скилл сет скилл get sign сет сайн вот это вот напишите у нас даже этого не было написано мы так из за этого грустили и страдали не повторяйте наших ошибок, пожалуйста.

682: А вот молодцы. А вот, а у нас 3 умника не написали, так что я думаю, что на этом можно заканчивать. Пишите вопросы, если есть какие-то обязательно.

683: И там есть ещё, как я и обещала 2 комментария, там 2 слайдика с с приложениями, там немножко про, про то, как оставлять комментарии в функциях и про

684: Другой тип представления если вам вот хочется попробовать что-то более такое экзотическое, можете пробовать бинарно закодированные десятичные числа, то есть банк децима.

685: Это через файл тогда, да? Или как закодирован? Там идея. Смотри, у тебя есть 4 бита, 4 бита. У тебя каждый разряд десятичный хранится в 1, вот, вот в этих вот ниббл.

686: Они называются ниббл в 4 битовых группках, и по факту у тебя вот в каждой из этих группах хранится число от нуля до 9.

687: Там есть очень красивый такой прекрасный алгоритм преобразования двоичного числа вот в это вот как бы байнери децл.

688: Очень красиво и очень сложно объяснить, почему оно правильно работает. Мне, по крайней мере, я с этим не разобралась толком.

689: Через кстати кто-то через string делал это тоже вариант.

690: Ага, и там у тебя.

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

692: На самом деле оно так не кажется. Пока что оно выглядит очень страшно и непонятно, но это удобно, когда с этим разберёшься. Все, мне больше нечего вам сказать. Вопросы есть какие-то?

693: Нет, спасибо. Прекрасно. Хорошего вам вечера тогда, друзья.

694: Угу, да.