Solution Template

Solution_CP.java

import java.util.*;
import java.io.*;
import java.math.*;

public class Solution {

    public static void main(String[] args) {
        // WRITE CODE HERE
        int a = in.nextInt(), b = in.nextInt();
        out.println(power(a,b));
        out.flush();
    }
    
    // ALL PRE-WRITTEN HELPER FUNCTIONS
    static QuickReader in = new QuickReader();
    static PrintWriter out = new PrintWriter(System.out);
    private final static int MOD = (int)((1e9)+7);

    private static boolean[] primeFinder(int n) {
        boolean[] result = new boolean[n+1];
        Arrays.fill(result, true);
        result[0] = false; result[1] = false;
        for (int i = 2; i * i <= n; i++) {
            if(!result[i]) continue;
            for (int j = i * i; j <= n; j += i) {
                result[j] = false;
            }
        }
        return result;
    }

    private static long gcd(long a, long b) {
        return a % b == 0 ? b : gcd(b, a % b);
    }

    private static long lcm(long a, long b) {
        return a * b / gcd(a, b);
    }

    private static long power(long a, long b) {
        long result = 1;
        while(b>0) {
            if((b&1) == 1) {
                result = (result * a) % MOD;
            }
            b >>= 1;
            a = (a * a) % MOD;
        }
        return result;
    }

    private static long modInverse(long a) {
        return power(a, MOD - 2);
    }

    private static long nCr(int n, int r) {
        if(n < r) return 0;
        if(r == 0) return 1;
        long[] dp = factorial(n);
        return ((dp[n] * modInverse(dp[r]) % MOD) * (modInverse(dp[n-r]) % MOD)) % MOD;
    }

    private static long nCr(int n, int r, long[] dp) {
        if(n < r) return 0;
        if(r == 0) return 1;
        return ((dp[n] * modInverse(dp[r]) % MOD) * (modInverse(dp[n-r]) % MOD)) % MOD;
    }

    private static long nPr(int n, int r) {
        if(n < r) return 0;
        if(r == 0) return 1;
        long[] dp = factorial(n);
        return (dp[n] * modInverse(dp[n-r])) % MOD;
    }

    private static long nPr(int n, int r, long[] dp) {
        if(n < r) return 0;
        if(r == 0) return 1;
        return (dp[n] * modInverse(dp[n-r])) % MOD;
    }

    private static long[] factorial(int n) {
        long[] factorial = new long[n + 1];
        factorial[0] = 1;
        for (int i = 1; i <= n; i++) {
            factorial[i] = (factorial[i - 1] * i) % MOD;
        }
        return factorial;
    }

    private static void printArray(int[] a) {
        for(int i : a) out.print(i + " ");
        out.println();
    }

    private static void printlnArray(int[] a) {
        for (int i : a) out.println(i);
    }

    private static void printMatrix(int[][] a) {
        for(int[] i : a) printArray(i);
    }

    private static void sortArray(int[] a, int order) {
        ArrayList<Integer> l = new ArrayList<>();
        for (int i : a) l.add(i);
        if(order == -1) Collections.sort(l, Collections.reverseOrder());
        else Collections.sort(l);
        for (int i = 0; i < a.length; i++) a[i] = l.get(i);
    }

    private static class QuickReader {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer("");

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        String next() {
            while (!st.hasMoreTokens())
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        int[] readIntArray(int n) {
            int[] a = new int[n];
            for (int i = 0; i < n; i++) a[i] = nextInt();
            return a;
        }

        long[] readLongArray(int n) {
            long[] a = new long[n];
            for (int i = 0; i < n; i++) a[i] = nextLong();
            return a;
        }
    }
}

Solution_LeetCode.java

import java.util.*;
import java.io.*;
import java.math.*;

public class Solution {
    public static void main(String[] args) {
        // WRITE CODE HERE
        System.out.println(power(5,2));
    }


    // ALL PRE-WRITTEN HELPER FUNCTIONS
    private final static int MOD = (int)((1e9)+7);

    private static boolean[] primeFinder(int n) {
        boolean[] result = new boolean[n+1];
        Arrays.fill(result, true);
        result[0] = false; result[1] = false;
        for (int i = 2; i * i <= n; i++) {
            if(!result[i]) continue;
            for (int j = i * i; j <= n; j += i) {
                result[j] = false;
            }
        }
        return result;
    }

    private static long gcd(long a, long b) {
        return a % b == 0 ? b : gcd(b, a % b);
    }

    private static long lcm(long a, long b) {
        return a * b / gcd(a, b);
    }

    private static long power(long a, long b) {
        long result = 1;
        while(b>0) {
            if((b&1) == 1) {
                result = (result * a) % MOD;
            }
            b >>= 1;
            a = (a * a) % MOD;
        }
        return result;
    }

    private static long modInverse(long a) {
        return power(a, MOD - 2);
    }

    private static long nCr(int n, int r) {
        if(n < r) return 0;
        if(r == 0) return 1;
        long[] dp = factorial(n);
        return ((dp[n] * modInverse(dp[r]) % MOD) * (modInverse(dp[n-r]) % MOD)) % MOD;
    }

    private static long nCr(int n, int r, long[] dp) {
        if(n < r) return 0;
        if(r == 0) return 1;
        return ((dp[n] * modInverse(dp[r]) % MOD) * (modInverse(dp[n-r]) % MOD)) % MOD;
    }

    private static long nPr(int n, int r) {
        if(n < r) return 0;
        if(r == 0) return 1;
        long[] dp = factorial(n);
        return (dp[n] * modInverse(dp[n-r])) % MOD;
    }

    private static long nPr(int n, int r, long[] dp) {
        if(n < r) return 0;
        if(r == 0) return 1;
        return (dp[n] * modInverse(dp[n-r])) % MOD;
    }

    private static long[] factorial(int n) {
        long[] factorial = new long[n + 1];
        factorial[0] = 1;
        for (int i = 1; i <= n; i++) {
            factorial[i] = (factorial[i - 1] * i) % MOD;
        }
        return factorial;
    }
}