Place Values
1, 2, 4, 8…
Each bit position is a power of two, starting at 20 on the right.
Convert Binary to Decimal in PHP
Overview
What You’ll Learn
Binary (base 2) uses only bits 0 and 1; decimal (base 10) is the everyday number system. This tutorial covers place values, a live preview, algorithm steps, worked PHP examples, edge cases, and complexity.
Manual Loop
Sum 2^i
Walk bits right-to-left; add 2^power for every 1 bit.
bindec($s)
Built-in
Parse a binary string as base 2 and get a decimal int in one call.
Validate First
Only 0 / 1
Reject empty strings and any character outside {0, 1}.
Live Preview
Try any bits
Type a binary string and convert it to decimal instantly.
O(k)
Complexity
One pass over k bits; extra space stays O(1) beyond the input.
Introduction
Binary-to-decimal conversion turns a base-2 string into a base-10 integer. Each bit contributes a power of two: the rightmost bit is 20, then 21, 22, and so on.
You can sum those place values by hand, use a Horner loop, or call PHP’s bindec() / intval($bits, 2). Classic example: 101010 → 32 + 8 + 2 = 42.
Why it matters?
It trains place-value thinking, string loops, validation, and the habit of explaining O(k) bit complexity in interviews.
Key Highlights
Powers of Two
Only 1-bits contribute; 0-bits add nothing.
Validate Bits
Anything outside 0/1 is not a binary string.
Two Styles
Manual loop for interviews; bindec($s) for apps.
Watch Overflow
Very long bit strings can exceed PHP integer range — validate length.
In short: for each 1-bit at position i (from the right), add 2i — or just call bindec($bits).
Foundation
📝 Problem & Approach
Given a binary string of 0s and 1s, return its decimal integer value.
php
# Example: "101010"
# 1*32 + 0*16 + 1*8 + 0*4 + 1*2 + 0*1 = 42Inputs & Outputs
| Item | Type | Description |
|---|---|---|
bits | str | Non-empty string containing only characters 0 and 1. |
| Return / print | int | Decimal integer value of that binary number. |
Minimal workflow
Pseudocode
function binary_to_decimal(s):
if s has characters other than 0 and 1:
return error
total = 0
power = 0
for bit from right to left in s:
if bit == '1':
total = total + (2 ^ power)
power = power + 1
return totalMethod comparison
| Method | Idea | Notes |
|---|---|---|
| Digit peel / place value | Peel bits with % 10 and add weights | Best for showing interview math |
bindec($bits) | Built-in base-2 parse | Shortest production style |
Cheat Sheet
⚡ Quick Reference
| Goal | Pattern |
|---|---|
| Validate bits | preg_match('/[^01]/', $bits) must fail |
| Digit peel | $digit = $n % 10; $n = intdiv($n, 10) |
| Add place value | $value += $digit * $weight |
| Built-in convert | bindec($bits) or intval($bits, 2) |
| Horner / doubling | $value = $value * 2 + $bit left-to-right |
| Classic check | "101010" → 42 |
Compare
📋 Place Value vs bindec / intval vs Doubling
Same decimal answer — different clarity and interview signaling.
Place value
sum 2^iShows powers of two clearly; preferred whiteboard style
bindec($s)
built-inIdiomatic PHP for real applications
Doubling
2*total + bitLeft-to-right Horner form; no reverse needed
Interview tip
manual firstExplain place values, then mention bindec($s)
Context
When This Problem Shows Up
Reach for binary-to-decimal drills when base conversion and bit place values matter.
Interview warm-ups
Quick check of loops, powers, and input validation.
Teaching place value
Makes 1, 2, 4, 8… feel concrete with a famous 42 example.
Gateway to other bases
Same idea extends to octal, hex, and custom bases.
Low-level / systems intros
Bits show up constantly in networking and hardware topics.
Not for float binaries alone
Fractional binary (after a point) needs a different place-value story.
Key benefit: one short problem that covers powers of two, string loops, validation, and O(k) reasoning.
Interactive
🔮 Live Preview
Enter a binary string (0 and 1 only) and convert it to decimal.
Hands-On
Examples Gallery
Three complete PHP programs — digit peel, bindec, and the Horner / doubling method. Click View Output to reveal sample console results.
📚 Getting Started
Powers of two from the right — peel digits stored as an int.
Example 1 — Digit Peel from Integer Form
Treat the binary pattern as a decimal-looking int (e.g. 101010), peel digits with % 10, and add place values.
php
<?php
function binaryDigitsToDecimal(int $binaryForm): int
{
$value = 0;
$weight = 1;
$n = $binaryForm;
while ($n > 0) {
$digit = $n % 10;
if ($digit !== 0 && $digit !== 1) return -1;
$value += $digit * $weight;
$n = intdiv($n, 10);
$weight *= 2;
}
return $value;
}
echo "Binary digits: 101010" . PHP_EOL;
echo "Decimal: " . binaryDigitsToDecimal(101010) . PHP_EOL;
?>How It Works
Each loop peels the least-significant decimal digit of $n and treats it as a binary bit. $weight doubles each step (1, 2, 4, …). Invalid digits return -1.
⚡ Idiomatic PHP
Same answer with the built-in parser.
Example 2 — Using bindec()
Validate first, then let PHP parse the base-2 string.
php
<?php
function binaryToDecimalBuiltin(string $bits): int
{
$bits = trim($bits);
if ($bits === '' || preg_match('/[^01]/', $bits)) {
return -1;
}
return (int) bindec($bits);
}
$binaryNumber = "101010";
echo "Binary: " . $binaryNumber . PHP_EOL;
echo "Decimal: " . binaryToDecimalBuiltin($binaryNumber) . PHP_EOL;
?>How It Works
bindec($bits) interprets the string in base 2 (same idea as intval($bits, 2)). Keeping your own validation gives clearer error handling than relying on silent casting.
🔁 Left-to-Right Variant
Horner / doubling form — no reverse needed.
Example 3 — Horner Method on a String
For each bit from the left: $value = $value * 2 + $bit.
php
<?php
function binaryStringToDecimal(string $s): int
{
if ($s === '') return -1;
$value = 0;
for ($i = 0; $i < strlen($s); $i++) {
$ch = $s[$i];
if ($ch !== '0' && $ch !== '1') return -1;
$value = $value * 2 + ($ch === '1' ? 1 : 0);
}
return $value;
}
echo binaryStringToDecimal("1010") . PHP_EOL;
echo binaryStringToDecimal("00101") . PHP_EOL;
?>How It Works
Each step shifts the previous total one bit left (multiply by 2) and adds the next bit. Leading zeros do not change the value — 00101 is still 5.
🧠 How the Algorithm Converts
1
Validate
Reject empty strings and any character that is not 0 or 1.
Guard
2
Walk the bits
Right-to-left with powers, left-to-right with doubling, or call bindec($s).
Scan
3
Accumulate
Add each 1-bit’s contribution into a running total.
Sum
=
Decimal result
Return the total — that is the base-10 value of the binary string.
Trace
🔎 Worked Walkthrough — 101010
Trace the place-value method from the right. Positions: 0 … 5.
| Bit (right→left) | Power | Contribution | total |
|---|---|---|---|
0 | 0 | 0 | 0 |
1 | 1 | 2 | 2 |
0 | 2 | 0 | 2 |
1 | 3 | 8 | 10 |
0 | 4 | 0 | 10 |
1 | 5 | 32 | 42 |
Final decimal: 42 (= 32 + 8 + 2).
Use Cases
Where binary-to-decimal conversion shows up beyond the interview prompt.
1. Interview Warm-Ups
Tests place value, loops, and validation together.
Example: write binary_to_decimal(s).
2. Teaching Powers of Two
Makes 1, 2, 4, 8… memorable with 101010 → 42.
Example: chalkboard bit positions.
3. Config / Flag Strings
Some tools store compact bit masks as binary text.
Example: parse a permission bit string.
4. Gateway to Hex / Octal
Same place-value idea with different bases.
Example: hexdec($s) or intval($s, 16) for hex.
5. Complexity Practice
Argue O(k) from the bit length convincingly.
Example: “how many loop iterations?”
6. Overflow Awareness
PHP integers are platform-sized; very long bit strings can overflow.
Example: discuss fixed-width overflow.
Pro Tip: keep validation in one helper so manual, doubling, and built-in paths share the same rules.
Advantages
Why this pattern works well in interviews and classwork.
1. Math Maps Cleanly
Place values are exactly what the loop computes.
2. Easy Built-in Shortcut
bindec($s)keeps application code short after you know the theory.3. Tiny Extra Memory
A few integers suffice — O(1) extra space beyond the input string.
4. Clear Validation Story
Empty / invalid-character cases give interviewers easy follow-ups.
Pro Tip: say “rightmost bit is 20” before coding — it prevents off-by-one power mistakes.
Usage Tips
Small habits that keep binary conversion interview-ready.
1. Validate Before Converting
Check non-empty and only 0/1 characters first.
2. Lead with Place Values
In interviews, show the manual sum before
bindec($s).3. Strip Whitespace
Call
trim()so accidental spaces do not fail validation.4. Spot-Check 101010
Assert the result is 42 — a fast golden test.
5. Allow Leading Zeros
They are valid padding; do not strip them as invalid.
Pro Tip: dry-run 101010 on paper once — it locks in right-to-left powers faster than guessing.
Common Pitfalls
Mistakes that commonly break binary-to-decimal solutions.
1. Starting Power from the Left
Treating the leftmost bit as 20 reverses place values.
→ Rightmost bit is power 0 for the classic method.
2. Skipping Validation
Digits like 2 or letters produce wrong results or cryptic errors.
→ Reject anything outside {0, 1} early.
3. Treating the String as an Integer
intval("101010")without base 2 reads it as decimal one-hundred-one-thousand…→ Use
bindec($bits)orintval($bits, 2).4. Rejecting Leading Zeros
Padding zeros are valid binary.
→ Allow them; they do not change the value.
5. Ignoring Empty Input
An empty string should error, not convert to 0 silently in every design.
→ Decide the policy and document it.
Edge Cases
Check these inputs before calling the solution done.
Invalid chars
Contains 2 or letters
Reject strings like 1021 or 10a1.
Empty input
No bits provided
Return a clear error instead of converting.
Leading zeros
Allowed
00101 is still valid and equals 5.
Single bit
0 or 1
Smallest non-empty cases — return 0 or 1.
Long strings
May overflow
Huge values can exceed PHP int limits; the JS live preview is also capped for safety.
Whitespace
Strip ends
Trim spaces before validating characters.
Math
⚖️ Facts Worth Knowing
Handy follow-ups interviewers sometimes ask.
- Horner form. The doubling method is the same polynomial evaluation used in base conversion generally.
- Unique representation. Every non-negative integer has a unique binary form without leading zeros (except 0 itself).
- Inverse. Decimal-to-binary uses repeated division by 2 and collecting remainders.
- Other bases.
intval($s, $base)works for bases from 2 to 36; helpers likehexdec/octdecalso exist.
Drill
🎯 Practice Problems
Try these variations to lock in the pattern.
1. Verify classics
- 1010 → 10
- 111 → 7
- 101010 → 42
2. Reject invalid input
- Raise on
1021and empty string - Accept
00101
3. Implement both styles
- Place-value and doubling
- Assert they match
bindec($s)
4. Decimal to binary
- Write the inverse conversion
- Round-trip test with the same helpers
Important
Notes
- Place values. Add powers of two for every 1-bit from the right.
- Always validate that the string contains only 0 and 1.
- In interviews, show the manual method first; mention
bindec($bits)second. - State O(k) time for k bits and O(1) extra space.
Quick Takeaway: sum 2i for each 1-bit (or call bindec($bits)) after validating the string.
Analysis
⏱️ Time and Space Complexity
| Program | Time | Extra space |
|---|---|---|
| Digit peel / place-value loop | O(k) | O(1) |
Built-in bindec($bits) | O(k) | O(1) |
| Horner / doubling method | O(k) | O(1) |
🎉 Conclusion
Binary-to-decimal conversion is a clean place-value exercise: validate the bits, then sum powers of two (or use bindec($s)). Master the manual loop first, then the doubling and built-in shortcuts.
Practice the three examples above, then continue to common divisors for another classic number-theory warm-up.
Always validate 0/1 input, remember the rightmost bit is 20, and state O(k) for k bits.
Pro Tips
💡 Best Practices
✅ Do
- Validate non-empty 0/1 strings
- Explain place values before coding
- Test 101010 → 42 and leading zeros
- Mention
bindec($bits)as a shortcut - State O(k) time for k bits
❌ Don’t
- Call
intval($bits)without base 2 - Start powers from the left by accident
- Accept digits other than 0 and 1
- Reject leading zeros as invalid
- Skip empty-string handling
Summary
Key Takeaways
Knowledge Unlocked
Five things to remember about binary to decimal
Convert base 2 the interview-friendly way.
5
Core concepts 01
Rule
Sum 2^i for 1-bits
Definition 02
Direction
Rightmost is 2^0
Math 03
Validate
Only 0 and 1
Guard 04
Built-in
bindec($s)
Code 05
Complexity
O(k) time
Analysis❓ Frequently Asked Questions
Add powers of 2 where the bit is 1, use the Horner/doubling loop (value = value*2 + bit), or call bindec()/intval($s, 2).
Binary numbers can only contain 0 and 1. Validation prevents wrong answers and runtime errors.
They parse a binary string as base 2 and return its decimal integer value.
O(k), where k is the number of bits. Extra space is O(1) for the loop methods.
Yes. Very long binary strings can exceed PHP integer range depending on platform; validate length for safety.
Yes for string methods. Values like 00101 are valid and equal to 5 in decimal. Digit-peel from an int loses leading zeros.
For place-value / digit-peel, start from the rightmost bit as power 0. The doubling (Horner) method walks left to right instead.
Treat it as invalid. Return an error or a documented sentinel — do not convert silently.
Did you Know? 🔊
101010 in binary equals 42 in decimal because only the 32, 8, and 2 positions are turned on.
Continue to Common Divisors
Learn how to find all positive integers that divide two numbers evenly.
About the author
9 people found this page helpful