Os melhores amigos dos alunos do CodeGym são tarefas de programação, Java e o validador de tarefas. Ainda assim, chega um momento em que todo desenvolvedor padawan deve começar a sair do caminho comum, inventar seus próprios miniprojetos e se preparar para entrevistas. Alguém poderia pensar que a entrevista teria exatamente as mesmas tarefas práticas de Java encontradas neste curso. E assim é na maioria dos casos, mas algumas empresas gostam de fazer perguntas capciosas ou algo desconhecido. Para evitar ficar confuso durante uma entrevista estressante, é útil tentar resolver tarefas semelhantes em Java por conta própria em casa.
Neste artigo, exploraremos 5 dessas tarefas complicadas. Recomendamos que você primeiro leia as condições e tente resolvê-las você mesmo. E mais uma coisa: não se esqueça de fazer tarefas Java neste curso todos os dias!
Um bloco de código foi fornecido. Adicione a ele para tornar o loop 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 */
}
}
}
" Isso não é difícil ", você diz. Você provavelmente já se encontrou repetidamente neste cenário: ao concluir uma tarefa Java, você criou um loop infinito e teve que pensar em como se livrar dele. Bem, este é o contrário. Aqui está a parte complicada: você não pode alterar o próprio loop ou suas condições de saída. Existem apenas duas iterações. Mas, eles são suficientes para criar um loop infinito. Parece que deve ser executado apenas por duas iterações, mas você pode torná-lo infinito usando o estouro. Você já adivinhou como?
Solução
Devido ao estouro, Integer.MAX_VALUEé o valor máximo que um intpode armazenar em Java. Se você atingir Integer.MAX_VALUEe incrementar esse valor, reverterá para Integer.MIN_VALUE, ou melhor, para o menor Integervalor possível. Assim, para concluir esta tarefa Java, basta atribuir 1 a menos que o intvalor máximo para a startvariável. Código Java para esta tarefa:
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
}
}
}
O que acontece? Começamos com start=2147483645 (Integer.MAX_VALUE-1). Na próxima iteração, o valor se torna 2147483645, depois 2147483646, depois -2147483648, -2147483647... e assim por diante.
Tarefa 2: criar um comentário executável
Bem, aqui estamos nós! Desde as primeiras aulas, ouvimos que os comentários não são executados. É por isso que eles são chamados de comentários. Acreditamos que a solução para esta tarefa nem sempre será óbvia para os programadores Java, mesmo os mais experientes. No entanto, existe uma maneira complicada (mas "legal") de fazer a JVM executar um comentário. Você pode sentir para onde estamos indo? Tente adivinhar!
Solução
Código Java para esta tarefa:
public class ExecutableComment {
public static void main(String[] args) {
// The comment below will be executed!
// \u000d System.out.println("executable comment");
}
}
Se inserirmos esse código Java em um IDE, eis o que obteremos:
executable comment
Isso ocorre porque o compilador Java interpreta o caractere Unicode \u000dcomo uma nova linha e lê nosso código assim: Código Java para esta tarefa, conforme interpretado pelo compilador:
public class ExecutableComment {
public static void main(String[] args) {
// The comment below will be executed!
// \u000d
System.out.println("comment executed");
}
}
Tarefa 3: Criar um loop nomeado
Aqui está outro membro da série intitulada "Problemas práticos de programação em Java para vacas esféricas". No sentido de que não está claro por que isso é necessário: não é provável que o loop fique ofendido pelo fato de não ter recebido um nome. De qualquer forma, é importante por outro motivo: a linguagem permite nomear um loop.
Solução
Observação: esses "nomes" são conhecidos por algumas pessoas como "rótulos" e não são recomendados para uso na prática. Código Java para demonstrar um loop nomeado
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);
}
}
}
}
Aqui está o que será gerado se você executar o 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
Você também pode usar a palavra-chave continue para retornar ao início de um loop nomeado. E se necessário, você pode usar break(ou continue) em um aninhado if-elsecom um forloop para quebrar vários loops usando um if-else. Isso ajudará a evitar a criação de um grande número de sinalizadores e sua verificação em uma if-elseinstrução para determinar se deve continuar ou sair do loop interno.
Tarefa 4: encontre uma única duplicata em uma matriz de números inteiros
Você recebe um array inteiro (ou um ArrayList, se preferir) que contém todos Integerde 1 a 100. O array tem um, e apenas um, elemento duplicado. Como você o encontra? É mais comum para um programador Java obter esse tipo de tarefa do que as três anteriores. Porque se trata de lógica, e não do seu conhecimento das sutilezas raramente usadas da linguagem. Seu primeiro impulso desenfreado de usar a força bruta passará rapidamente quando seu cérebro entrar em ação ou você perceber "Sou um programador. Sou inteligente". O único problema é que durante uma entrevista, quando você está estressado, isso pode não acontecer. Portanto, pense agora antes de olhar para a solução!
Aqui está o algoritmo
Calcule a soma de todos os números de 1 a 100. Achamos que você sabe como fazer isso (por exemplo, usando o famoso método de Gauss). Agora calcule a soma dos elementos em sua matriz ou ArrayList. E... subtraia a primeira soma da segunda. Bingo! O número resultante é o valor do elemento duplicado. Código Java para esta tarefa usando um arquivo 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);
}
}
Outra solução
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));
}
}
Tarefa 5: encontre uma duplicata não exclusiva em uma matriz de números inteiros
Se a tarefa anterior foi muito fácil para você, tente fazer esta: Você recebe uma lista de números inteiros de 1 a 100. Há duplicatas nela (mais de uma). Como você encontra os elementos que ocorrem mais de uma vez (encontre os elementos e indique quantas vezes eles ocorrem)?
Solução
Aqui a solução lógica seria usar algo como um HashMap, pois armazena os dados em pares chave-valor. Código para esta tarefa em 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);
}
}
Conclusão
Existem muitos tipos diferentes de tarefas práticas em Java e você não sabe que tipo de quebra-cabeças o entrevistador pedirá para você resolver. Mas qualquer empregador sensato entende que sua capacidade de concluir tarefas práticas reais , como as que você encontrará no trabalho, é muito mais importante do que sua capacidade de resolver questões capciosas. Portanto, faça isso o máximo possível. É por isso que criamos o CodeGym. Material de geeksforgeeks foi usado para criar este artigo.
GO TO FULL VERSION