Discussion :

[AsmCode]

Bonjour

J'essaie de trouver une formule de math afin d'évaluer un rendement.

Admettons que j'ai un nombre: 25000

et que je veuille réduire celui-ci de 0.5% à chaque fois que je le réduit.

Est-ce qu'il y aurait une formule toute simple au lieu de faire quelque chose du genre:

25000 - ((25000 X 0.5)/100) = Z

Z - ((Z X 0.5)/100) = A

A - ((B X 0.5)/100) = C

et ainsi de suite dépendamment du nombre de fois que je veux réduire ce nombre.

Merci.

Déplacé depuis le forum Assembleur par Alcatîz

[plegat]

Salut,

Ouaip, y'a:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

C=25000*(0.995^n)

avec n = nombre de réductions

PS: les parenthèses sont là pour la forme, normalement la puissance (^) est prioritaire...

[AsmCode]

Merci

Mais pourquoi l'exposant ?

ce ne serait pas plutôt

C = C - (C x (0.995 x n)) :

[plegat]

C = C - (C x (0.995 x n))

Y'aurait pas une 'tite incohérence dans ta formule là???

Si tu veux enlever 0.5% à ta valeur, ça consiste à n'en garder que 99.5%
Au tour d'après, tu gardes 99.5% de ce qu'il reste, soit 99.5% de 99.5% de la valeur initiale, soit 99.5% x 99.5% = (99.5%)^2
Et ainsi de suite.
Au rang n, ça donne (99.5%)^n de la valeur initiale.

Tu trouveras ce résultat facilement si tu factorises tes expressions dans ton premier post (vu que:
25000 - ((25000 X 0.5)/100) = Z
25000 x (1- 0.5/100) = Z
soit 25000 x 0.995 = Z
)

[Arthaniel]

Il y aurait aussi moyen d'y aller avec la récursion si tu ne sais pas le nombre de fois exacte que tu veux réduire.

Tu garde 99.5% du nombre que tu passe en paramètre à la même fonction.

En pseudo code, ça donne ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
Function MaFonctionRecur (Nombre : réel) : Réel
    MaFonctionRecur = 0.995 * Nombre
    Call MaFonctionecur (MaFonctionRecur)
Fin Function

Bien sûr, tu rajoutes une condition sinon, il boucle sans fin

[AsmCode]

Ok

Mais j'aurais besoin d'une autre formule de math

Celle-ci, par contre, je n'ai aucune idée de son concept alors en pseudo-code ça doit faire ceci:

Supposons que j'ai la valeur numérique 16706 qui est en fait l'équivalent de 'AB' en ascii.

Prenon un exemple plus long, admettons 'ABCDEF' qui est égal à:

010000010100001001000011010001000100010101000110

qui vaut: 71752852194630

comment, au moment de la lecture d'un octet à la fois, ajouter leur valeur pour "construire" une notation simplifié comme 2^x + y qui serait = 71752852194630 ?

Puis ensuite, comment je pourrais prendre cette notation: 2^x + y pour refaire l'inverse ?

C'est-à-dire avoir quelque chose comme:

Z = portion de 2^x + y

calculer l'octet O de Z

retenir O

prendre une autre portion de 2^x + y (s'il en reste)

calculer l'octet O + 1

Puis à la fin de la boucle (quand il n'y a plus de portion) aditionner ou mettre ensemble tout les octets O pour que cela donne bien 'ABCDEF'

Merci.

[Laurent Gomila]

Tu as déjà posté un sujet pour ça, merci de ne pas te disperser.

http://www.developpez.net/forums/viewtopic.php?t=376677

[AsmCode]

Je voudrais pouvoir calculer le nombre minimal d'octets à enlever X sur un nombre d'octets N. Car une fois X octets enlevé, j'ajoute toujours à ce qui reste de N un nombre de bits égal à son nombre d'octets qui reste. Donc par rapport à ce que je rajoute, je voudrais savoir le minimum que je dois enlever au départ pour ne pas en rajouter plus que ce que j'en ait enlevé.

Par exemple:
N: 1024 octets
X: j'enlève 24 octets
R: Reste 1000 octets et j'ajoute 1000 bits donc 1000/8
J: j'ajoute 1000/8 octets donc 125 octets.

Ce n'est pas bon car j'en ait enlevé 24 et j'en ait rajouté 125.

Mais si j'en enlève 128 c'est correct car il reste 896, 896/8 = 112 donc là je suis gagnant.

je cherches une formule pour calculer le minimum pour ne pas avoir à "tatonner" à la main.

[AsmCode]

C'est bon j'ai trouvé la formule moi-même.

((N - x) + ((N - x) / 8 ) = N - 2

si N = 1024 ..

(1024 - x) + ((1024 - x) / 8 ) = 1022

Mais je dois encore isoler le x, mais mes notions de math sont loin. Quelqu'un peut-il m'aider ?

[plegat]

C'est bon j'ai trouvé la formule moi-même.

((N - x) + ((N - x) / 8 ) = N - 2

si N = 1024 ..

(1024 - x) + ((1024 - x) / 8 ) = 1022

Mais je dois encore isoler le x, mais mes notions de math sont loin. Quelqu'un peut-il m'aider ?

Tu factorises (1024-x): (1024-x) * (1+1 / 8 ) = 1022
soit: (1024-x) * ( 9 / 8 ) = 1022
soit: 1024-x = 1022 * 8 / 9
soit: x= 1024 - (1022 * 8 / 9 ) = 115.55555555555555555555...

[AsmCode]

Bonjour

Je recherches une autre formule.

Je croyais que c'était: n! / (k! (n-k)!)

Mais non, alors si quelqu'un peut m'aider à trouver une formule plus simple aussi car n! est très lourd à calculer si j'ai un nombre d'environ 1 millions.

Je voudrais calculer le nombre de possibilités qu'une position peut occuper selon un groupe. Mais sans inversion.

Par exemple, faisons cela avec des 0 et des 1.

Si j'ai 5 bits
combien de positions puis-je avoir avec 2 bits ?

Voici la solution manuelle de ce que je veux dire:

11000
10100
10010
10001
01100
01010
01001
00110
00101
00011

10 positions.

avec 4 bits et un groupe de 2 bits:
1100
1010
1001
0110
0101
0011

6 positions

Merci

[AsmCode]

Oops

Non ok c'est moi qui s'est trompé

[Rafy]

Non ok c'est moi qui s'est trompé

hum hum, C'est moi qui me suis trompé serai mieux, je pense...
Sinon pour ton problème
Tu dois chercher le nombre de Combinaisons
appelé Cnk par les anciens (dont je fais parti) et k parmi n pour les petits jeunes...
noté :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
    k
  C
    n
ou 
(n)
(k)

Et la formule C'est C(n,k) = k!/(n!*(n-k)!)
Tu y étais presque...
Dans ton cas k le nombre de bits à placer, et n le nombre de bits total...

[Matthieu Brucher]

Même chose, tu choisis 2 positions parmi 5, donc C(5, 2)

[DrTopos]

Et la formule C'est C(n,k) = k!/(n!*(n-k)!)
Tu y étais presque...

J'ai bien peur que la formule soit plutôt C(n,k) = n!/(k!*(n-k)!).

[Matthieu Brucher]

C(n, 0) = C(n, n) = 1, donc c'est Topos qui gagne

[Le Furet]

Oui enfin bon, ça reste la pire formule sur C(n;k) du point de vue calculs (d'à peu près tous les points de vue d'ailleurs).

C(n,k) = n(n-1)...(n-k+1)/k!, c'est déjà mieux.

[Rafy]

Je suis d'accord... Allez y (mais pas trop)
Il est vrai sinon que je ne vais avoir que des fractions, avec un maximum en 1...
Un souvenir trouble, faut que je relise mes cours

[DrTopos]

Question: que calcule la fonction suivante (on suppose que 0 <= k <= n) ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
int f (int n, int k)
{
  int *t = (int *)malloc((k+1)*sizeof(int)); 
  int i, j; 
 
  for (j = 0; j <= k; j++) t[j] = 1; 
 
  for (i = 0; i < n-k; i++)
    for(j = 0; j < k; j++)
      t[j+1] += t[j]; 
 
  i = t[k];
  free(t); 
  return i; 
}

Seules les réponses duement justifiées seront prises en compte.

[Le Furet]

Oui, c'est mieux

On pouvait le faire récursivement aussi...