Array Java Quotient

Question

So I need help I'm trying to calculate the quotient of all the elements inside an array. I only have 2 pairs of code but I don't know if they will work.

public static int yourFunction(ArrayList<Integer> list){
    String numbers = ""; // fill a string with your numbers

    for(Integer i : list){
        numbers += String.valueOf(i);
    } // could be nicer with java8 lambda function


    String tmp_numbers; // temporary string needed
    while(numbers.length() > 2){
        tmp_numbers = "";
        for(int i = 0; i < numbers.length()-1; ++i){
            // add two following numbers
            // substring to read digit by digit
            int v = Integer.parseInt(numbers.substring(i,i+1)); // first digit
                v += Integer.parseInt(numbers.substring(i+1,i+2)); // + second
            tmp_numbers = tmp_numbers + String.valueOf(v); // and fill the tmp string with it
        }
        numbers = tmp_numbers; // set the tmp string to our new beginning
    }
    return Integer.parseInt(numbers);
}

And this other code

public static int yourFunction(ArrayList<Integer> list){
    String numbers = ""; // fill a string with your numbers

    for(Integer i : list){
        numbers += String.valueOf(i);
    } // could be nicer with java8 lambda function


    String tmp_numbers; // temporary string needed
    while(numbers.length() > 2){
        tmp_numbers = "";
        for(int i = 0; i < numbers.length()-1; ++i){
            // add two following numbers
            // substring to read digit by digit
            int v = Integer.parseInt(numbers.substring(i,i+1)); // first digit
                v += Integer.parseInt(numbers.substring(i+1,i+2)); // + second
            tmp_numbers = tmp_numbers + String.valueOf(v); // and fill the tmp string with it
        }
        numbers = tmp_numbers; // set the tmp string to our new beginning
    }
    return Integer.parseInt(numbers);
}

Answer 1

I don't know what exactly you'r going to to. To give a specific answer, please specify what do you mean by making array quotient or better what is the code expected to do?

The first code looks a bit senseless for me. What you are doing is to take the first and second number in your string and you doing an addition of those two. After that you take the second number and doing an addition with the third number, and so on.

If your input is 12345 then your result will be:

Outer: 0, numbers: 12345
Inner: 0 i: 0, temp: 3
Inner: 1 i: 1, temp: 35
Inner: 2 i: 2, temp: 357
Inner: 3 i: 3, temp: 3579
tmp: 3579
Outer: 1, numbers: 3579
Inner: 0 i: 0, temp: 8
Inner: 1 i: 1, temp: 812
Inner: 2 i: 2, temp: 81216
tmp: 81216
Outer: 2, numbers: 81216
Inner: 0 i: 0, temp: 9
Inner: 1 i: 1, temp: 93
Inner: 2 i: 2, temp: 933
Inner: 3 i: 3, temp: 9337
tmp: 9337
Outer: 3, numbers: 9337
Inner: 0 i: 0, temp: 12
Inner: 1 i: 1, temp: 126
Inner: 2 i: 2, temp: 12610
tmp: 12610
Outer: 4, numbers: 12610
Inner: 0 i: 0, temp: 3
Inner: 1 i: 1, temp: 38
Inner: 2 i: 2, temp: 387
Inner: 3 i: 3, temp: 3871
tmp: 3871
Outer: 5, numbers: 3871
Inner: 0 i: 0, temp: 11
Inner: 1 i: 1, temp: 1115
Inner: 2 i: 2, temp: 11158
tmp: 11158
Outer: 6, numbers: 11158
Inner: 0 i: 0, temp: 2
Inner: 1 i: 1, temp: 22
Inner: 2 i: 2, temp: 226
Inner: 3 i: 3, temp: 22613
tmp: 22613
Outer: 7, numbers: 22613
Inner: 0 i: 0, temp: 4
Inner: 1 i: 1, temp: 48
Inner: 2 i: 2, temp: 487
Inner: 3 i: 3, temp: 4874
tmp: 4874
Outer: 8, numbers: 4874
Inner: 0 i: 0, temp: 12
Inner: 1 i: 1, temp: 1215
Inner: 2 i: 2, temp: 121511
tmp: 121511
Outer: 9, numbers: 121511
Inner: 0 i: 0, temp: 3
Inner: 1 i: 1, temp: 33
Inner: 2 i: 2, temp: 336
Inner: 3 i: 3, temp: 3366
Inner: 4 i: 4, temp: 33662
tmp: 33662
Result: 33662

//and so on until you'r out of ram cause it is growing.

If your input is above 2222... the tmp_number will infinitely grow or alternate.

As long as I can see your second example is exactly the first one, maybe a copy paste error?

The example you offer is quite interesting, but I don't know what you want to do.

Why do you translate list of int's in a string and then you do calculations with strings? That is memory intensive and worth nothing. If your aim is using really long numbers it is better to have a look at BigInteger: https://www.geeksforgeeks.org/biginteger-class-in-java/ and Byte Arrays https://www.hudatutorials.com/java/basics/java-arrays/java-byte-array.

Funny: if your input == "33333". The it will run forever since the values are alternating. 33333 -> 6666 -> 121212 -> 33333.

But if the code does what you want there might be a better solution (take a look). Proof for yourself:

package at.bluewest;

import java.util.ArrayList;
import java.util.List;

public class App 
{
    private static Boolean AVOID_DEBUG = false;

    public static void main( String[] args )
    {
        String number = "22222";
        old(convert(number));
        System.out.println("---------------------------------------------------------");
        better(number);
    }

    public static void old(List<Integer> list) {

        String numbers = "";

        for(Integer i : list){
            numbers += String.valueOf(i);
        } // could be nicer with java8 lambda function

        String tmp_numbers; // temporary string needed
        int outer_run = 0;
        while(numbers.length() > 2){
            System.out.println("Outer: " + outer_run++ + ", numbers: " + numbers);
            tmp_numbers = "";
            for(int i = 0, r =0; i < numbers.length()-1; ++i, r++){
                // add two following numbers
                // substring to read digit by digit
                int v = Integer.parseInt(numbers.substring(i,i+1)); // first digit
                v += Integer.parseInt(numbers.substring(i+1,i+2)); // + second
                tmp_numbers = tmp_numbers + String.valueOf(v); // and fill the tmp string with it
                System.out.println("Inner: " + r + ", i: " + i + ", temp: " + tmp_numbers);
            }

            System.out.println("After inner: " + tmp_numbers);
            numbers = tmp_numbers; // set the tmp string to our new beginning

            if(outer_run > Integer.MAX_VALUE -1) {
                break;
            }
        }
        System.out.println("Result: " + numbers);
    }

    public static void better(String number) {

        List<Integer> list = convert(number);

        int outer_run = 0;
        while(list.size() > 2){
            printDebug(list, "Outer: " + outer_run++ + ", numbers: ");
            List<Integer> next_numbers = new ArrayList<>();
            for(int i = 0, r =0; i < list.size()-1; ++i, r++){
                int first = list.get(i);
                int second = list.get(i+1);
                int result = first + second;

                //Handle two list elements
                if(result >= 10) {
                    next_numbers.add((int) (result / 10));
                    next_numbers.add(result % 10);
                } else {
                    next_numbers.add(result);
                }

                printDebug(next_numbers, "Inner: " + r + ", i: " + i + ", temp: " );
            }

            print(next_numbers, "Next Numbers Result: ");
            list = next_numbers;

            //Avoid invinite loop
            if(outer_run > Integer.MAX_VALUE -1) {
                break;
            }
        }
       print(list, "Final Result: ");
    }

    private static List<Integer> convert(String sNumber) {
        List<Integer> result = new ArrayList<>(sNumber.length());
        for(char s : sNumber.toCharArray()){
            result.add(s - '0');
        }

        print(result, "After Conversion: ");

        return result;
    }

    private static void print(List<Integer> numbers, String message) {

        System.out.print(message);
        for(Integer i : numbers){
            System.out.print(i);
        }
        System.out.println();
    }

    private static void printDebug(List<Integer> numbers, String message) {
        if(AVOID_DEBUG) {
            return;
        }
        print(numbers, message);
    }
}

So I hope this helped.