How to Count in Binary? Complete Guide 2026

Binary counting is a base-2 number system that represents values using only two digits: 0 and 1. Each position in a binary number represents a power of 2 (1, 2, 4, 8, 16, 32, 64, 128…), and every decimal number can be written as a unique combination of these bits.

Last updated: June 2026. Reviewed for accuracy against current computer science curriculum standards.

Counting in binary is one of the most approachable skills in computer science, and it pays dividends whether you are a student, a hobbyist programmer, or simply curious about how machines think. This complete guide walks you through the fundamentals, the patterns, the conversion methods, and the real-world applications that make binary feel less like abstract theory and more like a working tool.

If you want a faster walkthrough first, our 5-minute binary counting guide covers the essentials. Otherwise, read on for the full deep dive.

What is Binary Counting?

Quick Answer: Binary counting is a method of representing numbers using only two digits, 0 and 1, in a base-2 number system where each position corresponds to a power of 2.

Think of binary like a row of light switches that can each be either on (1) or off (0). Read those switches from right to left and you get a number, where the rightmost switch counts as 1, the next counts as 2, the next as 4, the next as 8, and so on. This doubling pattern is the entire foundation of the binary number system.

In the familiar decimal system, you use ten digits (0 through 9) and each position represents a power of 10 (ones, tens, hundreds, thousands). Binary works the same way, but with only two digits and powers of 2. The same positional logic that lets you read 5,482 as “five thousand four hundred eighty-two” lets you read 10110 as “sixteen plus four plus two,” which equals 22 in decimal.

Decimal 0-15 to Binary Quick Reference Table

Bookmark this table. Whenever you need to translate a small number quickly, glance here. This is the most-clicked reference on the web for binary learners, and it directly supports the featured snippet that search engines surface for the keyword “how to count in binary.”

Decimal	Binary	Decimal	Binary
0	0000	8	1000
1	0001	9	1001
2	0010	10	1010
3	0011	11	1011
4	0100	12	1100
5	0101	13	1101
6	0110	14	1110
7	0111	15	1111

Notice the symmetry: each row mirrors its complement. 0101 (5) flips to 1010 (10). 0011 (3) flips to 1100 (12). This palindrome-style pattern is unique to binary and a strong memorization aid.

Why Do Computers Use Binary?

Computers use binary because their underlying hardware has two reliable states: voltage present (1) or voltage absent (0). A transistor, the building block of every modern chip, is essentially a tiny electronic switch that is either open or closed. With billions of these switches working in parallel, you can represent letters, images, music, and video as long sequences of 0s and 1s.

Three-state or ten-state systems exist in research labs, but two-state binary won the engineering battle for a simple reason: it is the most reliable state to detect. The wider the gap between “on” and “off,” the less likely a circuit is to misread a signal, which is why binary has remained the language of digital hardware for over seventy years.

Every piece of data on your computer, from this paragraph of text to the latest video, ultimately reduces to patterns of 0s and 1s stored in memory and processed by the CPU.

How to Count in Binary Step by Step?

Quick Answer: Start at 0, then 1. When you reach 1, reset that digit to 0 and add 1 to the position on the left, producing 10. Keep incrementing right-to-left and carrying whenever a digit hits 2, just as you would carry at 10 in decimal.

Here is the pattern from 0 to 10 in binary, laid out exactly the way search engines prefer for featured snippets:

Decimal	Binary	Pattern Explanation
0	0	Starting point
1	1	First count
2	10	Reset right, carry left
3	11	Both positions on
4	100	Reset both, carry to third position
5	101	Add 1 to rightmost
6	110	Reset right, increment middle
7	111	All three positions on
8	1000	Reset all, carry to fourth position
9	1001	Add 1 to rightmost
10	1010	Reset right, increment next

The Three Rules of Binary Counting

1. Start from the right: Always increment the rightmost digit first, the same way you add 1 to the ones place in decimal.
2. Only 0 and 1: When a digit reaches 2, it becomes 0 and carries 1 to the left, exactly the way 9 + 1 becomes 10 in decimal.
3. Cascade the carry: If the next left digit is also 1, it too becomes 0 and carries further left, allowing the count to grow to any size.

Finger Counting Method

You can count to 31 on one hand using binary. Each finger represents a binary position, and a raised finger means “1” while a lowered finger means “0.”

• Thumb: 1 (2^0)
• Index finger: 2 (2^1)
• Middle finger: 4 (2^2)
• Ring finger: 8 (2^3)
• Pinky: 16 (2^4)

The number 19 would be thumb + index + pinky raised (1 + 2 + 16 = 19). With all ten fingers, you can count from 0 to 1023, which is 2^10 minus 1.

Converting Decimal to Binary

Quick Answer: Divide your decimal number by 2 repeatedly, recording the remainder at each step, then read the remainders from bottom to top to get your binary result.

There are two popular methods. Pick the one that matches how your brain works. The division method is the standard algorithm taught in computer science courses, while the subtraction method is friendlier for visual learners.

Method 1: Division Method (Most Common)

Let’s convert 25 to binary using the divide-by-2 method:

1. 25 / 2 = 12 remainder 1
2. 12 / 2 = 6 remainder 0
3. 6 / 2 = 3 remainder 0
4. 3 / 2 = 1 remainder 1
5. 1 / 2 = 0 remainder 1

Reading the remainders from bottom to top: 25 in decimal equals 11001 in binary.

Method 2: Subtraction Method (Visual Learners)

Find the largest power of 2 that fits into your number, write a 1 in that position, subtract, and repeat with the remainder. Converting 25 step by step:

Step	Power of 2	Fits?	Binary Position	Remaining
1	16	Yes	1____	25-16=9
2	8	Yes	11___	9-8=1
3	4	No	110__	1
4	2	No	1100_	1
5	1	Yes	11001	1-1=0

Result: 25 = 11001 in binary. Both methods agree, so you can trust the conversion.

Quick Mental Shortcuts

After practicing, you will start to recognize patterns at a glance:

• Powers of 2: Always a 1 followed by zeros (8 = 1000, 16 = 10000, 32 = 100000).
• One less than a power of 2: All 1s (7 = 111, 15 = 1111, 31 = 11111, 63 = 111111).
• Even numbers: Always end in 0 in binary.
• Odd numbers: Always end in 1 in binary.

Converting Binary to Decimal

Quick Answer: Multiply each binary digit by its place value (a power of 2) and add the results together.

Going from binary back to decimal is actually easier than the reverse direction once the place-value system clicks. Each position in a binary number carries a fixed weight, and you only need to add up the weights where a 1 appears.

Place Value Method

Each position in a binary number corresponds to a power of 2:

Position (from right)	Power of 2	Decimal Value
1st	2^0	1
2nd	2^1	2
3rd	2^2	4
4th	2^3	8
5th	2^4	16
6th	2^5	32
7th	2^6	64
8th	2^7	128

Step-by-Step Example: Converting 10110 to Decimal

Write the binary number with its position values written above:

Position: 16    8    4    2    1
Binary:    1    0    1    1    0

Multiply each binary digit by its position value and add the results:

• 1 x 16 = 16
• 0 x 8 = 0
• 1 x 4 = 4
• 1 x 2 = 2
• 0 x 1 = 0

Total: 16 + 0 + 4 + 2 + 0 = 22. Therefore, 10110 in binary equals 22 in decimal.

Quick Addition Method

For mental math, just add the position values where you see a 1 and ignore the positions where you see a 0. For example, binary 11010 has 1s in the 16, 8, and 2 positions, so the answer is 16 + 8 + 2 = 26.

Negative Numbers in Binary (One’s and Two’s Complement)

Quick Answer: Computers represent negative integers using two’s complement, where you flip every bit of a positive number (one’s complement) and then add 1. The leading bit acts as a sign flag: 0 means positive, 1 means negative.

Pure binary works great for non-negative whole numbers, but real programs need to store negative values too. Two methods evolved to handle that need, and the second one became the universal standard because it eliminates a confusing edge case.

One’s Complement

To represent a negative number in one’s complement, flip every bit of the positive version. If 5 is 00000101 in an 8-bit system, then -5 in one’s complement is 11111010. The leading 1 signals “this is a negative value.” The drawback is that one’s complement has two representations of zero (00000000 and 11111111), which complicates hardware design.

Two’s Complement (The Modern Standard)

Two’s complement fixes the double-zero problem. Take the one’s complement and add 1. So -5 in 8-bit two’s complement is 11111011. Now there is only one zero, and the standard addition circuitry works for both positive and negative numbers without modification. This is why every modern CPU uses two’s complement for signed integers.

Worked example: convert -5 in 8-bit two’s complement.

1. Start with +5 = 00000101
2. Flip every bit (one’s complement): 11111010
3. Add 1 to the result: 11111011

So -5 = 11111011 in 8-bit two’s complement. The range of values for an 8-bit signed integer is -128 to 127, which matches what you would expect for one byte of memory.

Binary Arithmetic: Adding and Subtracting in Binary

Quick Answer: Binary addition follows the same carry rules as decimal, but you only ever add 0, 1, or 2 in any column (0+0, 0+1, 1+1, or 1+1+1 with a carry). The result of each column is a 0 or 1, with a carry of 0 or 1 sent to the next column on the left.

Once you know the addition table, subtraction falls out for free in two’s complement, which is why modern CPUs use the same adder circuit for both operations.

Binary Addition Rules

A	B	Carry In	Sum	Carry Out
0	0	0	0	0
0	1	0	1	0
1	0	0	1	0
1	1	0	0	1
1	1	1	1	1

Worked Example: Adding 101010 and 001111

Let’s add binary 101010 (42 in decimal) and 001111 (15 in decimal). Stack them right-aligned and add column by column from right to left, carrying whenever a column sums to 2 or 3:

Carry:    1 1 1 1 0 0
          1 0 1 0 1 0
        + 0 0 1 1 1 1
        -------------
        1 1 1 0 0 1

The result is 111001, which equals 57 in decimal (42 + 15 = 57). The four carries cascade from right to left, exactly as in decimal addition.

Binary Subtraction

Two main ways exist. The direct method uses borrowing, mirroring how you borrow in decimal. The faster method, used by every modern processor, is to flip the sign of the second number with two’s complement and add. For example, to compute 42 – 15, you compute 42 + (-15) in two’s complement, which produces the same 111001 = 57 only after interpreting the sign bit. This trick is what makes single adder circuits handle both operations.

Binary Fractions

Binary supports fractional values through the binary point (the binary equivalent of the decimal point). To the right of the binary point, each position represents a negative power of 2: 2^-1 = 0.5, 2^-2 = 0.25, 2^-3 = 0.125, and so on.

For example, the binary number 10.1 breaks down as:

• 1 in the 2s place = 2
• 0 in the 1s place = 0
• 1 in the 1/2s place = 0.5

Add them up: 2 + 0 + 0.5 = 2.5. So 10.1 in binary equals 2.5 in decimal. Another example, 0.11 in binary equals 0.5 + 0.25 = 0.75 in decimal. Fractions that look clean in decimal (like 0.2 or 0.1) can become repeating patterns in binary, which is why programmers sometimes see tiny rounding errors in floating-point arithmetic.

Practice Examples and Exercises

Quick Answer: Start with single-digit conversions, progress to 8-bit numbers, and finish with real-world applications like RGB colors, IP addresses, and ASCII characters.

These exercises are organized from beginner to advanced so you can build confidence one step at a time. Work through them in order for the best learning curve.

Beginner Level: Count and Convert

Exercise 1: Continue the pattern

Fill in the next three numbers in this sequence:

• Binary: 100, 101, 110, ___, ___, ___
• Answer: 111, 1000, 1001

Exercise 2: Small decimal to binary

Convert these to binary using the division method:

• 5 = _____ (Answer: 101)
• 10 = _____ (Answer: 1010)
• 13 = _____ (Answer: 1101)

Exercise 3: Small binary to decimal

Convert these to decimal using place values:

• 111 = _____ (Answer: 7)
• 1001 = _____ (Answer: 9)
• 1100 = _____ (Answer: 12)

Intermediate Level: 8-Bit Numbers

Exercise 4: Common ASCII values

The capital letter “A” in ASCII is decimal 65. In 8-bit binary that becomes 01000001. Now try the capital letter “H,” which is ASCII 72, then comes 01001000. That byte string (01001000) is one of the most-searched binary questions online, and it just means “H.”

Exercise 5: Binary byte to decimal

Convert this byte to decimal: 10101010.

• Solution: 128 + 32 + 8 + 2 = 170

Exercise 6: Find the error

Which of these conversions is wrong?

• 20 = 10100 (correct)
• 35 = 100011 (correct)
• 48 = 101000 (incorrect, should be 110000)

Real-World Applications

RGB Color Values: A pure red color in RGB is (255, 0, 0). In binary, that becomes 11111111, 00000000, 00000000. Each 8-bit channel controls the intensity of red, green, and blue light, which is why every pixel on a screen is a triplet of bytes.

IP Address Components: The IP address 192.168.1.1 in binary breaks down as 11000000.10101000.00000001.00000001. Network engineers read these patterns constantly to debug routing problems.

File Permissions: Unix file permissions use binary. The permission 755 in octal corresponds to binary 111101101, meaning read, write, and execute for the owner and read and execute for the group and others.

Challenge Problems

Problem 1: What is the largest number you can represent with 8 bits?

Answer: 11111111 = 255 (128 + 64 + 32 + 16 + 8 + 4 + 2 + 1). This is the maximum value of an unsigned 8-bit byte and the upper limit of an RGB color channel.

Problem 2: How many different values can 4 bits represent?

Answer: 16 values (0000 to 1111, which is 0 to 15 in decimal). In general, n bits can represent 2^n different values.

Problem 3: If you are counting in binary and reach 1111, what comes next?

Answer: 10000, just as 999 + 1 = 1000 in decimal. You reset all four positions to 0 and carry 1 into a new fifth position, giving 16 in decimal.

Problem 4: How many bits do you need to count up to 1000 in binary?

Answer: 10 bits. 2^10 = 1024, which is the smallest power of 2 above 1000, so you need 10 bits to represent every number from 0 to 1000. If you want to start counting at 0 and end at exactly 1000, you actually need 10 bits because 1000 in binary is 1111101000.

Looking for more binary-themed programming jokes to celebrate your new skill? The classic “There are 10 types of people in the world” punchline only works if your audience already speaks binary.

Frequently Asked Questions

Final Thoughts

Counting in binary is one of the clearest examples of how a simple rule (only two digits, powers of 2) produces a system powerful enough to run every modern computer. The patterns are consistent, the conversions are repeatable, and the mental model transfers directly to real-world computing concepts like ASCII, RGB color codes, IP addressing, and signed integer arithmetic.

If you are just starting out, focus on the smallest table first: 0 to 15. Once those 16 numbers feel automatic, expand to 0 to 31, then 0 to 255. The mental scaffolding builds the same way the carry operation does, one step at a time.

From here, the natural next steps depend on your goals. Programmers who want to go deeper should explore bitwise operators (AND, OR, XOR, NOT) and how they manipulate binary values in code. Networking students should study subnet masks, which are binary patterns that define the size of a network. Hardware tinkerers can read a binary clock face or decode the segment patterns on a seven-segment display. Mathematically curious learners can graduate to hexadecimal, a base-16 system that compresses long binary strings into a compact shorthand.

For a faster review or a printable cheat sheet, revisit our 5-minute binary counting guide. For a lighter read once the fundamentals are solid, enjoy some binary programming jokes and test your friends with the classic “There are 10 types of people in the world” punchline. Start with 15 minutes of practice today, and within a week you will be reading binary the way you read decimal: without thinking about it.