Schreiben Sie ein Programm, um die Länge der längsten konsekutiven Sequenz im Array von ganzen Zahlen zu finden?

Question

Zum Beispiel Gegeben [100, 4, 200, 1, 3, 2], Die längste aufeinanderfolgende Elemente Sequenz ist [1, 2, 3, 4].

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

    int a[]={10,15,1,2,3,4,5,11,12}; 

    int b=1; 
    int c=0; 
    for(int i=0;i<a.length-1;i++){ 

     if(a[i]-a[i+1]==-1){ 

     b=b+1; 
     c=c+1; 
     if(b>=c) 
     { 

     System.out.println(a[i]); 

     } 
     else{ 
      b=0; 
     } 

    } 

} 
} 
} 

Aber ich bin immer Ausgang als 1 2 3 4 11 während des Ausgang 1 2 sollte 3 4 5.

Wie die erforderliche Leistung bekommen, was den Fehler in einem Code?

Answer 1

Sie können dies ausprobieren:

int[] array = {10,15,1,2,3,4,5,11,12}; 
List<Integer> tempList = new ArrayList<>(); // prepare temp list for later use 
List<List<Integer>> arrays = new ArrayList<>(); // used to store the sequences 
int lastNum = array[0]; // get the fist number for compasion in loop 
tempList.add(lastNum); 
for (int i = 1; i < array.length; i++) { 
    if (array[i]-1 == lastNum) { // check for sequence (e.g fist num was 12, 
     // current number is 13, so 13-1 = 12, 
     // so it has the sequence), then store the number 
     tempList.add(array[i]); // store it to the temp list 
     lastNum = array[i]; // keep current number for the next 
    } else { // if it has not the sequence, start the new sequence 
     arrays.add(tempList); // fist store the last sequence 
     tempList = new ArrayList() // clear for the next sequence 
     lastNum = array[i]; // init the lastNumnber 
     tempList.add(lastNum); 
    } 
} 
// now iterate for the longest array 
// craete an empty array to store the longest 
List<Integer> longestLength = new ArrayList<>(); 
for (List<Integer> arr : arrays) { 
    if (arr.size() > longestLength.size()) { 
     // check if the current array hase the longest size than the last one 
     // if yes, update the last one 
     longestLength = arr; 
    } 
} 
// at the end print the result. 
System.out.println("longestLength = " + longestLength); 

Das Ergebnis:

longestLength = [1, 2, 3, 4, 5] 

Answer 2

Ihr Code sollte funktionieren, wenn Sie das Array zuerst sortieren. Hast du das probiert?

Answer 3

import java.util.*; 
    Arrays.sort(a); 

dann

if(a[i]+1==a[i+1]) 
      //print it 
    else 
     { 
      System.out.print(a[i]); 
      i=a.length; 
     }//stop the loop 

Answer 4

Versuchen Sie diesen Code

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

     int a[]={10,15,1,2,3,4,5,11,12}; 

     int ms=0;     // starting point of max subseq 
     int me=0;     //ending point of max subseq 
     int cs=0,ce=0;    //starting and ending point of current subseq 
     int max=0,c=0;   // length of max and current subseq 
     for(int i=0;i<a.length-1;i++){ 

      if(a[i]-a[i+1]==-1){ 

      if(c==0)    //we found the first element of a subseq 
      { 
       cs=i;ce=i+1;c=2; //made the starting of currrent seq=i, end=i+1 and length=2 
       } 
      else    // element is a part of subsequence but not first elem 
       { 
       ce=i+1;c++;  // increased current ending point 
       } 

       if(c>max)   // if lenth of current subseq is now largest then update staring and ending points of max 
       { 
        max=c; 
        ms=cs; 
        me=ce; 
       } 
      } 
      else    // subseq ended 
      { 
      cs=0; 
      ce=0; 
      c=0; 
       } 
     } 
     for(i=ms;i<=me;i++)   //printing max subsequence 
     System.out.println(a[i]); 
    } 
    } 

Hinweis: siehe Kommentar zur Beschreibung

Answer 5

class Test 
{ 
    public static void main (String[] args) throws java.lang.Exception 
    { 
     int a[]={10,15,1,2,3,4,5,11,12}; 
     Arrays.sort(a); 
     ArrayList<Integer>output = new ArrayList<Integer>(); 
     ArrayList<Integer>temp = new ArrayList<Integer>(); 
     for(int i =1; i<a.length; i++){ 
      //If elements have difference of one, add them to temp Arraylist 
      if(a[i-1] + 1 == a[i]){ 
       temp.add(a[i-1]); 
      } 
      else{ 
       //Add the last consecutive element 
       temp.add(a[i-1]); 

       //If temp is lager then output 
       if(temp.size() > output.size()){ 
        output = (ArrayList<Integer>) temp.clone(); 
         temp.clear(); 
       }   
      } 
     } 

     //Outside for loop, making sure the output is the longer list. This is to handle the case where the consecutive sequence is towards the end of the array 
     if(temp.size() > output.size()){ 
      output = (ArrayList<Integer>) temp.clone();System.out.println("after clone outside for " + output.toString()); 
     } 
     System.out.println(output.toString()); 
    } 

}