Pausa caffè #110. Risolviamo il problema di come trovare il terzo numero più grande in un array. Invertire una stringa in Java

Come trovare il terzo numero più grande in un array

Fonte: Dev.to Abbiamo un problema da risolvere: ti viene fornita una serie non ordinata di numeri interi. Come trovare il terzo numero più grande in un array? Nota: l'array contiene sia valori duplicati che valori negativi e anche questo codice dovrebbe funzionare se la lunghezza dell'array aumenta di N volte. La soluzione è data in Java:

Esempio 1: array non ordinato con valori negativi

Ingresso: [87, 99, -14, 05, 46, 54] Codice:

public class ThirdLargestNumInArray {

    public static void main(String[] args) {

        /*
         * unsorted Array with duplicate and negative values
         */
        Integer arr[] = { 87, 99, -14, 05, 46, 54 };

        /* Variable initialization */
        int largest = 0, secondLargest = 0, thirdLargest = 0;

        /* Condition to find */
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > largest) {
                /*
                 * if condition is true assign large value to second large value
                 */
                secondLargest = largest;

                /* assign new large value */
                largest = arr[i];

            } else if (arr[i] > secondLargest) {
                /*
                 * if condition is true assign second large value to third large value
                 */
                thirdLargest = secondLargest;

                /* assign new second large value */
                secondLargest = arr[i];

            } else if (arr[i] > thirdLargest) {
                /*
                 * if condition is true the third largest value will be assigned
                 */
                thirdLargest = arr[i];
            }
        }

        /* Print the values */
        System.out.println("Largest = " + largest);
        System.out.println("Second Largest = " + secondLargest);
        System.out.println("Third Largest = " + thirdLargest);

    }
}

Conclusione: Spiegazione:

1. Come accennato in precedenza, l'array viene inizializzato con valori sia positivi che negativi.

2. Inizializziamo le variabili per memorizzare rispettivamente il valore più grande, il secondo più grande e il terzo più grande. Nota: le variabili vengono inizializzate a 0 per un caso speciale: se il terzo elemento massimo non è nell'array, restituirà 0.

3. Ripetiamo il ciclo N (la lunghezza dell'array) un numero di volte per trovare i tre valori più grandi.

4. Se la condizione è assegnare il valore più grande al secondo valore più grande e inizializzare un nuovo valore più grande nell'array.

   La prima condizione elseif consiste nell'assegnare il secondo grande valore al terzo grande valore e inizializzare un nuovo secondo grande valore nell'array.

   La seconda condizione elseif consiste nell'assegnare il terzo valore grande nell'array.

5. Infine stampiamo le variabili.

Esempio 2: array non ordinato con valori negativi e duplicati

Ingresso: [77, 101, 95, 14, 05, 46, -47, 94, 00, 95, 52, 86, 36, -54, 94, 89] Codice:

import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;

public class ThirdLargestNumInSet {

    public static void main(String[] args) {

        /*
         * unsorted Array with duplicate and negative values
         */
        Integer arr[] = { 77, 101, 14, 05, 46, -47, 94, 00, 95, 52, 86, 36, -54, 94, 89 };

        /* Variable initialization */
        int largest = 0, secondLargest = 0, thirdLargest = 0;

        /*
         * using LinkedHashSet - Map to remove duplication in Array
         */
        Set<Integer> newSet = new LinkedHashSet<>();

        for (int i = 0; i < arr.length; i++) {
            newSet.add(arr[i]);
        }

        /* Condition to find */
        for (Integer i : newSet) {
            if (i > largest) {
                /*
                 * if condition is true assign large value to second large value
                 */
                secondLargest = largest;

                /* assign new large value */
                largest = i;

            } else if (i > secondLargest) {
                /*
                 * if condition is true assign second large value to third large value
                 */
                thirdLargest = secondLargest;

                /* assign new second large value */
                secondLargest = i;

            } else if (i > thirdLargest) {
                /*
                 * if condition is true the third largest value will be assigned
                 */
                thirdLargest = i;
            }
        }

        /* Print the values */
        System.out.print("Largest = " + largest);
        System.out.print("\nSecond Largest = " + secondLargest);
        System.out.print("\nThird Largest = " + thirdLargest);
    }
}

Conclusione: Spiegazione: lo pseudo codice utilizzato in entrambi i codici è lo stesso, l'unica differenza nell'esempio 2 è che stiamo utilizzando LinkedHashSet. È una raccolta Java in cui memorizziamo oggetti univoci che si traducono nella rimozione di valori duplicati nell'array.

Un'altra soluzione:

Possiamo utilizzare l'algoritmo bubble sort (ordinamento dall'ordine più basso a quello più alto) per ordinare l'array e trovare il valore più grande dell'array. Ingresso: [87, 99, 14, 05, 46, 54] Codice:

import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;

public class Main {

    public static void bubblesort(Integer[] arr) {

        int n = arr.length;
        int temp;

        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }

            }
        }

    }

    public static void main(String[] args) {

        Integer[] arr = { 87, 99, 14, 05, 46, 54 };

        bubblesort(arr);

        System.out.print("array after sorting : ");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }

        int n = arr.length;

        int max = arr[n - 3];
        System.out.println("\n3rd largest value: " + max);
    }

}

Conclusione:

Invertire una stringa in Java

Fonte: Dev.to

Programma Java per invertire una stringa utilizzando StringBuilder

Spiegazione: Le stringhe sono oggetti in Java supportati internamente da un array di caratteri. Le stringhe sono immutabili perché gli array sono immutabili (chiusi alla modifica). Ogni volta che apporti modifiche a una riga, viene creata una nuova riga. Nel nostro caso stiamo usando StringBuilder che è mutabile. Nota: possiamo anche utilizzare la classe StringBuffer . Codice:

public class ReverseStringBuilder {

    public static void main(String[] args) {

        /* String is immutable */
        String name = "Palindrome";

        /* Create StringBuilder(mutable) object */
        StringBuilder s1 = new StringBuilder();

        /* Using append() and reverse() in StringBuilder */
        s1.append(name);
        s1 = s1.reverse();

        /* Print the reverse */
        System.out.println(s1);

    }

}

Conclusione: Sequenziamento:

1. Crea un oggetto della classe String e inizializzalo.

2. Creare un oggetto della classe generatore di stringhe .

3. Utilizza le funzioni integrate di creazione di stringhe append() e reverse() .

4. Stampa l' oggetto generatore di stringhe .

Programma Java per invertire una stringa senza utilizzare la funzione incorporata String reverse()

Metodo 1

Spiegazione: La funzione toCharArray() viene utilizzata per convertire questa stringa in un array di caratteri. Successivamente, utilizzeremo un ciclo for per scorrere ciascun carattere in ordine inverso e ottenere l'output per ciascun carattere. Codice:

public class Reverse {

    public static void main(String[] args) {

        /* String is immutable */
        String name = "Palindrome";

        /* Using toCharArray() function */
        char[] ch = name.toCharArray();

        /* Temp string */
        String rev = "";

        /* Iterating for loop in reverse to store */
        for (int i = ch.length - 1; i >= 0; i--) {
            /* Concatenating Strings */
            rev += ch[i];
        }

        /* Print the reverse */
        System.out.println(rev);

    }

}

Conclusione: Sequenziamento:

1. Crea un oggetto della classe String e inizializzalo.

2. Crea un array di caratteri e chiama la funzione toCharArray() con un oggetto String .

3. Crea un oggetto String per una variabile temporanea.

4. Ripeti il ​​ciclo for al contrario per ottenere ciascun carattere in ordine inverso.

5. Concatena ogni carattere in una variabile Temp .

6. Tipo Temp .

Metodo 2

Spiegazione: utilizzando un ciclo for , abbiamo stampato una stringa in ordine inverso. D'altra parte, il metodo charAt(index) restituisce il carattere in ogni dato indice. Il carattere verrà concatenato dopo ogni iterazione per modificare la variabile stringa. Codice:

public class ReverseCharAt {

    public static void main(String[] args) {

        /* String is immutable */
        String name = "Palindrome";

        /* Temp string */
        String rev = "";

        /* Iterating for loop in reverse to store */
        for (int i = name.length() - 1; i >= 0; i--) {
            /* Concatenating Strings */
            rev = rev + name.charAt(i);
        }

        /* Print the reverse */
        System.out.println(rev);

    }

}

Conclusione: Sequenziamento:

1. Creazione di un oggetto della classe String e inizializzazione.

2. Crea un oggetto String per una variabile temporanea.

3. Ripetendo il ciclo for in ordine inverso per ottenere ciascun carattere in ordine inverso.

4. Concatena ogni carattere in una variabile Temp chiamando la funzione charAt() .

5. Stampiamo Temp .

Nota speciale: potresti avere familiarità con la funzione inversa, ma l'obiettivo qui è esplorare le funzionalità di StringBuilder e come ottimizzare il tuo codice senza la funzione inversa. Spero che questo aiuti qualcuno in futuro!