Java 大数

How Many Fibs?

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 6641    Accepted Submission(s): 2629

Problem Description

Recall the definition of the Fibonacci numbers:
f1 := 1
f2 := 2
fn := fn-1 + fn-2 (n >= 3)

Given two numbers a and b, calculate how many Fibonacci numbers are in the range [a, b].

 

Input

The
input contains several test cases. Each test case consists of two
non-negative integer numbers a and b. Input is terminated by a = b = 0.
Otherwise, a <= b <= 10^100. The numbers a and b are given with no
superfluous leading zeros.

 

Output

For each test case output on a single line the number of Fibonacci numbers fi with a <= fi <= b.

 

Sample Input

10 100

1234567890 9876543210

0 0

 

Sample Output

5

4

import java.util.*;
import java.io.*;
import java.math.*;
public class Main
{
    static Scanner cin=new Scanner(System.in);
    static PrintWriter cout=new PrintWriter(System.out,true);
    public static void main(String[] args)
    {
        BigInteger a[]=new BigInteger[1010],n,m;
        a[1]=BigInteger.ONE;
        a[2]=BigInteger.valueOf(2);
        for(int i=3;i<=1008;i++)
        {
            a[i]=a[i-1].add(a[i-2]);
        }
        while(cin.hasNext())
        {
            int ans=0;
            n=cin.nextBigInteger();
            m=cin.nextBigInteger();
            if(n.compareTo(BigInteger.ZERO)==0 && m.compareTo(BigInteger.ZERO)==0) return;
            if(n.compareTo(m)>0) {BigInteger t=n;n=m;m=t;}
            for(int i=1;i<=1008;i++)
            {
                if(a[i].compareTo(n)>=0 && a[i].compareTo(m)<=0) ans++;
            }
            cout.println(ans);
        }
    }
}

Integer Inquiry

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 20693    Accepted Submission(s): 5500

Problem Description

One
of the first users of BIT's new supercomputer was Chip Diller. He
extended his exploration of powers of 3 to go from 0 to 333 and he
explored taking various sums of those numbers.
``This supercomputer
is great,'' remarked Chip. ``I only wish Timothy were here to see these
results.'' (Chip moved to a new apartment, once one became available on
the third floor of the Lemon Sky apartments on Third Street.)

 

Input

The
input will consist of at most 100 lines of text, each of which contains
a single VeryLongInteger. Each VeryLongInteger will be 100 or fewer
characters in length, and will only contain digits (no VeryLongInteger
will be negative).

The final input line will contain a single zero on a line by itself.

 

Output

Your program should output the sum of the VeryLongIntegers given in the input.

This problem contains multiple test cases!

The
first line of a multiple input is an integer N, then a blank line
followed by N input blocks. Each input block is in the format indicated
in the problem description. There is a blank line between input blocks.

The output format consists of N output blocks. There is a blank line between output blocks.

 

Sample Input

1

123456789012345678901234567890

123456789012345678901234567890

123456789012345678901234567890

0

 

Sample Output

370370367037037036703703703670

import java.util.*;
import java.io.*;
import java.math.*;
public class Main
{
    static Scanner cin=new Scanner(System.in);
    static PrintWriter cout=new PrintWriter(System.out,true);
    public static void main(String[] args)
    {
        int n=cin.nextInt();
        while((n--)!=0)
        {
            BigInteger b=BigInteger.ZERO;
            BigInteger a=cin.nextBigInteger();
            BigInteger ans=BigInteger.ZERO;
            while(a.compareTo(b)>0)
            {
                ans=ans.add(a);
                a=cin.nextBigInteger();
            }
            cout.println(ans.toString());
            if(n!=0) cout.println();
        }
    }
}

Exponentiation

Time Limit: 2000/500 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 9667    Accepted Submission(s): 2873

Problem Description

Problems
involving the computation of exact values of very large magnitude and
precision are common. For example, the computation of the national debt
is a taxing experience for many computer systems.

This problem requires that you write a program to compute the exact value of Rⁿ where R is a real number ( 0.0 < R < 99.999 ) and n is an integer such that 0 < n <= 25.

 

Input

The
input will consist of a set of pairs of values for R and n. The R value
will occupy columns 1 through 6, and the n value will be in columns 8
and 9.

 

Output

The
output will consist of one line for each line of input giving the exact
value of R^n. Leading zeros should be suppressed in the output.
Insignificant trailing zeros must not be printed. Don't print the
decimal point if the result is an integer.

 

Sample Input

95.123 12

0.4321 20

5.1234 15

6.7592 9

98.999 10

1.0100 12

 

Sample Output

548815620517731830194541.899025343415715973535967221869852721
.00000005148554641076956121994511276767154838481760200726351203835429763013462401
43992025569.928573701266488041146654993318703707511666295476720493953024
29448126.764121021618164430206909037173276672
90429072743629540498.107596019456651774561044010001
1.126825030131969720661201

import java.util.*;
import java.io.*;
import java.math.*;
public class Main
{
    static Scanner cin=new Scanner(System.in);
    static PrintWriter cout=new PrintWriter(System.out,true);
    public static void main(String[] args)
    {
        BigDecimal a,c;
        int b;
        while(cin.hasNext())
        {
            a=cin.nextBigDecimal();
            b=cin.nextInt();
            c=a.pow(b);
            String ans=c.toPlainString();
            if(ans.contains(".")==false)
            {
                cout.println(ans);
            }
            else
            {
                int x=0,y=ans.length()-1;
                while(ans.charAt(x)=='0') x++;
                while(ans.charAt(y)=='0') y--;
                if(ans.charAt(y)!='.')y++;
                cout.println(ans.substring(x,y));
            }
        }
    }
}

N!

Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 262144/262144 K (Java/Others)
Total Submission(s): 83284    Accepted Submission(s): 24514

Problem Description

Given an integer N(0 ≤ N ≤ 10000), your task is to calculate N!

 

Input

One N in one line, process to the end of file.

 

Output

For each N, output N! in one line.

 

Sample Input

1

2

3

Sample Output

1

2

6

import java.util.*;
import java.io.*;
import java.math.*;
public class Main
{
    static Scanner cin=new Scanner(System.in);
    static PrintWriter cout=new PrintWriter(System.out,true);
    public static void main(String[] args)
    {
        int n;
        while(cin.hasNext())
        {
            n=cin.nextInt();
            BigInteger a=BigInteger.valueOf(n);
            BigInteger b=BigInteger.ONE;
            BigInteger c=BigInteger.ONE;
            for(BigInteger i=BigInteger.ONE;i.compareTo(a)<=0;i=i.add(b))
            {
                c=c.multiply(i);
            }
            cout.println(c);
        }
    }
}