Leetcode: Super Pow

Your task is to calculate ab mod 1337 where a is a positive integer and b is an extremely large positive integer given in the form of an array.

Example1:

a = 2
b = [3]

Result: 8
Example2:

a = 2
b = [1,0]

Result: 1024

 ab % k = (a%k)(b%k)%k
Since the power here is an array, we'd better handle it digit by digit.
One observation:
a^1234567 % k = (a^1234560 % k) * (a^7 % k) % k = (a^123456 % k)^10 % k * (a^7 % k) % k
put it other way:
Suppose f(a, b) calculates a^b % k; Then translate above formula to using f :
f(a,1234567) = f(a, 1234560) * f(a, 7) % k = f(f(a, 123456),10) * f(a,7)%k;
Implementation of this idea:

public class Solution {
    public int superPow(int a, int[] b) {
        return superPow(a, b, b.length, 1337);
    }
    
    public int superPow(int a, int[] b, int len, int k) {
        if (len == 1) return powMud(a, b[0], k);
        return powMud(superPow(a, b, len-1, k), 10, k) * powMud(a, b[len-1], k) % k;
    }
    
    public int powMud(int x, int y, int k) {
        int res = 1;
        for (int i=y; i>0; i--) {
            x = x % k;
            res = (res * x) % k;
        }
        return res;
    }
}

Another clear solution:

public class Solution {
    public int superPow(int a, int[] b) {
        int res = 1;
        int j = 0;
        a = a % 1337;
        while(j < b.length){
            int rem = pow(a,b[j]);
            // left shift b;
            res = (rem * pow(res,10)) % 1337;
            j++;
        }
        return res;
    }
    // write a pow function to avoid overflow
    public int pow(int a, int b){
        int res = 1;
        while(b > 0){
            // module 1337 every time to avoid overflow
            res = (res * a) % 1337;
            b--;
        }
        return res;
    }
}