Trouver des numéros dans une rangée?

Question

Je travaille sur un algorithme, et je dois pouvoir passer dans une liste et voir s'il y a quatre nombres dans une rangée à n'importe quel point dans la liste.

Je me bats avec un moyen facile de le faire ... Voici l'idée de base .. Je voudrais la méthode fourNumbersInARow() pour retourner vrai:

import java.util.ArrayList; 
import java.util.List; 
import java.util.Random; 


public class Numbers { 

    /** 
    * @param args 
    */ 
    public static void main(String[] args) { 
     List<Integer> numbers = new ArrayList<Integer>(); 
     for(int i = 0; i<10; i++){ 
      numbers.add((new Random().nextInt())); 
     } 
     numbers.add(1); 
     numbers.add(2); 
     numbers.add(3); 
     numbers.add(4); 

     System.out.println(fourNumbersInARow()); 

    } 

    private static boolean fourNumbersInARow() { 


    } 

} 

Answer 1

est ici une implémentation en Java.

static boolean fourNumbersInARow(List<Integer> list) { 
    int last = 0xFACADE; // can be any number 
    int count = 0;  // important! 
    for (int i : list) { 
     if (i == last + 1) { 
      if (++count == 4) return true; 
     } else { 
      count = 1; 
     } 
     last = i; 
    } 
    return false; 
} 

Contrairement à d'autres, ce remet à zéro le nombre de numéros dans une ligne à 1 lorsque la séquence est rompue (car un numéro sur son propre est le numéro 1 de suite). Ceci permet de traiter plus facilement la première itération là où techniquement il n'y a pas de numéro précédent.

Answer 2

Utilisez deux variables: last_value et row_count. En parcourant la liste un par un, regardez toujours si la valeur actuelle est exactement une plus grande que la last_value; Si oui, augmentez row_count, sinon, réinitialisez-la à 1. Dans tous les cas, définissez last_value sur la valeur actuelle et bouclez. Si à tout moment row_count devient 4, renvoyer true. Si vous atteignez la fin de la liste, renvoyez false.

_{EDIT: plage compteur changé pour commencer à 1}

Answer 3

Cela sonne un peu comme une question de devoirs, alors je ne veux pas écrire une solution complète. Mais dans votre méthode il suffit de parcourir la liste. Prendre le premier nombre et voir si le prochain numéro vient après le courant, si oui alors définir un drapeau de variable avec la position de départ et le nombre actuel, à l'itération suivante par le contrôle de la boucle pour voir si cette valeur est antérieure à la précédente etc ... Une fois quatre dans une rangée sont trouvés, sortir de la boucle et retourner vrai. Si vous rencontrez un nombre qui n'est pas chronologiquement correct, définissez un indicateur (emplacement de départ) sur null ou négatif et recommencez le processus à partir de l'emplacement actuel dans la liste.

Answer 4

En pseudocode:

consecutiveCount = 1 
lastNumber = firstElementInList(list) 

for (number in list.fromSecondElement()): 
    if (number - lastNumber == 1): 
    consecutiveCount++ 
    else: 
    consecutiveCount = 1 

    if (consecutiveCount == 4): 
    return true 

    lastNumber = number 

return false 

La ligne de fond est, vous aurez envie de garder une trace du dernier numéro qui figure dans la liste, et de le comparer avec le nombre actuel pour voir si la différence est 1. Afin de se rappeler le dernier nombre, une variable telle que lastNumber est nécessaire. Puis, afin de garder une trace du nombre de numéros consécutifs, il devrait y avoir un compteur pour cela aussi, ce qui dans l'exemple est le consecutiveCount.

Lorsque la condition où quatre nombres consécutifs se sont produits, la méthode doit renvoyer true.

Answer 5

vérifierons ce code, cela retourne vrai s'il y a une séquence de 4 chiffres et d'autre sinon false

public class FindFourSequence { 

    public boolean isFourinRow(ArrayList seqList) { 

     boolean flag = false; 
     int tempValue = 0; 
     int tempValue2 = 0; 
     int tempValue3 = 0; 
     int tempValue4 = 0; 
     Iterator iter = seqList.iterator(); 
     while(iter.hasNext()){ 
      String s1 = (String)iter.next(); 
      tempValue=Integer.valueOf(s1).intValue(); 
      if(!(iter.hasNext())){ 
       break; 
      } 
      String s2 = (String)iter.next(); 
      tempValue2=Integer.valueOf(s2).intValue(); 
      if(((tempValue2-tempValue)==1) || (tempValue-tempValue2)==1){ 
       if(!(iter.hasNext())){ 
        break; 
       } 
       String s3 = (String)iter.next(); 
       tempValue3=Integer.valueOf(s3).intValue(); 
       if((tempValue3-tempValue2)==1 || (tempValue2-tempValue3)==1){ 
        if(!(iter.hasNext())){ 
         break; 
        } 
        String s4 = (String)iter.next(); 
        tempValue4=Integer.valueOf(s4).intValue(); 
        if((tempValue3-tempValue4==1) || (tempValue4-tempValue3)==1){ 
         flag = true; 
         return flag; 
        } 
       } 
      } 
     } 

     return flag; 
    } 

    public static void main(String[] args) throws Exception { 

     ArrayList aList = new ArrayList(); 
     boolean flag = false; 
     FindFourSequence example = new FindFourSequence(); 
     Random random = new Random(); 
     for (int k = 0; k < 25; k++) { 
      int number = random.nextInt(20); 
      System.out.println(" the Number is :" + number); 
      aList.add("" + number); 
     } 
/*  aList.add("" + 1); 
     aList.add("" + 2); 
     aList.add("" + 3); 
     aList.add("" + 4);*/ 
     flag = example.isFourinRow(aList); 
     System.out.println(" the result value is : " + flag); 

    } 
}