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 "
3 respuestas
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);
}
}
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();
}
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.
Preguntas relacionadas
Nuevas preguntas
java
Java es un lenguaje de programación de alto nivel. Utilice esta etiqueta cuando tenga problemas para usar o comprender el idioma en sí. Esta etiqueta rara vez se usa sola y se usa con mayor frecuencia junto con [spring], [spring-boot], [jakarta-ee], [android], [javafx], [hadoop], [gradle] y [maven].