Pause café #110. Nous résolvons le problème de savoir comment trouver le troisième plus grand nombre dans un tableau. Inverser une chaîne en Java

Comment trouver le troisième plus grand nombre dans un tableau

Source : Dev.to Nous avons un problème à résoudre : vous recevez un tableau d'entiers non triés. Comment trouver le troisième plus grand nombre dans un tableau ? Remarque : le tableau contient à la fois des valeurs en double et des valeurs négatives, et ce code devrait également fonctionner si la longueur du tableau augmente de N fois. La solution est donnée en Java :

Exemple 1 : tableau non trié avec des valeurs négatives

Entrée : [87, 99, -14, 05, 46, 54] Code :

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

    }
}

Conclusion: Explication:

1. Comme mentionné ci-dessus, le tableau est initialisé avec des valeurs positives et négatives.

2. Nous initialisons les variables pour stocker respectivement la plus grande, la deuxième plus grande et la troisième plus grande valeur. Remarque : Les variables sont initialisées à 0 pour un cas particulier : si le troisième élément maximum n'est pas dans le tableau, il renverra 0.

3. Nous répétons la boucle N (la longueur du tableau) plusieurs fois pour trouver les trois plus grandes valeurs.

4. Si la condition est d'attribuer la plus grande valeur à la deuxième grande valeur et d'initialiser une nouvelle grande valeur dans le tableau.

   La première condition elseif consiste à attribuer la deuxième grande valeur à la troisième grande valeur et à initialiser une nouvelle deuxième grande valeur dans le tableau.

   La deuxième condition elseif consiste à attribuer la troisième grande valeur du tableau.

5. Enfin, nous imprimons les variables.

Exemple 2 : tableau non trié avec des valeurs négatives et en double

Entrée : [77, 101, 95, 14, 05, 46, -47, 94, 00, 95, 52, 86, 36, -54, 94, 89] Code :

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

Conclusion: Explication : Le pseudo code utilisé dans les deux codes est le même, la seule différence dans l'exemple 2 est que nous utilisons LinkedHashSet. Il s'agit d'une collection Java dans laquelle nous stockons des objets uniques, ce qui entraîne la suppression des valeurs en double dans le tableau.

Une autre solution:

Nous pouvons utiliser l'algorithme de tri à bulles (tri de l'ordre le plus bas au plus élevé) pour trier le tableau et trouver la plus grande valeur du tableau. Entrée : [87, 99, 14, 05, 46, 54] Code :

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

}

Conclusion:

Inverser une chaîne en Java

Source : Dev.to

Programme Java pour inverser une chaîne à l'aide de StringBuilder

Explication : Les chaînes sont des objets en Java qui sont soutenus en interne par un tableau de caractères. Les chaînes sont immuables car les tableaux sont immuables (fermés à la modification). Chaque fois que vous apportez des modifications à une ligne, une nouvelle ligne est créée. Dans notre cas, nous utilisons StringBuilder qui est mutable. Remarque : Nous pouvons également utiliser la classe StringBuffer . Code:

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

    }

}

Conclusion: Séquençage :

1. Créez un objet de la classe String et initialisez-le.

2. Créez un objet de la classe String Builder .

3. Utilisez les fonctions append() et reverse() du générateur de chaînes intégré .

4. Imprimez l' objet générateur de chaîne .

Programme Java pour inverser une chaîne sans utiliser la fonction intégrée String reverse()

Méthode 1

Explication : La fonction toCharArray() est utilisée pour convertir cette chaîne en tableau de caractères. Après cela, nous utiliserons une boucle for pour parcourir chaque caractère dans l'ordre inverse et obtenir la sortie pour chaque caractère. Code:

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

    }

}

Conclusion: Séquençage :

1. Créez un objet de la classe String et initialisez-le.

2. Créez un tableau de caractères et appelez la fonction toCharArray() avec un objet String .

3. Créez un objet String pour une variable temporaire.

4. Répétez la boucle for en sens inverse pour obtenir chaque caractère dans l'ordre inverse.

5. Concaténez chaque caractère dans une variable Temp .

6. Tapez Temp .

Méthode 2

Explication : à l'aide d'une boucle for , nous avons imprimé une chaîne dans l'ordre inverse. D'un autre côté, la méthode charAt(index) renvoie le caractère à n'importe quel index donné. Le caractère sera concaténé après chaque itération pour changer la variable chaîne. Code:

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

    }

}

Conclusion: Séquençage :

1. Créer un objet de la classe String et l'initialiser.

2. Créez un objet String pour une variable temporaire.

3. Répéter la boucle for dans l'ordre inverse pour obtenir chaque caractère dans l'ordre inverse.

4. Concaténez chaque caractère dans une variable Temp en appelant la fonction charAt() .

5. Nous imprimons Temp .

Remarque spéciale : vous connaissez peut-être la fonction inverse, mais l'objectif ici est d'explorer les capacités de StringBuilder et comment vous pouvez optimiser votre code sans la fonction inverse. J'espère que cela aidera quelqu'un à l'avenir !