Der schnellste Permutationscode Permutation von Zahlen in VB NET

Question

Es gibt einen berühmten und schnellsten Permutationscode ohne "Funktion" für VB .Net, um Zahlen nur in mehreren Zeilen zu permutieren, an die ich mich leider nicht erinnern kann.

Kennt jemand diesen Code? Oder weißt du das?

Ein Teil des Codes ist hier:

UPDATE: ich es gefunden. ALLE ARBEITS CODES HIER:

Dim L(4) As Byte 
Dim I As Byte 
Dim K As Byte 
Dim J As Byte 
Dim RESULTS As String 
Dim UB, UBm1 As Integer 

L = {1, 2, 3, 4, 5} 

UB = L.GetUpperBound(0) 
UBm1 = UB - 1 

Do 
    I = UBm1 
    Do While I > 0 And L(I) >= L(I + 1) 
     I -= 1 
    Loop 
    K = L(I) 
    J = UB 
    Do While J > 0 And L(J) <= K 
     J -= 1 
    Loop 

    RESULTS = L(0) & "," & L(1) & "," & L(2) & "," & L(3) & "," & L(4) 

    L(I) = L(J) 
    L(J) = K 
    Array.Reverse(L, I + 1, UB - I) 

Loop While J 

Answer 1

Es scheint, wie Sie für diese suchen ...

http://www.cut-the-knot.org/do_you_know/AllPerm.shtml (2. Lexikographische Ordnung und der Suche nach der nächsten Permutation)

...?

Falls dies der Fall ist, sind die Startwerte für I und J falsch (sie sollten 4 und 5 statt 3 bzw. 4 sein).

(Ich weiß, dass das Beispiel verwendet swap, aber das kann mit einer einzigen Doppelpunkt-getrennte Leitung ersetzt werden.)

Dim L(4) As Byte 
L = {1, 2, 3, 4, 5} 

Dim K as Byte 

For N as integer = 1 to 120 'No. of permutations: 5! 
    Dim I As Byte = 4, J as Byte = 5 

    While L(I - 1) >= L(I) 
     I -= 1 
    End While 
    While L(J - 1) <= L(I - 1) 
     J -= 1 
    End While 

    K = L(I - 1) : L(I - 1) = L(J - 1) : L(J - 1) = K 
    I += 1 : J = 5 
    While I < J 
     K = L(I - 1) : L(I - 1) = L(J - 1) : L(J - 1) = K 
     I += 1 : J -= 1 
    End While 

    Dim RESULT as String = L(0) & "," & L(1) & "," & L(2) & "," & L(3) & "," & L(4) 
    'Export/print RESULT as you like, e.g. Console.WriteLine or something 
Next 

Answer 2

Für eine Reihe von Permutationen einer natürlichen Zahl zu erhalten (empfohlen weniger als 10 obwohl es größer sein kann), ist diese VBA Excel Unterroutine sehr schnell und kurz. Ich glaube, es kann leicht sein, es in VB.NET umzuwandeln. Guck mal.

Const P = 5          'Recommended Max P = 9 
Dim m As Long, PArray(1 To 1000, 1 To P)  'Recommended Max 9! = 362880 

Public Sub PermutationNaturalNumber() 
    Dim Q(1 To P) As Long 
    For m = 1 To P: Q(m) = m: Next: m = 0 
    PermutationGenerator P, Q 
    Range("A1").Resize(UBound(PArray), P) = PArray: End 
End Sub 

Sub PermutationGenerator(n As Long, Q() As Long) 
    Dim i As Long, j As Long, k As Long 
    If n > 1 Then 
     For i = 1 To n - 1 
      PermutationGenerator n - 1, Q 
      If n Mod 2 = 1 Then j = 1 Else j = i 
      k = Q(j): Q(j) = Q(n): Q(n) = k 
     Next 
     PermutationGenerator n - 1, Q 
    Else 
     m = m + 1: For i = 1 To P: PArray(m, i) = Q(i): Next 
    End If 
End Sub 

P kann jede natürliche Zahl sein, in diesem Fall {1, 2, 3, 4, 5}. Stellen Sie sicher, dass Sie die obere Grenze von PArray mit P ändern! Bedeutung (P*(P-1)*(P-2)*...*1).