Скачать "КАК РАБОТАТЬ С БИТАМИ | ОСНОВЫ ПРОГРАММИРОВАНИЯ"

Обложка аудиозаписи

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

Предыдущее видео: Практический курс по SQL для начинающих - #4 Подзапросы в SQL Следующее видео: Графика в Python. Баллистика

0:00

Введение

2:19

Логические операторы

3:04

РЕКЛАМА

4:41

Битовые операторы

6:03

Сжатие аргументов

7:44

Узнать содержимое бита

8:26

Установка бита в 1

9:02

Установка бита в 0

9:20

Инверсия бита

10:03

РЕКЛАМА

11:31

Функции для работы с битами

12:01

Битовые сдвиги

13:02

Арифметический сдвиг

15:12

Логический сдвиг

15:40

Циклический сдвиг

16:05

Особенности битовых сдвигов

19:05

Дописываем функции для работы с битами

20:37

Битовый вектор

Графика в Python. Баллистика

Графика в Python. Баллистика

Канал: Алексей Белкин

Практический курс по SQL для начинающих - #4 Подзапросы в SQL

Практический курс по SQL для начинающих - #4 Подзапросы в SQL

Канал: EngineerSpock - IT & программирование

Практический курс по SQL для начинающих - #10 Функции pl/pgSQL

Практический курс по SQL для начинающих - #10 Функции pl/pgSQL

Канал: EngineerSpock - IT & программирование

Битовые операции

работа с битами

основы программирования

Alek OS

программирование

бит

байт

computer science

логические операторы

программирование с нуля

битовый вектор

00:00:02

чтобы мы могли не не вспоминать ее

00:00:04

расточительство больше не воспринимается

00:00:06

как что-то плохое однако до сих пор есть

00:00:08

области где я память это критический

00:00:10

ценный ресурс и от умение правильно ей

00:00:12

распоряжаться будет зависеть

00:00:14

работоспособность всей программы чтобы

00:00:17

не уходить далеко в дебри

00:00:18

программирования возьмем простой пример

00:00:20

в котором у нас есть массив на 8000

00:00:22

чисел среди которых присутствуют дубли

00:00:25

при этом известно что сами числа

00:00:27

находится в диапазоне от 1 до 8 тысяч

00:00:30

включительно нам нужно перебрать этот

00:00:33

массив цикле и вывести все дублина экран

00:00:36

чтобы на очередной итерации получив

00:00:38

число мы понимали является ли она дублем

00:00:40

где-то должно быть упоминание о том что

00:00:43

это число уже была прочитана самое

00:00:46

простое что мы можем сделать это создать

00:00:48

второй бульон массив на 8 тысяч

00:00:50

элементов и на каждой итерации по

00:00:53

индексу который равен текущему числу в

00:00:55

цикле -1 записывать труп помечая тем

00:00:58

самым что это число прочитано но перед

00:01:01

этим мы будем проверять что если по

00:01:03

этому индексу уже true стоит значит это

00:01:06

число уже была прочитана и следовательно

00:01:08

является дублем такой алгоритм отлично

00:01:11

будет работать но лишь до тех пор пока у

00:01:14

нас нет никаких ограничений по памяти

00:01:17

однако представим что нашем распоряжении

00:01:19

для решения этой задачи остался всего 1

00:01:22

кибибайт или 1024 байта несмотря на то

00:01:26

что нам для хранения true либо фолз

00:01:29

вполне хватило бы и одного бита в памяти

00:01:31

под каждое значение типа boolean будет

00:01:33

выделен 1 байт и следовательно полный

00:01:36

размер нашего массива будет составлять 8

00:01:39

тысяч по что совершенно никак не

00:01:41

вписывается в наше условие если бы мы в

00:01:44

памяти вместо 8000 баев выделили 8 тысяч

00:01:47

бит что равняется тысячи байтом то это

00:01:50

бы полностью решила все наши проблемы

00:01:52

однако тот факт что в компьютерах

00:01:54

используется бойцовая адресация не

00:01:56

позволяет нам напрямую обращаться

00:01:58

каждому биту в отдельности далеко не

00:02:00

каждый знает что хоть мы и не можем

00:02:02

обращаться к битам в памяти мы можем

00:02:05

работать с каждым битом внутри отдельно

00:02:07

взятого числа при помощи специальных

00:02:10

битовых операций попробуем разобраться

00:02:12

как это работает и что в итоге из этого

00:02:15

получится

00:02:19

программируя очередной алгоритм все мы

00:02:21

привыкли использовать такие логические

00:02:23

операторы как и или не которые работают

00:02:27

согласно таблицам истинности и

00:02:28

возвращают нам либо true либо фолз то

00:02:32

есть 1 и 0 это 0 1 или 0 это 1-ое так

00:02:36

далее в однако помимо логических

00:02:38

операторов в языках присутствуют и так

00:02:40

называемые битовые операторы про который

00:02:43

слышал уже далеко не каждый программист

00:02:45

не говоря уже об их использовании

00:02:48

подобные базовые темы часто остаются без

00:02:50

внимания как в ходе самостоятельного

00:02:52

обучения так и на различных обучающих

00:02:54

курсах фундаментальные основы это знание

00:02:57

которые помогут научиться мыслить как

00:02:59

программисты легко осваивать различные

00:03:01

языки программирования и технологии

00:03:03

хорошая новость том что есть еще школы

00:03:06

которые сохраняют в своем обучении этот

00:03:08

самый фундаментальный подход в одной из

00:03:11

таких школ является онлайн школа

00:03:12

программирования hex лет

00:03:14

программирование это единственный фокус

00:03:16

этой школы здесь не повторяют за

00:03:18

учителем а учат развивать

00:03:20

алгоритмическое мышление самостоятельно

00:03:22

находить ошибки и исправлять их

00:03:24

наставники в hex лети практикующие

00:03:26

разработчики они будут поддерживать тебя

00:03:28

на протяжении всего обучения поэтому ты

00:03:30

всегда сможешь спросить совет у

00:03:32

профессионала также в помощь тебе самое

00:03:34

большое комьюнити в рунете 27000

00:03:37

айтишников отсутствие какого-либо опыта

00:03:39

разработки и твой возраст не играют

00:03:42

никакой роли важно лишь твое желание

00:03:44

формат занятий здесь асинхронный учить

00:03:46

когда тебе удобно причем обучение можно

00:03:49

совмещать текущей занятостью а

00:03:51

образовательные контента и практика в

00:03:53

онлайн тренажере доступны 24 на 7 сейчас

00:03:56

у тебя есть отличный шанс начать свое

00:03:58

обучение вместе с hex лет и его

00:04:00

обновленным флагманским курсом front-end

00:04:02

разработчик

00:04:03

hex лети регулярно мониторит какие

00:04:05

компетенции востребованы и

00:04:06

работодателями поэтому ты получишь все

00:04:08

инструменты необходимые именно в

00:04:11

реальной разработки на курсе очень много

00:04:13

практики упражнения в онлайн тренажере

00:04:15

задачи повышенной сложности собственные

00:04:18

open source и четыре полноценных проекта

00:04:21

но самое главное после прохождения всей

00:04:23

программы тебя пригласят на оплачиваемую

00:04:25

стажировку в проект дайте кластера

00:04:28

ростелекома узнай подробности и

00:04:30

познакомься с полной программой обучение

00:04:32

по ссылке в описании а чтобы получить

00:04:35

скидку 10 процентов сообщил менеджеру

00:04:37

или в чат поддержки кодовое слово олег

00:04:40

уоз битовые операторы подчиняются все

00:04:43

тем же таблица истинности только

00:04:45

применяться не будут абсолютно каждому

00:04:47

биту своих оперантов например выражение

00:04:50

5 побитовое и 6 если бы это был

00:04:52

логический оператор это в некоторых

00:04:54

языках мы бы получили true но применив

00:04:57

побитовое и мы каким-то образом получаем

00:04:59

число 4 если представить наши данные в

00:05:02

двоичном виде то это перестает выглядеть

00:05:04

так абсурдно 5 выглядит как

00:05:07

1016 как 110 что мы с этим делаем мы

00:05:11

берем первый бит первого числа начиная с

00:05:14

младших разрядов и первый бит 2 числа и

00:05:17

согласно таблице истинности применяем к

00:05:19

ним побитовое и получаем 0 далее берем

00:05:22

вторые биты чисел снова применяем

00:05:24

битовая и и снова получаем ноль и в

00:05:27

конце берем 3 биты и применив к ним наш

00:05:29

оператор получаем 1 в итоге если это

00:05:32

число снова перевести в десятичный вид

00:05:34

то это окажется число 4 точно по такому

00:05:37

же принципу работают и все остальные

00:05:40

операторы единственная стоит понимать

00:05:42

что в зависимости от того на кого

00:05:44

используются типы или без знаковый мы

00:05:46

можем получать разный результат например

00:05:49

при инверсии байта в котором записано

00:05:50

число 8 мы получим либо число минус 9

00:05:54

если используется знаковый тип либо

00:05:56

число 247 если тип был без знаковый

00:05:58

почему это именно так ты можешь узнать

00:06:00

из ролика на канале про отрицательные

00:06:02

числа частый пример того где мы могли бы

00:06:05

встретить работу этих операторов это

00:06:07

ситуации в которой в качестве параметра

00:06:10

функции передается запись такого вида

00:06:12

изначально функция ожидала получить три

00:06:14

состояния мы в зависимости от того true

00:06:17

в них передан или фолз будут происходить

00:06:19

какие-то действия для этого мы могли бы

00:06:22

просто передать три параметра типа

00:06:23

boolean затем каждый из них проверять в

00:06:25

отдельности и несмотря на то что нам

00:06:28

требовалось передать всего три бита в

00:06:30

памяти будет выделено 24 бита но

00:06:33

благодаря это вам оператором мы можем

00:06:36

передать эти три состояния сжатые всего

00:06:38

в одно число типа байт первые три бита

00:06:40

которого и будут соответствовать нашим

00:06:43

состоянии чтобы это сделать нам

00:06:45

понадобится три переменные типа байт

00:06:47

равный одному 2 и 4 чтобы понять почему

00:06:50

именно такие значения достаточно

00:06:53

посмотреть как эти числа выглядят в

00:06:55

двоичном виде у первого числа в единицу

00:06:57

установлен только один самый первый бит

00:07:00

2 числа только 2 бит и у третьего числа

00:07:03

только 3 и применяя теперь побитого я

00:07:06

или к этим переменам мы будем получать

00:07:08

передаваемый параметр с теми битами

00:07:10

которые нам требуется установить то есть

00:07:13

применив битва или к первой и третьей

00:07:15

переменной мы получим число у которого в

00:07:17

единицу установленные первый и третий

00:07:19

бит времени побитого или ко всем трем

00:07:22

переменным мы получим установленные все

00:07:24

три бита в единицу из этих восьми бит у

00:07:27

нас по-прежнему остаются

00:07:28

неиспользованные биты но теперь их

00:07:30

количество сократилось всего до 5 теперь

00:07:33

внутри функции вместо проверки каждой из

00:07:35

трех переменных нам требуется проверить

00:07:37

каждый из трех битов передаваемого числа

00:07:40

но как нам узнать что находится внутри

00:07:43

отдельно взятого бита в этом нам поможет

00:07:45

побитовое оператор и к искомому биту

00:07:48

числа мы должны примените единицу ко

00:07:51

всем остальным битвам применить 0 это

00:07:53

позволит там занулить все биты исходного

00:07:55

числа которые нас не интересуют

00:07:57

вне зависимости от того чему они были

00:07:59

равны но единственный из комы бит если

00:08:02

он был единиц это он ей останется если

00:08:05

же он был нулем то тоже превратиться в

00:08:08

ноль в итоге получается что итоговое

00:08:10

число которое мы получим всегда будет

00:08:13

или равно нулю если искомый бит был

00:08:15

равен нулю либо она будет нулю не равно

00:08:18

если искомый бит был единицы именно по

00:08:21

этому признаку мы определим чем у был

00:08:24

равен конкретный бит но одними только

00:08:26

проверками работа сбитыми не

00:08:28

ограничивается мы бы хотели иметь

00:08:30

возможность изменять значение нужного

00:08:32

нам бита устанавливая его в единицу или

00:08:35

наоборот сбрасывая его в ноль как это

00:08:38

сделать мы берем исходное число и решаем

00:08:41

что хотим поменять второй вид справа на

00:08:43

единицу сейчас там стоит ноль чтобы из

00:08:46

нуля получить единицу нам нужно

00:08:49

применить к нему побитовое или вместе с

00:08:51

единицей все остальные биты снова нужно

00:08:54

занулить в итоге получается что 2 бит

00:08:56

исходного числа изменится на единицу во

00:08:59

все остальные биты какими были такими и

00:09:02

останутся чтобы обнулить бит нужно чтобы

00:09:05

наоборот по целевым битом находился 0 а

00:09:07

под всеми остальными единицы только

00:09:10

вместо побитого или мы применим

00:09:12

побитовое и это снова нам позволит

00:09:14

сохранить все биты которые нас не

00:09:16

интересуют в исходном виде по целевой

00:09:18

бит поменять на 0 помимо этих операции

00:09:21

мы можем попробовать полностью бит

00:09:23

инвертировать вне зависимости от того

00:09:25

чему он равен то есть если там была

00:09:27

единица то она должна стать нулем если

00:09:30

там был 0 то он должен стать единицы для

00:09:33

решения этой задачи нам поможет еще один

00:09:35

вид новый оператор исключающее или

00:09:38

работает он по принципу что все

00:09:39

одинаковые значения дают ноль все разные

00:09:42

значения дают единицу поэтому под нужный

00:09:45

бит нужно подогнать единицу на все

00:09:47

остальные биты заполнить нулями в итоге

00:09:50

ноль и один даст нам единицу а все

00:09:52

остальные биты останутся без изменений и

00:09:55

наоборот если бы в исходном виде стояла

00:09:57

единицу то один и один дадут нам 0 то

00:10:00

есть инвертирование произойдет в любом

00:10:02

случае одни из главных качеств успешного

00:10:04

программиста это усидчивости и

00:10:06

концентрация конечно наше время когда

00:10:08

вокруг столько отвлекающих факторов

00:10:09

достаточно сложно сконцентрироваться над

00:10:12

задачей если ты постоянно отвлекаешься

00:10:14

от работы в твоих проектах не валялся

00:10:16

коня дедлайны поджимают тогда тебе

00:10:19

идеально подойдет австрийский на

00:10:20

антропный комплекс myth buster который

00:10:22

станет незаменимым помощником для

00:10:24

нервной системы при высоких умственных

00:10:26

нагрузках он поможет не только

00:10:28

сконцентрироваться на от текущей задачей

00:10:30

но и в долгосрочной перспективе

00:10:32

сформировать нужные нейроны так

00:10:34

необходимый для получения новых знаний и

00:10:36

совершенствования скилов разработки

00:10:38

связка из десяти органических

00:10:40

компонентов поможет победить усталость и

00:10:42

депрессию увеличит мотивацию улучшит

00:10:45

память креативность и скорость обучение

00:10:48

причем часть этого составом дает эффект

00:10:50

уже сразу после применения а пройдя

00:10:53

шестинедельный курс выпивая по 2 капсулы

00:10:55

в день ты заметишь у себя значительные

00:10:57

структурные улучшения и как

00:11:00

дополнительный бонус в разы сократится

00:11:01

количество выпитого кофе важно что myth

00:11:04

buster прошел необходимое испытания и

00:11:06

официально зарегистрирован что можно

00:11:08

проверить в реестре прежде чем

00:11:10

советовать myth buster вам я сама

00:11:12

пробовал его на себе и скажу что если

00:11:15

использовать его вкупе с правильным

00:11:16

образом жизни то можно очень сильно

00:11:19

поднять кпд своей работы особенно

00:11:21

кропотливый удобнее всего приобрести его

00:11:23

на сайте производителя ссылка в описании

00:11:26

масс промо-кода малик можно получить

00:11:28

скидку 10 процентов

00:11:31

все что мы рассмотрели можно записать в

00:11:33

виде кода состав соответствующие функции

00:11:35

для получения бита для установки его в

00:11:38

единицу для его инверсии и для его

00:11:41

установки в ноль в каждую функцию мы

00:11:44

передаем числом сбитом которого нам

00:11:45

требуется работать и номер этого бита

00:11:48

относительно младших разрядов

00:11:50

однако на этом моменте у нас появляется

00:11:53

небольшая проблема как нам автоматически

00:11:55

сгенерировать такое число в котором

00:11:58

единица будет стоять в нужный нам

00:12:00

позиция чтобы решить эту проблему нужно

00:12:03

познакомиться с ещё одной группой битвах

00:12:05

операции называемых бита вами сдвигами в

00:12:09

чем их смысл у нас есть число 1 у

00:12:11

которого в самом младшем разряде

00:12:12

находится единичка и с помощью оператора

00:12:15

битового сдвига мы можем стрелять все

00:12:18

это число до тех пор пока единица не

00:12:20

встанет по тот бит который нам нужен

00:12:23

кажется все просто однако в работе

00:12:25

битовых сдвигов существует довольно

00:12:26

много тонких моментов о которых следует

00:12:28

знать перед тем как начать ими

00:12:30

пользоваться во первых существует сразу

00:12:33

три типа битвы сдвигов это

00:12:35

арифметический сдвиг логический и

00:12:37

циклический наличие или отсутствие того

00:12:40

или иного битового сдвига будет зависеть

00:12:42

от конкретного языка программирования

00:12:44

например все плюс плюс сишарп или питоне

00:12:47

есть только арифметические сдвиги на в

00:12:50

таких языках как java и или java-script

00:12:52

помимо арифметического сдвигом есть еще

00:12:54

и логически помимо этого сдвиги могут

00:12:57

происходить как в левую такое в правую

00:12:59

сторону но начнем по порядку

00:13:02

арифметический сдвиг вправо слева от

00:13:04

него записывается число бит и которого

00:13:06

нужно сдвинуть справа на сколько бит

00:13:09

должен быть произведен сдвиг произведя

00:13:12

сдвиг к примеру на один бит мы замечаем

00:13:14

что у нас освобождается позиция слева то

00:13:17

чем она будет заполнена будет зависеть

00:13:19

от типа сдвига в случае с правом

00:13:21

арифметическим сдвигом она будет

00:13:23

заполнено битом знака то есть если число

00:13:25

было положительным то она заполнится

00:13:27

нулем если число было отрицательным то

00:13:29

она заполнится единицы случай с

00:13:32

арифметическим сдвигом влево

00:13:33

освободившиеся справа позиция будет

00:13:36

заполняться не битом знака а к нулю если

00:13:38

мы теперь соберем обратно получившиеся

00:13:40

числа из двоичной системы в десятичную

00:13:42

то заметим одну особенность изначально и

00:13:45

число 8 после правого арифметического

00:13:48

сдвига уменьшилась ровно в два раза а

00:13:51

после левого арифметического сдвига она

00:13:54

наоборот ровно в два раза увеличилась

00:13:56

дело в том что арифметические битовые

00:13:58

сдвиги являются аналогами и деления и

00:14:00

умножения только делают они это во много

00:14:03

раз быстрее привычных нам операции

00:14:05

поэтому в некоторых ситуациях их

00:14:07

довольно часто используют для

00:14:08

оптимизации сдвиг на один влево это

00:14:11

умножение на 2 сдвиг влево на 2 это

00:14:13

умножение на 4 и так далее поэтому можно

00:14:16

сказать что сдвиг на and beat влево это

00:14:18

то же самое что и умножить число на 2 в

00:14:21

степени n

00:14:22

аналогичные не с правым сдвигом сдвиг

00:14:25

вправо на 1 а это то же самое что и

00:14:26

разделить число на 2 сдвиг вправо на 2

00:14:29

поделить число на 4 сдвиг вправо на 3

00:14:31

поделить число на 8 и так далее

00:14:33

следовательно сдвиг на in beat вправо

00:14:36

это делении числа на 2 в степени n но

00:14:38

важный момент деление происходит с

00:14:41

округлением в меньшую сторону

00:14:42

например если мы попытаемся число 9

00:14:45

сдвинуть на один бит правок то вместо

00:14:47

четырех с половиной мы получим целое

00:14:49

число 4 однако это выделение есть одно

00:14:52

исключение это число минус 1 в

00:14:55

дополнительном коде она представляет

00:14:57

собой все единицы и следовательно сделав

00:14:59

арифметический сдвиг вправо свободная

00:15:02

позиция слева снова заполнится единицей

00:15:04

поэтому мы снова получим число минус 1

00:15:07

число никак не меняется и соответственно

00:15:10

никакого деления не происходит второй

00:15:12

тип битовых сдвигов иметь название

00:15:15

логический при сдвиге вправо

00:15:16

освободившаяся позиция заменяется не

00:15:19

битом знака как это происходит в

00:15:21

арифметическом сдвигом а нулем

00:15:23

происходит точно такое же деление однако

00:15:26

актуально но только когда мы используем

00:15:28

by знаковые типы потому что вместо

00:15:30

сохранения знаком старший бит всегда

00:15:32

будет подставляться 0 0 логический сдвиг

00:15:35

работает идентична арифметическому

00:15:38

поэтому двигаемся дальше циклический

00:15:40

сдвиг работает исходя из своего названия

00:15:43

по циклу то есть если мы сдвигаем бит

00:15:45

справа то этот сдвинутый бит будет

00:15:47

перенесён в левую освободившуюся позицию

00:15:50

и наоборот если мы сдвигаем бит влево то

00:15:52

вышедший за пределы регистра бит будет

00:15:55

перенесён в освободившийся разряд справа

00:15:58

все работает довольно логично но лишь до

00:16:00

тех пор пока мы сдвигаем биты на

00:16:02

относительно маленькие величины например

00:16:05

у нас было 32-битное число 16 после

00:16:08

левого сдвига на 3 бита мы ожидаем а

00:16:11

получаем число 128 и и логично что если

00:16:14

мы сдвинем это число к примеру на

00:16:15

тридцать три бита то все изначальные вид

00:16:18

и числа полностью выйдут за пределы

00:16:20

регистра и следовательно число в которой

00:16:23

у нас должно получиться будет равно нулю

00:16:26

однако на самом деле мы получаем число

00:16:28

32 и чтобы понять что здесь произошло

00:16:31

стоит погрузиться немного в историю во

00:16:33

времена когда процессоры были еще только

00:16:36

16 бит ними сдвиг который бы имел смысл

00:16:39

16 битном регистре составляет от 0 до 16

00:16:43

потому что каждый последующий сдвиг в

00:16:45

этом диапазоне будет давать нам разный

00:16:48

результат при сдвиге на 16 мы полностью

00:16:50

сдвигаемся обито исходного числа за

00:16:52

пределы регистра и получаем число 0

00:16:55

следовательно все остальные сдвиги

00:16:57

начиная от 17 и дальше являются

00:17:00

бесполезными потому что они тоже будут

00:17:02

давать там один и тот же результат ноль

00:17:04

такая работа сдвигов выглядит вполне

00:17:06

логично однако в то время процессорах

00:17:09

еще не было устройство быстрого битового

00:17:11

сдвига поэтому к примеру сдвиг на 125

00:17:14

бит будет выполняться намного дольше чем

00:17:16

сдвиг на 16 бит это при том что в итоге

00:17:19

они дают нам один и тот же результат

00:17:21

поняв это разработчики подумали и решили

00:17:24

что пускай начиная с 286 модели

00:17:27

процессора из числа на которое мы хотим

00:17:30

сдвинуть будут браться только младший 5

00:17:33

бит это означает что если теперь мы

00:17:35

захотим сдвинуть число на 125 бит а он

00:17:39

на самом деле сдвиг произойдет только на

00:17:41

29б краткий экскурс математику чтобы

00:17:45

получить из числа последний and beat

00:17:47

нужно поделить это число по модулю на

00:17:49

основании в степени n то есть поделив и

00:17:51

x по модулю на 2 в пятой степени мы

00:17:54

получим число состоящая из пяти

00:17:56

последних битв числа x в 5 бит

00:17:59

помещаются числа от 0 до 31 и это

00:18:03

означает что на какое бы число вы теперь

00:18:06

не попытались произвести сдвиг после

00:18:08

деления его по модулю мы всегда будем

00:18:10

получать одно из чисел в этом диапазоне

00:18:12

такая логика сдвигов актуально как для

00:18:15

положительных чисел так и для

00:18:17

отрицательных шло время и на свет

00:18:20

появился 32 битный процессор 80 386 этот

00:18:24

процессор получил устройство быстрого

00:18:26

битового сдвига что означало выполнении

00:18:29

любого сдвига за одну операцию однако

00:18:32

логика работы с последними 5 битами

00:18:34

по-прежнему продолжала работать пока что

00:18:37

текущего сдвига на 31 нам вполне хватает

00:18:40

так как регистр на 32 бита но с

00:18:44

появлением 64-битных процессоров размер сдвига

00:18:47

нужно было увеличивать поэтому вместо

00:18:49

последних 5 бит стали брать 6 бит в 6

00:18:52

бит помещается диапазон чисел от 0 до 63

00:18:55

что нас снова вполне устраивает из-за

00:18:59

обратной совместимости со старым

00:19:00

программным обеспечением такая логика

00:19:02

работы поддерживается и по сей день

00:19:05

теперь зная все это мы можем дописать

00:19:08

наши четыре функции функция определения

00:19:11

битва нам нужно единицу сдвинуть на

00:19:13

позицию искомого бита искомая позиция

00:19:16

это номер бита которой мы передаем в

00:19:18

параметре индекс поэтому просто

00:19:21

применяем к единице арифметический сдвиг

00:19:23

влево на яндекс в конце мы возвращаем

00:19:26

результат сравнения получившегося числа

00:19:28

на неравенство с нулем если число не

00:19:31

равно нулю то обед был равен единице и

00:19:33

мы вернем true если число было равно

00:19:36

нулю то значит бит был тоже равен нулю

00:19:38

возвращаем falls функция установки битом

00:19:41

и точно также сдвигаем единицу на яндекс

00:19:44

влево и возвращаем результат

00:19:47

аналогично выглядит и функция инверсии

00:19:50

бита где нам тоже достаточно сдвинуть

00:19:52

единицу на нужную нам позицию все эти

00:19:55

три функции объединяют то что после

00:19:57

левого сдвига правой биты автоматически

00:20:00

заполняются нулями и такое поведение нас

00:20:03

абсолютно устраивает однако последний

00:20:05

функция установки битов 0 нам требуется

00:20:07

сделать противоположное подгонять нам

00:20:10

нужно не единица 0 ом все освободившиеся

00:20:12

биты должны заполняться не нулями и

00:20:15

единицами как нам этого достичь для

00:20:17

начала мы все-таки снова сдвинем единицу

00:20:20

на нужную позицию затем просто возьмем и

00:20:23

полностью инвертируем by это числа

00:20:25

которые у нас получится в итоге наша

00:20:27

единица заменятся нулем а все остальные

00:20:30

биты заменятся единичками далее

00:20:33

применяем битовая и и возвращаем

00:20:36

итоговый результат хорошо у нас есть

00:20:38

четыре готовой функции для работы с

00:20:41

битами и вспоминая нашу задачу с бульон

00:20:43

массива мы говорили что было бы неплохо

00:20:45

если бы вместо 8000 байт можно было бы

00:20:48

выделить памяти 8000 биты хранить в

00:20:50

каждом бите либо ноль либо единицу у нас

00:20:54

практически появилась такая возможность

00:20:56

осталось лишь понять как организовать

00:20:58

такую структуру данных который бы смогла

00:21:01

таким образом хранить бита для начала

00:21:04

стоит понять что выделять в памяти мы

00:21:06

все равно можем значение только которые

00:21:08

кратные восьми битам но так как мы

00:21:11

теперь можем работать с битами и каждого

00:21:13

числа то значит там достаточно выделить

00:21:15

памяти столько байт чтобы в сумме они

00:21:18

либо равнялись либо превышали 8000 бит

00:21:21

понятно что это не одно число поэтому мы

00:21:23

заведем массив целых чисел к примеру

00:21:25

типа int тип имт составляет 32 бита это

00:21:29

означает что нам нужно выделить памяти

00:21:31

250 таких чисел такая структура данных

00:21:35

называется битовый вектор по факту это

00:21:37

обычный одномерный массив фунтов в

00:21:39

котором каждый бит каждого числа можно

00:21:42

представить как отдельные независимое

00:21:44

значение для начала для более удобного

00:21:47

восприятия этой информации создадим

00:21:50

битовый вектор всего на 32 бита то есть

00:21:53

мы можем создать массив на 4 числа типа

00:21:55

байт или например массив на два числа

00:21:57

типа short вели массив одно число типа

00:21:59

им что по сути не имеет смысла главное

00:22:02

чтобы суммарно количество бит всех чисел

00:22:04

минимум составляла 32 далее стоит

00:22:07

понимать что нас абсолютно не интересует

00:22:09

какие числа в итоге будут в этом массиве

00:22:11

нас интересует только отбита этих чисел

00:22:14

поэтому данный одномерный массив условно

00:22:17

можно представить как двумерный где

00:22:19

числа одномерного массива это строки а

00:22:22

их биты это колонки чтобы в двухмерном

00:22:25

массиве обратиться к нужной ячейки

00:22:26

нужно сначала обратиться к yandex строки

00:22:29

затем к индексу колонке мы будем

00:22:31

придерживаться точно такой же логике

00:22:33

поэтому для начала про индексируем все

00:22:35

наши строки и колонки единственное

00:22:38

отличие от двухмерного массива в том что

00:22:40

нумерация наших колонок будет

00:22:41

производиться справа налево от 0 до 15

00:22:44

по направлению от младших битов к

00:22:47

старшим далее стоит понимать что мы

00:22:49

работаем с битовым вектором как с

00:22:51

набором 32-bit поэтому для

00:22:53

взаимодействия сбитом мы просто будем

00:22:55

передавать его номер от 0 до 31 и в

00:22:59

зависимости от этого номера мы будем

00:23:01

определять в какой строке и в какой

00:23:03

колонки находится бит с данным номером

00:23:06

например мы хотим узнать чему равен бит

00:23:08

с номером 24 глазами мы видим что он

00:23:11

находится во второй строке с индексом 1

00:23:13

и в колонке с индексом 8 но нам нужно

00:23:17

чтобы эти два значения определялись

00:23:19

программно для этого мы создадим две

00:23:21

дополнительные функции на вход они обе

00:23:23

будут принимать номер бита а на выходе 1

00:23:26

из них будет возвращать индекс строки 2

00:23:28

индекс колонки чтобы узнать индекс

00:23:30

строки нам достаточно номер бита

00:23:33

разделить на количество колонок в строке

00:23:35

всего ik16 поэтому можно воспользоваться

00:23:37

стандартным делением а можно вспомнить

00:23:40

что деление на 16 является аналогом

00:23:42

арифметического сдвига вправо на 4

00:23:45

получившееся число нужно округлить вниз

00:23:48

чтобы теперь получить индекс колонки

00:23:50

нужно этот номер битом поделить на

00:23:52

количество колонок строки и затем

00:23:54

вернуть остаток от этого деления

00:23:57

выполнив эти две функции для обито с

00:23:59

номером 24 мы получим индекс строки 1 и

00:24:02

яндекс нашей колонке 8 хорошо теперь

00:24:05

немного подредактирую наши четыре

00:24:07

функции каждый из них теперь

00:24:09

передаваемый индекс будет являться

00:24:11

номером бита орбита вам векторе с

00:24:12

которым мы хотим что-то сделать далее мы

00:24:15

получаем индекс строки и яндекс колонки

00:24:17

в соответствующие переменные затем

00:24:20

вместо нам пора обращаемся к индексу

00:24:22

нашего массива то есть грубо говоря

00:24:24

обращаемся к строке далее индекс меняем

00:24:27

на яндекс кол который соответствует

00:24:29

позиции нашего искомого бита внутри

00:24:31

числа все остальное остается без

00:24:34

изменений и теперь все что нам осталось

00:24:36

сделать это в цикле перебирая наш массив

00:24:39

обращаться к биту по номеру равному

00:24:41

текущему числу в цикле -1 потому что

00:24:43

счет битов массиве начинаются с нуля и

00:24:45

проставлять единицы как знак того что

00:24:47

это число было прочитано если этот бит

00:24:51

уже был равен единице значит мы нашли

00:24:53

дубль на самом деле битовые векторы как

00:24:56

структура данных хуже реализованного

00:24:58

многих языках программирования и каждый

00:25:01

раз писать все это с нуля конечно не

00:25:02

требуется максимальное количество бит

00:25:05

которая битовый вектор сможет хранить

00:25:07

будет равно максимальному размеру типа

00:25:09

умноженная на максимальный размер

00:25:11

массива в языке подписывайся на канал и

00:25:14

в социальных сетях если ты еще этого не

00:25:16

сделал это лучшая поддержка которую ты

00:25:19

можешь мне дать увидимся в следующих

00:25:21

видео

Описание:

Начни изучать программирование на курсе Frontend-разработчик от Хекслет https://ru.hexlet.io/programs/frontend А чтобы получить скидку 10% - сообщи менеджеру или в чат поддержки кодовое слово AlekOS 🧠 MindBooster от Nooteria Labs: ноотропный комплекс для улучшения внимания, памяти, мотивации и работы мозга: https://vivaherb.ru/product/mindbooster/ Битовые операции. Из-за того, что в компьютерах используется байтовая адресация, мы вынуждены выделять в памяти минимум 8 бит. Однако есть задачи, в которых память критична, а размер данных настолько мал, что можно обойтись и битами. В этом видео показано как работать с каждым битом в отдельности, и в какую структуру данных всё это выльется. Подписывайся в соц. сетях: Телеграм - https://t.me/Alek_OS ВК - https://vk.com/alekos1 Яндекс Дзен - https://dzen.ru/id/62220edf240e7221b567946a ❤️ Поддержка канала: Бусти - https://boosty.to/alekos Юмани - https://yoomoney.ru/to/410011179144828 Патреон - https://www.patreon.com/AlekOS1 ✔️ Полезные ссылки: Основы программирования - https://www.youtube.com/watch?v=Wh22_O8jXVQ&list=PLIJLLSrXDPojDGKW0WZ7sU0eO3nyn0oDc&t=0s Полезно знать - https://www.youtube.com/watch?v=PS4S8BnURYU&list=PLIJLLSrXDPoibU-4S40dY6OpALf3nNOjA&t=0s 00:00 Введение 02:19 Логические операторы 03:04 РЕКЛАМА 04:41 Битовые операторы 06:03 Сжатие аргументов 07:44 Узнать содержимое бита 08:26 Установка бита в 1 09:02 Установка бита в 0 09:20 Инверсия бита 10:03 РЕКЛАМА 11:31 Функции для работы с битами 12:01 Битовые сдвиги 13:02 Арифметический сдвиг 15:12 Логический сдвиг 15:40 Циклический сдвиг 16:05 Особенности битовых сдвигов 19:05 Дописываем функции для работы с битами 20:37 Битовый вектор

Готовим варианты загрузки

Популярные

HD видео

Только звук

Все форматы

* — Если видео проигрывается в новой вкладке, перейдите в неё, а затем кликните по видео правой кнопкой мыши и выберите пункт "Сохранить видео как..."

** — Ссылка предназначенная для онлайн воспроизведения в специализированных плеерах

Вопросы о скачивании видео

Как можно скачать видео "КАК РАБОТАТЬ С БИТАМИ | ОСНОВЫ ПРОГРАММИРОВАНИЯ"?

Сайт http://unidownloader.com/ — лучший способ скачать видео или отдельно аудиодорожку, если хочется обойтись без установки программ и расширений. Расширение UDL Helper — удобная кнопка, которая органично встраивается на сайты YouTube, Instagram и OK.ru для быстрого скачивания контента.
Программа UDL Client (для Windows) — самое мощное решение, поддерживающее более 900 сайтов, социальных сетей и видеохостингов, а также любое качество видео, которое доступно в источнике.
UDL Lite — представляет собой удобный доступ к сайту с мобильного устройства. С его помощью вы можете легко скачивать видео прямо на смартфон.

Какой формат видео "КАК РАБОТАТЬ С БИТАМИ | ОСНОВЫ ПРОГРАММИРОВАНИЯ" выбрать?

Наилучшее качество имеют форматы FullHD (1080p), 2K (1440p), 4K (2160p) и 8K (4320p). Чем больше разрешение вашего экрана, тем выше должно быть качество видео. Однако следует учесть и другие факторы: скорость скачивания, количество свободного места, а также производительность устройства при воспроизведении.

Почему компьютер зависает при загрузке видео "КАК РАБОТАТЬ С БИТАМИ | ОСНОВЫ ПРОГРАММИРОВАНИЯ"?

Полностью зависать браузер/компьютер не должен! Если это произошло, просьба сообщить об этом, указав ссылку на видео. Иногда видео нельзя скачать напрямую в подходящем формате, поэтому мы добавили возможность конвертации файла в нужный формат. В отдельных случаях этот процесс может активно использовать ресурсы компьютера.

Как скачать видео "КАК РАБОТАТЬ С БИТАМИ | ОСНОВЫ ПРОГРАММИРОВАНИЯ" на телефон?

Вы можете скачать видео на свой смартфон с помощью сайта или pwa-приложения UDL Lite. Также есть возможность отправить ссылку на скачивание через QR-код с помощью расширения UDL Helper.

Как скачать аудиодорожку (музыку) в MP3 "КАК РАБОТАТЬ С БИТАМИ | ОСНОВЫ ПРОГРАММИРОВАНИЯ"?

Самый удобный способ — воспользоваться программой UDL Client, которая поддерживает конвертацию видео в формат MP3. В некоторых случаях MP3 можно скачать и через расширение UDL Helper.

Как сохранить кадр из видео "КАК РАБОТАТЬ С БИТАМИ | ОСНОВЫ ПРОГРАММИРОВАНИЯ"?

Эта функция доступна в расширении UDL Helper. Убедитесь, что в настройках отмечен пункт «Отображать кнопку сохранения скриншота из видео». В правом нижнем углу плеера левее иконки «Настройки» должна появиться иконка камеры, по нажатию на которую текущий кадр из видео будет сохранён на ваш компьютер в формате JPEG.

Сколько это всё стоит?

Нисколько. Наши сервисы абсолютно бесплатны для всех пользователей. Здесь нет PRO подписок, нет ограничений на количество или максимальную длину скачиваемого видео.