Replace all '0' with '5' in an Input Integer using JavaScript

Given a number, our task is to take an input integer and replace all occurrences of the digit '0' with the digit '5'. We can solve this problem by using various methods in JavaScript.

Example:

Input:
n = 1020

Output:
1525

Below are the approaches to replace all '0' with '5' in an input integer using JavaScript:

String Conversion and Manipulation

This approach converts the input integer into a string using the toString() method. Then, it replaces all occurrences of '0' with '5' using the replace() method with a regular expression /0/g. Finally, it parses the modified string back to an integer using parseInt() with a radix of 10 for decimal conversion.

Example: The example below shows the replacement of all '0' with '5' in an input integer using String Conversion and Manipulation.

function replaceZeros(n) {
    let str = n.toString();
    str = str.replace(/0/g, '5');
    return parseInt(str, 10);
}
const n = 1020;
console.log(replaceZeros(n));

1525

Time Complexity: O(n), where n is the number of digits in the integer.

Space Complexity: O(n).

Mathematical Manipulation

The function replaceZerosWithMath iterates through each digit of the input integer 'n', replaces '0' with '5', and constructs the resulting integer using mathematical manipulation. It initializes 'result' to 0 and 'multiplier' to 1, then iterates through each digit of 'n', replacing '0' with '5' and building the result by multiplying each digit with 'multiplier' and adding it to 'result'. Finally, it returns the resulting integer after processing all digits.

Example: The example below illustrates the replacement of all '0' with '5' in an input integer using Mathematical Manipulation.

function replaceZeros(n) {
    let result = 0;
    let multiplier = 1;
    while (n > 0) {
        let digit = n % 10;
        if (digit === 0) digit = 5;
        result += digit * multiplier;
        multiplier *= 10;
        n = Math.floor(n / 10);
    }
    return result;
}
const n = 1020;
console.log(replaceZeros(n));

1525

Time Complexity: O(n), where n is the number of digits in the integer.

Space Complexity: O(1).

Iterative with Reversal

The function 'replaceZeroWithFive' iterates through each digit of the input integer 'num'. It replaces every '0' digit with '5' by building a temporary integer 'temp' with reversed digits containing '5' instead of '0'. It then reverses 'temp' to obtain the final result integer 'reversed' and returns it.

Example: The example below shows the replacement of all '0' with '5' in an input integer using the Iterative with Reversal method.

function replaceWithFive(num) {
    let temp = 0;

    while (num > 0) {
        let digit = num % 10;
        if (digit === 0) {
            digit = 5;
        }
        temp = temp * 10 + digit;
        num = Math.floor(num / 10);
    }

    let reversed = 0;
    while (temp > 0) {
        reversed = reversed * 10 + temp % 10;
        temp = Math.floor(temp / 10);
    }

    return reversed;
}

console.log(replaceWithFive(9570320003));

9575325553

Time Complexity: O(n), where n is the number of digits in the integer.

Space Complexity: O(1).

Recursion

The function replaceZeroWithFive recursively replaces each '0' digit in the input integer num with '5'. It checks if num is equal to 0, in which case it returns 5. Otherwise, it extracts the last digit of the num, replaces '0' with '5' if necessary, and recursively calls itself with the remaining digits. Finally, it concatenates the modified digit with the result of the recursive call to build the final integer with '0' replaced by '5'.

Example: The example below shows the replacement of all '0' with '5' in an input integer using the Iterative with the Recursion method.

function replaceWithFive(num) {
    if (num === 0) {
        return 5;
    }
    const digit = num % 10;
    const modifiedDigit = digit === 0 ? 5 : digit;
    return replaceWithFive(Math.floor(num / 10)) * 10 + modifiedDigit;
}

console.log(replaceWithFive(0304003092));

5354553592

Time Complexity: O(n), where n is the number of digits in the integer.

Space Complexity: O(n).