Lectura eficiente de entradas para programación competitiva con Java 8

Como todos sabemos, al resolver cualquier problema de CP, el primer paso es recopilar o leer la entrada. Un error común que todos cometemos es pasar demasiado tiempo escribiendo código y compilando también. En Java, se recomienda usar BufferedReader en lugar de Scanner para aceptar la entrada del usuario. ¿Por qué? Se discute en uno de nuestros artículos anteriores aquí. (Además, los problemas asociados con java.util.Scanner están disponibles). Sin embargo, para una mejor comprensión, revisaremos ambas implementaciones en este artículo.

Formas de leer entradas 

• Usando la clase de escáner
• Usando la clase BufferedReader
• Uso de la clase BufferedReader con ayuda de flujos (Más optimizado)

Ahora analicemos formas de leer individualmente en profundidad proporcionando programas java limpios y percibiendo la salida generada a partir de la entrada personalizada. 

Forma 1: lectura de entrada de escáner simple

La clase java.util.Scanner proporciona métodos integrados para leer datos primitivos de la consola junto con las líneas de texto. En el siguiente fragmento de código, comprendamos cómo se hace.

Ejemplo

// Java Program Illustrating Reading Input
// Using Scanner class
  
// Importing Arrays and Scanner class
// from java.util package
import java.util.Arrays;
import java.util.Scanner;
  
// Main class
class GFG {
  
    // Main driver method
    public static void main(String[] args)
    {
        // Creating object of Scanner class
        Scanner scan = new Scanner(System.in);
  
        // Basic Input Reading
        int a = scan.nextInt();
        float b = scan.nextFloat();
  
        System.out.println("Integer value: " + a);
        System.out.println("Float value: " + b);
  
        // Space Separated Input Reading
        int[] arr = new int[5];
  
        for (int i = 0; i < arr.length; i++) {
            arr[i] = scan.nextInt();
        }
  
        System.out.println(Arrays.toString(arr));
    }
}

Producción:

De la salida del shell de Linux anterior, podemos concluir que la entrada se proporciona de la siguiente manera:

4
5.6
1 2 3 4 5

La salida generada es la siguiente:

Integer value: 4
Float value: 5.6
[1, 2, 3, 4, 5]

El ejemplo anterior ilustra el enfoque más común utilizado por la mayoría de los programadores al resolver problemas de programación competitivos. Pero, ¿y si podemos mejorar un poco nuestro código para hacerlo más rápido y confiable? 

Método 2: Lectura de entrada de BufferedReader simple

La clase java.io.BufferedReader no proporciona ningún método para leer entradas de datos primitivos. La clase Java.io.BufferedReader lee texto de un flujo de entrada de caracteres, almacenando en búfer los caracteres para proporcionar una lectura eficiente de la secuencia de caracteres. Aunque arroja una excepción comprobada conocida como IOException. Veamos cómo manejar esa excepción y leer la entrada del usuario. Considere la entrada personalizada de la siguiente manera:

Aporte:

4
5.6
1 2 3 4 5

Ejemplo

// Java Program Illustrating Reading Input
// Using
  
// Importing required classes
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
  
// Main class
class GFG {
  
    // Main driver method
    public static void main(String[] args)
        throws IOException
    {
  
        // Reading input via BufferedReader class
        BufferedReader br = new BufferedReader(
            new InputStreamReader(System.in));
  
        // Basic Input Reading
        int a = Integer.parseInt(br.readLine());
        float b = Float.parseFloat(br.readLine());
  
        // Print above input values in console
        System.out.println("Integer value: " + a);
        System.out.println("Float value: " + b);
  
        // Space Separated Input Reading
        int[] arr = new int[5];
        String[] strArr = br.readLine().split(" ");
  
        for (int i = 0; i < arr.length; i++) {
            arr[i] = Integer.parseInt(strArr[i]);
        }
  
        // Printing the elements in array
        // using toString() method
        System.out.println(Arrays.toString(arr));
    }
}

Producción:

Integer value: 4
Float value: 5.6
[1, 2, 3, 4, 5]

El ejemplo anterior ilustra otro enfoque común utilizado para leer los datos mientras se resuelven problemas de programación competitivos. Entonces, ¿es esto suficiente? ¿Y si podemos mejorarlo aún más? Sí. Es posible. Manténganse al tanto.

Método 3: forma mejorada de leer datos separados usando BufferedReader a través de Streams 

En los ejemplos anteriores, hemos visto que mientras leíamos datos separados por espacios, los almacenamos primero en una array de strings, y luego iteramos sobre los elementos y luego usamos el tipo de conversión de Java para convertirlos al tipo de datos requerido. ¿Qué tal una sola línea de código que hace esto posible? Sí. La biblioteca de flujo de Java 8 proporciona una variedad de funciones para que sea fácil y optimizado. Considere la entrada personalizada de la siguiente manera:

Aporte:

34 55 78 43 78 43 22
94 67 96 32 79 6 33

Ejemplo

// Java Program to Read Separated Data
// Using BufferedReader class voa enhanced for loopd
  
// Importing required classes
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
  
// Main class
class GFG {
  
    // Main driver method
    public static void main(String[] args)
        throws IOException
    {
  
        // Reading input separated by space
        BufferedReader br = new BufferedReader(
            new InputStreamReader(System.in));
  
        // Storing in array
        int[] arr = Stream.of(br.readLine().split(" "))
                        .mapToInt(Integer::parseInt)
                        .toArray();
        System.out.println(Arrays.toString(arr));
  
        // Using streams concepts to parse map to integer
        // later on collecting via Collectors via toList()
        // method and storing it an integer list
        List<Integer> arrayList
            = Stream.of(br.readLine().split(" "))
                  .mapToInt(Integer::parseInt)
                  .boxed()
                  .collect(Collectors.toList());
  
        // Print the above List as created
        System.out.println(arrayList);
    }
}

Producción:

[34, 55, 78, 43, 78, 43, 22]
[94, 67, 96, 32, 79, 6, 33]

El ejemplo anterior ilustra cómo podemos leer entradas separadas y almacenarlas en la estructura de datos requerida usando una sola línea de código. Al usar java8, existe la posibilidad de que los programadores se sientan cómodos con la recopilación de listas. Por eso está tapado. Ahora, entendamos el código palabra por palabra. 

Almacenando en una array int:

1. java.util.stream.Stream.of(): crea un flujo de array de strings pasada

2. br.readLine().split(” “): convierte la string de entrada en una array de strings según el valor del separador. (Espacio en blanco – ” ” en el ejemplo)

3. mapToInt(Integer::parseInt) – Convierte el elemento String en el tipo de datos requerido utilizando la función de mapeo adecuada (parseInt() de Integer en el ejemplo)

4. toArray(): convierte el flujo de elementos int en una array

Almacenamiento en la colección de listas:

1. java.util.stream.Stream.of(): crea un flujo de array de strings pasada

2. br.readLine().split(” “): convierte la string de entrada en una array de strings según el valor del separador. (Espacio en blanco – ” ” en el ejemplo)

3. mapToInt(Integer::parseInt) – Convierte el elemento String en el tipo de datos requerido utilizando la función de mapeo adecuada (parseInt() de Integer en el ejemplo)

4. boxed() – encajona la secuencia a elementos Integer

5. collect(Collectors.toList()): crea una colección de elementos Integer y la convierte en la colección java.util.List.