Code

That's what they all say.

Bases 2 through 36 are simple, yes; however, trying to find out how a number is converted was a bit challenging. I couldn't find much online about base-10 to base-32 conversion. I did, eventually, find something useful, and I've created code, as well as a formula in math to accomplish base-10 to base-32 conversion:

Code:

f(x) = x - 32⌊ˣ⁄₃₂⌋

or

x mod 32

Result:


I tried to make a recursive function/formula, but I don't know of any way to return an alphanumeric result in math, which is absolutely necessary when converting large numbers. I could, however, return the remainders via a multivariable function (not sure this works. I've never really used multivariable functions):

Code:

g(1) = 1; g(x) = (g(⌊x / 32⌋), x mod 32)
                        ^^^^^^^^^^^^^^
                                  VECTOR

My brain hurts already. I'm not going to try and figure this out for y'all. Good luck;

As tetrationiscool mentioned: there are the basic digits, 0-9, which would be used first. If the remainder is a number greater than 9, it'd start using letters a-v. Being that the first remainder of our input, 40, was 8, the last character in the string would be 8. The next remainder you'd have to get is the quotient of x/32 floored. You'd continue this process until your number, in this case, 40, is zero or smaller. 40/32 is 1.25; floored, it's 1. 1 mod 32 is 1. So 1 would be added to the start of the string. That becomes 18. 1 / 32 is obviously zero or smaller, so that's where you'd stop. End result: 40 in base-32 is 18.

I'm sure that made no sense, so if you understand code, perhaps you'll get a better understanding reading this:

Spoiler: C++

PHP:

class Base32 {
    public:
        static std::string dict;
        static std::string encode(int number) {
            std::string result = "";
            bool negative = false;
            if (number < 0) {
                negative = true;
            }

            number = abs(number);
            do {
                result = Base32::dict[fmod(floor(number), 32)] + result;
                number /= 32;
            } while(number > 0);

            if (negative) {
                result = "-" + result;
            }
  
            return result;
        }

        static int decode(std::string str) {
            int result = 0;
            int negative = 1;
            if (str.rfind("-", 0) == 0) {
                negative = -1;
                str = str.substr(1);
            }

            for(char& letter : str) {
                result = result * 32 + Base32::dict.find(letter);
            }

            return result * negative;
        }
};

std::string Base32::dict = "0123456789abcdefghijklmnopqrstuvwxyz";


Spoiler: JavaScript

PHP:

class Base32 {
    static dict = "0123456789abcdefghijklmnopqrstuvwxyz";
    static encode(number) {
        let result = "";
        let negative = false;
        if (number < 0) {
            negative = true;
        }
      
        number = Math.abs(number);
        do {
            result = Base32.dict[Math.floor(number) % 32] + result;
            number /= 32;
        } while(number >= 1);

        if (negative) {
            result = "-" + result;
        }

        return result;
    }
  
    static decode(string) {
        let result = 0;
        let negative = 1;
        if (string.startsWith("-")) {
            negative = -1;
            string = string.slice(1);
        }
      
        for (const letter of string) {  
            result += Base32.dict.indexOf(letter);
            result *= 32;
        }

        return result / 32 * negative;
    }
}


P.S. I forgot about the modulo operator.