Assembly permutations

/********************************************************************************
Generare tutte le permutazioni dei primi N numeri naturali.
              Le permutazioni generate vanno inserite all'interno di un unico
            array di interi. Ad esempio, se N=3, l'array deve contenere:
            {1,2,3, 1,3,2, 2,1,3, 2,3,1, 3,1,2, 3,2,1}.

 ********************************************************************************/


#include <stdio.h>


int main()
{
// Variabili
int N=4;    // numero di interi (provare con valori <=6)
int Perm[4326]; // array permutazioni: la dimensione è sufficiente per N<=6
int Num;    // Alla fine deve contenere il numero di permutazioni generate

// Blocco assembler
    __asm
    {
        XOR EAX, EAX    ; Azzera EAX (contatore permutazioni)
        MOV ECX, N      ; Metti N in ECX
        CMP ECX, 1      ; Confronta ECX e 1
        JBE Piccolo     ; Se ECX <= 1 vai a Piccolo (casi particolari 1 e 0)

        DEC ECX     ; Decrementa ECX (in modo che ECX = N - 1)
        MOV EAX, N  ; Metti N in EAX

        MaxPerm:
            MUL ECX         ; Esegui l'operazione EDX:EAX = EAX * ECX
            LOOP MaxPerm    ; Cicla per trovare il numero di permutazioni

        MOV Num, EAX    ; Muovi EAX (n° permutazioni) in Num
        MOV EAX, 1      ; Imposta EAX (numero permutazione) a 1
        MOV EBX, 0      ; Azzera EBX (EBX = 0)
        MOV ECX, 1      ; Azzera ECX

        CicloIniziale:
            DEC ECX                 ; Decrementa ECX (per compararlo con N)
            CMP ECX, N              ; Confronta ECX ed N
            JE Permutazione         ; Se ECX == N (la prima permutazione è stata scritta, salta alla generazione delle successive)
            INC ECX                 ; Incrementa ECX
            MOV Perm[4*EBX], ECX    ; Inserisci ECX nell'array Perm
            INC ECX                 ; Incrementa ECX
            INC EBX                 ; Incrementa EBX
            JMP CicloIniziale       ; Continua il ciclo

        Permutazione:
            XOR EAX, EAX    ; Indice locale della permutazione attuale
            XOR EBX, EBX    ; Indice permutazione precedente
            MOV ECX, N      ; Indice assoluto della permutazione attuale
            MOV EDI, 1      ; Valore k (elemento che viene spostato)
            MOV ESI, 1      ; Nuova posizione di k

                CicloPermutazione:
                CMP EAX, N              ; Confronta EAX e N
                JE ResetPerm            ; Se è stata raggiunta la fine della permutazione, vai a ResetPerm
                CMP EDI, N
                JNE ContPerm
                INC ESI
                CMP ESI, N
                DEC ESI
                JNE ContPerm
ContPerm:       MOV EDX, Perm[4*EBX]    ; Altrimenti salva l'elemento della permutazione precedente in posizione EBX in EDX
                CMP EDX, EDI            ; Confronta EDX e EDI
                JE ValoreUguale         ; Se sono uguali, vai a ValoreUguale
                CMP EAX, ESI            ; Altrimenti confronta EAX e ESI
                JE InserisciElSpostato  ; Se è ora di spostare l'elemento, vai a InserisciElSpostato
                MOV Perm[4*ECX], EDX    ; Riporta il valore della permutazione precedente nella nuova permutazione

                ContinuaCiclo:
                    INC EBX                 ; Aumenta l'indice della permutazione precedente
                    INC EAX                 ; Aumenta l'indice locale
                    INC ECX                 ; Aumenta l'indice della nuova permutazione
                    JMP CicloPermutazione   ; Continua il ciclo

                InserisciElSpostato:
                    MOV Perm[4*ECX], EDI    ; Metti nella nuova permutazione il valore EDI
                    MOV EDX, N              ; EDX = N
                    DEC EDX                 ; EDX -= 1
                    CMP ESI, EDX            ; Confronta ESI e EDX
                    JE ResettaK             ; Se ESI == EDX vai a ResettaK
                    JMP ContinuaCiclo       ; Continua il ciclo

                ValoreUguale:
                    CMP EAX, 0              ; Confronta EAX e 0
                    JZ PrimaPos             ; Se la posizione è la prima vai a PrimaPos
                    MOV EDX, Perm[4*EBX+4]  ; Altrimenti salva l'elemento in posizione EBX - 1
                    MOV Perm[4*ECX], EDX    ; Inserisci EDX nella nuova permutazione
                    JMP ContinuaCiclo       ; Continua il ciclo

                    PrimaPos:
                        MOV EDX, Perm[4*EBX+4]  ; Salva in EDX l'elemento in posizione ECX + 1
                        MOV Perm[4*ECX], EDX    ; Inserisci EDX nella nuova permutazione
                        JMP ContinuaCiclo       ; Continua il ciclo

                ResettaK:
                    XOR ESI, ESI            ; Azzera ESI
                    MOV EDI, Perm[4*EDI]    ; EDI = Perm[EDI]
                    JMP ContinuaCiclo       ; Continua il ciclo

                ResettaKN:
                    CMP EDI, N          ; Confronta EDI e N
                    JNE ContinuaCiclo   ; Se EDI != N allora continua il ciclo
                    JMP ResettaK        ; Altrimenti vai a ResettaK

            ResetPerm:
                MOV EAX, Num            ; EAX = Num
                MUL DWORD PTR N         ; EAX *= N (Così da trovare il numero di elementi di tutte le permutazioni)
                CMP EAX, ECX            ; Confronta EAX e ECX
                JE Fine                 ; Se EAX == ECX (concluse le permutazioni) allora concludi
                XOR EAX, EAX            ; Altrimenti azzera EAX
                INC ESI                 ; Aumenta indice di k
                JMP CicloPermutazione   ; Continua il ciclo

        Piccolo:            ; Se N = 0 o N = 1, l'unica permutazione possibile è composta da 1 solo elemento
            MOV Num, 1
            MOV Perm[0], ECX

        Fine:
    }

// Stampa su video
    {
        int i,j,k;
        printf("%d permutazioni dei primi %d numeri naturali\n", Num, N);
        for (i=k=0;i<Num;i++)
        {
            for (j=0;j<N;j++)
            {
                printf("%3d",Perm[k++]);
            }
            printf("\n");
        }
    }

    return 0;
}