PureBasic

Salut !

Comment fait pure basic pour me sortire un nombre hexadecimale avec un nombre ?

Je voudrais faire la même chose mais avec plus de caractères pour avoir une plus grande plage de possibilité
comment dois-je proceder, j'ai bien essayer ceci:

Code : Tout sélectionner

Procedure.s GenerationNombreTetradecimale(Nombre)
  
  Caracteres$ = "!" + Chr(34) + "#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ"
  
  Repeat
    
    Permutation + 1
    Position + 1
    
    If Position > 216
      NumeroCaractere + 1
        PremierCaractere$ = Mid(Caracteres$, NumeroCaractere, 1)
      Position = 1
    EndIf
    
      Caractere$ = Mid(Caracteres$, Position, 1)
    
    If Nombre = Permutation
      Break
    EndIf
    
  Until PremierCaractere$ = "ÿ" And Caractere$ = "ÿ"
  
  ProcedureReturn PremierCaractere$ + Caractere$
EndProcedure

Debug GenerationNombreTetradecimale(46656)

Cependent je suis limité a deux caractère ici ce qu'il n'est pas excelent du tous

Je ne sais pas comment aller plus loins et en plus cette solution est bien trop longue
il faut impérativement éviter les boucles qui sont bien trop longue pour ce genre de chose

J'ai pensser qu'il falais calculer le nombre héxadecimale au lieux de faire sa avec des boucles
peut-être faire un genre de compteur, je ne sais pas, avez vous une idée comment puis proceder ?

...............

Ouoi !!!, merci infiniment Dobro

respet grand chef

Bonjour

Dobro, Il y a un problème avec ton exemple
Si la valeur est inferieur a 16 (je crois)
ça marche pas

Je cherche un programme qui va permettre de compresser un nombre

Plus le nombre est grand et plus la compression est importante
Je connais le système hexadécimale mais y a t-il un moyen encore plus efficace ?

Ou alors il faudrait crée un système genre hexadécimale mais avec le plus
de caractères possible (Ascii) pour avoir le plus de combinaison possible
je pense par exemple de chr(1) a chr(255)

Je cherche également des procédures qui vont permettre de faire
des opérations comme si ont les fessais sur papier
(addition, soustraction, multiplication, division, etc,) au moins les 4 de base

ça permettra de faire de gigantesques opérations que
Pure Basic et une calculatrice ne peuvent pas faire

Pouvez-vous m'aidez s'il vous plaie !

J'ai commencer ceci pour la table de caractères ascii hexadecimale
enfin si on peut appeler sa comme ça évidement

C'est pas du tous au point mais j'ai bien commenter cette fois-ci

Code : Tout sélectionner

Global NewList Retenu()

Procedure.s Tetradecimale(Nombre)
  
  If Nombre <= 0
    ; On sort imédiatement de la procedure avec la valeur 0
    Debug "Le Nombre est inférieur ou égale a 0 donc on sort de la procedure"
    Debug "--------------------------------------------------------------------------------------------------------------------"
    ProcedureReturn "0"
  Else
    SauvegardeNombre = Nombre
    ; J'ajoute + 1 au Nombre car l'énumération Ascii commence a 1 et non a 0
    ;Nombre + 1
  EndIf

  ; Creation de la base de caractères Ascii (1 Octet par caractère)
  
  ; On commence a partir du code chr(1) car le zéro est réserver pour la fin
  ; de la chaine de caractère et ne peut donc pas être utiliser
  
  For Caractere = 1 To 255
    Caractere$ + Chr(Caractere) + ","
  Next
  
  Reste = Nombre % 255 ; "Nombre" est diviser par 255 (le Nombre de caractère Ascii disponible) et le reste est sauvegarder dans la variable "Reste"
  
  Debug "Le reste de Nombre (" + Str(Nombre) + ") / 255 = " + Str(Reste)
  Debug "Il y a " + Str(Nombre / 255) + " fois 255 dans Nombre (" + Str(Nombre) + ")"
  Debug "--------------------------------------------------------------------------------------------------------------------"
  
  If Nombre / 255 > 0 ; Si le résulta est supérieur a 0, "Nombre" est diviser par 255 pour savoir combien de fois il y a "255" dans "Nombre"
    Debug "Le Nombre est supérieur a 0 car " + Str(Nombre) + " / par 255 donne bien (" + Str(Nombre / 255) + ")"
    Debug "--------------------------------------------------------------------------------------------------------------------"
    Nombre / 255
  Else ; Sinon on ne fait rien
    Debug "Le Nombre est = a 0 car " + Str(Nombre) + " / par 255 donne bien (" + Str(Nombre / 255) + ")"
    Debug "--------------------------------------------------------------------------------------------------------------------"
    Nombre = 0
  EndIf
  
  If Reste > 0
    AddElement(Retenu())
    Retenu() = Reste
    
    Debug "On ajoute le reste (" + Str(Reste) + ") dans la liste 'Retenu()'"
    Debug "--------------------------------------------------------------------------------------------------------------------"
    
  Else
    
  Debug "On ajoute rien dans la liste 'Retenu()' car le reste est de 0"
  Debug "--------------------------------------------------------------------------------------------------------------------"
  
  EndIf

  If Nombre > 255
    Debug "Le Nombre est supérieur a 255 donc on recommence l'oppération du début avec ce nouveaux Nombre (" + Str(Nombre) + ")"
    Debug "--------------------------------------------------------------------------------------------------------------------"
    Tetradecimale(Nombre)
  ElseIf Nombre > 0 And Nombre < 256
    Debug "Le Nombre est supérieur a 0 et inférieur a 256:"
    Debug "On ajoute le Nombre (" + Str(Nombre) + ") dans la liste 'Retenu()'"
    Debug "--------------------------------------------------------------------------------------------------------------------"
    AddElement(Retenu())
    Retenu() = Nombre
  Else
    Debug "Le Nombre est = a 0:"
    Debug "On ajoute rien dans la liste 'Retenu()' car le Nombre est = a 0"
    Debug "--------------------------------------------------------------------------------------------------------------------"
  EndIf
  
  Debug "Recherche des caractères coréspondent au Nombre: (" + Str(SauvegardeNombre) + ")"
  
  ForEach Retenu()
    Retenu$ = StringField(Caractere$, Retenu(), ",")
    Debug "Le caractère correspondent a (" + Str(Retenu()) + ") est = a " + Chr(34) + Retenu$ + Chr(34) + ", = Chr(" + Str(Asc(Retenu$)) + ")"
    Sortie$ + Retenu$
  Next
  
  Debug "--------------------------------------------------------------------------------------------------------------------"
  Debug "Le résulta finale est = a " + Chr(34) + ReverseString(Sortie$) + Chr(34)
  
  ProcedureReturn ReverseString(Sortie$)
  
EndProcedure

Tetradecimale(65025)

Le changement de base ne compresse pas.
Regarde plutot du coté du format zip.

??? non ???

Code : Tout sélectionner

Debug Hex(350045532)

dayvid a écrit :Bonjour

Dobro, Il y a un problème avec ton exemple
Si la valeur est inferieur a 16 (je crois)
ça marche pas

corrigé

Ar-S a écrit :??? non ???
Code : Tout sélectionner
Debug Hex(350045532)

!!! Non !!!

Code : Tout sélectionner

Entier.l = 350045532
Debug Entier
Debug "mémoire utilisée : " + Str(SizeOf(Long)) + " octets"
Chaine.s = Hex(Entier)
Debug Chaine
Debug "mémoire utilisée : " + Str(StringByteLength(Chaine) + SizeOf(Character)) + " octets"

oui mais d'un point de vue Fichier

si tu écris dans ton fichier la chaine "255" elle prends 3 octets
alors que l’équivalent Hexa = "FF" , ça ne prends plus que 2 octets ! il y a bien compression !

parce que je résonne en Chaine hein ...

Ya mieux encore que je vien de découvrir

tu peut faire plutôt

Code : Tout sélectionner

WriteByte(#Fichier, Valeur.b)

J'ai découvert ça très recement

Dobro, dit moi, j'aimerais faire la même chose avec ton code mais avec les caractères a partire de chr(1) jusqu'à chr(255)
comment puis-je proceder stp

J'ai bien essayer déjà de modifier ton code mais j'y arrive pas
regarde:

Code : Tout sélectionner

Declare.s Deci2hexa(nombre.i)
Global NewList retenu()

Global hex$

For a = 1 To 255
  hex$+Chr(a) + ","
Next

For i=0 To 255
  nombre.i=i
  Debug Deci2hexa(nombre.i)
Next i

Procedure.s Deci2hexa(nombre.i)
  ; by Dobro
  ; récursive Power
  
  If nombre.i<256 And nombre.i<>0
    retenu$=StringField(hex$,nombre,",")
    ProcedureReturn retenu$
  ElseIf nombre=0
    retenu$="0"
    ProcedureReturn retenu$
  EndIf
  
  reste.i=nombre.i%256
  nombre.i=nombre.i/256
  
  AddElement(retenu()):retenu()=reste.i
  
  If nombre.i>256
    Deci2hexa(nombre.i)
  Else
    AddElement(retenu()):retenu()=nombre.i
  EndIf
  
  
  ForEach retenu()
    If retenu()>0
      retenu$=StringField(hex$,retenu(),",")
    Else
      retenu$="0"
    EndIf
    
    
    sortie$=sortie$+retenu$
  Next
  ClearList(retenu())
  ProcedureReturn ReverseString (sortie$)
EndProcedure

J'ai pas eu le temps de bien tester mais ça marche ou pas ?

Merci a toi

Salut

Dobro, ton code marche niquel si ce n'est que ça s'arrète a 255

ou alors c'est que je n'est rien compris

Sinon, j'ai générer une table de 65534 caractères Unicode grâce a ce code:

Code : Tout sélectionner

OpenFile(1, "Base de donnée de caractères unicode.txt")
WriteStringFormat(1, #PB_Unicode)

For a = 0 To 65536
  WriteUnicodeCharacter(1, a)
Next
CloseFile(1)

Mais je ne comprends pas pourquoi il manque 2 ou 3 caractères
le caractère chr(0) est réserver pour la fin d'une chaine, a ok
pour le deuxième, serais-ce pour le début d'une chaine ?
et pour le dernier je ne sais pas !

J'ai crée cette petite fonction pour ne gargder qu'un seule exemplaire
des caractères au cas ou il en aurais en double:

Code : Tout sélectionner

If ReadFile(0, "Base de donnée de caractères unicode.txt")
  While Eof(0) = 0
(Eof = 'End Of File') 
    a$ + ReadString(0, #PB_Unicode)
  Wend
  CloseFile(0)
Else
  MessageRequester("Information","Impossible d'ouvrir le fichier!")
EndIf

Repeat
  Pos + 1
  Caractere$ = Mid(a$, Pos, 1)
  If Not FindString(b$, Caractere$, 1)
    b$ + Caractere$
  EndIf
  
Until Caractere$ = ""

SetClipboardText(b$)

J'ai ensuite essayez de crée une fonction pour renvoyer
des caractères Unicode suivent le nombre:

Code : Tout sélectionner

Global NewList Retenu.q()
Global BaseDeDonneeDeCaracteresUnicode$

If ReadFile(0, "Base de donnée de caractères unicode.txt")  ; Si le fichier peut être lu , on continue...
  While Eof(0) = 0         ; Boucle tant que la fin du fichier n'est pas atteinte. (Eof = 'End Of File') 
    BaseDeDonneeDeCaracteresUnicode$ + ReadString(0, #PB_Unicode)      ; Affiche ligne par ligne le contenu du fichier
  Wend
  CloseFile(0)               ; Ferme le fichier précédemment ouvert
Else
  MessageRequester("Information","Impossible d'ouvrir le fichier!")
EndIf


Procedure.s NombreUnicoDecimale(Nombre.q)
  
  If Nombre > 0 And Nombre < 65533
    Retenu$ = Mid(BaseDeDonneeDeCaracteresUnicode$, Nombre, 1)
    
  ElseIf Nombre = 0
    Retenu$ = "0"
    ProcedureReturn Retenu$
    
  EndIf
  
  Reste.q = Nombre % 65532
  Nombre = Nombre / 65532
  
  Debug Reste
  Debug Nombre
  
  AddElement(Retenu())
  Retenu() = Reste
  
  If Nombre > 65532
    NombreUnicoDecimale(Nombre)
  Else
    AddElement(Retenu())
    Retenu() = Nombre
  EndIf
  
  
  ForEach Retenu()
    If Retenu() > 0
      Retenu$ = Mid(BaseDeDonneeDeCaracteresUnicode$, Retenu(), 1)
      
    Else
      Retenu$ = "0"
      
    EndIf
    
    Sortie$ = Sortie$ + Retenu$
  Next
  
  ;ClearList(Retenu()) ; ici si on enlève le commantaire, rien ne va plus, pourquoi ?
  
  ProcedureReturn ReverseString(Sortie$)
  
EndProcedure

MessageRequester("", "        {" + Chr(34) + NombreUnicoDecimale(45550) + Chr(34) + "}", 64)

Mais j'y arrive pas, le but ici serais de faire la même chose que la commande
Hex mais avec des caractères Unicode car il en as beaucoup plus !

Ensuite, j'ai pas réussie a mètre tous ces caractères en DataSection
car pure basic ne reconnais pas les caractères Unicode
Comment puis-je procéder pour mètre cette table
directement dans le programme et l'inclure dans l'exe ?

Je ne veut pas simplement l'inclure dans l'exe mais aussi m'en servir sans pour autant extraire le fichier, c'est pour sa que j'ai essayer avec les DataSection !

Autres question

Comment je peut faire pour que pure basic accepte de très grand nombre
pourquoi c'est limité a maximum -9223372036854775808 à +9223372036854775807

Par exemple en basic « liberty basic »
et bien lui il peut calculer de gigantesque nombre, pourquoi pas bure basic ?

En basic si je fait par exemple:

Print 9999999999999999999999999999999999999999999999999999999999999999
+ 9999999999999999999999999999999999999999999999999999999999999999

il me sort bien:

19999999999999999999999999999999999999999999999999999999999999998

Sa encore ce n'est rien car il peut calculer des nombres gigantesque !

Y a t-il une fonction que l'on peut crée pour que pure basic face de même ?

Que puis-je vous dire de plus pour avoir un peut d'aide
y a t-il un truc que j'aurais zapé

j'y arrive pas

Je n'ai pas étudié ni essayé les codes précédents dayvid
mais je vois For a = 0 To 65536
Déjà je partirai sur 0 to 65535

Je voudrait faire un système comme le hex()
mais avec tous ces caractères

j'ai des soucis et sais pas comment faire !

J'ai trouvé un solution

Je stock tous sa en Data comme ça :

DataSection
Data.s 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, etc. jusqu’à 65535
EndDataSection

Mais comment je fais après pour lire un caractère à une certaine position, exemple 53541
Bon et pour par la suite générer les caractères Unicode suivent le nombre, exemple 999999999999999999

Et comment je fait pour le contraire après, je donne les caractères Unicode et il me trouve le nombre ?

PureBasic

Aide sur génération code...

Aide sur génération code...

Re: Aide sur génération code...

Re: Aide sur génération code...

Re: Aide sur génération code...

Re: Aide sur génération code...

Re: Aide sur génération code...

Re: Aide sur génération code...

Re: Aide sur génération code...

Re: Aide sur génération code...

Re: Aide sur génération code...

Re: Aide sur génération code...

Re: Aide sur génération code...

Re: Aide sur génération code...

Re: Aide sur génération code...

Re: Aide sur génération code...