Exercices sur les fonctions - Page 1

salut tout le monde
est ce que quelqu'un peu m aider sur cet exercices:

je vois pas ce qui faut utiliser pour retourner un nombre au hasard compris entre 0 et le nombre introduit!

a) Ecrire une fonction dénommée hasard0 prenant en paramètre un entier et retournant un entier.
L'entier retourné sera compris entre 0 et l'entier passé en paramètre.
b) Ecrire une fonction dénommée hasard1 prenant en paramètre un entier et retournant un entier.
L'entier retourné sera compris entre 1 et l'entier passé en paramètre. Pour ce faire, vous ferez
appel à la fonction hasard0.

cordialement.

Indice : cherche du côté de "Random" ^^

oui merci mais je le savais
mais j comprend pas comment l utiliser
j ai chercher et que dalle
c est mal expliquer ou bien c est moi qui est con

C'est bien expliqué.
Je te laisse tirer la douloureuse conclusion.

ok
merci beaucoup les gars
vous m avez vraiment bien aider

enfin
j ai trouver pour le a mais pas le b
j vois pas comment il faut faire pour que l entier soit compris entre 1 et le nombre rentré en parametre et pas entre 0 et le nombre

(int) Math.floor(Math.random()*nbr);

(int) Math.floor(Math.random()*(nbr-1))+1; //nbr>1

merci beaucoup the_chojin
je l aurai jamais trouver
merci infiniment

mouais, ce qui est idiot avec le fait qu'il t'ait directement donné la solution, c'est que tu n'as pas forcément compris pourquoi et comment trouver la prochaine fois... en gros c'est inutile :/

Peut être qu'il n'en a rien à faire de l'info et qu'il veut se débarrasser de cette exercice? Et si il aime l'info, il y a plein d'autre chose où il peut essayer de chercher la solution par lui même. Moi je suis pour donner les solutions rapidement

ok
bin quelqu un peut m expliquer comment on trouve cette methode avec d autre exemple
et merci davance

bon :

Tu veux un entier aléatoire compris entre 1 et N, N étant ton paramètre. Tu peux utiliser une fonction, Math.random () qui génère un nombre aléatoire X tel que 0 <= X < 1, il ne reste donc plus qu'à changer de domaine.

Si tu fais "Math.random () * N", tu obtiendras un nombre décimal X tel que 0 <= X < N, et donc si tu fais (int)(Math.random () * N), en supprimant toutes les décimales, tu as un nombre entier compris entre 0 et N-1 inclus. Il suffit d'ajouter 1 pour avoir le résultat de ta question b, la réponse de the_chojin était donc fausse.

Pour la question a, vu que tu veux un nombre compris entre 0 et N au lieu de 0 et N-1, il faut augmenter le nombre de possibilités au lieu de décaler le domaine, c'est donc au moment de la multiplication qu'il faut ajouter 1 à N pour obtenir "N+1" possibilités différentes plutôt que "N", ce qui donne donc "(int)(Math.random () * (N + 1))".

Mais franchement si tu luttes sur ce genre d'exos, reprends sérieusement des cours d'algorithmique plutôt que de java, dans un premier temps :/

ok merci
mais faut pas oublier aussi que c est ma premiere annee en informatique et
qu on ne fait pas ca au cours d algorithme

et qu au cours de java le prof nous explique que dalle

Heu si tu arrives pas a trouver comment passer d'un nombre entre 0 et 1 a un nombre entre 0 et N (oui il peut y avoir des trucs tres complique derriere, mais pas la), c'est un probleme d'algorithmie ou de logique, comme tu veux.

Zephyr (./12) :
Si tu fais "Math.random () * N", tu obtiendras un nombre décimal X tel que 0 <= X < N, et donc si tu fais (int)(Math.random () * N), en supprimant toutes les décimales, tu as un nombre entier compris entre 0 et N-1 inclus. Il suffit d'ajouter 1 pour avoir le résultat de ta question b, la réponse de the_chojin était donc fausse.

Tiens exact, j'étais persuadé que floor arondissais ... comme round :/

donc c est juste pour etre sur que j ai compris
pour le a c est: nbr=(int)(Math.random()*(N+1));
ex: si N=0 alors nbr=0
et si N=1 alors nbr doit avoir ou bien 1 ou 0

et pour le b c est: nbr=(int)(Math.random()*N)+1;
ex: si N=1 alors nbr=1
et si N=0 alors nbr doit avoir 1 ou bien 0 mais le problem c est que j obtient tjs 1 et jamai 0

cordialement.

Heu ! VOus n'avez pas oublié que pour b) il faut faire appel à hasard0 ?

J'ai l'impression que ce topic va devenir mythique !

the_chojin (./15) :

Zephyr (./12) :
Si tu fais "Math.random () * N", tu obtiendras un nombre décimal X tel que 0 <= X < N, et donc si tu fais (int)(Math.random () * N), en supprimant toutes les décimales, tu as un nombre entier compris entre 0 et N-1 inclus. Il suffit d'ajouter 1 pour avoir le résultat de ta question b, la réponse de the_chojin était donc fausse.

Tiens exact, j'étais persuadé que floor arondissais ... comme round :/

Le terme floor est un mot anglais dont la traduction française littérale est plancher.
Le plancher, c'est ce qui constitue le bas d'une pièce, c'est également l'entier qui représente la borne inférieure d'un intervalle [N;N+1[ _{/ N entier}, l'entier vers lequel sera ramené tout réel de cet intervalle par floor().
Mais une pièce a également un plafond, tout comme un intervalle ]N-1;N] _{/ N entier} a une borne supérieure entière vers lequel peut être ramené tout réel de cet intervalle.
Et en anglais, plafond se dit ceiling... d'où la méthode ceil() dont je vous laisse deviner l'utilité...

Sur un réel, le transtypage (int) fonctionne comme un floor(), donc comme Math.random() donne un résultat réel dans [0;1[, Math.random() * (N+1) donne un résultat réel dans [0;N+1[, donc (int) (Math.random() * (N+1)) donne un résultat entier dans [[0;N+1[[, c'est-à-dire dans [[0;N]], justement ce qui est demandé pour hasard0().
N+1)) ) ; }

On a donc :/** Retourne un entier entre 0 et N inclus */
int hasard0( int N ) {
	return ( (int) (Math.random() * (

Ceux qui savent compter ici verront que hasard0(X) donne (X+1) résultats possibles.
On veut que hasard1(N) donne un résultat entre 1 et N, soit N résultats possibles : comme il faut utiliser hasard0(), est-ce vraiment si difficile que ça de trouver quel paramètre X utiliser ?
Et une fois X trouvé en fonction de N, est-ce vraiment si difficile que ça de trouver quel ajustement faire pour obtenir le résultat escompté ?

C'est peut-être loin pour certains, mais la manipulation d'entiers — représentés par des cailloux, des bananes, des barres de chocolat ou tout ce qui peut convenir —, ça s'apprend à l'école primaire, hein...
Quoiqu'il en soit, ce n'est pas ici un problème de Java ni même d'algo, juste du dénombrement (ie. savoir compter sur ses doigts).

b) moi je le voyais comme ça

*** appeler hasard0 (ce qui est demandé)
*** utiliser une structure while

plutot que de mettre la formule directe.

J'avais un prof assez sévère mais juste pour faire attention à ce genre de détail

Mais elle aurait fait quoi ta boucle while ?

Elle aurait vérifié, tant que cela se serait avéré nécessaire, que le résultat du tirage aléatoire ne valût pas 0.
Je pense que la finalité de la question est de montrer que l'on peut y arriver sans devoir établir une fonction plus compliquée à mettre en oeuvre.

/** Retourne un entier entre 1 et N inclus */
int hasard1( int N ) {
	int r ;
	do {
		r = hasard0(N) ;
	} while ( r == 0 ) ;
	return r ;
}

Ce... machin... est complètement ...
Faire un while pourri uniquement parce que l'on n'a pas envie de sa casser le cul à calculer a et b dans int hasard1( int N ) { return ( a + hasard0( N + b ) ) ; } (diantre, que c'est compliqué !), c'est... inqualifiable ...

Par contre, pour faire mieux, il faudrait vérifier dans hasard0 que N >= 0 (inutile de vérifier dans hasard1 que N >= 1), et, peut-être, lever une exception ou afficher un message d'erreur.

Genre tu en fais pas un peu trop la ?