Discussion :

[philben]

bonjour User,

Une nouvelle version avec le sql

Ta nouvelle solution fonctionne bien, de mon côté, je me suis amusé à programmer une méthode sans la colonne <mot> de la table pour gagner 1,5Mo, ça fonctionne mais c'est pour le fun !

Je me suis aussi amusé à programmer le Compte est bon avec une fonction récursive qui semble fonctionner pas mal.
Le style est un peu crade mais en une heure c'était dans le sac.

La fonction :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
'v1.01 :
'-> optimisation et nettoyage du code
'-> correction d'un bug avec la division (autorise / maintenant si l1 = l2)
Private Sub ChercheCEB(ByRef alNombres() As Long, ByVal lResultat As Long, _
                       ByVal byProf As Byte, tCEB As tCompteEstBon)
   Dim fDiv As Single
   Dim l1 As Long, l2 As Long, lSaveBest As Long, lSaveValeur As Long
   Dim i As Byte, j As Byte, k As Byte
   Dim bCalc As Boolean
 
   For i = 0 To 5
      If alNombres(i) > 0 Then
         l1 = alNombres(i)
         alNombres(i) = 0
         For j = i + 1 To 5
            If alNombres(j) > 0 Then
               l2 = alNombres(j)
               alNombres(j) = 0
               For k = 0 To 3
                  Select Case k
                  Case 0   '+
                     alNombres(i) = l1 + l2
                     bCalc = True
                  Case 1   '-
                     If l1 <> l2 Then
                        alNombres(i) = Abs(l1 - l2)
                        bCalc = True
                     End If
                  Case 2   'x
                     If l1 < 10 ^ 4 And l2 < 10 ^ 4 Then
                        alNombres(i) = l1 * l2
                        bCalc = True
                     End If
                  Case Else   '/
                     If l1 >= l2 Then
                        fDiv = l1 / l2
                        If fDiv = Int(fDiv) Then
                           alNombres(i) = fDiv
                           bCalc = True
                        End If
                     End If
                  End Select
                  If bCalc Then
                     tCEB.lCount = tCEB.lCount + 1
                     If alNombres(i) = lResultat Or _
                        Abs(alNombres(i) - lResultat) < Abs(tCEB.lBest - lResultat) Then
                        tCEB.byLastProf = byProf
                        tCEB.lBest = alNombres(i)
                        SetOperation k, byProf, l1, l2, alNombres(i), tCEB
                        If alNombres(i) = lResultat Then Exit Sub
                     End If
                     If byProf - 1 > 0 Then
                        lSaveValeur = alNombres(i)
                        lSaveBest = tCEB.lBest
                        ChercheCEB alNombres, lResultat, byProf - 1, tCEB
                        If tCEB.lBest = lResultat Or _
                           Abs(tCEB.lBest - lResultat) < Abs(lSaveBest - lResultat) Then
                           SetOperation k, byProf, l1, l2, lSaveValeur, tCEB
                           If tCEB.lBest = lResultat Then Exit Sub
                        End If
                     End If
                     bCalc = False
                  End If
               Next k
               alNombres(j) = l2
            End If
         Next j
         alNombres(i) = l1
      End If
   Next i
End Sub
 
Private Sub SetOperation(ByVal byOper As Byte, ByVal byProf As Byte, ByVal l1 As Long, _
                         ByVal l2 As Long, ByVal lValeur As Long, ByRef tCEB As tCompteEstBon)
   Select Case byOper
   Case 0
      tCEB.asOperations(byProf) = l1 & " + " & l2 & " = " & lValeur
   Case 1
      If l1 > l2 Then
         tCEB.asOperations(byProf) = l1 & " - " & l2 & " = " & lValeur
      Else
         tCEB.asOperations(byProf) = l2 & " - " & l1 & " = " & lValeur
      End If
   Case 2
      tCEB.asOperations(byProf) = l1 & " x " & l2 & " = " & lValeur
   Case Else
      tCEB.asOperations(byProf) = l1 & " / " & l2 & " = " & lValeur
   End Select
End Sub

le type utilisé :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
Private Type tCompteEstBon
   asOperations(1 To 5) As String
   lBest As Long
   lCount As Long
   byLastProf As Byte
End Type

la fonction appelante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
'modifiée
Public Function CEB(ByRef alNombres() As Long, ByVal lResultat As Long)
   Dim tCEB As tCompteEstBon
   Dim lTmp As Long
   Dim i As Integer, j As Byte
   Dim s As String
 
   DoCmd.Hourglass True
 
   Randomize
   For i = 5 To 2 Step -1
      j = Int(i * Rnd())
      lTmp = alNombres(i)
      alNombres(i) = alNombres(j)
      alNombres(j) = lTmp
   Next i
 
   ChercheCEB alNombres, lResultat, 5, tCEB
 
   If tCEB.lBest = lResultat Then
      s = "Solution trouvée : "
   Else
      s = "Compte Approché : "
   End If
   s = s & tCEB.lBest & vbCrLf & "en " & tCEB.lCount & " essais"
   j = 1
   For i = 5 To tCEB.byLastProf Step -1
      If tCEB.asOperations(i) <> vbNullString Then
         s = s & vbCrLf & j & ") " & tCEB.asOperations(i)
         j = j + 1
      End If
   Next i
 
   Forms!Compte_est_bon!Solutions = Forms!Compte_est_bon!Solutions & s & vbCrLf
   DoCmd.Hourglass False
End Function

Et le code du bouton appelant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
Private Sub Commande76_Click()
Dim t1(0 To 5) As Long
Dim i As Integer
Dim res As Integer
Dim s As String
Dim t0 As Long
 
 
Me!ProgressBar.Value = 0
Me.TimerInterval = 0
 
res = CInt(Me!Resultat.Caption)
 
For i = 0 To 5
t1(i) = CInt(Me("Nombre" & (i + 1)).Caption)
Next i
 
 
'Me!Solutions = ""
't0 = GetTickCount()
ceb t1, res
'MsgBox GetTickCount() - t0
End Sub

Amicalement,

Philippe

[vodiem]

c'est un peu limite à la discution mais je voudrais revenir sur le gain que tu parles philben.

j'ai comparé 4 requetes équivalentes provenant de synthaxe différente:
SQL1: INNER JOIN
SQL2: EXISTS
SQL3: LEFT JOIN (evidemment +long)
SQL4: IN
Une requete du type "WHERE ([motif]='...') OR ..." étant beaucoup plus long.

code de test:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
Option Compare Database
 
Private Declare Function GetTickCount Lib "kernel32" () As Long
 
Function tempsEcoule(sql As Variant) As Long
Dim rs As DAO.Recordset
debut = GetTickCount()
Set rs = CurrentDb.OpenRecordset(sql)
fin = GetTickCount()
rs.Close
tempsEcoule = fin - debut
End Function
 
Private Sub Commande1_Click()
 
SQL1 = "SELECT DISTINCT D.mot " & _
       "FROM combinaison AS C INNER JOIN dico AS D ON C.motif=D.motif;"
 
SQL2 = "SELECT t1.mot " & _
       "FROM dico AS t1 " & _
       "WHERE EXISTS (select t2.motif from combinaison t2 where t2.motif=t1.motif)"
 
SQL3 = "SELECT DISTINCT t2.mot " & _
       "FROM combinaison AS t1 LEFT JOIN dico AS t2 ON t1.motif = t2.motif " & _
       "WHERE not (t2.motif is null)"
 
SQL4 = "SELECT mot FROM dico " & _
       "WHERE motif IN (select motif from combinaison)"
 
Debug.Print "SQL4: " & tempsEcoule(SQL4)
Debug.Print "SQL3: " & tempsEcoule(SQL3)
Debug.Print "SQL2: " & tempsEcoule(SQL2)
Debug.Print "SQL1: " & tempsEcoule(SQL1)
 
End Sub

résultat:
après 1er ouverture de la base:
SQL1: 687
SQL2: 78
SQL3: 1969
SQL4: 31

2eme exécution
SQL1: 266
SQL2: 31
SQL3: 1375
SQL4: 15

3eme
SQL1: 250
SQL2: 15
SQL3: 1375
SQL4: 31

inversement (des fois que...)
SQL4: 15
SQL3: 1406
SQL2: 32
SQL1: 250

on peut donc noter que l'INNER JOIN est moins rapide qu'un EXISTS et qu'un IN.

et voici une discution sur la comparaison entre l'EXISTS et IN: ici

je vais donc garder mes aprioris.

User tu as bien fait de modifier le code du genCombinaison car cela devait être avec mon code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

s = s + Mid(chaine, j + 1, SHR(i + 1, j) And 1)

et tu as tout à fait raison: une fois la combinaison crée, toutes les formes sont déjà présent donc la génération du motif alourdi de traitement.

bravo philben pour la suite: "le compte est bon"
je n'aurait pas le temps là dessus de chipoter avec toi.

[philben]

salut vodiem,

peux-tu ajouter la boucle sur les enregistrements dans ton temps car ouvrir un recordset n'est pas parcourir le jeu...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
Set oRs = oDb.OpenRecordset(sql_mots, dbOpenForwardOnly)
   Do Until oRs.EOF
      tb_str(Len(oRs!mot)) = tb_str(Len(oRs!mot)) & oRs!mot & " "
      oRs.MoveNext
   Loop

A+

Philippe

[User]

Salut à tous les deux

Philben:
Concernant le compte est bon j'ai testé ta fonction récursive qui fonctionne très bien (ca ouvre de nouvelles possibilités...)

juste 2 petits problèmes à rectifier quand tu en auras le temps (restons zen),

eviter les opérations du style
10*1=10
10/1=10

et dans de très rares cas, des résultats intermédiaire qui ne sont pas utilisés du style:

compte a trouver 110
1) 50 +5 =55
2) 100+20 = 120
3) 55*2 = 110

l'operation 2) 100+20=120 n'est pas utilisé...


je precise qu'il s'agit de cas rares

--------------------------------------------

Sinon Bravo ca apporte un plus indéniable

Bonne soirée à tous

Denis

[vodiem]

salut à tous,

philben>

après 1er ouverture de la base:
SQL1: 297
SQL2: 265
SQL3: 2453
SQL4: 266

2eme exec:
SQL1: 266
SQL2: 266
SQL3: 1406
SQL4: 266

3eme:
SQL1: 265
SQL2: 282
SQL3: 1390
SQL4: 266

après qq manip:
SQL1: 266
SQL2: 265
SQL3: 1391
SQL4: 281

c'est une question intéressante. on va pas trop chipoter on peut dire que dans ce contexte cela se vaut.
je ne dirais pas que l'INNER JOIN est équivalent mais que l'utilisation des recordsets inhibe les performances du EXISTS/IN.

[philben]

bonjour Denis,

Sinon Bravo ca apporte un plus indéniable

Ce n'était pas mon objectif car ton système fonctionne très bien, mais seulement de pouvoir enfin battre ce jeu !

Merci à toi User

Philippe

[philben]

bonjour Denis,

J'ai essayé de tenir compte de tes observations et j'espère avoir résolu la majorité des problèmes (reste parfois des opérations non nécessaires) avec ce nouveau code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
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
 
Option Compare Database
Option Explicit
 
'Algo récursif pour le "Compte Est Bon" - v1.05 - Philben
 
'Constantes pour alOperations
Private Const gcbyl1 As Byte = 0
Private Const gcbyOper As Byte = 1
Private Const gcbyl2 As Byte = 2
Private Const gcbyValeur As Byte = 3
 
'Profondeur de recherche (aucune intérêt de rechercher plus en profondeur)
Private Const gcbyMinProf As Byte = 1
Private Const gcbyMaxProf As Byte = 5
 
Private Const gcbyMaxNombres As Byte = 6
Private Const gcbyMaxTab As Byte = gcbyMaxNombres + gcbyMaxProf - 1
 
Private Type tCompteEstBon
   alOperations(gcbyMinProf To gcbyMaxProf, gcbyl1 To gcbyValeur) As Long
   lMinEcart As Long
   lCount As Long
   byLastProf As Byte
End Type
 
'Fonction principale - Passage d'un tableau de nombre (1 to 6)
Public Function CEB(ByRef alNombres() As Long, ByVal lResultat As Long) As String
   Dim tCEB As tCompteEstBon
   Dim lTmp As Long, alValeurs(1 To gcbyMaxTab) As Long
   Dim i As Integer, j As Byte
   Dim sResultat As String
 
   Randomize
   For i = 1 To gcbyMaxNombres
      alValeurs(i) = alNombres(i)
   Next i
 
   'randomise l'ordre des nombres pour résultat aléatoire
   For i = gcbyMaxNombres - 1 To 2 Step -1
      j = Int(i * Rnd()) + 1
      lTmp = alNombres(i + 1)
      alNombres(i + 1) = alNombres(j)
      alNombres(j) = lTmp
   Next i
 
   tCEB.lMinEcart = 10 ^ 5
 
   'Algo principal de recherche de la solution
   ChercheCEB alNombres, lResultat, 1, tCEB
 
   'Préparation pour affichage
   With tCEB
      For i = gcbyMaxNombres + 1 To gcbyMaxNombres + .byLastProf - 1
         alValeurs(i) = .alOperations(i - gcbyMaxNombres, gcbyValeur)
      Next i
 
      If .lMinEcart = 0 Then
         sResultat = "Solution trouvée !"
      Else
         sResultat = "Compte Approché : " & .alOperations(.byLastProf, gcbyValeur)
      End If
      sResultat = sResultat & vbCrLf & "en " & .lCount & " essais"
      sResultat = sResultat & GetValideOperations(alValeurs, tCEB)
   End With
   CEB = sResultat
End Function
 
'Algo récursif v1.05 :
'-> optimisation vitesse
Private Sub ChercheCEB(ByRef alNombres() As Long, ByVal lResultat As Long, _
                       ByVal byProf As Byte, tCEB As tCompteEstBon)
   Dim fDiv As Single
   Dim l1 As Long, l2 As Long, lSaveEcart As Long, lSaveValeur As Long
   Dim i As Byte, j As Byte, k As Byte
 
   For i = 1 To gcbyMaxNombres
      If alNombres(i) > 0 Then
         l1 = alNombres(i)
         alNombres(i) = 0
         For j = i + 1 To gcbyMaxNombres
            If alNombres(j) > 0 Then
               l2 = alNombres(j)
               alNombres(j) = 0
               For k = 0 To 3
                  Select Case k
                  Case 0   '+
                     alNombres(i) = l1 + l2
                  Case 1   'x
                     If l1 > 1 And l2 > 1 And l1 < 10 ^ 4 And l2 < 10 ^ 4 Then
                        alNombres(i) = l1 * l2
                     End If
                  Case 2   '-
                     If l1 <> l2 Then alNombres(i) = Abs(l1 - l2)
                  Case Else   '/
                     If l1 > 1 And l2 > 1 Then
                        If l1 >= l2 Then
                           fDiv = l1 / l2
                        Else
                           fDiv = l2 / l1
                        End If
                        If fDiv = Int(fDiv) Then alNombres(i) = fDiv
                     End If
                  End Select
                  If alNombres(i) > 0 Then
                     tCEB.lCount = tCEB.lCount + 1
                     If Abs(alNombres(i) - lResultat) < tCEB.lMinEcart Then
                        tCEB.byLastProf = byProf
                        tCEB.lMinEcart = Abs(alNombres(i) - lResultat)
                        tCEB.alOperations(byProf, gcbyl1) = l1
                        tCEB.alOperations(byProf, gcbyOper) = k
                        tCEB.alOperations(byProf, gcbyl2) = l2
                        tCEB.alOperations(byProf, gcbyValeur) = alNombres(i)
                        If tCEB.lMinEcart = 0 Then Exit Sub
                     End If
                     If byProf < gcbyMaxProf Then
                        lSaveValeur = alNombres(i)
                        lSaveEcart = tCEB.lMinEcart
                        ChercheCEB alNombres, lResultat, byProf + 1, tCEB
                        If tCEB.lMinEcart < lSaveEcart Then
                           tCEB.alOperations(byProf, gcbyl1) = l1
                           tCEB.alOperations(byProf, gcbyOper) = k
                           tCEB.alOperations(byProf, gcbyl2) = l2
                           tCEB.alOperations(byProf, gcbyValeur) = lSaveValeur
                           If tCEB.lMinEcart = 0 Then Exit Sub
                        End If
                     End If
                     alNombres(i) = 0
                  End If
               Next k
               alNombres(j) = l2
            End If
         Next j
         alNombres(i) = l1
      End If
   Next i
End Sub
 
'Nettoyage des opérations (enlever celles qui ne sont pas utilisés, etc...)
Private Function GetValideOperations(ByRef alValeurs() As Long, ByRef tCEB As tCompteEstBon) As String
   Dim l As Long
   Dim j As Integer
   Dim i As Byte, k As Byte, byLastValeur As Byte, byCurValeur As Byte
   Dim sOpers As String
 
   With tCEB
      'Annule les nombres puis les opérations utilisés
      byLastValeur = gcbyMaxNombres + .byLastProf - 1
      byCurValeur = gcbyl1
      For i = 1 To 2
         For j = .byLastProf To 1 Step -1
            l = .alOperations(j, byCurValeur)
            For k = 1 To byLastValeur
               If l = alValeurs(k) Then
                  alValeurs(k) = 0
                  Exit For
               End If
            Next k
         Next j
         byCurValeur = gcbyl2
      Next i
 
      'Création des opérations valides
      For i = 1 To .byLastProf - 1
         If alValeurs(i + gcbyMaxNombres) = 0 Then sOpers = sOpers & vbCrLf & GetOperation(i, tCEB)
      Next i
      GetValideOperations = sOpers & vbCrLf & GetOperation(i, tCEB)
   End With
End Function
 
'Création de l'opération
Private Function GetOperation(ByVal byProf As Byte, ByRef tCEB As tCompteEstBon) As String
 
   Dim sOp As String
   Dim lTmp As Long
   With tCEB
      Select Case .alOperations(byProf, gcbyOper)
      Case 0
         sOp = " + "
      Case 1
         sOp = " x "
      Case 2
         sOp = " - "
         If .alOperations(byProf, gcbyl2) > .alOperations(byProf, gcbyl1) Then
            lTmp = .alOperations(byProf, gcbyl2)
            .alOperations(byProf, gcbyl2) = .alOperations(byProf, gcbyl1)
            .alOperations(byProf, gcbyl1) = lTmp
         End If
      Case Else
         sOp = " / "
         If .alOperations(byProf, gcbyl2) > .alOperations(byProf, gcbyl1) Then
            lTmp = .alOperations(byProf, gcbyl2)
            .alOperations(byProf, gcbyl2) = .alOperations(byProf, gcbyl1)
            .alOperations(byProf, gcbyl1) = lTmp
         End If
      End Select
      GetOperation = .alOperations(byProf, gcbyl1) & sOp & .alOperations(byProf, gcbyl2) & _
                   " = " & .alOperations(byProf, gcbyValeur)
   End With
End Function

On passe dorénavant un tableau de nombre 1 to 6.

Durant mes tests et essais comparatifs, je me suis aperçu que ton algo pouvait rencontrer exceptionnellement 2 type de problèmes :
1) Solution parfois non trouvée ou bien trouvée après relance de l'algo
Exemple : 947 avec 75,7,50,50,4,1 ou 638 avec 5,1,4,7,7,25

2) Erreur de dépassement de capacité
Exemple : 997 avec 100,100,50,10,100,9

Merci encore pour ce super programme et tes remarques constructives

Bonne continuation,

Philippe

[User]

ok,

merci à toi,

j'integre ton code dans la version n°3 d'ici peu...

ton code est disponible sur la version n°3

@+

Denis

[User]

Bonsoir à tous,

J'ai ajouté un module (lib_abc, "ABC du mot le plus long" ) qui propose une technique pour trouver des mots plus long en ajoutant à une "base" facilement mémorisable, 1,2,3.. lettres:
exemple

| BASE |
"MARTIEN" + "A" = "AIMANTER","ARMAIENT" etc..

ça aide a retrouver et memoriser ces "bases de mots" qui permettent de former des mots plus long...(en y ajoutant 1,2 ou 3 lettres)

Ce module peut être largement amélioré il s'agit d'une première version..

Notamment dans le module "lib_abc", les fonctions ne sont pas optimisées :

en particulier pour la procedure "gen_resultats_base" je souhaiterai pouvoir a partir de la base (ex:"NICHE") pouvoir generer les resultats:
+ 1 lettre (+"S" = "CHIENS")
+ 2 lettres
+ 3 lettres
...
comment optimiser ce code
(pour le moment je vais seulement jusqu'a +2 lettres)

(quand vous en aurez le temps biensur..Philben et vodiem m'ont déja bien aidé jusque là)

Merci à vous !



User

version n°4

[User]

Pour ouvrir sur de nouvelles perspectives,
je souhaitais programmé une fonction VBA non récursive pour le compte est bon (autre que Philben),
il se trouve que cette librairie Delphi est gourmand en mémoire et donne des résultats pas terrible niveau performance sous VBA.

D'ou mon idée de programmer cette routine en Delphi dans une dll, dont je donne le code à tout hazard, pour contourner les problèmes d'allocation de mémoire et de performance que rencontre parfois VBA...(ca peut aider certains qui programme sur plusieurs environnements)

librairie Delphi


Mon code n'est pas terrible niveau optimisation (il reste aussi quelques bugs), mais l'algo est intéressant, même s'il peut être amélioré...

Pour créer la dll je me suis servi du tuto de Bestiol,
Pour l'import dans VBA je suis allé sur ça:

Question 144 : Comment créer des fonctions en C (dans des Dll standards) appelables depuis VB ? - FAQ Visual Basic

Les changements sont sur la version n°4
Après téléchargement,
décompresser les 2 fichiers "Chiffres_lettres v4.mdb" et "lib_ceb.dll" dans un même répertoire...


j'ai ajouté pour l'import de la fonction Delphi en VBA:

en haut d'un module VBA:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Option Compare Database
Option Explicit
 
#Const DebugVersion = 1
 
Public Declare Function SetEnvironmentVariable _
    Lib "kernel32.dll" _
    Alias "SetEnvironmentVariableA" _
    ( _
    ByVal lpName As String, _
    ByVal lpValue As String _
    ) _
    As Long
 
 
Public Declare Function calculer Lib "lib_ceb.dll" (ByRef t As Long, ByVal res As Long, ByVal m As Long) As String

et sur ouverture du form de démarrage:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
Private Sub Form_Open(Cancel As Integer)
 
...
 
 
'#If DebugVersion Then
    SetEnvironmentVariable "PATH", Environ$("PATH") & ";" & Access.CurrentProject.Path
'#End If
 
End Sub

par la suite j'ajouterai le module VBA equivalent à la dll Delphi (code trop lent..avec problème d'allocation de mémoire)

Bonne lecture à tous !

User