linear recurrence, matrix exponentiation

Author: ivorynoise

10551-d.java

@@ -0,0 +1,71 @@
+import java.util.*;
+import java.io.*;
+import java.math.BigInteger;
+
+//Given 2 strings p and m in base b return p % m in base b
+
+class Main {
+	public static void main(String args[]){
+		int b;
+		BigInteger p, m;
+		String num, div, ans;
+		Scanner s = new Scanner(System.in);
+
+		while(true){
+			b = s.nextInt();
+			if (b == 0) break;
+
+			p = new BigInteger(s.next(), b);	//converted to base 10
+			m = new BigInteger(s.next(), b);
+			ans = p.mod(m).toString(b);
+			System.out.println(ans);
+		}
+
+	}
+	
+	static class FastReader {
+	// static class FastReader extends Scanner{
+	// INFO : final classes cant be extended
+
+		BufferedReader br;
+		StringTokenizer st;
+
+		public FastReader() {
+			br = new BufferedReader(new
+			                        InputStreamReader(System.in));
+		}
+
+		String next() {
+			while (st == null || !st.hasMoreElements()) {
+				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());
+		}
+
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		String nextLine() {
+			String str = "";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+	}
+}

10925-d.java

@@ -0,0 +1,68 @@
+import java.util.*;
+import java.io.*;
+import java.math.*;	//for BigInteger
+class Main {
+	// public static void main(){
+	public static void main(String args[]){
+		Scanner s = new Scanner(System.in);
+		int c = 0;
+		BigInteger sum = BigInteger.ZERO;
+
+		while(true){
+			++c;
+			int n = s.nextInt();
+			int f = s.nextInt();
+			if (n == 0 && f == 0) break;
+			sum = BigInteger.ZERO;
+			while(n-- > 0){
+				sum = sum.add(s.nextBigInteger());
+			}
+			// Bill #1 costs 16200000000: each friend should pay 540000000
+			System.out.printf("Bill #%d costs %s: each friend should pay %s\n\n", 
+				c, sum.toString(), sum.divide(BigInteger.valueOf(f)));
+		}
+	}
+	
+	static class FastReader {
+		BufferedReader br;
+		StringTokenizer st;
+
+		public FastReader() {
+			br = new BufferedReader(new
+			                        InputStreamReader(System.in));
+		}
+
+		String next() {
+			while (st == null || !st.hasMoreElements()) {
+				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());
+		}
+
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		String nextLine() {
+			String str = "";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+	}
+}

FIBOSUM-d.cpp

@@ -0,0 +1,65 @@
+#include <bits/stdc++.h>
+using namespace std;
+typedef long long ll;
+typedef vector<ll> vi;
+typedef vector<vi> vvi;
+const int mod = 1000000007;
+
+
+vvi mul(const vvi& a, const vvi& b){
+	vvi c(a.size(), vi(b[0].size(), 0));
+
+	for(int r = 0; r < a.size(); ++r){
+		for(int j = 0; j < b[0].size(); ++j){
+			for(int x = 0; x < b.size(); ++x){
+				c[r][j] += (a[r][x] % mod) * (b[x][j] % mod);
+				c[r][j] %= mod;
+			}
+		}
+	}
+	return c;
+}
+
+vvi pow(const vvi& a, int n){
+	if (n <= 1) return a;
+	if (n & 1) return mul(a, pow(a, n-1));
+
+	vvi ans = pow(a, n/2);
+	ans = mul(ans, ans);
+	return ans;
+}
+
+ll sum(int n){
+	vvi t = {
+		{1, 1, 0},		//the last 0 will be modified accordingly
+		{0, 0, 1},
+		{0, 1, 1}
+	};
+
+	vvi tn = pow(t, n);
+
+	// for(int i = 0; i < tn.size(); ++i){
+	// 	for(int j = 0; j < tn[0].size(); ++j){
+	// 		cout << tn[i][j] << " ";
+	// 	}
+	// 	cout << endl;
+	// }
+
+	ll ans = tn[0][2] % mod; 
+	return ans;
+}
+
+int main(){
+	int t;
+	cin >> t;
+	while(t--){
+		ll n, m;
+		cin >> n >> m;
+
+		m = sum(m+1);
+		n = sum(n);
+		cout << (m - n + mod) % mod << "\n"; 
+	}
+	return 0;
+	
+}

JULKA-d.java

@@ -0,0 +1,60 @@
+import java.util.*;
+import java.io.*;
+import java.math.BigInteger;
+
+class Main {
+	// public static void main(){
+	public static void main(String args[]){
+		Scanner s = new Scanner(System.in);
+		for(int i = 0; i < 10; ++i){
+			BigInteger sum = s.nextBigInteger();
+			BigInteger excess = s.nextBigInteger();
+			BigInteger h = sum.subtract(excess).divide(BigInteger.valueOf(2));
+			System.out.println(h.add(excess));
+			System.out.println(h);
+		}
+	}
+	
+	static class FastReader {
+		BufferedReader br;
+		StringTokenizer st;
+
+		public FastReader() {
+			br = new BufferedReader(new
+			                        InputStreamReader(System.in));
+		}
+
+		String next() {
+			while (st == null || !st.hasMoreElements()) {
+				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());
+		}
+
+		double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		String nextLine() {
+			String str = "";
+			try {
+				str = br.readLine();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			return str;
+		}
+	}
+}

largeFactorial.cpp

@@ -0,0 +1,38 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+typedef int digit;
+
+void mul(vector<digit>& v, int n){
+	int carry = 0;
+	int prod = 0;
+
+	for(int i = 0; i < v.size(); ++i){
+		prod = v[i] * n + carry;
+		v[i] = prod % 10;
+		carry = prod / 10;
+	}
+
+	while(carry){
+		v.push_back(carry % 10);
+		carry /= 10;
+	}
+}
+
+void factorial(int n){
+	vector<digit> v(1,1);
+
+	for(int i = 2; i <= n; ++i){
+		mul(v, i);
+	}
+
+	for(int i = v.size() - 1; i >=0; --i){
+		cout << v[i];
+	}
+}
+
+int main(){
+	int n;
+	cin >> n;
+	factorial(n);	
+}