Générateur de base

[Shadow]

Salut,

Moi qui est souvent besoin d'algorithme pour des bases, j'me suis dis que
si je pouvais en finir une bonne fois pour toute...

C'est chose faite !
Et oui, avec ce code, générez la base de vos rêve sans dec

Vous voulez une base 2, 3, 4, 5... 15, 16, 17..., 24, 25..., 32..., 64..., 128..., 255..., 999..., 9999..., 999999...
Mais oui mais vous voulez aussi utiliser les caractères voulue "Filtre" et oui, ont fais pas les chose à moities sinon autant aller se couché, vue l'heur

Ce code, c'est un premier crue, j'veux dire, un premier jet, permet tous cela !
Je suis très intéressé pour savoir si ya mieux, plus court, plus optimisé, etc quoi

Code : Tout sélectionner

; Code créé par monsieur Dieppedalle David le 26/02/2016
; Ce code permet de générer la base voulut, n'importe la quel minimum de 2, avec le filtre de sortie voulut.

; Si vous êtes en 32 Bit, vous ne pouvez aller au delà de: 2147483647
; Si vous êtes en 64 Bit, vous ne pouvez aller au delà de: 9223372036854775807

Procedure.s InverserChaine(Chaine.s, DelimiteurChaine$ = " ")
  Protected Phrase.s = "", Premier = 1
  
  For i = CountString(Chaine, DelimiteurChaine$) + 1 To 1 Step - 1
    If Premier = 0
      Phrase + DelimiteurChaine$
    Else
      Premier = 0
    EndIf
    Phrase + StringField(Chaine, i, DelimiteurChaine$)
  Next
  
  ProcedureReturn Phrase
EndProcedure

Procedure.q VerificateurNombreChaine(Instance.i, NombreChaine.s, NombreMaximal.s = "9223372036854775807", LongeurMaximum.i = 19)
  
  LongueurNombre.i = Len(NombreChaine.s)
  
  For I = 1 To LongueurNombre.i
    
    CaractereAscii = Asc(Mid(NombreChaine.s, I, 1))
    
    If (CaractereAscii < '0' Or CaractereAscii > '9')
      MessageRequester("GenerateurDeBase Instance n°" + Str(Instance.i) + ", ATTENTION !", "    Le nombre ne peut contenir que des chiffres !", 64)
      End
    EndIf
    
  Next
  
  If LongueurNombre.i = 0
    MessageRequester("GenerateurDeBase Instance n°" + Str(Instance.i) + ", ATTENTION !", "    Le nombre ne peut pas être une chaîne vide !", 64)
    End
    
  ElseIf LongueurNombre.i > LongeurMaximum.i
    MessageRequester("GenerateurDeBase Instance n°" + Str(Instance.i) + ", ATTENTION !", "    Le nombre ne peut pas être supérieur à " + Str(LongeurMaximum.i) + " chiffre !", 64)
    End
    
  ElseIf LongueurNombre.i = LongeurMaximum.i
    
    Maxi$ = NombreMaximal.s
    
    For I = 1 To LongueurNombre.i
      
      CaractereNombre$ = Mid(NombreChaine.s, I, 1)
      CaractereMaxi$ = Mid(Maxi$, I, 1)
      
      If Val(CaractereNombre$) > Val(CaractereMaxi$)
        
        MessageRequester("GenerateurDeBase Instance n°" + Str(Instance.i) + ", ATTENTION !", "    Le nombre est trop grand !" + Chr(13) + Chr(13) +
                                                                                             "    Le nombre doit être compris entre 0 et " + NombreMaximal.s + " inclus !"+ Chr(13) +
                                                                                             "    Le nombre actuel est de: " + NombreChaine.s, 64)
        End
        
      EndIf
      
    Next
    
  EndIf
  
  ProcedureReturn Val(NombreChaine.s)
  
EndProcedure

Procedure.s GenererBase(Instance.i, Base.i, NombreChaine.s, Filtre$, DelimiteurSortie$ = ".", InversionSortie.b = #True)
  
  ; Sert uniquement de repèrage en cas d'erreur.
  If Instance.i <= 0
    MessageRequester("GenerateurDeBase Instance n°" + Str(Instance.i) + ", ATTENTION !", "    Une instance ne peut pas être inférieure ou égale à 0 !", 64)
    End
  ElseIf Instance.i = #PB_Any
    MessageRequester("GenerateurDeBase Instance n°" + Str(Instance.i) + ", ATTENTION !", "    #PB_Any ne peut pas être utilisé pour le numéro de l'instance !" + Chr(13) +
                                    "    Vous devez vous même affecter un numéro d'instance !", 64)
    End
  EndIf
  
  CompilerIf #PB_Compiler_Processor = #PB_Processor_x86
    NombreVerifier.q = VerificateurNombreChaine(Instance.i, NombreChaine.s, "2147483647")
    
  CompilerElse
    NombreVerifier.q = VerificateurNombreChaine(Instance.i, NombreChaine.s, "9223372036854775807")
    
  CompilerEndIf

  If Base.i < 2
    MessageRequester("GenerateurDeBase Instance n°" + Str(Instance.i) + ", ATTENTION !", "    Base ne peut pas être inférieure à 2 !", 64)
    End
  EndIf
  
  If Len(DelimiteurSortie$) = 0
    MessageRequester("GenerateurDeBase Instance n°" + Str(Instance.i) + ", ATTENTION !", "    DelimiteurSortie$ doit être constitué d'au moins un caractère !", 64)
    End
  ElseIf Len(DelimiteurSortie$) > 1
    MessageRequester("GenerateurDeBase Instance n°" + Str(Instance.i) + ", ATTENTION !", "    DelimiteurSortie$ ne peut pas être supérieur à un caractère !", 64)
    End
  EndIf
  
  Dim TableauFiltre.s(CountString(Filtre$, DelimiteurSortie$))
  TableauFiltreIndex = 0
  
  For I = 1 To CountString(Filtre$, DelimiteurSortie$) + 1
    
    GroupeFiltre$ = StringField(Filtre$, I, DelimiteurSortie$)
    Trouver = 0
    
    For J = 0 To CountString(Filtre$, DelimiteurSortie$)
      
      If GroupeFiltre$ > "" And GroupeFiltre$ = TableauFiltre.s(J)
        Trouver = 1
        MessageRequester("GenerateurDeBase Instance n°" + Str(Instance.i) + ", ATTENTION !", "    Erreur avec un groupe dans " + Chr(34) + "Filtre$" + Chr(34) + " à l'index " + Str(I) + " !" + Chr(13) +
                                                         "    Le groupe " + Chr(34) + GroupeFiltre$ + Chr(34) + " est déjà utilisé à l'index " + Str(J + 1) +
                                                         " dans " + Chr(34) + "Filtre$" + Chr(34) + " !", 64)
        End
      EndIf
      
    Next
    
    If Trouver = 0
      TableauFiltre.s(TableauFiltreIndex) = GroupeFiltre$
      TableauFiltreIndex + 1
    EndIf
    
  Next
  
  For I = 1 To CountString(Filtre$, DelimiteurSortie$) + 1
    
    GroupeFiltre$ = StringField(Filtre$, I, DelimiteurSortie$)
    
    If GroupeFiltre$ = ""
      MessageRequester("GenerateurDeBase Instance n°" + Str(Instance.i) + ", ATTENTION !", "    Erreur avec un groupe dans " + Chr(34) + "Filtre$" + Chr(34) + " à l'index " + Str(I) + " !" + Chr(13) +
                                                       "    Un groupe dans " + Chr(34) + "Filtre$" + Chr(34) + " ne peut pas être vide !", 64)
      End
    EndIf
    
  Next
    
  If CountString(Filtre$, DelimiteurSortie$) + 1 <> Base.i
    MessageRequester("GenerateurDeBase Instance n°" + Str(Instance.i) + ", ATTENTION !", "    Erreur dans " + Chr(34) + "Filtre$" + Chr(34) + " !" + Chr(13)  + Chr(13) +
                                    "    Le nombre de groupe total (Entre chaque Delimiteur) est erronné !" + Chr(13) + Chr(13) +
                                    "    Vous devez spécifier un ensemble de" + Chr(13) +
                                    "    caractères entre chaque délimiteur !" + Chr(13) + Chr(13) +
                                    "    Exemple: Base = 2, " + Chr(34) + "Filtre$" + Chr(34) +
                                    " doit être de cette forme-ci (2 Groupes):" + Chr(13) + Chr(13) +
                                    "    a.b" + Chr(13) + "    0.1" + Chr(13) + "    abc.def" + Chr(13) + Chr(13) +
                                    "    Exemple: Base = 4, " + Chr(34) + "Filtre$" + Chr(34) +
                                    " doit être de cette forme-ci (4 Groupes):" + Chr(13) + Chr(13) +
                                    "    a.b.c.d" + Chr(13) + "    0.1.2.3" + Chr(13) + "    abc.def.ghi.jkl" + Chr(13) + Chr(13) +
                                    "    Exemple: Base = 6, " + Chr(34) + "Filtre$" + Chr(34) +
                                    " doit être de cette forme-ci (6 Groupes):" + Chr(13) + Chr(13) +
                                    "    a.b.c.d.e.f" + Chr(13) + "    0.1.2.3.4.5" + Chr(13) +
                                    "    abc.def.ghi.jkl.mno.pqr"  + Chr(13) + Chr(13) + "    Il est interdit d'utiliser les mêmes groupes !", 64)
    
    End
  EndIf
  
  Sortie$ = ""

  Repeat
    
    Division.q = NombreVerifier.q / Base.i
    Reste.q = NombreVerifier.q - (Division.q * Base.i)
    
    Sortie$ + StringField(Filtre$, Reste.q + 1, DelimiteurSortie$) + DelimiteurSortie$
    
    NombreVerifier.q = Division.q
    
  Until Division.q < Base.i
  
  If Division.q > 0
    Sortie$ + StringField(Filtre$, Division.q + 1, DelimiteurSortie$)
  EndIf
  
  If InversionSortie.b = #True
    Sortie$ = InverserChaine(Sortie$, DelimiteurSortie$)
  EndIf
  
  If Mid(Sortie$, Len(Sortie$), 1) = DelimiteurSortie$
    Sortie$ = Mid(Sortie$, 1, Len(Sortie$) - 1)
  ElseIf Mid(Sortie$, 1, 1) = DelimiteurSortie$
    Sortie$ = Mid(Sortie$, 2)
  EndIf
  
  ProcedureReturn Sortie$
  
EndProcedure

Procedure DecodeBase(Instance.i, Base.i, ChaineSortie$, SeparateurChaineSortie$, Filtre$, SeparateurFiltre$ = ".")
  
  ; Sert uniquement de repèrage en cas d'erreur.
  If Instance.i <= 0
    MessageRequester("DecodeBase Instance n°" + Str(Instance.i) + ", ATTENTION !", "    Une instance ne peut pas être inférieure ou égale à 0 !", 64)
    End
  ElseIf Instance.i = #PB_Any
    MessageRequester("DecodeBase Instance n°" + Str(Instance.i) + ", ATTENTION !", "    #PB_Any ne peut pas être utilisé pour le numéro de l'instance !" + Chr(13) +
                                    "    Vous devez vous même affecter un numéro d'instance !", 64)
    End
  EndIf
  
  If Len(SeparateurChaineSortie$) = 0
    MessageRequester("GenerateurDeBase Instance n°" + Str(Instance.i) + ", ATTENTION !", "    SeparateurChaineSortie$ doit être constituer d'au moins un caractère !", 64)
    End
  ElseIf Len(SeparateurChaineSortie$) > 1
    MessageRequester("GenerateurDeBase Instance n°" + Str(Instance.i) + ", ATTENTION !", "    SeparateurChaineSortie$ ne peut pas être supérieur à un caractère !", 64)
    End
  EndIf
  
  If Len(SeparateurFiltre$) = 0
    MessageRequester("GenerateurDeBase Instance n°" + Str(Instance.i) + ", ATTENTION !", "    SeparateurFiltre$ doit être constituer d'au moins un caractère !", 64)
    End
  ElseIf Len(SeparateurFiltre$) > 1
    MessageRequester("GenerateurDeBase Instance n°" + Str(Instance.i) + ", ATTENTION !", "    SeparateurFiltre$ ne peut pas être supérieur à un caractère !", 64)
    End
  EndIf
  
  NombreSortie.Q = 0
  Chiffre$ = ""
  
  Dim TableauFiltre.s(CountString(Filtre$, SeparateurChaineSortie$))
  TableauFiltreIndex = 0
  
  For I = 1 To CountString(Filtre$, SeparateurChaineSortie$) + 1
    
    GroupeFiltre$ = StringField(Filtre$, I, SeparateurChaineSortie$)
    Trouver = 0
    
    For J = 0 To CountString(Filtre$, SeparateurChaineSortie$)
      
      If GroupeFiltre$ = TableauFiltre.s(J)
        Trouver = 1
        MessageRequester("DecodeBase Instance n°" + Str(Instance.i) + ", ATTENTION !", "    Erreur avec un groupe dans " + Chr(34) + "Filtre$" + Chr(34) + " à l'index " + Str(I) + " !" + Chr(13) +
                                                         "    Le groupe " + Chr(34) + GroupeFiltre$ + Chr(34) + " est déjà utilisé à l'index " + Str(J + 1) +
                                                         " dans " + Chr(34) + "Filtre$" + Chr(34) + " !", 64)
        End
      EndIf
      
    Next
    
    If Trouver = 0
      TableauFiltre.s(TableauFiltreIndex) = GroupeFiltre$
      TableauFiltreIndex + 1
    EndIf
    
  Next
  
  For I = 1 To CountString(Filtre$, DelimiteurSortie$) + 1
    
    GroupeFiltre$ = StringField(Filtre$, I, DelimiteurSortie$)
    
    If GroupeFiltre$ = ""
      MessageRequester("DecodeBase Instance n°" + Str(Instance.i) + ", ATTENTION !", "    Erreur avec un groupe dans " + Chr(34) + "Filtre$" + Chr(34) + " à l'index " + Str(I) + " !" + Chr(13) +
                                                       "    Un groupe dans " + Chr(34) + "Filtre$" + Chr(34) + " ne peut pas être vide !", 64)
      End
    EndIf
    
  Next
  
  If CountString(Filtre$, SeparateurChaineSortie$) + 1 <> Base.i
    MessageRequester("DecodeBase Instance n°" + Str(Instance.i) + ", ATTENTION !", "    Erreur dans " + Chr(34) + "Filtre$" + Chr(34) + " !" + Chr(13)  + Chr(13) +
                                    "    Le nombre de groupe total (Entre chaque Delimiteur) est erronné !" + Chr(13) + Chr(13) +
                                    "    Vous devez spécifier un ensemble de" + Chr(13) +
                                    "    caractères entre chaque délimiteur !" + Chr(13) + Chr(13) +
                                    "    Exemple: Base = 2, " + Chr(34) + "Filtre$" + Chr(34) +
                                    " doit être de cette forme-ci (2 Groupes):" + Chr(13) + Chr(13) +
                                    "    a.b" + Chr(13) + "    0.1" + Chr(13) + "    abc.def" + Chr(13) + Chr(13) +
                                    "    Exemple: Base = 4, " + Chr(34) + "Filtre$" + Chr(34) +
                                    " doit être de cette forme-ci (4 Groupes):" + Chr(13) + Chr(13) +
                                    "    a.b.c.d" + Chr(13) + "    0.1.2.3" + Chr(13) + "    abc.def.ghi.jkl" + Chr(13) + Chr(13) +
                                    "    Exemple: Base = 6, " + Chr(34) + "Filtre$" + Chr(34) +
                                    " doit être de cette forme-ci (6 Groupes):" + Chr(13) + Chr(13) +
                                    "    a.b.c.d.e.f" + Chr(13) + "    0.1.2.3.4.5" + Chr(13) +
                                    "    abc.def.ghi.jkl.mno.pqr"  + Chr(13) + Chr(13) + "    Il est interdit d'utiliser les mêmes groupes !", 64)
    
    End
  EndIf
  
  If ChaineSortie$ > ""
    
    For Index = 1 To CountString(ChaineSortie$, SeparateurFiltre$) + 1
      
      Chiffre$ = StringField(ChaineSortie$, Index, SeparateurFiltre$)
      
      For I = 1 To CountString(Filtre$, SeparateurChaineSortie$) + 1
        
        If StringField(Filtre$, I, SeparateurChaineSortie$) = Chiffre$
          Chiffre = I - 1
          Break
        EndIf
        
      Next
      
      NombreSortie.Q * Base.i
      NombreSortie.Q + Chiffre
      
    Next
    
    ProcedureReturn NombreSortie.Q
  Else
    
    ProcedureReturn 0
  EndIf
  
EndProcedure

NombreTest$ = "16"

; Exemple 1
Instance.i = 1
Base.i = 2
Nombre.s = NombreTest$
Filtre$ = "0.1"
ChaineSortie$ = GenererBase(Instance.i, Base.i, Nombre.s, Filtre$, ".")
Debug "Exemple 1"
Debug "Nombre original = " + Nombre.s
Debug "Codé en base -> " + Str(Base.i)
Debug "Filtre de génération = " + Filtre$
Debug "Chaine généré = " + ChaineSortie$
Debug "Chaine décodé = " + Str(DecodeBase(Instance.i,Base.i, ChaineSortie$, ".", Filtre$, "."))

Debug "------------------------------------------------------------------------------------------"

; Exemple 2
Instance.i = 2
Base.i = 4
Nombre.s = NombreTest$
Filtre$ = "1.2.3.4"
ChaineSortie$ = GenererBase(Instance.i,Base.i, Nombre.s, Filtre$, ".")
Debug "Exemple 2"
Debug "Nombre original = " + Nombre.s
Debug "Codé en base -> " + Str(Base.i)
Debug "Filtre de génération = " + Filtre$
Debug "Chaine généré = " + ChaineSortie$
Debug "Chaine décodé = " + Str(DecodeBase(Instance.i,Base.i, ChaineSortie$, ".", Filtre$, "."))

Debug "------------------------------------------------------------------------------------------"

; Exemple 3
Instance.i = 3
Base.i = 5
Nombre.s = NombreTest$
Filtre$ = "A.B.C.D.E"
ChaineSortie$ = GenererBase(Instance.i,Base.i, Nombre.s, Filtre$, ".")
Debug "Exemple 3"
Debug "Nombre original = " + Nombre.s
Debug "Codé en base -> " + Str(Base.i)
Debug "Filtre de génération = " + Filtre$
Debug "Chaine généré = " + ChaineSortie$
Debug "Chaine décodé = " + Str(DecodeBase(Instance.i,Base.i, ChaineSortie$, ".", Filtre$, "."))

Debug "------------------------------------------------------------------------------------------"

; Exemple 4
Instance.i = 4
Base.i = 8
Nombre.s = NombreTest$
Filtre$ = "Abc.Def.Ghi.Jkl.Mno.Pqr.Stu.Vwx"
ChaineSortie$ = GenererBase(Instance.i,Base.i, Nombre.s, Filtre$, ".")
Debug "Exemple 4"
Debug "Nombre original = " + Nombre.s
Debug "Codé en base -> " + Str(Base.i)
Debug "Filtre de génération = " + Filtre$
Debug "Chaine généré = " + ChaineSortie$
Debug "Chaine décodé = " + Str(DecodeBase(Instance.i,Base.i, ChaineSortie$, ".", Filtre$, "."))

Debug "------------------------------------------------------------------------------------------"

; Exemple 5
Instance.i = 5
Base.i = 8
Nombre.s = NombreTest$
Filtre$ = "Abc.Def.Ghi.Jkl.Mno.Pqr.Stu.Vwx"
ChaineSortie$ = GenererBase(Instance.i,Base.i, Nombre.s, Filtre$, ".")
Debug "Exemple 5"
Debug "Nombre original = " + Nombre.s
Debug "Codé en base -> " + Str(Base.i)
Debug "Filtre de génération = " + Filtre$
Debug "Chaine généré = " + ChaineSortie$
Debug "Chaine décodé = " + Str(DecodeBase(Instance.i,Base.i, ChaineSortie$, ".", Filtre$, "."))

Debug "------------------------------------------------------------------------------------------"

; Exemple 6
Instance.i = 6
Base.i = 10
Nombre.s = NombreTest$
Filtre$ = "0.1.2.3.4.5.6.7.8.9"
ChaineSortie$ = GenererBase(Instance.i,Base.i, Nombre.s, Filtre$, ".", #True)
Debug "Exemple 6"
Debug "Nombre original = " + Nombre.s
Debug "Codé en base -> " + Str(Base.i)
Debug "Filtre de génération = " + Filtre$
Debug "Chaine généré = " + ChaineSortie$
Debug "Chaine décodé = " + StrU(DecodeBase(Instance.i,Base.i, ChaineSortie$, ".", Filtre$, "."))

Debug "------------------------------------------------------------------------------------------"

; Exemple 7
Instance.i = 7
Base.i = 16
Nombre.s = NombreTest$
Filtre$ = "HO.HA.HE.HI.BO.BA.BE.BI.KO.KA.KE.KI.DO.DA.DE.DI"
ChaineSortie$ = GenererBase(Instance.i,Base.i, Nombre.s, Filtre$, ".", #True)
Debug "Exemple 7"
Debug "Nombre original = " + Nombre.s
Debug "Codé en base -> " + Str(Base.i)
Debug "Filtre de génération = " + Filtre$
Debug "Chaine généré = " + ChaineSortie$
Debug "Chaine décodé = " + StrU(DecodeBase(Instance.i,Base.i, ChaineSortie$, ".", Filtre$, "."))

Debug "------------------------------------------------------------------------------------------"

; Exemple 8
Instance.i = 8
Base.i = 16
Nombre.s = NombreTest$
Filtre$ = "0.1.2.3.4.5.6.7.8.9.A.B.C.D.E.F"
ChaineSortie$ = GenererBase(Instance.i,Base.i, Nombre.s, Filtre$, ".", #True)
Debug "Exemple 8"
Debug "Nombre original = " + Nombre.s
Debug "Codé en base -> " + Str(Base.i)
Debug "Filtre de génération = " + Filtre$
Debug "Chaine généré = " + ChaineSortie$
Debug "Chaine décodé = " + StrU(DecodeBase(Instance.i,Base.i, ChaineSortie$, ".", Filtre$, "."))

Debug "------------------------------------------------------------------------------------------"

; Exemple 9
Instance.i = 9
Base.i = 52
Nombre.s = NombreTest$
Filtre$ = "a.A.b.B.c.C.d.D.e.E.f.F.g.G.h.H.i.I.j.J.k.K.l.L.m.M.n.N.o.O.p.P.q.Q.r.R.s.S.t.T.u.U.v.V.w.W.x.X.y.Y.z.Z"
ChaineSortie$ = GenererBase(Instance.i,Base.i, Nombre.s, Filtre$, ".", #False)
Debug "Exemple 9"
Debug "Nombre original = " + Nombre.s
Debug "Codé en base -> " + Str(Base.i)
Debug "Filtre de génération = " + Filtre$
Debug "Chaine généré = " + ChaineSortie$
Debug "Chaine décodé = " + StrU(DecodeBase(Instance.i,Base.i, InverserChaine(ChaineSortie$, "."), ".", Filtre$, "."))

Debug "------------------------------------------------------------------------------------------"

; Exemple 10
Instance.i = 10
Base.i = 256
Nombre.s = NombreTest$
Filtre$ = "000.001.002.003.004.005.006.007.008.009.010.011.012.013.014.015.016.017.018.019.020.021.022.023.024.025.026.027.028.029.030.031.032.033.034.035.036.037.038.039.040.041.042.043.044.045.046.047.048.049.050.051.052.053.054.055.056.057.058.059.060.061.062.063.064.065.066.067.068.069.070.071.072.073.074.075.076.077.078.079.080.081.082.083.084.085.086.087.088.089.090.091.092.093.094.095.096.097.098.099.100.101.102.103.104.105.106.107.108.109.110.111.112.113.114.115.116.117.118.119.120.121.122.123.124.125.126.127.128.129.130.131.132.133.134.135.136.137.138.139.140.141.142.143.144.145.146.147.148.149.150.151.152.153.154.155.156.157.158.159.160.161.162.163.164.165.166.167.168.169.170.171.172.173.174.175.176.177.178.179.180.181.182.183.184.185.186.187.188.189.190.191.192.193.194.195.196.197.198.199.200.201.202.203.204.205.206.207.208.209.210.211.212.213.214.215.216.217.218.219.220.221.222.223.224.225.226.227.228.229.230.231.232.233.234.235.236.237.238.239.240.241.242.243.244.245.246.247.248.249.250.251.252.253.254.255"
ChaineSortie$ = GenererBase(Instance.i,Base.i, Nombre.s, Filtre$, ".", #False)
Debug "Exemple 10"
Debug "Nombre original = " + Nombre.s
Debug "Codé en base -> " + Str(Base.i)
Debug "Filtre de génération = " + Filtre$
Debug "Chaine généré = " + ChaineSortie$
Debug "Chaine décodé = " + StrU(DecodeBase(Instance.i,Base.i, InverserChaine(ChaineSortie$, "."), ".", Filtre$, "."))

Debug "------------------------------------------------------------------------------------------"

; Exemple de filtre:

; Base 16, "0.1.2.3.4.5.6.7.8.9.A.B.C.D.E.F"
; Base 16 Bibi-binaire, "HO.HA.HE.HI.BO.BA.BE.BI.KO.KA.KE.KI.DO.DA.DE.DI"
; Base 52, "a.A.b.B.c.C.d.D.e.E.f.F.g.G.h.H.i.I.j.J.k.K.l.L.m.M.n.N.o.O.p.P.q.Q.r.R.s.S.t.T.u.U.v.V.w.W.x.X.y.Y.z.Z"
; Base 256, "000.001.002.003.004.005.006.007.008.009.010.011.012.013.014.015.016.017.018.019.020.021.022.023.024.025.026.027.028.029.030.031.032.033.034.035.036.037.038.039.040.041.042.043.044.045.046.047.048.049.050.051.052.053.054.055.056.057.058.059.060.061.062.063.064.065.066.067.068.069.070.071.072.073.074.075.076.077.078.079.080.081.082.083.084.085.086.087.088.089.090.091.092.093.094.095.096.097.098.099.100.101.102.103.104.105.106.107.108.109.110.111.112.113.114.115.116.117.118.119.120.121.122.123.124.125.126.127.128.129.130.131.132.133.134.135.136.137.138.139.140.141.142.143.144.145.146.147.148.149.150.151.152.153.154.155.156.157.158.159.160.161.162.163.164.165.166.167.168.169.170.171.172.173.174.175.176.177.178.179.180.181.182.183.184.185.186.187.188.189.190.191.192.193.194.195.196.197.198.199.200.201.202.203.204.205.206.207.208.209.210.211.212.213.214.215.216.217.218.219.220.221.222.223.224.225.226.227.228.229.230.231.232.233.234.235.236.237.238.239.240.241.242.243.244.245.246.247.248.249.250.251.252.253.254.255"

[Micoute]

Très bon travail Shadow, il fonctionne très bien avec la dernière version de PureBasic (x86) et (x64).

Merci pour le partage.

[djes]

C'est très bien mais j'ai une petite remarque sur quelque chose qui n'a rien à voir avec la programmation. Voilà, tu fais des fautes de grammaire qui seraient très faciles à corriger avec un tout petit peu d'application. C'est important quand on présente un code, ça fait plus "sérieux", ça montre un certain respect pour les autres. En plus ce sont des fautes vraiment toutes bêtes.

Par exemple, le titre : "générateur de base". Pour moi, cela ne veut rien dire, surtout avec base au singulier. Première phrase "Moi qui est souvent besoin d'algorithme pour des bases" : verbe être au lieu du verbe avoir. Niveau élémentaire, tu remplaces par l'infinitif "être", et tu vois que la phrase est absurde ! Et dans le code, des tas de petites fautes d'accord : UNE base, donc tu accordes au féminin ; UN groupe, UNE chaîne...

Si tu n'es pas capable de faire attention à ce genre de détail, cela *peut* signifier que ton code non plus n'a pas été vérifié, et donc n'est pas fiable. Je ne dis pas que c'est le cas, je dis juste que pour tes productions futures, il faut que tu t'habitues à être hyper précis. Ici, c'est cool, mais ailleurs, cela pourrait te porter préjudice.

Allez, sans rancune ; c'est un bon code, merci pour le partage et tes efforts

[cage]

Bonjour,

Pour les utilisateurs de Firefox, voici une astuce qui peut aider.
Ouvrir les Options de Firefox puis cliquer sur Avancé
Cocher la case Vérifier l'orthographe lors de la frappe

Puis rendez vous sur la page :
https://support.mozilla.org/fr/kb/param ... =inproduct

[Shadow]

Bonjour,

@djes, je prends note merci à toi

C'est vraie que je poste très souvent à la va vite et que seul le renard de feu corriges mes fautes à se moment là !
Comme tu dis aussi, ici, c'est cool mais... préjudice ici quand même !

Ce code n'est pas superbe ni très bon, bon peut être et encore.
Je fais des tas de fautes bien que je me soie un peu amélioré, j'en fais encore pas mal.

Merci de t'es encouragement ça fais bien plaisir tu sais
Je ne suis pas satisfais à 100% de se code.

@cage, le renard de feu corriges mes fautes déjà mais je t'en remercie

[falsam]

Mon code proposé étant faux je l'ai retiré.

[Ar-S]

Shadow déjà ça fait plaisir de te voir sortir un code fonctionnel. Du coté des fautes je crois surtout que tu es un grand impatient et que tu ne te relis pas forcément beaucoup. C'est dommage.
ex : le renard de feu corriges mes fautes à se moment là
- Pourquoi mettre un s à corrige ?
- se moment / ce moment => Pour ne pas te tromper, l'astuce consiste (dans ta tête) à remplacer ce par "celui-ci". Si ça marche c'est que c'est CE. Imagine que tu puisses le montrer du doigt.

J'aime ce code (j'ai celui ci là ! ici ! tu vois je le montre lààà )
Il faut se coucher (il faut celui-ci coucher ça veut rien dire .. => donc se et pas ce)

Le cours est terminé

Poursuis dans tes efforts ça fait plaisir. Et prends ton temps quand tu postes un sujet.

[Shadow]

Shadow déjà ça fait plaisir de te voir sortir un code fonctionnel. Du coté des fautes je crois surtout que tu es un grand impatient et que tu ne te relis pas forcément beaucoup. C'est dommage.
ex : le renard de feu corriges mes fautes à se moment là
- Pourquoi mettre un s à corrige ?
- se moment / ce moment => Pour ne pas te tromper, l'astuce consiste (dans ta tête) à remplacer ce par "celui-ci". Si ça marche c'est que c'est CE. Imagine que tu puisses le montrer du doigt.

J'aime ce code (j'ai celui ci là ! ici ! tu vois je le montre lààà )
Il faut se coucher (il faut celui-ci coucher ça veut rien dire .. => donc se et pas ce)

Le cours est terminé

Poursuis dans tes efforts ça fait plaisir. Et prends ton temps quand tu postes un sujet.

Merci.

- Pourquoi mettre un s à corrige ?
Parce que le renard de feu corriges (Plusieurs fois) mes fautes à se moment là !
Faut pas trop m'en demander non plus lol.

Ont est pas là (Car ont peut dire "ici") pour faire un court de grammaire, les prof ont essayé (Car ont peut dire vendus)
il se sont cassés (Car ont peut dire vendus) toutes leurs dents !

Je ne dis pas ça (Car ont peu dire "ceci") pour toi Ar-s mais pour ne pas polémiquer...
Moi ont m'as dis:

Si tu peut mettre "Ceci", c'est "Ce", sinon c'est "Se", ex:

Se chien = Ok, Ce chien = Non
Se serait bien = Non, Ce serait bien = Ok
Il se dit = Ok, Il ce dit = Non
Et ça se pourrait bien = Ok, Et ça ce pourrait bien = Non
Se vêtement = Ok, Ce vêtement = Non

Mais je dois avoir tous faux j'imagine !
Car:

Se chien (Je peut le montrer du doigt) donc "Ce chien" ?
Se serait bien (Ici non, donc c'est bien "Ce")
Il se dit (Pareil ici !)
Et ça se pourrait bien (Ont ne change pas une équipe qui gagne !)
Se vêtement (Je peut le montrer du doigt) donc "Ce vêtement" ?

Bha voilà du coup j'ai polémiquer, c'est malin ça !
Bref.

[Ar-S]

N'empêche que ça marche

[Shadow]

Je poste le code optimisé et revue.
Code modifié (En haut).
Merci à Gally-HC.

Par contre je suis bloquer à 9223372036854775807, je ne sais pas comment aller jusque 18446744073709551615
J'ai bien essayé pourtant mais en vain !

Si quelqu'un sais comment faire

[Shadow]

Merci Dobro

Moi je peux générer n'importe quel base avec n'importe quel filtre de sortie !
C'est là ou deviens intéressant le code

[falsam]

Ton exemple 5 ne fonctionne pas Shadow.
La chaine que tu reconstitues n'est pas égale à l'originale.

Exemple 5
Nombre original = 9223372036854775807
Codé en base -> 256
Filtre de génération = 000.001.002.003.004.005.006.007.008.009.010.011.012.013.014.015.016.017.018.019.020.021.022.023.024.025.026.027.028.029.030.031.032.033.034.035.036.037.038.039.040.041.042.043.044.045.046.047.048.049.050.051.052.053.054.055.056.057.058.059.060.061.062.063.064.065.066.067.068.069.070.071.072.073.074.075.076.077.078.079.080.081.082.083.084.085.086.087.088.089.090.091.092.093.094.095.096.097.098.099.100.101.102.103.104.105.106.107.108.109.110.111.112.113.114.115.116.117.118.119.120.121.122.123.124.125.126.127.128.129.130.131.132.133.134.135.136.137.138.139.140.141.142.143.144.145.146.147.148.149.150.151.152.153.154.155.156.157.158.159.160.161.162.163.164.165.166.167.168.169.170.171.172.173.174.175.176.177.178.179.180.181.182.183.184.185.186.187.188.189.190.191.192.193.194.195.196.197.198.199.200.201.202.203.204.205.206.207.208.209.210.211.212.213.214.215.216.217.218.219.220.221.222.223.224.225.226.227.228.229.230.231.232.233.234.235.236.237.238.239.240.241.242.243.244.245.246.247.248.249.250.251.252.253.254.255
Chaine généré = 255.255.255.255.255.255.255.127
Chaine décodé = 18446744073709551615
------------------------------------------------------------------------------------------

[falsam]

Je pense que la conversion héxadécimale ne fonctionne pas non plus

Code : Tout sélectionner

instance.i=1
Base.i = 16
Nombre.s = "2000"
Filtre$ = "0.1.2.3.4.5.6.7.8.9.A.B.C.D.E.F"
ChaineSortie$ = GenererBase(Instance.i,Base.i, Nombre.s, Filtre$, ".", #False)
Debug "Exemple Hexadecimal"
Debug "Nombre original = " + Nombre.s
Debug "Codé en base -> " + Str(Base.i)
Debug "Filtre de génération = " + Filtre$
Debug "Chaine généré = " + ChaineSortie$
Debug "Chaine décodé = " + StrU(DecodeBase(Instance, Base, InverserChaine(ChaineSortie$, "."), ".", Filtre$, "."))

Ton résultat

Exemple Hexadecimal
Nombre original = 2000
Codé en base -> 16
Filtre de génération = 0.1.2.3.4.5.6.7.8.9.A.B.C.D.E.F
Chaine généré = 0.D.7
Chaine décodé = 2000

2000 en hexadécimale donne 7D0 et pas 0D7

PS : Faudrait expliquer à quoi sert l'instance.

[Shadow]

Chez moi en PB 5.41 LTS x 64 fonctionne très bien !
Code mis à jour: Ajout d'un exemple base 16, c'est tout !

Edit: Premier code (Tous en haut) mis a jour.
Maintenant le code s'adapte à votre version de PB, 86 ou 64.

Instance sert à te repérer dans ton code.
Par exemple si tu as plusieurs appel dans le code.

Merci Falsam.

[falsam]

Ton code est prêt pour de la conversion système Bibi-binaire

2000 en héxa devient 7D0 puis en Bibi-binaire devient BIDAHO. Je trouve ça jolie.

Ref : https://fr.wikipedia.org/wiki/Syst%C3%A8me_Bibi-binaire