Kaffeepause Nr. 110. Wir lösen das Problem, wie man die drittgrößte Zahl in einem Array findet. Kehren Sie eine Zeichenfolge in Java um

So finden Sie die drittgrößte Zahl in einem Array

Quelle: Dev.to Wir müssen ein Problem lösen: Sie erhalten ein unsortiertes Array von Ganzzahlen. Wie finde ich die drittgrößte Zahl in einem Array? Hinweis: Das Array enthält sowohl doppelte als auch negative Werte, und dieser Code sollte auch funktionieren, wenn die Länge des Arrays um das N-fache zunimmt. Die Lösung ist in Java angegeben:

Beispiel 1: Unsortiertes Array mit negativen Werten

Eingabe: [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);

    }
}

Abschluss: Erläuterung:

1. Wie oben erwähnt, wird das Array sowohl mit positiven als auch mit negativen Werten initialisiert.

2. Wir initialisieren Variablen, um jeweils den größten, zweitgrößten und drittgrößten Wert zu speichern. Hinweis: Für einen Sonderfall werden die Variablen auf 0 initialisiert: Wenn das dritte maximale Element nicht im Array ist, wird 0 zurückgegeben.

3. Wir wiederholen die Schleife N (die Länge des Arrays) mehrmals, um die drei größten Werte zu finden.

4. Wenn die Bedingung darin besteht, dem zweitgrößten Wert den größten Wert zuzuweisen und einen neuen großen Wert im Array zu initialisieren.

   Die erste elseif- Bedingung besteht darin, den zweiten großen Wert dem dritten großen Wert zuzuweisen und einen neuen zweiten großen Wert im Array zu initialisieren.

   Die zweite elseif- Bedingung besteht darin, den dritten großen Wert im Array zuzuweisen.

5. Zum Schluss drucken wir die Variablen aus.

Beispiel 2: Unsortiertes Array mit negativen und doppelten Werten

Eingabe: [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);
    }
}

Abschluss: Erläuterung: Der in beiden Codes verwendete Pseudocode ist derselbe. Der einzige Unterschied in Beispiel 2 besteht darin, dass wir LinkedHashSet verwenden. Es handelt sich um eine Java-Sammlung, in der wir eindeutige Objekte speichern, was dazu führt, dass doppelte Werte im Array entfernt werden.

Eine andere Lösung:

Wir können den Blasensortierungsalgorithmus (Sortierung von der niedrigsten zur höchsten Reihenfolge) verwenden, um das Array zu sortieren und den größten Wert des Arrays zu finden. Eingabe: [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);
    }

}

Abschluss:

Kehren Sie eine Zeichenfolge in Java um

Quelle: Dev.to

Java-Programm zum Umkehren eines Strings mit StringBuilder

Erläuterung: Strings sind Objekte in Java, die intern durch ein Array von Zeichen unterstützt werden. Zeichenfolgen sind unveränderlich, da Arrays unveränderlich sind (für Änderungen geschlossen). Jedes Mal, wenn Sie Änderungen an einer Zeile vornehmen, wird eine neue Zeile erstellt. In unserem Fall verwenden wir StringBuilder , der veränderbar ist. Hinweis: Wir können auch die StringBuffer- Klasse verwenden . 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);

    }

}

Abschluss: Reihenfolge:

1. Erstellen Sie ein Objekt der String- Klasse und initialisieren Sie es.

2. Erstellen Sie ein Objekt der String-Builder -Klasse .

3. Verwenden Sie die integrierten String-Builder- Funktionen append() und reverse() .

4. Drucken Sie das String-Builder- Objekt .

Java-Programm zum Umkehren einer Zeichenfolge ohne Verwendung der integrierten Funktion String reverse()

Methode 1

Erläuterung: Die Funktion toCharArray() wird verwendet, um diese Zeichenfolge in ein Zeichenarray zu konvertieren. Danach verwenden wir eine for- Schleife , um jedes Zeichen in umgekehrter Reihenfolge zu durchlaufen und die Ausgabe für jedes Zeichen zu erhalten. 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);

    }

}

Abschluss: Reihenfolge:

1. Erstellen Sie ein Objekt der String- Klasse und initialisieren Sie es.

2. Erstellen Sie ein Zeichenarray und rufen Sie die Funktion toCharArray() mit einem String- Objekt auf .

3. Erstellen Sie ein String- Objekt für eine temporäre Variable.

4. Wiederholen Sie die for- Schleife in umgekehrter Reihenfolge, um jedes Zeichen in umgekehrter Reihenfolge zu erhalten.

5. Verketten Sie jedes Zeichen in einer Temp- Variablen .

6. Geben Sie Temp ein .

Methode 2

Erläuterung: Mithilfe einer for- Schleife haben wir eine Zeichenfolge in umgekehrter Reihenfolge gedruckt. Andererseits gibt die Methode charAt(index) das Zeichen an einem beliebigen Index zurück. Das Zeichen wird nach jeder Iteration verkettet, um die Zeichenfolgenvariable zu ändern. 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);

    }

}

Abschluss: Reihenfolge:

1. Erstellen Sie ein Objekt der String- Klasse und initialisieren Sie es.

2. Erstellen Sie ein String- Objekt für eine temporäre Variable.

3. Wiederholen Sie die for- Schleife in umgekehrter Reihenfolge, um jedes Zeichen in umgekehrter Reihenfolge zu erhalten.

4. Verketten Sie jedes Zeichen in einer Temp- Variablen, indem Sie die Funktion charAt() aufrufen .

5. Wir drucken Temp .

Besonderer Hinweis: Möglicherweise sind Sie mit der Umkehrfunktion vertraut, aber das Ziel besteht hier darin, die Fähigkeiten von StringBuilder zu erkunden und zu erfahren, wie Sie Ihren Code ohne die Umkehrfunktion optimieren können. Ich hoffe, das hilft jemandem in der Zukunft!