leetcode 10/17/2024

#include <ranges>

constexpr long long pow(int num, int power) {
    if (power == 0) return 1;
    return (long long)num * pow(num, power - 1);
}

constexpr int ithDigit(int num, int i) {
    return (num / pow(10, i)) % 10;
}

static_assert(ithDigit(1234, 0) == 4);
static_assert(ithDigit(1234, 1) == 3);
static_assert(ithDigit(1234, 2) == 2);
static_assert(ithDigit(1234, 3) == 1);

constexpr int numDigits(int num) {
    if (num == 0) return 0;
    return 1 + numDigits(num / 10);
}

static_assert(numDigits(1) == 1);
static_assert(numDigits(12) == 2);
static_assert(numDigits(123) == 3);
static_assert(numDigits(1234) == 4);

constexpr int swapDigits(int num, int a, int b) {
    long long int firstValue = ithDigit(num, a) * (long long) pow(10, a);
    long long int secondValue = ithDigit(num, b) * (long long) pow(10, b);
    int removedSwaps = num - firstValue - secondValue;
    long long int newFirst = ithDigit(num, a) * (long long) pow(10, b);
    long long int newSecond = ithDigit(num, b) * (long long) pow(10, a);
    return removedSwaps + newFirst + newSecond;
}

static_assert(swapDigits(1234, 0, 1) == 1243);
static_assert(swapDigits(1234, 2, 3) == 2134);
static_assert(swapDigits(1234, 0, 3) == 4231);
static_assert(swapDigits(1234, 2, 1) == 1324);

class Solution {
public:
    constexpr int maximumSwap(int num) {

        int num_digits = numDigits(num);

        auto all_possibilites = std::views::cartesian_product(std::views::iota(0, num_digits),
                                                              std::views::iota(0, num_digits)) |
                                std::views::transform([num](std::tuple<int, int> t) {
                                    const auto& [a, b] = t;
                                    return swapDigits(num, a, b);
                                });

        return std::ranges::max(all_possibilites);
    }
};