Create a Flowchart, Pseudocode, and Algorithm for Number System Conversion.

Question

In the proposed process, the system will ask for a decimal number as an input and will convert it to other 3 number systems (binary, octal, and hex). 

Answer 1

1. The Algorithm

The core logic for converting a decimal (base 10) number into binary (base 2), octal (base 8), and hexadecimal (base 16) is identical. The process uses the division-remainder method.

The system must run this algorithm three separate times, once for each target base (B).

1. Input: The system will prompt the user for a positive decimal integer. Call this number N.
2. Process (Main Loop): To convert N to a target base B (where B is 2, 8, or 16), the system must repeat the following steps while N is greater than 0.
3. a. Divide: Calculate the integer division N / B.
4. b. Find Remainder: Calculate the remainder N % B.
5. c. Store Remainder: The remainder is the next digit of the result.
6. d. Update: The quotient from step 2a becomes the new value of N.
7. Result: The loop stops when N becomes 0. The final converted number is the complete list of stored remainders, read in reverse order (from last remainder to first).

Special Case: Hexadecimal

The algorithm requires one modification for hexadecimal (base 16).

1. The remainders can range from 0 to 15.
2. Any remainder from 10 to 15 must be mapped to a character.
3. 10 = A
4. 11 = B
5. 12 = C
6. 13 = D
7. 14 = E
8. 15 = F

2. Pseudocode

This pseudocode uses a single, reusable function to perform the conversion. This is efficient. The main program simply calls this function three times.

Code snippet

// This procedure handles the main program flow

PROCEDURE Main

// 1. Get Input

PRINT "Enter a decimal number: "

INPUT decimal_number

// 2. Process

// Call the conversion function for each base

string binary_result = ConvertDecimal(decimal_number, 2)

string octal_result = ConvertDecimal(decimal_number, 8)

string hex_result = ConvertDecimal(decimal_number, 16)

// 3. Output

PRINT "Binary: " + binary_result

PRINT "Octal: " + octal_result

PRINT "Hexadecimal: " + hex_result

END PROCEDURE

// This function converts a decimal number (N) to any base (B)

FUNCTION ConvertDecimal(N, B)

// Handle the zero case, which loops do not catch

IF N = 0 THEN

RETURN "0"

END IF

// A mapping for digits. This handles 0-9 and A-F

string digits = "0123456789ABCDEF"

string result = ""

// This is the main division-remainder loop

WHILE N > 0

// Find the remainder

integer remainder = N % B

// Find the character for that remainder and add it to the

// *front* of the string. This automatically reverses the order.

result = digits[remainder] + result

// Update N to the quotient of the integer division

N = N / B

END WHILE

RETURN result

END FUNCTION

3. Flowchart

This process is best shown as two separate flowcharts: one for the Main procedure and one for the ConvertDecimal function it calls.

Flowchart: Main Procedure

This chart shows the high-level flow of the program.

1. START (Ellipse)
2. Output: "Enter a decimal number:" (Parallelogram)
3. Input: decimal_number (Parallelogram)
4. Process (Subroutine): binary_result = ConvertDecimal(decimal_number, 2) (Rectangle with side-lines)
5. Process (Subroutine): octal_result = ConvertDecimal(decimal_number, 8) (Rectangle with side-lines)
6. Process (Subroutine): hex_result = ConvertDecimal(decimal_number, 16) (Rectangle with side-lines)
7. Output: "Binary: " + binary_result (Parallelogram)
8. Output: "Octal: " + octal_result (Parallelogram)
9. Output: "Hexadecimal: " + hex_result (Parallelogram)
10. END (Ellipse)

Flowchart: ConvertDecimal(N, B) Function

This chart shows the detailed logic of the conversion algorithm itself.

1. START: ConvertDecimal(N, B) (Ellipse)
2. Decision: N = 0? (Diamond)
3. Yes: Process: RETURN "0" (Rectangle) -> END (Ellipse)
4. No:
5. Process: result = "" (Rectangle)
6. Process: digits = "0123456789ABCDEF" (Rectangle)
7. Decision (Loop Start): N > 0? (Diamond)
8. No: Process: RETURN result (Rectangle) -> END (Ellipse)
9. Yes (Loop Body):
10. Process: remainder = N % B (Rectangle)
11. Process: result = digits[remainder] + result (Rectangle)
12. Process: N = N / B (Rectangle)
13. (Flow arrow points back up to the N > 0? decision diamond)