Soy novato y no sé cómo combinar mis conocimientos. Tengo que hacer que Algorithm busque la secuencia ascendente de números más larga. Mi archivo tiene 50 columnas, cada columna tiene algunos números aleatorios separados con espacio.

Todavía estoy tratando de ponerlos en Matrix u otras matrices multidimensionales, pero no sé cómo.

Este es mi código:

import java.io.File;
import java.util.Scanner;
import java.util.StringTokenizer;

public class reading {

    public static void main(String[] args) {
        double[][] numbers = new double[101][101];
        int column = 0, row = 0;

        try {
            System.out.print("Enter the file name with extension : ");
            Scanner input = new Scanner(System.in);
            File file = new File(input.nextLine());
            input = new Scanner(file);

            for (int columns = 0; columns < 101; columns++) {
                String input2 = input.nextLine();
                StringTokenizer strToken = new StringTokenizer(input2);
                int count = strToken.countTokens();

                for (int rows = 0; rows < count; rows++) {
                    numbers[columns][rows] = Integer.parseInt((String) strToken.nextElement());// writing values to arrays
                    System.out.println(numbers[columns][rows]);// test 
                }
            }

            input.close();

        } catch (Exception ex) {
            ex.printStackTrace();
        }

        // here someday will be algorithm 

    }
}

** Lo siento chicos por mi pobre inglés. Estoy tratando de decir lo que quiero pero es un poco difícil para mí. :( Recibí un archivo con muchos números y tengo que encontrar la serie de números más larga, de menor a mayor sin reemplazar los números **

Pequeño ejemplo del archivo "

45-31-21-34 30-2 12 21-39-46-48 8 15 30 8-48 29 12 11-28 40 27 28-45 2 50 8 28 14 47-22-20 27 16 43-7 35 13 7 15 40-42 23-7 7 18 22 13 28-33-15-46 12-22 31-33 39 34-11 45-25 25-25 50 48 31-20-25-5 5 18-36 - 24-17 10 24 21-35 6 19 38 6 44 20 30-49-33-44 9 37-36-18 2-2 35-2 45-36 40 26-42-17 45 40-31-21 33 - 4-50 40 13-50 11 12 37-26 38-31 7 30 4 32-50-7-40-12 27 17-5-11 41-1 46 16 16 48 38-49 10 1 25 39 26-14 -50 "

0
Bestils 17 ene. 2018 a las 16:56

3 respuestas

La mejor respuesta

Si está intentando leer valores separados por espacios en blanco, la solución más fácil es probablemente usar Scanner.next o una de las otras funciones next... (que no sea nextLine, como Scanner.nextInt, o Scanner.nextDouble en su caso) .

Estas funciones usan espacios en blanco como delimitador, por lo que cada llamada posterior devolverá el siguiente fragmento de texto que se encuentre entre algunos espacios en blanco, y también lo convertirá al tipo apropiado, si corresponde.

input = new Scanner(file);

for (int rows = 0; rows < numbers.length; rows++){
   for (int columns = 0; columns < numbers[rows].length; columns++){
      numbers[rows][columns] = input.nextDouble(); 
   }
}

Si desea que cada línea del archivo sea una fila, el bucle rows debe estar en el exterior (considere que desea comenzar con la fila 0 y pasar por cada columna de la misma manera que comenzaría desde la línea 0 y pasar por cada valor en esa línea).


Esto no es particularmente robusto (si hay algo mal con sus datos, aún podría funcionar o podría ser difícil encontrar dónde está el problema).

Si está buscando algo más robusto, podría recomendar algo más como:

for (int rows = 0; rows < numbers.length; rows++){
   String[] split = input.nextLine().split("\\s+"); // \\s+ is 1 or more whitespace characters
   if (split.length != numbers.length) {
      throw new IllegalArgumentException("Line " + rows + " has " + split.length + " columns, but needs " + numbers.length);
   }
   for (int columns = 0; columns < numbers[rows].length; columns++){
      numbers[rows][columns] = Double.parseDouble(split[columns]);
   }
}

En Java 8 podemos lograr el mismo resultado así:

final int DESIRED_ROW_LENGTH = 101;
for (int rows = 0; rows < numbers.length; rows++){
   numbers[rows] = Arrays.stream(input.nextLine().split("\\s+"))
                       .mapToDouble(Double::parseDouble).toArray();
   if (numbers[rows].length != DESIRED_ROW_LENGTH) {
      throw new IllegalArgumentException("Line " + rows + " has " + numbers[rows].length + " columns, but needs " + DESIRED_ROW_LENGTH);
   }
}
2
Bernhard Barker 17 ene. 2018 a las 14:58

El algoritmo real ocurre en una matriz unidimensional de enteros. Entonces, esto podría hacerse por línea leída desde el archivo.

Path path = Paths.get(input.nextLine());
for (String line : Files.readAllLines(path, Charset.defaultCharset())) {

    // Convert line into numbers:
    String[] words = line.split(" ");
    int[] numbers = new int[words.length];
    for (int i = 0; i < numbers.length; ++i) {
        numbers[i] = Integer.parseInt(words[i]);
    }

    // Find longest sequence in numbers array:
    ...
}

Como otro código aquí usa File and Scanner, le he dado a Path (una alternativa más nueva para File), y Files una clase de utilidad que tiene métodos tan buenos como readAllLines.


Aunque no necesita una matriz, en general uno no usa el orden matemático típico, sino línea por línea (por filas):

 for (int row = 0; row < count; rows++) {
     ... read a line
     for (int column = 0; column < 101; column++) {
         numbers[row][column] = ...
         System.out.print(numbers[row][column] + " ");
     }
     System.println();
 }
0
Joop Eggen 17 ene. 2018 a las 14:37

Proporcionaré una alternativa * a la respuesta @Dukeling con la premisa de que en realidad estás buscando algún tipo de algoritmo para la secuencia de números en aumento más larga:

Básicamente, hágalo directamente mientras lee el archivo, y simplemente verifique cada posición de ((columna + 1) - (columna) == 1) y actualice un campo si es así.

File file = new File("\\\\share\\file\\path\\file.txt");
Scanner sc = new Scanner(file);
int totalCount = 0;
int tempCount = 0;
int tempLineNumber = 1;
int totalLineNumber = 0;
while (sc.hasNextLine()) {
    String[] array = sc.nextLine().split("\\s+");
    for (int i = 0; i < array.length - 1; i++) {
        if (Integer.parseInt(array[i + 1]) - Integer.parseInt(array[i]) == 1) {
            tempCount++;
        }
    }
    if (totalCount < tempCount) {
        totalCount = tempCount;
        totalLineNumber = tempLineNumber;
    }
    tempCount = 0;
    tempLineNumber++;
}
System.out.println("The max longest rising sequence of numbers is: "
        + totalCount + " at line " + totalLineNumber);

* Acabo de unir este ejemplo rápidamente, y lo más probable es que tenga un problema o dos, como faltar casos extremos, etc.

0
achAmháin 17 ene. 2018 a las 14:21
48302852