PureBasic

Salut a tous,

je cherche une solution plus rapide et moins bordelique que ma methode pour recuperer un quad dans une chaine.
Je sais, ca ressemble au sujet "décortiquer un quad" mais ca n'est pas la meme chose.
Pouvez vous m'aider

:

Code : Tout sélectionner

x$="fe15d87c963aab7c4edffd874a54aaca85d6eef"


RandomSeed(1) ; seed

For i=1 To 5
x=Random(Len(x$))
a$="$"+Mid(x$,x,16)
quad.q=Val(a$)
Debug quad
Next i

;###############
Debug("======")
Debug ("La liste du dessus doit etre la meme que celle du dessous")
Debug("======")
;###############


RandomSeed(1) ; seed

For i=1 To 5
x=Random(Len(x$))

;quad.q= ;;;;;    votre methode

Debug quad
Next i

On définit un tableau de 8 quads

Code : Tout sélectionner

Dim Q.Q(7)

On définit n la localisation du word en cours de traitement et Qn l'index du quad affecté par le traitement.

Code : Tout sélectionner

Define n, Qn

On définit un word

Code : Tout sélectionner

Define.U word

Puis, on lit, word après word, les mots de 16 bits.

Code : Tout sélectionner

n = 0
Qn = 0
Repeat
 word = PeekU(*X + (n * 2) )
 n + 1
 ; tralala
Until word = 0; quitte si terminal 0

C'est dans le tralala qu'on traite le 'word'. Il peut y avoir une fixation de la casse en minuscule :

Code : Tout sélectionner

word | $20

On peut détecter les chiffres décimaux

Code : Tout sélectionner

word - '0'
If word
 If word <= 9
  a + word
 EndIf
EndIf
word + '0'

On peut détecter les chiffres hexadécimaux

Code : Tout sélectionner

word - 'a'
If word
 If word <= 5
  a + word + 10
 EndIf
EndIf
word + 'a'

a devient le nombre accumulateur. C'est a qui va affecter le quad concerné du nombre final.

Code : Tout sélectionner

If ((n % 16) = 15) or (word = 0)
 Q(Qn) = a
 Qn + 1
 a = 0
EndIf
a << 4

Voilà. Tout ça dans 'tralala' et ça marche...
Le résultat est dans le tableau Q()

Hola, hola, holaaa

Ca me parait incroyablement complexe pour ce que je demande...

Prend mon code au post 1 et rajoute ta methode pour voir

Tu veux ça

x= PokeQ(*Adresse)

Mais ton hasard est déséquilibré, faute d'explication... Pour ma part, c'est juste la fonction Val() que je décompose en étapes.

Ce n'est pas un équivalent total de ton code, juste un équivalent la fonction Val(), au cas où une solution AVX soit nécessaire.

Mais on ne sait rien... Longueur de la chaîne variable ou pas ? Grande ou pas ? Pourquoi choisir une plage qui force à tronquer les quads de droite et qui déséquilibre les statistiques aléatoires ? Etc...

Bon, j'ai trouvé un moyen. Je bosse dessus...

Si tu fais x=Random(Len(x$)), tu risques de dépasser la fin de la chaîne. Il faut faire x=Random(Len(x$)-16).

djes a écrit :Si tu fais x=Random(Len(x$)), tu risques de dépasser la fin de la chaîne. Il faut faire x=Random(Len(x$)-16).

C'est tres precisement ce que je pensais !
Oui, il faut faire attention

Tu peux remplacer Val(Mid(A$,i,1) ) par un tableau pré-rempli

Code : Tout sélectionner

Dim vm(255)
vm(0) = -1
For i = 1 to 255
 vm(i) = Val(Chr(i) )
Next

vm(?) -->> donne l'équivalent décimal d'un caractère hexadécimal codé en ASCII.

Code : Tout sélectionner

; exemple
Debug vm('f') ; affichera 15

; Exemple : "35a" (hexa)
Debug Hex(vm('3') << 8   |   vm('5') << 4   |   vm('a') )
; (affichera 35A)

Pour stocker dans un quad :

1) on fait de la place

Code : Tout sélectionner

myQuad << 4

2) on y "gare" sa nouvelle valeur de 4 bits (= 1 chiffre hexa)

Code : Tout sélectionner

myQuad | vm(Chose)

Remarques :

□
"Chose" est une valeur ASCII entre 1 et 255.
2 méthodes pour la récupérer

1/2) Chose = Asc(Mid("DE9A", i, 1) )

2/2) Chose = PeekA(*Adresse): *Adresse + 2

□
nombre << exposant
Ceci fait de la place à droite du nombre, et écrase la gauche du nombre :
exemples factices (base inadéquate, base 10 au lieu de base 2) :
1998 << 1 = 9980
1998 << 2 = 9800
1998 << 3 = 8000

□
nombre >> exposant
Ceci fait de la place à gauche du nombre, et écrase la droite du nombre :
exemples factices (base inadéquate, base 10 au lieu de base 2) :
1998 >> 1 = 0199
1998 >> 2 = 0019
1998 >> 3 = 0001

□
Logiquement, 4 chiffres de décalage dans un nombre de 4 chiffres, ça écrase tout : il ne reste que des zéros.

□
De la théorie à la pratique,
1) le signe et la grandeur du nombre ne sont pas à oublier.
Dans les décalages à droite (a >> b), le bit de signe est étiré et duppliqué autant que le nombre subit de bits de décalage.
2) les exemples sont en base 10, tandis que la réalité est en base 2.
3) dans les exemples, les nombres ont 4 chiffres. Dans la réalité, les entiers binaires ont entre 32 bits en X86, et 64 bits en X64.
4) dans un entier, le bit de droite, c'est le bit numéro zéro, et c'est aussi le bit de parité (0= nombre pair, 1= nombre impair)
5) dans un entier, le bit de gauche, c'est le bit numéro 31 (X86) ou 63 (X64), et c'est aussi le bit de signe.

PureBasic

[Résolu] Faire mieux qu'un "quad.q=Val(a$)"

[Résolu] Faire mieux qu'un "quad.q=Val(a$)"

Re: Faire mieux qu'un "quad.q=Val(a$)"

Re: Faire mieux qu'un "quad.q=Val(a$)"

Re: Faire mieux qu'un "quad.q=Val(a$)"

Re: Faire mieux qu'un "quad.q=Val(a$)"

Re: [En voie d'etre résolu] Faire mieux qu'un "quad.q=Val(a$

Re: [En voie d'etre résolu] Faire mieux qu'un "quad.q=Val(a$

Re: [Résolu] Faire mieux qu'un "quad.q=Val(a$)"