Coffee break #110. Malutas namin ang problema kung paano hanapin ang pangatlong pinakamalaking numero sa isang array. Baliktarin ang isang string sa Java

Paano mahanap ang pangatlong pinakamalaking numero sa isang array

Pinagmulan: Dev.to Mayroon kaming problemang dapat lutasin: Bibigyan ka ng hindi naayos na hanay ng mga integer. Paano mahahanap ang ikatlong pinakamalaking numero sa isang array? Tandaan: Ang array ay naglalaman ng parehong mga duplicate na halaga at negatibong halaga, at dapat ding gumana ang code na ito kung ang haba ng array ay tataas ng N beses. Ang solusyon ay ibinigay sa Java:

Halimbawa 1: Unsorted array na may mga negatibong value

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

    }
}

Konklusyon: Paliwanag:

1. Tulad ng nabanggit sa itaas, ang array ay sinisimulan na may parehong positibo at negatibong mga halaga.

2. Sinisimulan namin ang mga variable upang mag-imbak ng pinakamalaki, pangalawa sa pinakamalaki, at pangatlong pinakamalaking halaga ayon sa pagkakabanggit. Tandaan: Ang mga variable ay sinisimulan sa 0 para sa isang espesyal na kaso: kung ang ikatlong maximum na elemento ay wala sa array, ito ay magbabalik ng 0.

3. Ulitin namin ang loop N (ang haba ng array) nang maraming beses upang mahanap ang tatlong pinakamalaking halaga.

4. Kung ang kundisyon ay magtalaga ng pinakamalaking halaga sa pangalawang malaking halaga at magpasimula ng bagong malaking halaga sa array.

   Ang 1st elseif na kundisyon ay ang magtalaga ng pangalawang malaking halaga sa ikatlong malaking halaga at magpasimula ng bagong pangalawang malaking halaga sa array.

   Ang 2nd elseif na kundisyon ay ang magtalaga ng ikatlong malaking halaga sa array.

5. Sa wakas, nai-print namin ang mga variable.

Halimbawa 2: Unsorted array na may negatibo at duplicate na value

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

Konklusyon: Paliwanag: Ang pseudo code na ginamit sa parehong mga code ay pareho, ang pagkakaiba lang sa halimbawa 2 ay gumagamit kami ng LinkedHashSet. Ito ay isang koleksyon ng Java kung saan nag-iimbak kami ng mga natatanging bagay na nagreresulta sa pag-alis ng mga duplicate na halaga sa array.

Isa pang solusyon:

Maaari naming gamitin ang bubble sort algorithm (pag-uuri mula sa pinakamababa hanggang sa pinakamataas na pagkakasunud-sunod) upang pag-uri-uriin ang array at hanapin ang pinakamalaking halaga ng array. Input: [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);
    }

}

Konklusyon:

Baliktarin ang isang string sa Java

Pinagmulan: Dev.to

Java program upang baligtarin ang isang string gamit ang StringBuilder

Paliwanag: Ang mga string ay mga bagay sa Java na panloob na sinusuportahan ng isang hanay ng mga character. Ang mga string ay hindi nababago dahil ang mga array ay hindi nababago (sarado sa pagbabago). Sa tuwing gagawa ka ng mga pagbabago sa isang row, isang bagong row ang nalilikha. Sa aming kaso gumagamit kami ng StringBuilder na nababago. Tandaan: Magagamit din natin ang StringBuffer class . 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);

    }

}

Konklusyon: Sequencing:

1. Gumawa ng object ng String class at simulan ito.

2. Lumikha ng object ng string builder class .

3. Gamitin ang built-in na string builder append() at reverse() function .

4. I-print ang bagay na tagabuo ng string .

Java program upang baligtarin ang isang string nang hindi ginagamit ang built-in na function na String reverse()

Paraan 1

Paliwanag: Ang toCharArray() function ay ginagamit upang i-convert ang string na ito sa isang character array. Pagkatapos nito, gagamit tayo ng for loop para dumaan sa bawat character sa reverse order at makuha ang output para sa bawat character. 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);

    }

}

Konklusyon: Sequencing:

1. Gumawa ng object ng String class at simulan ito.

2. Gumawa ng array ng character at tawagan ang toCharArray() function na may String object .

3. Gumawa ng String object para sa isang pansamantalang variable.

4. Ulitin ang para sa loop sa reverse upang makuha ang bawat character sa reverse order.

5. Pagsamahin ang bawat karakter sa isang Temp variable .

6. I-type ang Temp .

Paraan 2

Paliwanag: Gamit ang for loop , nag-print kami ng string sa reverse order. Sa kabilang banda, ibinabalik ng charAt(index) na paraan ang karakter sa anumang ibinigay na index. Ang karakter ay pagsasama-samahin pagkatapos ng bawat pag-ulit upang baguhin ang string variable. 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);

    }

}

Konklusyon: Sequencing:

1. Paglikha ng object ng String class at pagsisimula nito.

2. Gumawa ng String object para sa isang pansamantalang variable.

3. Inuulit ang for loop sa reverse order para makuha ang bawat character sa reverse order.

4. Pagsamahin ang bawat karakter sa isang Temp variable sa pamamagitan ng pagtawag sa charAt() function .

5. Nag-print kami ng Temp .

Espesyal na Paalala: Maaaring pamilyar ka sa reverse function, ngunit ang layunin dito ay galugarin ang mga kakayahan ng StringBuilder at kung paano mo ma-optimize ang iyong code nang walang reverse function. Sana makatulong ito sa isang tao sa hinaharap!