Pagina 1 di 4 1 2 3 ... ultimoultimo
Visualizzazione dei risultati da 1 a 10 su 31
  1. #1
    Utente di HTML.it
    Registrato dal
    Jan 2012
    Messaggi
    79

    [ASSEMBLER] Permutazioni

    Eccomi a scocciare per la terza volta..
    probabilmente ormai mi odierete ç_ç ma io intanto chiedo, al massimo non rispondetemi o arrabbiatevi (fareste bene, lo capisco)
    Mi trovo a lottare da questa mattina alle 10 col l'ultimo esercizio di assembler che mi trovo a dover fare...
    o meglio..ci troviamo, ci sto ragionando assieme a compagni di studi ma niente da fare..siamo tutti bloccati, chi più o chi meno...
    Questa volta il problema è quello di generare le permutazioni dei primi N numeri naturali contenuti all'interno di un array...
    ho sempre il mio "scheletro in C" da non poter modificare

    codice:
    #include <stdio.h>  
    void main() 
    { 	
    int N=4;  //numero di interi 	
    int Perm[4326] = {1,2,3,4}; //array permutazioni 	
    int Num;  	
    _asm 	
    {
    
    
    }
    
    {
        int i,j,k;
         printf("Permutazioni dei primi %d numeri naturali \n",N);
         for (i=k=0;i<Num;i++)
    	{
    	  for(j=0;j<N;j++)
    			{
    			   printf("%3d",Perm[k++]);
    			}
    			printf("\n");
    		}
    	}
    }
    nonostante ci sia stato dato un algoritmo (in C) di riferimento (posso postare il link?) non riusciamo a effettuare la "traduzione" in assembler...

    io ho abbozzato questo, ma non so quando abbia senso :/ è proprio fermo agli albori :/ in teoria dovrebbe cominciare a scorrere da fine vettore verso l'inizio, cercando un numero < di quello in esame...

    codice:
    XOR EAX,EAX //contiene l'indice di EDX da modificare 	(ovvero l'indice che decremento per scorrere gli el del vettore)	
    XOR EBX,EBX  //contiene numero  		
    XOR ECX,ECX  //lo uso come indice dell'ultimo elemento 		
    XOR EDX,EDX 		
    	
    
    MOV ECX,N //metto in ECX la lunghezza che ci fa da indice 		
    MOV EBX,Perm[ECX] //contenuto ultima cella del vettore 		
    MOV EAX,ECX   //eax contiene l'indice da modificare (len) 		
    DEC EAX //decremento così diventa il penultimo indice 		
    CMP EAX,0 //se i = 0 finisce il programma 		
    JE fine         
    CMP EBX,Perm[EAX] //controlla l'ultimo numero nel vettore con quello precedente, devo controllare che ebx (ovvero il numero prima a quello in esame) sia < del numero in esame
    //non capisco che salto mettere...  in teoria un JB se la condizione sopra è verificata..
    
    
    fine:
    lo so, questa volta chiedo molto
    non è che non ho voglia di farlo, ma proprio non capisco (non capiamo..neanche unendo i cranii ce la facciamo) dove mettere le mani..l'esercizio delle permutazioni è un bel pò più tosto rispetto gli altri due, così ce l'avevano presentato..e così si è visto :/
    qualche anima pia che abbia voglia di aiutare?
    davvero un giorno quando riuscirò a gestire questi linguaggi con dimestichezza ricambierò l'aiuto!
    grazie in anticipo..

  2. #2
    Utente di HTML.it L'avatar di oregon
    Registrato dal
    Jul 2005
    residenza
    Roma
    Messaggi
    36,462
    Quale algoritmo vi è stato proposto ?
    No MP tecnici (non rispondo nemmeno!), usa il forum.

  3. #3
    Utente di HTML.it
    Registrato dal
    Jan 2012
    Messaggi
    79
    questo è il link..
    http://dzone.com/snippets/generate-permutations
    oppure noi abbiamo trovato questo..
    http://thedarshan.files.wordpress.co...ioni_v1-01.pdf
    (il primo, Algoritmo iterativo per generare permutazioni in ordine lessicografico)

  4. #4
    Utente di HTML.it L'avatar di oregon
    Registrato dal
    Jul 2005
    residenza
    Roma
    Messaggi
    36,462
    Sono molto simili ... (quasi uguali) ...

    Il programma deve funzionare per qualsiasi N o solo con N=4 ?
    No MP tecnici (non rispondo nemmeno!), usa il forum.

  5. #5
    Utente di HTML.it
    Registrato dal
    Jan 2012
    Messaggi
    79
    deve funzionare con valori N<=6 , non è necessario di più
    oh grazie davvero da parte di tutti

  6. #6
    Utente di HTML.it L'avatar di oregon
    Registrato dal
    Jul 2005
    residenza
    Roma
    Messaggi
    36,462
    Per questa sera vedo di dar(vi) una mano ...
    No MP tecnici (non rispondo nemmeno!), usa il forum.

  7. #7
    Utente di HTML.it
    Registrato dal
    Jan 2012
    Messaggi
    79
    Originariamente inviato da oregon
    Per questa sera vedo di dar(vi) una mano ...
    grazie ancora intanto vediamo di continuare a fare qualcosa

  8. #8
    Utente di HTML.it L'avatar di oregon
    Registrato dal
    Jul 2005
    residenza
    Roma
    Messaggi
    36,462
    Occhio alla SWAP del primo algoritmo ... potrebbe non funzionare ... scrivete una vostra funzione per lo swap.

    Una domanda ... perché avete previsto 4326 elementi?
    No MP tecnici (non rispondo nemmeno!), usa il forum.

  9. #9
    Utente di HTML.it
    Registrato dal
    Jan 2012
    Messaggi
    79
    Originariamente inviato da oregon
    Occhio alla SWAP del primo algoritmo ... potrebbe non funzionare ... scrivete una vostra funzione per lo swap.

    Una domanda ... perché avete previsto 4326 elementi?
    eh infatti quella swap non funzionerà nel nostro caso..dobbiamo fare l'operazione di scambio manualmente..
    4326 elementi per avere posto necessario in caso di permutazione del 6 (per quindi poter contenere tutte le permutazioni), è un valore datoci nella consegna...
    il nostro array alla fine deve contenere tutte tutte le permutazioni...quindi nel caso di 3
    1,2,3,1,3,2,2,1,3,2,3,1,3,1,2,3,2,1
    e con sei la cosa verrà molto più lunga...quindi per essere sicuri di avere spazio

  10. #10
    Utente di HTML.it L'avatar di oregon
    Registrato dal
    Jul 2005
    residenza
    Roma
    Messaggi
    36,462
    Come promesso, una soluzione che si basa sul primo link ...

    codice:
    void main() 
    { 	
    	int N=6;  
    	int Perm[4320] = {1,2,3,4,5,6}; 
    	int Num;  	
    
    	_asm 	
    	{
    		XOR ESI,ESI
    		MOV ECX,N
    lpSave:
    		MOV EAX,Perm[ESI*4]
    		PUSH EAX
    		INC ESI
    		DEC ECX
    		JNZ lpSave
    
    		MOV EDI,N
    		PUSH EDI
    
    		MOV Num,0				
    
    lpMain:
    		INC Num					
    
    		MOV ESI,N
    		SUB ESI,2
    
    lpOne:
    		CMP ESI,0
    		JL noMore
    		MOV EAX,Perm[ESI*4]
    		CMP EAX,Perm[ESI*4+4]
    		JLE chkOne
    		DEC ESI
    		JMP lpOne
    	
    chkOne:
    		MOV EDI,N
    		DEC EDI
    
    lpTwo:
    		MOV EAX,Perm[ESI*4]
    		MOV ECX,Perm[EDI*4]
    		CMP EAX,ECX
    		JL swpOne
    		DEC EDI
    		JMP lpTwo
    
    swpOne:
    		MOV Perm[ESI*4],ECX
    		MOV Perm[EDI*4],EAX
    
    		MOV ECX,ESI		
    		INC ECX			
    		XOR EDI,EDI		
    
    lpThr:
    		MOV EAX,N
    		ADD EAX,ESI
    		SAR EAX,1
    		INC EAX
    		CMP ECX,EAX
    		JL nolpMain
    
    		XOR ESI,ESI				
    		POP EDI
    		MOV ECX,N
    cpGrp:
    		MOV EAX,Perm[ESI*4]		
    		MOV Perm[EDI*4],EAX		
    		INC ESI					
    		INC EDI					
    		DEC ECX					
    		JNZ cpGrp				
    		PUSH EDI
    		JMP lpMain
    		
    nolpMain:
    		MOV EAX,N
    		SUB EAX,EDI
    		MOV EDX,Perm[EAX*4-4]
    		PUSH EDX
    		MOV EDX,Perm[ECX*4]
    		MOV Perm[EAX*4-4],EDX
    		POP EDX
    		MOV Perm[ECX*4],EDX
    
    		INC ECX
    		INC EDI
    		JMP lpThr
    
    noMore:
    		POP EDI
    
    		MOV EDI,N
    		MOV ECX,N
    lpRestore:
    		POP EAX
    		MOV Perm[EDI*4-4],EAX
    		DEC EDI
    		DEC ECX
    		JNZ lpRestore
    	}
    
    	int i,j,k;
    	printf("Permutazioni dei primi %d numeri naturali \n",N);
    	for (i=k=0;i<Num;i++)
    	{
    		for(j=0;j<N;j++)
    			printf("%3d",Perm[k++]);
    	
    		printf("\n");
    	}
    }
    Con 6 elementi le permutazioni sono 6! ovvero 720 e dunque gli elementi devono essere 6*720 cioè 4320

    Buon lavoro ...
    No MP tecnici (non rispondo nemmeno!), usa il forum.

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2024 vBulletin Solutions, Inc. All rights reserved.