Pausa para el café #110. Resolvemos el problema de cómo encontrar el tercer número más grande en una matriz. Invertir una cadena en Java

Cómo encontrar el tercer número más grande en una matriz

Fuente: Dev.to Tenemos un problema que resolver: se le proporciona una matriz de números enteros sin clasificar. ¿Cómo encontrar el tercer número más grande en una matriz? Nota: La matriz contiene valores duplicados y valores negativos, y además este código debería funcionar si la longitud de la matriz aumenta N veces. La solución se da en Java:

Ejemplo 1: matriz sin clasificar con valores negativos

Entrada: [87, 99, -14, 05, 46, 54] Código:

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

    }
}

Conclusión: Explicación:

1. Como se mencionó anteriormente, la matriz se inicializa con valores tanto positivos como negativos.

2. Inicializamos variables para almacenar el valor más grande, el segundo más grande y el tercer más grande, respectivamente. Nota: Las variables se inicializan a 0 para un caso especial: si el tercer elemento máximo no está en la matriz, devolverá 0.

3. Repetimos el ciclo N (la longitud de la matriz) varias veces para encontrar los tres valores más grandes.

4. Si la condición es asignar el valor más grande al segundo valor grande e inicializar un nuevo valor grande en la matriz.

   La primera condición elseif es asignar el segundo valor grande al tercer valor grande e inicializar un nuevo segundo valor grande en la matriz.

   La segunda condición elseif es asignar el tercer valor grande en la matriz.

5. Finalmente, imprimimos las variables.

Ejemplo 2: matriz sin clasificar con valores negativos y duplicados

Entrada: [77, 101, 95, 14, 05, 46, -47, 94, 00, 95, 52, 86, 36, -54, 94, 89] Código:

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

Conclusión: Explicación: El pseudocódigo utilizado en ambos códigos es el mismo, la única diferencia en el ejemplo 2 es que estamos usando LinkedHashSet. Es una colección de Java en la que almacenamos objetos únicos lo que da como resultado la eliminación de valores duplicados en la matriz.

Otra solución:

Podemos usar el algoritmo de clasificación de burbujas (ordenar de menor a mayor) para ordenar la matriz y encontrar el valor más grande de la matriz. Entrada: [87, 99, 14, 05, 46, 54] Código:

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

}

Conclusión:

Invertir una cadena en Java

Fuente: Dev.to

Programa Java para invertir una cadena usando StringBuilder

Explicación: Las cadenas son objetos en Java que están respaldados internamente por una matriz de caracteres. Las cadenas son inmutables porque las matrices son inmutables (cerradas a modificaciones). Cada vez que realiza cambios en una fila, se crea una nueva fila. En nuestro caso estamos usando StringBuilder que es mutable. Nota: También podemos usar la clase StringBuffer . Código:

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

    }

}

Conclusión: Secuenciación:

1. Crea un objeto de la clase String e inicialízalo.

2. Cree un objeto de la clase constructora de cadenas .

3. Utilice las funciones incorporadas append() y reverse() del generador de cadenas .

4. Imprime el objeto generador de cadenas .

Programa Java para invertir una cadena sin utilizar la función incorporada String Reverse()

Método 1

Explicación: La función toCharArray() se utiliza para convertir esta cadena en una matriz de caracteres. Después de esto, usaremos un bucle for para recorrer cada carácter en orden inverso y obtener el resultado para cada carácter. Código:

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

    }

}

Conclusión: Secuenciación:

1. Crea un objeto de la clase String e inicialízalo.

2. Cree una matriz de caracteres y llame a la función toCharArray() con un objeto String .

3. Cree un objeto String para una variable temporal.

4. Repita el bucle for a la inversa para obtener cada carácter en orden inverso.

5. Concatene cada carácter en una variable temporal .

6. Escriba temperatura .

Método 2

Explicación: Usando un bucle for , imprimimos una cadena en orden inverso. Por otro lado, el método charAt(index) devuelve el carácter en cualquier índice determinado. El carácter se concatenará después de cada iteración para cambiar la variable de cadena. Código:

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

    }

}

Conclusión: Secuenciación:

1. Creando un objeto de la clase String e inicializándolo.

2. Cree un objeto String para una variable temporal.

3. Repitiendo el bucle for en orden inverso para obtener cada carácter en orden inverso.

4. Concatene cada carácter en una variable Temp llamando a la función charAt() .

5. Imprimimos Temp .

Nota especial: es posible que esté familiarizado con la función inversa, pero el objetivo aquí es explorar las capacidades de StringBuilder y cómo puede optimizar su código sin la función inversa. ¡Espero que esto ayude a alguien en el futuro!