Aunque C++ es el lenguaje dominante en el universo de la programación competitiva, hay una buena cantidad de usuarios que aún continúan usando Java como se ha visto en el campo del desarrollo y, al mismo tiempo, pueden usar la programación competitiva siendo lo más rápido posible. ser alternado de un lado a otro donde python es el más lento entre los dinámicos y apenas se ve en el mundo competitivo. Entonces, los usuarios que se sienten cómodos con la programación en Java únicamente y que querían buscar una programación competitiva con él, aquí se explica cómo configurar su entorno en la computadora local. Como editor, utilizaremos uno de los editores de código más populares en la actualidad, VS Code.
Procedimiento:
Siga los pasos estándar secuencialmente para configurar. Hay 4 pasos a seguir de la siguiente manera:
- Instale VS Code y configure JDK (si no está instalado). Sigamos.
- Configure un fragmento para la E/S rápida.
- Configuración de sus archivos de entrada y salida.
- Particionando tu pantalla.
Ahora profundizaremos en cada paso junto con las ayudas visuales desde el principio para obtener una comprensión absolutamente clara de los geek a medida que duran más.
Explicación:
Paso 1: Instale VS Code y configure JDK
- Instale VS Code desde el sitio web oficial de VS Code
- A partir de entonces, instale/actualice la última versión de JDK. (Kit de desarrollo de Java)
Paso 2: configure un fragmento para la E/S rápida.
Los fragmentos son muy útiles para insertar rápidamente una gran cantidad de código preescrito que usa con frecuencia. Dado que el código de entrada y salida se usará para todos los problemas de programación competitivos, un fragmento será extremadamente útil para nuestra causa.
Para configurar un fragmento, observe los siguientes pasos:
2.1 Abra VS Code y vaya a Archivo -> Preferencias -> Fragmentos de usuario.
2.2 Seleccione java.json del siguiente cuadro desplegable como se muestra a continuación.
2.3 Encontrará que VS Code ya proporciona una guía aproximada sobre cómo crear un fragmento personalizado. El texto debe ser algo como lo siguiente:
{
Place your snippets for java here. Each snippet is defined
under a snippet name and has a prefix, body and
description.
The prefix is what is used to trigger the snippet and
the body will be expanded and inserted. Possible variables are:
$1, $2 for tab stops, $0 for the final cursor position, and ${1:label}, ${2:another} for placeholders.
Placeholders with the
same ids are connected.
Illustration:
"Print to console": {
"prefix": "log",
"body": [
"console.log('$1');",
"$2"
],
"description": "Log output to console"
}
}
2.4 Debajo de los comentarios dados y dentro de las llaves, pegue el siguiente código:
"Template for CP" : {
"prefix": "template",
"body":[
"import java.util.*;",
"import java.io.*;",
"public class Main {",
"$LINE_COMMENT For fast input output",
"static class FastReader {",
"BufferedReader br;",
"StringTokenizer st;",
"public FastReader()",
"{ try {br = new BufferedReader(",
"new FileReader(\"input.txt\"));",
"PrintStream out = new PrintStream(new FileOutputStream(\"output.txt\"));",
"System.setOut(out);}",
"catch(Exception e) { br = new BufferedReader(new InputStreamReader(System.in));}",
"}",
"String next()",
"{",
"while (st == null || !st.hasMoreElements()) {",
"try {st = new StringTokenizer(br.readLine());}",
"catch (IOException e) {",
"e.printStackTrace();}",
"}",
"return st.nextToken();",
"}",
"int nextInt() { return Integer.parseInt(next()); }",
"long nextLong() { return Long.parseLong(next()); }",
"double nextDouble() {return Double.parseDouble(next()); }",
"String nextLine()",
"{",
"String str = \"\";",
"try {",
"str = br.readLine();",
"}",
"catch (IOException e) {",
"e.printStackTrace();",
"}",
"return str;",
"}",
"}",
"$LINE_COMMENT end of fast i/o code",
"public static void main(String[] args) {",
"FastReader reader = new FastReader();",
"$0",
"}",
"}"
],
"description": "template for cp in java"
},
"For loop":{
"prefix" : "forl",
"body" : [
"for(int i = 0; i < $0; i++)"
]
}
Nota: Se proporciona una explicación del fragmento anterior y es necesario comprenderlo para comprender su uso y su posterior modificación .
- Plantilla para CP es el nombre del fragmento. Se utiliza para identificar el fragmento mientras aparece durante la finalización del código (marcado en rojo).
- plantilla es el prefijo que se utiliza para activar la finalización del código (marcado en verde).
- body es donde se encuentra el código del fragmento. Algunos puntos importantes a tener en cuenta aquí son:
- El código Fast I/O es una ligera modificación del código FastReader del artículo Fast I/O in Java in Competitive Programming .
- La modificación radica en el bloque try/catch en el constructor de la clase FastReader. Se utiliza para conectarse al archivo de entrada y salida en nuestra computadora local. Veremos el proceso para configurar archivos de entrada y salida más adelante en este artículo.
- $0 en la función principal se usa como marcador de posición para el cursor. Después de que el fragmento se pegue en su archivo Java, el cursor se colocará automáticamente en la marca de $0.
- Se pueden agregar comentarios en el fragmento con la palabra clave $LINE_COMMENT colocada antes del comentario.
- Los caracteres especiales (como las comillas) se deben escapar mediante una barra invertida ( \ );
- Es importante tener en cuenta que cada línea en el cuerpo del fragmento se debe colocar individualmente entre comillas y se debe colocar una coma después de cada línea, como se ilustra a continuación.
- La descripción se utiliza para dejar una breve nota sobre el fragmento para futuras referencias.
Sugerencia: cuando el fragmento se implementa en su programa, aparece sin formato y sin sangría. Para formatearlo rápidamente, presione Shift + Alt + F.
Paso 3: Configuración de sus archivos de entrada y salida.
Durante las competencias, es más fácil pegar una entrada grande y leer la salida correspondiente de los archivos en lugar de ingresar manualmente la entrada en la ventana de su terminal. Por lo tanto, configuraremos un archivo de entrada y salida. Los pasos a seguir son los siguientes:
- Cree una carpeta separada y cree dos archivos de texto en ella: » entrada.txt» y » salida.txt «. Es imperativo que su archivo de código Java esté en esa misma carpeta. Esto debería ser suficiente para hacer el truco. En caso de que desee colocar los archivos de entrada, salida y Java en diferentes directorios, coloque la ruta de los archivos en su código en los lugares que se muestran a continuación.
Necesitamos mirar de cerca el siguiente fragmento de código para saber cómo funciona el bloque try/catch aquí, que se proporciona a continuación en el ejemplo.
Ejemplo
// This code snippet is a part of the FastReader class
// as illustrated above
public FastReader() {
// The try block runs when both input and output files
// are present in the specified directory.
try {
// We modify the input stream to take input
//from the input.txt file
br = new BufferedReader(new FileReader("input.txt"));
// We modify the output stream to print the output
// in the output.txt file
PrintStream out = new
PrintStream(new FileOutputStream("output.txt"));
System.setOut(out);
}
// In case the input or the output file is not found,
// a FileNotFoundException is thrown and we enter the
// catch block.
// Catch block to handle th exception
catch (Exception e) {
// Since an input file is not present, we take input
// from the usual system input stream.
br = new BufferedReader(
new InputStreamReader(System.in));
}
}
La explicación del fragmento anterior es la siguiente:
Aquí, básicamente, estamos buscando primero un archivo de entrada y salida, que debería estar presente en nuestro dispositivo local, y la entrada y la salida allí. Sin embargo, si no se encuentra un archivo de texto de entrada y salida, como es el caso cuando el código se envía a un juez en línea, el programa leerá la entrada del flujo de entrada estándar y la salida en el flujo de salida estándar.
Paso 3 (Alternativa): Configuración de sus archivos de entrada y salida.
Durante las competencias, es más fácil pegar una entrada grande y leer la salida correspondiente de los archivos en lugar de ingresar manualmente la entrada en la ventana de su terminal. Por lo tanto, configuraremos un archivo de entrada y salida. Los pasos a seguir son los siguientes:
- Busque e instale una extensión llamada Code Builder .
- Ejecute el código usando Build with IO Command o use CTRL+ALT+K
- Le pedirá los archivos de entrada y salida en tiempo de ejecución si no está configurado; de lo contrario, utilizará los archivos seleccionados anteriormente.
- Asegúrese de que los archivos de entrada y salida estén en la misma unidad que el archivo de origen.
- Entonces no tendrá que modificar el flujo de entrada y el flujo de salida.
- Las modificaciones de fragmentos se realizarán de la siguiente manera
Ejemplo
// This code snippet is a part of the FastReader class
// as illustrated above
public FastReader() {
// The try block runs when both input and output files
// are present in the specified directory.
try {
//The Extension will PIPE the Input and Output Stream to Files at Runtime
br = new BufferedReader(System.in);
}
// In case there is an error input or the output file is not found,
// Exception is thrown and we enter the
// catch block.
// Catch block to handle the exception
catch (Exception e) {
// Printing the Stack Trace of Exception
e.printStackTrace();
}
}
Paso 4: Dividir tu pantalla
Ahora que se han creado todos los archivos necesarios, configuremos nuestro entorno de codificación:
- Abra VS Code y abra la carpeta que contiene su entrada, salida y archivo de programa Java. Para lograr esto, vaya a Archivo-> Abrir carpeta y seleccione su carpeta.
- Abra los tres archivos simultáneamente para que estén en pestañas separadas.
- Vaya a Ver-> Diseño del editor-> Dos filas a la derecha .
- Arrastre input.txt al panel superior derecho y output.txt al panel inferior derecho o viceversa, según su conveniencia. Mantenga su archivo Java en el panel izquierdo para darle la máxima cobertura de pantalla. Ajuste los tamaños de los paneles arrastrando los bordes de cada división de panel.
- El producto final debería verse así:
Sugerencia: puede cambiar rápidamente entre paneles usando las combinaciones de teclas Ctrl + PgUp y Ctrl + PgDown .