Discussion :

[blaame]

Bonjour,

J'ai fait une routine qui compare des valeurs deux par deux, puis 3 par 3, puis encore 4 par 4, 5 par 5 et ainsi de suite.

Le principe est de trouver un maximum de lignes dont la somme fait zéro.

Je me demande s'il est possible de fusionner ce code en un seul, par une boucle.

Un truc du genre For i = 2 to N , Compare les données de i en i

Voici une version simplifiée du code que j'ai et que je voudrais (éventuellement) fusionner :

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
 
 
Sub MaMacro()
 
'Loop 1
For i = 1 to Fin - 1
  For j = i + 1 to Fin
      Test = i + j
  Next j
Next i
 
'Loop 2
For i = 1 to Fin - 2
  For j = i + 1 to Fin - 1
    For k = j + 1 to Fin
      Test = i + j + k
    Next k
  Next j
Next i
 
'Loop 3
For i = 1 to Fin - 3
  For j = i + 1 to Fin - 2
    For k = j + 1 to Fin - 1
      For l = k + 1 to Fin
        Test = i + j + k + l
      Next l
    Next k
  Next j
Next i
 
'etc etc
 
End Sub

Merci d'avance !

[ouskel'n'or]

Je ne vois aucune comparaison, seulement des boucles
Peux-tu préciser ?

[blaame]

Désolé, sans doute une déformation comptable ... on y compare en additionnant

Ce que je cherche, s'est Test = 0 (ou presque).

En fait, j'ai une liste de factures et de notes de crédits

"Date" "Numéro" "Montant"

Seul le montant est pris en considération.

Et ma macro doit essayer de trouver le plus possible de factures et notes de crédit qui font zéro.

Et ce, en cherchant :
- Deux lignes qui font zéro
- Trois lignes qui font zéro
- Quatre lignes qui font zéro
- etc

Pour l'instant, chaque recherche se fait par des boucles imbriquées.
Et comme chaque recherche se ressemble assez fort (simple rajout d'une nouvelle boucle), je voulais savoir s'il y a moyen de ne faire qu'un seul code de recherche.

[ucfoutu]

Bonjour,

C'est totalement incompréhensible.

Si i, j, k, etc.... sont des variables directrices de boucle, elles constituent donc chacune, par incrémentation dans la boucle, une série continue.
Il est donc impossible qu'à quelque moment que ce soit, i + j + ... soit = 0 (ton test) !!!
Il va sans doute falloir que tu exposes bien plus clairement ...
Je crois avoir deviné (et une seule boucle suffirait alors), mais je tiens à ce que tu fasses toi-même cet effort d'exposé.

[ucfoutu]

Allez...

Analyse ceci et planche dessus...
Planche, car je n'ai pas l'intention d'expliquer (c'est auto explicite) !

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
Option Explicit
Private Sub Command1_Click()
  'juste pour constituer un tableau d'essai
  Dim toto(9) As Single, i As Integer, j As Integer, resul As String, a As Single
  For i = 0 To 9
    toto(i) = i
  Next
 
  resul = ""
  For i = 0 To UBound(toto) \ 2
    a = toto(i)
    For j = i To UBound(toto) - i
      a = a + toto(i) + toto(j)
      resul = resul & a & vbCrLf
    Next
  Next i
  MsgBox "voilà tes résultats" & vbCrLf & resul
End Sub

adapte ensuite car (tu t'es exprimé incomplètement) j'ai des doutes sur la nécessité d'ajouter le a dans

Code :

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

a = a + toto(i) + toto(j)

Bref ... à toi de voir...

Edit : et laisse le signe \ tel qu'il est, hein... un \ n'est pas un / et la division n'est pas la même dans un cas et dans l'autre .

[blaame]

J'aurais du dire "valeur en i" + "valeur en j" + "valeur en k" = 0

Mon probleme est en fait un problème d'examen des combinaisons possibles.

Je voudrais examiner TOUTES les combinaisons possibles dans une liste de montants, mais dans l'ordre : 2 par 2, 3 par 3, 4 par 4 et ainsi de suite.

Exemple :

La liste des montants :
A
B
C
D
E

Examen de :
[Test 1]
A, B, C, D, E

puis :
[Test 2]
A+B, A+c, A+D, A+E
B+C, B+D, B+E
C+D, C+E
D+E

puis :
[Test 3]
A+B+C, A+B+D, A+B+E
A+C+D, A+C+E
A+D+E

B+C+D, B+C+E
B+D+E

C+D+E

puis encore :
[Test 4]
A+B+C+D, A+B+C+E
B+C+D+E

finalement :
[Test 5]
A+B+C+D+E

Bien sur, ma liste pourrait être encore plus longue, et donc le nombre de tests devrait aussi être plus grand.

Pour l'instant, à chaque [Test] correspond un code spécifique (avec 1, 2, 3, 4 et 5 boucles imbriquées) qui fonctionne pas trop mal jusqu'à une comparaison de 5 en 5 (mais un peu long).

Ma question est de savoir s'il est possible de ne faire qu'un seul code pour ces différents tests et qui ferait la même chose dans le même ordre. Mais surtout qui me permettrait d'examiner au delà de 5 par 5 sans faire de code spécifique.

[Gorfael]

Salut blaame et le forum
Comme d'hab, dans le flou total

Code :

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

Le principe est de trouver un maximum de lignes dont la somme fait zéro.

Si je prends en lecture simple, il suffit de compter les lignes qui font 0, mais je ne pense pas que le problème soit ça.

Donc, ça pourrait vouloir dire : trouver le maximum de lignes consécutives dont le total fait 0 (ou qui font 0 individellement ?).

Ou le nombre de fois que le total de deux lignes consécutives fait 0, le même pour trois, quatre etc.. ?

et c'est le total des lignes ou la ligne qui doit faire 0 ?

Pour tout ces principes de calcul, une boucle parcourant la plage, avec une 2ème parcourant le reste depuis la ligne en cours devrait suffire. mais quelle proposition est la bonne, si tant est qu'il y en ait au moins une ?

A+

[oscar.cesar]

bonjour à tous
Blame

Pas les plus grands des hasards, Tu ne chercherais pas à travailler sur des combinaisons de nombres ou lettres avec ou sans permutation?

Si c'est le cas j'ai peut etre quelque chose !

[blaame]

Je crois qu'il s'agit d'un problème de combinaisons de chiffres sans permutation (recherche des combinaisons à somme nulle).

L'objectif est de la réconciliation de compte (en compta).

Suite au conseil de ucfoutu je me suis penché sur l'algorithmie et j'entrevois une solution du genre en utilisant 3 tables (une de base, une de combinaisons déjà évaluées et une temporaire).

Je teste lundi au boulot

[Pierre Fauconnier]

Je pense qu'il y a plusieurs cas.

1. Une facture compensée par une note de crédit ou un paiement
2. Une facture compensée par plusieurs notes de crédit (rare) ou plusieurs paiements (plus fréquent)
3. Plusieurs factures compensées par une note de crédit ou un paiement
4. Plusieurs factures compensées par plusieurs notes de crédit ou plusieurs paiements
5. Toutes les écritures se compensent (solde nul) (rare mais facile!)

Il ne faut pas s'étonner que les logiciels de compa ne proposent pas d'outils de réconciliation au-delà du point 1.

Il faut noter que si plusieurs factures du même montant existent et que plusieurs notes de crédits ou paiements existent pour les mêmes montants, il est normalement légal de tenir compte de quoi solde quoi (pour le calcul des intérêts de retard notamment). Donc, c'est loin d'être gagné, si tu veux mon avis...

[oscar.cesar]

bonsoir
en effet, on peut se servir en compta.
Dans un autre domaine,je fais , en autre, la somme des nombres qui composent chaque combinaison est en fonction du resultat, j'elimine la combinaison

Dans le principe
l'algo part d'une serie de nombres : ex 45-788-99-2-89 puis en fonction du nombres de numeros composant la combinaison, l'algo compose les combinaison

[blaame]

Je pense qu'il y a plusieurs cas.

1. Une facture compensée par une note de crédit ou un paiement
2. Une facture compensée par plusieurs notes de crédit (rare) ou plusieurs paiements (plus fréquent)
3. Plusieurs factures compensées par une note de crédit ou un paiement
4. Plusieurs factures compensées par plusieurs notes de crédit ou plusieurs paiements
5. Toutes les écritures se compensent (solde nul) (rare mais facile!)

Il ne faut pas s'étonner que les logiciels de compa ne proposent pas d'outils de réconciliation au-delà du point 1.

Il faut noter que si plusieurs factures du même montant existent et que plusieurs notes de crédits ou paiements existent pour les mêmes montants, il est normalement légal de tenir compte de quoi solde quoi (pour le calcul des intérêts de retard notamment). Donc, c'est loin d'être gagné, si tu veux mon avis...

Dans mon cas, ce serait surtout dirigé vers la réconciliation inter-compagnie : Les recevables d'une entité A vers une entité B d'un même groupe doit s'annuler avec les payables de l'entité B envers l'entité A (objectif : Somme nulle). Mais ça pourrait aussi servir pour les comptes de transit ou les réconciliations Balance Sheet.

J'ai déjà une partie de code qui matche par numéro de document puis par montant, puis par 3 (3 boucles), 4 (4 boucles) et 5 (5 boucles). Ma prochaine étape (et ma question pour cette discussion) est de remplacer ces trois dernières étapes par une seule.