Develop Reference

Fastest way to calculate binomial coefficients in Java

I'm calculating binomial coefficients of arbitrary size using the following recursive function
private static final BigDecimal ZERO = new BigDecimal("0");
private static final BigDecimal ONE = new BigDecimal("1");
private static BigDecimal binomial(BigDecimal n, BigDecimal k) {
if(n.equals(k) || k.equals(ZERO))
return ONE;
else if(k.compareTo(ZERO) < 0)
return ZERO;
else
return binomial(n.subtract(ONE), k).add(binomial(n.subtract(ONE), k.subtract(ONE)));
}
For large numbers it gets really slow. Are there any simple and/or obvious optimizations to make? Not sure how much BigDecimals slows it down but making a custom class for large numbers seems like a lot of work.

You can do reasonably well while keeping the recursion (arithmetics on BigInteger are pretty unpleasant though):
public class Binomials {
private HashMap<Pair<BigInteger, BigInteger>, BigInteger> map = new HashMap();
public BigInteger binomial(int n, int k) {
return binomial(new Pair(valueOf(n), valueOf(k)));
}
public BigInteger binomial(Pair<BigInteger, BigInteger> x) {
if(x.getValue().equals(ZERO) || x.getKey().equals(x.getValue())) {
return ONE;
}
return map.computeIfAbsent(x, nk -> binomial(doP1(nk)).add(binomial(doP2(nk))));
}
private Pair<BigInteger, BigInteger> doP1(Pair<BigInteger, BigInteger> nk) {
return new Pair(nk.getKey().subtract(ONE), nk.getValue());
}
private Pair<BigInteger, BigInteger> doP2(Pair<BigInteger, BigInteger> nk) {
return new Pair(nk.getKey().subtract(ONE), nk.getValue().subtract(ONE));
}
public static void main(String[] args) {
System.out.println(new Binomials().binomial(8, 4)); // 70
}
}
In fact all the Pair and BigInteger shenanigans are noisy enough to obscure what is going on so here is the same approach in Kotlin:
fun BigInteger.plus(other: BigInteger): BigInteger = this.add(other)
fun BigInteger.minus(other: BigInteger): BigInteger = this.subtract(other)
object Binomial {
val map = mutableMapOf<Pair<BigInteger, BigInteger>, BigInteger>()
fun binomial(n: Int, k: Int): BigInteger =
binomial(Pair(n.toBigInteger(), k.toBigInteger()))
fun binomial(x: Pair<BigInteger, BigInteger>): BigInteger {
val (n, k) = x
if (k == ZERO || n == k) {
return ONE
}
return map.getOrPut(x) { binomial(Pair(n - ONE, k)) + binomial(Pair(n - ONE, k - ONE)) }
}
}
fun main() {
println(binomial(8, 4)) // 70
}

Recursion is usually much slower because all function calls must be stored in a stack to allow the return back to the caller functions. In many cases, memory has to be allocated and copied to implement scope isolation.
Try an iterative algorithm like that:
private static long binomial(int n, int k)
{
if (k>n-k)
k=n-k;
long b=1;
for (int i=1, m=n; i<=k; i++, m--)
b=b*m/i;
return b;
}

What size does of stack does java -xss16M allocate 16 MegaBytes or 16Megabits

I am attempting to prove that I am using tail recursion properly by restricting the size allocated to the thread stack using the java -Xss160M command. I am writing a simple tail recursion algorithm for finding the factorial of a really big numbers:
/*
*
*my Program
*
*/
import java.math.BigInteger;
public class TailFactorial {
private BigInteger factorial(BigInteger n, BigInteger acc) {
if (n.equals(BigInteger.ONE)) return acc;
else return factorial(n.subtract(BigInteger.ONE), n.multiply(acc));
}
public static void main(String[] args) {
// TODO Auto-generated method stub
TailFactorial classs = new TailFactorial();
int num;
BigInteger bigNum = BigInteger.ONE;
boolean gTG = false;
String finalNumString = "";
String msg = "";
try {
num = Integer.parseInt(args[0]);
bigNum = BigInteger.valueOf(num);
msg = "fact("+String.valueOf(num)+") = ";
gTG = true;
}catch(Exception e) {
System.out.println("Could not get arguments, please make sure you are passing an integer");
gTG = false;
}
try {
if(gTG) {
BigInteger finalNum = classs.factorial(bigNum ,BigInteger.ONE);
System.out.println(String.valueOf(finalNum.bitCount()));
finalNumString = finalNum.toString();
//System.out.println( msg + finalNumString);
}
else {
System.out.print("Exiting");
}
}catch(StackOverflowError e) {
System.out.print("Not enough memory allocated to stack, try exicuting with java -Xss$bigger memory inserted here$ TrailFactorial");
}
catch(Exception e) {
System.out.print("Unrecoginzed error in finding factorial");
}
}
}
The code runs just fine, but I have to allocate 50M to the stack. When I run the current program, it displays the bit count of the result. When I find the factorial of one-hundred-thousand the bit count is 708,218, and I still have to use 50M. Can someone explain to me the meaning of the M? is it megabytes or bits? Am I not implementing tail-recursion properly?

As noted; Java doesn't support tail call recursion optimisation so for a large n value you will always run out of stack.
I suggest you use a simple loop if you want to avoid this.
public static BigInteger factorial(int n) {
BigInteger acc = BigInteger.ONE;
for (int i = 2; i <= n; i++)
acc = acc.multiply(BigInteger.valueOf(i));
return acc;
}
If you really, really want to use recursion, you can use divide and conquer
public static BigInteger factorial(int n) {
return product(1, n);
}
public static BigInteger product(int from, int to) {
if (from == to) return BigInteger.valueOf(from);
int mid = (from + to) >>> 1;
return product(from, mid).multiply(product(mid + 1, to));
}
This has a stack depth of log2(n) or a maximum of ~32.
BTW The following code
System.out.println(String.valueOf(finalNum.bitCount()));
finalNumString = finalNum.toString();
System.out.println( msg + finalNumString);
is the same as
System.out.println(finalNum.bitCount());
System.out.println(msg + finalNum);

I want to write a program which reverses all the integers entered in an array

I want to write a program which reverses all the integers entered in an array but my code displayed here isn't working properly. Here is my code:
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
public static void main (String[] args) throws Exception {
//code
Scanner ss=new Scanner(System.in);
int[] arr = new int[31];
int T=ss.nextInt();
int rem,p=0;
for(int i=1;i<=T;i++){
int a=ss.nextInt();
if(a<=1000000000){
while(a!=0){
rem=a%10;
p=p*10+rem;
a=a/10;
}
System.out.println(p);
} else
System.out.println("wrong input");
}
}
}
input:
2
56
78
expected output:
65
87
actual output:
65
6578
What is wrong?

Possible solution could be
if(a<=1000000000){
p=0; // reinitialize p
while(a!=0){
rem=a%10;
p=p*10+rem;
a=a/10;
}
For better understanding just add this line System.out.println("P is :"+ p); in if and you will see why p=0; was required.
if(a<=1000000000){
System.out.println("P is :"+ p);
while(a!=0){
rem=a%10;
p=p*10+rem;
a=a/10;
}
OutPut:
2
65
P is :0
56
78
P is :56
5687

There are couple of mistakes in your code (arguably), if reviewed by peer. You are trying to print p, which is not being re-initialized. Lot of unused variables in your code are removed in this answer.
You just declared an array, but never used in your program. Not sure whether you wanted to store the user inputs in the array and once all the inputs are received, you might want to compute the reverse and display or compute the reverse and store them in your array directly. So, I just removed it
The check a <= 1000000000 I believe is to ensure that values entered are within int range. Java provides you a constant for this in Integer wrapper class, Integer.MAX_VALUE (which is 2^31 - 1)
The code was lacking modularity. Hence, I extracted it to the method reverse(int num) which takes care of computation
Importing all classes from the package is not recommended, rather import only those classes that are used in your code.
import java.util.Scanner;
public class GFG {
public static void main(String[] args) throws Exception {
Scanner ss = new Scanner(System.in);
int T = ss.nextInt();
for (int i = 1; i <= T; i++) {
int a = ss.nextInt();
if (a <= Integer.MAX_VALUE) {
a = reverse(a);
System.out.println(a);
} else {
System.out.println("wrong input");
}
}
}
private static int reverse(int num) {
int reverse = 0;
while( num != 0 ) {
reverse = reverse * 10;
reverse = reverse + num % 10;
num = num/10;
}
return reverse;
}
}
On a side note, if you look at GhostCat's answer of converting the number to String and reversing it, the approach fails for negative numbers.
Example: When user input is -51, the output would be 15-
However, it is common practice in industry to store certain long values as String. One such example is credit/debit card numbers

Probably you are just learning how to do things; thus you want to solve this problem "mathematically", but there is a different perspective in here.
It seems that you simply want to reverse the digits within any number; and you treat this as mathematical problem. But one can see this as string manipulation problem; which allows you to use existing functions to solve the problem:
int originalNumber = ....
String originalNumberAsString = Integer.toString(originalNumber);
String reversedNumberAsString = new StringBuilder(originalNumberAsString).reverse().toString();
int reversedNumber = Integer.parseInt(reversedNumberAsString);
Please note: there is also no need to check for the size of your input here; but you probably should check for >=0 (or do what is appropriate in your case for negative numbers).

NumberFormatException while trying to print reverse of 32 bit binary number

I am trying to print reverse of a 32 bit binary number in decimal format:
Example:
x = 3,
00000000000000000000000000000011
=> 11000000000000000000000000000000
return 3221225472
I am getting a number format exception, can anyone please help me whats wrong in my code? I appreciate your help.
public class ReverseBinary {
public long reverse(long a) {
String s1 = String.format("%32s", Long.toBinaryString(a)).replace(' ', '0');
StringBuilder sb = new StringBuilder(s1);
String s = sb.reverse().toString();
long c = Integer.parseInt(s, 2);
return c;
}
public static void main(String args[]) {
ReverseBinary rb = new ReverseBinary();
long ans = rb.reverse(3);
System.out.println(ans);
}
}

Your variable c might be a long variable, but the value delivered by Integer.parseInt(s,2) is still an integer. This call tries to parse an integer value which causes problems, because the value is obviously out of the integer range.
Simply replace Integer.parseInt(s,2) by Long.parseLong(s, 2).

It should be
long c= Long.parseLong(s,2);

Just in case you want the signed integer that corresponds to the reversed bit pattern: there is a method to just do that.
public class Test
{
public static void main (String[] args)
{
// 000...001 -> 100...000, interpret as two's complement 32bit int
int reversed = Integer.reverse(0b0_00000000_00000000_00000000_00000001);
System.out.println(reversed == Integer.MIN_VALUE); // -> true
}
}

Java: Summing all digits of 2^1000

I'm trying to solve Project Euler problem #16, where I need to sum all the digits of 2^1000. I've gotten stuck dealing with such a big number. My program worked for any number below 10^16, but failed afterwards. This told me that my logic was correct. I went ahead and converted all variables and methods to BigDecimal, but now the program does not run properly. It compiles as it is and there is no error; it just does not terminate. Does anyone have an idea on where I went wrong here?
import java.math.BigDecimal;
import java.math.RoundingMode;
public class Powerdigitsum {
private static final BigDecimal one = new BigDecimal("1");
private static final BigDecimal ten = new BigDecimal("10");
private static BigDecimal sumofDigits(BigDecimal n){
BigDecimal sum = new BigDecimal("0");
while(n.compareTo(one) == 1 || n.compareTo(one) == 0){
sum.add(n.remainder(ten));
n.divide(ten);
n = n.setScale(0, RoundingMode.FLOOR);
}
return sum;
}
public static void main(String[] args) {
final double the_number = Math.pow(2,1000);
final double test = 15;
final BigDecimal two_to_the_thousandth_power = new BigDecimal(test);
System.out.println(sumofDigits(two_to_the_thousandth_power));
}
}

Just use BigInteger properly:
BigInteger a = new BigInteger("2").pow(1000);

The whole method is kinda wrong. See this:
private static BigInteger sumOfDigits(BigInteger n) {
BigInteger sum = BigInteger.ZERO;
while (n.compareTo(BigInteger.ZERO) == 1) {
sum = sum.add(n.remainder(ten));
n = n.divide(ten);
}
return sum;
}
You needed to compare to zero, not one. And you need to assign the values for BigIntegers and BigDecimals, their methods do nothing on their own, the instances of those classes are immutable.
For integers, it's generally better to use BigInteger. The decimal part (that gets there from dividing) is just thrown away.

final double the_number = Math.pow(2,1000);
This won't work because the_number is not large enought to take the result. You need to convert the pow call to BigInteger:
BigInteger result = new BigInteger("2").pow(1000);
But be aware.. this can take some time..

Don't use the BigDecimal(double) constructor: it is limited by the double primitive type, which cannot represent 2^1000.
You can use a BigInteger. Something along these lines should work (probably suboptimal, but...):
public static void main(final String... args)
{
// 2^1000
final BigInteger oneTo2000 = BigInteger.ONE.shiftLeft(1000);
BigInteger digitSum = BigInteger.ZERO;
// We don't want to split against the empty string, the first element would be ""
for (final String digit: oneTo2000.toString().split("(?<=.)"))
digitSum = digitSum.add(new BigInteger(digit));
System.out.println(digitSum);
}

public class SumofDigitsPow {
public static void main(String[] args) {
//2(2^1000)
String temp = BigInteger.ONE.shiftLeft(1000).toString();
int sum = 0;
for(int i=0;i<temp.length();i++){
sum+= temp.charAt(i) - '0';
}
System.out.println(Integer.toString(sum));
}
}
java.math.BigInteger.shiftLeft(int n) method returns a BigInteger whose value is (this << n),So you can get the answer by using BigInteger and LeftShift Method

import java.math.BigInteger;
public class Problem16 {
public static void main(String[] args) {
BigInteger number2 = new BigInteger("2");
BigInteger number3 = new BigInteger("0");
number3 =number2.pow(1000);
String str = number3.toString();
BigInteger sum = new BigInteger("0");
for(int i=0; i<str.length(); i++)
{
char c= str.charAt(i);
int value = Character.getNumericValue(c);
BigInteger value2 = new BigInteger(Integer.toString(value));
sum =sum.add(value2) ;
}
System.out.println(sum);
}
}

IF YOU THINK BIGINTEGER IS CHEATING AND/OR don't feel like using it/learning how to use it, this algorithm is the way to go.
Think about how you would calculate 2^1000 by hand. You'd start with 2^1 and multiply by two repeatedly. Now notice that the number of digits of powers of two increase by 1 for AT LEAST every 3 powers (could be after 4 powers like with 1024 to 8192). So make a jagged 2D array like this
int a[][]= new int[1000][];
for(int i=0;i<1000;i++)
{
a[i]= new int[1+(i/3)];
}
Then initialize a[0][0] to 2. After this, you want to write a for loop such that each row is filled from the rightmost spot. So make two variables "digit" and "carry". Digit is the number that you will input into the row you're working on, and the carry is the one you're going to take to the next calculation and add to the product of 2 and whatever digit you're multiplying it with. Be careful with the order you update digit and carry and reinitialize them to zero after every calculation. I think the hardest part is coming up with the limits for the for loop, so that it fits with the every 3 powers thing. You can make this simpler by just making a triangular jagged array that increments by one every row. I did it like this though. Here's my whole code.
import java.util.*;
public class ProjectEuler16
{
public static void main(String[] args)
{
long t1=System.currentTimeMillis();
ProjectEuler16 obj = new ProjectEuler16();
System.out.println(obj.bigNumHandler());
long t2= System.currentTimeMillis();
System.out.println(t2-t1);
}
int bigNumHandler()
{
int a[][] = new int[1000][];
for(int i=0;i<1000;i++)
{
a[i]= new int[1+(i/3)];
}
a[0][0]=2;
for(int i=1;i<1000;i++)
{
int carry=0;
int digit=0;
int f=0;
if(i%3==0)
{
f=1;
}
for(int j=a[i-1].length-1+f;j>=0;j--)
{
if(j==0&f==1)
{
a[i][0]=carry;
}
else
{
digit=((2*a[i-1][j-f])+carry)%10;
carry=((2*a[i-1][j-f])+carry)/10;
a[i][j]=digit;
}
}
}
int sum=0;
for(int k=0;k<a[999].length;k++)
{
sum=sum+a[999][k];
}
return sum;
}
}
Note that the last row lists the digits for 2^1000.I think you can figure out how to sum the digits. The program took about 5 seconds to come up with the answer.

solution::::
import java.math.BigInteger;
public class PR9 {
/**
* #param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
BigInteger zero=BigInteger.valueOf(0);
BigInteger ten=BigInteger.valueOf(10);
BigInteger sum=zero;
BigInteger a = new BigInteger("2").pow(1000);
while(a.compareTo(zero)>0){
sum=sum.add(a.mod(ten));
a=a.divide(ten);
}
System.out.println(sum);
}
}
output:::::
1366

import java.math.BigInteger;
public class P16 {
public static BigInteger digitSum(int n) {
BigInteger sum = BigInteger.ZERO;
BigInteger number = new BigInteger("2").pow(n);
while (number.compareTo(BigInteger.ZERO) == 1) {
BigInteger remainder = number.remainder(BigInteger.TEN);
sum = sum.add(remainder);
number = number.divide(BigInteger.TEN);
}
return sum;
}
public static void main(String[] args) {
final double START = System.nanoTime();
System.out.println(digitSum(Integer.parseInt(args[0])));
final double DURATION = System.nanoTime() - START;
System.out.println("Duration: " + DURATION / 1000000 + "ms.");
}
}
While there maybe a way of solving this problem without the use of BigIntegers, it is clear that they make the code run way faster.
Mine only took about 4ms to find an answer.