C Decimal to Octal Conversion

Beginner
6 min read
Updated: Oct 2026
2 programs
Live preview
Definition

What Is Decimal to Octal Conversion?

Decimal (base 10) is the everyday number system. Octal (base 8) uses only digits 0–7. Conversion means rewriting a nonnegative integer using powers of eight instead of powers of ten.

Remember
Rightmost octal digit = 8⁰ (value 1)
Next digit             = 8¹ (value 8)
Next digit             = 8² (value 64)
…

Example: 57₁₀
  57 ÷ 8 → rem 1, then 7
  reverse → 71₈
  Check: 7×8 + 1 = 57
DecimalRemainders (LSD first)Octal
80, then 110
571, then 771
640, 0, then 1100
Approach

How to Convert Decimal to Octal in C

Four clear steps — then pick a remainder loop or printf("%o").

  1. Accept a nonnegative integer n.
  2. If n == 0, print 0 immediately.
  3. Collect digits with n % 8 and n /= 8, then reverse — or call printf("%o", n).
  4. Print the octal digits.
MethodIdeaTimeBest for
Remainder + reverseStore n % 8, divide by 8, print reverseO(log n)Interviews, learning place values
printf("%o")Library formats n as base 8O(log n)Short answers, production printing

Pseudocode

Pseudocode
function DecimalToOctal(n):          // n >= 0
    if n == 0:
        print 0
        return

    digits = []
    while n > 0:
        digits.append(n mod 8)       // LSD first
        n = floor(n / 8)

    for i from length(digits) - 1 down to 0:
        print digits[i]
Reference

Cheat Sheet

Keep these facts handy while writing the program.

TopicDetail
Valid digitsOnly 0–7
Next digitn % 8
Shrink nn /= 8
OrderFirst remainder = rightmost digit
Built-inprintf("%o", n)
Binary link1 octal digit = 3 binary bits
Classic check57 → 71
Try it

Live Preview

Enter a nonnegative integer to see remainders and the octal result.

Whole numbers n ≥ 0 (capped at 999999999). Tap a chip or type a value.

Result
Decimal    = 57
Remainders = 1, 7  (LSD → MSD)
Octal      = 71
Check      = 7×8 + 1 = 57
Trace

Worked Walkthrough — n = 57

Divide by 8. Stack remainders from right to left, then reverse for the final string.

Calculation
57 ÷ 8 = 7 remainder 1   ← LSD (rightmost)
 7 ÷ 8 = 0 remainder 7   ← MSD (leftmost)

Remainders collected: 1, 7
Reverse for output:   7, 1
Octal:                71

Verify: 7×8¹ + 1×8⁰ = 56 + 1 = 57 ✓
Code

C Programs

Start with the remainder loop so you can explain every digit. Then use printf("%o") for a short library-style answer.

Example 1 — Remainder + Reverse

Store n % 8 digits LSD-first in an array, then print them from last index to first.

C
#include <stdio.h>

void decimal_to_octal(int n)
{
    int digits[32];
    int count = 0;
    int i;

    if (n < 0)
    {
        printf("Use a nonnegative integer.\n");
        return;
    }
    if (n == 0)
    {
        printf("0\n");
        return;
    }

    while (n > 0)
    {
        digits[count++] = n % 8;
        n /= 8;
    }

    for (i = count - 1; i >= 0; i--)
    {
        printf("%d", digits[i]);
    }
    printf("\n");
}

int main(void)
{
    decimal_to_octal(57); /* 71 */
    decimal_to_octal(0);  /* 0 */
    decimal_to_octal(64); /* 100 */
    return 0;
}

How It Works

  1. Reject negatives so the learning version stays focused on nonnegative conversion.
  2. Print 0 when n is zero — otherwise the loop would produce no output.
  3. While n > 0, store n % 8 (current LSD) and replace n with n / 8.
  4. Print from count - 1 down to 0 so the most significant digit comes first.
  5. For 57: remainders 1, 7 reverse to 71.
Trace — 57
n = 57 → store 1, n = 7
n = 7  → store 7, n = 0

digits = [1, 7]
print reverse → 71

Example 2 — printf %o

Guard negatives, then let the standard library format the number as octal.

C
#include <stdio.h>

void decimal_to_octal(int n)
{
    if (n < 0)
    {
        printf("Use a nonnegative integer.\n");
        return;
    }

    printf("%o\n", (unsigned)n);
}

int main(void)
{
    decimal_to_octal(57); /* 71 */
    decimal_to_octal(0);  /* 0 */
    decimal_to_octal(8);  /* 10 */

    /* Bonus: same idea for binary groups */
    printf("%o in binary groups: 111 001\n", 57u);
    /* 71₈ ↔ 111 001₂  (7=111, 1=001) */
    return 0;
}

How It Works

  1. Reject negatives so the contract matches the remainder method.
  2. %o means “print this unsigned value in base 8.”
  3. Zero is handled for you — printf("%o", 0) prints 0.
  4. Optional check: binary of 57 is 111001; grouped as 111 001 it recovers octal digits 7 and 1.
  5. Use the remainder loop in interviews when you must show the math; prefer %o when you only need to print.

Edge Cases & Pitfalls

Check these before calling the solution done.

Zero

Special-case 0

A plain while (n > 0) loop prints nothing — print 0 first.

Order

Reverse remainders

Printing in collection order reverses the digits (57 would show as 17).

Negatives

Define a policy

This tutorial rejects negatives. Do not silently take an absolute value unless the problem says so.

Wrong base

Use % 8 and / 8

Copy-pasting a binary solution with % 2 produces binary, not octal.

Analysis

Time and Space Complexity

ProgramTimeExtra space
Remainder + reverseO(log n)O(log n)
printf("%o")O(log n)O(1) beyond the print buffer

Digit count is about log8 n for positive n.

Remember

Key Takeaways

  • Core loop: take n % 8, then n /= 8, until n is 0.
  • Reverse: first remainder is the rightmost digit.
  • Two options: manual remainder loop, or printf("%o").
  • Test set: 57 → 71; 64 → 100; 0 → 0.

One line: collect n % 8 remainders and reverse them — or print with %o.

Frequently Asked Questions

Repeatedly take n % 8 (the next digit) and n /= 8 until n becomes 0, then print the digits in reverse. Or use printf("%o", n).
The first remainder is the least significant digit. Printing from last remainder to first gives the usual left-to-right octal form.
A while (n > 0) loop never runs, so print 0 before the loop (or use printf %o, which already prints 0).
The %o conversion specifier prints an unsigned integer in octal. For example, printf("%o", 57) prints 71.
One octal digit equals exactly three binary bits. Octal 7 is binary 111; octal 71 is binary 111001.
The remainder method produces O(log₈ n) digits, which is O(log n). Extra space for the digit buffer is also O(log n).

Next: Disarium Number

Check whether a number equals the sum of its digits raised to their positions.

Disarium number tutorial →

About the author

Mari Selvan M P
Mari Selvan M P 🔗

Developer, cloud engineer, and technical writer

  • Experience 12 years building web and cloud systems
  • Focus Full Stack Development, AWS, and Developer Education

I write practical tutorials so students and working developers can learn by doing—from databases and APIs to deployment on AWS.

AWS Certified Developer – Associate (Credly)

10 people found this page helpful

C Decimal to Binary Conversion C Disarium Number Program