Bonjour,

Pour une suite de Syracuse, j'ai dû créer un tableau avec la déclaration suivante : ArrayList <Integer> tabArray = new ArrayList <Integer> () ;

Mon tableau me permet de stocker les termes de ma suite, puis de les trier par ordre croissant, ce grâce à deux méthodes.

Mais, ce que j'aimerai désormais faire, ce serait de trouver quels termes de ma suite sont supérieurs au premier terme, ce, avant qu'un des terme ait une valeur inférieure au premier terme.
Un exemple pour illustrer ce que je dis...
5 - 16 - 8 - 4 - 6 - 2 - 1
ATTENTION c'est un exemple qui est FAUX, en effet, en réalité il n'y aurait pas le chiffre 6.
Bon, dans cette suite, la durée de vol en altitude (ce que j'ai expliqué plus haut) serait égale à 3, il y aurait en effet le 5, 16 et le 8 mais pas le 6 car 4 < 5.

Je ne sais pas comment procéder... pour seulement sélectionner ces 3 premières valeurs, et ne pas prendre en compte le 6.

Si vous avez des questions sur le fonctionnement de la suite, n'hésitez pas à me les poser, je ne pense pas avoir été clair à 100%.
Merci à ceux qui m'ont aidé à développer ce petit programme jusqu'à présent

A bientôt et bonne journée.

Salut, donc si j'ai bien compris ton premier chiffre est celui de référence et dès que tu tombe sur un qui est infèrieur tu ne prend pas le reste c'est bien cela?

Oui exactement
Enfin, c'est uniquement pour calculer la durée en altitude que je ne prend pas le reste, car j'affiche tous les termes jusqu'au cycle "4, 2, 1" sur ma console.

Et cette procédure te pose problème?!
Essaye de l'écrire en pseudo code tu va direct trouver comment résoudre ça!
Bon hésite pas à revenir si tu n'y arrive pas mais là c'est vraiment pas compliqué.
Essaye de résonné juste en français déjà.
Un indice: ajoute dans une nouvelle liste seulement si le chiffre en cours dans ta boucle est supérieur au chiffre que tu a sauvegarder dans une variable au début (enfin c'est plus qu'un indice mais déjà c'est pas le code, cela te fera au moins manipuler).

Le problème est que je me retrouve à chaque fois dans une boucle infinie, j'ai essayé avec while et for mais en vain :s

bah tu ne connait pas le break? Fait voir ton code sinon, je vais te dire.

Oki je vais te montrer le code car je suis dans le flou total avec cette histoire x) C'est certainement un truc tout bête comme tu l'as dis, mais je ne dois pas réfléchir comme il faut :/

Je te MP avec mon code et je rajouterai ce qu'il faut à ce sujet quand la solution sera trouvée.
A tout de suite

Sinon, bien que tu décrives ton problème, j'aurai apprécié un petit récapitulatif tel que
entreé: suite
sortie: ...

Parce que la tu veux récuperer toutes les valeurs qui soient supérieures au premier terme de la suite avant que ... vrai ? Mais tu veux quoi en sortie, la suite "filtrée", ou le nombre de valeur supérieur a la première ?

Bonsoir,

Entrée : Premier terme de la suite

Calculs : Tous les termes de la suite jusqu'au chiffre 1
Comptage du nombre de termes trouvés ( = Durée de vol)
Recherche du terme le plus grand ( = Altitude maximale)
Recherche du nombre de termes supérieurs au premier terme, jusqu'à ce qu'un terme soit inférieur au premier terme ( = Durée de vol en altitude)

Sortie : Affichage des résultats de mes calculs

Pour le moment, je me retrouve avec des boucles me donnant des faux résultats, et j'ai beau chercher de différentes manière j'arrive toujours à un échec :s
Si tu veux que je te MP avec le code actuel n'hésite pas à me le demander

Bonne soirée.

Tu peux paster ici le code

Sinon pour compter : ajout d'un compteur qui s'incrémente a chaque tour de boucle
Pour le terme le plus grand : Initialiser une valeur a 0; et a chaque calcul d'une nouvelle valeur dans ta suite; regarder si elle est supérieur a la plus grande trouvée jusqu'a présent, si c'est le cas mettre a jour ta variable contenant la plus grande valeur trouvée pour le moment.
Pour la recherche de termes supérieures, tu peux procéder plus ou moins de la même manière que pour la valeur max (i.e regarder a chaque itération si la valeur courante est plus grande que la première, si oui incrementer une variable contenant le nombre de valeurs supérieures a la première).

Ah mince ! Ce que je vais te dire va t'embêter je crois Il n'y a qu'une chose que je n'arrive pas à faire, c'est le calcul des termes plus élevés que le premier terme.
Et ta méthode ne fonctionne hélas pas

Pourquoi ?

Parce que le programme prend tous les termes de la suite supérieurs au premier terme, sans s'arrêter dès qu'il voit une valeur inférieure au premier terme :s

Je t'envoie mon code par MP ; je posterai ici mon code quand il sera terminé (pour éviter d’embrouiller les gens qui regardent le sujet^^)

Problème résolu. Merci beaucoup à ceux qui m'ont aidé

Voici le code, j'espère l'avoir bien commenté :

import java.util.ArrayList ;
import java.util.Scanner ;

public class Syracuse 
{
	/**
	 * @param args
	 */
	
	public Syracuse() 
	{
		
		// TODO Auto-generated method stub
		
		// Déclatation des variables

		int duree = 0 ;
		boolean superieur = true ;
		int dureeVolAlt = 1 ;
		
		// Objet Scanner
		
		Scanner sc = new Scanner(System.in);

		// L'array list permet d'avoir un tableau de taille variable. Ici c'est un tableau d'objet.
		// Je casterai ce tableau d'objet plus tard en entier.
		// Déclaration du tableau
		
		ArrayList <Integer> tabAltMax = new ArrayList <Integer> () ;		
		
		System.out.println("Saisissez un nombre de départ appartenant à N : ") ;
		int first = sc.nextInt() ;
		
		// On donne à la variable "courante" la valeur du premier terme "first"
		
		int courante = first ;
		
		// Si le premier terme est supérieur à 1
		
		if (first > 1)
		{
			do 
			{	
				// Si le terme est pair : on le divise par 2
				
				if (courante % 2 == 0) 
				{
					courante /= 2 ;
					duree ++ ;
				} 
				
				// Sinon, si le terme est impair : on le multiplie par 3 et on lui ajoute 1
				
				else 
				{
					courante *= 3 ;
					courante ++ ;
					duree ++ ;
				}
				
				// Si le terme actuel est supérieur au premier terme et que "superieur" est vrai

				if (courante > first && superieur) 
				{
					dureeVolAlt ++ ;
				} 
				
				// Sinon, si le terme actuel est inférieur au premier terme, "superieur" devient faux
				
				else if (courante < first) 
				{
					superieur = false ;
				}

				// On caste ici le tableau d'objet en entier
				
				tabAltMax.add((int)courante) ;
				
				// Tant que "courante" est différente de 1
				
			} while (courante != 1) ;
			
			// On affiche respectivement les termes, leur durée de vol et leur durée de vol en altitude
					
			System.out.println(tabAltMax) ;
			  System.out.println("Durée de vol : " + duree) ;
			    System.out.println("Durée de vol en altitude : " + dureeVolAlt) ;
					    
		    // Appel de la méthode triCroissant, je lui envoie mon tableau d'objet en paramètre
		    
		    this.triCroissant(tabAltMax) ;
		
			// Appel de la méthode altitudeMaximale, je lui envoie mon tableau d'objet en paramètre
		
			this.altitudeMaximale(tabAltMax) ;					
		}
		
		// Sinon si le premier terme est égal à 1
		
		else if (first == 1)
		{
			System.out.println("Avec 1 en premier terme, on obtient uniquement le cycle 4, 2, 1") ;
		}
		
		// Sinon, si le premier terme est inférieur à 1
		
		else
		{
			System.out.println("Mauvaise saisie") ;
		}
	}
	
	/*
	 * Pour trier, il faut utiliser un algorithme qui peut être le tri à bulle, c'est le cas ici.
	 * Voir wikipédia: http://fr.wikipedia.org/wiki/Tri_à_bulles
	 */
	
	public void triCroissant(ArrayList <Integer> tabAltMax)
	{
		// Cette variable temporaire permet de récupérer la première valeur sur les 2 que l'on travaille
		
		int temp = 0 ;
		
		// Size (pour un objet, ici l'arraylist) est équivalent à Length (pour un tableau à taille fixe)
		
		for(int i = 0 ; i < (tabAltMax.size() - 1) ; i++)
		{
			for(int j = 0 ; j < (tabAltMax.size() - 1) ; j++)
			{
				if(tabAltMax.get(j) >= tabAltMax.get(j + 1))
				{
					// On copie la première valeur dans la variable temporaire
					
					temp = tabAltMax.get(j);
					
					// On remplace la première valeur par la deuxième valeur
					// Envoie à l'emplacement j de l'arrayList le contenu de l'emplacement j+1 de l'arrayList
					
					tabAltMax.set(j, tabAltMax.get(j + 1));
					
					// On remplace la deuxième valeur par la première valeur soit la variable temp
					
					tabAltMax.set(j + 1, temp);
				}
			}	
		}
	}
	
	public void altitudeMaximale(ArrayList <Integer> tabAltMax)
	{
		// On initialise une variable en prenant la plus petite valeur possible
		
		int valeurMax = 0 ;
		
		for(int i = 0 ; i < tabAltMax.size() ; i++)
		{
			// Cette condition permet de trouver une valeur plus importante que celle trouvée précédemment
			
			if(tabAltMax.get(i) > valeurMax)
			{
				// A chaque fois on remplace la variable valeurMax par une valeur parcourue dans le tableau qui est plus haute
				
				valeurMax = tabAltMax.get(i) ;
			}
		}

		System.out.println("Altitude maximale : " + valeurMax) ;
	}
}