Casse tête de la semaine

yvesffr · Message par **yvesffr** » 05 avr. 2006 23:09

Et ca marche pas ca alors ?

A= &H12345678 + &H4443BBBC

jasz · Message par **jasz** » 06 avr. 2006 00:10

A=&H1234*65536+&H5678

ensuite?

Le but est de swapper les deux valeurs 16 bits.

yvesffr · Message par **yvesffr** » 06 avr. 2006 06:24

A=&H5678*65536+&H1234
A= &H12345678 + &H4443BBBC

arf, et bien le fait de faire l'une de ces deux opérations à le même résultat, sauf qu'avec la premiere tu ne manipule pas la valeur d'origine, en C ca aurait donné:

A = (0x12345678 << 16) | ((0x12345678 >> 16) & 0xFFFF) )

Yves

jasz · Message par **jasz** » 06 avr. 2006 10:23

J'ai utilisé &H12345678 comme j'aurais pu utiliser &H3985CD5D

Un ch'tit coup de main.

&H1234*65536=&H12340000

yvesffr · Message par **yvesffr** » 06 avr. 2006 10:38

arf, tu le fais exprès...

C'est peine perdue, j'arrête

Yves

Message par **Torlus** » 06 avr. 2006 14:06

jasz a écrit :J'ai utilisé &H12345678 comme j'aurais pu utiliser &H3985CD5D

Un ch'tit coup de main.

&H1234*65536=&H12340000

Je crois que Yves avait compris

C'est à la portée d'un programmeur moyen ce problème. La vraie difficulté ici c'est la connaissance du Basic Thomson...
Si le C te va pas, que dirais-tu d'une version en Pampuk Forth ?

Apparemment y'a un VARPTR ou assimilé sur ce Basic, donc c'est assez trivial non ?

jasz · Message par **jasz** » 06 avr. 2006 14:07

Allons y alors

A=&H1234*366536+5678
AA=INT(A/65536) => AA=&H1234

Ensuite c'est trés proche cherche encore un peu.

Donc on pose

A=&H12345678
AA=&H1234

Y pas un ingénieur informaticien à bord?

Message par **Torlus** » 06 avr. 2006 14:10

Tu ne connais pas le C, je me trompe ?

jasz · Message par **jasz** » 06 avr. 2006 14:15

Torlus a écrit :La vraie difficulté ici c'est la connaissance du Basic Thomson...

Ce n'est pas un problème de basic thomson car la solution est compatible avec tous les basic.
On utilise que des +-* et /

Torlus a écrit :C'est à la portée d'un programmeur moyen ce problème.

C'est pour cette raison que presonne n'a trouvé la soluce

CLS2086 · Message par **CLS2086** » 06 avr. 2006 14:20

Converti en décimal ça passera mieux ...

jasz · Message par **jasz** » 06 avr. 2006 14:21

Torlus a écrit :Tu ne connais pas le C, je me trompe ?

Non, mais je connais plein d'autres choses qui feraient vomir un mort

Message par **Torlus** » 06 avr. 2006 14:24

Pfft

AH = (A/65536)
AL = A-(AH*65536)
A = AL*65536+AH

Satisfait ?

A supposer comme l'a dit justement quelqu'un précédemment, le Basic sache gérer des nombres sur 32 bits (ce dont je doute).

Pour ta culture, >> et << sont des opérateurs de bitshift, qui font l'équivalent des multiplications/divisions par 65536, et qui existent sur pas mal de langages.

Yves avait donc donné la bonne réponse.

Si ça existe sur le Basic Thomson, utilise ça à la place (ou alors tu fais confiance au Basic pour qu'il fasse l'optimisation tout seul, au lieu de perdre un temps précieux à faire les multiplications/divisions).

jasz · Message par **jasz** » 06 avr. 2006 14:27

CLS2086 a écrit :Converti en décimal ça passera mieux ...

Alors
A=305419896

C'est mieux?

Torlus a écrit :AH = (A/65536)
AL = A-(AH*65536)
A = AL*65536+AH

Satisfait ?

Oui, c'est la bonne réponse

Moi c'est du style

A=&H1234*65536+&H5678
AA=INT(A/65536)
A=(A-AA*65536)*65536+AA

Ce qui revient à la même chose. Enfantin!

ps

Torlus a écrit :Pour ta culture, >> et << sont des opérateurs de bitshift, qui font l'équivalent des multiplications/divisions par 65536, et qui existent sur pas mal de langages.

Sauf le basic... Faut suivre là.

foolduplex · Message par **foolduplex** » 06 avr. 2006 15:17

ouaip. sauf que je persiste et signe : les entiers sont limites a -32768..32767 en BASIC Thomson.

En realite, si tu ecris le code ci-dessus, ce qu'il se passe c'est que ta variable est declaree en nombre a virgule flottante et les calculs sont faits en virgule flottante. Comme les nombres flottants sont codes totalement differemment des entiers en memoire, ce calcul n'a aucun interet pratique.

(il suffit pour s'en convaincre de faire un PRINT A qui affiche un consternant 3.0542E+08 au lieu de 305419896)

Naturellement, je ne parle pas des BASIC pouvant gerer des entiers plus grands, qui eux realiseront sans doute l'operation esperee.

Fool

jvernet · Message par **jvernet** » 06 avr. 2006 17:59

foolduplex a écrit :
(il suffit pour s'en convaincre de faire un PRINT A qui affiche un consternant 3.0542E+08 au lieu de 305419896)

En l'occurence, 3.0542E+08 est le bon resultat, affiché dans un format virgule flottante

.

Dans le BASIC microsoft, il y avait la possibilité de typer les variables, (I%; I#,...) ça n'existe pas sur les TO ?

Par contre, l'encodage en mémoire n'a rien à voir, sans doute.

Ca m'enerve, ces BASIC qui se limitent aux entiers 16bits signés, m'empéche de faire des boucles FOR dès que I>32768...