Program for Decimal to Octal Conversion

Last Updated : 05 Aug, 2024

Given a decimal number as input, we need to write a program to convert the given decimal number into an equivalent octal number. i.e convert the number with base value 10 to base value 8. The base value of a number system determines the number of digits used to represent a numeric value. For example, the binary number system uses two digits 0 and 1, the octal number system uses 8 digits from 0-7 and the decimal number system uses 10 digits 0-9 to represent any numeric value.

Examples:

Input : 16
Output: 20

Input : 10
Output: 12

Input : 33
Output: 41

Algorithm:

Store the remainder when the number is divided by 8 in an array.
Divide the number by 8 now
Repeat the above two steps until the number is not equal to 0.
Print the array in reverse order now.

For Example:

If the given decimal number is 16.

Step 1: Remainder when 16 is divided by 8 is 0. Therefore, arr[0] = 0.
Step 2: Divide 16 by 8. New number is 16/8 = 2.
Step 3: Remainder, when 2 is divided by 8, is 2. Therefore, arr[1] = 2.
Step 4: Divide 2 by 8. New number is 2/8 = 0.
Step 5: Since number becomes = 0.

Stop repeating steps and print the array in reverse order. Therefore, the equivalent octal number is 20.

The below diagram shows an example of converting the decimal number 33 to an equivalent octal number.

decToOctal

Below is the implementation of the above idea.

C++

// C++ program to convert a decimal
// number to octal number

#include <iostream>
using namespace std;

// function to convert decimal to octal
void decToOctal(int n)
{

    // array to store octal number
    int octalNum[100];

    // counter for octal number array
    int i = 0;
    while (n != 0) {

        // storing remainder in octal array
        octalNum[i] = n % 8;
        n = n / 8;
        i++;
    }

    // printing octal number array in reverse order
    for (int j = i - 1; j >= 0; j--)
        cout << octalNum[j];
}

// Driver Code
int main()
{
    int n = 33;

    // Function Call
    decToOctal(n);

    return 0;
}

C

// C program to convert decimal
// number to octal number
#include <stdio.h>

// function to convert decimal to octal
void decToOctal(int n)
{

    // array to store octal number
    int octalNum[100];

    // counter for octal number array
    int i = 0;
    while (n != 0) {

        // storing remainder in octal array
        octalNum[i] = n % 8;
        n = n / 8;
        i++;
    }

    // printing octal number array in reverse order
    for (int j = i - 1; j >= 0; j--)
        printf("%d", octalNum[j]);
}

// Driver Code
int main()
{
    int n = 33;

    // Function Call
    decToOctal(n);

    return 0;
}

Java

// Java program to convert a decimal
// number to octal number
import java.io.*;

class GFG {
    // Function to convert decimal to octal
    static void decToOctal(int n)
    {
        // array to store octal number
        int[] octalNum = new int[100];

        // counter for octal number array
        int i = 0;
        while (n != 0) {
            // storing remainder in octal array
            octalNum[i] = n % 8;
            n = n / 8;
            i++;
        }

        // Printing octal number array in reverse order
        for (int j = i - 1; j >= 0; j--)
            System.out.print(octalNum[j]);
    }

    // Driver Code
    public static void main(String[] args)
    {
        int n = 33;

        // Function Call
        decToOctal(n);
    }
}

// Contributed by Pramod Kumar

Python3

# Python3 program to convert
# a decimal number to
# octal number

# function to convert
# decimal to octal


def decToOctal(n):

    # array to store
    # octal number
    octalNum = [0] * 100

    # counter for octal
    # number array
    i = 0
    while (n != 0):

        # storing remainder
        # in octal array
        octalNum[i] = n % 8
        n = int(n / 8)
        i += 1

    # printing octal number
    # array in reverse order
    for j in range(i - 1, -1, -1):
        print(octalNum[j], end="")


# Driver Code
n = 33

# Function Call
decToOctal(n)

# This code is contributed
# by mits

C#

// C# program to convert a decimal
// number to octal number
using System;

class GFG {

    // Function to convert decimal to octal
    static void decToOctal(int n)
    {

        // array to store octal number
        int[] octalNum = new int[100];

        // counter for octal number array
        int i = 0;
        while (n != 0) {

            // storing remainder in octal array
            octalNum[i] = n % 8;
            n = n / 8;
            i++;
        }

        // Printing octal number array in
        // reverse order
        for (int j = i - 1; j >= 0; j--)
            Console.Write(octalNum[j]);
    }

    // Driver Code
    public static void Main()
    {
        int n = 33;

        // Function Call
        decToOctal(n);
    }
}

// This code is contributed by nitin mittal.

JavaScript

<script>

// JavaScript program to convert a decimal
// number to octal number

// function to convert decimal to octal
function decToOctal(n)
{
    
    // array to store octal number
    let octalNum = new Array(100);

    // counter for octal number array
    let i = 0;
    while (n != 0) {

        // storing remainder in octal array
        octalNum[i] = n % 8;
        n = Math.floor(n / 8);
        i++;
    }

    // printing octal number array in reverse order
    for (let j = i - 1; j >= 0; j--)
        document.write(octalNum[j]);
}

// Driver Code
    let n = 33;
    
    // Function Call
    decToOctal(n);


// This code is contributed by Surbhi Tyagi

</script>

PHP

<?php
// PHP program to convert 
// a decimal number to 
// octal number

// function to convert
// decimal to octal
function decToOctal($n)
{
    
    // array to store
    // octal number
    $octalNum;

    // counter for octal
    // number array
    $i = 0;
    while ($n != 0) 
    {

        // storing remainder
        // in octal array
        $octalNum[$i] = $n % 8;
        $n = (int)($n / 8);
        $i++;
    }

    // printing octal number
    // array in reverse order
    for ( $j = $i - 1; $j >= 0; $j--)
        echo $octalNum[$j];
}

// Driver Code
$n = 33;

// Function Call
decToOctal($n);

// This code is contributed 
// by ajit
?>

Output

Time Complexity: O(log N)

Auxiliary Space: O(L) where L is the number of digits in octal number.

Another Approach: (O(1) space Complexity)

This problem can also be solved without using an array using the following algorithm:

Initialize octal num to 0 and countVal to 1 and the decimal number as n
Find the remainder when decimal number divided by 8
Update octal number by octalNum + (remainder * countval)
Increase countval by countval*10
Divide decimal number by 8
Repeat from the second step until the decimal number is zero

Below is the implementation of the above idea:

C++

// C++ program to convert decimal
// number to octal number
#include <iostream>
using namespace std;

// function to calculate the octal value of the given
// decimal number
void decimaltoOctal(int deciNum)
{

    // initializations
    int octalNum = 0, countval = 1;
    int dNo = deciNum;

    while (deciNum != 0) {

        // decimals remainder is calculated
        int remainder = deciNum % 8;

        // storing the octalvalue
        octalNum += remainder * countval;

        // storing exponential value
        countval = countval * 10;
        deciNum /= 8;
    }
    cout << octalNum << endl;
}

// Driver Code
int main()
{
    int n = 33;

    // Function Call
    decimaltoOctal(n);
    return 0;
}

C

// C program to convert decimal
// number to octal number
#include <stdio.h>

// function to calculate the octal value of the given
// decimal number
void decimaltoOctal(int deciNum)
{

    int octalNum = 0, countval = 1;
    int dNo = deciNum;

    while (deciNum != 0) {
        // decimals remainder is calculated
        int remainder = deciNum % 8;

        // storing the octalvalue
        octalNum += remainder * countval;

        // storing exponential value
        countval = countval * 10;
        deciNum /= 8;
    }
    printf("%d", octalNum);
}

// Driver Code
int main()
{
    int n = 33;

    // Function Call
    decimaltoOctal(n);
    return 0;
}

Java

// JAVA program to convert decimal
// number to octal number

import java.io.*;

class GFG {
    // function to calculate the octal value of the given
    // decimal number
    static void octaltodecimal(int deciNum)
    {
        int octalNum = 0, countval = 1;
        int dNo = deciNum;
        while (deciNum != 0) {

            // decimals remainder is calculated
            int remainder = deciNum % 8;

            // storing the octalvalue
            octalNum += remainder * countval;

            // storing exponential value
            countval = countval * 10;
            deciNum /= 8;
        }
        System.out.println(octalNum);
    }

    // Driver Code
    public static void main(String[] args)
    {
        int n = 33;

        // Function Call
        octaltodecimal(n);
    }
}

Python

# Python3 program to convert decimal
# number to octal number

# function to calculate the octal value of the given
# decimal number


def decimaltoOctal(deciNum):

    # initializations
    octalNum = 0
    countval = 1
    dNo = deciNum

    while (deciNum != 0):

        # decimals remainder is calculated
        remainder = deciNum % 8

        # storing the octalvalue
        octalNum += remainder * countval

        # storing exponential value
        countval = countval * 10
        deciNum //= 8

    print(octalNum)


# Driver Code
if __name__ == '__main__':

    n = 33

    # Function Call
    decimaltoOctal(n)

# This code is contributed by pratham76

C#

// C# program to convert decimal
// number to octal number
using System;
class GFG {

    // function to calculate
    // the octal value of the given
    // decimal number
    static void octaltodecimal(int deciNum)
    {
        int octalNum = 0, countval = 1;

        while (deciNum != 0) {
            // decimals remainder is
            // calculated
            int remainder = deciNum % 8;

            // storing the octalvalue
            octalNum += remainder * countval;

            // storing exponential value
            countval = countval * 10;
            deciNum /= 8;
        }
        Console.Write(octalNum);
    }

    // Driver Code
    public static void Main(string[] args)
    {
        int n = 33;

        // Function Call
        octaltodecimal(n);
    }
}

// This code is contributed by rutvik_56

JavaScript

<script>

// Javascript program to convert decimal
// number to octal number

// function to calculate the octal value of the given
// decimal number
function decimaltoOctal(deciNum)
{

    // initializations
    let octalNum = 0, countval = 1;
    let dNo = deciNum;

    while (deciNum != 0) {

        // decimals remainder is calculated
        let remainder = Math.floor(deciNum % 8);

        // storing the octalvalue
        octalNum += remainder * countval;

        // storing exponential value
        countval = countval * 10;
        deciNum = Math.floor(deciNum/8);
    }
    document.write(octalNum + "<br>");
}

// Driver Code
    let n = 33;

    // Function Call
    decimaltoOctal(n);

//This code is contributed by Mayank Tyagi

</script>

Output

Time Complexity: O(log N)

Auxiliary Space: O(1)

Using a predefined function

C++

#include <bits/stdc++.h>
using namespace std;

string intToOctal(int n)
{
    stringstream st;
    st << oct << n;
    return st.str();
}

int main()
{
    int n = 43;
    cout << intToOctal(n);
    return 0;
}

Java

// JAVA program to convert decimal
// number to octal number
import java.io.*;

class GFG {
    public static void decToOct(int n)
    {
        System.out.println(Integer.toOctalString(n));
    }
    public static void main(String[] args)
    {

        int n = 33;
        decToOct(n);
    }
}

Python

# Python program to convert decimal
# number to octal number

def decToOct(n):
    print(oct(n));

if __name__ == '__main__':

    n = 33;
    decToOct(n);
    
# This code is contributed by Amit Katiyar

C#

// C# program to convert decimal
// number to octal number
using System;

public class GFG 
{
    public static void decToOct(int n)
    {
        Console.WriteLine(Convert.ToString(n, 8));
    }
    public static void Main(String[] args)
    {

        int n = 33;
        decToOct(n); 
    }
}

// This code is contributed by 29AjayKumar

JavaScript

<script>

// Javascript program to convert decimal
// number to octal number
function decToOct(n)
{
    document.write(n.toString(8));
}
   
var n = 33;
decToOct(n);

// This code contributed by Princi Singh 

</script>

Output

Time complexity: O(1).

Space complexity: O(1).

Program for Octal to Decimal Conversion

GeeksforGeeks

News

Improve

Similar Reads

n-bit Johnson Counter in Digital Logic

Prerequisite - Counters Johnson counter also known as creeping counter, is an example of synchronous counter. In Johnson counter, the complemented output of last flip flop is connected to input of first flip flop and to implement n-bit Johnson counter we require n flip-flop. It is one of the most i

Ripple Counter in Digital Logic

Counters play a crucial role in digital logic circuits, enabling tasks such as clock frequency division and sequencing. This article explores the concept of ripple counters, a type of asynchronous counter, their operation, advantages, and disadvantages in digital logic design. What is a Counter?Coun

Design counter for given sequence

A Counter is a device which stores (and sometimes displays) the number of times a particular event or process has occurred, often in relationship to a clock signal. Counters are used in digital electronics for counting purpose, they can count specific event happening in the circuit. For example, in

Master-Slave JK Flip Flop

Prerequisite -Flip-flop types and their ConversionRace Around Condition In JK Flip-flop - For J-K flip-flop, if J=K=1, and if clk=1 for a long period of time, then Q output will toggle as long as CLK is high, which makes the output of the flip-flop unstable or uncertain. This problem is called race

Asynchronous Sequential Circuits

An asynchronous sequential circuit does not have the clock signal; the transitions between different states occur due to the ‘change of inputs’. This makes them suitable for applications which involve low power input or when a clock signal may not be needed. In this article, we explain how these cir

Shift Registers in Digital Logic

Pre-Requisite: Flip-Flops Flip flops can be used to store a single bit of binary data (1 or 0). However, in order to store multiple bits of data, we need multiple flip-flops. N flip flops are to be connected in order to store n bits of data. A Register is a device that is used to store such informat

Design 101 sequence detector (Mealy machine)

A sequence detector is a sequential state machine that takes an input string of bits and generates an output 1 whenever the target sequence has been detected. In a Mealy machine, output depends on the present state and the external input (x). Hence, in the diagram, the output is written outside the

Amortized analysis for increment in counter

Amortized analysis refers to determining the time-averaged running time for a sequence (not an individual) operation. It is different from average case analysis because here, we don't assume that the data arranged in average (not very bad) fashion like we do for average case analysis for quick sort.

Number System and Base Conversions

Electronic and Digital systems may use a variety of different number systems, (e.g. Decimal, Hexadecimal, Octal, Binary), or even Duodecimal or less well known but better named Uncial. All the other bases other than Decimal result from computer usage. Uncial (named from Latin for 1/12 "uncia" the ba

Code Converters - BCD(8421) to/from Excess-3

Prerequisite - Number System and base conversions Excess-3 binary code is an unweighted self-complementary BCD code. Self-Complementary property means that the 1's complement of an excess-3 number is the excess-3 code of the 9's complement of the corresponding decimal number. This property is useful

Code Converters - Binary to/from Gray Code

In this article, we will go through Code Converters - Binary to/from Gray Code,we will start our article by defining Code converters, Binary code and Gray code, and then we will go through the conversion of binary code to gray code and vice versa. At last, we will conclude our article with some faqs

Program for Decimal to Binary Conversion

Given a decimal number as input, we need to write a program to convert the given decimal number into an equivalent binary number. Examples of Decimal to Binary: Input : 7Output : 111Input : 10Output : 1010Input: 33Output: 100001Recommended PracticeDecimal to binaryTry It!Brute force ApproachFor Exa

Program for Binary To Decimal Conversion

Given a binary number as input, we need to write a program to convert the given binary number into an equivalent decimal number. Check: Binary to Decimal ConverterExamples : Input : 111Output : 7Input : 1010Output : 10Input: 100001Output: 33Recommended PracticeBinary number to decimal numberTry It!

Program for Decimal to Octal Conversion

Given a decimal number as input, we need to write a program to convert the given decimal number into an equivalent octal number. i.e convert the number with base value 10 to base value 8. The base value of a number system determines the number of digits used to represent a numeric value. For example

Program for Octal to Decimal Conversion

Given an octal number as input, we need to write a program to convert the given octal number into equivalent decimal number. Examples: Input : 67Output: 55Input : 512Output: 330Input : 123Output: 83The idea is to extract the digits of a given octal number starting from the rightmost digit and keep a

Program for Hexadecimal to Decimal

Given a hexadecimal number as input, we need to write a program to convert the given hexadecimal number into an equivalent decimal number. Examples: Input : 67Output: 103Input : 512Output: 1298Input : 123Output: 291We know that hexadecimal number uses 16 symbols {0, 1, 2, 4, 5, 6, 7, 8, 9, A, B, C

Computer Arithmetic | Set - 1

Negative Number Representation Sign Magnitude Sign magnitude is a very simple representation of negative numbers. In sign magnitude the first bit is dedicated to represent the sign and hence it is called sign bit. Sign bit ‘1’ represents negative sign. Sign bit ‘0’ represents positive sign. In sign

Computer Arithmetic | Set - 2

FLOATING POINT ADDITION AND SUBTRACTION FLOATING POINT ADDITION To understand floating point addition, first we see addition of real numbers in decimal as same logic is applied in both cases. For example, we have to add 1.1 * 103 and 50. We cannot add these numbers directly. First, we need to align

Introduction of Floating Point Representation

1. To convert the floating point into decimal, we have 3 elements in a 32-bit floating point representation: i) Sign ii) Exponent iii) Mantissa Sign bit is the first bit of the binary representation. '1' implies negative number and '0' implies positive number. Example: 110000011101000000000000000000

Difference Between 1's Complement Representation and 2's Complement Representation Technique

In computer science, binary number representations like 1's complement and 2's complement are essential for performing arithmetic operations and encoding negative numbers in digital systems. Understanding the differences between these two techniques is crucial for knowing how computers handle signed

Computer Organization | Booth's Algorithm

Booth algorithm gives a procedure for multiplying binary integers in signed 2’s complement representation in efficient way, i.e., less number of additions/subtractions required. It operates on the fact that strings of 0’s in the multiplier require no addition but just shifting and a string of 1’s in

Restoring Division Algorithm For Unsigned Integer

The Restoring Division Algorithm is an integral procedure employed when calculating division on unsigned numbers. It is particularly beneficial in the digital computing application whereby base-two arithmetic is discrete. As a distinct from other algorithms, the Restoring Division Algorithm divides

Non-Restoring Division For Unsigned Integer

The non-restoring division is a division technique for unsigned binary values that simplifies the procedure by eliminating the restoring phase. The non-restoring division is simpler and more effective than restoring division since it just employs addition and subtraction operations instead of restor

Article Tags :

翻译：