Latest Updates: fonctionnement des boucles RSS

  • Compter nombre d'occurences de traitements en incrémentant simple variable

    admin 15 h 50 min on 6 décembre 2009 | 0 Permalink | Reply
    Tags: , , fonctionnement des boucles

    Compter en incrémentant la variable nbreCoups à chaque tour de boucle while.

    package poubelle;
import java.util.Scanner;

public class Test {
	public static void main(String[] args){
		Scanner sc= new Scanner(System.in);
		System.out.println(" taille maximale du chiffre ? ");
		int limite= sc.nextInt();
		int rand= (int)((Math.random())*limite)+1;
		System.out.println("chiffre à trouvé " + rand);
		int nbreCoups=1;
		int rand2= (int)((Math.random())*limite)+1;

		while (rand2!=rand){
			rand2=(int)((Math.random())*limite)+1;
			nbreCoups++;
			System.out.println("Il faut trouvé le chiffre: " + rand + " et je propose " + rand2 + " pour la tentative n° " + nbreCoups);
		}
	}
}
     

  • Créer un programme qui fusionne deux chaines de caractères

    admin 0 h 11 min on 8 octobre 2009 | 1 Permalink | Reply
    Tags: , fonctionnement des boucles

    Enoncé exercice : créer un programme qui fusionne deux chaines de caractère que l’utilisateur envoie au système. Les mots entrés par l’utilisateur peuvent contenir un nombre différents de caractères. Si par exemple l’utilisateur entre le mot bonjour et le mot hello, le résultat à l’affichage sera « HBeolnljoour »

    import java.util.Scanner;
public class Fusion {
	public static  String merge(String s, String t){
		String res = "";
		int i,j,k;
		for (  i=0, j=0 ; i < s.length() && j < t.length(); i++, j++){
			res += Character.toString(s.charAt(i)) + Character.toString(t.charAt(j));
			//  s.charAt(i) et t.charAt(j)sont des types primitifs, pour pouvoir utiliser
			//la methode toString, il faut utiliser la methode statique toString qui se trouve
			//dans la classe "Character" . Car cette méthode s'applique sur un char, or on a besoin de l'objet même que represente le type primitif
		}
		// on traite la chaine la plus longue...
		String laPlusLongue = s.length() > t.length() ? s : t;
		// equivalent à :
		//		if(s.length() > t.length())
		//			laPlusLongue = s;
		//		else
		//			laPlusLongue = t;
		for( k = i; k < laPlusLongue.length(); k++) {
			res += Character.toString(laPlusLongue.charAt(k));
		}
		return res;
	}
	public static void main(String[] args) {
		System.out.println("Veuillez entrer une chaine de caractère");
		Scanner MonScanner = new Scanner(System.in);
		String result = MonScanner.next();
		System.out.println("Veuillez entrer une chaine de caractère");
		String result2 = MonScanner.next();

		String res = merge(result, result2);
		System.out.println(res);
	}

}
     

  • Exercices sur les boucles: 100 piles ou faces

    admin 16 h 20 min on 19 septembre 2009 | 0 Permalink | Reply
    Tags: , fonctionnement des boucles 

    public class UKOex7 {
	public static void main(String[] args) { // méthode main porte d'entrée du programme.
		TestCoin.test(); // on appel la méthode test() sur l'objet TestCoin
	}
}

class TestCoin {
	public static void test() {
		Coin jeton = new Coin(); // Instanciation du jeton qui va nous servir pour le jeu
		int nbPile = 0, nbFace = 0;
		for(int i = 0; i < 100; i++) { // A chaque execution du programme, on va "lancer" 100fois le jeton
			jeton.toss();
			if(jeton.isHead()) nbFace++;
			else nbPile++;
		}
		// Maintenant on affiche à l'écran les résultat des 100 tours de boucle (1 tour de boucle = 1 pile ou face)
		System.out.println("Nombre de faces : " + nbFace);
		System.out.println("Nombre de piles : " + nbPile);
	}
}

class Coin {
	boolean pile;
	public void toss() {
		int resultat = (int) (Math.random() * 10); // resultat compris entre 0 et 9, utilisation de la méthode randoom pour génerer un chiffre aléatoirement.
		if(resultat <= 4) pile = true;
		else pile = false;
	}
	public boolean isHead() {
		return !pile;
	}
	public boolean isTail() {
		return pile;
	}
}
     

  • Mettre des données dans un tableau et tester leurs présences

    admin 16 h 01 min on 19 septembre 2009 | 0 Permalink | Reply
    Tags: , fonctionnement des boucles, 

    public class MonLivre {
	public static void main(String[] args) {
		Person mehdi = new Person("Mehdi Z.", 3931907);
		Person karim = new Person("Karim M.", 1234567);

		Person[] tab1 = new Person[]{mehdi}; //on crée un tableau et on met une chaine de caractère qui correspond à un prenom d'auteur
		Person[] tab2 = new Person[]{karim};
		Person[] tab3 = new Person[]{mehdi, karim};// création d'un tableau à 2indices, on place 2 prénoms, chaque prenoms dans uen cellule distincte du tableau.

		Book b1 = new Book("Java pour enfants, version améliorée", "97892374987", tab1);//création d'un livre
		Book b2 = new Book("Java avancé", "97892374988", tab2);
		Book b3 = new Book("Intro HTML", "97892374989", tab3);

		System.out.println("Mehdi auteur de b1 ? " + b1.isAnAuthor(mehdi)); //on appel la méthode isAnAuthor() qui test si le prenom testé est celui d'un auteur contenu dans un des tableaux crées

		System.out.println("Karim auteur de b1 ? " + b1.isAnAuthor(karim));
		System.out.println("Mehdi auteur de b2 ? " + b2.isAnAuthor(mehdi));
		System.out.println("Karim auteur de b2 ? " + b2.isAnAuthor(karim));
		System.out.println("Mehdi auteur de b3 ? " + b3.isAnAuthor(mehdi));
		System.out.println("Karim auteur de b3 ? " + b3.isAnAuthor(karim));
	}
}

// classe privée
class Book {// création d'une classe Book
	String titre;
	String ISBN;
	Person[] tab;

	Book(String t, String isbn, Person[] tab_reçu) {// on utilise le constructeur de la classe Book .
		titre = t;
		ISBN  = isbn;
		tab = tab_reçu;
	}

	public boolean isAnAuthor(Person p) { // enfin on crée une méthode booléenne qui va tester si un auteur fait parti du tableau.
		for(int i = 0; i < tab.length; i++) {
			if(p.equals(tab[i])) {    // Utilisation de la méthode equals pour tester si les deux objets sont identique
				return true;
			}
		}
		return false;
	}
}

//classe privée
class Person {
	String nom;
	int idnb;

	Person(String n, int ni) { // on utilise le constructeur pour définir des valeur de variables
		nom = n;
		idnb = ni;
	}

	public boolean equals(Person p) {

		return this.idnb == p.idnb;
	}
}
     

  • Première boucle: compter jusque 1000

    admin 14 h 49 min on 13 septembre 2009 | 0 Permalink | Reply
    Tags: , fonctionnement des boucles

    Exercice de base sur l’utilisation et le fonctionnement des boucles.

    Enoncé de l’exercice : créer un programme qui compte jusque mille et affiche la valeur de i à chaque tour de boucle.

    package loops;
public class boucle1 {
	public static void hand (G-string [] Args) {
		for (int I = 0; I <= 1000; i++) {
			System.out.println (I);
		}
		//To put G-string in a table… index 0=salut, index 1= vacuum, index 2 = no one
		//index 3= no one, index 4 = goodbye.
		G-string [] = {“Hello”, "", no one, "", “Goodbye! ”};
		//prints the contents of the table
		for (int I = 0; I < tab.length; i++) System.out.println ([I]); //it has there only one instruction, the loop can thus be written without accodances.
	}
}
     

  • Calculer moyenne

    admin 16 h 20 min on 1 septembre 2009 | 0 Permalink | Reply
    Tags: , fonctionnement des boucles

    Enoncé de l’exercice : construire un programme qui calcule la moyenne des entiers entrée par un utilisateur. Les entiers sont compris entre 0 et 20. Si l’utilisateur entre un entier supérieur à 20, cet entier sera ignoré par le programme. Lorsque l’utilisateur appuiera sur la touche m, le programme affichera la moyenne des entiers entrés. Si l’utilisateur appuie sur la touche x, le programme se termine.

    import java.util.Scanner;
public class CalculerMoyenne {

public static void main (String[] Args){
	Scanner monScanner = new Scanner(System.in);
	double somme = 0, i, moyenne;
	String valeurEntrée;
	for(i = 0; true; i++) {
		System.out.println("Veuillez entrer un nombre entre 0 et 20.");
		valeurEntrée = monScanner.next();

		if(valeurEntrée.equals("x")) { // pour quitter
			System.out.println("Ciao !");
			return;
		} else if(valeurEntrée.equals("m")) { // pour afficher la moyenne ET quitter
			break;
		}

		try {
			double d = Double.parseDouble(valeurEntrée);
			if(d >= 0 && d <= 20)
				somme += d;
			else {
				System.out.println("Vous avez entré un nombre non compris entre 0 et 20.");
				i--;
			}
		} catch(NumberFormatException e) {
			System.out.println("NumberFormatException: vous n'avez pas entré un double !");
			i--; // pour contrer le i++
		}
	}
	if(i > 0) {
		moyenne = somme/i;
		System.out.println("La moyenne est de : " + moyenne);
	} else {
		System.out.println("Pas de moyenne à calculer !");
	}
}
}
     

  • Utilisation des boucles: chiffre caché

    admin 16 h 12 min on 1 septembre 2009 | 0 Permalink | Reply
    Tags: , fonctionnement des boucles

    Enoncé de l’exercice : créer un programme qui permet à l’utilisateur de trouver un entier généré par le programme (entre 0 et 20). Le programme indique à l’utilisateur si l’entier entré par ce dernier est plus petit ou plus grand que l’entier généré par le programme.

    import java.util.InputMismatchException;
import java.util.Scanner;
import java.util.Random;
// on a mis 20 en argument au programme.
public class UKOex10 {
	public static void main(String[] args) {
		Scanner monScanner = new Scanner(System.in);
		int MIN = 0, MAX = Integer.parseInt(args[0]); // récupère le premier argument : 20
		int RANDOM = new Random().nextInt(MAX+1); // contient une valeur entre 0 et MAX
		// i contiendra le nombre de coups
		for(int i = 1; true; i++) {
			// le try catch est le code de la gestion d'erreurs possibles
			try {
				System.out.print("? ");
				int nombreEntré = monScanner.nextInt();
				if(nombreEntré > RANDOM)
					System.out.println("Trop grand");
				else if(nombreEntré < RANDOM)
					System.out.println("Trop petit");
				else {
					System.out.println("Bravo ! En " + i + " coups !");
					return; // on utilise un return, pour signifier au programme qu'on a fini
				}
				System.out.println();
			} catch(InputMismatchException e) {
				System.out.println("Vous n'avez pas respecté les consignes !!!");
				return;
			}
		}
	}
}
     

  • Tester si l'objet est un palindrome

    admin 20 h 52 min on 28 août 2009 | 0 Permalink | Reply
    Tags: , fonctionnement des boucles

    Construire une méthode qui dit si l’objet testé est un palindrome. (Qu’est ce qu’un palindrome : définition wikipedia).

    public class palindrome {
	public static boolean isPalindromeMehdi(String s) {
		char[] s_i = new char[s.length()];
		int n = s.length();

		for(int i = n-1, j = 0; i >= 0; i--, j++) {
			s_i[j] = s.charAt(i);
		}
		String s_inv = new String(s_i);
		return s.equals(s_inv);
	}
	public static boolean isPalindromeKarim(String s) {
		int n = s.length();
		for(int i = 0; i < n/2; i++) {
			if(s.charAt(i) != s.charAt(n-i-1)) {
				return false;
			}
		}
		return true;
	}
	public static void main(String[] args) {
		System.out.println(isPalindromeMehdi("radar"));
		System.out.println(isPalindromeMehdi("salut"));
		System.out.println(isPalindromeKarim("radar"));
		System.out.println(isPalindromeKarim("salut"));
	}
}
     

  • Inverser une chaine de String

    admin 20 h 43 min on 28 août 2009 | 0 Permalink | Reply
    Tags: , fonctionnement des boucles

    Énoncé exercice : Construire une méthode (reverse) qui inverse une chaine de caractère. Par exemple si on appel la méthode reverse (« salut »), la méthode renvoie « tulas ».

    import java.util.Scanner;
public class SolutionSalut {
	public static void main(String[] args) {
		System.out.println("Veuillez entrer une chaine...");
		Scanner monScanner = new Scanner(System.in);  //création d’un scanner dans la variable nommée monscanner
		monScanner.useDelimiter("\n");  // on précise au programme quel sera le délimiteur à utilisé (par défaut « \n », donc la touche entrer du clavier)
		String result = monScanner.next(); // on récupère le traitement du scanner dans une variable en appliquant la méthode next() à monScanner
		int n = result.length(); // la méthode length permet de calculer la longueur de la chaine récupérée dans result
		// On créer une boucle tant que i est plus grand ou égale à zéro on remonte de 1 cellule dans le tableau (jusqu’à ce que l’on arrive à la cellule possédante l’indice 0, à ce moment la boucle s’arrête)</code>

		for (int i = n - 1; i >= 0; i--)
		{
			System.out.print (result.charAt(i));
		}
	}
}
     

  • Filtrer occurences de caractères dans chaine de String

    admin 20 h 27 min on 28 août 2009 | 0 Permalink | Reply
    Tags: , fonctionnement des boucles

    Filtrer des caractères contenus dans une chaine String pour les supprimer
    Exercice :

    Créer une méthode qui renvoie une chaine de caractère (str), dont les caractères présents dans le tableau tab [] ont été supprimés. Par exemple, si on appel la méthode filtre (Bonjour = new char[] { ‘o’, ‘u’}); Alors la méthode renvoie Bnjr.

    public class EstPresent {
	// vérifie si le caractère c est présent dans le tab
	public static boolean isCharPresent(char[] tab, char c) {
		for(int i = 0; i < tab.length; i++) {
			if(tab[i] == c) return true;
		}
		return false;
	}
	// renvoie une chaine de caractères correspondant à la chaine str
	// dont toutes les occurrences des caractères présents dans le tableau tab ont été supprimées
	public static String filter(String str, char[] tab) {
		String res = "";
		for(int i = 0; i < str.length(); i++) {
			if(!isCharPresent(tab, str.charAt(i))) {
				res += str.charAt(i);
			}
		}
		return res;
	}

	public static void main(String[] args) {
		String filtrée = filter("Bonjour", new char[] {'o', 'u'});
		System.out.println(filtrée);
	}
}
     

Older Posts →

c
compose new post
j
next post/next comment
k
previous post/previous comment
r
reply
e
edit
o
show/hide comments
t
go to top
esc
cancel