# Add two integers of given base

In mathematics and computer science, working with numbers of different bases (radices) is common. Each base represents a different numerical system. Adding two integers of a given base involves performing addition using the rules of that particular base. This task is useful in various computer science applications, such as cryptography, number representation, and encoding.

## Problem Statement and Description

The problem is to add two integers that are given in a specific base and produce the sum in the same base. This involves converting the given numbers to decimal form, performing the addition, and then converting the result back to the original base. The algorithm needs to handle both positive and negative numbers as well as different bases.

## Example

Let's consider an example where we want to add two numbers: `16` and `5`. These numbers are in base `16` (hexadecimal). The algorithm should convert them to decimal, perform the addition (`22 + 5 = 27` in decimal), and then convert the result back to base `16`, which is `1B`.

## Idea to Solve the Problem

To solve this problem, the algorithm performs the following steps:

1. Define a `charValue` function to convert a digit into its character representation in the given base.
2. Define a `convertToDecimal` function to convert a number from the given base to decimal.
3. Define an `additionOfNumber` function to add two numbers in the given base.
4. Inside the `additionOfNumber` function, convert the given numbers to decimal using the `convertToDecimal` function.
5. Add the decimal numbers and store the result.
6. Convert the result back to the given base using the `charValue` function and store it in a string.
7. If the result is negative, prepend a minus sign.
8. Display the original numbers, the base, and the addition result.

## Pseudocode

Here's the pseudocode for the algorithm:

``````function charValue(num):
if num is between 0 and 9:
return character representation of num
else:
return character representation of (num - 10 + 'A')

function convertToDecimal(num, baseValue):
if baseValue is 10:
return num
Convert num to positive if it's negative
Initialize multiplier to 1
Initialize result to 0
While num is not 0:
Add (num % 10) * multiplier to result
Multiply multiplier by baseValue
Divide num by 10
If num was negative, return -result
Else, return result

Convert num1 and num2 to decimal using convertToDecimal
Calculate sum = num1 + num2
If sum is negative, set flag to true and make sum positive
Initialize result string to empty
Convert sum to baseValue and append to result
If flag is true, prepend a minus sign to result
Display original numbers, baseValue, and result

main:
Create an instance of the Addition class

## Algorithm Explanation

1. Define the `charValue` function to convert a digit into its character representation in the given base.
2. Define the `convertToDecimal` function to convert a number from the given base to decimal.
3. Define the `additionOfNumber` function to add two numbers in the given base.
4. In the `additionOfNumber` function, convert the numbers to decimal using `convertToDecimal`.
5. Add the decimal numbers and store the result. Handle the flag for negative numbers.
6. Convert the result back to the given base using `charValue` and store it in a string.
7. If the result is negative, prepend a minus sign.
8. Display the original numbers, base, and addition result.
9. In the `main` program, create an instance of the `Addition` class and call `additionOfNumber` for the provided test cases.

## Program Solution

``````// Include header file
#include <iostream>
using namespace std;
// C++ program
// Add two integers of given base
{
public: char charValue(int num)
{
if (num >= 0 && num <= 9)
{
return (char)(num + '0');
}
else
{
return (char)(num - 10 + 'A');
}
}
// Convert given number into decimal number
int convertToDecimal(int num, int baseValue)
{
if (baseValue == 10)
{
return num;
}
int n = num;
if (n < 0)
{
n = -n;
}
int multiplier = 1;
int result = 0;
while (n != 0)
{
result += (n % 10) *multiplier;
multiplier *= baseValue;
n = n / 10;
}
if (num < 0)
{
return -result;
}
return result;
}
void additionOfNumber(int num1, int num2, int baseValue)
{
// Convert Given numbers into decimal and addition of it value
int sum = this->convertToDecimal(num1, baseValue) +
this->convertToDecimal(num2, baseValue);
bool flag = false;
if (sum < 0)
{
sum = -sum;
flag = true;
}
// This is used to store result
string result = "";
// Transform sum to given base
while (sum > 0)
{
result = (this->charValue(sum % baseValue))  +  result;
sum /= baseValue;
}
if (flag == true)
{
result = "-" + result;
}
// Display given numbers
cout << "\n Given num1 : "
<< num1;
cout << "\n Given num2 : "
<< num2;
cout << "\n Given Base : "
<< baseValue;
// Display result
cout << "\n Addition : " << result << "\n";
}
};
int main()
{
// Test A
// Base : 16
// 16 + 5 = 1B (hexa)
// Note (22 + 5) = 27 (in decimal)
// Test B
// Base : 4
// 42 + 14 = 123 (Base 4)
// Test C
// Base : 8
// 453 + 234 = 707 (Base 8)
// Test C
// Base : 3
// (-45) + (-23) = -222 (Base 3)
return 0;
}``````

#### Output

`````` Given num1 : 16
Given num2 : 5
Given Base : 16

Given num1 : 42
Given num2 : 15
Given Base : 4

Given num1 : 453
Given num2 : 234
Given Base : 8

Given num1 : -45
Given num2 : -23
Given Base : 3
``````// Java program
// Add two integers of given base
{
public char charValue(int num)
{
if (num >= 0 && num <= 9)
{
return (char)(num + '0');
}
else
{
return (char)(num - 10 + 'A');
}
}
// Convert given number into decimal number
public int convertToDecimal(int num, int baseValue)
{
if (baseValue == 10)
{
return num;
}
int n = num;
if (n < 0)
{
n = -n;
}
int multiplier = 1;
int result = 0;
while (n != 0)
{
result += (n % 10) * multiplier;
multiplier *= baseValue;
n = n / 10;
}
if (num < 0)
{
return -result;
}
return result;
}
public void additionOfNumber(int num1, int num2, int baseValue)
{
// Convert Given numbers into decimal and addition of it value
int sum = convertToDecimal(num1, baseValue) +
convertToDecimal(num2, baseValue);
boolean flag = false;
if (sum < 0)
{
sum = -sum;
flag = true;
}
// This is used to store result
String result = "";
// Transform sum to given base
while (sum > 0)
{
result = (charValue(sum % baseValue)) + result;
sum /= baseValue;
}
if (flag == true)
{
result = "-" + result;
}
// Display given numbers
System.out.print("\n Given num1 : " + num1);
System.out.print("\n Given num2 : " + num2);
System.out.print("\n Given Base : " + baseValue);
// Display result
System.out.print("\n Addition : " + result + "\n");
}
public static void main(String[] args)
{
// Test A
// Base : 16
// 16 + 5 = 1B (hexa)
// Note (22 + 5) = 27 (in decimal)
// Test B
// Base : 4
// 42 + 14 = 123 (Base 4)
// Test C
// Base : 8
// 453 + 234 = 707 (Base 8)
// Test C
// Base : 3
// (-45) + (-23) = -222 (Base 3)
}
}``````

#### Output

`````` Given num1 : 16
Given num2 : 5
Given Base : 16

Given num1 : 42
Given num2 : 15
Given Base : 4

Given num1 : 453
Given num2 : 234
Given Base : 8

Given num1 : -45
Given num2 : -23
Given Base : 3
``````// Include namespace system
using System;
// Csharp program
// Add two integers of given base
{
public char charValue(int num)
{
if (num >= 0 && num <= 9)
{
return (char)(num + '0');
}
else
{
return (char)(num - 10 + 'A');
}
}
// Convert given number into decimal number
public int convertToDecimal(int num, int baseValue)
{
if (baseValue == 10)
{
return num;
}
int n = num;
if (n < 0)
{
n = -n;
}
int multiplier = 1;
int result = 0;
while (n != 0)
{
result += (n % 10) * multiplier;
multiplier *= baseValue;
n = n / 10;
}
if (num < 0)
{
return -result;
}
return result;
}
public void additionOfNumber(int num1, int num2, int baseValue)
{
// Convert Given numbers into decimal and addition of it value
int sum = this.convertToDecimal(num1, baseValue) +
this.convertToDecimal(num2, baseValue);
Boolean flag = false;
if (sum < 0)
{
sum = -sum;
flag = true;
}
// This is used to store result
String result = "";
// Transform sum to given base
while (sum > 0)
{
result = (this.charValue(sum % baseValue)) + result;
sum /= baseValue;
}
if (flag == true)
{
result = "-" + result;
}
// Display given numbers
Console.Write("\n Given num1 : " + num1);
Console.Write("\n Given num2 : " + num2);
Console.Write("\n Given Base : " + baseValue);
// Display result
Console.Write("\n Addition : " + result + "\n");
}
public static void Main(String[] args)
{
// Test A
// Base : 16
// 16 + 5 = 1B (hexa)
// Note (22 + 5) = 27 (in decimal)
// Test B
// Base : 4
// 42 + 14 = 123 (Base 4)
// Test C
// Base : 8
// 453 + 234 = 707 (Base 8)
// Test C
// Base : 3
// (-45) + (-23) = -222 (Base 3)
}
}``````

#### Output

`````` Given num1 : 16
Given num2 : 5
Given Base : 16

Given num1 : 42
Given num2 : 15
Given Base : 4

Given num1 : 453
Given num2 : 234
Given Base : 8

Given num1 : -45
Given num2 : -23
Given Base : 3
``````package main
import "fmt"
// Go program
// Add two integers of given base
return me
}
func(this Addition) charValue(num int) byte {
if num >= 0 && num <= 9 {
return (byte)(num + 48)
} else {
return (byte)(num - 10 + 65)
}
}
// Convert given number into decimal number
func(this Addition) convertToDecimal(num, baseValue int) int {
if baseValue == 10 {
return num
}
var n int = num
if n < 0 {
n = -n
}
var multiplier int = 1
var result int = 0
for (n != 0) {
result += (n % 10) * multiplier
multiplier *= baseValue
n = n / 10
}
if num < 0 {
return -result
}
return result
}
// Convert Given numbers into decimal and addition of it value
var sum int = this.convertToDecimal(num1, baseValue) +
this.convertToDecimal(num2, baseValue)
var flag bool = false
if sum < 0 {
sum = -sum
flag = true
}
// This is used to store result
var result string = ""
// Transform sum to given base
for (sum > 0) {
result = string((this.charValue(sum % baseValue))) + result
sum = sum / baseValue
}
if flag == true {
result = "-" + result
}
// Display given numbers
fmt.Print("\n Given num1 : ", num1)
fmt.Print("\n Given num2 : ", num2)
fmt.Print("\n Given Base : ", baseValue)
// Display result
fmt.Print("\n Addition : ", result, "\n")
}
func main() {
// Test A
// Base : 16
// 16 + 5 = 1B (hexa)
// Note (22 + 5) = 27 (in decimal)
// Test B
// Base : 4
// 42 + 14 = 123 (Base 4)
// Test C
// Base : 8
// 453 + 234 = 707 (Base 8)
// Test C
// Base : 3
// (-45) + (-23) = -222 (Base 3)
}``````

#### Output

`````` Given num1 : 16
Given num2 : 5
Given Base : 16

Given num1 : 42
Given num2 : 15
Given Base : 4

Given num1 : 453
Given num2 : 234
Given Base : 8

Given num1 : -45
Given num2 : -23
Given Base : 3
``````<?php
// Php program
// Add two integers of given base
{
public	function charValue(\$num)
{
if (\$num >= 0 && \$num <= 9)
{
return chr(\$num + ord('0'));
}
else
{
return chr(\$num - 10 + ord('A'));
}
}
// Convert given number into decimal number
public	function convertToDecimal(\$num, \$baseValue)
{
if (\$baseValue == 10)
{
return \$num;
}
\$n = \$num;
if (\$n < 0)
{
\$n = -\$n;
}
\$multiplier = 1;
\$result = 0;
while (\$n != 0)
{
\$result += (\$n % 10) * \$multiplier;
\$multiplier *= \$baseValue;
\$n = (int)(\$n / 10);
}
if (\$num < 0)
{
return -\$result;
}
return \$result;
}
{
// Convert Given numbers into decimal and addition of it value
\$sum = \$this->convertToDecimal(\$num1, \$baseValue) +
\$this->convertToDecimal(\$num2, \$baseValue);
\$flag = false;
if (\$sum < 0)
{
\$sum = -\$sum;
\$flag = true;
}
// This is used to store result
\$result = "";
// Transform sum to given base
while (\$sum > 0.00000)
{
\$result = \$this->charValue(\$sum % \$baseValue).\$result;
\$sum = (int)(\$sum / \$baseValue);
}
if (\$flag == true)
{
\$result = "-".\$result;
}
// Display given numbers
echo("\n Given num1 : ".\$num1);
echo("\n Given num2 : ".\$num2);
echo("\n Given Base : ".\$baseValue);
// Display result
"\n");
}
}

function main()
{
// Test A
// Base : 16
// 16 + 5 = 1B (hexa)
// Note (22 + 5) = 27 (in decimal)
// Test B
// Base : 4
// 42 + 14 = 123 (Base 4)
// Test C
// Base : 8
// 453 + 234 = 707 (Base 8)
// Test C
// Base : 3
// (-45) + (-23) = -222 (Base 3)
}
main();``````

#### Output

`````` Given num1 : 16
Given num2 : 5
Given Base : 16

Given num1 : 42
Given num2 : 15
Given Base : 4

Given num1 : 453
Given num2 : 234
Given Base : 8

Given num1 : -45
Given num2 : -23
Given Base : 3
``````// Node JS program
// Add two integers of given base
{
charValue(num)
{
if (num >= 0 && num <= 9)
{
return String.fromCharCode((num + '0'.charCodeAt(0)));
}
else
{
return String.fromCharCode((num - 10 + 'A'.charCodeAt(0)));
}
}
// Convert given number into decimal number
convertToDecimal(num, baseValue)
{
if (baseValue == 10)
{
return num;
}
var n = num;
if (n < 0)
{
n = -n;
}
var multiplier = 1;
var result = 0;
while (n != 0)
{
result += (n % 10) * multiplier;
multiplier *= baseValue;
n = parseInt(n / 10);
}
if (num < 0)
{
return -result;
}
return result;
}
{
// Convert Given numbers into decimal and addition of it value
var sum = this.convertToDecimal(num1, baseValue) +
this.convertToDecimal(num2, baseValue);
var flag = false;
if (sum < 0)
{
sum = -sum;
flag = true;
}
// This is used to store result
var result = "";
// Transform sum to given base
while (sum > 0)
{
result = (this.charValue(sum % baseValue)) + result;
sum = parseInt(sum / baseValue);
}
if (flag == true)
{
result = "-" + result;
}
// Display given numbers
process.stdout.write("\n Given num1 : " + num1);
process.stdout.write("\n Given num2 : " + num2);
process.stdout.write("\n Given Base : " + baseValue);
// Display result
process.stdout.write("\n Addition : " + result + "\n");
}
}

function main()
{
// Test A
// Base : 16
// 16 + 5 = 1B (hexa)
// Note (22 + 5) = 27 (in decimal)
// Test B
// Base : 4
// 42 + 14 = 123 (Base 4)
// Test C
// Base : 8
// 453 + 234 = 707 (Base 8)
// Test C
// Base : 3
// (-45) + (-23) = -222 (Base 3)
}
main();``````

#### Output

`````` Given num1 : 16
Given num2 : 5
Given Base : 16

Given num1 : 42
Given num2 : 15
Given Base : 4

Given num1 : 453
Given num2 : 234
Given Base : 8

Given num1 : -45
Given num2 : -23
Given Base : 3
``````#  Python 3 program
#  Add two integers of given base
def charValue(self, num) :
if (num >= 0 and num <= 9) :
return chr((num + ord('0')))
else :
return chr((num - 10 + ord('A')))

#  Convert given number into decimal number
def convertToDecimal(self, num, baseValue) :
if (baseValue == 10) :
return num

n = num
if (n < 0) :
n = -n

multiplier = 1
result = 0
while (n != 0) :
result += (n % 10) * multiplier
multiplier *= baseValue
n = int(n / 10)

if (num < 0) :
return -result

return result

def additionOfNumber(self, num1, num2, baseValue) :
#  Convert Given numbers into decimal and addition of it value
sum = self.convertToDecimal(
num1, baseValue
) + self.convertToDecimal(
num2, baseValue
)
flag = False
if (sum < 0) :
sum = -sum
flag = True

#  This is used to store result
result = ""
#  Transform sum to given base
while (sum > 0) :
result = str(self.charValue(sum % baseValue)) + result
sum = int(sum / baseValue)

if (flag == True) :
result = "-"+ result

#  Display given numbers
print("\n Given num1 : ", num1, end = "")
print("\n Given num2 : ", num2, end = "")
print("\n Given Base : ", baseValue, end = "")
#  Display result
print("\n Addition : ", result )

def main() :
#  Test A
#  Base : 16
#  16 + 5 = 1B (hexa)
#  Note (22 + 5) = 27 (in decimal)
#  Test B
#  Base : 4
#  42 + 14 = 123 (Base 4)
#  Test C
#  Base : 8
#  453 + 234 = 707 (Base 8)
#  Test C
#  Base : 3
#  (-45) + (-23) = -222 (Base 3)

if __name__ == "__main__": main()``````

#### Output

`````` Given num1 :  16
Given num2 :  5
Given Base :  16

Given num1 :  42
Given num2 :  15
Given Base :  4

Given num1 :  453
Given num2 :  234
Given Base :  8

Given num1 :  -45
Given num2 :  -23
Given Base :  3
``````#  Ruby program
#  Add two integers of given base
def charValue(num)
if (num >= 0 && num <= 9)
return ((num + '0'.ord)).chr
else
return ((num - 10 + 'A'.ord)).chr
end

end

#  Convert given number into decimal number
def convertToDecimal(num, baseValue)
if (baseValue == 10)
return num
end

n = num
if (n < 0)
n = -n
end

multiplier = 1
result = 0
while (n != 0)
result += (n % 10) * multiplier
multiplier *= baseValue
n = n / 10
end

if (num < 0)
return -result
end

return result
end

#  Convert Given numbers into decimal and addition of it value
sum = self.convertToDecimal(num1, baseValue) +
self.convertToDecimal(num2, baseValue)
flag = false
if (sum < 0)
sum = -sum
flag = true
end

#  This is used to store result
result = ""
#  Transform sum to given base
while (sum > 0)
result = (self.charValue(sum % baseValue)).to_s + result
sum = sum / baseValue
end

if (flag == true)
result = "-"+ result
end

#  Display given numbers
print("\n Given num1 : ", num1)
print("\n Given num2 : ", num2)
print("\n Given Base : ", baseValue)
#  Display result
print("\n Addition : ", result ,"\n")
end

end

def main()
#  Test A
#  Base : 16
#  16 + 5 = 1B (hexa)
#  Note (22 + 5) = 27 (in decimal)
#  Test B
#  Base : 4
#  42 + 14 = 123 (Base 4)
#  Test C
#  Base : 8
#  453 + 234 = 707 (Base 8)
#  Test C
#  Base : 3
#  (-45) + (-23) = -222 (Base 3)
end

main()``````

#### Output

`````` Given num1 : 16
Given num2 : 5
Given Base : 16

Given num1 : 42
Given num2 : 15
Given Base : 4

Given num1 : 453
Given num2 : 234
Given Base : 8

Given num1 : -45
Given num2 : -23
Given Base : 3
``````
``````// Scala program
// Add two integers of given base
{
def charValue(num: Int): Char = {
if (num >= 0 && num <= 9)
{
return (num + '0'.toInt).toChar;
}
else
{
return (num - 10 + 'A'.toInt).toChar;
}
}
// Convert given number into decimal number
def convertToDecimal(num: Int, baseValue: Int): Int = {
if (baseValue == 10)
{
return num;
}
var n: Int = num;
if (n < 0)
{
n = -n;
}
var multiplier: Int = 1;
var result: Int = 0;
while (n != 0)
{
result += (n % 10) * multiplier;
multiplier *= baseValue;
n = n / 10;
}
if (num < 0)
{
return -result;
}
return result;
}
def additionOfNumber(num1: Int, num2: Int, baseValue: Int): Unit = {
// Convert Given numbers into decimal and addition of it value
var sum: Int = convertToDecimal(num1, baseValue) +
convertToDecimal(num2, baseValue);
var flag: Boolean = false;
if (sum < 0)
{
sum = -sum;
flag = true;
}
// This is used to store result
var result: String = "";
// Transform sum to given base
while (sum > 0)
{
result = (charValue(sum % baseValue)).toString() + result;
sum = sum / baseValue;
}
if (flag == true)
{
result = "-" + result;
}
// Display given numbers
print("\n Given num1 : " + num1);
print("\n Given num2 : " + num2);
print("\n Given Base : " + baseValue);
// Display result
print("\n Addition : " + result + "\n");
}
}
object Main
{
def main(args: Array[String]): Unit = {
// Test A
// Base : 16
// 16 + 5 = 1B (hexa)
// Note (22 + 5) = 27 (in decimal)
// Test B
// Base : 4
// 42 + 14 = 123 (Base 4)
// Test C
// Base : 8
// 453 + 234 = 707 (Base 8)
// Test C
// Base : 3
// (-45) + (-23) = -222 (Base 3)
}
}``````

#### Output

`````` Given num1 : 16
Given num2 : 5
Given Base : 16

Given num1 : 42
Given num2 : 15
Given Base : 4

Given num1 : 453
Given num2 : 234
Given Base : 8

Given num1 : -45
Given num2 : -23
Given Base : 3
``````// Swift 4 program
// Add two integers of given base
{
func charValue(_ num: Int) -> Character
{
if (num >= 0 && num <= 9)
{
return Character(UnicodeScalar(num + 48)!);
}
else
{
return Character(UnicodeScalar(num - 10 + 65)!);
}
}
// Convert given number into decimal number
func convertToDecimal(_ num: Int, _ baseValue: Int) -> Int
{
if (baseValue == 10)
{
return num;
}
var n: Int = num;
if (n < 0)
{
n = -n;
}
var multiplier: Int = 1;
var result: Int = 0;
while (n  != 0)
{
result += (n % 10) * multiplier;
multiplier *= baseValue;
n = n / 10;
}
if (num < 0)
{
return -result;
}
return result;
}
func additionOfNumber(_ num1: Int, _ num2: Int, _ baseValue: Int)
{
// Convert Given numbers into decimal and addition of it value
var sum: Int = self.convertToDecimal(num1, baseValue) +
self.convertToDecimal(num2, baseValue);
var flag: Bool = false;
if (sum < 0)
{
sum = -sum;
flag = true;
}
// This is used to store result
var result: String = "";
// Transform sum to given base
while (sum > 0)
{
result = String((self.charValue(sum % baseValue))) + result;
sum = sum / baseValue;
}
if (flag == true)
{
result = "-"
+ result;
}
// Display given numbers
print("\n Given num1 : ", num1, terminator: "");
print("\n Given num2 : ", num2, terminator: "");
print("\n Given Base : ", baseValue, terminator: "");
// Display result
print("\n Addition : ", result );
}
}
func main()
{
// Test A
// Base : 16
// 16 + 5 = 1B (hexa)
// Note (22 + 5) = 27 (in decimal)
// Test B
// Base : 4
// 42 + 14 = 123 (Base 4)
// Test C
// Base : 8
// 453 + 234 = 707 (Base 8)
// Test C
// Base : 3
// (-45) + (-23) = -222 (Base 3)
}
main();``````

#### Output

`````` Given num1 :  16
Given num2 :  5
Given Base :  16

Given num1 :  42
Given num2 :  15
Given Base :  4

Given num1 :  453
Given num2 :  234
Given Base :  8

Given num1 :  -45
Given num2 :  -23
Given Base :  3
``````// Kotlin program
// Add two integers of given base
{
fun charValue(num: Int): Char
{
if (num >= 0 && num <= 9)
{
return (num + '0'.toInt()).toChar();
}
else
{
return (num - 10 + 'A'.toInt()).toChar();
}
}
// Convert given number into decimal number
fun convertToDecimal(num: Int, baseValue: Int): Int
{
if (baseValue == 10)
{
return num;
}
var n: Int = num;
if (n < 0)
{
n = -n;
}
var multiplier: Int = 1;
var result: Int = 0;
while (n != 0)
{
result += (n % 10) * multiplier;
multiplier *= baseValue;
n = n / 10;
}
if (num < 0)
{
return -result;
}
return result;
}
fun additionOfNumber(num1: Int, num2: Int, baseValue: Int): Unit
{
// Convert Given numbers into decimal and addition of it value
var sum: Int = this.convertToDecimal(num1, baseValue) +
this.convertToDecimal(num2, baseValue);
var flag: Boolean = false;
if (sum < 0)
{
sum = -sum;
flag = true;
}
// This is used to store result
var result: String = "";
// Transform sum to given base
while (sum > 0)
{
result = (this.charValue(sum % baseValue)).toString() + result;
sum = sum / baseValue;
}
if (flag == true)
{
result = "-" + result;
}
// Display given numbers
print("\n Given num1 : " + num1);
print("\n Given num2 : " + num2);
print("\n Given Base : " + baseValue);
// Display result
print("\n Addition : " + result + "\n");
}
}
fun main(args: Array < String > ): Unit
{
// Test A
// Base : 16
// 16 + 5 = 1B (hexa)
// Note (22 + 5) = 27 (in decimal)
// Test B
// Base : 4
// 42 + 14 = 123 (Base 4)
// Test C
// Base : 8
// 453 + 234 = 707 (Base 8)
// Test C
// Base : 3
// (-45) + (-23) = -222 (Base 3)
}``````

#### Output

`````` Given num1 : 16
Given num2 : 5
Given Base : 16

Given num1 : 42
Given num2 : 15
Given Base : 4

Given num1 : 453
Given num2 : 234
Given Base : 8

Given num1 : -45
Given num2 : -23
Given Base : 3

## Time Complexity

The time complexity of this algorithm mainly depends on the arithmetic operations and the GCD calculation used within the `convertToDecimal` function. Arithmetic operations and comparisons are typically constant time operations, while the GCD calculation has a time complexity of O(log(min(a, b))). Therefore, the overall time complexity of the algorithm is reasonable for most practical scenarios.

## Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.