public BigInteger count(int n) { BigInteger[] prev = new BigInteger[k]; Arrays.fill(prev, BigInteger.ZERO); prev[s] = BigInteger.ONE; while (n-- > 0) { BigInteger[] next = new BigInteger[k]; Arrays.fill(next, BigInteger.ZERO); for (int i = 0; i < k; ++i) { if (prev[i].signum() <= 0) { continue; } for (int j = 0; j < z; ++j) { if (e[j][i] < 0) { continue; } next[e[j][i]] = next[e[j][i]].add(prev[i]); } } prev = next; } BigInteger ans = BigInteger.ZERO; for (int term : t) { ans = ans.add(prev[term]); } return ans; }
BigInteger getResult(int n, int r) { BigInteger ans; ans = F[n]; ans = ans.divide(F[r]); ans = ans.divide(F[n - r]); return ans; }
static { // TODO: DecimalFormat uses ROUND_HALF_EVEN, not ROUND_HALF_UP // Float: precision of 7 (6 digits after .) floatFormatter = new DecimalFormat(); floatFormatter.applyPattern("0.######E0"); // Double: precision of 16 (15 digits after .) doubleFormatter = new DecimalFormat(); doubleFormatter.applyPattern("0.###############E0"); bigIntTenPow = new BigInteger[20]; bigIntMinUnscaled = new BigInteger[20]; bigIntMaxUnscaled = new BigInteger[20]; for (int i = 0; i < bigIntTenPow.length; i++) { bigIntTenPow[i] = bigIntTen.pow(i); if (i < 19) { bigIntMaxUnscaled[i] = bigIntTenPow[i].subtract(BigInteger.ONE); bigIntMinUnscaled[i] = bigIntMaxUnscaled[i].negate(); } else { bigIntMaxUnscaled[i] = BigInteger.valueOf(Long.MAX_VALUE); bigIntMinUnscaled[i] = BigInteger.valueOf(Long.MIN_VALUE); } } }
public static void countPairs(Integer[] arr) { HashMap<Integer, Integer> seenElements = new HashMap<Integer, Integer>(); // ArrayList<Integer> countList = new ArrayList<Integer for (int i = 0; i < arr.length; i++) { if (!seenElements.containsKey(arr[i])) { seenElements.put(arr[i], 1); } else { seenElements.put(arr[i], seenElements.get(arr[i]) + 1); } } BigInteger count = null; for (int element : seenElements.keySet()) { if (seenElements.get(element) > 1) { System.out.println("count is :" + seenElements.get(element)); count.add( factorial(seenElements.get(element)).divide(factorial(seenElements.get(element) - 2))); System.out.println(count); } } if (count == null) { System.out.println("0"); } }
Pair Calculate(int u) { BigInteger ans; Pair temp; temp = new Pair(); if (g[u].size() == 0) { temp.x = BigInteger.ONE; temp.n = 1; return temp; } if (g[u].size() == 1) { temp = Calculate((int) g[u].get(0)); temp.n++; return temp; } int p, q; temp = Calculate((int) g[u].get(0)); ans = temp.x; p = temp.n; temp = Calculate((int) g[u].get(1)); ans = ans.multiply(temp.x); q = temp.n; ans = ans.multiply(C[p + q][p]); temp.x = ans; temp.n = p + q + 1; return temp; }
/** @param args */ public static void main(String[] args) { // array: 99*99 = 9801; BigInteger[] array = new BigInteger[9801]; int cont = 0; for (int i = 2; i < 101; i++) { BigInteger dos = new BigInteger("2"); BigInteger uno = new BigInteger("1"); for (int j = 2; j < 101; j++) { array[cont] = dos.pow(i); cont++; dos = dos.add(uno); } } for (int x = 0; x < array.length; x++) { for (int j = 1; j + x < array.length; j++) { int res = array[x].compareTo(array[x + j]); if (res == 0) { cont--; System.out.println("salto!"); break; } } } System.out.println(cont); }
public static void main(String[] args) { Scanner input = new Scanner(System.in); System.out.println(3 ^ 5 ^ 4 ^ 5 ^ 5 ^ 6 ^ 6 ^ 7); System.out.println(3 ^ 7); int[] a = new int[10]; for (int i = 0; i < 10; i++) a[i] = input.nextInt(); for (int aa : a) { System.out.print(aa); } sss(1, 3, 4, 5, 6, 7, 8, 9); BigInteger aa = new BigInteger( "12809348038290834905895869048359034859083495894038590438590348590834905890345"); BigInteger bb = new BigInteger("111111111111111111111"); System.out.println(aa.subtract(bb)); BigDecimal rrrr = new BigDecimal(input.next()); int aaa; double b; float c; StringBuilder sssss = new StringBuilder("1234234"); System.out.println(); Integer ttt = 4; Double t1 = 14.2; }
public static BigInteger largeSum(ArrayList<BigInteger> nums) { BigInteger sum = BigInteger.ZERO; for (BigInteger i : nums) { sum = sum.add(i); } return sum; }
public static void main(String args[]) throws IOException { BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); while (true) { String str = in.readLine(); // Scanner in = new Scanner(System.in); if (str == null) { break; } else { BigInteger num = new BigInteger(str); if (str.equals("0") || str.equals("1")) { System.out.println(str); } else { // BigInteger num = new BigInteger(str); // // System.out.println(num.subtract(BigInteger.ONE).multiply(BigInteger.valueOf(2))); System.out.println(num.multiply(BigInteger.valueOf(2)).subtract(BigInteger.valueOf(2))); } } } }
public String toString(byte[] bytes) { BigInteger mantissa = ZERO; for (int blockoffset = 8; blockoffset >= 0; blockoffset -= 4) { for (int byteidx = 0; byteidx < 4; byteidx++) { mantissa = mantissa.multiply(BYTESHIFT_FACTOR); int idx = blockoffset + byteidx; mantissa = mantissa.add(new BigInteger(String.valueOf(bytes[idx] & 0xff), 10)); } } // The exponent is stored negative by .NET so we change it back here !!! int exponent = -bytes[13] & 0x1f; boolean negative = bytes[12] != 0; BigDecimal result = new BigDecimal(mantissa); if (exponent < 0) { for (int i = exponent; i < 0; i++) { result = result.divide(TEN, BigDecimal.ROUND_HALF_DOWN); } } else { for (int i = 0; i < exponent; i++) { result = result.multiply(TEN); } } if (negative) { result = result.negate(); } return result.toString(); }
public static void testICDE() { // Number of total operations int numberOfTests = 5; // Length of the p, note that n=p.q int lengthp = 512; Paillier esystem = new Paillier(); Random rd = new Random(); PaillierPrivateKey key = KeyGen.PaillierKey(lengthp, 122333356); esystem.setDecryptEncrypt(key); // let's test our algorithm by encrypting and decrypting few instances long start = System.currentTimeMillis(); for (int i = 0; i < numberOfTests; i++) { BigInteger m1 = BigInteger.valueOf(Math.abs(rd.nextLong())); BigInteger m2 = BigInteger.valueOf(Math.abs(rd.nextLong())); BigInteger c1 = esystem.encrypt(m1); BigInteger c2 = esystem.encrypt(m2); BigInteger c3 = esystem.multiply(c1, m2); c1 = esystem.add(c1, c2); c1 = esystem.add(c1, c3); esystem.decrypt(c1); } long stop = System.currentTimeMillis(); System.out.println( "Running time per comparison in milliseconds: " + ((stop - start) / numberOfTests)); }
public static void main(String[] z) { BigInteger b = BigInteger.ONE; int i = 2, n = new java.util.Scanner(System.in).nextInt(); for (; i < 1501; i++) b = b.multiply(new BigInteger(String.valueOf(i))); System.out.println(b.add(new BigInteger("2"))); for (i = 0; i < n; i++) System.out.println(i + 2); }
public PaillierCryptoSystem(int a, int b) { p = a; q = b; n = BigInteger.valueOf(p).multiply(BigInteger.valueOf(q)); lambda = psi = lcm(p - 1, q - 1); g = n.add(BigInteger.valueOf(1)); nu = psi.modInverse(n); }
public static void main(String[] args) { Scanner s = new Scanner(System.in); BigInteger a = new BigInteger(s.next()); BigInteger b = new BigInteger(s.next()); BigInteger ad = a.add(b); BigInteger mu = a.multiply(b); System.out.println(ad); System.out.println(mu); }
public static void main(String[] args) { /* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */ Scanner scan = new Scanner(System.in); BigInteger bigInteger1 = scan.nextBigInteger(); BigInteger bigInteger2 = scan.nextBigInteger(); System.out.println(bigInteger1.add(bigInteger2)); System.out.println(bigInteger1.multiply(bigInteger2)); }
public static BigInteger factorial(int i) { BigInteger fact = new BigInteger("1"); while (i > 1) { fact = fact.multiply(new BigInteger(new Integer(i).toString())); i--; } return fact; }
public PaillierCryptoSystem() { p = 100000 + (new Random().nextInt(4) + 1) * 10000 + 1; while (!isPrime(p)) p += 2; q = p + 2; while (!isPrime(q)) q += 2; n = BigInteger.valueOf(p).multiply(BigInteger.valueOf(q)); lambda = psi = lcm(p - 1, q - 1); g = n.add(BigInteger.valueOf(1)); nu = psi.modInverse(n); }
public fraction add(fraction x) { BigInteger gcd = den.gcd(x.den); BigInteger A = x.den.divide(gcd); BigInteger B = den.divide(gcd); BigInteger newNum = num.multiply(A).add(x.num.multiply(B)); BigInteger newDen = den.multiply(A); fraction t = new fraction(newNum, newDen); t.fix(); return t; }
private void constrain() { BigInteger offset = new BigInteger(Integer.toString(addressSize * (numUsableRows))); BigInteger endVal = startVal.add(offset); if (endVal.compareTo(scrollBar.getMaximumHP()) > 0) { startVal = scrollBar.getMaximumHP().subtract(offset); endVal = scrollBar.getMaximumHP(); scrollBar.setValueHP(startVal); model.fireTableDataChanged(); } }
private void updateFromScrollBar() { beginUpdate(); BigInteger oldStartVal = startVal; startVal = scrollBar.getValueHP(); constrain(); model.fireTableDataChanged(); if (oldStartVal != null) { modifySelection(oldStartVal.subtract(startVal).intValue() / addressSize); } endUpdate(); }
public static void main(String[] args) { Scanner in = new Scanner(System.in); while (in.hasNextBigInteger()) { BigInteger N = in.nextBigInteger(); if (N.compareTo(BigInteger.ONE) > 0) { BigInteger two = new BigInteger("2"); N = N.multiply(two).subtract(two); } System.out.println(N); } }
public static BigInteger factorial(long n) { BigInteger one = new BigInteger("1"); BigInteger zero = new BigInteger("0"); BigInteger m = new BigInteger((n - 1) + ""); BigInteger result = new BigInteger(n + ""); if (result.equals(one) || result.equals(zero)) { return one; } else { return result.multiply(factorial(n - 1)); } }
public RSA(Random random) { savedRandom = random; p = getPrime(random); // p and q are arbitrary large primes q = getPrime(random); n = p.multiply(q); phiN = (p.subtract(ONE)).multiply(q.subtract(ONE)); S = getPrime(random); // s is an arbitrary secret; we'll use a prime V = S.modPow(new BigInteger("2"), n); }
public static void main(String args[]) { Scanner cin = new Scanner(System.in); BigInteger a = BigInteger.ONE; int cas = 0; while (true) { cas++; a = cin.nextBigInteger(); if (a.compareTo(BigInteger.ZERO) == 0) break; long ans = calc(a); System.out.println("Case " + cas + ": Public Key = " + a + " Private Key = " + ans); } }
void solve(int caseNum) { int n = in.nextInt(); BigInteger[] past = new BigInteger[n], d = new BigInteger[n]; for (int i = 0; i < n; i++) past[i] = new BigInteger(in.next()); Arrays.sort(past); for (int i = 0; i < n; i++) d[i] = past[i].subtract(past[0]); for (int i = 2; i < n; i++) d[i] = d[i].gcd(d[i - 1]); BigInteger gcd = d[n - 1], mod = past[0].mod(gcd); System.out.printf("Case #%d: ", caseNum); if (mod.equals(BigInteger.ZERO)) System.out.println(0); else System.out.println(gcd.subtract(mod)); }
void work() { cin = new Scanner(System.in); int n = cin.nextInt(); BigInteger a = BigInteger.ONE; BigInteger b = BigInteger.ONE; n -= 1; for (int i = 0; i < n; i++) { BigInteger c = a.add(b); a = b; b = c; } System.out.println(b.toString()); }
public static void main(String[] args) { // Generics, varargs & boxing working together: List<Integer> li = Arrays.asList(1, 2, 3, 4, 5, 6, 7); Integer result = reduce(li, new IntegerAdder()); print(result); result = reduce(li, new IntegerSubtracter()); print(result); print(filter(li, new GreaterThan<Integer>(4))); print(forEach(li, new MultiplyingIntegerCollector()).result()); print( forEach(filter(li, new GreaterThan<Integer>(4)), new MultiplyingIntegerCollector()) .result()); MathContext mc = new MathContext(7); List<BigDecimal> lbd = Arrays.asList( new BigDecimal(1.1, mc), new BigDecimal(2.2, mc), new BigDecimal(3.3, mc), new BigDecimal(4.4, mc)); BigDecimal rbd = reduce(lbd, new BigDecimalAdder()); print(rbd); print(filter(lbd, new GreaterThan<BigDecimal>(new BigDecimal(3)))); // Use the prime-generation facility of BigInteger: List<BigInteger> lbi = new ArrayList<BigInteger>(); BigInteger bi = BigInteger.valueOf(11); for (int i = 0; i < 11; i++) { lbi.add(bi); bi = bi.nextProbablePrime(); } print(lbi); BigInteger rbi = reduce(lbi, new BigIntegerAdder()); print(rbi); // The sum of this list of primes is also prime: print(rbi.isProbablePrime(5)); List<AtomicLong> lal = Arrays.asList( new AtomicLong(11), new AtomicLong(47), new AtomicLong(74), new AtomicLong(133)); AtomicLong ral = reduce(lal, new AtomicLongAdder()); print(ral); print(transform(lbd, new BigDecimalUlp())); }
public static List range(BigInteger start, BigInteger end) { List l = new List(); long st = start.longValue(); long en = start.longValue(); if (BigInteger.valueOf(st).equals(start) && BigInteger.valueOf(en).equals(end)) { int dir = st < en ? 1 : -1; while (st != en) { l.add(BigInteger.valueOf(st)); st = st + dir; } } else { BigInteger dir; if (start.compareTo(end) < 0) { dir = BigInteger.ONE; } else { dir = BigInteger.valueOf(-1); } while (!start.equals(end)) { l.add(start); start = start.add(dir); } } return l; }
public static void main(String[] args) { Scanner cin = new Scanner(System.in); int Case = 0; int t = cin.nextInt(); while (t > 0) { t--; if (Case != 0) System.out.println(); ; BigInteger a = cin.nextBigInteger(); BigInteger b = cin.nextBigInteger(); System.out.println("Case " + (++Case) + ":"); System.out.println(a + " + " + b + " = " + a.add(b)); } }
public static void main(String args[]) { Scanner in = new Scanner(System.in); int T; BigInteger sum = new BigInteger("0"); BigInteger aux = new BigInteger("0"); T = in.nextInt(); for (int i = 0; i < T; i++) { aux = in.nextBigInteger(); sum = sum.add(aux); } System.out.println(sum); }