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 the built-in formatter.

  1. Accept a nonnegative integer n.
  2. If n == 0, return "0" immediately.
  3. Collect digits with n % 8 and n /= 8, then reverse — or call Convert.ToString(n, 8).
  4. Print or return the octal string.
MethodIdeaTimeBest for
Remainder + reverseAppend n % 8, divide by 8, reverse digitsO(log n)Interviews, learning place values
Convert.ToString(n, 8)Format n as base 8 in one callO(log n)Production code, short answers

Pseudocode

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

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

    reverse(digits)
    return join(digits)
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-inConvert.ToString(n, 8)
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 Convert.ToString for a one-line production-style answer.

Example 1 — Remainder + Reverse

Collect n % 8 digits LSD-first, reverse them, then return the octal string.

C#
using System;
using System.Text;

class Program
{
    static string DecimalToOctal(int n)
    {
        if (n < 0)
        {
            throw new ArgumentException("Expected a nonnegative integer.");
        }

        if (n == 0)
        {
            return "0";
        }

        StringBuilder digits = new StringBuilder();
        while (n > 0)
        {
            digits.Append(n % 8);
            n /= 8;
        }

        char[] arr = digits.ToString().ToCharArray();
        Array.Reverse(arr);
        return new string(arr);
    }

    static void Main()
    {
        Console.WriteLine(DecimalToOctal(57)); // 71
        Console.WriteLine(DecimalToOctal(0));  // 0
        Console.WriteLine(DecimalToOctal(64)); // 100
    }
}

How It Works

  1. Reject negatives so the learning version stays focused on nonnegative conversion.
  2. Return "0" when n is zero — otherwise the loop would produce an empty string.
  3. While n > 0, append n % 8 (current LSD) and replace n with n / 8.
  4. Reverse the collected characters so the most significant digit comes first.
  5. Return the joined string (for 57: remainders 1, 7 → reverse → "71").
Trace — 57
n = 57 → append 1, n = 7
n = 7  → append 7, n = 0

buffer = "17"
reverse → "71"

Example 2 — Convert.ToString

Guard negatives, then let the framework format the number as base 8.

C#
using System;

class Program
{
    static string DecimalToOctal(int n)
    {
        if (n < 0)
        {
            throw new ArgumentException("Expected a nonnegative integer.");
        }

        return Convert.ToString(n, 8);
    }

    static void Main()
    {
        Console.WriteLine(DecimalToOctal(57)); // 71
        Console.WriteLine(DecimalToOctal(0));  // 0
        Console.WriteLine(DecimalToOctal(8));  // 10

        // Bonus: same idea for binary
        Console.WriteLine(Convert.ToString(57, 2)); // 111001
        // 71₈ ↔ 111 001₂  (7=111, 1=001)
    }
}

How It Works

  1. Reject negatives so the contract matches the remainder method.
  2. Call Convert.ToString(n, 8). The second argument means “format in base 8.”
  3. Zero is handled for you — Convert.ToString(0, 8) returns "0".
  4. Optional check: binary of 57 is 111001; grouped as 111 001 it recovers octal digits 7 and 1.

Use the remainder loop in interviews when you must show the math. Prefer Convert.ToString(n, 8) in real projects for clarity.

Edge Cases & Pitfalls

Check these before calling the solution done.

Zero

Special-case 0

A plain while n > 0 loop prints nothing — return "0".

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)
Convert.ToString(n, 8)O(log n)O(log n)

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 (or recurse): first remainder is the rightmost digit.
  • Two options: manual remainder loop, or Convert.ToString(n, 8).
  • Test set: 57 → 71; 64 → 100; 0 → 0.

One line: collect n % 8 remainders and reverse them — or call Convert.ToString(n, 8).

Frequently Asked Questions

Repeatedly take n % 8 (the next digit) and n /= 8 until n becomes 0, then reverse the digits. Or call Convert.ToString(n, 8).
The first remainder is the least significant digit. Reversing prints the usual left-to-right octal form.
A while n > 0 loop never runs, so return "0" before the loop (or use Convert.ToString, which already returns "0").
It returns the octal digit string for a nonnegative integer. For example, Convert.ToString(57, 8) returns "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