jdk - java telecharger



Trouver le deuxième nombre le plus élevé dans le tableau (20)

Classe publique SecondHighInIntArray {

public static void main(String[] args) {
    int[] intArray=new int[]{2,2,1};
            //{2,2,1,12,3,7,9,-1,-5,7};
    int secHigh=findSecHigh(intArray);
    System.out.println(secHigh);
}

private static int findSecHigh(int[] intArray) {

    int highest=Integer.MIN_VALUE;
    int sechighest=Integer.MIN_VALUE;
    int len=intArray.length;
    for(int i=0;i<len;i++)
    {
        if(intArray[i]>highest)
        {
            sechighest=highest;
            highest=intArray[i];
            continue;
        }

        if(intArray[i]<highest && intArray[i]>sechighest)
        {
            sechighest=intArray[i];
            continue;
        }


    }
    return sechighest;
}

}

J'ai du mal à comprendre la logique derrière la méthode pour trouver le deuxième nombre le plus élevé dans le tableau. La méthode utilisée est de trouver le plus haut dans le tableau mais inférieur au plus haut précédent (qui a déjà été trouvé). La chose que je ne peux toujours pas comprendre est pourquoi || highest_score == second_highest || highest_score == second_highest nécessaire. Par exemple, je saisis trois chiffres: 98, 56, 3. Sans elle, les deux valeurs les plus élevées et les deuxièmes seraient 98. Veuillez expliquer.

int second highest = score[0];  
if (score[i] > second_highest && score[i] < highest_score || highest_score == second_highest)   
    second_highest = score[i];

Answer #1

Deuxième plus grand en O (n / 2)

public class SecMaxNum {

    // second Largest number with O(n/2)
    /**
     * @author Rohan Kamat
     * @Date Feb 04, 2016
     */
    public static void main(String[] args) {
        int[] input = { 1, 5, 10, 11, 11, 4, 2, 8, 1, 8, 9, 8 };
        int large = 0, second = 0;

        for (int i = 0; i < input.length - 1; i = i + 2) {
            // System.out.println(i);
            int fist = input[i];
            int sec = input[i + 1];
            if (sec >= fist) {
                int temp = fist;
                fist = sec;
                sec = temp;
            }
            if (fist >= second) {
                if (fist >= large) {
                    large = fist;
                } else {
                    second = fist;
                }

            }

            if (sec >= second) {
                if (sec >= large) {
                    large = sec;
                } else {
                    second = sec;
                }
            }
        }
    }
}

Answer #2

Je donne une solution qui n'est pas dans le programme JAVA (écrit en JavaScript), mais il faut une itération (n / 2) pour trouver le nombre le plus élevé et le deuxième nombre le plus élevé.
Lien de violoniste actif Lien Fiddler

 var num=[1020215,2000,35,2,54546,456,2,2345,24,545,132,5469,25653,0,2315648978523];
var j=num.length-1;
var firstHighest=0,seoncdHighest=0;
num[0] >num[num.length-1]?(firstHighest=num[0],seoncdHighest=num[num.length-1]):(firstHighest=num[num.length-1],   seoncdHighest=num[0]);
j--;
for(var i=1;i<=num.length/2;i++,j--)
{
   if(num[i] < num[j] )
   {
          if(firstHighest < num[j]){
          seoncdHighest=firstHighest;
           firstHighest= num[j];
          }
           else if(seoncdHighest < num[j] ) {
               seoncdHighest= num[j];

           }
   }
   else {
       if(firstHighest < num[i])
       {
           seoncdHighest=firstHighest;
           firstHighest= num[i];

       }
       else if(seoncdHighest < num[i] ) {
            seoncdHighest= num[i];

       }
   }

}         

Answer #3

Je ne suis pas convaincu que faire ce que vous avez fait corrige le problème; Je pense que cela masque un autre problème dans votre logique. Trouver le deuxième plus haut est en fait assez simple:

 static int secondHighest(int... nums) {
    int high1 = Integer.MIN_VALUE;
    int high2 = Integer.MIN_VALUE;
    for (int num : nums) {
      if (num > high1) {
        high2 = high1;
        high1 = num;
      } else if (num > high2) {
        high2 = num;
      }
    }
    return high2;
 }

C'est O(N) en un seul passage. Si vous voulez accepter les liens, if (num >= high1) à if (num >= high1) , mais tel quel, il retournera Integer.MIN_VALUE s'il n'y a pas au moins 2 éléments dans le tableau. Il retournera également Integer.MIN_VALUE si le tableau ne contient que le même nombre.


Answer #4

Le deuxième élément le plus important du tableau: EN Java:

class test2{
    public static void main(String[] args) {

int a[] = {1,2,3,9,5,7,6,4,8};
Arrays.sort(a);
int aa = a[a.length -2 ];
System.out.println(aa);


    }//main

}//end

En Python:

a = [1, 2, 3, 9, 5, 7, 6, 4, 8]

aa = sorted(list(a))
print(aa)
aaa = aa[-2]
print(aaa)

Answer #5

Le moyen le plus simple est -

public class SecondLargest {
    public static void main(String[] args) {
        int[] arr = { 1, 2, 5, 6, 3 };

        int first = Integer.MIN_VALUE;
        int second = Integer.MIN_VALUE;
        for (int i = 0; i < arr.length; i++) {
            // If current element is smaller than first then update both first
            // and second
            if (arr[i] > first) {
                second = first;
                first = arr[i];
            }
            // If arr[i] is in between first and second then update second
            else if (arr[i] > second && arr[i] != first) {
                second = arr[i];
            }
        }
    }
}

Answer #6

Mon idée est que vous supposez que les premier et second membres du tableau sont vos premier et second max. Ensuite, vous prenez chaque nouveau membre d'un tableau et le comparez avec le second max. N'oubliez pas de comparer le 2ème max avec le 1er. Si c'est plus gros, échangez-les simplement.

   public static int getMax22(int[] arr){
    int max1 = arr[0];
    int max2 = arr[1];
    for (int i = 2; i < arr.length; i++){
        if (arr[i] > max2)
        {
            max2 = arr[i];
        }

        if (max2 > max1)
        {
            int temp = max1;
            max1 = max2;
            max2 = temp;
        }
    }
     return max2;
}

Answer #7

Problème: Le problème est d'obtenir le deuxième élément de tableau le plus grand.

Observation: le deuxième nombre le plus grand est défini comme le nombre ayant la différence minimale lorsqu'il est soustrait de l'élément maximum du tableau.

Solution: Ceci est une solution en deux passages. La première passe consiste à trouver le nombre maximum. Le second passage consiste à trouver l'élément qui présente la différence minimale avec l'élément maximum par rapport aux autres éléments du tableau. Exemple: Dans le tableau [2, 3, 6, 6, 5] maximum = 6 et le deuxième maximum = 5, car il a la différence minimale avec l'élément maximum 6 - 5 = 1 la solution pour le deuxième plus grand = 5

function printSecondMax(myArray) {
  var x, max = myArray[0];
  // Find maximum element 
  for(x in myArray){
     if(max < myArray[x]){
        max = myArray[x];
     }
  }
  var secondMax = myArray[0], diff = max - secondMax;
  // Find second max, an element that has min diff with the max
  for(x in myArray){
    if(diff != 0 && (max - myArray[x]) != 0 && diff > (max - myArray[x])){
        secondMax = myArray[x];
        diff = max - secondMax;
    }
  }
  console.log(secondMax);
}

Complexité: O (n), c'est la manière la plus simple de le faire.

Pour trouver le maximum d'éléments encore plus efficacement, on peut chercher dans max heap , un appel à max-heapify prendra le temps O (log n) pour trouver le max et ensuite, pop-up l'élément supérieur donnera le maximum. Pour obtenir le deuxième maximum, max-heapify après avoir sauté le haut et continue à apparaître jusqu'à ce que vous obteniez un nombre inférieur au maximum. Ce sera le deuxième maximum. Cette solution a la complexité O (n log n).


Answer #8

Si cette question vient de l'intervieweur, veuillez NE PAS UTILISER la technique de TRI ou N'utilisez aucune méthode intégrée telle que Arrays.sort ou Collection.sort. Le but de ces questions est de savoir si votre solution est optimale en termes de performances, de sorte que la meilleure option serait simplement d'implémenter votre propre logique avec l'implémentation O (n-1). Le code ci-dessous est strictement réservé aux débutants et non aux gars expérimentés.

  public void printLargest(){


    int num[] ={ 900,90,6,7,5000,4,60000,20,3};

    int largest = num[0];

    int secondLargest = num[1];

    for (int i=1; i<num.length; i++)
    {
        if(largest < num[i])
        {
            secondLargest = largest;
            largest = num[i];


        }
        else if(secondLargest < num[i]){
            secondLargest = num[i];
        }
    }
    System.out.println("Largest : " +largest);
    System.out.println("Second Largest : "+secondLargest);
}

Answer #9

Si la complexité temporelle n'est pas un problème, vous pouvez exécuter le tri par bulles et dans deux itérations, vous obtiendrez votre deuxième nombre le plus élevé car, lors de la première itération de la boucle, le plus grand nombre sera déplacé vers le dernier. Dans la deuxième itération, le deuxième plus grand nombre sera déplacé en dernier.


Answer #10

Si vous voulez le 2ème plus haut et le plus haut index de nombre dans le tableau alors ....

public class Scoller_student {

    public static void main(String[] args) {
        System.out.println("\t\t\tEnter No. of Student\n");
        Scanner scan = new Scanner(System.in);
        int student_no = scan.nextInt();

        // Marks Array.........
        int[] marks;
        marks = new int[student_no];

        // Student name array.....
        String[] names;
        names = new String[student_no];
        int max = 0;
        int sec = max;
        for (int i = 0; i < student_no; i++) {
            System.out.println("\t\t\tEnter Student Name of id = " + i + ".");

            names[i] = scan.next();
            System.out.println("\t\t\tEnter Student Score of id = " + i + ".\n");

            marks[i] = scan.nextInt();
            if (marks[max] < marks[i]) {
                sec = max;
                max = i;
            } else if (marks[sec] < marks[i] && marks[max] != marks[i]) {
                sec = i;
            }
        }

        if (max == sec) {
            sec = 1;
            for (int i = 1; i < student_no; i++) {
                if (marks[sec] < marks[i]) {
                    sec = i;
                }
            }
        }

        System.out.println("\t\t\tHigherst score id = \"" + max + "\" Name : \""
            + names[max] + "\" Max mark : \"" + marks[max] + "\".\n");
        System.out.println("\t\t\tSecond Higherst score id = \"" + sec + "\" Name : \""
            + names[sec] + "\" Max mark : \"" + marks[sec] + "\".\n");

    }
}

Answer #11

Utiliser la fonction suivante
`

public static int secHigh(int arr[]){
            int firstHigh = 0,secHigh = 0;
            for(int x: arr){
                if(x > firstHigh){
                    secHigh = firstHigh;
                    firstHigh = x;
                }else if(x > secHigh){
                    secHigh = x;
                }
            }
            return secHigh;
        }

Appel de fonction

int secondHigh = secHigh(arr);

Answer #12

import java.util.Scanner;

Classe publique SecondHighestFromArrayTest {

public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    System.out.println("Enter size of Array");
    int size = scan.nextInt();
    int[] arr = new int[size];
    for (int i = 0; i < size; i++) {
        arr[i] = scan.nextInt();
    }
    System.out.println("second highest element " + getSecondHighest(arr));
}

public static int getSecondHighest(int arr[]) {
    int firstHighest = arr[0];
    int secondHighest = arr[0];
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] > firstHighest) {
            secondHighest = firstHighest;
            firstHighest = arr[i];
        } else if (arr[i] > secondHighest) {
            secondHighest = arr[i];
        }
    }
    return secondHighest;
}

}


Answer #13
   /* Function to print the second largest elements */
    void print2largest(int arr[], int arr_size)
    {
   int i, first, second;

   /* There should be atleast two elements */
   if (arr_size < 2)
   {
    printf(" Invalid Input ");
    return;
    }

   first = second = INT_MIN;
   for (i = 0; i < arr_size ; i ++)
   {
    /* If current element is smaller than first
       then update both first and second */
    if (arr[i] > first)
    {
        second = first;
        first = arr[i];
    }

    /* If arr[i] is in between first and 
       second then update second  */
    else if (arr[i] > second && arr[i] != first)
        second = arr[i];
   }
   if (second == INT_MIN)
    printf("There is no second largest elementn");
    else
    printf("The second largest element is %dn", second);
    }

Answer #14
// Initialize these to the smallest value possible
int highest = Integer.MIN_VALUE;
int secondHighest = Integer.MIN_VALUE;

// Loop over the array
for (int i = 0; i < array.Length; i++) {

    // If we've found a new highest number...
    if (array[i] > highest) {

        // ...shift the current highest number to second highest
        secondHighest = highest;

        // ...and set the new highest.
        highest = array[i];
    } else if (array[i] > secondHighest)
        // Just replace the second highest
        secondHighest = array[i];
    }
}

// After exiting the loop, secondHighest now represents the second
// largest value in the array

Modifier:

Oups. Merci d'avoir signalé mon erreur, les gars. Correction maintenant


Answer #15
import java.util.Scanner;

public class SecondLargest {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter size of array : ");
        int n = sc.nextInt();
        int ar[] = new int[n];
        for(int i=0;i<n;i++)
        {
            System.out.print("Enter value for array : ");
            ar[i] = sc.nextInt();
        }
        int m=ar[0],m2=ar[0];
        for(int i=0;i<n;i++)
        {
            if(ar[i]>m)
                m=ar[i];
        }
        for(int i=0;i<n;i++)
        {
            if(ar[i]>m2 && ar[i]<m)
                m2=ar[i];
        }
        System.out.println("Second largest : "+m2);
        sc.close();
    }
}

Answer #16
public class SecondHighest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        /*
         * Find the second largest int item in an unsorted array.
         * This solution assumes we have atleast two elements in the array
         * SOLVED! - Order N. 
         * Other possible solution is to solve with Array.sort and get n-2 element.
         * However, Big(O) time NlgN 
         */

        int[] nums = new int[]{1,2,4,3,5,8,55,76,90,34,91};
        int highest,cur, secondHighest = -1;

        int arrayLength = nums.length;
        highest = nums[1] > nums[0] ? nums[1] : nums[0];
        secondHighest = nums[1] < nums[0] ? nums[1] : nums[0];

        if (arrayLength == 2) {
            System.out.println(secondHighest);

        } else {

            for (int x = 0; x < nums.length; x++) {

                cur = nums[x];
                int tmp;

                if (cur < highest && cur > secondHighest)
                    secondHighest = cur;

                else if (cur > secondHighest && cur > highest) {
                    tmp = highest;
                    highest = cur;
                    secondHighest = tmp;
                }

            }   

            System.out.println(secondHighest);

        }   
    }
}

Answer #17
public class SecondLargestNumber
{
  public static void main(String[] args)
  {
    int[] var={-11,-11,-11,-11,115,-11,-9};
    int largest = 0;
    int secLargest = 0;
    if(var.length == 1)
    {
      largest = var[0];
      secLargest = var[0];
    }
    else if(var.length > 1)
    {
      largest= var[0];
      secLargest = var[1];
      for(int i=1;i<var.length;i++)
      {
        if(secLargest!=largest)
        {
          if(var[i]>largest)
          { 
            secLargest = largest;
            largest = var[i];
          }
          else if(var[i]>secLargest && var[i] != largest)
          {
            secLargest= var[i];
          }
        }
        else
        {
          if(var[i]>largest)
          {
           secLargest = largest;
           largest = var[i];
          }
          else
          {
           secLargest = var[i];
          }
       }
    }
  }

    System.out.println("Largest: "+largest+" Second Largest: "+secLargest);
  }
}

Answer #18
public class SecondandThirdHighestElement {
    public static void main(String[] args) {
        int[] arr = {1,1,2,3,8,1,2,3,3,3,2,3,101,6,6,7,8,8,1001,99,1,0};
        // create three temp variable and store arr of first element in that temp variable so that it will compare with other element
        int firsttemp = arr[0];
        int secondtemp = arr[0];
        int thirdtemp = arr[0];
        //check and find first highest value from array by comparing with other elements if found than save in the first temp variable 
        for (int i = 0; i < arr.length; i++) {
            if(firsttemp <arr[i]){
                firsttemp =  arr[i];
            }//if

        }//for
        //check and find the second highest variable by comparing with other elements in an array and find the element and that element should be smaller than first element array
        for (int i = 0; i < arr.length; i++) {
            if(secondtemp < arr[i] && firsttemp>arr[i]){
                secondtemp = arr[i];
            }//if
        }//for
        //check and find the third highest variable by comparing with other elements in an array and find the element and that element should be smaller than second element array

        for (int i = 0; i < arr.length; i++) {
            if(thirdtemp < arr[i] && secondtemp>arr[i]){
                thirdtemp = arr[i];
            }//if
        }//for

        System.out.println("First Highest Value:"+firsttemp);
        System.out.println("Second Highest Value:"+secondtemp);
        System.out.println("Third Highest  Value:"+thirdtemp);

    }//main
}//class

Answer #19
public class secondLargestElement 
{
    public static void main(String[] args) 
    {
        int []a1={1,0};
        secondHigh(a1);
    }

    public static void secondHigh(int[] arr)
    {
        try
        {
            int highest,sec_high;
            highest=arr[0];
            sec_high=arr[1];

                for(int i=1;i<arr.length;i++)
                {
                    if(arr[i]>highest)
                    {           
                        sec_high=highest;
                        highest=arr[i]; 
                    }
                    else 
                    // The first condition before the || is to make sure that second highest is not actually same as the highest , think 
                        // about {5,4,5}, you don't want the last  5 to be reported as the sec_high
                        // The other half after || says if the first two elements are same then also replace the sec_high with incoming integer
                        // Think about {5,5,4}
                    if(arr[i]>sec_high && arr[i]<highest || highest==sec_high)
                        sec_high=arr[i];
                }
            //System.out.println("high="+highest +"sec"+sec_high);
            if(highest==sec_high)
                System.out.println("All the elements in the input array are same");
             else
                 System.out.println("The second highest element in the array is:"+ sec_high);

         }

        catch(ArrayIndexOutOfBoundsException e)
        {
        System.out.println("Not enough elements in the array");
        //e.printStackTrace();
        }
    }
}




java