I am working on a program that needs to calculate the sum of 2 large integers without using the biginteger class in java. I am stuck on my for loop which calculates the sum. I am getting an extra 0 so 30 + 30 = 600.
I am pretty sure it is because I am looping through the arrays the wrong way. I need to go the opposite way (starting from the right side like you would when adding numbers) but I can't seem to fix it without getting an out of array index error.
here is my code:
main:
import java.util.Scanner;
public class testLargeInteger
{
public static void main(String[] args)
{
Scanner input = new Scanner(System.in);
String string1;
String string2;
int exp =0;
System.out.print("Enter the first integer: ");
//Store up the input string “string1” entered by the user from the keyboard.
string1 = input.next();
LargeInteger firstInt = new LargeInteger(string1);
System.out.print("Enter the second integer: ");
string2 = input.next();
//Store up the input string “string2” entered by the user from the keyboard.
LargeInteger secondInt = new LargeInteger(string2);
System.out.print("Enter the exponential integer: ");
//Store up the input integer “exp” entered by the user from the keyboard.
exp = input.nextInt();
LargeInteger sum = firstInt.add(secondInt);
System.out.printf ("First integer: %s \n", firstInt.display());
System.out.println("Second integer: " + secondInt.display());
System.out.println(" Exponent: " + exp);
System.out.printf (" Sum = %s \n", sum.display());
}
}
Large integer:
public class LargeInteger {
private int[] intArray;
//convert the strings to array
public LargeInteger(String s) {
intArray = new int[s.length()];
for (int i = 0; i < s.length(); i++) {
intArray[i] = Character.digit(s.charAt(i), 10); // in base 10
}
}
public LargeInteger( int[] array ) {
intArray = array;
}
//display the strings
public String display() {
String result="";
for (int i = 0; i < intArray.length; i++) {
result += intArray[i];
}
return result.toString();
}
//get first array
public int[] getIntArray() {
return intArray;
}
//ADD method to add 2 arrays together
public LargeInteger add(LargeInteger secondInt){
int[] otherValues = secondInt.getIntArray();
int maxIterations = Math.min(intArray.length, otherValues.length);
int currentResult; //to store result
int[] resultArray = new int[Math.max(intArray.length, otherValues.length) +1 ];
int needToAdd = 0; //to store result should be added next step
for(int i = 0; i < maxIterations; i++) {
currentResult = intArray[i] + otherValues[i];
resultArray[i] = currentResult % 10 + needToAdd; //if more than 9 its correct answer
needToAdd = currentResult / 10; //this is what you need to add on next step
}
resultArray[Math.max(intArray.length, otherValues.length) ] = needToAdd;
return new LargeInteger( resultArray );
}
}
I have tried changing the for loop in sum to something like this:
for(int i = maxIterations; i >= 0; i--)
That for loop is only one of your problems.
1] you are not adding the carry properly.
2] a stack is more appropriate here than an array.
With a stack (place code inside your method):
Note: You are calling the function with number.add(num2);
public class LargeInt{
private String number;
public LargeInt(String num){
this.number = num;
}
public String add(String num2){
Stack<Integer> adder = toIntegerStack(this.number);//UPDATE
Stack<Integer> addend = toIntegerStack(num2);//UPDATE
Stack<Integer> result = new Stack<Integer>();
int carry =0;
int tmp = 0;
while(!.adder.isEmpty && !addend.isEmpty()){
tmp = adder.pop()+addend.pop()+carry;
if(tmp > 10){
carry = tmp/10;
tmp%=10;
}else{
carry=0;
}
result.push(tmp);
}//while
while(!adder.isEmpty){
tmp = adder.pop()+carry;
if(tmp > 10){
carry = tmp/10;
tmp%=10;
}else{
carry=0;
}
result.push(tmp);
}//while
while(!addend.isEmpty){
tmp = addend.pop()+carry;
if(tmp > 10){
carry = tmp/10;
tmp%=10;
}else{
carry=0;
}
result.push(tmp);
}//while
//beyond this point the result is your answer
//here convert your stack to string before returning
}
}
UPDATE TO ANSWER COMMENT:
I am also editing above to call this function to fill stacks.
private Stack<Integer> toIntegerStack(String n){
Stack<Integer> stack = new Stack<Integer>();
for(char c: n.toCharArray())
stack.push(c-48);//ASCII
return stack;
}//toStack(String)
If you insist on using array, you must follow the same pattern with your array.
int indexA=0;
int indexB=0;
int[] result = new int[1+A.length>B.length?A.length:B.length];
int indexResult=result.length-1;
while(indexA < A.length && indexB <B.length){//inside is same idea
tmp = A[indexA++] + B[indexB++] + carry;
//... do here as for stacks for tmp and carry
result[indexResult--];
}
while(indexA < A.length){
//do as in stack version
}
while(indexB < B.length){
//do as in stack version
}
Your adding code assumes that the least significant digit is in array[0], but your reading code puts the most significant digit there. You should reverse the array after reading.
Related
I want to store non "h" values in an array. So to give you a background, I need to make a basic cash register that accepts 5 items in an array with a price on them. Nevertheless, some items will have HST(tax) included with them. To know which items have tax and which don't. The user will press h or H before or after entering the dollar amount. I have stored the values with the HST in an array, but how would I store the non-HST values?
NOTE: I tried doing it as the same as my "h" values, but it would not work that's why I am confused
I cannot use Arrayslist or any other array methods
Sample input:
4.565H
H2.3435
4.565h
5.234
5.6576h
Sample Output:
HST Values:
4.565
2.3435
4.565
5.6576
Non-HST Values
5.234
This is What I tried But it won't work:
// Import scanner class
import java.util.Scanner;
// Create class and method
class Main {
public static void main(String[] args) {
// Create scanner object and set scanner variables
Scanner inp = new Scanner(System.in);
System.out.println("Press any key to start");
String key = inp.nextLine();
System.out.println("\nEnter the amount of each item");
System.out.println("Upto 5 inputs are allowed!\n");
// Initialize counter and index variables to use it in the while loop
int counter = 0;
int index = 0;
int index2 = 0;
// Create a double array variable, and set the limit to 5
Double[] numbers = new Double[5];
Double[] numbers2 = new Double[5];
// Create a boolean variable to use it in the while loop
boolean go = true;
while (go) {
String value = inp.nextLine();
value = value.toLowerCase();
// Set the index value to "h" or "H"
int indexOfh = value.indexOf('h');
boolean containsh = indexOfh == 0 || indexOfh == (value.length() - 1);
if (containsh) { // Validate h at beginning or end
numbers[index] = Double.parseDouble(value.replace("h", ""));
index++;
System.out.println("HST will be taken account for this value");
}else{
numbers2[index2] = Double.parseDouble(value.replace("","")); // value.replace is an issue
}
counter++;
if (counter == 5) {
go = false;
}
}
System.out.println("\nHST Values:");
for (int i = 0; i < numbers.length; i++) {
// If there is any absence of values, print the HST values
if (numbers[i] != null) {
System.out.println(numbers[i]);
}
}
System.out.println("\nNon-HST Values:");
for (int x = 0; x < numbers2.length; x++){
if (numbers2[x] != null){
System.out.println(numbers2[x]);
}
}
}
}
Try this:
Things I changed:
numbers2[index2] = Double.parseDouble(value); // no need to replace anything here
index2++ , I see you increment index but not index2
When you print HST and non-HST value, you do not need to go till numbers.length or numbers2.length, because you know the values of index and index2, you already know the values in each array.
If you do this way then you do not need to do null check when you are printing.
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// Create scanner object and set scanner variables
Scanner inp = new Scanner(System.in);
System.out.println("Press any key to start");
String key = inp.nextLine();
System.out.println("\nEnter the amount of each item");
System.out.println("Upto 5 inputs are allowed!\n");
int counter = 0;
int index = 0;
int index2 = 0;
Double[] numbers = new Double[5];
Double[] numbers2 = new Double[5];
boolean go = true;
while (go) {
String value = inp.nextLine();
value = value.toLowerCase();
// Set the index value to "h" or "H"
int indexOfh = value.indexOf('h');
boolean containsh = indexOfh == 0 || indexOfh == (value.length() - 1);
if (containsh) { // Validate h at beginning or end
numbers[index] = Double.parseDouble(value.replace("h", ""));
index++;
System.out.println("HST will be taken account for this value");
} else {
numbers2[index2] = Double.parseDouble(value); // changed here
index2++; //added this line
}
counter++;
if (counter == 5) {
go = false;
}
}
System.out.println("\nHST Values:");
for (int i = 0; i < index; i++) { // changed here
// no need to do null check now
System.out.println(numbers[i]);
}
System.out.println("\nNon-HST Values:");
for (int x = 0; x < index2; x++) { // changed here
// no need to do null check now
System.out.println(numbers2[x]);
}
} }
The issue with the failed parsing of non-HST values is generally resolved in #Anon's answer above, however there are some other points to make code cleaner:
provide a constant instead of hardcoded length of arrays 5
remove redundant messages
improve logic, rename variables and remove redundant ones
improve handling of errors in user's input
use String matches method with a case-insensitive regexp to check if the item is HST or not
public static void main(String[] args) {
final int SIZE = 5;
// Create a double array variable, and set the limit
double[] hstItems = new double[SIZE];
double[] nonHstItems = new double[SIZE];
// Create scanner object and set scanner variables
Scanner inp = new Scanner(System.in);
System.out.printf("Enter up to %d HST or non-HST items%n", SIZE);
// Initialize counter and index variables to use it in the while loop
int counter = 0;
int hstCount = 0;
int nonHstCount = 0;
while (counter++ < SIZE) {
String value = inp.nextLine();
try {
if (value.matches("(?i)(h.+|.+h)")) {
hstItems[hstCount++] = Double.parseDouble(value.replaceAll("(?i)h", ""));
System.out.println("HST will be taken into account for this value");
} else {
nonHstItems[nonHstCount++] = Double.parseDouble(value);
System.out.println("No HST is taken into account for this value");
}
} catch (Exception ex) {
System.out.printf("Failed to parse value: %s, error: %s, please try again%n", value, ex.getMessage());
counter--;
}
}
System.out.println("\nHST Values:");
for (int i = 0; i < hstCount; i++) {
System.out.println(hstItems[i]);
}
System.out.println("\nNon-HST Values:");
for (int i = 0; i < nonHstCount; i++) {
System.out.println(nonHstItems[i]);
}
}
I have an application where you are supposed to enter 7 integers and then the application is supposed to tell you how many occurrences each number is put in.
Example: if I have 5 6 7 8 8 5 8, then it is supposed to come back that I have two 5's, one 6, one 7, and three 8's. All I'm getting out of it, however; is the first number i put in, in this case 5, and then it occurs 7 times. How do I fix this problem?
import java.util.Scanner;
public class U7A1_NumberCount {
public static void main(String[] args) {
final int MAX_INPUT_LENGTH = 7;
int[] inputArray = new int[MAX_INPUT_LENGTH];
System.out.print("Please, enter seven integers: ");
Scanner input = new Scanner(System.in);
int max = 0;
int nums = input.nextInt();
for(int n = 0; n < MAX_INPUT_LENGTH; n++) {
if(inputArray[n] > max) {
max = inputArray[n];
}
}
int[] count = new int[max + 1];
for(int n = 0; n < MAX_INPUT_LENGTH; n++) {
count[(inputArray[n])]++;
}
for(int n = 0; n < count.length; n++) {
if(count[n] > 0) {
System.out.println("The number " + nums + " occurs " + count[n] + " times.");
}
}
}
}
For input of the numbers, I would use something that can take many integers on a single line split by some delimiter. So basically, if the comma is the delimiter,
Scanner scan = new Scanner(System.in);
// some prompt here
List<Integer> intList = Stream.of(scan.nextLine().split(','))
.map(String::trim)
.map(Integer::new)
.collect(Collectors.toList());
Obviously, some more error handling could be useful (e.g. skipping things which cannot be parsed to an integer). You could also change your delimiter to be anything which is not a digit.
Then I would create a HashBag (for example, I will be using the implementation in Apache Commons Collections) and print the results with the bag's toString.
HashBag bag = new HashBag(intList);
System.out.println(bag.toString());
Or you could iterate through the HashBag to get and print the information you want.
Implementation of a HashBag-like object would be trivial: make a class backed with a HashMap<Object, Integer> and use some kind of adding method to call an Object#equals and if true, increment the value, and if false, create a new key with value 1.
Java is object oriented language, so use classess and objects to simplify your code. I would do it like that:
public class CountNumbers {
private Map<Integer,Integer> numbers = new HashMap<>();
public void addNumber(Integer number){
Integer howMany =numbers.get(number);
if( null != howMany){
howMany++;
}else{
howMany=1;
}
numbers.put(number,howMany);
}
public Map<Integer,Integer> getNumbers(){
return numbers;
}
}
public class Majn {
final static int MAX_INPUT_LENGTH = 7;
public static void main(String[] args) {
CountNumbers countNumbers = new CountNumbers();
System.out.print("Please, enter seven integers: ");
Scanner input = new Scanner(System.in);
for(int i = 0; i< MAX_INPUT_LENGTH; i++) {
int nums = input.nextInt();
countNumbers.addNumber(nums);
}
for(Integer number: countNumbers.getNumbers().keySet()){
System.out.format("The number %d occurs %d\n", number, countNumbers.getNumbers().get(number));
}
}
}
is the first number i put in, in this case 5, and then it occurs 7 times. How do I fix this problem?
You created an array to hold 7 integers, but you didn't utilise it. You only assigned value to another variable:
int nums = input.nextInt();
If you want to input all 7 inputs into the array, you can prompt the user n times:
for(int i=0; i<inputArray.length; i++)
inputArray[i] = input.nextInt(); //requires user to press enter 7 times
first at all, if you do not understand your code make it more readable ... this avoids a lot of problems simply in the beginning.
according to clean code of robert c. martin try to write down the code as you think about it. (https://de.wikipedia.org/wiki/Clean_Code)
here is one very reduced example to make it not to complicate
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
public class U7A1_NumberCount {
private static class NumberCount {
public NumberCount(final int number, final int amount) {
this.number = number;
this.amount = amount;
}
int amount;
int number;
}
public static void main(final String[] args) {
final int MAX_INPUT_LENGTH = 7;
final int[] userInput = readUserInput(MAX_INPUT_LENGTH);
final List<NumberCount> count = getNumberCount(userInput);
printResult(count);
}
private static NumberCount countSingleNumber(final int nr, final int[] userInput) {
int amount = 0;
for (int i = 0; i < userInput.length; i++) {
if (userInput[i] == nr) {
amount++;
}
}
return new NumberCount(nr, amount);
}
private static List<NumberCount> getNumberCount(final int[] userInput) {
final List<NumberCount> result = new LinkedList<>();
for (int i = 0; i < userInput.length; i++) {
final int nr = userInput[i];
if (isNumberNotConsideredYet(result, nr)) {
final NumberCount count = countSingleNumber(nr, userInput);
result.add(count);
}
}
return result;
}
private static int getUsersChoice(final Scanner scanner) {
System.out.print("Please, enter a number: ");
return scanner.nextInt();
}
private static boolean isNumberNotConsideredYet(final List<NumberCount> result, final int nr) {
return result.stream().noneMatch(count -> count.number == nr);
}
private static void printResult(final List<NumberCount> count) {
for (final NumberCount nr : count) {
System.out.println("The number " + nr.number + " occurs " + nr.amount + " times.");
}
}
private static int[] readUserInput(final int inputAmout) {
final Scanner scanner = new Scanner(System.in);
final int[] userInput = new int[inputAmout];
for (int i = 0; i < userInput.length; i++) {
userInput[i] = getUsersChoice(scanner);
}
scanner.close();
return userInput;
}
}
I can't figure out why is the array out of its borders, eclipes says the problem is at line 15
int d = array[1] - array[0];
import java.util.*;
public class Arrays1 {
static Scanner reader = new Scanner(System.in);
public static void main(String[] args) {
int N = reader.nextInt();
int[] array = new int[N];
boolean right = true;
for (int i=0; i<array.length; i++)
{
System.out.println("Enter number for array");
array[i] = reader.nextInt();
}
int d = array[1] - array[0];
if ((array[N]-1)%d !=0)
{
right = false;
}
}
}
You probably want something like that:
public class Main {
static Scanner reader = new Scanner(System.in);
public static void main(String[] args) {
int N = reader.nextInt();
int[] array = new int[N];
boolean right = true;
for (int i=0; i<array.length; i++)
{
System.out.println("Enter number for array");
array[i] = reader.nextInt();
}
int d = array[1] - array[0];
if ((array[N-1])%d !=0)
{
right = false;
}
}
}
Have a look at this part:
if ((array[N-1])%d !=0)
You were doing: if ((array[N]-1)%d !=0)
Btw, is aways a problem to trust the scan, you will need several validations.
Since you read the bounds of your array from the reader, it may be 0 or 1. To ensure it is big enough, you can try something like:
if(N > 1) {
int d = array[1] - array[0];
if ((array[N]-1)%d !=0)
{
right = false;
}
}
If it has to be bigger than 1 for you application to work, you could enforse this contraint right at the beginning:
int N = reader.nextInt();
if(N <= 1) {
System.out.println("N must be bigger than 1");
System.exit(1); // exit with error code
}
Try to validate the user input before you read your Array items, as the user may enter 1 for example when he is prompted for the array size thus there well be only one item in the array and accessing the item in second index (1 as it 0 based) will result in an ArrayOutOfBoundsException:
import java.util.*;
public class Arrays1 {
static Scanner reader = new Scanner(System.in);
public static void main(String[] args) {
int N = reader.nextInt();
while (N < 2) {
System.out.println("Enter a valid size for the array");
N = reader.nextInt();
}
int[] array = new int[N];
boolean right = true;
for (int i=0; i<array.length; i++)
{
System.out.println("Enter number for array");
array[i] = reader.nextInt();
}
int d = array[1] - array[0];
if ((array[N]-1)%d !=0)
{
right = false;
}
}
}
As a side note, pay attention to follow Java naming conventions as of the camelCase,so identifiers may begin with lowercase character not upper ones such as for int N which should be int n.
I am supposed to write a program that reads integers from a txt file in an IntegerType array. I have created an IntegerType class that implements my AnyType interface as you will see in the code. I am then supposed to sort the array and study how many comparisons and swaps were made during the sorting to study the efficiency, which I know is O(N^2). I have set breakpoints in my code which showed me that the integers are being read into my String[] numbers array. When I try to add them to my IntegerType arrays, it hits the the while (scan.hasNext()) line of code and completely skips over my for loop to add the integers into my array. Anyone have any advice on how to resolve this? Thanks for your time. Here is my code:
My Sorting class:
public class Sorting {
public static void main(String[] args) throws IOException {
int type, sort;
Scanner read = new Scanner(System.in);
//Ask user for data type of input
System.out.println("Make selection by typing corresponding integer value and pressing Enter.");
System.out.println("Select type of input:");
System.out.println("1 = Integer 2 = String");
type = read.nextInt();
//Ask user for sorting algorithm desired
System.out.println("Select sorting algorithm to be used:");
System.out.println("1 = Insertion 2 = Selection 3 = Bubble");
sort = read.nextInt();
//Read in integer values from generated .txt files into corresponding integer arrays
Scanner scan = new Scanner(new File("descending.txt"));
String line = scan.nextLine();
String[] numbers = line.split(" ");
IntegerType[] worstCase = new IntegerType[numbers.length];
while (scan.hasNext()) {
for (int i = 0; i < worstCase.length; i++) {
worstCase[i] = new IntegerType(scan.nextInt());
}
}
scan = new Scanner(new File("random.txt"));
line = scan.nextLine();
numbers = line.split(" ");
IntegerType[] avgCase = new IntegerType[numbers.length];
while (scan.hasNext()) {
for (int i = 0; i < numbers.length; i++) {
avgCase[i] = new IntegerType(scan.nextInt());
}
}
scan = new Scanner(new File("ascending.txt"));
line = scan.nextLine();
numbers = line.split(" ");
IntegerType[] bestCase = new IntegerType[numbers.length];
while (scan.hasNext()) {
for (int i = 0; i < numbers.length; i++) {
bestCase[i] = new IntegerType(scan.nextInt());
}
}
if ((type == 1 || type == 2) && (sort == 1)) //Insertion Ascending
{
System.out.println("Insertion Sort / Ascending / Worst Case");
Sort.insertionSort(worstCase, worstCase.length);
System.out.println("Insertion Sort / Ascending / Average Case");
Sort.insertionSort(avgCase, avgCase.length);
System.out.println("Insertion Sort / Ascending / Best Case");
Sort.insertionSort(bestCase, bestCase.length);
}
}
}
My Sort class:
public class Sort {
public static void insertionSort(AnyType[] list, int size) {
int compare = 0, swap = 0;
AnyType key;
for (int i = 1; i < size; i++) {
key = list[i];
int j = i - 1;
compare++;
if ((j > -1) && (list[j].isBetterThan(key))) {
list[j + 1] = list[j];
j--;
swap++;
}
list[j + 1] = key;
}
System.out.println("There were " + compare + " comparisons made.");
System.out.println("There were " + swap + " swaps made.");
}
}
My AnyType Interface
public interface AnyType {
public boolean isBetterThan(AnyType datum);
}
My IntegerType class
public class IntegerType implements AnyType {
private int number;
IntegerType() {
number = 0;
}
IntegerType(int i) {
number = i;
}
IntegerType(String s) {
number = Integer.parseInt(s);
}
public boolean isBetterThan(AnyType datum) {
return (this.number > ((IntegerType) datum).number);
}
public int toInteger() {
return number;
}
}
I guess the file consists of space seperated integer values in one line.
Anyway you should use the Scanner.hasNextInt() methode, for checking.
So the problem is here (see comments):
//Read in integer values from generated .txt files into corresponding integer arrays
Scanner scan = new Scanner(new File("descending.txt"));
String line = scan.nextLine(); //reads already the whole line
String[] numbers = line.split(" "); //now a string array with all the values
//there is nothing left, everything is already stored in "line"/"numbers" variables
while (scan.hasNext()) {
//something
}
Since you do not now in advance how many integer values there will be, you need a dynamic data structure for your IntegerType values (f.e. an ArrayList). Or you iterate over the number array and convert every string value to an int:
Scanner scan = new Scanner(new File("descending.txt"));
String line = scan.nextLine();
String[] numbers = line.split("\\s+");
IntegerType[] worstCase = new IntegerType[numbers.length];
for(int i = 0; i < numbers.length; ++i)
worstCase[i] = new IntegerType(numbers[i]); //will work because IntegerType has a constructor which accepts a string
}
One more comment for your Sort methodes: They do not need the length of the array as parameter, you can just use array.length (but this is just flavor i guess).
I need to make a program that adds long integers without using the biginteger class.
I am working on the add method now and I think I have it correct but I am stuck on returning the correct data type for my method and I'm not sure how to correct it.
Here are my 2 classes so far:
Main Class:
import java.util.Scanner;
public class testLargeInteger
{
public static void main(String[] args)
{
Scanner input = new Scanner(System.in);
String string1;
String string2;
int exp =0;
System.out.print("Enter the first integer: ");
//Store up the input string “string1” entered by the user from the keyboard.
string1 = input.next();
LargeInteger firstInt = new LargeInteger(string1);
System.out.print("Enter the second integer: ");
string2 = input.next();
//Store up the input string “string2” entered by the user from the keyboard.
LargeInteger secondInt = new LargeInteger(string2);
System.out.print("Enter the exponential integer: ");
//Store up the input integer “exp” entered by the user from the keyboard.
exp = input.nextInt();
LargeInteger sum = firstInt.add(secondInt);
System.out.printf ("First integer: %s \n", firstInt.display());
System.out.println("Second integer: " + secondInt.display());
System.out.println(" Exponent: " + exp);
System.out.printf (" Sum = %s \n", sum.display());
}
}
LargeInteger.class:
public class LargeInteger
{
private int[] intArray;
//convert the strings to array
public LargeInteger(String s)
{
intArray = new int[s.length()];
for (int i = 0; i < s.length(); i++)
intArray[i] = Character.digit(s.charAt(i), 10); // in base 10
}
//display the strings
public String display()
{
String result="";
for (int i = 0; i < intArray.length; i++)
result += intArray[i];
return result.toString();
}
//get first array
public int[] getIntArray()
{
return intArray;
}
public LargeInteger add(LargeInteger secondInt)
{
int[] otherValues = secondInt.getIntArray();
int maxIterations = Math.min(intArray.length, otherValues.length);
int currentResult; //to store result
int[] resultArray = new int[Math.max(intArray.length, otherValues.length) + 1];
int needToAdd = 0; //to store result should be added next step
for(int i = 0; i < maxIterations; i++)
{
currentResult = intArray[i] + otherValues[i];
resultArray[i] = currentResult % 10 + needToAdd; //if more than 9 its correct answer
needToAdd = currentResult / 10; //this is what you need to add on next step
}
resultArray[Math.max(intArray.length, otherValues.length) + 1] = needToAdd;
return resultArray;
}
}
You need a second LargeInteger constructor:
public LargeInteger( int[] array ) {
intArray = array
}
Then your method can return:
return new LargeInteger( resultArray );
Well first thing, your method add in LargeInteger is supposed to return a LargeInteger, but instead returns an array (int[]). You could fix this by adding a constructor for LargeInteger that takes in an int[] parameter (i.e. LargeInteger(int[] digitArray)). Then, in your add method you could simply do: return new LargeInteger(resultArray);.