Forum TI-Planet.org

Bonjour à nouveau ! J'ai trouver l'outil me permettant de supprimer les crochets du nombre généré par randbin grâce à product()... le nouveau problème, (c'est comme une onde... chaque problème résolu engendre un autre tel le niveau de l'eau s'egalisant.) c'est que mon product() et randbin() n'aiment pas les fractions... qui font des nombre à virgule. Et je n'arrive pas à éliminer mes fractions à cause du fait que je fais la moyenne de a et b dans mon Randbin() de cette façon :

a:=100
b:=0

ApproxRational((Randbin(a,0.5,1)+b/2+0.25),1)->y (Vous noterez que +0.25 est une tentative désespérée pour enpecher b/2 de faire des 0.5...)
y->l13
approxRational(product(l13,1,1),1)->y

Et boum ! Ma liste avec ses crochets n'en a plus !
Mais avec tout ça, j'ai à un endroit fais :
Si p>a alors
à+j+5->a
FinSi
Si p<b alors
b-j-5->b
FinSi
Si y<p alors
y->b
FinSi
Si y>p alors
y->a
FinSi

"J" étant ma variable de fluctuation de p, lui-même étant le nombre à trouver.

Il n'y a pas tout le programme, bien sûr mais j'en ai fais de nouvelles version et ce soir le 9 mars, je mets normalement un nouvelle version vers minuit. Avec bien sûr le bug.

Je n'ai pas besoin de beaucoup de conseil, mais juste savoir comment faire un random binomial de b à a avec probabilité à la moitié qui ne fait pas de nombre à virgule à terme.

À l'aide ! ?



-----
....Ancien.... c'est le sujet du début mais il est réglé. Il reste intéressant.
-----

"Bonjour, j'ai légèrement avancé dans mon problème. J'ai trouvé mon random, avec ce que je voulais faire... randbin. J'ai adapté le jeu mais je me heurte malheureusement à un problème. Le random me donne une liste et mon programme n'aime pas les listes. Comment je récupère la valeur du liste entre crochets pointus, comme nombre sans rien avec, pour lui donner une variable ?
Je ne veux pas {85}, mais je veux 85.
Parce que je ne sais trop pourquoi mais :
{85}->a
Ne fonctionne pas... puisque c'est la valeur qui va dans mon randbin.
Et randbin({85},0.5,1) ne fonctionne pas.
Je suis bloqué ! À l'aide !!!"




"Bonjour, j'ai besoin d'aide. Enfin ça vous l'aviez deviné !
Je cherche à avoir un random de 0 à 100 avec une plus grande probabilité d'avoir 50 et ce qu'il y a autour que 99 ou 4... de plus je veux aussi des nombres entiers. (Ce n'est pas toujours 0 à 100...)

Je travail bien sûr en Ti-basic avec une ti-nspire-cx-cas.

Mon problème : je fabrique mon jeux de plus ou moins... PouM, il est disponible en ligne, et je vais bientôt le mettre à jour, et le but est de créer un programme qui joue au jeux. Bien sûr, l'approche purement statistique est facile et bien, mais pas aussi bien que statistique et aléatoire. Je défini 100->a et 0->b y:=50 et randInt(0,100)->p.
Ainsi si y<p alors b:=y. Bien sûr avec le randInt(-j,j) (défini par moi) de chaque tour qui change p, j'ai déjà appliqué ce qu'il faut pour que ça fonctionne.

Il me faut quelque chose qui me donne des entiers de "b" à "a" qui a plus de chance de donner des résultats aléatoires autours de (b+a)/2 avec un écart type ainsi que la moyenne réglable si possible entre les deux valeurs "b" et "a" qui rentrent dans le truc pour lequel j'ai besoin d'aide. C'est un random de Gauss... de "b" à "a" avec une probabilité plus grande en fonction de la courbe de gauss avec la loi normale il me semble... Je suis débutant en programmation, j'ai commencé il y a trois semaines mais j'apprends très vite. Soyez indulgents.
Pour être précis, il me faudrait des coups entre b et a qui soient du genre de 10% de 0-9 et 90-100 ; 20% de 10-19... mais pas de truc par paliers. Cette courbe ne fait pas de paliers, il me faut une probabilité qui s'adapte à la quantité de nombres.
Tour 0 il y en a 100 et tour 1 après avoir mis 50, bas il reste 50 possibilités sans compter la variation de p selon j. Et tour... 10, il peut m'en rester plus que 13... alors ça doit être adaptatif... mais entier car c'est un plus ou moins.

Je vous invite à télécharger mon jeu PouM, pour voir de quoi il s'agit.
Par contre ce n'est pas la version automatique que je n'ai pas mis en ligne... elle est trop rationnelle. Je n'aime pas. Je trouve que l'aléatoire à sa place dans un jeu où il y a de l'aléatoire."

Merci de votre attention, et de l'aide que j'espère vous m'apporterez.
?

Oh la la c'est un truc du genre loi normal, ou loi normal gaussien
Tu peux regarder de ce coté la ....
J'ai trouvé cela si cela convient : https://tiplanet.org/forum/viewtopic.php?t=12244.
Sinon y'a surement un prof de maths qui gère le site qui passera par ici ...(ptet demain matin , vu l'heure ... )

Extra44 wrote:Oh la la c'est un truc du genre loi normal, ou loi normal gaussien
Tu peux regarder de ce coté la ....
J'ai trouvé cela si cela convient : https://tiplanet.org/forum/viewtopic.php?t=12244.
Sinon y'a surement un prof de maths qui gère le site qui passera par ici ...(ptet demain matin , vu l'heure ... )

Oui merci je l'avais vu, mais sans trouver mon bonheur... le forum est toujours mon dernier recours. Je fais un minimum de recherche avant. Mais merci ! C'est quand même intéressant.

Je n'ai pas vraiment compris ce que tu cherchais à faire : ta façon d'écrire sur un forum comme si tu discutais avec quelqu'un qui serait dans ta tête n'aide franchement pas à comprendre.

Clarifie les choses, donne un exemple (simple et précis !) de ce que tu souhaiterais faire, et on pourra sans doute t'aider.

Et bien... si je met 71 pour p.

P : nombre à trouver
J : variable à définir qui va faire changer p à chaque tour de -j à +j dans un random.
Y : le nombre que met l'ordinateur.
A : maximum ou peut se trouver p
B : minimum ou peu se trouver p

Donc pour p=71

Y=50
C'est plus

Donc A=100 Et b=50
approxRational(Randbin(a,0.5,1)+(b/2),1)->y
Car je veux que la moyenne de à+b donne la valeur de y mais avec une fluctuation aléatoire basée sur une loi binormale ou normale je ne sais plus.
Donc y= disons 78
C'est moins
Alors B=50 Et A=78
Puis
approxRational(Randbin(a,0.5,1)+(b/2),1)->y

Y->l13 (la je fais une liste pour enlever les sortes de crochet de ma liste de un chiffre qui est faite par Randbin)
Product(l13,1,1)->y (et voilà plus de liste !)
Y= Disons 57
C'est plus
Du coup :
B=57 et A=78
Puis
approxRational(Randbin(78,0.5,1)+(57/2),1)->y

Y= {76.5}
Y->l13
Je recommence avec product
Et donc
76.5->y
Et bien la déjà c'est ce que je ne veux pas.
Alors j'ai essayer de faire :
approxRational(Randbin(a,0.5,1)+(b/2) +0.25 ,1)->y
Pour essayer de faire tomber sur des nombre entiers mais non...

Je reprends :
C'est moins.
Donc A=76.5 et B=57
Donc :
approxRational(Randbin(76.5,0.5,1)+(57/2),1)->y
Bon bas la ça me fait erreur.

Si ça fonctionne de temps en en temps car A est un nombre entier alors avec b/2 si b est impaire, alors b=27.5 par exemple et quand :
Y->l13
Product(l13,1,1)->y et bien avec un nombre à virgule ça ne fonctionne pas non plus alors erreur programme... je suis tout bloqué !


J'ai besoin de quelque chose qui puisse aller dans un programme et qui me transforme des nombre à virgule en nombre entier. Même si c'est un morceau de programme je m'en fiche, je le copie/colle dans mon programme la ou il faut...
une idée ?

Je ne vois pas comment faire plus clair sans carrément recopier tout mon programme dans le chat ! ? Il est très long : 350 lignes environ.

Bonsoir,

La fonction floor(x) permet d'obtenir la partie entière de x.

Ô ! Merci ! Vous me sauvez la vie ! ? Et c'est un euphémisme !
Si j'ose dire.

Ça va bien m'aider merci !
Une bonne nouvelle dans ma journée !

Alors là, vraiment, ça fait peur.
Sans vouloir t'offenser, j'espère pour toi que tu arrives à te faire comprendre dans d'autres situations parce que là, pour moi, c'est un charabia quasiment incompréhensible.

Ce qui m'embête le plus dans ton explication, c'est que tu sembles utiliser des fonctions sans vraiment savoir ce qu'elles font... et comme ça ne te donne pas ce que tu voudrais, tu bidouilles après pour que ça marche !
En général, quand on fait ça, on se retrouve avec des centaines de lignes de code, qui ne servent pas à grand chose... et qui pourraient être énormément simplifiées en utilisant la bonne fonction !

Bref...après ton "explication", je ne sais toujours pas ce que tu veux faire (tu ne définis pas ce que sont censées contenir tes variables, tu ne dis pas comment tu souhaites les modifier, ni dans quel but, etc...)

Si tu es capable de répondre à ces questions, cela pourrait aider :
1) Apparemment, d'après tes anciens messages, tu souhaites créer de manière aléatoire des entiers compris entre 0 et 100 qui ont une probabilité d'autant plus grande de sortir qu'ils sont proches de 50. C'est exactement ce qu'il se passe lorsque tu utilises une loi normale (et non une loi binomiale, comme tu l'utilises actuellement) de moyenne 50. Mais pour être plus précis, il faudrait connaître la dispersion que tu souhaiterais voir sur ces nombres. Ma question est donc :
Quelle devrait être selon toi la probabilité que ton nombre soit compris entre 25 et 75 (par exemple) pour que cela corresponde à ce que tu veux ?

2) Tu as utilisé randBin avec 3 paramètres... et ensuite tu es embêté parce que tu obtiens une liste (et du coup, tu bidouilles avec product pour virer la liste, ce qui est une méthode complètement farfelue !!). Si tu n'avais utilisé que 2 paramètres, tu n'aurais plus ce problème. Pourquoi ne le fais-tu pas ?

3) Tu as utilisé la fonction approxRationnal apparemment parce que tu souhaitais transformer ton nombre en nombre entier... mais malheureusement, ce n'est pas ce que fait cette fonction !! Donc, elle ne te sert à RIEN. Bon sang... mais pourquoi utilises-tu les fonctions au hasard ?

Franchement, plus je te lis... et plus je me dis que ton programme de 350 lignes peut se réécrire en une dizaine de lignes, simplement en apprenant à utiliser correctement les fonctions qui existent au lieu de faire du copier-coller sorti d'on ne sait où, sans savoir ce que ça fait.
Tu devrais lire ATTENTIVEMENT le manuel d'utilisation de ta calculette pour connaître les fonctions qui existent et les utiliser à bon escient !

[Edit] Je viens de télécharger ton jeu, pour regarder ton code, et "Oh mon Dieu !!", "Mes yeux, mes yeux !!"...
Sérieusement, à quoi pensais-tu en écrivant des choses comme :

Code: Select all

If y>100 Then
y-(y-100)→y

If y<0 Then
y-y→y


Et à quoi peuvent bien servir des lignes et des lignes de Lock et de Unlock (qui pourraient d'ailleurs être écrites à chaque fois en une seule ligne...) ?

1) Je voudrais qu'il y ai dans les 80% de chances que ce soit entre 45 et 55.

2) Parce que je demande à mon prof de mathématiques, et qu'il me dit de faire comme ça. Avec trois paramètres dans randBin. Après je met product pour corriger le problème. Du coup, comme mon prof m'explique mal apparemment, bas je fais mal. ? Je vais corriger.

3) au début je l'ai utilisé et voyant que ça ne fonctionne pas... je met autre chose. Et je n'enlève pas parce que ça n'empêche pas le programme de fonctionner. Je ne met pas au hasard, je met des fonctions qui font ce que je veux. Ou presque... je ne les connais pas totalement mais un peu quand même...

Je pensais à faire en sorte que si y>100 alors y:=100. Mais ça ne fonctionne pas toujours. Je ne sais pas pourquoi. Alors comme ça, ça fonctionne. Du coup je le fais.

Pour lock et unlock. Je ne savais pas ! Merci le prof

@kinkazma : Tout d'abord, excuse-moi de m'être un peu emporté la dernière fois, mais je trouve toujours hallucinant de vouloir apprendre la programmation par la pseudo-méthode consistant à prendre des bouts de code par-ci par -là et les bidouillant pour faire en sorte que ça colle à peu près à ce qu'on souhaitait, plutôt que d'apprendre à utiliser des fonctions existantes qui font le boulot proprement ou encore de créer soi-même les dites fonctions.

Bref, maintenant que mon coup de gueule est passé, voici ce que je peux dire pour t'aider.

1) Pour générer un nombre entier au hasard suivant une loi normale de moyenne 50 et ayant une probabilité de 80% de tomber entre 45 et 55, il faut choisir un écart-type environ égal à 3.9. Le problème, c'est que le résultat renvoyé par la fonction randNorm n'est pas un entier mais un réel... et si on en prend la partie entière ou même un arrondi, on change la répartition, et on obtient de gros écarts avec la probabilité voulue. De plus, le réel n'est pas contraint à rester entre 0 et 100, ce qui peut poser problème !

Du coup, on se rabat sur la loi binomiale de paramètres N=100 et p=1/2 (pour avoir une moyenne égale à 50 et un ensemble image formé d'entiers de 0 à 100). La probabilité de tomber sur un entier entre 45 et 55 est alors environ égale 0.7677... J'espère que cela sera suffisant car c'est de loin la solution la plus simple.

2) Pour renvoyer un entier suivant cette loi, il suffit de taper : randbin(100, 0.5).
Il n'y a que deux arguments car le troisième argument n'est utilisé que lorsque l'on veut renvoyer non pas une valeur mais plusieurs d'un coup, sous la forme d'une liste. (Ce que tu appelles "le truc entre accolades")

3) Tu n'as plus besoin de faire ni approximations rationnelles, ni parties entières car les nombres aléatoires renvoyés seront toujours des entiers.
Cependant, si dans d'autres calculs tu as besoin que le résultat soit un entier, la fonction floor est celle qu'il te faut : elle ne conserve que la partie entière de son argument.

4) Pour Les lignes que j'ai extraites de ton code, tu peux les remplacer par :

Code: Select all

If y>100 then
100→y
blabla
endIf

If y<0 then
0→y
blabla
endIf

5) Pour Lock et unLock, je suppose que tu les utilises pour cacher ton score mais de toute façon, ceux qui ont les connaissances nécessaires pour modifier le score à la main seront toujours capables de le faire, et ceux qui ne les ont pas n'iraient même pas chercher comment faire, même si tu n'utilisais pas Lock et unLock.
Bref, pour moi, ça ne sert à rien.
Cependant, si tu tiens à les utiliser, ainsi que la douzaine de variables qui vont avec, tu peux écrire en une seule ligne :

Code: Select all

Lock toutes, mes, variables, en, une, fois
unLock toutes, mes, variables, en, une, fois