Comparaison de 2 chaines & limitation à 63 caracteres

Ganagyre · Message par **Ganagyre** » lun. 15/juin/2009 13:42

Bonjour.

Avec le code suivant, je compare 2 chaines de caractères ne contenant que des 1 ou 0.
Ensuite je fait le compte des "positions" commune des valeurs 1.

Je butte sur une limitation de 63 caractères .
Comment proceder pour aller jusqu'à 100 caractères en 1 seul passage ?

Code : Tout sélectionner

;
;Chaines de caractères longues de 63 
;         =           1         2         3         4         5         6         7 
;         =  1234567890123456789012345678901234567890123456789012345678901234567890
Valeur1.s = "100101010100110101010101010101111111111101010101010000000000011"
Valeur2.s = "100000000000000000000000000000000000000100000000000000000001001"

test.d = Val("%"+Valeur1) & Val("%"+Valeur2) 
; nombre de 1 Communs entre Valleur1 & Valeurs2
Resultat.d = CountString(Bin(test),"1") 
; nombre de 1 Communs entre Valeur1 & Valeurs2  
resulte.d = CountString(Bin(Val("%"+Valeur1) & Val("%"+Valeur2)),"1") 
;
Debug"Longueur Chaine Valeur1 = " + Str(Len(Valeur1))
Debug"Longueur Chaine Valeur2 = " + Str(Len(Valeur2))
Debug"======================================================================="
Debug Valeur1
Debug Valeur2
Debug Bin(test)
Debug "Communs au 2 Chaines = " +Str(Resultat)
Debug "Communs au 2 Chaines (formule) = " +Str(resulte)
Debug"======================================================================="
Debug Val("%"+Valeur1)
Debug Val("%"+Valeur2)
Debug test
Debug"======================================================================="
Debug Bin(Val("%"+Valeur1))       ; Bin Valeur1
Debug Bin(Val("%"+Valeur2))       ; Bin Valeur2
Debug Bin(test)
Debug"======================================================================="

Cool Dji · Message par **Cool Dji** » lun. 15/juin/2009 14:09

Salut,
J'ai pas de solutions en un seul passage, désolé

Pour faire ça, j'utiliserai la méthode lourde

,
Je pense que tu connais mais zaucazou :

Code : Tout sélectionner

nombre de 1 communs=0
for i = 1 to 100
If (Mid(Text1$,i,1)=Mid(Texte2$,i,1)) and (Mid(Text1$,i,1)='1')
;ce sont les 2 des 1
nombre de 1 communs+1
endif
next

Pas forcément classe

, mais l'essentiel n'est pas toujours dans l'apparence

(ça m'arrange bien de dire ça

)

cha0s · Message par **cha0s** » lun. 15/juin/2009 14:15

-premièrement tu utilise des flottant pour calculer des entier.
-je voie pas en quoi tu est limité a 63 caractères
-une autre façon de voir :

Code : Tout sélectionner

EnableExplicit
Define n.w, result.w
#Valeur1 = "10010101010011010101010101010111111111110101010101000000000001100000000000000001111111111111111111110"
#Valeur2 = "10000000000000000000000000000000000000010000000000000000000100100000000000000000000000000000010000000"

For n = 1 To Len(#Valeur1)
  If Mid(#Valeur1, n, 1) = "1" And Mid(#Valeur1, n, 1) = Mid(#Valeur2, n, 1)
    result+1
  EndIf
Next n

Debug "Occurence : " + Str(result)
Debug "Taille : " + Str(Len(#Valeur1))

Edit : je suis trop lent :p

Cool Dji · Message par **Cool Dji** » lun. 15/juin/2009 14:30

cha0s a écrit :Edit : je suis trop lent :p

cha0s, t'as pris le temps de faire un joli code

cha0s · Message par **cha0s** » lun. 15/juin/2009 14:33

Cool Dji a écrit :
chaos a écrit :Edit : je suis trop lent :p
cha0s, t'as pris le temps de faire un joli code

Je suis surtout très maniaque sur le code ! (pas comme sur le français ^^')

Backup · Message par **Backup** » lun. 15/juin/2009 15:06

cha0s a écrit :
Code : Tout sélectionner
  If Mid(#Valeur1, n, 1) = "1" And Mid(#Valeur1, n, 1) = Mid(#Valeur2, n, 1)

tu pouvais faire ça aussi

Code : Tout sélectionner

 If Mid(#Valeur1, n, 1) = "1" And  Mid(#Valeur2, n, 1)="1"

ou ça :

Code : Tout sélectionner

If Val(Mid(#Valeur1, n, 1) ) & Val( Mid(#Valeur2, n, 1))=1

Cool Dji · Message par **Cool Dji** » lun. 15/juin/2009 15:07

cha0s a écrit :Je suis surtout très maniaque sur le code !

T'inquiète, ça doit se soigner

erix14 · Message par **erix14** » lun. 15/juin/2009 19:00

Voici une solution qui utilise les pointeurs pour éviter la fonction Mid, cela permet de gagner énormément de temps CPU.

Code : Tout sélectionner

EnableExplicit
Define Valeur1.s, Valeur2.s, *Char1.Character, *Char2.Character, result.w
Valeur1 = "10010101010011010101010101010111111111110101010101000000000001100000000000000001111111111111111111110"
Valeur2 = "10000000000000000000000000000000000000010000000000000000000100100000000000000000000000000000010000000"

*Char1 = @Valeur1
*Char2 = @Valeur2
result = 0
Repeat
 If(*Char1\c='1' And *Char2\c='1') : result+1 : EndIf
 *Char1+1 : *Char2+1
Until Not *Char1\c Or Not *Char2\c

Debug "Occurence : " + Str(result)
Debug "Taille : " + Str(*Char1-@Valeur1)

Ganagyre · Message par **Ganagyre** » mar. 16/juin/2009 13:04

Merci à tous pour vos exemples.
Apres un petit moment à triturer le tout, et moult reflexions une autre possibilité :

Code : Tout sélectionner

;
T1.s = "10010101010011010101010101010111111111110101010101000000000001100000000000000001000001000000010000011"
T2.s = "10000000000000000000000000000000000111010000000000000000000100100000000000000000000000000000010000001"


Debug T1
Debug T2
Debug"====================================================================================================="

T1 = T2

Debug T1

Resultat.w = CountString(T1,"1") 

Debug"====================================================================================================="
Debug"Resultat : " + Str(Resultat)

Simple et efficace, dans ce cas de figure.

Backup · Message par **Backup** » mar. 16/juin/2009 13:31

@Ganagyre : excellent !!

Cool Dji · Message par **Cool Dji** » mar. 16/juin/2009 13:47

Ganagyre a écrit :Merci à tous pour vos exemples.
Apres un petit moment à triturer le tout, et moult reflexions une autre possibilité :

Code : Tout sélectionner

;
T1.s = "10010101010011010101010101010111111111110101010101000000000001100000000000000001000001000000010000011"
T2.s = "10000000000000000000000000000000000111010000000000000000000100100000000000000000000000000000010000001"


Debug T1
Debug T2
Debug"====================================================================================================="

T1 = T2

Debug T1

Resultat.w = CountString(T1,"1") 

Debug"====================================================================================================="
Debug"Resultat : " + Str(Resultat)

Simple et efficace, dans ce cas de figure.

Comprends-pas !!
T'as pas le nombre de 1 commun entre T1 et T2 avec ton truc...
Tu as juste compter le nombre de 1 dans T1, non

Bon, si c'est pas ça, je vais faire la sieste

Backup · Message par **Backup** » mar. 16/juin/2009 15:08

HA bah oui !!

Code : Tout sélectionner


T1 = T2 ; tu met T2 dans T1

Debug T1

Resultat.w = CountString(T1,"1") ; tu teste seulement T1 !!

pffff ! je fatigue moi , j'avais meme pas vu la bourde !!

Ganagyre · Message par **Ganagyre** » mer. 17/juin/2009 13:09

Mince !

en effet : AND est un ET logique (binaire) cet opérateur ne peut être utilisé avec une variable de type chaine.

a.w = %1000 & %0101 ; Le résultat sera 0
b.w = %1100 & %1010 ; Le résutlat sera %1000
bits = a & b ; Effectue un ET bit à bit entre a et b et utilise le résultat avec l'opérateur =
a & b ; Effectue un ET bit à bit entre a et b et place le résultat directement dans la variable "a"

Apparement on ne peu dépasser une chaine de 62 Caracteres transcodé en binaire pour faire une comparaison.

Code : Tout sélectionner

;                  Chaines de caracteres longues de 62 caracteres 
;         =           1         2         3         4         5         6         7 
;         =  1234567890123456789012345678901234567890123456789012345678901234567890
Valeur1.s = "10010101010011010101010101010111111111110101010101000000000001"
Valeur2.s = "10000000000000001000000010000010010000010000000000000000000001"


test = Val("%"+Valeur1) & Val("%"+Valeur2) 
; nombre de 1 Communs entre Valleur1 & Valeurs2
Resultat.w = CountString(Bin(test),"1") 
; nombre de 1 Communs entre Valeur1 & Valeurs2  
resulte.w = CountString(Bin(Val("%"+Valeur1) & Val("%"+Valeur2)),"1") 

Debug"======================================================================="
Debug"Longueur Chaine Valeur1 = " + Str(Len(Valeur1))
Debug"Longueur Chaine Valeur2 = " + Str(Len(Valeur2))
Debug"======================================================================="
Debug Valeur1
Debug Valeur2
Debug Bin(test)
Debug "Communs au 2 Chaines = " +Str(Resultat)
Debug "Communs au 2 Chaines (formule) = " +Str(resulte)
Debug"======================================================================="
Debug Val("%"+Valeur1)
Debug Val("%"+Valeur2)
Debug test
Debug"======================================================================="
Debug Bin(Val("%"+Valeur1))       ; Bin Valeur1
Debug Bin(Val("%"+Valeur2))       ; Bin Valeur2
Debug Bin(test)
Debug"======================================================================="

En mettant :

Valeur1.s = "100101010100110101010101010101111111111101010101010000000000001"
Valeur2.s = "100000000000000010000000100000100100000100000000000000000000001"

La comparaison ne fonctionne plus .

Reste la solution de couper les chaines à comparer pour faire un seul passage sans boucle.