Los mejores amigos de los estudiantes de CodeGym son las tareas de programación, Java y el validador de tareas. Aún así, llega un momento en que cada desarrollador padawan debe comenzar a alejarse de los caminos trillados, inventar sus propios miniproyectos y prepararse para las entrevistas. Uno pensaría que la entrevista tendría exactamente las mismas tareas prácticas de Java que se encuentran en este curso. Y así es en la mayoría de los casos, pero a algunas empresas les gusta hacer preguntas capciosas o algo desconocido. Para evitar sentirse nervioso durante una entrevista estresante, es útil intentar resolver tareas similares de Java por su cuenta en casa.
En este artículo, exploraremos 5 de estas tareas complicadas. Le recomendamos que primero lea las condiciones e intente resolverlas usted mismo. Y una cosa más: ¡no olvides hacer tareas de Java en este curso todos los días!
Se ha proporcionado un bloque de código. Añádelo para que el bucle sea infinito.
class ToInfinity {
public static void main(String[] args) {
// Insert code here
for (int i = start; i <= start + 1; i++) {
/* This should be an infinite loop, but don't change anything here */
}
}
}
" Eso no es difícil ", dices. Es muy probable que te hayas encontrado en este escenario repetidamente: mientras completabas una tarea de Java, creaste un bucle infinito y tuviste que pensar en cómo deshacerte de él. Bueno, esto es al revés. Aquí está la parte difícil: no puede cambiar el bucle en sí mismo o sus condiciones de salida. Solo hay dos iteraciones. Pero, son suficientes para crear un bucle infinito. Parece que solo debería ejecutarse durante dos iteraciones, pero puede hacerlo infinito usando el desbordamiento. ¿Ya has adivinado cómo?
Solución
Por desbordamiento, Integer.MAX_VALUEes el valor máximo que un intpuede almacenar en Java. Si alcanza Integer.MAX_VALUEe incrementa este valor, vuelve a Integer.MIN_VALUE, o más bien, al Integervalor más bajo posible. Por lo tanto, para completar esta tarea de Java, simplemente necesitamos asignar 1 menos que el intvalor máximo a la startvariable. Código Java para esta tarea:
class ToInfinity {
public static void main(String[] args) {
int start = Integer.MAX_VALUE - 1;
for (int i = start; i <= start + 1; i++) {
// Infinite loop
System.out.println(i); // Be sure we are in an infinite loop
}
}
}
¿Lo que sucede? Empezamos con start=2147483645 (Integer.MAX_VALUE-1). En la siguiente iteración, el valor se convierte en 2147483645, luego en 2147483646, luego en -2147483648, -2147483647... y así sucesivamente.
Tarea 2: crear un comentario ejecutable
¡Bueno aquí estamos! Desde las primeras lecciones, hemos escuchado que los comentarios no se ejecutan. Por eso se llaman comentarios. Creemos que la solución a esta tarea no siempre será obvia para los programadores de Java, incluso para los experimentados. Sin embargo, hay una forma complicada (pero "legal") de hacer que la JVM ejecute un comentario. ¿Puedes sentir hacia dónde nos dirigimos? ¡Intenta adivinar!
Solución
Código Java para esta tarea:
public class ExecutableComment {
public static void main(String[] args) {
// The comment below will be executed!
// \u000d System.out.println("executable comment");
}
}
Si ingresamos este código Java en un IDE, esto es lo que obtendremos:
executable comment
Esto se debe a que el compilador de Java interpreta el carácter Unicode \u000dcomo una nueva línea y lee nuestro código de la siguiente manera: código Java para esta tarea, tal como lo interpreta el compilador:
public class ExecutableComment {
public static void main(String[] args) {
// The comment below will be executed!
// \u000d
System.out.println("comment executed");
}
}
Tarea 3: crear un bucle con nombre
Aquí hay otro miembro de la serie titulada "Problemas prácticos de programación en Java para vacas esféricas". En el sentido de que no está claro por qué esto es necesario: no es probable que el bucle se sienta ofendido por el hecho de que no se le ha dado un nombre. De todos modos, es importante por otra razón: el idioma te permite nombrar un bucle.
Solución
Nota: estos "nombres" son conocidos por algunas personas como "etiquetas", y no se recomienda su uso en la práctica. Código Java para demostrar un bucle con nombre
public class NamedLoop {
public static void main(String[] args) {
loop1:
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
if (i == 3)
break loop1;
System.out.println("i = " + i + " j = " + j);
}
}
}
}
Esto es lo que se generará si ejecuta el programa:
i = 0 j = 0
i = 0 j = 1
i = 0 j = 2
i = 0 j = 3
i = 0 j = 4
i = 1 j = 0
i = 1 j = 1
i = 1 j = 2
i = 1 j = 3
i = 1 j = 4
i = 2 j = 0
i = 2 j = 1
i = 2 j = 2
i = 2 j = 3
i = 2 j = 4
También puede utilizar la palabra clave continuar para volver al principio de un bucle con nombre. Y si es necesario, puede usar break(o continue) en un anidado if-elsecon un forbucle para dividir varios bucles usando un if-else. Esto ayudará a evitar crear una gran cantidad de indicadores y verificarlos en una if-elsedeclaración para determinar si continuar o salir del ciclo interno.
Tarea 4: encontrar un solo duplicado en una matriz de enteros
Se le proporciona una matriz de enteros (o un ArrayList, si lo prefiere) que contiene cada uno Integerdel 1 al 100. La matriz tiene un elemento duplicado, y solo uno. ¿Cómo lo encuentras? Es más común que un programador de Java obtenga este tipo de tareas que las tres anteriores. Porque se trata de la lógica en lugar de su conocimiento de las sutilezas del lenguaje que rara vez se usan. Tu primer impulso desenfrenado de usar la fuerza bruta pasará bastante rápido cuando tu cerebro se active o te des cuenta de que "soy un programador. Soy inteligente". El único problema es que durante una entrevista, cuando estás bajo estrés, es posible que esto no suceda. ¡Así que piensa ahora antes de buscar la solución!
Aquí está el algoritmo
Calcula la suma de todos los números del 1 al 100. Creemos que sabes cómo puedes hacerlo (por ejemplo, usando el famoso método de Gauss). Ahora calcule la suma de los elementos en su arreglo o ArrayList. Y... restar la primera suma de la segunda. ¡Bingo! El número resultante es el valor del elemento duplicado. Código Java para esta tarea utilizando un archivo ArrayList.
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public class FindDuplicate {
private static void findDuplicate(List<Integer> elements) {
int distinctSum = elements.stream().distinct().mapToInt(e -> e).sum();
// Find the sum of all list elements
int totalSum = elements.stream().mapToInt(e -> e).sum();
System.out.println("The repeated element is: " + (totalSum - distinctSum));
}
public static void main(String[] args) {
// Create a list of sequential elements in the interval [1..101).
List <Integer> elements = IntStream.range(1, 101).boxed().collect(Collectors.toList());
// Add the value 23 at index 53
elements.set(53, 23);
findDuplicate(elements);
}
}
Otra solución
import java.util.List;
import java.util.ArrayList;
public class Duplicate {
public int findDuplicateNumber(List<Integer> numbers) {
int highestNumber = numbers.size() - 1;
int total = getSum(numbers);
int duplicate = total - (highestNumber * (highestNumber + 1) / 2);
return duplicate;
}
public int getSum(List<Integer> numbers) {
int sum = 0;
for (int num : numbers) {
sum = sum + num;
}
return sum;
}
public static void main(String a[]) {
List <Integer> numbers = new ArrayList <Integer>();
for (int i = 1; i < 100; i++) {
numbers.add(i);
}
// Add a duplicate to the list
numbers.add(25);
Duplicate dn = new Duplicate();
System.out.println("The repeated element is: " + dn.findDuplicateNumber(numbers));
}
}
Tarea 5: encontrar un duplicado no único en una matriz de enteros
Si la tarea anterior fue demasiado fácil para usted, intente hacer esta: se le da una lista de números enteros del 1 al 100. Hay duplicados (más de uno). ¿Cómo encuentras los elementos que ocurren más de una vez (busca los elementos e indica cuántas veces ocurren)?
Solución
Aquí la solución lógica sería usar algo como un HashMap, porque almacena los datos en pares clave-valor. Código para esta tarea en Java:
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public class SomeDuplicates {
private static void findDuplicates(List<Integer> elements) {
HashMap <Integer, Integer> duplicates = new HashMap <>();
// Use the following rule to populate the Map duplicates:
// the key is the element value, and the value is the number of times it occurs
elements.forEach(e -> duplicates.put(e, duplicates.get(e) == null ? 1 : duplicates.get(e) + 1));
// Remove any elements that don't occur more than once from the Map duplicates
// and store the result as a list (to make it easy to work with in the next step)
List <Map.Entry <Integer, Integer> >
result = duplicates.entrySet().stream().filter(d -> d.getValue() > 1).collect(Collectors.toList());
// Write the results for all elements to the result list
result.forEach(e -> System.out.println(String.format("Element %d occurs %d times", e.getKey(), e.getValue())));
}
public static void main(String[] args) {
List <Integer> elements = IntStream.range(1, 101).boxed().collect(Collectors.toList());
elements.set(97, 23);
elements.set(27, 51);
elements.set(99, 23);
findDuplicates(elements);
}
}
Conclusión
Hay muchos tipos diferentes de tareas prácticas de Java, y no sabes qué tipo de acertijos te pedirá que resuelvas el entrevistador. Sin embargo, cualquier empleador sensato entiende que su capacidad para completar tareas prácticas reales , como las que encontrará en el trabajo, es mucho más importante que su capacidad para resolver preguntas capciosas. Así que haz esto tanto como sea posible. Por eso creamos CodeGym. Se utilizó material de geeksforgeeks para crear este artículo.
GO TO FULL VERSION