Длинка на Java

package net.egork;

import net.egork.collections.Pair;
import net.egork.utils.io.InputReader;
import net.egork.utils.io.OutputWriter;

import java.util.Arrays;
import java.util.Random;

public class Task5E {
    public void solve(int testNumber, InputReader in, OutputWriter out) {
        if (false) {
            fromBaseTest();
            toBaseTest();
            BigInt.divideTest();
            BigInt.toStringTest();
            BigInt.multiplyTest();
            BigInt.addTest();
        }

        int base1 = in.readInt();
        int base2 = in.readInt();
        String value = in.next();
        BigInt bigInt = fromBase(value, base1);
        out.print(toBase(bigInt, base2));
    }

    private String toBase(BigInt value, int base) {
        StringBuilder result = new StringBuilder();
        while (!value.isZero()) {
            Pair<BigInt, Integer> divide = value.divide(base);
            result.append(toChar(divide.second));
            value = divide.first;
        }
        if (result.length() == 0) result.append(0);
        return result.reverse().toString();
    }
    public void toBaseTest() {
        Random rnd = new Random(System.currentTimeMillis());
        for (int i = 0; i < 1000; i++) {
            int base = rnd.nextInt(35) + 2;
            int number = rnd.nextInt((int) 1e9);
            if (!toBase(new BigInt(number), base).equalsIgnoreCase(Integer.toString(number, base)))
                throw new OutOfMemoryError("Oops");
        }
    }

    private char toChar(int value) {
        if (value < 10) return (char) (value + '0');
        return (char) (value - 10 + 'A');
    }
    private int fromChar(char c) {
        if (Character.isLetter(c)) return c - 'A' + 10;
        return c - '0';
    }

    private BigInt fromBase(String s, int base) {
        BigInt result = new BigInt(0);
        BigInt baseMultiplier = new BigInt(1);
        for (int i = s.length() - 1; i >= 0; i--) {
            int d = fromChar(s.charAt(i));
            result = result.add(baseMultiplier.multiply(d));
            baseMultiplier = baseMultiplier.multiply(base);
        }
        return result;
    }
    public void fromBaseTest() {
        Random rnd = new Random(System.currentTimeMillis());
        for (int i = 0; i < 1000; i++) {
            int base = rnd.nextInt(35) + 2;
            int number = rnd.nextInt((int) 1e9);
            String inNewBase = Integer.toString(number, base).toUpperCase();
            if (!fromBase(inNewBase, base).toString().equals(number + ""))
                throw new OutOfMemoryError("Oops");
        }
    }
}

class BigInt {
    private int[] number;

    public BigInt(int[] number) {
        this.number = prepare(number);
    }

    public BigInt(int value) {
        int len = numLen(value);
        number = new int[len];
        for (int i = 0; i < len; i++) {
            number[i] = value % 10;
            value /= 10;
        }
    }

    public BigInt add(BigInt value) {
        int[] result = new int[Math.max(number.length, value.number.length) + 1];
        for (int i = 0, carry = 0; i < result.length; i++) {
            if (i < number.length) carry += number[i];
            if (i < value.number.length) carry += value.number[i];
            result[i] = carry % 10;
            carry /= 10;
        }
        return new BigInt(result);
    }
    public static void addTest() {
        for (int i = 0; i <= 1000; i++)
            for (int j = 0; j <= 1000; j++)
                if (!new BigInt(i).add(new BigInt(j)).toString().equals(i + j + ""))
                    throw new OutOfMemoryError("Oops");
    }

    public Pair<BigInt, Integer> divide(int value) {
        int[] result = new int[number.length];
        int last = number.length - 1;
        int num = number[last];
        while (last > 0 && num < value)
            num = num * 10 + number[--last];
        last++;
        num /= 10;
        int newLen = 0;
        while (last > 0) {
            newLen++;
            num = num * 10 + number[--last];
            result[result.length - newLen] = num / value;
            num %= value;
        }
        return Pair.makePair(new BigInt(Arrays.copyOfRange(result, result.length - newLen, result.length)), num);
    }
    public static void divideTest() {
        for (int i = 0; i <= 1_000; i++)
            for (int j = 1; j <= 10_000; j++)
                if (!new BigInt(i).divide(j).equals(Pair.makePair(new BigInt(i / j), i % j)))
                    throw new OutOfMemoryError("Oops");
    }

    public BigInt multiply(int val) {
        int[] result = new int[number.length + numLen(val)];
        for (int i = 0; val > 0; val /= 10, i++) {
            int digit = val % 10;
            int carry = 0;
            for (int j = 0; j < number.length; j++) {
                carry += result[i + j] + number[j] * digit;
                result[i + j] = carry % 10;
                carry /= 10;
            }
            result[i + number.length] += carry;
        }
        return new BigInt(prepare(result));
    }
    public static void multiplyTest() {
        for (int i = 0; i <= 1_000; i++)
            for (int j = 0; j <= 10_000; j++)
                if (!new BigInt(i).multiply(j).toString().equals(i * j + ""))
                    throw new OutOfMemoryError("Oops");
    }

    private static int[] prepare(int[] number) {
        int last = number.length - 1;
        while (last > 0 && number[last] == 0)
            last--;
        if (last == number.length - 1)
            return number;
        return Arrays.copyOfRange(number, 0, last + 1);
    }

    private int numLen(int val) {
        if (val == 0)
            return 1;
        int len = 1;
        while ((val /= 10) > 0)
            len++;
        return len;
    }

    public boolean isZero() {
        return number.length == 1 && number[0] == 0;
    }

    @Override
    public boolean equals(Object obj) {
        return Arrays.equals(number, ((BigInt) obj).number);
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder(number.length);
        for (int i : number)
            sb.append(i);
        return sb.reverse().toString();
    }
    public static void toStringTest() {
        for (int i = 0; i <= 100000; i++)
            if (!new BigInt(i).toString().equals(i + ""))
                throw new OutOfMemoryError("Oops");
    }
}