ProEuler_P13

package problems;

import java.util.*;
import java.io.*;
public class Problem_013 {

public static void main(String[] args) {
    int[][] digitArray = readFile("p13_data.txt");
    System.out.println(  digitArrayToString(  ( sumDigitArrays(digitArray)  ) ) );
}

public static int[] sumDigitArrays(int[][] inputArray){
    int arrayLength = inputArray.length;
    int[][] digitArray = inputArray;

    while(arrayLength > 2){ /* Reduce numbers to add down to 2. */
        int[][] sideKickArray = addArrays(digitArray);
        digitArray = sideKickArray;
        arrayLength = sideKickArray.length;
    }

    return sumArrays(digitArray); /* Sum last two numbers. */
}


/* This takes in a digit array containing x amount of numbers
 * and returns a digit array containing pair-sums.*/

public static int[][] addArrays(int[][] inArray){

    if(inArray.length % 2 != 0){
        Arrays.copyOf(inArray, inArray.length+1);
        int[] zeroArray = new int[inArray[0].length+10];
        inArray[inArray.length-1] = zeroArray;
    }

    int[][] outArray = new int[inArray.length/2][inArray[0].length];

    if(outArray.length % 2 != 0){
        outArray = Arrays.copyOf(outArray, outArray.length+1);
        int[] zeroArray = new int[outArray[0].length+10];
        outArray[outArray.length-1] = zeroArray;
    }

    int k = 0;

    for(int i = -2; i < inArray.length-2; i+=2){

        /* Create temp array to store result. */
        int[][] tempArray = new int[2][inArray[0].length];

        /* Inject data from input array into temp array. */
        tempArray[0] = inArray[i+2];
        tempArray[1] = inArray[i+3];

        /* Compute sum of numbers in temp array, inject to outarray at k.*/
        outArray[k] = sumArrays(tempArray);
        k++;
    }

        return outArray;
}

/* Takes two digits arrays and add them together, returning 1d digit array*/
public static int[] sumArrays(int[][] inputArray){

    /*Test if input array contains even amount of numbers, if not add zero number. */

    if(inputArray.length % 2 != 0){
        Arrays.copyOf(inputArray, inputArray.length+1);
        int[] zeroArray = new int[inputArray[0].length];
        inputArray[inputArray.length-1] = zeroArray;
    }

    /* Set input to array we compute on. Bleh. */
    int[][] numDigitArray = inputArray;

    /* Extending number by one digit, in case of "precision overflow". */
    for(int i = 0; i < numDigitArray.length; i++) {
        numDigitArray[i] = Arrays.copyOf(numDigitArray[i], numDigitArray[i].length+1);
    }

    /* Shifting digits to the right. */
    for(int i = 0; i < numDigitArray.length; i++) {
        numDigitArray[i] = shiftArray(numDigitArray[i]);
    }


    /* Initialize vars and arrays for computation. */

    int numDigits = numDigitArray[0].length;
    int[] carryDigit = new int[numDigits];
    int[] result = new int[numDigits];

    /* Add digits and detect carries. */
    for(int j = numDigits-1; j > 0; j--) {

        if(numDigitArray[0][j] + numDigitArray[1][j] >= 10) {
            result[j] = (numDigitArray[0][j] + numDigitArray[1][j])-10;
            carryDigit[j-1] += 1;
        } else {
            result[j] = numDigitArray[0][j] + numDigitArray[1][j];
        }
    }

    /* Add carries. */
    for(int r = numDigits-1; r >= 0; r--) {

        if(result[r] + carryDigit[r] < 10){
            result[r] += carryDigit[r];
        } else {
            carryDigit[r-1] += carryDigit[r];
            result[r] = 0;
        }
    } return result;

} /* End of sumArrays method. */

public static int[][] readFile(String filename){

    /* Reads a file with numbers on lines, returns a 2d array
     * with an array of digits of the numbers. */

    int index = 0;
    int lines = 100;

    File inputFile = new File(filename);
    String[] numbers = new String[lines];
    int[][] digits = new int[lines][50];

    try {

        Scanner readFile = new Scanner(inputFile);

        while(readFile.hasNext() && index < lines){
            numbers[index] = readFile.nextLine();
            index++;
        }

        for(int i = 0; i < numbers.length; i++){
            for(int j = 0; j < numbers[0].length(); j++){
                digits[i][j] = Character.getNumericValue(numbers[i].charAt(j));
            }
        }

    } catch (FileNotFoundException e) {
        System.out.println("Cant find file.");
    }

    return digits;

} // End of readFile method.

public static int[] shiftArray(int[] inArray){

    int lastElem = inArray[inArray.length-1];

    for(int i = 0; i < inArray.length-1; i++) {
        inArray[inArray.length-1-i] = inArray[inArray.length-2-i];
    }
        inArray[0] = lastElem;
    return inArray;

}

public static int[] stringToDigitArray(String input){

    int[] digits = new int[input.length()];

    for(int j = 0; j < digits.length; j++){
        digits[j] = Character.getNumericValue(input.charAt(j));
    }
    return digits;
}

public static String digitArrayToString(int[] inputArray){

    String output = "";

    for(int i = 0; i < inputArray.length; i++){
        output += inputArray[i];
    }
    return output.replaceFirst("^0*", ""); /* Get rid of leading zeros. */
}

}