数论 （大数，小费马定理，欧拉定理，威尔逊定理，快速数论变换（NNT）模版）

Java大数
import java.util.*;
import java.math.*;
public class Main{
    public static void main(String args[]){
       Scanner cin = new Scanner(System.in);
       BigInteger a, b;
      
       //以文件EOF结束
       while (cin.hasNext()){
           a = cin.nextBigInteger();
           b = cin.nextBigInteger();
          
           System.out.println(a.add(b)); //大整数加法
           System.out.println(a.subtract(b)); //大整数减法
           System.out.println(a.multiply(b)); //大整数乘法
           System.out.println(a.divide(b)); //大整数除法(取整)
           System.out.println(a.remainder(b)); //大整数取模
          
           //大整数的比较
           if( a.compareTo(b) == 0 ) System.out.println("a == b"); //大整数a==b
           else if( a.compareTo(b) > 0 ) System.out.println("a > b"); //大整数a>b
           else if( a.compareTo(b) < 0 ) System.out.println("a < b"); //大整数a<b
          
           //大整数绝对值
           System.out.println(a.abs()); //大整数a的绝对值
          
           //大整数的幂
           int exponent=10;
           System.out.println(a.pow(exponent)); //大整数a的exponent次幂
          
           //返回大整数十进制的字符串表示
           System.out.println(a.toString());
          
           //返回大整数p进制的字符串表示
           int p=8;
           System.out.println(a.toString(p));
       }
    }
}
 
高精度小数A+B，要去掉末尾的后导0.
import java.math.*;
import java.util.*;
 
public class Main {
    void solve () {
        //BigInteger a, b, c;
        Scanner cin = new Scanner(System.in);
        BigDecimal a = BigDecimal.valueOf (0);
        BigDecimal b = BigDecimal.valueOf (0);
        while (cin.hasNext ()) {
            a = cin.nextBigDecimal ();
            b = cin.nextBigDecimal ();
            System.out.println (a.add (b).stripTrailingZeros().toPlainString());
        }
    }
    public static void main (String[] args) {
        Main work = new Main();
        work.solve ();
    }
}
 
Java二维数组
从控制台输入行数，打印对应的杨辉三角
//从控制台获取行数
Scanner s = new Scanner(System.in);
int row = s.nextInt();
//根据行数定义好二维数组，由于每一行的元素个数不同，所以不定义每一行的个数
int[][] arr = new int[row][];
//遍历二维数组
for(int i = 0; i < row; i++){
    //初始化每一行的这个一维数组
    arr[i] = new int[i + 1];
    //遍历这个一维数组，添加元素    
    for(int j = 0; j <= i; j++){
        //每一列的开头和结尾元素为1，开头的时候，j=0，结尾的时候，j=i
        if(j == 0 || j == i){
            arr[i][j] = 1;
        } else {//每一个元素是它上一行的元素和斜对角元素之和
            arr[i][j] = arr[i -1][j] + arr[i - 1][j - 1];
        }
        System.out.print(arr[i][j] + "	");
    }
    System.out.println();
}
 
 
 
三个重要的同余式——威尔逊定理、费马小定理、欧拉定理 + 求幂大法
一、威尔逊定理
若p为质数，则
p|(p-1)!+1
亦：(p-1)! ≡ p-1 ≡ -1(mod p)
威尔逊定理的逆也成立.
 
二、费马小定理
假如p是质数，且gcd(a,p)=1，那么
a^(p-1) ≡1（mod p）
我们可以利用费马小定理来简化幂模运算：由于a^(p-1)≡a^0≡1(mod p)，所以a^x(mod p)有循环节，长度为p-1，所以a^x≡a^(x%(p-1))(mod p)
三、欧拉定理
若a,m为正整数，且gcd(a,m) = 1，则
a^φ(m)≡1(mod m)
我们亦可以利用欧拉定理来简化幂模运算：a^x≡a^(x%φ(m))(mod m)
为下一节做铺垫，我们将a^x≡a^(x%φ(m))(mod m)变下形：
由于a^φ(m)≡1(mod m)
a^x≡a^(x%φ(m))≡a^(x%φ(m)+φ(m))(mod m)
 
四、求幂大法（广义欧拉定理）及其证明
对于同余式a^b≡x(mod m)，如何求出x？（1<=a,m<=1000000000，1<=b<=10^1000000）
注意到b很大，我们可以先采取一些方法降幂。
若gcd(a,m)=1，那么使用欧拉定理即可：a^b≡a^(b%φ(m))(mod m)
若gcd(a,m)>1，且b>φ(m)，则有“求幂大法”——a^b≡a^(b%φ(m)+φ(m))(mod m)
（当b<=φ(m)时直接用快速幂即可）
 
 
__int128_t 输入输出
 
void scan(__int128_t &x) {
    x = 0;
    int f = 1;
    char ch;
    if((ch = getchar()) == '-') f = -f;
    else x = x * 10 + ch - '0';
    while((ch = getchar()) >= '0' && ch <= '9')
        x = x * 10 + ch - '0';
    x *= f;
}
 
void _print(__int128_t x) {
    if(x<0) putchar('-'), x *= -1;
    if(x>9) _print(x / 10);
    putchar(x%10 + '0');
}
 
 
__int128_t  170141183460469231731687303715884105727 1e38
__uint128_t 340282366920938463463374607431768211455 3e38
 
 
 
Python input and output
A + B problem
 
try:
    while True:
        a, b = map(int, input().split())
        print(a + b)
except:
    pass
 
 
快速数论变换（NNT）模版
 
const int MAXN = 800005;
 
const int P=998244353;
const int g=3;//P的原根
int W[MAXN];
int mod_pow(int a, int k)
{
   ll A=1LL*a,ANS=1LL;
   for(;k;k>>=1,A=A*A%P)
   {
       if(k&1)
       {
           ANS=ANS*A%P;
       }
   }
   return (int)ANS%P;
}
void ntt(ll A[],int nn,int ty)
{
   int t1,t2,i,j,k,m;
   for(i=0;i<nn;i++)
   {
       for(j=0,k=i,m=1;m<nn;m<<=1,j=(j<<1)|(k&1),k>>=1);
       if(i<j)
       {
           t1=A[i];
           A[i]=A[j];
           A[j]=t1;
       }
   }
   W[0]=1;
   for(m=1;m<nn;m<<=1)
   {
       t1= mod_pow(g, P - 1 + ty * (P - 1) / (m << 1));
       for(i=1;i<m;i++)
       {
           W[i]=1LL*W[i-1]*t1%P;
       }
       for(k=0;k<nn;k+=m<<1)
       {
           for(i=k;i<k+m;i++)
           {
               t1=A[i];
               t2=1LL*A[i+m]*W[i-k]%P;
               A[i]=t1+t2;
               A[i]-=A[i]>P?P:0;
               A[i+m]=t1-t2;
               A[i+m]+=A[i+m]<0?P:0;
           }
       }
   }
   if(ty==1)
   {
       return ;
   }
   t1= mod_pow(nn, P - 2);
   for(i=0;i<nn;i++)
   {
       A[i]=1LL*A[i]*t1%P;
   }
}
 
 
使用方法 
元素个数是2的幂。
 
nnt变换：nnt(数组名, 元素个数, 1)
nnt逆变换：nnt(数组名, 元素个数, -1)