Reprise du message précédent :
Pour moi ca c'est suffisant :
 

joce a écrit a écrit : faut faire :     depart = (floor (size/16)) * 16;   décaler depart de 4 bits vers la gauche, et commencer les tests

 
Merci, ça a l'air sympa. Dès que j'aurai assez dormi pour réussir à compiler un chunk avec "floor()", j'essaierai de poster un comparatif des perfs, si jamais quelqu'un est intéressé. Pour le moment, ça ressemble à ça :
 
/tmp/ccCWX7bz.o: In function `main':
/home/sys/tp1/foo.c:5: undefined reference to `floor'
/home/sys/tp1/foo.c:6: undefined reference to `floor'
/home/sys/tp1/foo.c:7: undefined reference to `floor'
/home/sys/tp1/foo.c:8: undefined reference to `floor'

fait un include de math.h

 
Ah oui presque... Non en fait j'avais oublié -lm comme option de l'éditeur de liens. Je suis pas fier

joce a écrit a écrit :

 
Euh "elseif" c'est un mot clé de quel langage ?  

exo_ a écrit a écrit :     Euh "elseif" c'est un mot clé de quel langage ?

elsif
un melange de tout
tient t'es sur que ca existe pas d'ailleurs
A programmer en plein de language je sais plus

joce a écrit a écrit : elsif un melange de tout tient t'es sur que ca existe pas d'ailleurs A programmer en plein de language je sais plus

 
Euh "else if", non ?
 
Sinon bilan des courses, victoire pour moi. La preuve ?
 
[root@localhost tp1]# ./a.out
s=15 exo_=4 joce=0
s=3245 exo_=12 joce=103424
s=115 exo_=7 joce=35328
s=128 exo_=7 joce=512
 
Implementation exo_ :
int expDeux(int x) {
  int k=0;
  int p=1;
  while (p<x) {
    k++;
    p<<=1;
  }
  return k;
}
 
Implementation joce :
int expDeuxBis(int size) {
int result;
int depart;
depart = ((floor (size/16)) * 16);
depart <<= 4;
if (size & depart)
   result = depart<<1;
else if (size & (depart>>1))
   result = depart;
else if (size & (depart>>2))
   result = depart>>1;
else
   result = depart>>2;
return result;
}
 
Edit : J'avais oublié...  

c'est quoi tes chiffres
sinon j'ai une meilleure idée

pour l'avoir tu fais :
 
je verifie

 
[root@localhost tp1]# ./a.out
s=15 exo_=4 joce=32
s=3245 exo_=12 joce=7678
s=115 exo_=7 joce=3328
s=128 exo_=7 joce=256
 
Y'a de l'idée   (Mon algo renvoie le n de 2^n)

nan c'était completement faux mon dernier truc, par contre je capte pas pkoi le premier marche pas
 
c'est koi s, exo et joce, tu peux être plus explicite

joce a écrit a écrit : nan c'était completement faux mon dernier truc, par contre je capte pas pkoi le premier marche pas   c'est koi s, exo et joce, tu peux être plus explicite

 
s = size soit le chiffre que l'algo mange
exo_ = le resultat obtenu avec mon algo (a mettre en exposant de 2)
joce = le resultat obtenu avec ton algo

tient d'ailleurs après  
depart <<= 4;  
faut mettre  
 
if (depart == 0) depart = 1;
 
 

ceci dit y manque une étape dans mon algo

joce a écrit a écrit : tient d'ailleurs après   depart <<= 4;   faut mettre     if (depart == 0) depart = 1;

 
Euh... Comment dire    
 
[root@localhost tp1]# ./a.out
s=15 exo_=4 joce=2
s=3245 exo_=12 joce=103424
s=115 exo_=7 joce=35328
s=128 exo_=7 joce=512
 
Avec :
int expDeuxBis(int size) {
int result;
int depart;
depart = floor(size/16);
depart <<= 8;
if (depart == 0) depart = 1;
if (size & depart)
   result = depart<<1;
else if (size & (depart>>1))
   result = depart;
else if (size & (depart>>2))
   result = depart>>1;
else
   result = depart>>2;
return result;
}

heu pardon c'était if (depart == 0) depart = 8;

joce a écrit a écrit : heu pardon c'était if (depart == 0) depart = 8;

 
[root@localhost tp1]# ./a.out
s=15 exo_=4 joce=16
s=3245 exo_=12 joce=103424
s=115 exo_=7 joce=35328
s=128 exo_=7 joce=512
 
 
 
 
5/20. L'élève joce doit se ressaisir au second trimestre.

exo_ a écrit a écrit :     [root@localhost tp1]# ./a.out s=15 exo_=4 joce=16 s=3245 exo_=12 joce=103424 s=115 exo_=7 joce=35328 s=128 exo_=7 joce=512

parfait ca corrige au moins le premier resultat

joce a écrit a écrit :   parfait ca corrige au moins le premier resultat

 
D'où mon edit.

je sais où est le bug ceci dit

joce a écrit a écrit : je sais où est le bug ceci dit

 
Ah oui ?   Moi c'est l'initialisation de départ qui me semble louche. D'ailleurs, floor ne sert à rien, il me semble.

exo_ a écrit a écrit :     Ah oui ?   Moi c'est l'initialisation de départ qui me semble louche. D'ailleurs, floor ne sert à rien, il me semble.

oui je dirais même que c'est completement foireux

joce a écrit a écrit :   oui je dirais même que c'est completement foireux

 
En trifouillant comme un porc (c'est une de mes grandes spécialités), j'obtiens :
 
[root@localhost tp1]# ./a.out
s=7 exo_=3 joce=8
s=15 exo_=4 joce=16
s=16 exo_=4 joce=32
s=17 exo_=5 joce=32
s=33 exo_=6 joce=64
s=63 exo_=6 joce=64
s=65 exo_=7 joce=128
s=115 exo_=7 joce=138
s=3245 exo_=12 joce=404
s=128 exo_=7 joce=2
 
Conclusion générale sur l'optimisation (proverbe écossais) : He that seeks trouble, It where a pity he should miss it. Sur ce, merci pour tout et bonne nuit.

Voui c nawak
plus t'augmenteras les chiffres et plus ca sera nawak

par contre j'aurais bien une solution.
y a moins de convertir le chiffre en hexa, et de compter le nombre de chiffre de la representation en hexa ?

joce a écrit a écrit : Voui c nawak plus t'augmenteras les chiffres et plus ca sera nawak

 
J'ai vu. C'est très . Bon dodo moi. Thanx a lot.

exo_ a écrit a écrit :     J'ai vu. C'est très . Bon dodo moi. Thanx a lot.

de rien, les bugs sont offerts

joce a écrit a écrit : par contre j'aurais bien une solution. y a moins de convertir le chiffre en hexa, et de compter le nombre de chiffre de la representation en hexa ?

 
Avec une boucle ?    

exo_ a écrit a écrit :     Avec une boucle ?

ouais mais vu que c'est en Hexa c'est plus court

Bonsoir,
 
Si tu veux que ca aille vite, tu ne te laisserais pas tenter par un petit calcul par table ?
 
int expDeux(unsigned int x) { -- int sur 4 octets (b1b2b3b4)
 -- Tu as la table precalculee pour les valeurs 0 .. 255
 static int p[256] = { 0, 1, 2, 2, 3, ... };
 register unsigned char * index =(&x) +3;
 int result;
 
 if (*index ==0) { // raipde a l'exec, tu es sur b4
  index --;
  if (*index ==0) { // b3
   index --;
   if (*index ==0) { // b2
    index --;
    if (*index ==0) { // b1
     return 0;
    }
   }
  }
 }
 // index pointe sur l'octet !=0
 result =p[*index];
 return result +((index -&x) *8);
}
 
Pas teste, bien sur, et il doit y avoir des petits ajustements a faire, mais uniquement des ==0 sur reg, le proc. devrait adorer.
Bon c'est l'idee quoi.
exple d'ajustements :
 
   if (*index ==0) { // b2
    result = 8;
    if (*(--index) ==0)
   :
 return result +p[*index];
 
hth

exo_ a écrit a écrit :     Euh... Comment dire       [root@localhost tp1]# ./a.out s=15 exo_=4 joce=2 s=3245 exo_=12 joce=103424 s=115 exo_=7 joce=35328 s=128 exo_=7 joce=512   Avec : int expDeuxBis(int size) { int result; int depart; depart = floor(size/16); depart <<= 8; if (depart == 0) depart = 1; if (size & depart)    result = depart<<1; else if (size & (depart>>1))    result = depart; else if (size & (depart>>2))    result = depart>>1; else    result = depart>>2; return result; }

 
Tient essaie voir :
 

 
ou si tu veux les même resultats que toi :
 

 
oué ben a ce moment la, ma solution marchait aussi hein...  

HappyHarry a écrit a écrit :     oué ben a ce moment la, ma solution marchait aussi hein...

mais moi je marche par bloc de 4

joce a écrit a écrit : mais moi je marche par bloc de 4

 
que ca marche, ca reste a voir  

HappyHarry a écrit a écrit :     que ca marche, ca reste a voir

mais si ca marche

up ?

 
J'en suis quasi sur aussi pour cette instruction... sinon, il suffit  de faire qqs shl et de verifier le carry bit (si je me rapelle bien).  

pffff....
J'y comprends rien à votre cpp de noix de castagnette
gna...gna...gna gna...math.h...gna...gna...gna
   <<VB.NET>>

up