Problemas de Java com um truque: Olá, entrevistas!

Para estudantes JavaRush , os desafios de programação, Java e o validador são melhores amigos. No entanto, chega um momento para cada desenvolvedor padawan em que às vezes você precisa começar a sair do caminho tradicional, criar miniprojetos para si mesmo e se preparar para entrevistas. Na entrevista, parece que você encontrará exatamente os mesmos problemas práticos de Java que no curso. Na maioria dos casos, isso é verdade, mas algumas empresas gostam de fazer perguntas capciosas ou algo incomum. Para evitar confusão durante uma entrevista estressante, é útil tentar resolver esses problemas de Java sozinho, em casa. Neste artigo veremos meia dúzia dessas tarefas complicadas. Recomendamos que você primeiro leia a condição e tente resolvê-la sozinho. E mais uma coisa: não esqueça de resolver todos os dias os problemas de Java do curso!

• Tarefa 1: Criando um loop infinito do zero
• Tarefa-2. Crie um comentário que será executado
• Tarefa 3: Crie um loop nomeado
• Tarefa-4. Sobre uma única duplicata em uma matriz de números inteiros
• Tarefa-5. Sobre uma duplicata não exclusiva em uma matriz de números inteiros

Problema Java - 1: Criando um loop infinito do zero

Dado um bloco de código. Complete-o para que o loop se torne infinito.

class ToInfinity {
    public static void main(String[] args) {

//впишите code сюда

        for (int i = start; i <= start + 1; i++) {
             /* тут должен быть бесконечный цикл, менять ничего нельзя*/
        }
    }
}

“Nada complicado”, você diz. Provavelmente, você já se encontrou nesta situação mais de uma vez: ao resolver problemas Java, você criou um loop infinito e pensou em como se livrar dele. É o contrário. O truque é que o próprio ciclo e as condições para sair dele não podem ser alterados. Existem apenas duas iterações. No entanto, existem suficientes para criar um loop infinito. Parece que deve funcionar apenas por duas iterações, mas pode ser infinito usando overflow. Você já adivinhou como?

Solução

Devido ao transbordamento. Integer.MAX_VALUEé o valor máximo que intpode ser armazenado em Java. Se você atingir Integer.MAX_VALUEe incrementar esse valor, você desce até Integer.MIN_VALUE, ou seja, até o valor mínimo Integer. Assim, para resolver este problema Java, precisamos apenas atribuir um startvalor à variável que seja 1 menor que o valor máximo para o tipo de dados int. Código da tarefa em Java:

class ToInfinity {
    public static void main(String[] args) {
        int start = Integer.MAX_VALUE - 1;
        for (int i = start; i <= start + 1; i++) {
            //бесконечный цикл
            System.out.println(i); //убеждаемся в бесконечности цикла
        }
    }
}

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 Java 2. Crie um comentário que será executado

Bem, aqui estamos! Desde as primeiras palestras ouvimos que comentários não são executados. É para isso que servem os comentários. Achamos que a solução para este problema nem sempre é óbvia para um programador Java, mesmo experiente. No entanto, existe uma maneira complicada de forçar a máquina Java a executar “legalmente” um comentário para execução. Você sente de onde o vento está soprando? Tente adivinhar!

Solução

Código para resolver o problema em Java:

public class ExecutableComment {
    public static void main(String[] args) {
        // комментарий ниже будет выполнен!
        // \u000d System.out.println("выполняемый комментарий");
    }
}

Se digitarmos o código para esta tarefa em Java no IDE, obteremos isto:

выполняемый комментарий

A razão é que o compilador Java lê o caractere Unicod \u000dcomo uma nova linha e lê nosso código da seguinte forma: O compilador decifrou o código para resolver o problema em Java:

public class ExecutableComment {
    public static void main(String[] args) {
        // the line below this gives an output
        // \u000d
        System.out.println("comment executed");
    }
}

Tarefa Java - 3: Criar um loop nomeado

Outro representante da série “problemas práticos de programação, Java no vácuo esférico”. No sentido de que não está claro por que isso é necessário, é pouco provável que o ciclo se sinta ofendido pelo fato de ser impessoal. Bem, tudo bem, outra coisa é importante: a linguagem permite que você dê um nome ao ciclo.

Solução

Nota: para alguns, esses “nomes” são conhecidos como “tags”, que não são recomendados para uso na prática. Código para resolver o problema em Java, demonstrando 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);
            }
        }
    }
}

Esta é a saída 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

Aqui você também pode usar continue para ir para o início de um loop nomeado. E se necessário, você pode usar break(ou continue) em um loop if-elsewith aninhado forpara quebrar vários loops usando if-else. Isso ajudará a evitar definir muitos sinalizadores e testá-los if-elsepara descobrir se deve continuar ou sair do loop interno.

Problema Java - 4. Sobre a única duplicata em uma matriz de números inteiros

Dado um array (ou ArrayList, como você preferir) de números inteiros contendo elementos Integerde 1 a 100. Este array possui um e apenas um elemento duplicado. Como encontrá-lo? Essas tarefas são mais familiares para um programador Java do que as três anteriores. Porque não se trata de conhecer as sutilezas da linguagem, que quase nunca são utilizadas, mas de lógica. O primeiro impulso desenfreado de resolver pela força bruta desaparece rapidamente quando sua cabeça gira ou surge uma atitude “Sou um programador, sou inteligente”. A única coisa ruim é que durante uma entrevista, sob estresse, isso pode não acontecer. Então pense agora antes de procurar a solução!

O algoritmo de solução é o seguinte:

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 Gauss) Agora calcule a soma dos elementos do seu array ou ArrayList’а. E... subtraia o primeiro valor do segundo. Bingo! O número resultante é o valor do elemento duplicado. Código de solução de problemas Java para 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();
//находим сумму всех элементов списка
        int totalSum = elements.stream().mapToInt(e -> e).sum();
        System.out.println("Элемент, который повторяется : " + (totalSum - distinctSum));
    }

    public static void main(String[] args) {
//создаем список последовательных элементов на промежутке [1..101).
        List <Integer> elements = IntStream.range(1, 101).boxed().collect(Collectors.toList());
//устанавливаем элементу с индексом 53 meaning 23
        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);
        }
        //добавляем дубликат в список
        numbers.add(25);
        Duplicate dn = new Duplicate();
        System.out.println("Элемент, который повторяется: " + dn.findDuplicateNumber(numbers));
    }
}

Problema Java - 5. Sobre uma duplicata não exclusiva em uma matriz de inteiros

Se o problema anterior lhe pareceu muito fácil, tente resolver o seguinte: dada uma planilha de números inteiros de 1 a 100. Ela contém duplicatas (mais de uma). Como encontrar elementos que ocorrem mais de uma vez (encontre o próprio elemento e indique quantas vezes ele ocorre)?

Solução

A solução mais lógica aqui é usar uma estrutura como HashMap, pois ela armazena dados em pares chave-valor. Código para resolver o problema 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 < >();
//заполняем Map duplicates значениями по принципу:
// ключ – meaning element, meaning – сколько раз он встречается
        elements.forEach(e -> duplicates.put(e, duplicates.get(e) == null ? 1 : duplicates.get(e) + 1));
//из duplicates убираем все элементы, которые встретorсь не более 1 раза,
//и сохраняем //результат в список (для удобства обработки на следующем шаге)
        List <Map.Entry <Integer, Integer> >
        result = duplicates.entrySet().stream().filter(d -> d.getValue() > 1).collect(Collectors.toList());
//выводим результат для всех элементов в списке result
        result.forEach(e -> System.out.println(String.format("Элемент %d  встречается %d раз", 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

Os problemas práticos de Java são muito diferentes e você não sabe que tipo de quebra-cabeça desconhecido o entrevistador decidirá lhe dar. No entanto, qualquer empregador adequado entende que muito mais importante do que sua capacidade de resolver problemas complicados de Java será sua capacidade de resolver problemas práticos reais , como aqueles que você encontrará durante seu trabalho. Portanto, resolva-os o máximo possível. É por isso que o JavaRush foi criado. Materiais de geeksforgeeks foram usados ​​na preparação deste artigo.