Assembly-MIPS unione e intersezione di vettori

di il
5 risposte

Assembly-MIPS unione e intersezione di vettori

Salve, avrei bisogno di una mano con un esercizio.
Devo inserire 5 vettori di massimo 50 caratteri e fare unione e intersezione. Come mi consigliate di agire? Se riuscite a scrivermi anche il codice sareste dei grandi!

5 Risposte

  • Re: Assembly-MIPS unione e intersezione di vettori

    Forse stai cercando anche qualcuno che vada a fare l'esame al posto tuo.
    allora per quanto riguarda il codice quello te lo scrivi da solo.
    qui non si fanno i compiti qui si aiuta la gente ad imparare.
    per quanto riguarda l'unione basta che una volta che hai definito i vettori e li hai riempiti li visualizzi.
    per quanto riguarda l'intersezione devi definirti delle regole che trovano gli elementi comuni e poi vettore per vettore te li stampi.
  • Re: Assembly-MIPS unione e intersezione di vettori

    Il tuo commento e stato più che intile perché la teoria la so ma non riesco a scrivere l'untimo pezzo di codice solo per fare proprio intersezione e unione ho già creato tutti i vettori ma ho provato vari metodi me non riesco a farlo !! Mi basterebbero anche solo dei consigli su come scrivere il codice forse ho sbagliato a pormi !!
  • Re: Assembly-MIPS unione e intersezione di vettori

    Beh, sicuro che hai sbagliato ... se chiedi il codice pronto non vuoi certo dire che vuoi dei consigli ...

    Se hai impostato del codice prova a postarlo, lo commenti e si fornisce qualche consiglio per risolvere la parte su cui hai dubbi ...
  • Re: Assembly-MIPS unione e intersezione di vettori

    Salve anche io ho lo stesso problema volevo chiedervi se per creare i 5 vettori va fatto cosi
    .data
    insertchar: .asciiz "\n inserire gli elementi nel vettore ( premere '0' per terminare)"
    messaggfine: .asciiz "\n i caretteri che compaiono sono: \n"
    inserimento: .asciiz "\n elemento successivo: \n"
    arraypieno: .asciiz "\n capacità massima del vettore raggiunta (50 elementi)"
    fine: .asciiz "\n FINE "
    array1: .word 0:50 #inizializza un vettore di 50 numeri tutti a zero
    array2: .word 0:50 #inizializza un vettore di 50 numeri tutti a zero
    array3: .word 0:50 #inizializza un vettore di 50 numeri tutti a zero
    array4: .word 0:50 #inizializza un vettore di 50 numeri tutti a zero
    array5: .word 0:50 #inizializza un vettore di 50 numeri tutti a zero
    arryUnione: .word 0:50 #inizializzo un vettore di 50 numeri tutti a zero che conterra l' unione
    arryIntersezione: .word 0:50 #inizializzo un vettore di 50 numeri tutti a zero che conterra l' intersezione


    .text

    .globl main

    main:
    move $t0, $zero
    move $t1, $zero
    move $t2, $zero
    move $t3, $zero
    move $t4, $zero
    move $s0, $zero # contatore i

    la $s1, array1
    la $s2, array2
    la $s3, array3 # carica l'indirizzo nei vettori principali
    la $s4, array4
    la $s5, array5

    li $v0, 4
    la $a0, insertchar
    syscall # stampa stringa "inserire gli elementi nel vettore"
    li $s6, '0' # imposto 0 come carettere di interruzione riempimento

    ciclo:

    # si esegue un ciclo per caricare il vettore

    li $v0, 4 # ciclo per caricare il vettore
    la $a0, inserimento # 50 elementi al massimo e appena leggiamo l'elemento e usciamo
    syscall
    li $v0, 12
    syscall


    primoArray:
    beq $v0, $s6, secondoArray
    sw $v0, 0($s1) # salva v0 nella prima posizione dell' array1 con $s1 indirizzo+offset della posizione
    addi $s1, $s1, 4 # aggiungo offset per il prossimo inserimento
    beq $t0, 5, secondoArray
    addi $t0, $t0, 1
    j ciclo
    # incrementa variabile iterazione $t0

    secondoArray:

    sw $v0, 0($s2) # salva v0 nella prima posizione dell' array1 con $s2 indirizzo+offset della posizione
    addi $s2, $s2, 4 # aggiungo offset per il prossimo inserimento
    beq $t1, 5, terzoArray
    addi $t1, $t1, 1 # incrementa variabile iterazione $t0

    j ciclo


    terzoArray:
    sw $v0, 0($s3) # salva v0 nella prima posizione dell' array1 con $s3 indirizzo+offset della posizione
    addi $s3, $s3, 4 # aggiungo offset per il prossimo inserimento
    beq $t2, 5, array4
    addi $t2, $t2, 1 # incrementa variabile iterazione $t0
    j ciclo

    quartoArray:
    sw $v0, 0($s4) # salva v0 nella prima posizione dell' array1 con $s2 indirizzo+offset della posizione
    addi $s4, $s4, 4 # aggiungo offset per il prossimo inserimento
    beq $t3, 5, array5
    addi $t3, $t3, 1 # incrementa variabile iterazione $t0
    j ciclo

    quintoArray:
    sw $v0, 0($s5) # salva v0 nella prima posizione dell' array1 con $s2 indirizzo+offset della posizione
    addi $s5, $s5, 4 # aggiungo offset per il prossimo inserimento
    beq $t4, 5, inter_riemp
    addi $t4, $t4, 1 # incrementa variabile iterazione $t0

    j ciclo

    inter_riemp:
    li $v0, 4
    la $a0, messaggfine # stampiamo il messagio di fine
    syscall
  • Re: Assembly-MIPS unione e intersezione di vettori

    Vi posto il codice che ho fatto, ho un problema, inserisco gli elementi, stampo i 5 vettori (con 0 che chiude l'inserimento) ma non riesco a fare l'unione perchè mi esce dal programma... qual'è il problema? non riesco a trovarlo.


    .data
    msg1: .asciiz "\n Inserisci gli elementi del vettore 1 e premi '0' per terminare: \n\n"
    msg2: .asciiz "\n Inserisci gli elementi del vettore 2 e premi '0' per terminare:\n"
    msg3: .asciiz "\n Inserisci gli elementi del vettore 3 e premi '0' per terminare:\n"
    msg4: .asciiz "\n Inserisci gli elementi del vettore 4 e premi '0' per terminare:\n"
    msg5: .asciiz "\n Inserisci gli elementi del vettore 5 e premi '0' per terminare:\n"
    msg_exit: .asciiz "\n FINE INSERIMENTO!!! \n"

    array1: .space 50 #creazione array in cui possono essere allocati al massimo 50 byte di memoria (per ogni array)
    array2: .space 50
    array3: .space 50
    array4: .space 50
    array5: .space 50
    vettoreUnione: .space 50



    .text
    .globl main

    main:
    li $v0,4 #stampa msg1
    la $a0,msg1
    syscall

    li $s0, 0 #uso $s0 come indice dell'array
    li $s1, 49 #termina l'inserimento quando sono stati inseriti 50 caratteri


    inserimento1:
    la $t0, array1 #$t0 prende l'indirizzo dell'array
    li $v0, 12
    syscall


    move $t1, $v0 #inizializzazione del ciclo per l'inserimento
    sb $t1, array1($s0)
    beq $v0, '0', vett2 #se è stato inserito zero si deve concludere
    addi $t0,$t0, 1 #incrementa di 1 per poter andare avanti nel ciclo
    addi $s0, $s0, 1
    bne $s0, $s1, inserimento1

    vett2:
    li $v0,4 #stampa msg_successivo
    la $a0,msg2
    syscall

    li $s0, 0 #uso $s0 come indice dell'array
    li $s1, 49 #termina l'inserimento quando sono stati inseriti 50 caratteri

    j inserimento2

    inserimento2:
    la $t0, array2 #$t0 prende l'indirizzo dell'array
    li $v0, 12
    syscall


    move $t1, $v0
    sb $t1, array2($s0)
    beq $v0, '0', vett3 #se è stato inserito zero si deve concludere
    addi $t0,$t0, 1
    addi $s0, $s0, 1
    bne $s0, $s1, inserimento2

    vett3:
    li $v0,4 #stampa msg_successivo
    la $a0,msg3
    syscall

    li $s0, 0 #uso $s0 come indice dell'array
    li $s1, 49 #termina l'inserimento quando sono stati inseriti 50 caratteri

    j inserimento3

    inserimento3:
    la $t0, array3 #$t0 prende l'indirizzo dell'array
    li $v0, 12
    syscall


    move $t1, $v0
    sb $t1, array3($s0)
    beq $v0, '0', vett4 #se è stato inserito zero si deve concludere
    addi $t0,$t0, 1
    addi $s0, $s0, 1
    bne $s0, $s1, inserimento3

    vett4:
    li $v0,4 #stampa msg_successivo
    la $a0,msg4
    syscall

    li $s0, 0 #uso $s0 come indice dell'array
    li $s1, 49 #termina l'inserimento quando sono stati inseriti 50 caratteri

    j inserimento4

    inserimento4:
    la $t0, array4 #$t0 prende l'indirizzo dell'array
    li $v0, 12
    syscall


    move $t1, $v0
    sb $t1, array4($s0)
    beq $v0, '0', vett5 #se è stato inserito zero si deve concludere
    addi $t0,$t0, 1
    addi $s0, $s0, 1
    bne $s0, $s1, inserimento4

    vett5:
    li $v0,4 #stampa msg_successivo
    la $a0,msg5
    syscall

    li $s0, 0 #uso $s0 come indice dell'array
    li $s1, 49 #termina l'inserimento quando sono stati inseriti 50 caratteri

    j inserimento5

    inserimento5:
    la $t0, array5 #$t0 prende l'indirizzo dell'array
    li $v0, 12
    syscall


    move $t1, $v0
    sb $t1, array5($s0)
    beq $v0, '0', exit #se è stato inserito zero si deve concludere
    addi $t0,$t0, 1
    addi $s0, $s0, 1
    bne $s0, $s1, inserimento5

    move $t2, $zero # int i=0,

    forIparte1:
    beq $t2, $v0, uscitaUnione # se i==v.length ha finito e torna al main

    lbu $t0, 0($a1) # v = $t0
    beq $t0, $s0, updateForI # v == 0, non considero questo elemento

    move $t3, $zero # int j=0


    forJ:
    blt $s3, $t3, forIparte2 # if k < j esce dal j loop
    lbu $t1, 0($a2) # unione[j] = $t1
    beq $t0, $t1, updateForI # if v==unione[j], non salva v

    addi $a2, $a2, 1 #
    addi $t3, $t3, 1 # j++

    j forJ

    forIparte2:
    sb $t0, vettoreUnione($s3) # vettoreUnione[k] = v
    addi $s3, $s3, 1 # k++

    beq $s2, $s3, printUnione # if 49==k (vettoreUnione è pieno) vai al print

    updateForI:
    addi $a1, $a1, 1 # incremento il puntatore a v
    addi $t2, $t2, 1 # i++
    j forIparte1

    printUnione:
    la $t0, vettoreUnione #$t0 prende l'indirizzo dell'array
    li $v0, 12
    syscall

    uscitaUnione:
    jr $ra



    exit:
    li $v0,4 #stampa msg_exit
    la $a0,msg_exit
    syscall

    li $v0, 10 # termina programma
    syscall




Devi accedere o registrarti per scrivere nel forum
5 risposte