[Visual Basic] - Combinazioni con ripetizione

[lucausa75]

Salve ragazzi,
vorrei realizzare una programma scritto in Visual Basic che mi elabora tutte le combinazioni possibili di N numeri a gruppi di K.
Ad esempio se ho queste 4 lettere: a,b,c,d il mio programma deve essere in grado di elaborare tutte le seguenti possibili 20 combinazioni non ordinate:


a b c-a b d-a c d-b c d
a a a-b b a-c c a-d d a
a a b-b b b-c c b-d d b
a a c-b b c-c c c-d d c
a a d-b b c-c c d-d d d

Mi aiutate?

Grazie

[MarcoGG]

Combinazioni con ripetizione su N elementi di classe K.
Io l'ho risolto così :

Public Function CombinazioniConRipetizione(ByVal arrayElementi() As String, ByVal classe As Byte) As List(Of String)

Dim LC As New List(Of String)
If arrayElementi.Count = 0 Then Return LC
If classe = 0 Then Return LC

Dim aP(classe - 1) As Integer
Dim C As String = ""
Do
C = ""
For i As Integer = 0 To aP.Count - 1
C = C & arrayElementi(aP(i))
Next
LC.Add(C)

Dim cnt As Integer = 0
For i As Integer = aP.Count - 1 To 0 Step -1
If aP(i) = arrayElementi.Count - 1 Then
cnt += 1
If cnt = aP.Count Then Exit Do
Else
aP(i) += 1
For j = 0 To aP.Count - 1
If i < j Then aP(j) = aP(i)
Next
Exit For
End If
Next
Loop

Return LC

End Function

;)

[lucausa75]

Combinazioni con ripetizione su N elementi di classe K.
Io l'ho risolto così :

Public Function CombinazioniConRipetizione(ByVal arrayElementi() As String, ByVal classe As Byte) As List(Of String)

Dim LC As New List(Of String)
If arrayElementi.Count = 0 Then Return LC
If classe = 0 Then Return LC

Dim aP(classe - 1) As Integer
Dim C As String = ""
Do
C = ""
For i As Integer = 0 To aP.Count - 1
C = C & arrayElementi(aP(i))
Next
LC.Add(C)

Dim cnt As Integer = 0
For i As Integer = aP.Count - 1 To 0 Step -1
If aP(i) = arrayElementi.Count - 1 Then
cnt += 1
If cnt = aP.Count Then Exit Do
Else
aP(i) += 1
For j = 0 To aP.Count - 1
If i < j Then aP(j) = aP(i)
Next
Exit For
End If
Next
Loop

Return LC

End Function

;)


Ciao e grazie 1000 per il codice :D

Quando lo inserisco in Visual Basic mi da degli errori, indicati in rosso, come indicato nella figura.
Non riesco a capire se ilcodice contiene delle parti da te commentate:

http://img29.imageshack.us/img29/3594/codice.th.png (http://img29.imageshack.us/i/codice.png/)

Probabilmente l'errore è dovuto al fatto che sto utilizzando VBA e non VB...

Ti dispiacerebbe mandarmi il file vbp completo?

;)

[MarcoGG]

Il mio è codice VB 2008, quindi .NET. Devi fare le opportune modifiche, prima fra tutte la sostituzione della List() con un array ( utilizzando ReDim Preserve sullo stesso ad ogni inserimento di una nuova combinazione C ). Inoltre le dichiarazioni sulla stessa linea vanno "spezzate", perchè VBA non le supporta...
Se ho tempo più tardi vedo di postare anche una soluzione VBA, intanto vedi se ce la fai a tradurre... ;)

[lucausa75]

Il mio è codice VB 2008, quindi .NET. Devi fare le opportune modifiche, prima fra tutte la sostituzione della List() con un array ( utilizzando ReDim Preserve sullo stesso ad ogni inserimento di una nuova combinazione C ). Inoltre le dichiarazioni sulla stessa linea vanno "spezzate", perchè VBA non le supporta...
Se ho tempo più tardi vedo di postare anche una soluzione VBA, intanto vedi se ce la fai a tradurre... ;)

...e per le combinazioni SENZA ripetizione ?

[lucausa75]

Il mio è codice VB 2008, quindi .NET. Devi fare le opportune modifiche, prima fra tutte la sostituzione della List() con un array ( utilizzando ReDim Preserve sullo stesso ad ogni inserimento di una nuova combinazione C ). Inoltre le dichiarazioni sulla stessa linea vanno "spezzate", perchè VBA non le supporta...
Se ho tempo più tardi vedo di postare anche una soluzione VBA, intanto vedi se ce la fai a tradurre... ;)

Tradotto il codice ma sottoforma di una Sub e successivamente provato con esito positivo:

Sub CombinazioniConRipetizione(n As Long, k As Long)

Dim aP() As Long
Dim C As String
Dim cnt As Long
Dim arrayElementi() As Long

ReDim aP(k) As Long
ReDim arrayElementi(n) As Long

lstCombinazioni.Clear

Do
C = ""
For i = 0 To UBound(aP) - 1
C = C & CStr(aP(i))
Next

lstCombinazioni.AddItem C

cnt = 0
For i = UBound(aP) - 1 To 0 Step -1
If aP(i) = UBound(arrayElementi) - 1 Then
cnt = cnt + 1
If cnt = UBound(aP) Then Exit Do
Else
aP(i) = aP(i) + 1
For j = 0 To UBound(aP) - 1
If i < j Then aP(j) = aP(i)
Next
Exit For
End If
Next
Loop

lblContatore = lstCombinazioni.ListCount

End Sub

[MarcoGG]

Ok. Posto anche la mia versione VBA della CombinazioniConRipetizione, sotto forma di Function, valida per ogni utilizzo. Il tipo restituito è una Collection, che è abbastanza "simile" ( parola grossa ) alla List() di VB.NET... :

Public Function CombinazioniConRipetizione(arrayElementi() As Variant, classe As Byte) As Collection

Dim LC As New Collection
If UBound(arrayElementi) = 0 Then
Set CombinazioniConRipetizione = LC
End If
If classe = 0 Then
Set CombinazioniConRipetizione = LC
End If

Dim aP() As Integer
ReDim aP(classe - 1)
Dim i As Integer
Dim j As Integer
Dim C As String
Dim cnt As Integer
Do
C = ""
For i = 0 To UBound(aP)
C = C & arrayElementi(aP(i))
Next i
LC.Add (C)

cnt = 0
For i = UBound(aP) To 0 Step -1
If aP(i) = UBound(arrayElementi) Then
cnt = cnt + 1
If cnt = UBound(aP) + 1 Then Exit Do
Else
aP(i) = aP(i) + 1
For j = 0 To UBound(aP)
If i < j Then aP(j) = aP(i)
Next
Exit For
End If
Next i
Loop

Set CombinazioniConRipetizione = LC

End Function

[lucausa75]

Ok. Posto anche la mia versione VBA della CombinazioniConRipetizione, sotto forma di Function, valida per ogni utilizzo. Il tipo restituito è una Collection, che è abbastanza "simile" ( parola grossa ) alla List() di VB.NET... :

Public Function CombinazioniConRipetizione(arrayElementi() As Variant, classe As Byte) As Collection

Dim LC As New Collection
If UBound(arrayElementi) = 0 Then
Set CombinazioniConRipetizione = LC
End If
If classe = 0 Then
Set CombinazioniConRipetizione = LC
End If

Dim aP() As Integer
ReDim aP(classe - 1)
Dim i As Integer
Dim j As Integer
Dim C As String
Dim cnt As Integer
Do
C = ""
For i = 0 To UBound(aP)
C = C & arrayElementi(aP(i))
Next i
LC.Add (C)

cnt = 0
For i = UBound(aP) To 0 Step -1
If aP(i) = UBound(arrayElementi) Then
cnt = cnt + 1
If cnt = UBound(aP) + 1 Then Exit Do
Else
aP(i) = aP(i) + 1
For j = 0 To UBound(aP)
If i < j Then aP(j) = aP(i)
Next
Exit For
End If
Next i
Loop

Set CombinazioniConRipetizione = LC

End Function



Ottimo ;)
Ma se volessimo parlare di Combinazioni SENZA Ripetizione ?
Avete una Function o una Sub già pronta?

Grazie 1000!

[MarcoGG]

Ottimo ;)
Ma se volessimo parlare di Combinazioni SENZA Ripetizione ?
Avete una Function o una Sub già pronta?

Grazie 1000!

Pronta ! :D
Basta aggiustare qualcosa :
- Mentre nelle combinazioni con ripetizione la classe può anche superare il numero di elementi dell'insieme N, nelle combinazioni semplici no.
- L'array delle posizioni aP() va inizializzato alla prima posizione valida ( non devono essere tutti zero ).
- Quando nel ciclo For interno un elemento di aP() viene incrementato di 1, quelli di indice maggiore vanno aggiornati diversamente.

Per il resto è molto simile alla precedente ( sempre per VB 2008 - a te il piacere di tradurre... :D ) :

Public Function CombinazioniSemplici(ByVal arrayElementi() As String, ByVal dimensioneGruppo As Byte) As List(Of String)

Dim LC As New List(Of String)
If arrayElementi.Count = 0 Then Return LC
If dimensioneGruppo = 0 Or dimensioneGruppo > arrayElementi.Count Then Return LC

Dim aP(dimensioneGruppo - 1) As Integer
For i As Integer = 0 To aP.Count - 1
aP(i) = i
Next

Dim C As String = ""
Do
C = ""
For i As Integer = 0 To aP.Count - 1
C = C & arrayElementi(aP(i))
Next
LC.Add(C)

Dim cnt As Integer = 0
For i As Integer = aP.Count - 1 To 0 Step -1
If aP(i) = arrayElementi.Count - 1 - cnt Then
cnt += 1
If cnt = aP.Count Then Exit Do
Else
aP(i) += 1
For j = 0 To aP.Count - 1
If i < j Then aP(j) = aP(i) + (j - i)
Next
Exit For
End If
Next
Loop

Return LC

End Function

;)

[lucausa75]

Pronta ! :D
Basta aggiustare qualcosa :
- Mentre nelle combinazioni con ripetizione la classe può anche superare il numero di elementi dell'insieme N, nelle combinazioni semplici no.
- L'array delle posizioni aP() va inizializzato alla prima posizione valida ( non devono essere tutti zero ).
- Quando nel ciclo For interno un elemento di aP() viene incrementato di 1, quelli di indice maggiore vanno aggiornati diversamente.

Per il resto è molto simile alla precedente ( sempre per VB 2008 - a te il piacere di tradurre... :D ) :

Public Function CombinazioniSemplici(ByVal arrayElementi() As String, ByVal dimensioneGruppo As Byte) As List(Of String)

Dim LC As New List(Of String)
If arrayElementi.Count = 0 Then Return LC
If dimensioneGruppo = 0 Or dimensioneGruppo > arrayElementi.Count Then Return LC

Dim aP(dimensioneGruppo - 1) As Integer
For i As Integer = 0 To aP.Count - 1
aP(i) = i
Next

Dim C As String = ""
Do
C = ""
For i As Integer = 0 To aP.Count - 1
C = C & arrayElementi(aP(i))
Next
LC.Add(C)

Dim cnt As Integer = 0
For i As Integer = aP.Count - 1 To 0 Step -1
If aP(i) = arrayElementi.Count - 1 - cnt Then
cnt += 1
If cnt = aP.Count Then Exit Do
Else
aP(i) += 1
For j = 0 To aP.Count - 1
If i < j Then aP(j) = aP(i) + (j - i)
Next
Exit For
End If
Next
Loop

Return LC

End Function

;)


Grazie 1000 per il codice che ho tradotto correggendoti, probabilmente, un errore in entrambe le funzioni:

NO
For i As Integer = 0 To aP.Count - 1
C = C & arrayElementi(aP(i))
Next

SI
For i As Integer = 0 To aP.Count - 1
C = C & aP(i)
Next

Verifica e fammi sapere
Cmq così come ho tradotto le due routine funziona:

Sub CombinazioniConRipetizione(n As Long, k As Long)

Dim i As Long
Dim j As Long
Dim aP() As Long
Dim C As String
Dim cnt As Long
Dim arrayElementi() As Long

ReDim aP(k) As Long
ReDim arrayElementi(n) As Long

lstCombinazioni.Clear

Do
C = ""
For i = 0 To UBound(aP) - 1
C = C & CStr(aP(i))
Next

lstCombinazioni.AddItem C

cnt = 0
For i = UBound(aP) - 1 To 0 Step -1
If aP(i) = UBound(arrayElementi) - 1 Then
cnt = cnt + 1
If cnt = UBound(aP) Then Exit Do
Else
aP(i) = aP(i) + 1
For j = 0 To UBound(aP) - 1
If i < j Then aP(j) = aP(i)
Next
Exit For
End If
Next
Loop

lblContatore = lstCombinazioni.ListCount

End Sub

Sub CombinazioniOrdinate(n As Long, k As Long)

Dim i As Long
Dim j As Long
Dim aP() As Long
Dim C As String
Dim cnt As Long
Dim arrayElementi() As Long

ReDim aP(k) As Long
ReDim arrayElementi(n) As Long

lstCombinazioni.Clear

For i = 0 To UBound(aP) - 1
aP(i) = i
Next

C = ""
Do
C = ""
For i = 0 To UBound(aP) - 1
C = C & CStr(aP(i))
Next

lstCombinazioni.AddItem C

cnt = 0
For i = UBound(aP) - 1 To 0 Step -1
If aP(i) = UBound(arrayElementi) - 1 - cnt Then
cnt = cnt + 1
If cnt = UBound(aP) Then Exit Do
Else
aP(i) = aP(i) + 1
For j = 0 To UBound(aP) - 1
If i < j Then aP(j) = aP(i) + (j - i)
Next
Exit For
End If
Next
Loop

lblContatore = lstCombinazioni.ListCount

End Sub

[MarcoGG]

Non c'è alcun errore nelle mie Function. Appena ho un po' di tempo posto una soluzione completa di esempi di utilizzo... ;)

[lucausa75]

Non c'è alcun errore nelle mie Function. Appena ho un po' di tempo posto una soluzione completa di esempi di utilizzo... ;)


...non mi permetterei mai di affermare che c'è un errore nelle tue funzioni è solo che trovo strano che apportando le correzioni da me suggerite mi funziona...cmq!

Hai dato un'occhiata al mio codice in Visual Basic 6? ;)

Prova a far girare il codice prendendo come esempio questa pagina: http://www.ripmat.it/mate/l/lb/lbcb.html

Grazie ancora!

[MarcoGG]

NO
For i As Integer = 0 To aP.Count - 1
C = C & arrayElementi(aP(i))
Next

SI
For i As Integer = 0 To aP.Count - 1
C = C & aP(i)
Next

Verifica e fammi sapere


Ok. Allora :

- Solitamente una Sub è meno generica e meno riutilizzabile di una Function, perciò non ho testato le tue Sub. Immagino che tu le abbia modificate per un motivo valido nel tuo caso.
Nel mio caso ( con le Function ) l'array aP() è l'array delle posizioni, e NON va confuso con arrayElementi, che invece va passato in input alle Function e contiene gli N elementi dell'insieme.
Perciò, nel mio caso :
C = C & arrayElementi(aP(i))
è l'istruzione giusta,
mentre :
C = C & aP(i)
non è corretta.

- Rimanendo in VBA, la Function corretta per le Combinazioni Semplici è la seguente :

Public Function CombinazioniSemplici(arrayElementi() As Variant, dimensioneGruppo As Byte) As Collection

Dim LC As New Collection
If UBound(arrayElementi) = 0 Then
Set CombinazioniSemplici = LC
End If
If dimensioneGruppo = 0 Or dimensioneGruppo > UBound(arrayElementi) Then
Set CombinazioniSemplici = LC
End If

Dim aP() As Integer
ReDim aP(dimensioneGruppo - 1)
Dim i As Integer
For i = 0 To UBound(aP)
aP(i) = i
Next i
Dim j As Integer
Dim C As String
Dim cnt As Integer
Do
C = ""
For i = 0 To UBound(aP)
C = C & arrayElementi(aP(i))
Next i
LC.Add (C)

cnt = 0
For i = UBound(aP) To 0 Step -1
If aP(i) = UBound(arrayElementi) - cnt Then
cnt = cnt + 1
If cnt = UBound(aP) + 1 Then Exit Do
Else
aP(i) = aP(i) + 1
For j = 0 To UBound(aP)
If i < j Then aP(j) = aP(i) + (j - i)
Next
Exit For
End If
Next i
Loop

Set CombinazioniSemplici = LC

End Function

E un suo utilizzo-tipo è questo ( esempio Excel-VBA con una ListBox ) :

ListBox1.Clear

Dim N() As Variant
N = Array("a", "b", "c", "d")
Dim K As Byte
K = 3

Dim Comb As Collection
Set Comb = CombinazioniSemplici(N, K)

Dim i As Integer
For i = 1 To Comb.Count
ListBox1.AddItem (Comb(i))
Next i

MsgBox Comb.Count

- Passiamo alle Combinazioni Con Ripetizione ( VBA ) :

Public Function CombinazioniConRipetizione(arrayElementi() As Variant, classe As Byte) As Collection

Dim LC As New Collection
If UBound(arrayElementi) = 0 Then
Set CombinazioniConRipetizione = LC
End If
If classe = 0 Then
Set CombinazioniConRipetizione = LC
End If

Dim aP() As Integer
ReDim aP(classe - 1)
Dim i As Integer
Dim j As Integer
Dim C As String
Dim cnt As Integer
Do
C = ""
For i = 0 To UBound(aP)
C = C & arrayElementi(aP(i))
Next i
LC.Add (C)

cnt = 0
For i = UBound(aP) To 0 Step -1
If aP(i) = UBound(arrayElementi) Then
cnt = cnt + 1
If cnt = UBound(aP) + 1 Then Exit Do
Else
aP(i) = aP(i) + 1
For j = 0 To UBound(aP)
If i < j Then aP(j) = aP(i)
Next
Exit For
End If
Next i
Loop

Set CombinazioniConRipetizione = LC

End Function

E un suo utilizzo-tipo :

ListBox1.Clear

Dim N() As Variant
N = Array("a", "b", "c", "d")
Dim K As Byte
K = 3

Dim Comb As Collection
Set Comb = CombinazioniConRipetizione(N, K)

Dim i As Integer
For i = 1 To Comb.Count
ListBox1.AddItem (Comb(i))
Next i

MsgBox Comb.Count

A questo punto la Function che riceve in ingresso un array Variant permette una gran flessibilità, anche in virtù del fatto che, come ho già detto, l'array delle posizioni aP() è indipendente dall'arrayElementi() .
Posso darle in pasto elementi di ogni tipo, come caratteri, stringhe, interi, decimali, currency e quant'altro :

Dim N() As Variant

N = Array("a", "b", "c", "d")

N = Array("str1", "str2", "str3", "str4")

N = Array(1, 2, 3, 4)

N = Array(1.11, 2.22, 3.33, 4.44)

...
...

E funzionerà sempre.

Credo sia tutto molto più chiaro adesso. :)

[lucausa75]

MarcoGG non ho parole: sei stato grande...anzi grandissimo

MarcoGG santo subito!!!

:ave: :ave: :ave: :ave: :ave: :ave: :ave: :ave: :ave:

[MarcoGG]

MarcoGG non ho parole: sei stato grande...anzi grandissimo

MarcoGG santo subito!!!

:ave: :ave: :ave: :ave: :ave: :ave: :ave: :ave: :ave:

:eek: :D

[lucausa75]

....e se adesso volessi realizzare un programma che mi visualizzi tutte le 24 (4!) disposizioni che si possono ottenere con le lettere: a, b, c, d?

Grazie

[MarcoGG]

E poi ci sono le Disposizioni di K su N, con K<N con e senza ripetizione, le Permutazioni, le Dismutazioni... :D
Beh, forza e coraggio ! Credo di aver già fonito parecchi spunti per continuare... ;)

[f4nt0m]

salve a tutti!!! :D
ho lettto tutto ,,, ee mi è venuto in mente unaa cosa..,,,
se io volessi calcolare combinazioni ... in seguente modo ,,,

a b c d e f g

voglio che "a" si ripete solo in posizione 3 , 5, 7
"b" in pos2, pos4, pos6
"c" pos1, pos2, pos3, pos4, pos5, pos6, pos7

è possibile fare una cosa del genere ????:confused:

ehemm ........ scusate per italiano nn corretto :cry:

[MarcoGG]

a b c d e f g

voglio che "a" si ripete solo in posizione 3 , 5, 7
"b" in pos2, pos4, pos6
"c" pos1, pos2, pos3, pos4, pos5, pos6, pos7


Non sono sicuro di aver capito cosa intendi, ma prova usando i miei codici, condizionando l'array delle posizioni in modo da tenere solo le posizioni desiderate...

[f4nt0m]

Non sono sicuro di aver capito cosa intendi, ma prova usando i miei codici, condizionando l'array delle posizioni in modo da tenere solo le posizioni desiderate...

va bien ,,, provo :D

[f4nt0m]

scusa,, potresti fare una cosa,, graziee

leggendo cosa nn riesco capire bene :muro:

nn è ke puoi scrivere qsto in Visual Basic ,, Salvare il progetto ,, e fai UPLOAD su un sito ..
e qui metti il link :D
GRAZIE 1000!!!!

[MarcoGG]

scusa,, potresti fare una cosa,, graziee

leggendo cosa nn riesco capire bene :muro:

nn è ke puoi scrivere qsto in Visual Basic ,, Salvare il progetto ,, e fai UPLOAD su un sito ..
e qui metti il link :D
GRAZIE 1000!!!!

Eh eh, :nonsifa: :D
Il codice di partenza ce l'hai, forza e coraggio...

[f4nt0m]

Dim a, b, c, d, e, f As String
Dim combinazione As String ' mi serve per elencare in listbox

'in queste variable assegno numeri o lettere per combinazione
a = txtnum.Text
b = txtnum1.Text
c = txtnum2.Text
d = txtnum3.Text
e = txtnum4.Text
f = txtnum5.Text


For i = 0 To 100 ' max num di combinazioni ke voglio
'FORMUL COMBINAZIONI
'FORMULA COMBINAZIONI

lstnum.AddItem = combinazione
Next i

allora questo è tutto quello che sono riuscito a fare... no so come usare il tuo codice @marcogg

formula combinazioni ?? -- il codice ?? nn so cosa fare:muro:

grazie in anticipo

[lupo-blu]

[QUOTE=MarcoGG;29665484]Pronta ! :D
Basta aggiustare qualcosa :
- Mentre nelle combinazioni con ripetizione la classe può anche superare il numero di elementi dell'insieme N, nelle combinazioni semplici no.
...

Non ho ancora capito tutta la soluzione ma mi chiedevo se mi riuscivate ad aiutare a risolvere un CASO UN PO' PIU' COMPLESSO.
TROVARE GRUPPI DI COMBINAZIONI SEMPLICI INDIEPNDENTI
Ad esempio se sono 35 le combinazioni semplici di 7 elementi di classe 3, diventano 70 le "coppie" di terne indipendenti come ad esempio:
(1,2,3) (4,5,6)
(1,2,3) (4,5,7)
(1,2,3) (4,6,7)
(1,2,3) (5,6,7)
(1,2,4) (......)
In realtà poi non avrei finito perché dovrei trasformare gli elementi trovati in numeri binari, sommarli come se fossero numeri decimali e trovare quelle terne che mi danno somme differenti ...
Ma già risolvere la prima parte mi SAREBBE DI ENORME AIUTO

SPERO IN QUALCHE VOSTRO AIUTO

[gugoXX]

Io procederei come segue:
Combinazioni con ripetizione sono abbastanza semplici da enumerare.
Se si hanno ad esempio 5 simboli e 7 cifre, e' sufficiente contare in base 5 fino a 5^7

Poi ad ogni valore da 0-4 si assegna una delle lettere risultato ed e' finito.

Ad esempio

0000000 => AAAAAAA
0000001 => AAAAAAB
0000002 => AAAAAAC
0000003
0000004
0000010
0000011
0000012

etc.

per contare in questo modo, o si gioca un po' con enumerazioni "moderne", cosa che VBA o VB vecchio non hanno, oppure si conta in modo normale e poi si trasforma di base

0 => 0000000
1 => 0000001
2 => 0000002
3 => 0000003
4 => 0000004
5 => 0000010
6 => 0000011

etc.

E' quindi sufficiente contare da 0 a 5^7=78125, trasformare ciascun numero in base 5, tradurre ciascuna cifra con le lettera corrispondente ed e' finita.

Il tuo esempio e' un poco piu' complesso, ma non piu' difficile.

E' sufficiente contare con un numero in base mista.
magari: Le prime 3 cifre in base 7, le altre 3 cifre in base 6

con enumerazioni su linguaggi "Moderni" resta semplice.

Trasformare invece un numero decimale in un numero a base mista e' tutto un altro discorso.
Forse e' meglio spaccare il problema proprio in 2, e tenere conto di 2 numeri decimali, passare i riporti a mano, etc. Molto piu' lungo e prono ad errori, ma se hai capito il ragionamento si fa.

Metto qui il pezzo in codice in un linguaggio un po' piu' moderno, magari per farti venire voglia di evolvere...


class Program
{
static void Main(string[] args)
{
var domain = from c1 in Enumerable.Range(0,5)
from c2 in Enumerable.Range(0,5)
from c3 in Enumerable.Range(0,5)
from c4 in Enumerable.Range(0,5)
from c5 in Enumerable.Range(0,5)
from c6 in Enumerable.Range(0,5)
from c7 in Enumerable.Range(0,5)
select new string(new char[]{Trans(c1), Trans(c2), Trans(c3), Trans(c4), Trans(c5), Trans(c6), Trans(c7)});

domain.ToList().ForEach(Console.WriteLine);

Console.ReadKey();
}

private static string conv = "ABCDEFGHIJKLMNOPOQRSTUVWXYZ";
private static char Trans(int n)
{
return conv[n];
}

}


Che procede con con


AAAAAAA
AAAAAAB
AAAAAAC
...
EEEEEEEE


Per la base mista e' semplicemente



var domain = from c1 in Enumerable.Range(0,5)
from c2 in Enumerable.Range(0,5)
from c3 in Enumerable.Range(0,5)
from c4 in Enumerable.Range(0,5)
from c5 in Enumerable.Range(0,7)
from c6 in Enumerable.Range(0,7)
from c7 in Enumerable.Range(0,7)
select new string(new char[]{Trans(c1), Trans(c2), Trans(c3), Trans(c4), Trans2(c5), Trans2(c6), Trans2(c7)});



che restituisce



AAAAAZZZ
AAAAAZZY
AAAAAZZW
...
AAAABZZZ
AAAABZZY
AAAABZZW
...
EEEEETTT


Li vuoi tutti, ma in ordine casuale?
Ecco


static void Main(string[] args)
{
var rnd = new Random();

var domain = from c1 in Enumerable.Range(0,5)
from c2 in Enumerable.Range(0,5)
from c3 in Enumerable.Range(0,5)
from c4 in Enumerable.Range(0,5)
from c5 in Enumerable.Range(0,7)
from c6 in Enumerable.Range(0,7)
from c7 in Enumerable.Range(0,7)
orderby rnd.NextDouble()
select new string(new char[]{Trans(c1), Trans(c2), Trans(c3), Trans(c4), Trans2(c5), Trans2(c6), Trans2(c7)});

// cicla e stampa