Cornell net id ____ ___ Name (last n ame in ALL CAPS ) _________________________________________
1
CS 1110 Prelim 3 Grades expected to be on the CMS late tonight 14 April 2009
This 90-minute exam has 6 questions (numbered 0..5) worth a total of 100 points. Spend a few minutes
looking at all the questions before beginning. Use the back of the pages if you need more space.
Question 0 (2 points). Fill in your netID and name, legibly, at the top of each page. (Hint: do it now.)
The questions in this exam deal with class BigInt, which implements integers of any size. Type int
has the range -231..231-1, and type long has the range -263..263-1, but some applications require larger
numbers. For example, consider looking for large prime numbers. In 1752, Euler used clever reasoning to
show that 231-1 was prime. In 1876, Lucas showed that 2127-1, which has 39 digits, is prime. But since the
advent of computers, much larger primes have been found. The longest one so far, 12,978,189 digits
long(!), was found in 2008. How does one calculate such things when the basic types int and long are
so restricted? One way is to write a class each instance of which contains an arbitrarily large integer.
We give below the specification of class BigInt, showing many but not all of its methods. For ex-
ample, we show a method to add two BigInts together but no methods for subtracting, multiplying, etc.
You will be asked to write some of these methods. Later in the course, we’ll show how this can be made
far more efficient by allowing larger numbers in each array element numb[i].
Note that there is a constructor for making a BigInt out of an int, but if you add or multiply many
such BigInts together, you may get an integer that is far too big to be in the range of int or even
long. So, we really need methods for adding, subtracting, and multiplying BigInts together.
/** An instance maintains an integer,
which can be any size. */
public class BigInt {
/* -1 or 1, depending on whether this
integer is negative or non-negative. */
private int sign;
/* the digits of the absolute value of the integer are
numb[0..numb.length-1]
with the least significant digit first.
E.g. the integer 3124 is stored as {4, 2, 1, 3}.
numb.length = number of digits in the integer
with no leading 0’s (0 for integer 0). */
private int[] numb;
/** Constructor: an instance with value 0. */
public BigInt()
/** Constructor: an instance for integer n. */
public BigInt(int n)
/** = number of digits for n, with no leading 0’s. */
public static int length(int n)
/** = this integer, as a string. */
public String toString()
/** = "b is a BigInt and contains the same
integer as this one." */
public boolean equals(Object b)
/** = 1, 0, or -1 depending on whether this
BigInt is greater than, equal to, or less than b. */
public int compareTo(BigInt b)
/** = 1, 0, or -1 depending on whether the
absolute value of this BigInt is
>, =, or < b. */
private int compareAbs(BigInt b)
/** = the sum of x and y.
Precondition: x and y are non-negative. */
public static BigInt add(BigInt x, BigInt y)
/** = – x. */
public static BigInt negate(BigInt x)
/** = index of minimum of b[h..k].
Precondition: h <= k.*/
public static int min(BigInt[] b, int h, int k)
/** Sort array b, using selection sort. */
public static void sort(BigInt[] b)
}
