Want to nail down stacks? This beginner-friendly video breaks down the stack data structure with clear diagrams and a laid-back vibe. We’ll walk you through how stacks work, why they reverse data (hello, LIFO – Last In, First Out), and how they’re used in real-world stuff like browser history, undo features in editors, and even the call stack in your code. Whether you’re just starting out or brushing up on data structures, we keep it simple with hands-on demos of pushing, popping, and checking stack size—no boring jargon here! Subscribe for more coding tutorials to level up your skills, and let us know in the comments what you want to learn next. Check out our site via the QR code in the video for more coding goodness!

Introduction to Stack 00:00:00
Explaining Stack Concept 00:00:06
Drawing Stack Diagram 00:00:30
Adding Elements to Stack 00:00:53
Stack Rules and Operations 00:01:16
Pop Operation and Interface 00:06:09
Stack Size and Empty Check 00:07:59
Tracing Stack Operations 00:11:46
Stack as Data Reverser 00:17:44
LIFO/FILO Explanation 00:21:13
Stack Use Cases 00:24:10
Call Stack Mention 00:26:18
Conclusion and Subscribe Request 00:27:21
Outro and Website Promotion 00:28:34

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social

Please help support us!

• Subscribing + Sharing on Social Media
• Leaving a comment or suggestion
• Subscribing to our Blog
• Watching the main “pinned” video of this channel for offers and extras

Hello there.

In this video, I’m going to show you a data structure called a stack.

We’re going to make a diagram of it.

We’re going to explain how it works.

We’re going to look at its typical interface,

and we’re just going to kind of work through the concept

of what is a stack and what does it do and all that stuff.

Where’s your daddy and what does he do?

So for starters, what am I talking about?

What am I talking about?

Let me open up a little notepad here.

And I’m going to start drawing.

A stack is pretty simple when you first think about it.

It just takes a little bit more work to really get all the details down.

Imagine I have a data structure and maybe like at the bottom here,

there’s like some grass.

And so we can say that the data structure is empty when we first start.

Okay, so there’s kind of a stack here, but it’s empty.

So there’s nothing really on screen.

Imagine then I wanted to add integers into this stack.

So I’m going to say let’s add the integers eight and then two and then three and then four for some reason.

Okay, so how do we do this?

The first thing we do is we take the eight and we just put it on top of the stack.

You can imagine this as a stack of boxes or a stack of books or a stack of whatever.

When we add items, we’re always going to add to the top of the stack.

When the stack is empty, we’re obviously just going to add like at the very bottom, you know, at the ground floor.

But that’s sort of the top.

when we add the two here the next thing that happens is we just put the two on top of the eight

and the next thing that we do is we uh put the three on top of the two and so forth right so

it’s important to understand a few a few rules about stacks let me add that four real fast

in stacks you’re only allowed to add to the top or remove from the top you’re not allowed to add

or remove from anywhere else let me put a t for top right here so basically you’re allowed to add

So basically you’re allowed to add and remove from the top.

So if I wanted to add, let’s say a 12, the 12 would have to go on top of the four.

It couldn’t go anywhere else in this data structure.

And if I wanted to remove data from this stack, I could only remove the four.

I could not remove the three or two or the eight or anything.

You’re also not allowed to look at the middle of the stack.

You’re not allowed to look anywhere but the top.

So if I wanted to look at the three, the two or the eight, I wouldn’t be allowed to do it.

I can only look at the four.

look at the four and if I want to see that three I have to pop the four off

first in order to just see what’s under it and technically unless you have the

data you added memorized somewhere else you probably shouldn’t know what’s under

the four until you actually remove it okay so we can add and remove from the

top we can’t look in the middle we can’t look at the bottom or anything like that

and let’s do a little let’s do a little sequence of pops let me show you what

So first off, you can imagine a stack is sort of like a vector or a list with less functionality or more restrictions.

It’s useful to add restrictions on top of more robust data structures for the purposes of, I don’t know, kindling your imagination or allowing yourself to use easier implementations or whatever.

If you’re a musician or artist, probably at some point you’ve been stumped and you’ve had writer’s block and you can’t figure out what to create.

can’t figure out what to create so uh you know i know sometimes musicians when they get writer’s

block they’ll they’ll go to the swap meet and they’ll buy like an old dusty dirty uh casio

keyboard from 1985 and then they’ll write a full song just with that one piece of equipment and it

really stirs their creativity or it sparks their creativity and then when they’re done then they’ll

probably upgrade to better equipment but anyway so there’s there’s a bunch of different reasons to

use you know lesser data structures although this is not really lesser it’s very useful

It’s very useful in its own right.

So let’s see the interface.

So what can we do in a stack?

I’m going to put S for stack.

Actually, I’m just going to type this up as code.

No need to use the pen the whole entire time.

Let’s see.

So I’m going to put S for stack.

Maybe I’ll say, you know, stack that holds integers.

And I’ll just put an S here.

If you don’t know how to code right now, at this point in your career, just bear with

me.

variable of type stack and in C++ these stacks you know stacks are a template of data structure

which means the integers that we are holding inside of the stack they could be any other data

type that we wanted to including custom classes so in C++ we would use these angle brackets to

say I want my stack to hold integers and then I’m going to say s is the variable that I’ll use for

the stack so but this is not really a programming video this is just about stacks so if I wanted to

stack to push something like onto the top of the stack i would use the the method push the method

push usually has this prototype let’s see i’ll do stack push and it usually takes in a t type element

and again the t type it’s a templated data type which means right now if i just declared a stack

that was of type integer it holds integers then the t would actually expand under the hood in c

hood in C++ anyway at compile time to be an integer. So it would be like typing int e, right?

So whenever I type t, just understand that that means one instance of a thing that you could put

into the stack. So we’ve got a push here and usually the return type is void and it takes in

one element to push. And that means if I’m going to actually call, let me put some comments here.

If I’m going to actually call push on the stack, I’ve got to give it something to push and the

type of the thing that I’m pushing has to match what the stack was declared to hold. So in this

case, it’s integers. So I’m going to put an eight to match the diagram up above. And then after that,

maybe I wanted to push another number. So it’s going to be a two. And I’m just going to match

what the diagram has up above. So eight, two, three, four. So that’s the interface for pushing

usually in C++. And other languages should be similar. The other thing you can do with stacks

We haven’t done that yet, but let me show it to you first.

POP usually comes in two forms,

depending on what implementation you’re looking at.

So sometimes POP returns nothing.

It simply removes an item from the top of the stack.

And sometimes it returns a copy of the item

that you’re actually removing.

So I’m going to put like stack here and then like stack

just to show you that it’s inside of the namespace.

Oh, I don’t know.

Maybe that’s too C++y.

I’ll get rid of that stuff.

Hold on.

hold on so we’ll maybe do this just to show you that we have three separate

parts to this little code snip so sometimes pop doesn’t give you a copy of

the thing it removes sometimes it gives you a copy of the thing it removes in

cases where pop does not give you a copy of the thing it removes then you would

probably want to call top right before you popped and top will return a copy of

Just to clarify, if I wanted to remove something and get a copy of it and I had this line 13

form of pop from whatever implementation I was using, then well, I would just call pop

and I would do something like this, you know, auto element equals, you know, the stack dot

pop.

And what would happen is under the hood, it removes the item and then it also returns

a copy to me.

Sorry for being too C++ in this video.

On the other hand, if I have the form that has void for pop,

then I would have to do something like this.

I’d have to say auto element equals stack.top just to get a copy first,

get a copy of that for before I remove it.

And then when I’m finished, then I can say s.pop just to grab a copy of it and then remove it.

So for now, we’re just going to use the form that gives you a copy of the data

at the same time that you’re removing it.

thing to keep in mind let’s see there are two other functions i wanted to mention mention real

fast so for now i’m going to say that we only have the t pop type you can also check to see if a stack

is uh is empty and you can also check its size uh usually those are functions that have those names

but i’m going to do let’s see boolean empty and then i’m going to say size type size again sorry

an unsigned 64-bit integer so just like a count or a size something that’s just

going to be a whole number and never negative so we have this little

interface that this data structure has and we have been calling push so far so

let’s go ahead and do some pops I’m gonna say auto auto elements equals s

dot pop maybe I’ll do two of those in a row maybe instead of calling that

just so that we can have different variables to put our pops in.

And then maybe after that, I’ll do some more pushes.

I’ll say, let’s push like a 15 and let’s push like a 25.

And then I think that means it’s probably time to erase that,

the top part of the diagram with the 8, 2, 3, 4

in favor of just whatever pushes and pops we’re doing.

So let me just do this real fast.

Okay, so we did our pushes.

two three four and then I’m going to try to grab a couple pieces of data with these pops

and for pop all you have to do is just to well I should have mentioned this before but first

check to make sure that there is something to pop for example if I had a blank stack let’s say I had

a blank stack right here there’s just like nothing on it and this green line is non-standard I’m just

drawing it for fun but imagine I had a blank stack with no items and I decided to call pop on it

well you’re not allowed to pop them an empty stack there’s nothing there to pop which means that’s a

stack there’s nothing there to pop which means that’s a really really naughty thing in c++ and

other languages we would say that something exceptionally bad has happened the user tried

to pop something that wasn’t there and so then we would do something called throwing an exception

at the user again this is not really a code video but if you know a little code hopefully you

understand try catch blocks and throwing exceptions when bad things happen so we would just throw an

exception at the user if you don’t know how to code at this point then just keep in mind we would

mind we would refuse to do it we would say something bad has happened we can’t do that

and then when you’re doing your pushes sometimes depending on what what you’re using to implement

the stack under the hood inside of your code you might decide that you’re using let’s say you’re

using an array under the hood which has a fixed capacity if you run out of capacity and you can’t

then you would throw if the user tried to push something into a full stack we would call that a

stack overflow and then when we tried to pop from an empty stack we would call that stack underflow

but for the purposes of this video just assume that the stack is just a diagram and it has no

capacity so we can just add as many things as we want on it or maybe we’re using a linked list

under the hood which would have an unlimited capacity or limited only by the machine’s

But anyway, so let’s go ahead and try to do this pop.

So let’s do a pop here.

Well, in the pop, we just look at the top only, right?

So we say, well, you know what?

Let’s make this more interesting.

Hang on a second.

Let’s make this more interesting.

Let’s do this.

I’m going to do auto a equals s dot top.

So I’m going to grab a value without actually removing it.

Okay.

So more interesting.

So we push the 8 and we push the 2.

So at that point in time, actually let’s trace this from scratch.

So we have like an empty stack here.

There’s nothing there.

And we’re going to push the 8.

So the 8 goes on the very top, just like we did last time.

I’m going to put an 8 there.

And then we’re going to push the 2 next.

So the 2 just kind of goes on top.

And then the next line, line 12, we’re just checking the top.

we’re allowed to actually look at the top if we want to. So since two is at the top, that means

a is equal to two. I’m going to put a two here to remind ourselves that a is now equal to two.

Then we’re going to do a push three. So I’m just going to stick a three on top of the stack.

And then we’re going to push a four, four is on top of the stack. Now, again, we’re not allowed

to look at anything in the middle, anything, anything, but the top. So for example, when the

it and remove it but now that we have a four on top we can no longer even see the three it’s not

available to us anymore so then we’re going to pop and put that value into b so um you know what’s

at the very top it’s a four so that means we’re going to actually remove the four and stick that

into b so i’m going to put four right here to remind ourselves that b is now equal to four

and uh for the purposes of this video you can just imagine that this you know the top of the stack is

of the stack is just totally gone deallocated depending on what implementation you use you

might want to think about crossing it out maybe there’s like some junk data there now but for the

purposes of this video in this diagram we’re just saying it’s gone so it’s just totally gone

okay then let’s do another pop so we’re going to pop and that’s going to become c so obviously the

top is uh is now the three so that means the three is going to go into the c variable so here’s a

c variable so here’s a three right there then the three gets deallocated

and now the top is the two so then we’ll push a 15 and we’ll push a 25 so again we just put those

new items on top of the stack even if there was stuff uh there before it’s gone now so we’re just

be a 15 and a 25 on top of the stack so we got this and then 25 and then we’re done adding our

stuff so uh the other functions that we talked about are empty and size uh at the very beginning

when we had just an empty stack like that if we were to call on the empty function it would tell

us true the stack is empty and then every step after that where we had some data in the stack

data in the stack like as soon as we even added that eight at the very beginning from that point

forward then empty would have returned false to us saying no the stack is uh it’s not empty

the size would have changed uh during every step of the way so you know at line 10 the size would

have been one after we’re finished with line 10 after line 11 the size would have been 2. 12

wouldn’t have changed the size so it still would have been 2. 13 would have upgraded the size to

have upgraded the size to four once we popped after that pop was finished it would have been

three again then the second pop would have brought it back down to two and then those two pushes

would have put it back up to three and then four and so then the final size whoops that was horrible

the final size of the stack is four and you can tell that there’s just four items

another way to double check yourself if you’re kind of trying to trace this on your own is just

count the number of pushes and subtract the number of pops so how many pushes do we have one two three

2, 3, 4, 5, 6.

So that’s like 6 minus however many pops we saw.

We see 2 pops.

So 6 minus 2 is equal to 4.

So, you know, when you’re writing this sort of thing down on,

like as a diagram to practice,

then you know it’s a 4 just by looking.

But what if you did something wrong?

It’s a great idea to double check yourself at all times.

So 6 minus 2 is 4.

So we know that the size of the stack is 4.

Looks pretty good.

Looks pretty good and we know the values of A, B, and C and you know one of those was

top two of those were pops.

And yeah, okay.

So notice something though that’s kind of peculiar about the data that came out.

If we added the data, like I guess while we were adding the data, we added first an eight

and then a two and then a three and then a four.

I’m just looking at the pushes right now and then a 15 and then a 25, right?

So we added the data in that order.

order. But then when we grab the data out, let me put this in, but maybe like a red bracket

or something. When we grab data out of it, the pops and the tops gave us two and then

a, okay, nevermind. That was not a pop. It gave us a four and then a three if we’re just

look at the, look at the first two items. Sorry, sorry, sorry. Look at the last two items right

before, and I didn’t draw this very well. Imagine that we had just pushed the eight and the two and

the three and the four only forget about these other pieces of data. So at this point, when we

start calling our pops, we have only an eight, two, three, four stack, right? So the data that

has a four and then a three if we’re removing data from the stack.

So notice how the four and the three are backwards.

Notice also like if we kept popping out data, you know, we got the four and then we got

the three, the next, what’s the next thing that would come out?

It would be the 25, right?

And then it would be the 15.

And then it would be the two.

And then it would be the eight.

So if you really think about it, the stack is reversing our input data.

We added a three and then a four, but we received a four and then a three.

And of course, it’s a little bit muddled because we have some pushes in between some tops and pops and stuff.

But just looking at what goes into the stack, it’s backwards, right?

Eight, two, 15, 25.

Let me finish this push sequence up here.

So we added three and four, and then we added a 15.

And then, oh, my penmanship, dude.

shit dude 15 and then we added a 25 so if you look at the data that comes out this is like a 15 and a

25 backwards and then the three and the four are backwards and then the two and the eight are also

backwards and so one thing that a stack does is it reverses data let me give you a cleaner example

with no pops in between the pushes just to show you what we’re talking about a little bit more

bit more clearly okay so i’m going to do maybe like another code page here whoops do that and

then i’m going to say got our stack and we’re just going to push in some data

and then we’ll just say s.pop and maybe i’ll just do that however many times

six two three four five six so now just a very quick trace because this is basically the same

intermixed. So I’m going to do like the bottom of the stack here. And then, well, I mean like an

empty stack. That’s not really a bottom of a stack. So we’re going to push an eight.

And then we’re going to push a two. And then we’re going to push a three. And then we’re

going to push a four. Then a 15. Got to work on my fives, dude. Okay. And then 25.

Okay, one more time.

Oh yeah, I guess I got to slow down.

So what’s going to come out?

Remember the top is the only place that will give us data.

So if we start popping all these one by one, we’re going to end up with a 25 for that first

pop.

Maybe I should write it down over here.

Do like a 25 and maybe I’ll add some line breaks in the code here so that it’s easier

for me to write with a pen.

Do this and that.

Okay, so the 25, I’m just going to do a red line through it to designate or to denote

deallocation or just like gone-ness.

Then the top is at the 15.

We do another pop.

It’s going to be 15.

Oh, I did my first perfect five today.

And then the top of the stack is now at the four.

So then the four is going to pop out next.

And then the three is going to pop out next.

The top is now at the three.

the three so the three is coming out for that pop we deallocate the three the top goes down one and

then we pop it becomes the two that’s deallocated now and then we grab the eight because that’s

where the top is so now we’ve grabbed all of our data out and I just want you to look at this one

more time notice the data is eight that the data that went in was eight two three four fifteen twenty

The data that came out was backwards 25, 15, 4, 3, 2, 8 or 8, 2, 3, 4, 15, 25.

If you kind of like look up.

So a stack is a data reverser.

A stack is also known as something called a, let’s see,

last in first out data structure, LIFO,

or first in last out, phylo data structure.

What that basically means is just it’s reversing the data or priority goes to the item that is the youngest.

So if you looked at the stack at the point where we were about to remove the 25,

25 was the most recently added or the youngest item or the item with, I guess, the timestamp, the furthest in the future,

however you want to look at it.

And that’s the item that came out.

So if you think about it, it was the last item in.

And therefore, when we did another pop, it was the first item out.

So LIFO or PHILO.

and uh you know this eight down here that was obviously the last item that we were able to grab

out of it so when we said you know hop our final pop before the stack became empty uh the eight was

definitely the first item in so first in was the last out if you really want to you can kind of like

jumble these uh these acronyms uh i think most like people just use lipo or phylo

life if you say something to me that I understand I think it’s probably fine

but it’s it’s non-standard I like to say you know foley first out last in that

definitely makes sense it’s just not very common another thing that I like to

do for fun is also I’ll mix up the phylo and I’ll say lo-fi because last out is

first in and now I’m cooler than other computer people because I use the word

lo-fi I’ve now got like a giant mustache and like a little like swap meet shirt

like swap meat shirt and I have craft beers and I have work boots on and I’d

roll up my jeans and my, my, my, my, my sleeves are rolled up and all that stuff.

You know what I’m saying?

I’m cooler than everybody else now because I used loaf pie anyway.

So we used integers.

It’s just important to understand that in modern coding,

I think I might’ve mentioned this before with the T’s,

these stacks are templated data structures,

we can hold another data type besides integers as long as we declare what the stack will hold in

advance. So instead of integers, you could imagine there’s like a custom class, like my class,

every single, you know, item in the stack is actually a full instance of a my class object,

or, you know, floats or strings or just, you know, any data structure you want,

you could put another data structure inside of a stack. People do that sometimes just for fun,

sometimes just for fun you could take a vector and stick it inside of a stack a list put it inside

of a stack you know whatever you want to do just to show that you understand everything

um so again by the way the stack is empty if we tried to pop from it at this point

this would be called a stack underflow we would probably want to throw an exception at the user

or just say we’re not allowed to do it let’s see um so i guess now i should tell you some

common uses for stacks i’m looking at my notes right here uh obviously our stack has reversed

has reversed the data. So stacks are kind of good for data reversing. Imagine if you had like a word

and you wanted to detect if the word was a palindrome or not, you would just like put all

the letters of the word into your stack and then grab them back out and see if the word was still

in the same order. If it was, then your word was probably a palindrome. If you don’t remember what

a palindrome is, I’m going to write down the word radar in reverse from backwards, from back to

front, right? It’s the same word. So that’s a palindrome. You could also use stacks kind of

as a trail of breadcrumbs. Like you could imagine that early implementations of browsers

had your browsing history in a stack somewhere so that every time you visited a webpage, then

some kind of block of information, maybe like a custom class instance was put onto a stack

somewhere and it contained information about like when you visited the webpage, what the URL was,

it is that the browser wants to remember and then later when you hit the back button then you can

imagine the browser is popping from the stack in order to go backwards in your history or your

spotify playlist or whatever it is you’re doing honestly you know these systems are much more

advanced than just using you know vanilla stacks now but you could imagine doing something on your

own for fun or just what it might have been like in the very beginning i’m going to erase fully

because that’s just that’s just that’s just cringe lo-fi i think is way cooler um so trail of bread

So a trail of breadcrumbs, like browser history, you could also imagine undo history, like

if you had a, I don’t know, like a text editor of some sort or like a image editor of some

sort, every major change that you did to it, maybe the program under the hood is adding

your change to the stack.

And that makes it easier to sort of reverse your changes as those changes are popped.

And there’s like a sort of mathematical uses like balancing parentheses and things, but

balancing parentheses and things, but I’m not going to talk about that too much.

And one of the most important uses for stacks inside of your computer is actually the call

stack. I’m going to talk about that in a future video. But again, remember each, you know, little

item on the stack, it could be a different data structure on its own. It doesn’t have to be an

integer. So imagine that I bundled up a bunch of information about a function call, and I called it

I just stuck a call frame on the stack.

That’s basically the call stack.

But that’s for another video.

Anyway, so let’s see.

Is there anything else that I wanted to show you?

I think we’re actually done just talking about the basics of stacks.

I’m not talking about time complexities or anything like that in this video.

Check a future video if you’re interested in time complexities per certain implementations

and so forth.

But for now, this is how a stack works.

or LIFO or LOFI data structure.

Nobody’s going to say LOFI but me, just FYI.

But maybe everybody will start doing it now.

I don’t know.

If it becomes a trend, okay?

You heard it here first.

Give everybody this link.

All right, I hope you feel like an expert on stacks

at this point.

I hope you had a little bit of fun

and learned a little bit of something, some stuffs.

I’ll see you in the next video.

hey everybody thanks for watching this video again from the bottom of my heart I really

appreciate it I do hope you did learn something and have some fun if you could do me a please a

small little favor could you please subscribe and follow this channel or these videos or whatever it

is you do on the current social media website that you’re looking at right now it would really mean

the world to me and it’ll help make more videos and grow this community so we’ll be able to do

videos, longer videos, better videos, or just I’ll be able to keep making videos in general. So please

do me a kindness and subscribe. You know, sometimes I’m sleeping in the middle of the night

and I just wake up because I know somebody subscribed or followed. It just wakes me up

and I get filled with joy. That’s exactly what happens every single time. So you could do it as

a nice favor to me or you could you could troll me if you want to just wake me up in the middle

of the night, just subscribe and then I’ll just wake up. I promise that’s what will happen.

Also, if you look at the middle of the screen right now, you should see a QR code which you can scan in order to go to the website

which I think is also named somewhere at the bottom of this video and

It’ll take you to my main website where you can just kind of like see all the videos

I published and the services and tutorials and things that I offer and all that good stuff and

If you have a suggestion for

Clarifications or errata or just future videos that you want to see

please leave a comment or if you just want to say hey what’s up what’s going on you know just send

me a comment whatever i also wake up for those in the middle of the night i get i wake up in a cold

sweat and i’m like it would really it really mean the world to me i would really appreciate it so

again thank you so much for watching this video and um enjoy the cool music

as as i fade into the darkness which is coming for us all

Thank you.

The post Master Stacks: Fun Guide to Data Structures, LIFO & Real-World Uses appeared first on NeuralLantern.com.

Hey there! In this video, I’m diving into the world of logic gates – AND, OR, XOR, and NOT. We’ll break down how each gate works, draw them in ANSI style, and rig up a circuit to see how they turn inputs into logical outputs. I’ll walk you through truth tables and show you how to chain gates for cool results, all while keeping it real and relatable. Whether you’re new to digital logic or just want a refresher, this is for you. Got questions? Drop a comment! Subscribe to join the crew, and scan the QR code to check out my site for more tutorials. Let’s geek out together!

Introduction to Logic Gates 00:00:00
Overview of AND Gate 00:00:47
Overview of OR Gate 00:01:07
Overview of XOR Gate 00:01:24
Overview of NOT Gate 00:01:49
Drawing AND Gate 00:02:14
Drawing OR Gate 00:03:07
Drawing XOR Gate 00:04:12
Drawing NOT Gate 00:05:31
Building a Circuit 00:06:04
Combining Gates 00:07:21
Testing with All Zeros 00:09:56
Testing with All Ones 00:11:23
Testing with Random Inputs 00:12:32
Introduction to Truth Tables 00:15:00
Creating Truth Tables 00:16:03
Analyzing Circuit with Truth Tables 00:18:50
Hierarchical Truth Table Approach 00:20:04
Final Circuit Analysis 00:26:36
Conclusion and Call to Action 00:29:15

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social

Please help support us!

• Subscribing + Sharing on Social Media
• Leaving a comment or suggestion
• Subscribing to our Blog
• Watching the main “pinned” video of this channel for offers and extras

Okay, hey everybody! In this video I’m going to talk about logic gates. I’m going to show you

AND, OR, XOR, and NOT. We’re going to draw them in a diagram style and we’re going to rig up a

bunch against each other and see if we can figure out how they would process some input data into

you know some logical output.

Okay so for starters let’s just go over what the gates look like. If you don’t know how these gates

don’t know how these gates work check my previous videos because I’ve explained them there. Here I’m

just going to sort of try to draw them and make a little big a little circuit area that we can play

with. Okay so AND. Okay you know what you want me to I’ll just do a quick recap. The AND gate just

means that both bits have to be a 1 in order for a 1 2 output so if we do a 0 and a 0 and a 1 and

sorry one and a zero and a one and a one then only this one is going to end up being a one

everything else is going to be a zero for the logical or it’s going to be if we do zero zero

zero one one zero and one one and if this is too fast and confusing for you see my other videos

but basically it’s going to be a one for those three because if either of those bits are a one

then the output is going to be a one and the only place it’ll be a zero is when both of the bits are

Let’s look at XOR. So XOR is

Basically and it’s an OR except this one position right here where both bits are a one that would end up being a zero

So for XOR 0 0 0 1 1 0 1 1

It’s going to be a 0 and

Then a 1 and then a 1 and then a 0 so it’s just a little bit different from OR and then not just inverts the bits

so

bit at a time and it’s just a zero becomes a one and a one becomes a zero and that’s pretty much it

okay so maybe I should put not right here just to just to emphasize that I’m talking about not

okay I’m definitely not not talking about not sorry so let’s do uh let’s draw a logical or a

bitwise and gate it’s basically just kind of like this and then there’s a little flat ridge at the

end of it and it takes two inputs there are many different styles to draw these kinds of gates but

i’m going to use the ansi style i think for the most part so just keep in mind you know you can

draw these in many different ways it’s going to take two inputs imagine this is a little circuit

right here and it’s going to give you one output so if you imagine what we talked about before

we could send it two different bits and it will produce the output for us so if we give it a zero

for us. If we give it a 0 and a 1, it’s still going to output a 0. If we give it a 1 and a 0,

still a 0. If we give it a 1 and a 1, then finally it’ll actually give us a 1.

Okay, so that’s just the way that gate looks. And now I’m going to draw the next one.

Let’s draw the OR. So maybe I’ll put OR here. Whoops. Oh, I got to do that. OR. So the OR gate

kind of looks like the AND gate at least in the style that I’m drawing except the

the flat ridges is more curved like this so you know an AND gate I’ll draw it in

red just to remind you that this is not what we’re doing right now it’s you know

flat right where’s the OR gate it has a curve it’s like a crescent moon kind of

it still takes two inputs so I’m gonna do an input here and an input here and

it still has one output and so if we’re just gonna give it a zero and a zero it’s

give it a zero and a zero it’s going to output zero for us if we give it a zero

and a one it’s going to output a one if we give it a one and a zero it’ll still

output a one if we give it a one and a one it’ll still output a one okay that

was pretty easy let’s look at exclusive or so XOR XOR the XOR gate looks like

like the ore gate so i’m going to start by trying to draw an ore gate as best i can

which is not good oh god let me start over on that one let me try one more time and then i’ll just

give up okay do this and then i’ll say okay that was good enough and then it has another line right

here the line is supposed to be parallel to the uh the crescent moon you know the curved side but

and that way it sort of looks like the inputs are passing through

like the first line before they touch the actual ridge.

So that’s an exclusive or it also outputs one bit.

So just practicing, we’ll give it two zeros.

It’s going to output a zero because there’s no or involved in two zeros

or I guess there’s no orness to the two zeros.

If we give it a zero and a one, then that’s going to output a one

one input is a one if we give it a one and a zero same thing looks good because

one input was a one but then once we get to two inputs then it’s going to output

a zero because the exclusive or demands that only one of the bits is a one and

actually exactly one of the bits is a one to produce a one okay so then the

next thing that I can show you is a knot gate it’s sort of like a little triangle

are different drawing styles it takes only one input and then there’s like a little circle up

here on top and then it outputs at the top and so if we give it a zero it’s going to output a one

i guess i could draw it a second time since there’s only you know two things we can we can input to it

it’s going to give us a zero if we inputted a one into it so it just reverts it’s an inverter

helps you understand the basics of these types of gates. Now I’m going to try to make a bunch of

them see if I can come up with something interesting on the fly. I had problems with

the drawing system on my other computer so I didn’t really prepare an example. Hopefully this

is good you never know. I’m just going to draw an AND gate here and I’ll say that it takes two

inputs because that’s what it does and then right next to it maybe I’ll do an exclusive OR so I’ll

like an OR gate here, and then I’ll do the exclusive OR part of it, and I’ll give it

two inputs because that’s what they take.

And then next to that, maybe I’ll just do a regular OR.

We’ll say OR, just like that.

Oh, that’s awful.

Try one more time.

Just do this, and then say this.

Okay, that’s acceptable, sort of.

We’ll do two more inputs there.

And what else can I do?

What else can I do?

Should I do another exclusive or or an and?

What do you think?

Vote.

Just kidding.

I’m going to do an and right here.

So I’m kind of repeating one of the gates.

Let’s see.

And or X or not.

Yeah, that’s all I wanted to talk about.

Okay, so now we can combine them because remember these have an output.

But if we sort of use the outputs of two of the gates as input for another gate,

then we can you can we can sort of like chain uh our circuits to make something a little bit more

interesting so maybe here i’ll do an and i’ll say this is an and gate oh god that’s awful

one more time okay my text-to-speech engine who i’ve given the personality of mary poppins

is telling me that a door is open so i’ve got to close the door after this video anyway

video anyway um yeah I have like an LLM server uh in the other room and so now my home assistant

is a little bit smarter and sometimes she messes with me that’s a story for another video

so I’m combining the output of both of those gates and sticking them into an and

and then I can do the same thing here I think I drew those I think I drew it like way too high

I’m gonna run out of room let me try one more time put that there we’ll do an and gate

gate like that and then I’ll just maybe curve the wires so it seems like uh it makes more sense okay

and then maybe over here I’ll do uh I don’t know maybe this should be an or I’ll do an or gate

like that and then the inputs from the other ones go into the or gate

then these two can combine to one more so maybe I’ll do exclusive or

or I guess I’ll just put an or gate here and then I will that’s not that’s not

curvy enough is it I like my Alex might I like my XOR gates nice and curvy so

we’ll do this and then I’ll put another line under it and then we’ll connect

these two so we’ll do this okay so then finally we have like one bit that’s

one bit that’s going to come out at the top let’s use the knot gate might as well so i’m going to

connect this to a knot gate and put a little circle on top of it and then it will give us our

final output and maybe i’ll stick it here in green or something like that okay so there’s lots of

different uh input output combinations we could use uh let’s see for every input we have that’s

one bit so one two three four five six seven eight that’s eight bits that means i could draw out

256 possible input combinations, which I’m definitely not going to do in this video.

But let’s just do some random stuff.

Let’s start off with zeros just for fun.

So we’ll do a bunch of zeros here.

So if you sort of look at this diagram, we go, all right, what was that?

This and here, there’s two zeros.

It’s going to produce a one.

So I’m just going to put a one right here to remind me that a one is going to be the

output of that gate.

the OR gate here is going to also output a what am I doing why did I put a one a zero because zero

and zero is zero and then zero or zero is also zero so this is going to output a zero and then

this exclusive OR is also going to output a zero and then the end is zero so I just have zeros at

the next level then we look at the inputs here to this and that’s obviously going to be zero and

then we look at the OR here that’s obviously going to be zero and then those two go into the gate

that’s a little bit higher and it’s going to output a zero because exclusive

or needs at least, you know, it needs exactly one, uh, one.

So it kind of feels like it’s going to be a zero for the output, right?

Uh, you’d be wrong if you thought that because the knot is going to invert it.

The knot is going to take that zero and flip it to a one.

So if we do all zeros, the answer is actually going to be a one.

Okay.

Let’s reset this and try again.

So I’m going to just get rid of these greens here.

and then I’m going to do, maybe I should write the inputs in red so they’re more fun,

so they don’t feel like they’re blending too much in with the actual diagram.

Okay, so now I’m going to, let’s try all ones. Let’s see what happens if we do all ones.

So I’m going to do ones on every input. One, one, one, one, one, one, one. And so

if we look at this AND gate, it’s going to output a one because, well, a one and one is a one.

one is a one the or gate same thing because a one or one is a one and then do the same thing down

here for this and and then the exclusive or that’s going to be a zero because it wants exactly one

bit to be a one not both so it’s a little bit more interesting and then we go up one level this and

gate is going to output a zero because it wanted both of those uh inputs to be a one for it to

output a one and then for the or it’s also going to output a well it’s going to output a one again

both of those are ones and then if we look at the exclusive or oh that’s going to output a one this

time because exactly one of the inputs is a one then the not is going to invert it so the final

answer is going to be zero for this whole giant thing i want to say make sense and wait for

questions but i guess i can’t so let’s try another example i’m going to do maybe two examples with

totally random numbers and then i’m going to show you how to write a truth table that might help you

might help you work this out on paper or like a like a notepad if you don’t really want to draw

so let’s see um uh i guess i’m gonna like maybe take some of these and turn these into zeros

let’s see get rid of that make that a zero maybe like i don’t know i feel like i’m not random

enough okay one zero and then like a maybe like a zero here how about like a one there and a zero

How about like a one there and a zero there?

Just one, zero, one, zero, oh, one, oh, one.

That’s too much of a pattern.

Let me do, let me do a one, oh here, or a one and a one.

Okay.

That feels more random to me.

So looking at the AND gate, that’s going to output a zero.

The OR gate is going to output a one.

The exclusive OR is going to output a zero.

The AND is going to output a zero.

So we just got a one right there.

So this AND is going to output a zero again.

This OR is going to output a one.

And then the exclusive OR, it’s got enough to output a one.

it’s got enough to output a one so that’s nice and then its final output is going to be

a zero because we had to not that one nice okay let’s just i don’t know change a couple random

bits i’m going to change this well let me erase first and then i’m going to start changing random

bits i don’t even remember what that last bit was anymore i’m going to pretend it was a one

and then i’m going to change it to a zero and then i’m going to change this zero to a one

change this one to a zero and then I’ll change this this zero to a one not like exactly random

it’s human random sort of so let’s look at this the and is going to output a one and the exclusive

or is going to do a one and then the or is going to do a one and then the and is going to do zero

one and one zero okay I think I did it right so the or is going to do a one and then I think

what’s happening is I gotta adjust my penmanship style I still have to like lift up sooner so it

doesn’t change colors so then the end it’s going to output a one and then this exclusive or it’s

going to output a zero because it wants only one bit one input to be a one and then the not is

Okay, let’s look at the idea of using a truth table to make this a little bit easier to

solve if you’re just kind of doing this without drawing.

So I’m not going to clear this just yet.

I might have to clear it in a second.

The first thing that you should do when you’re making a truth table is, you know, I mean,

I guess you can style this however you want, but you kind of have to think of this hierarchically.

Like what’s the easiest thing to do?

You don’t want to start computing the thing at the very top because that depends on a

lot of other stuff that’s at the bottom.

So instead I’m going to look at the very bottom row of inputs because they’re the easiest to calculate.

So I’m going to do and, I’m going to say something and something.

I guess I’m just going to put and by itself.

Maybe I’ll put one for input.

So for the inputs, I’ll just do the bits here.

0 1 1 no okay let’s just use two inputs only because we’re looking at the lowest level here

yeah and we’ll make maybe like a separate row or separate table for that so we just have two

inputs per gate on the bottom row and so for the end it’s going to be a one right then for the 0 1

should just do this in numeric order. I’ll just do every possible combo because we don’t have that

many numbers. So we have four combos. This is like zero, one, two, three. So from zero to three or

four possible combos. And then the end is going to be a zero here and a zero there and a zero there.

So that’s a truth table that just handles that first gate. So then I’m just going to, you know,

write, I mean, you could make another truth table for this, but I’m going to try to write this in a

I’m going to try to write this in a more compact way.

I’m going to say the second column is the result of ending.

The next column is the result of oaring.

And then the last column is the result of,

maybe second to last is the result of an XOR.

And then maybe I’ll make another table for nodding.

So what is the result of an OR here?

It’s going to be a, whoops, a zero.

The OR here is going to be a one.

So when you start to make these tables,

it just makes it a little bit easier to work your way up because when it gets time to let’s say the

not you don’t have to compute all the other things because they’re already computed in the table so

we got the or which i should have probably done first because the second gate was an xor i should

have done that maybe third i don’t know i’m going to leave it as and and or right now and then we’re

going to do xor so xor is basically if exactly one bit is a one will output a one so that’s a one

so that’s a one there and then a one there and then a zero there okay so we’ve got the basics

and if you think about it that’s the whole bottom row right so if we’re just sort of looking at

let’s say the the third gate right here then uh we just have to look at input one one for the or

and then that’s this right here right there so that tells us what the answer would be truth table

for input zero one we just have to go all right zero one xor the output should be a one

and we can double check ourselves because it’s really really easy to make mistakes i’m sure

there’s a chance that i have or will make a mistake pretty soon

so we did and or an xor let’s do maybe just one for the knot just to remind ourselves of what it is

and i’ll just say not and so we can only do two different inputs on the uh on the knot so i’m

so I’m going to go maybe a zero and then a one right here and then the not is going to say we

have a one there and a zero there okay so now we can get a little bit more complicated

by combining these terms so for the input now we could do

we could do uh let’s say two gates at a time so we’ll do the input here and we’ll say the input

1, 0, 1.

And so when we not, when we not the, well, when we do an and for the 1, 1, we can end

up with a 1.

And then when we do an XOR on the 0, 1, then this is not the best truth table, to be honest.

I’m just trying to I’m just trying to do it the XOR is going to be a one so now we kind of have

the results written down here let’s do another little table and you know the way these tables

work is you kind of want to put every possible combination of inputs there but that alone is

going to be so many combinations I don’t want to write it all down and by the time we get to eight

bits it’s going to be like in the 200s so if we just look at the next pair of gates we’ll say

gates will say one one zero zero and the first thing is an or for the one one and

then the next thing is an and for the zero zero and so I can just write this

down and go all right the or is going to be a one and the end is going to be a

zero okay so then I can do another level I’ve pretty much just handled you know

the bottom row here and again each table is supposed to be filled out for every

combination of inputs but I can now just kind of move on to the next row I can say

what is the result of inputting a one and a one you could do that but it might be a little bit

better and closer to some other places that might want you to input this sort of thing

to write down what is the result of the or what is the what are the two gates that are giving you

Okay, so the first input on the very bottom left, that’s an and, right?

And then the next input on the bottom row is an XOR.

And if we’re trying to figure out, you know, how are we combining those?

We could say and XOR, or we can do, you know, two ampersands.

I guess I’m going to do and XOR, just to keep it in plain English as much as I possibly can.

So basically, this is going to have, you know, one result.

this is going to have, you know, one result, you know, one bit result and its input is going to be

a one, one, zero, one. And so maybe I should do another row here. We can say the end

for the end is going to, for one, one is going to be that. And the XOR is going to, well,

I already wrote that down in the table. Okay. I’m just going to, I’m just going to clean it up

because you know, it’s really good in these truth tables. If you write down all

truth tables if you write down all of the numbers, but I’m just going to do it this.

I’m just going to do it this.

Maybe we can visually see that there’s a one one going into the first end and then a zero

one going into the second gate, which is an XOR.

I think maybe that’s acceptable.

So the result of that, if we just sort of look up at this table here, we have, you know,

what is the end and what is the OR?

It’s a one and a one.

So if we end those two together, that should be a one.

that should be a one so that means if we end the and against an xor then that’s the result that we

get and then we’ll make another little table here for the next layer of inputs so i’ll just do this

and i’ll say

or and then the operator that combines them is an or and then on the right side it’s an and

The input to both of those is going to be a one, one, zero, zero.

And again, you should make another row for every possible combination of inputs.

That would be a really smart idea.

So then I will say that, uh, the, or in the end for a one, one and a zero,

zero is this because we already wrote that down in the truth table.

So really we’re going to be looking at inputs of one and zero.

So that means, uh, if we’re applying an, or to that,

applying an or to that, the final result should actually be one.

Okay.

So now we’ve got that second row.

We just have to look at the second to the last row.

So I’m going to go input for an X or of something else.

And the X or is going to be, oh gosh.

of an and

well xor let’s put that in the middle let’s say and on the left and or on the right and then we’ll

do an xor against them maybe you could put the parentheses on the other ones i don’t know i’m

struggling with notation clearly right now but so we say and exclusive or with the or but then what

Let’s put some more parentheses around it and we’ll say the and anded with an X or.

Now we’re running out of room here.

Can I get this like at the top maybe more?

How about that?

Okay, that’s a little bit better.

So we have and being anded against an X or and then I put parentheses around that.

There is a, there are special symbols you can use for this to make it more clear, but

for this to make it more clear, but I’m not really trying to explain that right now.

I just want you to see how the gates work.

So we have, then the next two operators are in, oh gosh, yeah, we’re XORing against two

things.

So on the right side, the OR is ORing and OR, and then on its right side is the AND.

So maybe I should do, I don’t know, I guess I’ll put parentheses right there to make it

seem a little bit more clear.

So now we’ve basically got an XOR and on its left side what’s happening underneath it is an

anding which is the middle of an and on the left and an XOR on the right and then the

the right side of the XOR is

then the the right side of the XOR that was my LL I’m talking to me again

on its left sorry it’s oaring on its on its right and then under the or it’s got an or on the left

and an and on the right okay so we’ve written all these down in a way that’s okay not great but okay

and i’m just going to do one one zero one one zero zero and then um i’ll make another video in the

future about truth tables if everyone is super interested but that’s that’s not really what i

I’ll make a video where the truth tables look proper and nice and full and all that stuff.

So let’s do, what is the answer between the, oh, I have to scroll up a little bit to see that.

So the left side of the XOR had an anding of an and and an XOR.

So that was this right here.

So the result of that was a one.

and an end and that was a one so I have two ones basically so this XOR is going to output

a zero because it’s it’s got two ones as an input or as inputs okay so then I guess I could copy

paste this to make it a little bit easier on myself to write it all out and I could just say

let’s not the whole entire thing to get to that highest level so I you know again I can just kind

I, you know, again, I can just kind of keep the whole thing copy pasted and you know,

the original input bit sequence, uh, I can just nod it.

I can just change that zero to a one.

So let’s just double check all our levels here to make sure that I did this correctly.

You never know.

So the input not, we know what that is for the end and the X or where’s the end and the

X or, okay.

So bottom left.

What did I do wrong?

Input.

Oh, that was, those were just the basics.

Okay.

So that’s not a combination.

Okay, so that’s not a combination.

Let me just double check the basics for the anding.

Zero and zero and zero and then zero and then one and then one.

And then here it should be a one and then the or should be one and should be zero.

And here the and should be one and the or should be one.

Okay, so I’ve got the basics, right?

And then on line 15 here, we’re looking at

an AND and an XOR. I guess I just did both of those at the same time. Okay, so the AND is a

1 and the XOR is a 1. And then the next one, the OR and the AND, it’s a 1 and a 0. Okay.

And then we’re ANDing the AND and the XOR. So that’s a 1, 1, 0, 1. The answer should be a 1.

That matches the diagram. Okay. And then the ORing of the OR and the AND on the right side,

the or and the and on the right side, that’s a one.

So that matches the diagram.

And then when we’re doing the whole thing, except for the knot,

it should be a zero at the top.

Okay, good.

And then finally, when we invert it at the very top, it’s a one.

So keep that in mind.

You can build and build and build in a hierarchical manner.

I mean, think if I started adding a bunch more stuff on top of this knot,

maybe if there were a bunch of other circuits somewhere else

and they were combining and combining like many layers.

This is the sort of thing that could help you.

Drawing, I think, is a little bit easier, but this could help you to just draw out a little table.

And of course, you want to have a giant table showing all combinations somewhere,

just to make sure that you can just look it up quickly.

But yeah.

Okay, so I think this is all I wanted to talk about.

Let me just double check.

All right.

So this is all I wanted to talk about for this video,

about logical gates and the basics and kind of helping yourself with a little bit of a table.

yourself with a little bit of a table. In future videos, I’ll talk about a proper table, perhaps.

And I hope you’ve learned a little bit and laughed a little bit at me struggling to do this on the

fly without a pre-made example. And I hope you had a little bit of fun and learned a little bit

of stuff. And I’ll see you in the next video. Thanks for watching. Hey, everybody. Thanks for

watching this video again from the bottom of my heart. I really appreciate it. I do hope you did

If you could do me a please a small little favor

Could you please subscribe and follow this channel or these videos or whatever it is you do on the current social media?

It’s a website that you’re looking at right now

It would really mean the world to me and it’ll help make more videos and grow this community

So we’ll be able to do more videos longer videos better videos or just i’ll be able to keep making videos in general

So, please do do me a kindness and and subscribe

I’m sleeping in the middle of the night and I just wake up because I know somebody subscribed or followed.

It just wakes me up and I get filled with joy.

That’s exactly what happens every single time.

So you could do it as a nice favor to me or you could troll me if you want to just wake me up in the middle of the night.

Just subscribe and then I’ll just wake up.

I promise that’s what will happen.

Also, if you look at the middle of the screen right now, you should see a QR code which you can scan in order to go to the website,

which I think is also named somewhere at the bottom of this video.

and it’ll take you to my main website where you can just kind of like see all the videos I published and

the services and tutorials and things that I offer and all that good stuff.

And if you have a suggestion for clarifications or errata or just future videos that you want to see,

please leave a comment.

Or if you just want to say, hey, what’s up? What’s going on?

You know, just send me a comment, whatever.

I also wake up for those in the middle of the night.

I wake up in a cold sweat and I’m like,

it would really mean the world to me.

I would really appreciate it.

So again, thank you so much for watching this video

and enjoy the cool music

as I fade into the darkness,

which is coming for us all.

Thank you.

The post Logic Gates Crash Course: Learn AND, OR, XOR, NOT & Build Circuits appeared first on NeuralLantern.com.

Want to understand bitwise operators? This video dives into OR, AND, NOT, XOR, and NOR with easy-to-follow examples. Learn how to use these operators for flags, masks, and more in programming. Perfect for beginners or anyone wanting to master binary logic in C or other languages. I break it down with real examples, a touch of humor, and no fluff. Subscribe for more coding tutorials, and check out my site for extra resources. Drop a comment with your questions or video ideas!

Introduction to Logical Operators 00:00:00
Explanation of Bitwise OR 00:00:35
OR Operation Examples 00:01:01
Bitwise OR with Multiple Bits 00:02:12
Using OR for Flags 00:03:52
Introduction to Logical AND 00:08:06
AND Operation Examples 00:08:29
Using AND as a Mask 00:10:00
Checking Specific Bits with AND 00:11:17
Introduction to NOT Operation 00:13:36
Introduction to NOR Operation 00:14:38
Introduction to XOR Operation 00:16:37
XOR and Neural Networks 00:16:53
Conclusion and Call to Action 00:18:38

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social

Please help support us!

• Subscribing + Sharing on Social Media
• Leaving a comment or suggestion
• Subscribing to our Blog
• Watching the main “pinned” video of this channel for offers and extras

Hey everybody! In this video I’m going to talk about basic logical operators such as OR and AND.

Uh so let’s let’s dive right into it. What am I talking about with the OR and AND?

Suppose for the sake of argument that this notepad is totally dark and I wanted it to be really light

and then I have to go into the system settings to fix it. Sorry let me change my theme.

How about that?

Okay.

So suppose for the sake of argument, we’ve got, you know, a couple of bits.

These are going to be a bitwise operations for the most part.

In other languages, sometimes we will say logical operator, but actually we’re just

talking about values rather than bits individually.

So these are bitwise operators.

Imagine we have like a couple of bits.

Remember the possible values for bits are just, you know, a zero and a one binary.

So suppose we have a couple of values.

values, let’s say we have a zero here and a one.

So if I apply a logical or to the zero and the one,

the result is going to be a one because either the first bit or the second bit are a one.

You could also expand these operators to have multiple sets of bits,

but we’re just going to do, you know, one set against another set.

In this case, each set is just one bit long, but we’ll do, we’ll do a more complicated stuff in a minute.

If I have a zero and a one, then the answer there is, well, let me just put or maybe.

The answer is a one.

I’ll put or maybe at the top, just like or to let you know that we’re doing ors here

on the top.

So if we have a zero and a one, the answer is going to be a one.

If we have a one and a zero, the answer is going to be a one.

Also, if we have two ones, which looks like an L over there, I got to work on my penmanship.

Then the answer is also going to be a one.

if either of the bits in question are a one then the answer should be a one. The only case with an

OR that results in a zero is if both of the bits are zero because neither the first or the second

are actually a one right so this is the basic idea of using an OR operator and you can also do this

with multiple bits at the same time like for example we could say let’s take a bunch of random

work on the it’s the pressure dude the l’s are driving me crazy okay oh my god okay so i do that

and i let go okay i’m just going to put some random bits uh underneath the the first set of

random bits put like a zero here and then like a one here maybe and we’ll say that we’re going to

do a logical or just like you might think of doing a you know addition or subtraction we’ll just say

you know, addition or subtraction. We’ll just say we’re going to or these two sets of bits.

Actually, these are six on the top and six on the bottom. If I add two more, then it’ll be a nice

little bite for the top and the bottom. So I’m just going to do that, you know, to have eight

bits on the top and eight bits on the bottom. Okay. So if I just want to logically or two sets

of bits, literally, I just have to do one pair of bits at a time. So a one or zero is just a one.

One or zero is just a one, a zero or one is a one, a one or zero is a one, a zero or one

is a one.

And then these ones, everything is just a one.

Okay.

So that was too easy.

Maybe if I, I don’t know, maybe if I change one of these ones to a zero, then we would

actually be able to have a zero somewhere in here.

So that’s a logical or a bitwise or operator or operation.

So you can, you can kind of use this in various ways.

can kind of use this in various ways i mean obviously if you want to manipulate some bits

this can be pretty useful inside of the machine but there was kind of an old school way that

people did flags with arguments they would basically say something like this they would go

in their computer program they would say you know flag a name it something like turn on the display

or enable caching or just like whatever right so we’ll just have a flag we’ll call it flag a

that value is equal to a one and then maybe flag b its value is equal to a two and then flag c

its value would be a four and then we basically just double the value of the flag and the reason

for that c d e f i’ll just stop with f maybe oh wait that was supposed to be 16 and that’s 32.

the reason for that is if you double the value of each flag so that uh

and then you can do a bitwise or against all of these flags and sort of combine multiple flags.

Because if you think about it, if we’re talking about binary,

if we suppose this is just a regular eight bit number, then, you know, the first bit has a

strength of one. If you’ve seen my other videos for converting between binary and hex,

the second bit has a strength of two. The next bit has a strength of four and then eight and

and then 32 and 64 and then 128.

And so if you look at the flags,

1, 2, 4, 8, 16, 32,

they map to only one bit.

It’s not going to be some kind of random pattern for these numbers.

It’s literally going to be flag A is going to look like this.

1, 2, 3, 4, 5, 6, 7, 8.

And then flag B is going to look like this.

1, 2, 3, 4, 5, 6, 7, 8.

five, six, seven, eight. And flag D is going to look like this. Whoops. Let me make that green.

Still getting used to this. Oh, sorry. C is the next one. One, two, three, four, five,

six, seven, eight. Can you see the pattern here? Let me just do D and be done with it at this

point. One, two, three, four, five, six, seven, eight. So because we’re increasing the value of

the flags by a power of two, or by a power of two, they’ll always correspond to just one bit.

they’ll always correspond to just one bit, which means if you apply a logical or operation,

you can represent a bunch of different flags with just one number.

Think about this.

What if I wanted to have, oh, I don’t know.

Let me erase this.

What if I wanted to have some, let’s say I wanted flag A and flag D and flag F just for

the sake of argument.

Dang, this pen.

It’s actually my fault completely, but I need to practice.

but I need to practice F okay and DNF so that would basically be you know 1 2 3 4 5 6 7 8

and then D would be the 8 so a 1 0 0 0 there and then a bunch of zeros elsewhere and then the F

So if we did an OR between all of those, then the OR is just basically 00101001.

And if you convert that from binary to decimal, what is that?

That’s a 1248 plus 8 plus 1248 and then a 32.

So 41.

just write down the number 41 and if the programmer is smart enough to you know parse all the bits

and everything then they’ll know that you have flags a and d and f set that’s not necessarily

something that all the modern programs do anymore it was much more popular in the olden days but i

think some people still kind of do it especially if they’re programming in c and other languages

where they want speed it’s pretty fast to look at bits inside of the machine so keep that in mind

Keep that in mind now we know how to do an OR operation and we know one reason that it might be useful and

Yeah, okay. I’m gonna move on to the next operation

So clearing the screen now

Hello little doggy he barked and now he’s in the room

Let’s do

The logical AND operation okay, so suppose we have two bits here

in a one only if both of the input bits are a one i’m gonna whoops i accidentally cleared the whole

entire thing let me forget where my red pen is okay and okay so if we have a zero and a zero

the result is zero because neither of those are a one if we have a zero and a one the result is

still going to be zero because we need both bits to be a one to result in a one so then that means

would also result in a zero. So you get a bunch of zeros until finally you have an input pattern

that is just two ones. And then finally the result is one. So that’s a logical and.

Let me do a quick example so we can and a bunch of bits together. I’m just going to do more

random bit patterns. So there’s another L there. I’m cringing. I’m self-cringing. One, two, three,

okay so then i’ll do like another one there and like a zero there and a zero maybe a couple of

ones maybe three ones and then a zero and then one i guess and we’ll just say that we’re going

to end those together so and oh man i’m mixing uppercase and lowercase like crazy

so uh to end them together you know that bit position right here that’s going to be a one

and then we have a zero because they don’t match they’re not both one and then we have another zero

a one and then we have a zero and a zero and a zero and a one so this is a logical and you can

use logical ands for a wide variety of things but one thing you can kind of do somewhat easily is to

use one number as a mask against another number for example notice how uh suppose this was the

input number let’s just say we have the input number up top and maybe you wanted to make sure

because you’re you’re checking for those bits individually or maybe you want to just prevent

the input from having certain bits on for some other reason well you can you can apply the mask

as the second bit and use a logical and i’ll say mask here sorry you can apply a mask as the second

bit pattern and notice how in the answer there are only ones where both you know the input and

means if I wanted to just control only which ones are allowed I can use the mask notice how the mask

has ones in these positions and there are definitely no zeros sorry there are definitely

no ones in any position where a mask had a zero so the mask can kind of like you know mute or mask

or control the input pattern if that makes sense hopefully another thing we could do if we wanted

if one bit exists. Let me go ahead and clear this real fast. I’m going to just do maybe four

bits this time. So we could obviously do an and against four zeros, and this would result in just,

you know, a resulting pattern of zero. So this is not super useful. The result would just

definitely be four zeros. But notice again how the second pattern is sort of controlling what’s

allowed to go through from the first pattern. Suppose I wanted to check to see if that particular

particular bit was on or off.

All I have to do is mask it with a one in the correct pattern.

So, you know, the second bit that I just wrote down on the bottom row,

I just want to see if that second bit is on or off in the input pattern.

I don’t care about any of the other bits.

That means the result will be this.

So now it’s much more easy for me to see if that bit is on.

I could just compare the value of those bits to a regular integer.

Like, for example, if we consider that this was the one and this was the two

considered that this was the one and this was the two and this was the four or sorry four and then

the eight I could just ask now if the final value equals two and then I would know if that bit was

on or not in the original pattern and so if I wanted to check to see if this other you know

bit was on I can move this over here and set that back to a zero so the resulting pattern would be

zeros then I’d ask myself is the resulting value equal to four no it’s equal to zero and so then

Another thing you can do that I’m going to talk about in a future video is just sort of shift the bits over.

You could, instead of checking to see if the value was a 4 or like a direct integer,

you could just sort of shift over a certain number of spots and then check to see if it was equal to 1 or 0.

Let me put this 1 back over into its original position just so that we’ll have something that had a 1.

is one from uh you know the right side if it’s one to the left from the right side

then i could just shift all the bits one to the right and end up with a pattern that is zero zero

zero one i’m not going to talk about bit shifting operations in this video but just know that you can

and you’ll see more of it in a future video so then you know this is another way to check to

see if a bit was on first you do a mask for that bit and then you shift bits and then you just

check to see if the final value is a zero or one which may or may not feel easier than checking for

or may not feel easier than checking for an actual integer in your program.

Okay, so we’ve done OR and also AND. The next bit pattern is called a NOT, which is really easy.

It’s literally just an inversion of the original bit pattern. So for the NOT, we don’t really take

two bits against each other. We just take an input bit and we just invert it. We’ll just say

So that’s a knot. Pretty easy. We could also knot, you know, a random bit pattern with Ls.

So I swear, somebody’s going to show up and this is their first computer science video.

They’re going to go tell their parents, hey, there’s Ls in computer science.

So sorry. I’m so sorry. Okay. So I got four there. So if I knot those, then that’s pretty easy.

It’s just going to be the opposite, you know, an inversion.

you know, an inversion.

One, zero, one, zero.

Let me just double check that I did that correctly.

Yeah, so that’s the knot pattern.

No big deal.

Pretty easy.

So then maybe the next thing that we can talk about is the nor,

which just means not or.

So let me draw that out real fast just to show you what I’m talking about.

So if we do nor, pretty much you can imagine first taking the or and then knotting it.

So inverting the or.

the OR. So for example, if we have two bits here, actually, let me, let me do, let me do a

sequential counter. Cause I think that’s more fun. I’m counting right now from one to a three

or a actually, I do that in the last one. I started with zero. I hope let’s count from zero

to three. So zero and then one and then two and then three. So I’m counting in binary.

two input bits and we’re going to do a nor then the first thing we probably want to do is take

the or operator so that would be a zero here i’ll just put or in parentheses just to let you know

that this is kind of a nice first step you could memorize nor if you wanted to but i don’t i don’t

really remember how to do it without doing these steps so uh it’s going to be ones for everything

else because in the or you get a one if either of those is a one and then uh the next step is you

the or i’ll just put nor here just to let you well just to let you know that you’re uh well i

don’t know if i put nor then it kind of sounds like i’m norring that one bit doesn’t it so maybe

here i’ll say uh not just to let you know that this is just one step against the previous bit

so the knot is uh just going to be an inversion and so the nor of zero zero is one the nor of zero

nor of 1 1 is 0 and that’s how you do a nor and all of these logical or bitwise

operators can be used in circuits and circuit design and just you know other

types of logical operations I’m gonna move on let’s see the next one is gonna

be XOR that I wanted to talk about in this video so what is XOR it just means

exclusive or so it’s a little bit more complicated than or this is actually a

one because it has a history with neural networks. When you have a neural network that does not have

more than one, or sorry, if you have a neural network that does not have any hidden layers,

like if you just have an input layer and an output layer, then the neural network should

actually not be able to solve XOR. It should not be able to learn it. You have to increase the

topology of the neural network in some way, make it a little bit more complicated. For example,

one or more middle layers between the input and the output layers. If you understand neural

networks, it’s just kind of fun to know, oh, XOR stumps a shallow network and kind of starts to

prove that deep networks might be a little bit smarter or deepish at least. Okay. So XOR,

let’s start off by counting here. I’m going to do zero and zero, and then this is the number one,

and this is the number two, and this is the number three. And exclusive OR just basically means

just basically means an or but if both of the bits are one then it’s a zero so that means

either of the bits can be a one to produce a one but it must be exclusive the bit that is a one

can’t also be next to another bit that’s a one so let me show you so in is in a double zero

the answer is just going to be a zero in a zero and one the answer is going to be a one in a one

exclusive, the one is it has a, it has a buddy or a partner.

It’s not an exclusive one.

So we’ll say that that’s a zero.

So that’s the XOR.

I don’t know.

You could put like a, a, a not on top of that or an and on top of that or whatever

you wanted to do.

And we can make stuff that’s a lot more complicated, but these are the basics of

or and not XOR and NOR as bitwise operators.

So thank you for watching this video.

That’s all I have to say for now.

See you in the next one.

Hope you learned a little bit and had a little bit of fun.

I’m out.

social media website that you’re looking at right now it would really mean the world to me and it’ll

help make more videos and grow this community so we’ll be able to do more videos longer videos

better videos or just i’ll be able to keep making videos in general so please do do me a kindness

and uh and subscribe you know sometimes i’m sleeping in the middle of the night and i just

wake up because i know somebody subscribed or followed it just wakes me up and i get filled

with joy that’s exactly what happens every single time so you could do it as a nice favor to me or

it as a nice favor to me or you could you could troll me if you want to just wake me up in the

middle of the night just subscribe and then i’ll i’ll just wake up i promise that’s what will

happen also uh if you look at the middle of the screen right now you should see a qr code which

you can scan in order to go to the website which i think is also named somewhere at the bottom of

this video and it’ll take you to my main website where you can just kind of like see all the videos

i published and the services and tutorials and things that i offer and all that good stuff and

if you have a suggestion for uh uh clarifications or errata or just future videos that you want to

see please leave a comment or if you just want to say hey what’s up what’s going on you know

just send me a comment whatever i also wake up for those in the middle of the night i get i wake up

in a cold sweat and i’m like it would really it really mean the world to me i would really

appreciate it so again thank you so much for watching this video and um enjoy the cool music

the cool music as I fade into the darkness which is coming for us all.

Thank you.

The post Master Bitwise Operators: OR, AND, NOT, XOR, NOR for Beginners appeared first on NeuralLantern.com.

Want to conquer negative numbers in binary? This fun, beginner-friendly tutorial breaks down two’s complement with step-by-step examples (-109, -29) and shows how to convert, pad, and subtract in binary. Learn sign bits, carry bits, and avoid common mistakes. Subscribe for more coding tips and tech tutorials that make learning a blast! Scan the QR code for more resources and join our community!

Introduction to Two’s Complement 00:00:00
Signed vs. Unsigned Integers 00:00:28
Sign Bit Explanation 00:01:55
Positive and Negative Representation 00:02:06
Range of Signed Integers 00:02:48
Padding Signed Integers 00:05:36
Converting to Negative (Example: -109) 00:07:00
Binary Addition and Carry Bits 00:10:16
Correcting Conversion Mistakes 00:16:38
Converting Negative 29 00:13:32
Subtraction Using Two’s Complement 00:18:21
Adding Binary Numbers (109 – 29) 00:20:41
Verifying Results 00:23:56
Conclusion and Call to Action 00:25:40

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social

Please help support us!

• Subscribing + Sharing on Social Media
• Leaving a comment or suggestion
• Subscribing to our Blog
• Watching the main “pinned” video of this channel for offers and extras

Hey there! Let’s talk about representing negative numbers in binary.

We’re going to use a system called 2’s complement which is going to allow us to represent signed integers,

which means there will be a positive sign or a negative sign on the integer

and we’ll still be able to do it in pure binary.

So let me talk a little bit about what I mean first here.

signed and unsigned okay so if i just type the number 14 by itself that is uh that’s an unsigned

integer we don’t really know if it’s positive or negative like do we know that it’s negative 14 or

do we know that it’s positive 14 right so the sign is what lets us know if something is positive or

negative okay so if i if i type a number in binary let’s just do a pure binary number one two three

if you know how to convert binary to decimal you probably recognize right away that this is just

the number zero even if we add a couple of bits here that’s just like the number three

and so this is the number three but so far if if you haven’t learned signed integers in twos

complement or in binary then you don’t really know that there’s a sign you just kind of assume

that the number is positive by default if you’re not using twos complement and you’re just saying

and you’re just saying like well let’s just do a bunch of binary you know digits then yeah it’s a

safe assumption that the the sign is positive but we’ll use two’s complement which starts with the

idea that the highest bit the leftmost bit the bit with the height you know the most power that’s

going to turn into the sign that’s that’s going to turn into the plus or the minus so like you

the sign.

So this means that we have to decide, you know, does a zero mean positive or does it

mean negative or what means what?

So in two’s complement, we’ll say that zero is positive and one is negative.

So you can see right here that we’re still actually representing the number three, but

it’s positive three for sure because this sign bit right here is zero.

That’s positive.

Once we decide to represent two’s complement, then we can say that for sure.

On the other hand, if we put a one here,

then we definitely know that this number is now negative.

However, we don’t actually know that it’s a three

because the numbers don’t work out the same anymore

in two’s complement.

So the positive numbers, they will mostly look the same.

The negative numbers, they’ll look a lot different,

but they’ll still be valid in order,

you know, in terms of us being able to add them together,

subtract them from each other and things like that.

So two’s complement is pretty cool.

Let’s do, let’s see, what else can I tell you?

Oh, one thing to understand is that

One thing to understand is that in an 8-bit unsigned integer in binary, let’s say 1, 2,

3, 4, 5, 6, 7, 8, let’s say unsigned bits, maybe I’ll just put like, maybe just some

like V for value, all the bits are values, that means the range is 0 to 255 with 256

total combinations.

But if we want to use a signed number, then we’ll actually have the signed bit be the first bit,

and all the rest will be value bits.

1, 2, 3, 4, 5, 6, 7.

In this case, the range kind of goes down.

Because if you think about it, every single bit, you know, represents like, you know,

it helps towards the highest possible value that you can represent.

If we’re using the leftmost bit, then for an 8-bit integer, that’s 128.

integer that’s 128 that’s a value of 128 so we lose a lot off of the maximum

integer that we can represent so the range here is I think it’s negative 20

128 to positive 127 just keep in mind you’ll have to trust me in terms of why

is the negative 128 bigger and the positive 127 you know smaller but that’s

just the way it is so that means we only get these value bits here and if you if

that um let’s see if i can do this quickly enough without screwing it up we’ll say 127 minus um

minus negative 128 i guess that’s 255 and then also a zero but uh in terms of positive and

negative the way this is going to work out is the zero will probably show up twice because uh

255 possible combinations with seven bits.

Normally you would have a range from negative, sorry, from zero to positive 255.

And in this case, we’re just, you know, losing our range, but we can represent negative numbers.

Anyway. Okay.

So let’s talk about doing an example real fast. Let’s see.

I’ve got like a little notes to tell me what I should do. Okay.

It’s important to understand that normally when you have, let’s say, let’s say you have

like an 8-bit number and you go 1, 2, 3, 4, 5, 6, 7, 8.

And then you have 2 bits right there and so this is like, you know, positive 3.

If you wanted to copy that number into more bytes, like for example, if you wanted to

take a 2-byte integer and have it copy the value of a 1-byte integer, then it’s pretty

easy.

zeros to the left you’ll say one two three four five six seven eight that would work perfectly

however if you did this with a negative number let’s say that we have a negative number

I’m going to put some of the random patterns so that you don’t think it’s the three let’s see

one two three four five six seven eight that’s eight total so I’m going to make that a one and

then get rid of that so we have like eight negative number if we were going to copy that

integer then we would copy paste it to start but then you’d have to pad with

ones to the left one two three four five six seven eight same negative number

more bits so be very careful about how you pad if you’re padding an unsigned

integer then yeah you’ll always pad zeros to the left no matter what is

happening but if you’re padding a signed integer then you have to pad differently

signed integer you have to pad with whatever the highest bit is so in this case the highest bit was

a zero so we do pad with zeros but then in this case the highest bit was a one so we have to pad

with ones if you don’t do that you’re going to end up with a number that doesn’t actually make

sense okay so now let’s work on actually converting a number to a negative number or representing a

negative number in twos compliment okay so i’m going to write twos compliment here and then uh

Let’s start off with the number negative 109.

Okay, how do we do this?

The first thing is convert it to its positive form.

Take the absolute value. Okay.

So we’re really just, you know, take positive form here,

and that’s just going to be positive 109.

Okay, no problem.

I’ll say start with negative 109, and then we’ll take the positive form 109.

Now we’ll convert it to binary.

Okay, this is not a video that teaches you how to convert to binary, so I’m just going

to try to do this in my head real fast here.

It’s going to be, let’s see, we got 8 bits, we’ll use just 8 bits to store the number,

and because it’s low enough and I don’t want to use that many bits, so it’s odd, so I can

add a 1 there, but maybe for now I should find the highest bit that is less than the

actual number.

So this is the 128 bit right here. So that’s going to be a zero. This is the 64 bits

I’m going to put a one there and I’m just going to say

Mmm, maybe like

This is like maybe not the smartest way to do it. I’ll say 109 minus 64

Because I put a one there and then 45 so now this is 32 that’s less than 45. So I’ll put a one there and

Then it’s going to be minus 40

So it goes from 45 to 13.

So then that was the 32.

Okay, so 128, 64, 32, and then 16.

Is 16 less than 13?

No, it’s not.

So we’ll put a zero here.

And then the next one is going to be just four.

Four is definitely less.

So I’ll put a one bit there.

And then I’ll subtract four.

And then one, two, four.

Oh, wait a minute.

One, two, four, eight.

wait a minute one two four eight sorry that was supposed to be subtracted uh subtracting eight

because that was the eight bit uh then i want to get five so here is the four bit so i put a one

there and then i’ll just put a one here because four plus five is equal to uh i’m sorry four plus

one is equal to five so let’s see um it is let me just double check here one

one let me just double check my conversion real fast it’s going to be

the one bit plus two four plus eight six thirty two plus thirty two plus sixty

four did I get one on nine yeah okay so I guess I did it right so convert to

binary and that’s going to be this the next thing we’ll do is we will invert the

bits I made a little edit jump here because I inverted the bits incorrectly

on the first try which is sad but hey it happens the next thing we’ll do is

but hey it happens the next thing we’ll do is we’ll invert the bits so basically you know we

take this original sequence here and i’ll just turn every single bit uh i’ll flip it i’ll flip

ones to zeros and zeros to ones so i’m going to go one zero zero one zero zero one zero okay so now

we have this number invert the bits then we just have to add one so we’ll add positive one to that

that it’s just going to be a one there at the end.

But sometimes that might not be the case

because what if we already had a one there

and we had to add one to that?

Well, we’d add one to the right side

and it would turn into a zero

and then it would carry a bit to the left.

That would become a zero

and then the carry bit would show up all the way over there.

So I just want you to be aware of the fact that

when you add two binary numbers together,

you have to be careful.

You have to add them the same way you would add decimal numbers.

For each digit’s position,

you have to add the two numbers together and then if they overflow then you just

kind of wrap around to the lowest number again subtracting you know the highest

value or sorry subtracting the base like in decimal if you add 9 and 9 the answer

is 18 but you’re not going to write 18 in that one position you’re going to

subtract the base which is 10 so it’ll actually be 8 and then you’ll carry the

plus nine is equal to eight carry the one right so we’ll do the same thing in binary we’ll say

if we ever get a one plus one when we’re adding the answer will be two but then we subtract the

base which is two so the answer is actually zero carry a one bit keep that in mind i’m just gonna

write it all out for you so you can kind of get a little bit of practice it’s important to to

practice this because it’s easy to get wrong i’m going to put a bunch of dashes up at the top to

and I’m going to say we’re going to add, you know, one number plus another number,

put a little plus symbol over there just to try and make sure we do it the right way.

Okay, so how do we add these?

Well, we’ll just go to the right side.

Zero plus one is one, no carry bit.

One plus zero is one, no carry bit.

Then we got a couple zeros here, no carry bit, of course.

One plus zero is one, no carry bit.

And then a couple zeros and then another one with no carry bit.

Okay, so, you know, we could have done that pretty easily, but

but well now we’re getting a taste for binary addition that might be harder later.

So we’ll just do that for now.

And now this is the two’s complement representation of negative 109.

I’ll say now we have negative 109 is equal to that.

leftmost number the most powerful sorry leftmost bit the most powerful bit is a one remember one

always indicates negative so when you’re looking at it if your leftmost bit turns out to be a zero

then you probably did something wrong or you had an overflow maybe um and again if we were going

to try to you know send this number into a two byte number or an eight byte number or whatever

uh then we would just have to pad with the sign bit so one two three four five six seven eight

help my brain so this was this is the way it would look in a two-byte number this is the way it would

look in a three-byte a four-byte and five six seven how many one two three four five six seven

okay one more this is what it would look like as an eight-byte number or a quad word 64-bit number

yeah okay so now we know how to do negative 109 okay so now let’s do a number that’s a little bit

negative 29. So let’s say convert, or how about represent negative 29 into

2’s complement. Okay. So first we, you know, first get the absolute value.

So just 29. And then we have to invert the, sorry, we have to get that into binary. So

next convert to binary. And I’m going to start with zeros, one, two, three, four, five, six,

1, 2, 3, 4, 5, 6, 7, 8.

For this video, remember, we’re choosing to use one byte integers.

But if you wanted to do a bigger one or you had to do a bigger one,

then just, you know, keep that in mind.

Okay, so 128 is not smaller than 29.

64 is not.

32 is not.

16 is, though.

So I’ll put a 16 bit there.

And I’ll just subtract 16 from 29.

29 minus 16.

Now we’ve got 13 left.

So 64, 32, 16.

six four thirty two sixteen eight okay so now I’m gonna put a one bit there and

I’m gonna subtract 8 from the remainder and then we got a five which is pretty

easy to do eight four and then a one so now we have well zero zero zero one one

one zero one that’s the binary number the positive or unsigned representation

representation. So now we’ll add one. Positive one. And let’s try to do this the right way so

that we can practice carry bits with addition a little bit. Notice how this one is already there

on the right side. So it’s going to, we’re going to have at least one carry bit for sure.

So then I’m going to go doop like that. And then I’m going to say that we have like, you know,

what is the result? Put a positive sign there. And then I’m going to put a bunch of dashes

my carry bits because I can I can forget that pretty easily. So the first thing is we add one

and one. The answer is two, but we can’t put the number two here because it’s binary. Instead we

need to subtract the base which is two. So two minus two is equal to zero, but then we have a

carry bit of one. So I’m going to put a one there. The first carry bit will stay as a dash for this

whole you know exercise because you’re not going to carry on to the first digit. So now we have

what would have been just zero plus zero now we have one plus zero plus zero so

that means this is going to be one and then the carry bit is just going to be

zero because we don’t actually carry anything so then we have zero plus one

plus zero so that’s going to be a one and then zero carry bit and then zero

one zero is just going to be one and then there’s going to be no carry bit

and then zero one zero again a one no carry bit because we didn’t actually

zero zero zero and then I’m just gonna put zeros here okay so now we have

successfully added I blew it totally blew it I always forget steps don’t

forget the steps this is a good lesson I’m gonna leave this in the video

because I want you to see that everybody makes mistakes and you got to practice

practice practice especially before you have to actually do this in real life or

or something like that.

Next, convert to binary.

Before you add one, I’m gonna just remove this.

Oh my gosh.

Next, flip the bits,

which is gonna be 1110010.

Okay.

So now we take this bit flipped number

and we will add one.

So that’s gonna be zero, zero, zero, zero, zero, zero, zero,

one, oh, it’s too easy.

Maybe I got excited and I thought,

excited and I thought, oh, it’s carry bit time.

But even though the last edition that I did was wrong because I forgot to carry

the or flip the bits, you still at least saw a little bit about how to carry the bits.

Right. OK, so it’s just going to be one.

Let me start from the right side.

One one zero zero zero one one one one one one.

Let me just double check here.

One one one zero zero zero.

OK, so I got that.

Now we have.

negative 29 in twos compliment. Again notice if we actually tried to add those numbers up to be

like an unsigned binary number they’re not really going to make sense because this is like 64 plus

32 plus 3. So what would that end up being? Let’s just double check here. 64 plus 32 plus 3, 99.

That’s not actually the number but the number is 29. So keep in mind you can’t just look at this

unless you’re like really, really practiced.

Okay, and again, notice that the number is 1 at the very left,

indicating that it’s a negative number.

Now, let’s look at how to subtract one number from another

using 2’s complement.

Okay, so what I want to do is I want to subtract,

let’s say, 29 from 109.

Okay, so let’s subtract, and I’ll just say 109 minus 29.

109 minus 29.

And how I would do that is basically I’ll start by just taking 109.

Let’s see, convert to binary.

So I’m just going to copy paste that number.

So 109 is this and then 29, take the positive version.

It is just, let’s see, before we flip the bits or anything,

let me make sure that I grab the right one.

Invert the bits, okay.

So positive 29 is this number.

Whoops.

is this number whoops let me put parentheses around that so it’s easy to tell and then I’ll

put a positive sign there like that maybe like that nope nope nope nope how about this okay

so now we have both of these numbers in positive form so now if we added 109 plus 29 that wouldn’t

negative positive 29 that would be what we wanted right because really if you’re subtracting

i’ll say aka

positive 29 plus negative 29 all we really need to do is um invert the 29 and then add the result

to 109 so that means we’ll we’ll turn positive 29 into negative 29 using two’s complement

through the steps again but basically put it there but basically you know that’s negative 29

so say positive 129 is equal to what i just put up here and then negative 29 is equal to

maybe i should do the parentheses again for clarity uh is equal to this okay so you can tell

that positive 29 is pretty pretty different from negative 29 but now we have

29 but now we have both of those numbers so let’s see 0 1 1 0 and then we’re ready to add okay all

we got to do is add them together next add them together maybe I should write the steps up here

negative 29 using twos complement and then next add them together so then I’m

going to copy paste the bits here and it’s going to be this plus this do a

positive plus sign just to remind ourselves that we are actually adding

and then I’m going to put a bunch of placeholders for sign bits up at the

top and now we’ll have a little bit more fun adding numbers together maybe I’ll

drag this down

Oh my god. Oh, there we go. Okay. So I’ll start with the one on the right, the position on the

right. That’s going to be one plus one equals two, but then that’s an overflow. So I’m going to

subtract the base. So it’s going to be zero. And then don’t forget to carry the one. Oh,

cool. More interesting. So we have one plus zero plus one. That’s going to be another two carry

two carry the one so it’s going to be zero and then carry the one again so i’m going to put the

carry bit up there and then again we have one plus one is equal to two so it’s going to be zero

carry the one again zero carry the one and then finally we don’t really have a carry bit

um so we’ll just have like a one and there’s there’s no carry so it’s going to be you know

carry a zero and then we add these two together so it’s going to be a zero carry the one and then

Now we have a three.

Oh, that’s kind of nice.

So this is an interesting edge case kind of.

One plus one plus one is three.

But if we subtract two, the base from it, you know, three minus two, it’s going to be one, not zero.

So it actually is going to be a one and then carry the one on top of that.

Then for here, let me space this over a little bit so that I can illustrate what’s going on a little bit better.

We’re going to have one plus zero plus one.

definitely going to be zero and then carry the one but there’s no bit where that carried one can

can show up on right so that one overflows it falls off the edge if this was a bigger number

then okay we you know if we had more bits to this number then sure we would just keep carrying over

over to the left but remember we said before that when we have a very big number let’s see

bits it’s just ones all the way to the side that will actually help us make sure that if our final

number is actually going to end up being positive that everything kind of like dominoes like carry

the one carry the one carry the one carry the one carry the one all the way until one of the ones

falls off think about it so anyway this one just is gone we don’t really care about it anymore

the result is going to be just only eight bits because that’s the number that we started with

bunch of zeros what is you know the final answer let’s just compute this

real fast to decimal so this is 128 and then 64 so it’s gonna be 64 plus not 32

but 16 so 64 plus 16 that’s gonna be oops 16 that’s gonna be 80 and now we

just have to ask ourselves again as like a final step to double check yourself to

what you’re doing and that you got it right is just punch up 109 minus 29 just to make sure

109 minus 29 whoops what happened here 109 minus

oh i think i stole my subtraction key for the annotator 109 minus 29 is 80

so again you know if you’re if you’re trying to like you know write something down to do some

you know taking an exam or something you definitely want to double check yourself in several ways

As you can tell from this video alone

I got one of these things wrong because I forgot to input the bits as a step before adding one

So you know your final step should be actually trying to add two numbers together or subtract numbers or whatever

You’re doing to make sure that you got the binary correct

So let’s see

Hmm

I guess maybe your first indication that the result was going to be positive would be that

there’s a zero there. And just, you know, as a sanity check, you look at the top and you’re like,

well, I was going to subtract a small number from a larger number. So the result should probably be

positive, right? Like 29 is like way lower than 109. So it should be positive, which means the

final result should have a zero at that leftmost position. Okay, so that’s two’s compliment,

two’s complement how to convert numbers from positive to negative in two’s complement you

know what the sign bit means and all that stuff and how to perform subtraction via two’s complement

i hope you enjoyed this video thank you for watching i hope you learned a little bit of

stuff and had a little bit of fun see you in the next video hey everybody thanks for watching this

video again from the bottom of my heart i really appreciate it i do hope you did learn something

If you could do me a please, a small little favor, could you please subscribe and follow this channel or these videos or whatever it is you do on the current social media website that you’re looking at right now.

It would really mean the world to me and it’ll help make more videos and grow this community.

So we’ll be able to do more videos, longer videos, better videos, or just I’ll be able to keep making videos in general.

So please do me a kindness and subscribe.

in the middle of the night and I just wake up because I know somebody

subscribed or followed. It just wakes me up and I get filled with joy. That’s

exactly what happens every single time. So you could do it as a nice favor to me

or you could you could troll me if you want to just wake me up in the middle

of the night just subscribe and then I’ll just wake up. I promise that’s what

will happen. Also if you look at the middle of the screen right now you

should see a QR code which you can scan in order to go to the website which I

think is also named somewhere at the bottom of this video and it’ll take you

you to my main website where you can just kind of like see all the videos I published and the

services and tutorials and things that I offer and all that good stuff and if you have a suggestion

for clarifications or errata or just future videos that you want to see please leave a comment or if

you just want to say hey what’s up what’s going on you know just send me a comment whatever I also

wake up for those in the middle of the night I get I wake up in a cold sweat and I’m like

it would really mean the world to me. I would really appreciate it. So again,

thank you so much for watching this video and enjoy the cool music as I fade

into the darkness, which is coming for us all.

Thank you.

The post Master Two’s Complement: Convert & Subtract Negative Binary Numbers appeared first on NeuralLantern.com.

Confused by hexadecimal numbers? Don’t worry! This fun, step-by-step guide makes converting hex to decimal super easy, even for beginners. With clear examples and a chill vibe, you’ll master this computer science skill in no time. Perfect for students, coders, or anyone curious about number systems. Hit subscribe for more coding tutorials, and check out our site for extra resources! #HexToDecimal #CodingForBeginners #ComputerScience #LearnToCode

Introduction to Hexadecimal Conversion 00:00:00
Purpose of Conversion 00:00:11
Number System Basics 00:00:39
Hexadecimal Explanation 00:01:12
Converting Hex to Decimal 00:01:59
First Example Setup 00:02:35
Decimal Place Value Recap 00:03:02
Hexadecimal Place Value 00:05:14
Formula for Conversion 00:05:43
Translating Hex Letters 00:08:17
First Example Calculation 00:09:51
Second Example Introduction 00:11:14
Second Example Conversion 00:11:58
Second Example Result 00:13:11
Conclusion and Call to Action 00:14:00

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social

Please help support us!

• Subscribing + Sharing on Social Media
• Leaving a comment or suggestion
• Subscribing to our Blog
• Watching the main “pinned” video of this channel for offers and extras

Hello there. Let’s talk about converting hexadecimal to decimal.

So why would you do this? Of course, sometimes in computer science and other realms, you may be

faced with a number that looks like this, and it’s got some letters in there, and it’s weird,

and you’re thinking, oops, not a V. That wouldn’t work. Not a G. And you’re thinking like, what does

what does this number mean in decimal well this is a number that is real and we can just change

the way it’s represented uh to decimal so that we can understand what it is so just like a quick

recap if you haven’t watched my other videos yet uh in decimal we have a base 10 system which just

basically means we have these characters zero one two three four five six seven eight nine there

base is 10. In binary, of course, we have base two, which is just, you know, we have a zero and a one

because in the computer, which is why we learn binary, we just have on and off basically for

every single, you know, part of the computer. There’s just like a certain voltage or there’s

not a certain voltage and that’s it. And then for hexadecimal, which is a way to represent the same

numbers, but just in a more compact way. It’s a little bit more compact than decimal. It’s a lot

than binary we can say that this is base 16 which means we have 16 total characters that we can work

with zero one two three four five six seven eight nine and once we run out of numbers we just start

using letters so a b c d e f so there are 16 total characters if we include the zero which means we

So that’s the basics of you know the number basis let’s uh let’s work out how to convert a hex

number to decimal. So I’m going to say ox because in hex when you write down a hex number you should

usually put ox in front of it unless the program you’re working with doesn’t understand that but

usually especially for a human reader you should do it this way. So I’m going to just type like a

few random maybe I have to I have to keep the number small because hex will explode it’ll be

not careful. So I’m going to put like a I don’t know, maybe a few decimal numbers there or a few

like digits that are zero to nine, then I’ll just to make it more interesting, I’ll put some letters

in there. How about like an E there? And then I don’t know, like, we’ll do a B there. Okay, so

how many do I have? 12341234? How about we get rid of? Now, let’s go for it. This is going to be an

So this is our starting number hexadecimal. What we need to do is understand that, well,

a recap if you haven’t watched my other videos yet. In decimal we have, let’s say, 0, 1, 2, 3,

4, 5, 6. You know that the first digit has a strength of 1. You multiply 6 by 1 to understand

the real power of that 6. For the 5, you know that it has a power of 10 or a strength of 10

10 because it’s the next digit over you know to the left same thing for the four it’s like got a

strength of 100 and so every time you move to the left the strength of the digit increases by a

factor of 10. why does it increase by a factor of 10 because decimal is base 10 because we have 10

possible digits we can represent for each character okay so by the time we get to that

left, we have a strength of 100,000. So, you know, if you wanted to really understand 100,000,

if you really wanted to understand, you know, how powerful, let me, let me give some spacing here.

So this feels better. Okay. If you really wanted to understand like, you know, what is the strength?

What is like the actual value of this digit right here? You’re imagining this is like 100,000.

this digit here you’re imagining that this is two of ten thousand you know two times ten thousand

and so forth so uh uh just like another recap the first digit is really 10 to the zero power

like in terms of the strength because if you multiply um let me pin this to the top

if you multiply you know 10 to the something power and you start at zero with the most

the weakest digit 10 to the zero power gives a strength of one and then every time you move over

to the left you just increase the exponent there by one so 10 to the first power is going to be 10

that’s what that five has got so it’ll be five times 10 to give us an understanding of how you

know powerful that digit is move one over to the left it’s 10 to the second power so that’s 100

move one over to the left it’s 10 to the third power and so forth until we get to 10 to the fifth

1 times 10 to the fifth power to understand how powerful that is so we can do the same exact thing

with hexadecimal except instead of raising 10 to a power we raise 16 to a power because hexadecimal

is base 16 whereas decimal is base 10. so that means this e is is uh you know 10 to the or sorry

16 to the zero power and then that 3 is 16 to the 1 power and that f is 16 to the 2 power and so

16 to the 2 power and so forth so first what we should do is let’s write out a

formula which won’t work in a calculator because we’re going to put some letters

in there and then later we’ll translate the letters to actual values so we’ll

start off with the e we’ll say e times 16 to the something power it’s going to be

16 to the zero power okay so then the next digit is 3 so 3 times 16 to the

And then the next thing is going to be F times 16 to the second power.

And just as a reminder here, I’m starting with zero with the smallest digit.

And I’m just working my way up in steps of one.

So it’s zero power or raised to zero and raised to one and raised to two and just so forth all the way to the left.

That number will just keep increasing by one.

The exponent will increase by one.

times 16 to the third power do it again um one times 16 to the fourth power do it again

um d times 16 to the fourth power oh what did i do did i erase something

0, 1, 2, 3, 4, 5.

Oh, that was supposed to be a 5.

Okay, maybe it’s good that I thought I made a mistake

because that drew my attention to the bad exponent.

Okay, so after the D is a B.

B times 16 to the 6th power.

And then one more.

We’ll say 6 times 16 to the 7th power.

And then another one.

A times 16 to the, whoops, to the eighth power.

And another one.

One times 16 to the ninth power.

Ninth power.

Okay.

So just double check your work real fast.

You know, because I make typos all the time and I get things wrong all the time.

So just double check.

Zero, one, two, three, four, five, six, seven, eight, nine.

It’s sequential.

Double check the digits.

6 b d 1 3 f 3 e okay so i got that right i’m not going to erase my work because if i end up screwing

up the next part oh man is it going to be a hassle to correct so i’m just going to copy paste it here

and then i’m going to start translating the letters to numbers anytime you see a number here like one

time something it’s just one but every time you see a letter you have to translate that into

in decimal. Remember in hex, we’ll say, what can I do?

I can say A, B, C, D, E, F.

And I can say that the A is worth 10.

The B is worth 11.

The C is worth 12.

And the D is worth 13.

The E is worth 14 and the F is worth 15.

Well, maybe I should do the other numbers too.

five, six, seven, eight, nine,

just so we have a visual reminder

of like what we’re even looking at.

And I won’t write down what the digits are worth

because they’re worth themselves, right?

So like zero through nine, it’s just worth zero through nine.

So now that we have this little translation table up here,

anytime we see a letter,

we can just translate it very quickly to the decimal value.

So A is worth 10, we’ll put a 10 there.

Maybe I’ll add some spacing so that this continues to line up.

I see a B here, so the B is gonna be worth 11,

11 add another space so it lines up i’m running out of room but i’ll try the d is worth 13 add

another space so it lines up and then the f is worth 15 add another space so it lines up the e

is worth 14 so i’ll add another space so it lines up okay let me just double check my work here a b d

So now I’ve got like a big formula that I wrote out.

I can literally now, I mean, you can do this in your head if you’re like a crazy genius,

but I’m just going to paste this into a calculator and hit enter.

And this is the number that we had originally in hex.

Maybe I’ll put commas here to make things more fun.

I don’t know.

You don’t really need to do that, but I’m going to.

So for me, it’s easier to read.

this is uh like 113 trillion 478 no wait that’s a million and that’s a bill okay so 113 mil a

billion 478 million 25 022. let me punch up my personal calculator here to make sure that i’m

getting this right i’m not going to show this on the screen because i’ve just got this up

on my host machine bet you didn’t know i’m inside of vm right now surprised you didn’t know that

decimal and the number is supposed to be 113478025022 okay so we did this right we now know how

to convert from hexadecimal to decimal and it’s pretty awesome right okay let’s do another number

one that is not quite as hard let’s see how many digits do we have here one two three i think we

5, 6, 7, 8, 9, 10.

Yeah, okay, we had 10.

Let’s do a five-digit hex number.

Okay, maybe I’ll copy…

I’ll copy just this table at the top

since you don’t need it anymore,

but I’m going to need it to do my calculations.

So we’ll do 1, 2, 3, 4, 5,

and I’ll just start randomly changing

some of these numbers.

Like an 8 over here, and how about like a 2?

So I’ve got five numbers.

This is OX.

I’m going to say this is a hexadecimal number.

Kind of ambiguous if we tell the reader this is a hex number,

but then we put OX.

Kind of don’t really need to tell them that it’s hex

because OX tells you it’s hex.

It’s not even part of the value.

So let’s get on with it.

I’ll start by just doing 8 times 16 to the something power,

which is going to be 0 for that first position.

the power as we go to the left so it’s going to be 1 times 16 to the first power and then it’s

going to be f times 16 to the second power and then it’s going to be 2 times 16 to the third

power oh no my thoughts are wandering i think i’m getting bored of recording this video i’m starting

to the fourth power but honestly why couldn’t they end up together so and

then I think one two three four five okay so that’s five digits a to f one

eight a to f one eight all right zero one two three four just to make sure

that I got my exponents right copy paste it so I don’t have to repeat my work if

I get something wrong I’m gonna translate the letters into numbers so a

becomes 10 f becomes 15 and the other numbers are fine as is I can just copy

fine as is I can just copy paste this whole thing stick it into a calculator and now I know that

this number is actually 667 416 with a little comma in there don’t put commas if you are taking an

exam somewhere if you’re watching my video to help with your exam because most most likely the exam

that you’re taking will not accept a comma it’s not been pre-programmed for a comma I don’t know

If you start typing numbers and a comma just shows up, then it probably was programmed for a comma.

But don’t assume it might be a string match and not a numeric match.

So be careful out there.

Be careful.

So 667-416.

Let me punch this into my personal calculator just to make sure I got this right and I don’t have to issue an errata.

667-416.

All right.

We’ve done it.

We know how to convert hexadecimal numbers into decimal numbers.

Thank you so much for watching this video. I hope you enjoyed it and had a little bit of fun and

learned a little bit of stuff. I’ll see you in the next video. Hey everybody, thanks for watching

this video again from the bottom of my heart. I really appreciate it. I do hope you did learn

something and have some fun. If you could do me a please, a small little favor, could you please

subscribe and follow this channel or these videos or whatever it is you do on the current social

It would really mean the world to me and it’ll help make more videos and grow this community.

So we’ll be able to do more videos, longer videos, better videos, or just I’ll be able to keep making videos in general.

So please do me a kindness and subscribe.

You know, sometimes I’m sleeping in the middle of the night and I just wake up because I know somebody subscribed or followed.

It just wakes me up and I get filled with joy.

That’s exactly what happens every single time.

So you could do it as a nice favor to me or you could troll me if you want to just wake me up in the middle of the night.

Just subscribe.

just wake me up in the middle of the night just subscribe and then I’ll just

wake up I promise that’s what will happen also if you look at the middle of

the screen right now you should see a QR code which you can scan in order to go

to the website which I think is also named somewhere at the bottom of this

video and it’ll take you to my main website where you can just kind of like

see all the videos I published and the services and tutorials and things that I

for clarifications or errata or just future videos that you want to see please leave a comment or if

you just want to say hey what’s up what’s going on you know just send me a comment whatever I also

wake up for those in the middle of the night I get I wake up in a cold sweat and I’m like

it would really it really mean the world to me I would really appreciate it so again thank you so

much for watching this video and enjoy the cool music as as I fade into the darkness which is

the darkness which is coming for us all.

Thank you.

The post Hex to Decimal Made Easy: Fun & Simple Conversion Guide! appeared first on NeuralLantern.com.

Binary got you baffled? Let’s break it down! In this fun crash course, I’ll show you how to convert binary to decimal step-by-step—super easy, no stress. We’ll go from 765,432 in decimal to 10101111 in binary (that’s 335, btw), with tricks to eyeball it fast. Perfect for beginners or anyone who loves a good tech challenge. Hit subscribe—I wake up in a cold sweat when you do, and it means the world! More vids coming your way!

Introduction to Binary and Decimal 00:00:00
Understanding Decimal System 00:00:44
Decimal Position Strengths 00:01:39
Decimal Formula Explanation 00:03:48
Transition to Binary System 00:06:31
Binary Position Strengths 00:07:19
Binary Formula Breakdown 00:10:46
Calculating Binary Example (335) 00:12:55
Quick Binary Conversion Trick 00:15:24
Memorizing Binary Positions 00:13:52
Small Binary Example (19) 00:15:43
Closing and Subscription Request 00:16:48

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social

Please help support us!

• Subscribing + Sharing on Social Media
• Leaving a comment or suggestion
• Subscribing to our Blog
• Watching the main “pinned” video of this channel for offers and extras

Hello there. Let’s talk about converting binary to decimal.

Just a quick recap for those of you who don’t know. Watch my other videos if you’re not sure

about number bases, but basically, you know, decimal is a number system that has 10 characters

to represent a number. So 0, 1, 2, 4, 5, 6, 7, 8, 9. That’s 10 characters in decimal.

In binary, we just have two characters.

So it’s base two, whereas decimal is base 10.

How can we convert between the two?

Well, first, before we can try to convert between the two,

we should try to understand what’s really going on with normal decimal representations.

So if I have a decimal number here, and I say, I don’t know,

let’s just type a couple of random numbers.

How do we really know what this value is?

How do we kind of understand what is the meaning?

Okay, so you know that, you know,

if you just kind of look at this for a second,

you’ll realize this is 765,000, right?

765,432.

How do we know that this is 700,000?

Because it’s in a certain position.

It’s like, you know, several digits to the left.

How do we know that the next one represents 65,000?

Well, it’s one less to the left.

uh it’s a tenth of the like power of the seven digit same thing for the five how do we know

that’s a thousand same thing for the four and the three and the two what we really do is we end up

deciding okay you know what the uh the first digit here on the right side that two uh the strength of

of one. So like, you know, two times one is just two. So whatever, whatever that digit is, if it

was a five, it would just be a five, five times one is five, right? So the strength of the very

first digit on the right side is just one. Every time we move one digit to the left, we multiply

the strength by 10. The reason we multiply the strength by 10 is because there are 10 possible

digits, or 10 possible characters that we can use in decimal. Makes sense, right? So that means the

Makes sense, right?

So that means the three, we know that represents, you know, an addition of 30 because that’s

the 10th strength place.

Same thing for the four.

We multiply 10 by 10 again to get 100 in that position.

So this one has a strength of 100.

I’m writing this vertically.

Hopefully this is not too messy, but I’m hoping you’ll understand.

Well, I don’t know.

Maybe if I space this out, does that make it better or worse?

maybe it makes it slightly better i don’t know i’m going to roll with it

what can i say i’m a rebel okay so i live dangerously the five we know that’s worth

five thousand because again the four position over here you know that third digit it had a

strength of 100 so we multiply that strength by 10 going to the left to to end up with a thousand

to end up with a thousand.

So same thing with the six.

I’m not going to explain that any further.

You know, it’s got a strength of, you know, 10,000.

Okay.

And then the seven, it’s got a strength of 100,000.

And it just keeps going and going and going to millions and billions and trillions

and however far you actually want to go.

That’s how we understand the decimal numbers

that we’re looking at.

How could you imagine this in terms of a formula?

Well, we’re really raising something to the 10th power.

If you think about this, the one,

we could imagine that the value one

is actually 10 to the zero power

because anything raised to the zero power is just a one.

Let me pull up this calculator real fast.

I got to stick that on my desktop in the future.

If we say 10 to the zero power, it’s just one.

Any number to the zero power is just one.

Okay, so then we would multiply that strength

by the actual digit that we see,

the character that we see.

It’s a two.

Okay, so that’s going to be two times 10 to the zero power.

I’m going to put that in parentheses

to keep it a little bit clean or somewhat cleaner.

So now when we go one to the left

to look at that three digit,

to look at that three digit, we end up with three times something.

Let me get a space here for my brain.

Times 10 to the something power.

Well, every time we go to the left, we just really have to increase the power by one.

It’s 10 to the first power because we’re looking for actually just the number 10.

So if we say 10 to the first power on that calculator, it’s 10.

So then, you know, just keep repeating the process.

10 to the second power. And that should be 100. So if I say 10 to the second power, it’s 100.

All right. And, you know, we’re adding all the positions together, even though we’re multiplying

the digit by its strength. So I’m going to say five times 10 to the third power. And then again,

just to double check here, 10 to the third power is 1000. So you can see the five was supposed to

and then again we’ll say six times ten to the fourth power and then just double check here

the fourth power should be a thousand sorry ten thousand and then we’ll do it one last time we’ll

say seven times ten to the fifth power which should be a hundred thousand all right so now

that we’ve written this all out you know this is kind of madness right what you can do now

do now is you can put this into the calculator and it should give you the exact same number that

we started with. We should see 765432, unless there’s a typo. 765432. Nice. Okay, that might

have seemed like it was a little bit of a waste of time, but it’s not because now we kind of

understand the breakdown of the different positions of the digits in decimal, which means

now we can do the same thing in binary, basically the exact same thing, except just use a power of,

use a two to some power rather than a 10 to some power because the only reason we use 10 down here

it says we were in decimal that has a base of 10 now let’s go into binary

which is um a base of two so i’m going to just i guess maybe what did i do wrong

i hit something and it like did a space i don’t even want to know i don’t even want to know

okay so let’s do a binary number i’m just going to type a few random digits

a few random digits. I don’t know what number this is yet, but let’s work it out slowly

in the same way. You know what, maybe instead of doing the formula first and only, let’s do

both parts like we did with decimal. So what’s the position, what’s the strength of the position

for that first character? Well, I said before the first character is always just going to be,

sorry, the first digit is always just going to be a one, right? That’s going to be true

So I’m going to say this has a strength of 1.

How do we know it’s a strength of 1?

Because we’ll take 2 to the something power.

We start at 0 for that first position, and it’s going to give us a 1.

Okay.

So the strength of this one, I already know binary.

So I just know off the top of my head that to go to the left,

the strength just multiplies by 2.

And that’s pretty easy after you start memorizing it.

I haven’t quite memorized hexadecimal yet, but maybe you will in another video.

So I’m going to multiply one by two and I’m going to end up with two.

Double check over here in the calculator.

Two to the first power is two.

So then the strength of this next digit should be four.

Two times two is four, right?

So let’s do two to the second power.

That’s four.

Multiply by two again.

It’s going to be eight.

Double check over here.

Two to the third power is eight.

The next digit is going to be 16 of its strength.

So I’m going to write this vertically again.

So it’s going to be 16.

Double check over here with the calculator.

Double check over here with the calculator, 2 to the 4th power is 16.

Next digit is going to be 32.

Double check with the calculator, 2 to the 5th power.

And things are starting to get messy, so I think I’m going to like space everything out probably.

Just to make it easier to read.

Tell me if you think this makes it actually easier to read or if I’m making it way harder.

I think I’m making it easier.

Okay, so we got 32.

two. Next one up is going to be 64. Just multiply it by two. Double check two to the sixth power.

That’s going to be 64. And then the biggest one that we’ve written down is going to be 128.

Double check it. Six to the seventh power is 128. We could go on and on and on, but I’m just going

to leave it here because we, I hope we have a pretty good idea of, you know, what this means.

delineation or like a delimiter showing us that these are just representing the strengths and

this is the actual number. Okay, so how can we write this out in a formula?

Whoa, what did I do wrong? Did you see that? Oh no. Hang on a second.

I think I missed it. How many digits are there? If there are eight digits, then I definitely forgot

something. No, no. Okay. There are nine digits, so the last one should be 256. Okay.

256. Okay. So I got it all lined up. At some point I must have not lined it up. My apologies,

but hey, maybe I’m making these mistakes on purpose to make sure that you’re paying attention.

You never know. I want you to think. So 256 is going to be the next number. Double check it with

the calculator. Two to the eighth power, 256. Cool. By the way, a quick trick in binary that

the actual highest number that you can represent in an unsigned binary integer is basically the

strength of the highest digit, you know, this 256 here, multiplied by two and then subtract one

from it. So 256 multiplied by two is going to be 512. So it’s going to be 511. So I could

represent a number between zero and 511 or 512 possible combinations. Okay, so now let’s work

let’s work out the formula.

See 16, 30, 16, 40, okay, I did it okay.

I probably should have rehearsed this.

So let’s do each position.

So it’s either always gonna be one times something

or zero times something, right?

Because binary, these characters can only be one or a zero.

So let’s do on the, starting from the right,

we’ll say one times two to the something power.

It’s gonna be two to the zero power

You know, just going to be a one.

Working our way over to the left, it’s going to be one times two to the something power

to the first power because it just increases every time the power increases.

We have four ones in a row here.

I got to try to remember that.

This is where I’m going to start making lots and lots of typos.

Two to the second power.

And then we have another one.

One, two, three, four, one times two to the third power.

And then again, we are going to hit a zero.

So it’s going to be zero times two to the something power.

You might be tempted to omit the zeros.

You can if you want to.

But for me personally, it helps me quickly visually see that I’m getting the powers in

the right order.

I can see two to the zero power, first power, second power, third power, fourth power.

Sometimes when I omit the zeros, I end up kind of like messing up the order of the powers

and or the order of the exponents.

of the exponents and I have to redo everything all over again.

So I just keep it this way.

Okay, so it’s one, one, one, one, one, one, one, one, zero.

So there’s another zero that we need

times two to the fifth power.

So we got both of those zeros now.

And then we need another one times two to the sixth power.

And then we need

0 times 2 to the 7th power.

Okay.

And then we have another 1 times 2 to the 8th power.

And I know we’re supposed to be done on 8

because that’s what we were doing before.

The 256 strength.

So unless I made some mistakes here,

this is probably the number that we can punch up into the calculator

to see what this binary number is.

So I’m going to punch it up.

Huge.

It says that it’s the number 335.

Let’s see if that’s actually right.

I’m going to punch this up in my personal calculator real fast.

I’m going to say 10101111.

And the expression is decimal 335.

Yep.

So that’s it.

We know how to convert from binary to decimal.

And just again, like as a quick shorthand,

it’s probably a good idea if you’re involved in computer science,

to memorize these positions up to maybe

6, 5, 5, 3, 6.

That might sound a little extreme sometimes,

but I don’t know.

Personally, I’m not like the most advanced

binary reader at all times,

but I can remember up to that much.

And what do I mean when I’m saying that?

I’m saying, you know, start with a 1, 2, 4, 8,

8, 2, 56, 5, 12, 1, 2, 4, 2, 0, 4, 8, 4, 0, 9, 6, 8, 1, 9, 2, 1, 6, 3, 8, 4.

Took me a while to remember that one.

3, 2, 7, 6, 8, 6, 5, 5, 3, 6.

So if you think about it, how many bits is this?

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16.

Right here, 16.

That’ll give you two bytes worth of memorization or a word on many systems.

on many systems. For me personally, I just, I like to go up to 6, 5, 5, 3, 5 because

remember I was saying, you know, what is the highest number that you can go up to

with a certain number of bits? It’s always the power or the strength of the highest bit

multiplied by two and then subtract one. So when I remember 6, 5, 5, 3, 6, that tells me that if I

65535. This is very, very useful if you’re going to be working with binary numbers a lot,

or if you’re taking exams or whatever it is that you’re doing, I would recommend everyone do this.

Okay. What do you say? What do you say we do another binary number, but we’ll just do something

a little bit smaller to make it easy. Okay. So by the way, when you start to memorize these positions,

start to eyeball it, which is really, really fast and a good idea. Like I can see those two

numbers right there. I know the first one is a one and the second one is a two. So that means the

one and the one are just going to be a value of three. Then I just quickly go, all right, one,

two, four, eight, one, two, four, eight, 16. So it’s going to be 16 plus three. So it’s going to

be 19. I guarantee it. Let’s, let’s double check this real fast. We’ll say one times two to the

and then we’ll say 1 times 2 to the first power

and then we’ll say 0 times 2 to the second power

and then we’ll say 0 times 2 to the third power

and then we’ll say 1 times 2 to the fourth power

and if I didn’t go too fast and make a bunch of typos

it should be the number 19

So there is a lot of benefit in memorizing the strength of these different positions.

I personally never remember very much beyond 256 when I’m actually trying to work out a number

conversion, but when I’m just thinking of how to compute things, it’s faster if I can go up to

65536. Okay, I hope you enjoyed this video. I hope you learned a little bit of stuff. I hope

you had a little bit of fun. I’ll see you in the next one.

Hey everybody! Thanks for watching this video again from the bottom of my heart.

I really appreciate it. I do hope you did learn something and have some fun.

If you could do me a please, a small little favor, could you please subscribe

and follow this channel or these videos or whatever it is you do on the current

social media website that you’re looking at right now. It would really mean the

world to me and it’ll help make more videos and grow this community so we’ll

be able to do more videos, longer videos, better videos or just I’ll be able to

just I’ll be able to keep making videos in general so please do do me a kindness and uh and subscribe

you know sometimes I’m sleeping in the middle of the night and I just wake up because I know

somebody subscribed or followed it just wakes me up and I get filled with joy that’s exactly what

happens every single time so you could do it as a nice favor to me or you could you could troll me

if you want to just wake me up in the middle of the night just subscribe and then I’ll I’ll just

wake up I promise that’s what will happen also uh if you look at the middle of the screen right now

screen right now you should see a QR code which you can scan in order to go to the website which

I think is also named somewhere at the bottom of this video and it’ll take you to my main website

where you can just kind of like see all the videos I published and the services and tutorials and

things that I offer and all that good stuff and if you have a suggestion for clarifications or

errata or just future videos that you want to see please leave a comment or if you just want to say

what’s going on? You know, just send me a comment, whatever. I also wake up for those in the middle

of the night. I get, I wake up in a cold sweat and I’m like, it would really, it really mean the

world to me. I would really appreciate it. So again, thank you so much for watching this video

and enjoy the cool music as, as I fade into the darkness, which is coming for us all.

Thank you.

The post Binary to Decimal Made Easy: Fun Crash Course for Beginners appeared first on NeuralLantern.com.

Hey there! Let’s dive into converting decimal to binary—super simple once you get it! I walk you through 55432 and 632, step-by-step, with a few calculator oopsies (I’m not a math whiz either). Learn the divide-by-2 trick, why remainders matter, and how to double-check your work. Plus, a pro tip: don’t just memorize—practice tons! Hit subscribe if you liked it, and let’s keep learning together!

Introduction to Decimal and Binary 00:00:00
Explaining Base 10 and Base 2 00:00:11
Conversion Method Overview 00:01:35
Starting Conversion Example (55432) 00:02:20
Step-by-Step Division Process 00:02:35
Using Modulo Operator 00:02:57
Continuing Division Steps 00:04:04
Reaching Remainder Patterns 00:05:53
Finishing Conversion and Reversing 00:09:17
Double-Checking Binary Result 00:11:51
Second Example Introduction (632) 00:12:52
Conversion Process for 632 00:13:04
Correcting Mistakes in Calculation 00:14:22
Completing 632 Conversion 00:15:56
Learning Tips and Verification 00:16:04
Outro and Subscription Request 00:16:40
Additional Engagement Options 00:17:41

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social

Please help support us!

• Subscribing + Sharing on Social Media
• Leaving a comment or suggestion
• Subscribing to our Blog
• Watching the main “pinned” video of this channel for offers and extras

Hello there.

Let’s talk about converting decimal to binary.

So decimal and binary, if you don’t already know, they’re number representations with

different bases.

So if we have like a decimal, it’s base 10, which means we have the character 0, 1, 2,

to represent a number. We could represent the same exact number in binary as long as you’re

not using like a fraction or anything in binary which is a base 2 because in binary you only have

a 0 and a 1. By the way we can use fractions in binary it’s just that when you start using

fractions then sometimes the numbers don’t translate precisely in every single case.

They often do but not always so. If you’re not using a fraction and you want to convert a number

to binary or binary to decimal it should work you should be able to represent the number exactly

okay so base 10 means we have 10 digits that we can use base 2 means uh two digits or two

sorry two characters or 10 characters and um how do we convert a number okay so the first thing

i’d like to do is let’s see five five four three two is what i wanted to do let’s take a number

And we’ll convert this number into binary.

So the first thing that we do is we try to understand that every single time we have

a temporary number as we’re converting from decimal to binary, we’ll just keep dividing

it by two forever and take the remainder at each step.

The remainder is going to be either zero or one because we divided by two.

When we eventually have nothing left, then we’re done.

and all of the remainders are going to be the binary number so let’s try it I’m

gonna pull up a calculator because I’m not like super sharp at math all the

time I just want to do this quickly remove from favorites was already in

there oh it’s right there the symbol doesn’t make sense the calculate people

have a different symbol and I I’m doing something wrong it’s not showing the

right symbol here I need to fix that okay so 554 32 so the first thing we do

So the first thing we do is we divide it by 2, so I’m going to say 55432, just write down all the steps, it’s a really, really good idea.

55432 divided by 2 is what? It’s something, remainder something.

So the remainder is either going to be 0 or 1, so I’m just going to punch that into the calculator real fast, divided by 2, that’s going to be 27716.

Well, we started with an even number so I can just infer that the remainder is going to be zero.

But if you’re not sure, you can use the modulo operator.

So here when we use the division operator, it’ll tell us what the quotient is.

What’s the actual, you know, what is that number divided by the other number?

But if we use the modulo operator, it’ll just give us the remainder.

Not all calculators do this. Keep that in mind.

7 7 1 6 which was the the result and just multiply it by 2 again if you have the same exact number as you started with

Then you know the remainder is 0 otherwise

You can subtract the original number 5 5 4 3 2 from

The number that you multiplied back up and then that should give you the real remainder. Hopefully your calculator does modulo though

For those of you who are ambitious you can probably just open up a Python terminal and

way because programming languages all have the modular operator and python is pretty easy to get

into all right so we’ve done that we now know that there is a zero somewhere in our binary result

but because we have this result that is pretty big we’re not done we have to continue dividing

so i’m just going to take that number copy paste it to the next line and divide it again

and just repeat the process i’m going to say something divided by two it’s one three eight

check myself here 13858 the original number was even the six was even so I know there’s not going

to be a remainder pretty much you know if it’s even zero remainder if it’s odd one remainder

that’s pretty easy I don’t need to worry about the modulo operator and then I’m going to do it

again copy paste 13858 down to the next line divided by two equals what

2929 so 6929 remainder what?

858 at the end there was even so I’m going to say it’s remainder zero that’s like a lot of zero remainders for me personally

I like to space

My notepad results here out so that everything is lined up notice how the R is kind of like askew

So I’m just going to hit a space there to make sure everything is lined up

And then I’m going to do it again

6929 divided by 2 maybe I’ll hit a space before that

that division symbol to make sure everything is okay.

6929 is going to be, oops, I’m on the wrong.

Did I accidentally close that?

Oh my gosh.

I cannot stop myself.

What?

It’s saying that it was already open somewhere.

Did I just miss that?

No, okay.

Whatever.

Okay.

So 6929 divided by two,

divided by two it’s going to be oh I forgot yeah this calculator is not going

to like around for me so that’s that makes it even easier if the result is

0.5 then the remainder is definitely one otherwise the remainder is zero so it’s

going to be three four six four remainder one three four six four

remainder one space it out real fast three four six four remainder one okay

and then copy three four six four forget about the one we’re not copying that

copying the actual quotient result. So 3464 divided by 2, 1732, 32, remainder 0 because

it was even in the first place, 1732. Oh, there it is. I keep forgetting. Maybe I should

pin this to the top so I don’t lose it. 1732 divided by 2, it’s going to be 866. Whoops,

3 2 divided by 2 equals 8 66 remainder 0 because it was even do my spacing i did my spacing

then we’ll divide again 866 divided by 2 i don’t know maybe my spacing is kind of dumb maybe i

should have spaced the numbers and not spaced the operator that’s probably better okay so 866 divided

433, 433, and it was even, so the remainder is zero.

And then, 433, okay, so 433 divided by two.

I’m getting tired of this.

I don’t know if you can tell.

216, so 433 divided by two is going to be equal to 216,

and then remainder one.

Space that out.

Oh, I messed that up again, okay.

And then space those out, and then everything is good.

those out and then everything is good okay so then 216 divided by two and of

course I’m just doing this again and again and again I hope this is not too

boring but I hope you’re following along another good tip that I like to give

people when they’re learning new things is do not make the mistake of

accidentally memorizing a handful of examples try to find as many examples as

you possibly can and every time you practice use a different example that

way you will actually learn how to do the thing instead of accidentally

accidentally memorizing an example. Okay, so 108 divided by two. Maybe I’ll do this again,

but with a smaller number just to make things faster. It’s going to be 54,

remainder zero, and then 54 divided by two. I guess I can just do this in my head. I don’t

really trust myself, so I’m going to do it over here. Okay, 24 remainder zero, because it was

even and then we’ll do 27 over here that’s definitely going to be a remainder one so that’s

going to be like probably 13 remainder one i don’t trust myself i’m gonna do it for real

27 divided by 2 13 remainder 1 and then put the 13 there 13 divided by 2 is

um 6 remainder 1 oh no i’m losing it okay 6 remainder 1

for double checking. I am honestly not like an internal mind math whiz. And then we do

six divided by two, that’s just going to be three remainder zero. And then we’ll do

three divided by two is going to be, you know, one because only one of the twos can fit there.

And then one remainder one. And then we have one left over. So we’ll say one divided by two,

we can’t actually fit, you know, any twos into the one. So it’s going to be zero.

so it’s going to be zero remainder one and now at this point remember we’re just carrying over

the quotient result we’re not carrying over the remainder so if I carry this over here

zero divided by two the number is always going to just be zero remainder zero no matter how many

times now no matter how many times we carry this down so we know we’re done when this number that

we’re dividing is a zero we’re just totally finished so now I’m just going to omit that

Well, maybe I’ll leave one up there just to kind of prove a point.

Think about this, if this is actually going to be zeros forever, which side of the number

string would the zeros go on so that no matter how many zeros you computed, the actual result

wouldn’t change?

For example, if I had this original decimal number and I decided to say, all right, I’m

going to add some zeros to it without changing the result.

then it definitely changes what number that is, right?

The value is now multiplied by a thousand.

But if I put the zeros on the left,

then the number doesn’t actually change.

These are junk zeros.

They don’t mean anything or they mean nothing.

So that means wherever the endless zeros are

is actually the left side of the binary string

that you’re trying to make.

Think about it.

You know, we’re not going to put a bunch of zeros

on the right side of a binary string

we’d be increasing the size dramatically just based on our whims of how many times we tried

to divide a zero.

Instead if we stick the numbers on the left side, then the result doesn’t change so it’s

totally fine.

Which means if you kind of tilt your head to the left, that’s the number, not to the

right.

So that means you know probably intuitively you might have been thinking oh the first

number, the first remainder we got that was going to be the first digit and then we work

our way to the right.

we work our way to the right no no no actually it’s backwards we have to reverse it so i’m going

to go ahead and um you know you can you can if you want to you know you can start at the bottom

and work your way up and then just write the binary string correctly sometimes i’d like to

start from the top and then reverse the string later just as a little brain exercise so i’ll go

one two three starting from the top one one two three one one two three one one zero one one

And then I’ll reverse it.

I’ll say 1101100010001000.

And because I just did it this way, this provides a nice opportunity to double check your work

because it’s really easy to get things like this wrong.

I get things wrong all the time.

And so if you can figure out a way to double check your work in two or three different ways,

you reduce the chances of being wrong.

It takes a little more time, but it’s a really good idea when you’re actually doing work

or like you’re taking an exam or whatever.

an exam or whatever check your work in multiple different ways so now that I’ve done it in

the first way I’m going to do it from the bottom up just to see if I was right so I’m

going to go one one zero one one zero zero zero one zero zero zero one zero zero zero

does it match it seems to match so I’m pretty confident that this is the correct number let’s

just punch it in real fast I’m going to punch it in on my personal calculator here real

I’m just going to copy this to my outside calculator just to prove to myself that it works.

55432.

Okay, so this is indeed the correct answer.

We now understand how to convert from decimal to binary.

It’s not too bad, right?

Let’s do another number just for fun, just something really small.

Let’s go 632.

Okay, whoops, nope, nope, nope.

Let’s do another tab.

We’ll say decimal 632 so that this is faster.

We start with 632.

We divide it by 2.

632 we divide it by 2 the result is going to be oh can I guess this 350 and then like a 15 and then

a one one I don’t know if that’s going to be right remainder zero let me see if I can punch this up

632 divided by zero I oh I blew it oh I was thinking of okay this is why I use a calculator

316 divided by 2 is going to be, I thought I was so cool too, like, oh, everyone watching

is going to be so impressed that I did this in my mind.

Nope.

So we do 316 divided by 2, it’s going to be 158 remainder 0.

So 158 divided by 2, that’s going to be, okay, that’s 75 plus 4, I guarantee it.

So I’m going to do 79, 79 remainder 0.

Let me see if I’m right.

Oh gosh, this is going to be embarrassing if I get it wrong.

79, okay.

So then, now we’re gonna do 79 divided by two.

Whoops, I spaced poorly.

79 divided by two is basically gonna be 39 remainder one.

We know it’s remainder one,

cause you know, 79 is odd.

If it was 80 divided by two, it would’ve been 40.

So let’s just double check real fast

to make sure that we’re getting it right.

It’s easy to get things wrong

if you’re not double checking yourself.

39, okay, so then we’ll do 39 divided by two.

divided by 2

well that’s just going to be 20 remainder 1

am I right about that? I don’t know

let’s see

39 divided by 2

oh I blew it

what was I thinking?

of course it’s going to be at least 40 if it’s 20

totally blew it

so 19 divided by 2

ok so I’m looking for a lower number not a higher number

so 18 so that’s 9

let me see 9 remainder 1

am I right?

Am I right? By the way all these shenanigans that I’m doing right now are exactly how I’m gonna end up with the wrong result

And have to do this whole thing all over again from scratch, but hey at least it will be more brain exercise

Okay, so 9 divided by 2

I’m gonna say 4 remainder 1 because it’s odd

We’ll do 9 divided by 2 just to double check and then we’ll say 4 divided by 2 is

think I need to double check it although I probably should anyway 2 divided by 2 is going to be 1

remainder 0 okay we have a 1 so we actually have to do this one more step 1 divided by 2 equals

1 remainder 0 oh sorry sorry sorry sorry 0 remainder 0 otherwise that would have been

infinity 1s for no reason at all so 0 remainder 0 sorry remainder 1

Then finally, we’re down to 0 divided by 2 equals just 0, remainder 0.

And then we’re finished.

Okay.

Let me do it the first way where I go from top to bottom, then reverse it.

1, 2, 3, 1, 2, 3, 4, 1, 2, 1, 1, 2, 3, 4.

Then I’ll try to reverse that.

1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 4, 1, 2, 3.

Okay.

Then I’ll do it from the bottom up.

1, 2, 3, 4, 1, 0, 0, 1, 2, 3, 4, 1, 2, 3.

two, three, do these two match?

Yes, they do.

Okay, I think we’ve successfully done this.

We’re now semi-experts at converting decimal to binary.

Thank you for watching.

I hope you enjoyed this video.

I hope you learned a little bit of stuff and had a little bit of fun.

I’ll see you in the next video.

Hey, everybody.

Thanks for watching this video again from the bottom of my heart.

I really appreciate it.

I do hope you did learn something and have some fun.

If you could do me a please a small little favor

Could you please subscribe and follow this channel or these videos or whatever it is you do on the current social media?

It’s a website that you’re looking at right now

It would really mean the world to me and it’ll help make more videos and grow this community

So we’ll be able to do more videos longer videos better videos or just I’ll be able to keep making videos in general

So please do do me a kindness and and subscribe

in the middle of the night and I just wake up because I know somebody

subscribed or followed it just wakes me up and I get filled with joy that’s

exactly what happens every single time so you could do it as a nice favor to me

or you could you control me if you want to just wake me up in the middle of

night just subscribe and then I’ll just wake up I promise that’s what will

happen also if you look at the middle of the screen right now you should see a

QR code which you can scan in order to go to the website which I think is also

named somewhere at the bottom of this video and it’ll take you to my main

take you to my main website where you can just kind of like see all the videos I published and

the services and tutorials and things that I offer and all that good stuff and

if you have a suggestion for clarifications or errata or just future videos that you want to

see please leave a comment or if you just want to say hey what’s up what’s going on you know

just send me a comment whatever I also wake up for those in the middle of the night I get

it would really it really mean the world to me I would really appreciate it so

again thank you so much for watching this video and enjoy the cool music as

as I fade into the darkness which is coming for us all

Thank you.

The post Decimal to Binary Made Easy (Even I Can Do It!) appeared first on NeuralLantern.com.

Hello there! Ever wondered what number bases are all about? In this video, we?re diving into decimal (base 10 – the one you already know), binary (base 2 – just 1s and 0s, how your computer thinks), and hexadecimal (base 16 – the compact cool kid). I?ll show you how the same number looks totally different across these systems – binary gets LONG, hex keeps it short and sweet. Plus, why do we even use hex? Spoiler: it?s a game-changer for reading computer memory. Stick around to learn handy prefixes like 0x and 0b to avoid mix-ups. Want to be as cool as those binary-converting pros? Hit subscribe, scan the QR code for more, and let?s geek out together in the next video – conversions are coming up! Drop a comment with your thoughts or just say hi – it might wake me up in the middle of the night with joy!

Please help support us!

• Subscribing + Sharing on Social Media
• Leaving a comment or suggestion
• Subscribing to our Blog
• Watching the main “pinned” video of this channel for offers and extras

Hello there. Let’s talk about number bases. So what are number bases? You’ve probably at some

point heard someone say, hey, I can convert between decimal and binary or between decimal

and hexadecimal or hexadecimal and binary. And you thought that that person was way cooler than you

were. Well, they are way cooler than you. But if you watch my videos, maybe you can be just as cool

Anyway, so what do we mean by number basis exactly?

We’ll start with decimal,

which is the number system that everybody already understands, I hope.

So in decimal, you have 10 characters, right?

So we’ll say like 0, 1, 2, 3, 4, 5, 6, 7, 8, 9.

It’s like 9, or sorry, 10 possible characters.

So decimal is actually base 10.

I’m going to write base 10 here.

Decimal is base 10.

base 10 because it has 10 available characters. The next thing is binary. You’ve probably heard

of that before. Even a lot of non-computer scientists understand binary at least a little

bit because it’s just ones and zeros, right? This is how your computer represents information.

All characters, all numbers, all floats, all everything. They really just come down to zeros

and ones inside of the computer. And it’s not like there’s an actual zero or an actual one anywhere.

It’s more like there’s a certain voltage that represents a one or there’s a different voltage

represents a 1 or there’s a different voltage that represents a 0.

You can think of it as just like voltage or no voltage, but that’s not always the case.

But you know, long story short, it’s just 1s and 0s.

So in binary, we can just represent a 0 or we can represent a 1 and that’s it.

Because there’s only two characters that we can use to represent numbers, we call this

base 2.

So that’s binary.

Now not a lot of people have heard of hexadecimal outside of computer science, but hexadecimal

outside of computer science but hexadecimal is a number is another

number system that we can use which uses base 16 the reason we use hexadecimal is

it because it kind of it kind of compacts a number I’ll show you in a

second how it can represent the same number but with less characters you can

imagine in binary if we have base 2 there’s only two characters that means

the same number in decimal versus binary it’s probably going to be a lot longer

imagine that, right?

Because it’s not like the actual numbers change

that we’re trying to represent.

It’s just that the representation changes.

So hex or hexadecimal,

we have 16 different characters.

Did I say 15 a moment ago?

Sorry if I did.

So we start with the normal ones that base 10 has,

decimal has.

So we go three, four, five, six, seven, eight, nine.

So that’s 10.

the extra five, we do A, B, C, D, E, F. Sorry, extra six. I knew I was going to say five at some

point. So in hexadecimal, we have the characters zero, one, two, three, four, five, six, seven,

eight, nine, and then A, B, C, D, E, F. For a total of 16 characters, or one digit can represent

here. So this is the basics of the differences between the number systems. Let me show you a

quick example. Let me see if I got my calculator here. Hopefully it’ll work. Okay. I’m going to do,

let’s see, variables. So how do you get into this one? Mode. Oh, number base. So I’m going to do,

let’s just pick a random number in decimal. So I’m going to say like, you know, just hit the

So you can see that if I type a number in decimal and show it in decimal, then well,

it’s the exact same size as you probably have suspected.

But if I represent this exact same number in binary, you should probably expect that

the representation is going to be way longer because again, binary only has two characters

to work with.

So it’s harder for it to represent the same information.

So I’m going to change the expression base here to binary.

Oh no, what’s happening?

What’s going on here?

Expression base.

Oh, I did the wrong thing.

Decimal is the expression base.

Binary is the result base.

Okay.

So that same number that we had before, 871, 876, 42,

look at how huge it is in binary.

Takes up a lot of your screen, right?

So we use binary because it’s the closest representation

to what the actual machine has.

So that’s good.

Especially if you want to start manipulating individual bits

manipulating individual bits for one reason or another. It’s good to know how to, it’s good to

understand binary. But hexadecimal is useful, like I said before, to compact the same number. So

again, because the base of the original number is 10, you know, we had the original number in decimal.

If we show a hexadecimal version of it, it should be shorter because there’s 16 characters to work

with. It’s easier for it to represent the same information. So the result base, I’m just going

hexadecimal here and look at how short that number is the original number is one two three four five

six seven eight it’s eight characters long but the hexadecimal number is two four six seven

characters long and that savings in characters will go up and up and up the more you know the

longer the original or the bigger the original number is let me see if I can just add some more

numbers here okay let’s see if we get more savings here one two three four five six seven eight nine

Okay, so the original number is 15 long and here we have 2, 4, 6, 8, 10, 12, 13.

So that’s a savings.

Now think about it this way.

This is a huge savings compared to binary.

Let’s go back to binary real fast.

Same number, which is currently in hex.

As soon as I start showing it in binary, the number explodes.

So there are a lot of numbers, especially if you have a 64-bit number, which you work

if you were to just take you know one of those 64-bit numbers and try to express it in binary

it’s just kind of like it’s really really long and if you want to represent anything even a little

bit bigger like 128-bit numbers or even the contents of memory from you know one memory

location to another binaries just can explode and fly off the screen so this is why I mean this is

one of the biggest reasons why we use hexadecimal because it’s just it’s easier to see what’s inside

of the computer it’s easier than decimal and it’s easier than binary at least once you understand

hexadecimal one other thing that i want to uh show you real fast let me see like let me change

that back to decimal so i don’t screw myself later okay um suppose that you wanted to represent a

number in binary sorry let’s say decimal well you know we’ll say like one two three four right and

well actually let’s not do one two three four let’s say like a thousand and one and then you

want to represent a number in binary and you write one zero zero one and then you want to

represent a number in hexadecimal you could also have one zero zero one right the problem is that

each of these numbers are actually different numbers they only look the same because the

character representation is the same but not the actual number so how do you uh how do you sort of

How do you sort of like differentiate and make sure that the person reading the numbers that you’ve written down knows what base they’re in?

Because if you know if you’re a computer scientist or you’re doing some kind of crazy math, then

well, it might not be obvious and

you want to be careful that the person doesn’t misinterpret your results.

Okay, so let me do that thing again real fast

just to prove to you. What am I doing here? Units? No.

Mode.

Okay, so I’m going to say if I write 1001, I’m going to display it as decimal,

but the input is first going to be decimal.

So in decimal, 1001 is 1001.

Okay, that’s fine.

But if this 1001 was actually a binary number,

I’m going to say that the expression base is binary here.

Notice how the real number is actually 9 if you represented it in decimal.

expression like the original number was you know the characters were hexadecimal then the real

decimal version of 1001 would be 4097 that’s three totally different numbers so you got to be careful

that you know what you’re reading and you got to be careful that you help the person reading what

you’re writing down if you’re trying to transmit this information so with hexadecimal a really

really common prefix that everyone should use is ox ox and then any number after that usually just

reading this is a hexadecimal number so there’s no ambiguity same thing for binary you’ll just say

like ob and then for decimal you just just leave it alone i think there’s a another prefix you can

use but i usually don’t use anything but at least uh ob says this is binary and ox means this is

hexadecimal and then nothing just means okay just default to human reading just decimal

okay this was the basics of number bases in other videos i’m going to talk about how to actually

between these three bases maybe in the future at some other point in some other

video far off in YouTube land I might talk about octal or some other base but

in the immediate future it’s going to be decimal binary and hexadecimal so I

hope you’ve enjoyed this video I’ll see you in the next

hey everybody thanks for watching this video again from the bottom of my heart

I really appreciate it I do hope you did learn something and have some fun if you

a small little favor could you please subscribe and follow this channel or

these videos or whatever it is you do on the current social media website that

you’re looking at right now it would really mean the world to me and it’ll

help make more videos and grow this community so we’ll be able to do more

videos longer videos better videos or just I’ll be able to keep making videos

in general so please do do me a kindness and and subscribe you know sometimes

I’m sleeping in the middle of the night and I just wake up because I know

wake up because I know somebody subscribed or followed. It just wakes me up and I get filled

with joy. That’s exactly what happens every single time. So you could do it as a nice favor to me or

you could you could troll me if you want to just wake me up in the middle of the night just

subscribe and then I’ll just wake up. I promise that’s what will happen. Also if you look at the

middle of the screen right now you should see a QR code which you can scan in order to go to the

website which I think is also named somewhere at the bottom of this video and it’ll take you to my

You can just kind of like see all the videos I published and the services and tutorials and things that I offer and all that good stuff.

And if you have a suggestion for clarifications or errata or just future videos that you want to see, please leave a comment.

Or if you just want to say, hey, what’s up? What’s going on? You know, just send me a comment, whatever.

I also wake up for those in the middle of the night. I wake up in a cold sweat and I’m like,

It would really mean the world to me.

I would really appreciate it.

So again, thank you so much for watching this video.

And enjoy the cool music as I fade into the darkness, which is coming for us all.

Thank you.

The post Master Number Bases: Decimal, Binary, and Hexadecimal Explained! appeared first on NeuralLantern.com.