Maximum 69 Number

class Solution {
public:
    int highest69Number(int number) {
        int originalNumber = number;
        int positionOfSix = -1;
        int currentPlace = 0;

        while (originalNumber > 0) {
            if (originalNumber % 10 == 6)
                positionOfSix = currentPlace;

            originalNumber /= 10;
            currentPlace++;
        }

        return positionOfSix == -1 ? number : number + 3 * (int)pow(10, positionOfSix);
    }
};

The provided C++ solution is designed to solve the problem titled "Maximum 69 Number". The goal is to convert the maximum possible number of 6s to 9s in a given number to achieve the highest value possible. Here is how the code functions:

• The function highest69Number begins by initializing two integer variables, originalNumber to store the input number and positionOfSix to track the rightmost position of the digit 6 in the number.
• A loop runs while originalNumber is greater than 0, where the remainder when originalNumber is divided by 10 is checked. If the remainder is 6, positionOfSix is updated to the current digit position.
• After examining each digit, originalNumber is divided by 10 to remove the examined digit, and currentPlace is incremented to move to the next position.
• If no 6 is found (positionOfSix remains -1), the function returns the number as it is. However, if a 6 is found, the code calculates the new number by adding 3 * pow(10, positionOfSix) to the original number. This operation effectively replaces the rightmost 6 with a 9.
• The use of pow function aids in determining the precise place where the digit needs to be changed from 6 to 9.

This implementation efficiently determines the maximum number achievable by changing a single 6 to a 9, ensuring the change increases the number as much as possible. This approach is straightforward and optimizes the integer calculations without altering or reformatting the entire number, providing an optimal solution for this numerical transformation challenge.

class Solution {
    public int maximumNumberByChangingDigits(int inputNumber) {
        int copy = inputNumber;
        int mostSignificantSixIndex = -1;
        int digitPosition = 0;

        while (copy > 0) {
            if (copy % 10 == 6)
                mostSignificantSixIndex = digitPosition;
                
            copy /= 10;
            digitPosition++;
        }

        return mostSignificantSixIndex == -1 ? inputNumber : inputNumber + 3 * (int)Math.pow(10, mostSignificantSixIndex);
    }
}

This Java solution is designed to address the problem of maximizing a number by changing at most one digit from 6 to 9. The given code provides a method, maximumNumberByChangingDigits, which accepts an integer inputNumber and manipulates it to produce the largest possible number under the set constraint (changing one '6' to '9').

Following is how the code operates:

1. Initialize a copy of the input number, copy, and variables for indexing the digits—mostSignificantSixIndex for tracking the position of the most significant '6', and digitPosition for current digit examination.

2. Iterate through copy to examine each digit from least significant to most:

   • Check if current digit is '6'. If true, update mostSignificantSixIndex to digitPosition, marking the latest '6' found which could be the most significant when viewed from left-to-right in the number.
   • Reduce copy by a factor of 10 and increment digitPosition for moving to the next digit.

3. Calculate the result:

   • If mostSignificantSixIndex remains unchanged (i.e., no '6' found), return inputNumber.
   • If a '6' is found, enhance inputNumber by adding 3 multiplied by 10 raised to the power mostSignificantSixIndex. This effectively changes the rightmost '6' into a '9'.

The solution efficiently checks and alters the necessary digit with minimal computational steps, leveraging mathematical operations for digit manipulation without resorting to string conversions, ensuring better performance for larger numbers.