Problemi Java con un trucco: Ciao, interviste!

Per gli studenti JavaRush , le sfide di programmazione, Java e il validatore sono i migliori amici. Tuttavia, arriva il momento per ogni sviluppatore Padawan in cui a volte ha bisogno di uscire dai sentieri battuti, elaborare mini-progetti per se stesso e prepararsi per le interviste. Al colloquio sembrerebbe che dovresti incontrare esattamente gli stessi problemi pratici Java del corso. Nella maggior parte dei casi questo è vero, ma ad alcune aziende piace porre domande trabocchetto o fare qualcosa di insolito. Per evitare di confondersi durante un colloquio stressante, è utile provare a risolvere questi problemi Java da soli, a casa. In questo articolo esamineremo una mezza dozzina di questi compiti complicati. Ti consigliamo di leggere prima la condizione e provare a risolverla da solo. E ancora una cosa: non dimenticare di risolvere ogni giorno i problemi Java del corso!

• Attività-1: creazione di un ciclo infinito da zero
• Compito-2. Crea un commento che verrà eseguito
• Attività 3: crea un ciclo con nome
• Compito-4. Informazioni su un singolo duplicato in un array di numeri interi
• Compito-5. Informazioni su un duplicato non univoco in un array di numeri interi

Problema Java - 1: creazione di un ciclo infinito da zero

Dato un blocco di codice. Completalo in modo che il ciclo diventi infinito.

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

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

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

“Niente di complicato”, dici. Molto probabilmente, ti sei trovato in questa situazione più di una volta: risolvendo i problemi Java, hai creato un ciclo infinito e hai pensato a come sbarazzartene. È il contrario. Il problema è che il ciclo stesso e le condizioni per uscirne non possono essere modificati. Ci sono solo due iterazioni. Tuttavia, ce ne sono abbastanza per creare un ciclo infinito. Sembra che dovrebbe funzionare solo per due iterazioni, ma può essere reso infinito utilizzando overflow. Hai già indovinato come?

Soluzione

A causa del traboccamento. Integer.MAX_VALUEè il valore massimo che intpuò essere memorizzato in Java. Se si raggiunge Integer.MAX_VALUEe si incrementa questo valore, si scende fino a Integer.MIN_VALUE, ovvero al valore minimo Integer. Pertanto, per risolvere questo problema Java, dobbiamo solo assegnare un startvalore alla variabile che sia 1 inferiore al valore massimo per il tipo di dati int. Codice attività in 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); //убеждаемся в бесконечности цикла
        }
    }
}

Che succede? Iniziamo con start=2147483645 (Integer.MAX_VALUE-1), alla successiva iterazione il valore diventa 2147483645, poi 2147483646, poi -2147483648, -2147483647... e così via.

Attività Java-2. Crea un commento che verrà eseguito

Bene, eccoci qui! Fin dalle prime lezioni abbiamo sentito che i commenti non vengono eseguiti. Ecco perché sono commenti. Pensiamo che la soluzione a questo problema non sia sempre ovvia per un programmatore Java, anche se esperto. Tuttavia, esiste un modo complicato per forzare la macchina Java a eseguire "legalmente" un commento per l'esecuzione. Senti da dove soffia il vento? Provare ad indovinare!

Soluzione

Codice per risolvere il problema in Java:

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

Se digitiamo il codice per questa attività in Java nell'IDE, questo è ciò che otteniamo:

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

Il motivo è che il compilatore Java legge il carattere Unicod \u000dcome una nuova riga e legge il nostro codice come segue: Il compilatore ha decifrato il codice per risolvere il problema in Java:

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

Attività Java - 3: creare un ciclo denominato

Un altro rappresentante della serie “Problemi pratici di programmazione, Java nel vuoto sferico”. Nel senso che non si capisce perché ciò sia necessario, difficilmente il ciclo si sente offeso dal fatto di essere impersonale. Bene, va bene, un'altra cosa è importante: la lingua ti permette di dare un nome al ciclo.

Soluzione

Nota: per alcuni tali "nomi" sono noti come "tag", il cui utilizzo nella pratica non è raccomandato. Codice per risolvere il problema in Java, dimostrando un ciclo con nome

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);
            }
        }
    }
}

Questo è l'output che apparirà se esegui il programma:

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

Qui puoi anche usare continua per andare all'inizio di un ciclo con nome. E se necessario, puoi usare break(o continue) in un ciclo if-elsewith fornidificato per suddividere diversi cicli usando if-else. Ciò aiuterà a evitare di impostare molti flag e di testarli if-elseper capire se continuare o uscire dal ciclo interno.

Problema Java - 4. Informazioni sull'unico duplicato in un array di numeri interi

Dato un array (o ArrayList, come preferisci) di numeri interi contenenti elementi Integerda 1 a 100. Questo array ha uno e un solo elemento duplicato. Come trovarlo? Tali compiti sono più familiari a un programmatore Java rispetto ai tre precedenti. Perché non si tratta di conoscere le sottigliezze del linguaggio, che non vengono quasi mai usate, ma di logica. Il primo impulso sfrenato a risolvere con la forza bruta scompare abbastanza rapidamente quando la tua testa si accende o c'è un atteggiamento "Sono un programmatore, sono intelligente". L'unica cosa negativa è che durante un colloquio, sotto stress, questo potrebbe non accadere. Quindi pensaci ora prima di cercare la soluzione!

L'algoritmo risolutivo è il seguente:

Calcola la somma di tutti i numeri da 1 a 100. Pensiamo che tu sappia come farlo (ad esempio, utilizzando il famoso metodo Gauss). Ora calcola la somma degli elementi del tuo array o ArrayList’а. E... sottrai il primo importo dal secondo. Bingo! Il numero risultante è il valore dell'elemento duplicato. Codice di soluzione del problema Java per 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);
    }
}

Un'altra soluzione

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. Informazioni su un duplicato non univoco in un array di numeri interi

Se il problema precedente ti è sembrato troppo facile, prova a risolvere il seguente: dato un foglio di numeri interi da 1 a 100. Contiene duplicati (più di uno). Come trovare elementi che ricorrono più di una volta (trovare l'elemento stesso e indicare quante volte si verifica)?

Soluzione

La soluzione più logica in questo caso è utilizzare una struttura come HashMap, poiché memorizza i dati in coppie chiave-valore. Codice per risolvere il 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);
    }
}

Conclusione

I problemi pratici di Java sono molto diversi e non sai che tipo di puzzle sconosciuto l’intervistatore deciderà di sottoporti. Tuttavia, qualsiasi datore di lavoro adeguato capisce che molto più importante della capacità di risolvere complicati problemi Java sarà la tua capacità di risolvere problemi pratici reali , come quelli che incontrerai durante il tuo lavoro. Quindi risolvili il più possibile. Questo è il motivo per cui è stato creato JavaRush. Per preparare questo articolo sono stati utilizzati materiali di geeksforgeeks .