feat: Initial commit

LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2024 Matte23
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Laboratorio2/Esercizio1.asm

@@ -0,0 +1,16 @@
+.data
+n1: .byte 10
+n2: .byte 0x10
+n3: .byte '1'
+res: .space 1
+
+.text
+.globl main
+.ent main
+main:
+lb $t1, n1
+lb $t2, n2
+lb $t3, n3
+sub $t4, $t1, $t2
+add $t4, $t4, $t3
+sb $t4, res

Laboratorio2/Esercizio2.asm

@@ -0,0 +1,34 @@
+.data
+var1: .byte 'm'
+var2: .byte 'i'
+var3: .byte 'p'
+var4: .byte 's'
+var5: .byte 0
+
+.text
+.globl main
+.ent main
+main:
+    lb      $t1,    var1
+    sub     $t1,    $t1,    32
+    sb      $t1,    var1
+
+    lb      $t1,    var2
+    sub     $t1,    $t1,    32
+    sb      $t1,    var2
+
+    lb      $t1,    var3
+    sub     $t1,    $t1,    32
+    sb      $t1,    var3
+
+    lb      $t1,    var4
+    sub     $t1,    $t1,    32
+    sb      $t1,    var4
+
+    la      $a0,    var1
+    li      $v0,    4
+    syscall 
+
+    li      $v0,        10
+    syscall 
+    .end main

Laboratorio2/Esercizio3.asm

@@ -0,0 +1,18 @@
+.data
+op1: .byte 150
+op2: .byte 100
+
+.text
+.globl main
+.ent main
+main:
+    lb      $t1,    op1
+    lb      $t2,    op2
+    add     $t1,    $t1,    $t2
+    move    $a0,    $t1
+    li      $v0,    1
+    syscall 
+
+    li      $v0,    10
+    syscall 
+.end main

Laboratorio2/Esercizio4.asm

@@ -0,0 +1,19 @@
+.text
+.globl main
+.ent main
+main:
+    li      $v0,    5
+    syscall 
+    move $t1, $v0
+
+    li      $v0,    5
+    syscall 
+    move $t2, $v0
+
+    add $t1, $t1, $t2
+    sub $t2, $t1, $t2
+    sub $t1, $t1, $t2
+
+    li      $v0,    10
+    syscall 
+.end main

Laboratorio2/Esercizio5.asm

@@ -0,0 +1,58 @@
+.data
+formula: .asciiz "Calcolo f = (g+h)-(i+j)\n"
+insert_g: .asciiz "Inserire g = "
+insert_h: .asciiz "\nInserire h = "
+insert_i: .asciiz "\nInserire i = "
+insert_j: .asciiz "\nInserire j = "
+acq_term: .asciiz "\nAcquisizione terminata. f = "
+res: .word 1
+
+.text
+.globl main
+.ent main
+main:
+    la $a0, formula
+    li      $v0,    4
+    syscall 
+
+    la $a0, insert_g
+    li      $v0,    4
+    syscall 
+    li      $v0,    5
+    syscall
+    move $t1, $v0
+
+    la $a0, insert_h
+    li      $v0,    4
+    syscall 
+    li      $v0,    5
+    syscall
+    add $t1, $t1, $v0
+
+    la $a0, insert_i
+    li      $v0,    4
+    syscall 
+    li      $v0,    5
+    syscall
+    sub $t1, $t1, $v0
+
+    la $a0, insert_j
+    li      $v0,    4
+    syscall 
+    li      $v0,    5
+    syscall
+    sub $t1, $t1, $v0
+
+    la $a0, acq_term
+    li      $v0,    4
+    syscall 
+
+    move $a0, $t1 
+    li      $v0,    1
+    syscall 
+
+    sw $t1, res
+
+    li      $v0,    10
+    syscall 
+.end main

Laboratorio3/Esercizio1.asm

@@ -0,0 +1,23 @@
+.data
+var: .word 0x3FFFFFF0
+
+.text
+.globl main
+.ent main
+main:
+    lw      $t1,    var
+    add     $t1,    $t1,    $t1
+    move    $a0,    $t1
+    li      $v0,    1
+    syscall 
+    addi    $t2,    $t1,    40
+    move    $a0,    $t2
+    li      $v0,    1
+    syscall 
+    li      $t2,    40
+    add     $t2,    $t1,    $t1
+    move    $a0,    $t2
+    li      $v0,    1
+    syscall 
+    li      $v0,    10
+    syscall 

Laboratorio3/Esercizio2.asm

@@ -0,0 +1,28 @@
+.data
+formula: .asciiz "Overflow\n"
+res: .word 1
+
+.text
+.globl main
+.ent main
+main:
+    li      $v0,    5
+    syscall 
+    move    $t1,    $v0
+
+    li      $v0,    5
+    syscall 
+    move    $t2,    $v0
+
+    addu    $t1,    $t1,        $t2
+
+    slt     $t2,    $t1,        0
+    beq     $t2,    $0,         fine
+    la      $a0,    formula
+    li      $v0,    4
+    syscall 
+
+fine:
+    li      $v0,    10
+    syscall 
+.end main

Laboratorio3/Esercizio5.asm

@@ -0,0 +1,64 @@
+.data
+wVet: .space 50
+wRes: .space 1
+charact: .byte 'a'
+mex_prompt: .asciiz "Inserire caratteri\n"
+mex_occ: .asciiz "Occorrenze: "
+
+.text
+.globl main
+.ent main
+main:
+    la      $t0,        wVet                        # punta a inizio vettore
+    li      $t1,        0                           # inizializzo contatore
+
+# stampo primo messaggi
+    la      $a0,        mex_prompt
+    li      $v0,        4                           # id della syscall print_str
+    syscall 
+
+# lettura stringa. a quanto pare posso solo fare una read_chr
+ciclo_read:
+                                                    # syscall read
+    li      $v0,        12
+    syscall                                         # il risultato è in v0
+    sb      $v0,        ($t0)
+    add     $t0,        $t0,        1               # incremento puntatore
+    beq     $v0,        '\n',       fine_lettura    # smetto di saltare quando ho raggiunto un newline
+    add     $t1,        $t1,        1               # incremento contatore (sapendo che non è un \n)
+    beq     $t1,        50,         fine_lettura    # controllo di non uscire dal buffer
+    b       ciclo_read
+
+fine_lettura:
+    move    $t5,        $t1                         # salvo in $t5 la lunghezza della stringa
+
+
+# resetto puntatore
+    la      $t0,        wVet                        # punta a inizio vettore
+    add     $t1,        $t0,        $t5             # indirizzo finale
+    lb      $t2,        charact
+
+    move    $t4,        $0
+
+conta_occorrenze:
+    lb      $t3,        ($t0)
+    bne    $t3,        $t2,        prox_chr        # salto se non è un minimo
+    addi    $t4,        $t4,        1               # memorizzo il nuovo minimo
+prox_chr:
+    add     $t0,        $t0,        1               # incremento puntatore
+    bne     $t0,        $t1,        conta_occorrenze       # smetto di saltare quando ho iterato su tutti i caratteri
+
+# stampo ultimo messaggio
+    la      $a0,        mex_occ
+    li      $v0,        4                           # id della syscall print_str
+    syscall 
+
+    move    $a0,    $t4
+    li      $v0,    1
+    syscall 
+
+
+fine:
+    li      $v0,        10
+    syscall 
+.end main

Laboratorio4/Esercizio1.asm

@@ -0,0 +1,25 @@
+.data
+mpari: .asciiz "Il numero è pari\n"
+mdispari: .asciiz "Il numero è dispari\n"
+
+.text
+.globl main
+.ent main
+main:
+    li      $v0,    5
+    syscall
+    move $t0, $v0
+
+    andi $t0, t0, 0x1
+
+    beq .dispari %t0, 0x1
+    la      $a0,    mpari
+    j fine
+    dispari:
+    la      $a0,    mdispari
+    fine:
+    li      $v0,    4
+    syscall 
+
+    li      $v0,    10
+    syscall 

Laboratorio4/Esercizio3.asm

@@ -0,0 +1,45 @@
+.data
+var1: .word 14
+var2: .word 13
+var3: .word 12
+
+.text
+.globl main
+.ent main
+main:
+    lw $t1, var1
+    lw $t2, var2
+    lw $t3, var3
+
+    blt $t1, $t2 stepa
+    move $t0, $t2
+    move $t2, $t1
+    move $t1, $t0
+    stepa:
+
+    blt $t1, $t3 stepb
+    move $t0, $t3
+    move $t3, $t1
+    move $t1, $t0
+    stepb:
+
+    blt $t2, $t3 stepc
+    move $t0, $t3
+    move $t3, $t2
+    move $t2, $t0
+    stepc:
+
+    move    $a0,    $t1
+    li      $v0,    1
+    syscall 
+
+    move    $a0,    $t2
+    li      $v0,    1
+    syscall 
+
+    move    $a0,    $t3
+    li      $v0,    1
+    syscall 
+
+    li      $v0,    10
+    syscall 

Laboratorio4/Esercizio4.asm

@@ -0,0 +1,29 @@
+.data
+var1: .word 14
+
+.text
+.globl main
+.ent main
+main:
+    lw $t1, var1
+
+    move $t0, $0
+
+    move $t3, $0
+    addi $t5, $t0, 1
+    loop:
+    sllv $t4, $t5, $t3
+    and $t2, $t1,$t4
+    srlv $t2, $t2, $t3
+    beq $t2, 0, is_zero
+    addi $t0, $t0, 1 
+    is_zero:
+    addi $t3, $t3, 1
+    bne $t3, 8, loop
+
+    move    $a0,    $t0
+    li      $v0,    1
+    syscall 
+
+    li      $v0,    10
+    syscall 

Laboratorio5/Esercizio1.asm

@@ -0,0 +1,31 @@
+.data
+mpari: .asciiz "Il numero è pari\n"
+mdispari: .asciiz "Il numero è dispari\n"
+
+.text
+.globl main
+.ent main
+main:
+    move    $t0,        $0
+    addi    $t2,        $0,     10
+
+read_num:
+    li      $v0,        12
+    syscall 
+
+    beq     $v0,        '\n',   fine        # smetto di saltare quando ho raggiunto un newline
+    addi    $t1,        $v0,    -48         # $t0 = $v0 - '0'
+    mult    $t0,        $t2
+    mflo    $t0
+    add     $t0,        $t0,    $t1
+    j       read_num
+
+fine:
+
+    move    $a0,        $t0
+    li      $v0,        1
+    syscall 
+
+
+    li      $v0,        10
+    syscall 

Laboratorio6/Esercizio1.asm

@@ -0,0 +1,33 @@
+.data
+wVet: .space 20
+wDim: .byte 20
+
+.text
+.globl main
+.ent main
+main:
+    la      $t0,    wVet                        # punta a inizio vettore
+    lb      $t1,    wDim
+    add     $t1,    $t1,    $t0
+
+    addi $t4, $0, 1
+    sb      $t4, ($t0)
+    addi    $t0,    $t0,    1
+    sb      $t4, ($t0)
+
+
+# lettura stringa. a quanto pare posso solo fare una read_chr
+ciclo_fibonacci:
+                                                # syscall read
+    addi    $t2,    $t0,    -1
+    lb      $t4,    ($t2)
+    addi    $t2,    $t2,    -1
+    lb      $t5,    ($t2)
+    add     $t4,    $t4,    $t5
+    sb      $t4,    ($t0)
+    addi    $t0,    $t0,    1
+    bne     $t0,    $t1,    ciclo_fibonacci
+
+    li      $v0,    10
+    syscall 
+.end main

Laboratorio6/Esercizio4.asm

@@ -0,0 +1,34 @@
+.data
+wVet: .space 100
+wDim: .byte 10
+
+.text
+.globl main
+.ent main
+main:
+    la      $t0,    wVet                        # punta a inizio vettore
+    lb      $t1,    wDim
+
+    addi $t2, $0, 1
+
+
+
+# lettura stringa. a quanto pare posso solo fare una read_chr
+ciclo_riga:
+    addi $t3, $0, 1
+ciclo_colonna:
+    mult $t2, $t3
+    mflo $t4
+    sb $t4, ($t0)
+
+    addi    $t0,    $t0,    1
+    addi    $t3, $t3, 1
+    bne     $t3,    $t1,    ciclo_colonna
+
+    addi    $t0,    $t0,    10
+    addi    $t2, $t2, 1
+    bne     $t2,    $t1,    ciclo_riga
+
+    li      $v0,    10
+    syscall 
+.end main

Laboratorio6/Esercizio5.asm

@@ -0,0 +1,40 @@
+.data
+wVet: .word 154, 123, 109, 86, 4, 0
+.word 412, -23, -231, 9, 50, 0
+.word 123, -24, 12, 55, -45, 0
+.word 0, 0, 0, 0, 0, 0
+wDimX: .byte 5
+wDimY: .byte 3
+
+.text
+.globl main
+.ent main
+main:
+    la      $t0,    wVet                    # punta a inizio vettore
+    lb      $t1,    wDimX
+    lb      $t6,    wDimY
+
+
+    addi    $t2,    $0,     1
+
+ciclo_riga:
+    addi    $t3,    $0,     1
+    addi    $t4,    $0,     0
+ciclo_colonna:
+    lw      $t5,    ($t0)
+    add     $t4,    $t4,    $t5
+
+    addi    $t0,    $t0,    1
+    addi    $t3,    $t3,    1
+    bne     $t3,    $t1,    ciclo_colonna
+
+    addi    $t0,    $t0,    1
+    sw      $t4,    ($t0)
+
+    addi    $t0,    $t0,    10
+    addi    $t2,    $t2,    1
+    bne     $t2,    $t6,    ciclo_riga
+
+    li      $v0,    10
+    syscall 
+.end main

Laboratorio7/Esercizio1.asm

@@ -0,0 +1,30 @@
+.data
+num: .word 3141592653
+
+.text
+.globl main
+.ent main
+main:
+    lw      $t0,    num
+    addi $t2, $0, 10
+    move $t3, $sp
+    
+    seq_divide:
+    divu $t0, $t2
+    mfhi $t1 # remainder to $a2
+    mflo $t0
+    addi $sp, $sp, -4
+    sw $t1, 0($sp)
+    bne $t1, $0, seq_divide
+
+    print:
+    addi $sp, $sp, 4
+    lw $t0, 0($sp)
+    addi    $a0,        $t0,    48         # $t0 = $v0 - '0'
+    li $v0, 11
+    syscall
+    bne $sp, $t3, print
+
+    li      $v0,    10
+    syscall 
+.end main

Laboratorio7/Esercizio2.asm

@@ -0,0 +1,46 @@
+.data
+num: .word 3141592653
+p: .asciiz "Il numero è palindromo"
+np: .asciiz "Il numero non è palindromo"
+
+.text
+.globl main
+.ent main
+main:
+    move    $t0,        $sp
+    addi    $t0,        $t0,    -4
+
+read_str:
+    li      $v0,        12
+    syscall 
+
+    beq     $v0,        '\n',   fine    # smetto di saltare quando ho raggiunto un newline
+    addi    $sp,        $sp,    -4
+    sw      $v0,        0($sp)
+    j       read_str
+
+fine:
+
+print:
+    lw      $t1,        0($sp)
+    lw      $t2,        0($t0)
+    bne     $t1,        $t2,    non_p
+    addi    $sp,        $sp,    4
+    addi    $t0,        $t0,    -4
+
+    bgt     $t0,        $sp,    print
+
+    la      $a0,        p
+    li      $v0,        4
+    syscall 
+
+    j       f
+non_p:
+    la      $a0,        np
+    li      $v0,        4
+    syscall 
+
+f:
+    li      $v0,        10
+    syscall 
+.end main

Laboratorio8/Esercizio4.asm

@@ -0,0 +1,27 @@
+.data
+p: .asciiz "Il numero è palindromo"
+
+.text
+.globl main
+.ent main
+main:
+addiu $sp, $sp, -4
+sw $ra, ($sp)
+
+li $a0, 4
+li $a1, 3
+li $a2, 2
+li $a3, 1
+jal determinante2x2
+
+lw $ra, ($sp)
+jr $ra
+.end main
+
+.ent determinante2x2
+determinante2x2:
+mul $t0, $a0, $a3
+mul $t1, $a1, $a2
+sub $v0, $t0, $t1
+jr $ra
+.end determinante2x2

Laboratorio8/Esercizio5.asm

@@ -0,0 +1,87 @@
+.data
+p: .asciiz "Il numero è palindromo"
+
+.text
+.globl main
+.ent main
+main:
+addiu $sp, $sp, -4
+sw $ra, ($sp)
+
+li $a0, 4
+li $a1, 3
+li $a2, 2
+li $a3, 1
+jal determinante2x2
+
+lw $ra, ($sp)
+jr $ra
+.end main
+
+.ent determinante3x3
+determinante3x3
+# crea frame
+sub $sp, $sp, 4
+sw $fp, ($sp)
+move $fp, $sp
+
+# salva i registri
+sub $sp, $sp, 24
+sw $s0, ($sp)
+sw $s1, 4($sp)
+sw $s2, 8($sp)
+sw $s3, 12($sp)
+sw $s4, 16($sp)
+sw $ra, 20($sp)
+
+move $s0, $a0
+move $s1, $a1
+move $s2, $a2
+move $s3, $a3
+
+# calcolo step 1
+lw $a0, 20($fp)
+lw $a1, 16($fp)
+lw $a2, 8($fp)
+lw $a3, 4($fp)
+jal determinante2x2
+mul $s4, $v0, $s0
+
+# calcolo step 2
+move $a0, $s3
+lw $a1, 16($fp)
+lw $a2, 12($fp)
+lw $a3, 4($fp)
+jal determinante2x2
+mul $t0, $v0, $s1
+addu $s4, $s4, $t0
+
+# calcolo step 3
+move $a0, $s3
+lw $a1, 20($fp)
+lw $a2, 12($fp)
+lw $a3, 8($fp)
+jal determinante2x2
+mul $t0, $v0, $s2
+addu $v0, $s4, $t0
+
+# ripristina i registri
+lw $s0, ($sp)
+lw $s1, 4($sp)
+lw $s2, 8($sp)
+lw $s3, 12($sp)
+lw $s4, 16($sp)
+lw $ra, 20($sp)
+lw $fp, 24($sp)
+addi $sp, $sp, 28
+
+jr $ra
+.end determinante3x3
+
+.ent determinante2x2
+determinante2x2:
+mul $t0, $a0, $a3
+mul $t1, $a1, $a2
+sub $v0, $t0, $t1
+jr $ra
+.end determinante2x2

Laboratorio9/bisestile.asm

@@ -0,0 +1,70 @@
+    LUNG    =,          6
+.data
+anni: .word 1945, 2008, 1800, 2006, 1748, 1600
+ris: .space LUNG
+.text
+.globl main
+.ent main
+main:
+    la      $a0,        anni
+    la      $a1,        ris
+    li      $a2,        LUNG
+    jal     bisestile
+    li      $v0,        10                      # codice per uscita dal programma
+    syscall                                     # fine
+.end main
+
+.ent bisestile
+bisestile:
+    addi $sp, $sp, -4
+    sw $ra, ($sp)
+
+    li      $s0,        0
+    sll     $a2,        $a2,    2
+    addu    $s1,        $a0,    $a2
+    move    $s2,        $a0
+    move    $s3,        $a1
+
+loop:
+    lw      $a0,        ($s2)
+    jal     bisestileS
+    beq     $v0,        $0,     skip
+    addiu   $s0,        $s0,    1
+skip:
+    sb      $v0,        ($s3)
+
+    addiu   $s2,        $s2,    4
+    addiu   $s3,        $s3,    1
+    bne     $s2,        $s1,    loop
+
+    move    $v0,        $s0
+    lw $ra, ($sp)
+    addi $sp, $sp, 4
+    jr      $ra
+.end bisestile
+
+.ent bisestileS
+bisestileS:
+                                                # anno in $a0
+    li      $t0,        400
+    div     $a0,        $t0
+    mfhi    $t0
+    beq     $t0,        0,      bis
+
+    li      $t0,        100
+    div     $a0,        $t0
+    mfhi    $t0
+    beq     $t0,        0,      nbis
+
+    li      $t0,        4
+    div     $a0,        $t0
+    mfhi    $t0
+    beq     $t0,        0,      bis
+
+nbis:
+    li      $v0,        0
+    jr      $ra
+bis:
+    li      $v0,        1
+    jr      $ra
+.end bisestileS

Laboratorio9/costoparcheggio.asm

@@ -0,0 +1,46 @@
+.data
+ora_in: .byte 12, 47
+ora_out: .byte 18, 14
+X: .byte 1
+Y: .byte 40
+
+.text
+.globl main
+.ent main
+main:
+    la      $a0,                ora_in              # indirizzo di ora_in
+    la      $a1,                ora_out             # indirizzo di ora_out
+    lbu     $a2,                X
+    lbu     $a3,                Y
+    jal     costoParcheggio
+    li      $v0,                10                  # codice per uscita dal programma
+    syscall                                         # fine
+.end main
+
+.ent costoParcheggio
+costoParcheggio:
+                                                    # Calcolo minuti nel parcheggio in $t0
+    li      $t0,                60
+    lbu      $t1,                ($a0)
+    lbu      $t2,                ($a1)
+    subu     $t1,                $t2,        $t1
+    multu   $t0,                $t1
+    mflo    $t0
+
+    lb      $t1,                1($a0)
+    lb      $t2,                1($a1)
+    addu    $t0,                $t0,        $t2
+    sub     $t0,                $t0,        $t1
+
+    divu    $t0,                $a3
+    mflo    $t0
+    mfhi    $t1
+
+    beq     $t1,                $0,         compl
+    addiu   $t0,                $t0,        1
+compl:
+
+    multu   $t0,                $a2
+    mflo    $v0
+    jr      $ra
+.end costoParcheggio

Laboratorio9/hamming.asm

@@ -0,0 +1,47 @@
+    DIM     =,                  5
+.data
+vet1: .word 56, 12, 98, 129, 58
+vet2: .word 1, 0, 245, 129, 12
+risultato: .space DIM
+.text
+.globl main
+.ent main
+main:
+    la      $a0,                vet1
+    la      $a1,                vet2
+    la      $a2,                risultato
+    li      $a3,                DIM
+    jal     CalcolaDistanzaH
+    li      $v0,                10          # codice per uscita dal programma
+    syscall 
+.end main
+
+.ent CalcolaDistanzaH
+CalcolaDistanzaH:
+sll $a3, $a3, 2
+addu $t0, $a0, $a3
+
+loop:
+lw $t1, ($a0)
+lw $t2, ($a1)
+xor $t1, $t1, $t2
+li $t2, 0
+li $t3, 0
+
+iloop:
+andi $t4, $t1, 0x0001
+addu $t2, $t2, $t4
+srl $t1, $t1, 1
+addiu $t3, $t3, 1
+bne $t3,8, iloop
+
+sw $t2, ($a2)
+
+# incremento
+addiu $a0, $a0, 4
+addiu $a1, $a1, 4
+addiu $a2, $a2, 4
+bne $a0, $t0, loop
+
+jr $ra
+.end CalcolaDistanzaH

Laboratorio9/sconto.asm

@@ -0,0 +1,62 @@
+    NUM     =,              5
+    DIM     =,              NUM,        *,      4
+    SCONTO  =,              30
+    ARROTONDA=1
+.data
+prezzi: .word 39, 1880, 2394, 1000, 1590
+scontati: .space DIM
+.text
+.globl main
+.ent main
+main:
+    la      $a0,            prezzi
+    la      $a1,            scontati
+    li      $a2,            NUM
+    li      $a3,            SCONTO
+    li      $t0,            ARROTONDA
+    subu    $sp,            4
+    sw      $t0,            ($sp)
+    jal     calcola_sconto
+    li      $v0,            10                  # codice per uscita dal programma
+    syscall                                     # fine
+.end main
+
+.ent calcola_sconto
+calcola_sconto:
+    addiu   $sp,            $sp,        -4      # crea spazio per lo stack
+    sw      $fp,            ($sp)               # memorizza frame pointer
+    move    $fp,            $sp                 # il nuovo frame pointer è lo stack pointer precedente
+
+    move    $t0,            $a0                 # pointer prezzi
+    move    $t1,            $a1                 # pointer scontati
+    sll     $t2,            $a2,        2       # moltiplica per 4 (stiamo lavorando con delle
+    addu    $t2,            $t0,        $t2     # pointer fine prezzi
+    li      $t5,            100                 # fattore per dividere
+    sub     $t3,            $t5,        $a3     # fattore moltiplicativo
+    lw      $t4,            4($fp)              # flag approssima
+
+    move    $v0,            $0                  # totale scontato
+
+loop:
+    lw      $t8,            ($t0)               # carica prezzo dalla memoria
+    mul     $t6,            $t8,        $t3     # moltiplica per fattore
+    divu    $t6,            $t5                 # dividi
+    mflo    $t6                                 # carica quoto
+    beqz    $t4,            salva               # salta al salvataggio se la flag arrotonda è zero
+    mfhi    $t7                                 # carica resto
+    blt     $t7,            50,         salva   # salta al salvataggio se il resto è minore di 50
+    addiu   $t6,            $t6,        1       # arrotonda per eccesso
+salva:
+    sw      $t6,            ($t1)               # salva in memoria
+    subu    $t6,            $t8,        $t6
+    addu    $v0,            $v0,        $t6     # aggiorna totale
+
+    addiu   $t0,            $t0,        4       # incrementa pointer prezzi
+    addiu   $t1,            $t1,        4       # incrementa pointer scontati
+    bne     $t0,            $t2,        loop
+
+    lw      $fp,            ($sp)               # carica lo stack pointer salvato
+    move    $sp,            $fp                 # ripristinalo
+    addiu   $sp,            $sp,        4       # pop stack
+    jr      $ra
+.end calcola_sconto

Temi esame/cambio.asm

@@ -0,0 +1,52 @@
+    DIM     =,      6
+.data
+vetB: .byte 2, 14, 119, 54, 10, 41
+vetN: .space DIM
+
+.text
+.globl main
+.ent main
+main:
+    la      $a0,    vetB
+    la      $a1,    vetN
+    li      $a2,    DIM
+    jal     Cambio
+    li      $v0,    10                      # codice per uscita dal programma
+    syscall                                 # fine
+.end main
+
+.ent Cambio
+Cambio:
+
+    li      $t0,    0                       # contatore di riga
+loop:
+
+    li      $t1,    0                       # numero di cambi
+    addu    $t2,    $t0,    $a0
+    lb      $t2,    ($t2)                   # carico la parola
+    li      $t3,    0                       # contatore bit
+
+# inizializzo last val
+    andi    $t4,    $t2,    0x00000001
+
+rileva_cambi:
+    srl     $t2,    $t2,    1
+    andi    $t5,    $t2,    0x00000001
+
+    beq     $t4,    $t5,    cont
+    addiu   $t1,    $t1,    1
+
+cont:
+    move    $t4,    $t5
+
+    addiu   $t3,    $t3,    1
+    bne     $t3,    7,      rileva_cambi
+
+    addu    $t2,    $t0,    $a1
+    sb      $t1,    ($t2)                   # salvo il risultato in vetN
+
+    addiu   $t0,    $t0,    1
+    bne     $t0,    $a2,    loop
+
+    jr      $ra
+.end Cambio

Temi esame/codF.asm

@@ -0,0 +1,92 @@
+.data
+cognome:.asciiz "ROSSI"
+nome:.asciiz "GENNARO"
+data:.asciiz "120892"
+CF:.space 12
+
+.text
+.globl main
+.ent main
+main:
+    subu    $sp,        $sp,        4
+    sw      $ra,        ($sp)
+    la      $a0,        cognome
+    la      $a1,        nome
+    la      $a2,        data
+    la      $a3,        CF
+    jal     CalcoloCF
+    lw      $ra,        ($sp)
+    addiu   $sp,        $sp,        4
+    jr      $ra
+.end main
+
+.ent CalcoloCF
+CalcoloCF:
+# Calcolo cognome
+li $t0, 0
+move $t2, $a0
+genC:
+# salto delle vocali 
+lb $t3, 0($t2)
+beq $t3 'A', next
+beq $t3 'E', next
+beq $t3 'I', next
+beq $t3 'O', next
+beq $t3 'U', next
+
+# aggiungo carattere
+sb $t3, 0($a3)
+addiu $a3,$a3,1
+addiu $t0,$t0,1
+
+next:
+addiu $t2,$t2,1
+bne $t0, 3, genC
+
+# Calcolo nome
+li $t0, 0
+move $t2, $a1
+genC1:
+# salto delle vocali 
+lb $t3, ($t2)
+beq $t3 'A', next1
+beq $t3 'B', next1
+beq $t3 'C', next1
+beq $t3 'D', next1
+beq $t3 'E', next1
+
+# aggiungo carattere
+sb $t3, ($a3)
+addiu $a3,$a3,1
+addiu $t0,$t0,1
+
+next1:
+addiu $t2,$t2,1
+bne $t0, 3, genC1
+
+# Copio data
+move $t0, $a2
+lb $t1, ($t0)
+sb $t1, ($a3)
+lb $t1, 1($t0)
+sb $t1, 1($a3)
+
+addiu $t0,$t0,4
+addiu $a3,$a3,4
+lb $t1, ($t0)
+sb $t1, ($a3)
+lb $t1, 1($t0)
+sb $t1, 1($a3)
+
+jr $ra
+.end CalcoloCF
+
+.ent MonthToChar
+MonthToChar:
+                                        # Parametro in ingresso $a0 = 2 CARATTERI ESTRATTI DALLA DATA
+                                        # (esempio: "01" per Gennaio)
+                                        # Parametro in uscita $v0 = "A" per l'esempio di Gennaio
+                                     # codice della procedura da non sviluppare
+    li $v0, 'X'
+    jr      $ra
+.end MonthToChar

Temi esame/codFmeglio.asm

@@ -0,0 +1,102 @@
+.data
+cognome:.asciiz "ROSSI"
+nome:.asciiz "GENNARO"
+data:.asciiz "120892"
+CF:.space 12
+
+.text
+.globl main
+.ent main
+main:
+    subu    $sp,            $sp,        4
+    sw      $ra,            ($sp)
+    la      $a0,            cognome
+    la      $a1,            nome
+    la      $a2,            data
+    la      $a3,            CF
+    jal     CalcoloCF
+    lw      $ra,            ($sp)
+    addiu   $sp,            $sp,        4
+    jr      $ra
+.end main
+
+.ent CalcoloCF
+CalcoloCF:
+    subu    $sp,            $sp,        4
+    sw      $ra,            ($sp)
+
+# Calcolo cognome e nome
+    move    $t0,            $a3                         # destinazione
+    addiu   $t1,            $t0,        6               # puntatore termine
+    addiu   $t2,            $t0,        3               # puntatore swap
+    move    $t3,            $a0                         # parola
+
+loop_lettere:
+                                                        # salto delle vocali
+    lb      $t4,            0($t3)
+    beq     $t4,            'A',        next
+    beq     $t4,            'E',        next
+    beq     $t4,            'I',        next
+    beq     $t4,            'O',        next
+    beq     $t4,            'U',        next
+
+# aggiungo carattere
+    sb      $t4,            0($t0)
+    addiu   $t0,            $t0,        1
+
+next:
+    bne     $t0,            $t2,        incr
+                                                        # cambio source al nome
+    move    $t3,            $a1
+    j       en
+incr:
+    addiu   $t3,            $t3,        1
+en:
+    bne     $t0,            $t1,        loop_lettere
+
+# Copio la data
+    move    $t1,            $a2
+    lb      $t2,            ($t1)
+    sb      $t2,            ($t0)
+    lb      $t2,            1($t1)
+    sb      $t2,            1($t0)
+
+# Inserisco mese
+    addiu   $t0,            $t0,        2
+    addiu   $t1,            $t1,        2
+    lw      $a0,            ($t1)
+    andi    $a0,            $a0,        0x0000FFFF
+    jal     MonthToChar
+    sb      $v0,            ($t0)
+
+    lb      $t2,            2($t1)
+    sb      $t2,            1($t0)
+    lb      $t2,            3($t1)
+    sb      $t2,            2($t0)
+
+# calcolo parity bit
+    move    $t0,            $a3                         # iteratore codice
+    addiu   $t1,            $t0,        12              # puntatore termine
+    li      $t2,            0
+
+parity:
+    lb      $t3,            ($t0)
+    xor     $t2,            $t2,        $t3
+    addiu   $t0,            $t0,        1
+    bne     $t0,            $t1,        parity
+    sb      $t2,            ($t0)
+
+    lw      $ra,            ($sp)                       # ripristina $ra
+    addu    $sp,            4                           # ripristina $sp
+    jr      $ra
+.end CalcoloCF
+
+.ent MonthToChar
+MonthToChar:
+                                                        # Parametro in ingresso $a0 = 2 CARATTERI ESTRATTI DALLA DATA
+                                                        # (esempio: "01" per Gennaio)
+                                                        # Parametro in uscita $v0 = "A" per l'esempio di Gennaio
+                                                        # codice della procedura da non sviluppare
+    li      $v0,            'H'
+    jr      $ra
+.end MonthToChar

Temi esame/minintrig.asm

@@ -0,0 +1,57 @@
+DIM = 8
+.data
+matrice:
+.byte 3, 1, 41, 5, 9, 26, 5, 35
+.byte 89, 79, 32, 3, 8, 46, 26, 4
+.byte 33, 8, 32, 79, 50, 28, 8, 4
+.byte 19, 71, 69, 39, 9, 37, 5, 10
+.byte 58, 20, 9, 74, 9, 44, 59, 2
+.byte 30, 7, 8, 16, 40, 6, 28, 6
+.byte 20, 8, 9, 98, 62, 80, 3, 48
+.byte 25, 34, 21, 1, 70, 6, 7, 9
+
+.text
+.globl main
+.ent main
+main:
+subu $sp, $sp, 4
+sw $ra, ($sp)
+la $a0, matrice
+li $a1, 1
+li $a2, DIM
+jal maxInTriangolo
+# lettura del risultato calcolato dalla procedura
+lw $ra, ($sp)
+addiu $sp, $sp, 4
+jr $ra
+.end main
+
+.ent maxInTriangolo
+maxInTriangolo:
+# ricerca max in riga
+li $v0, 0
+
+mul $t0, $a1, $a2
+add $t0, $t0, $a0
+add $t1, $t0, $a2
+loop_riga:
+lw $t2, ($t0)
+blt $t2, $v0, cont_riga
+move $v0, $t2
+cont_riga:
+addiu $t0, $t0, 1
+bne $t0,$t1, loop_riga
+
+
+add $t0, $a0, $a2
+mul $t1, $a1, $a2
+add $t1, $t1, $t0
+loop_colonna:
+lw $t2, ($t0)
+blt $t2, $v0, cont_colonna
+move $v0, $t2
+cont_colonna:
+addu $t0, $t0, $a2
+bne $t0,$t1, loop_colonna
+
+.end maxInTriangolo

Temi esame/ortofrutta.asm

@@ -0,0 +1,33 @@
+#a0 matrice
+#a1 num
+#a2 SAC
+
+.ent calcolaCosto
+calcolaCosto:
+li $t0, 0
+move $t1, a0
+li $t2,0
+li $t3,0
+
+ciclo:
+lw $t4, 0($t1)
+addiu $t1,$t1,1
+addu $t2,$t2,$t1
+
+lw $t4, 0($t1)
+addiu $t1,$t1,1
+addu $t3,$t3,$t1
+
+lw $t4, 0($t1)
+addiu $t1,$t1,1
+beq		$t4, 0, calc_rem	# if $t4 =101 calc_rem goto target
+addu $t3, $t3, $a2
+calc_rem:
+blt		$t3, 99, incr	# if $t0 < $t1 then goto target
+sub $t3,$t3,100
+addiu $t2,$t2,1
+incr:
+addiu $t0, $t0, 1
+bne $t0, $a1, ciclo
+
+.end calcolaCosto

Temi esame/unamatrice.asm

@@ -0,0 +1,87 @@
+    N       =,              3
+    M       =,              4
+.data
+matriceA:
+.word 0xAB317811, 0xCD514229, 0xEF832040, 0xA1346269
+.word 0xB2178309, 0xC3524578, 0x65702887, 0x59227465
+.word 0x14930352, 0x24157817, 0x39088169, 0x63245986
+matriceB:
+.word 0x39916800, 0x47900160, 0x62270208, 0x87178291
+.word 0xA7674368, 0xB2092278, 0xC3556874, 0xD6402373
+.word 0xE1216451, 0x24329020, 0x51090942, 0x11240007
+matriceC:
+.space N * M * 4
+
+.text
+.globl main
+.ent main
+main:
+    subu    $sp,            $sp,        4
+    sw      $ra,            ($sp)
+    la      $a0,            matriceA
+    la      $a1,            matriceB
+    la      $a2,            matriceC
+    li      $a3,            N
+    li      $t0,            M
+    subu    $sp,            $sp,        4
+    sw      $t0,            ($sp)
+    jal     MediaMatrice
+    addiu   $sp,            $sp,        4
+    lw      $ra,            ($sp)
+    addiu   $sp,            $sp,        4
+    jr      $ra
+.end main
+
+.ent MediaMatrice
+MediaMatrice:
+
+    mult $a3, $t0
+    mflo $a3
+
+    li      $t1,            0
+loop_colonna:
+
+    li      $t2,            0
+loop_riga:
+
+    addu    $t3,            $t1,        $t2
+    sll     $t3,            $t3,        2
+    addu   $t3,            $t3,        $a0
+    lw      $t3,            ($t3)
+
+    addu    $t4,            $t1,        $t2
+    sll     $t4,            $t4,        2
+    addu   $t4,            $t4,        $a1
+    lw      $t4,            ($t4)
+
+    slt     $t5,            $t3,        $0
+    slt     $t6,            $t3,        $0
+    xor     $t5,            $t5,        $t6
+
+    bne     $t5,            $0,         opposto
+    addu    $t4,            $t3,        $t4
+    srl     $t4,            $t4,        1
+
+    li $t5, 0x80000000
+    and $t3, $t3, $t5
+    or $t4, $t4, $t3
+
+    j       salva_media
+opposto:
+    add     $t4,            $t3,        $t4
+    sra     $t4,            $t4,        1
+
+salva_media:
+    addu    $t3,            $t1,        $t2
+    sll     $t3,            $t3,        2
+    addu   $t3,            $t3,        $a2
+    sw      $t4,            ($t3)
+
+    addiu   $t2,            $t2,        1
+    bne     $t2,            $t0,        loop_riga
+
+    addu   $t1,            $t1,        $t0
+    bne     $t1,            $a3,        loop_colonna
+
+    jr      $ra
+.end MediaMatrice

ricercaMin.asm

@@ -0,0 +1,64 @@
+.data
+wVet: .space 50
+wRes: .space 1
+mex_prompt: .asciiz "Inserire caratteri\n"
+mex_result: .asciiz "\nValore minimo: "
+
+.text
+.globl main
+.ent main
+
+main:
+    la      $t0,        wVet                        # punta a inizio vettore
+    li      $t1,        0                           # inizializzo contatore
+
+# stampo primo messaggi
+    la      $a0,        mex_prompt
+    li      $v0,        4                           # id della syscall print_str
+    syscall 
+
+# lettura stringa. a quanto pare posso solo fare una read_chr
+ciclo_read:
+                                                    # syscall read
+    li      $v0,        12
+    syscall                                         # il risultato è in v0
+    sb      $v0,        ($t0)
+    add     $t0,        $t0,        1               # incremento puntatore
+    beq     $v0,        '\n',       fine_lettura    # smetto di saltare quando ho raggiunto un newline
+    add     $t1,        $t1,        1               # incremento contatore (sapendo che non è un \n)
+    beq     $t1,        50,         fine_lettura    # controllo di non uscire dal buffer
+    b       ciclo_read
+
+fine_lettura:
+    move    $t5,        $t1                         # salvo in $t5 la lunghezza della stringa
+
+# resetto contatore e puntatore
+    la      $t0,        wVet                        # punta a inizio vettore
+    li      $t1,        0                           # inizializzo contatore
+
+    lb      $t2,        ($t0)                       # memorizzo il valore minimo dentro t2, e inizializzo con primo carattere
+
+cerca_min:
+    lb      $t3,        ($t0)
+    ble     $t3,        0x20,       prox_chr        # salto se è un carattere speciale
+    bgt     $t3,        $t2,        prox_chr        # salto se non è un minimo
+    move    $t2,        $t3                         # memorizzo il nuovo minimo
+prox_chr:
+    add     $t0,        $t0,        1               # incremento puntatore
+    add     $t1,        $t1,        1               # incremento contatore
+    bne     $t1,        $t5,        cerca_min       # smetto di saltare quando ho iterato su tutti i caratteri
+
+# stampo messaggio
+    la      $a0,        mex_result
+    li      $v0,        4                           # id della syscall mex_result
+    syscall 
+
+# stampo carattere minimo
+    move    $a0,        $t2
+    li      $v0,        11
+    syscall 
+
+# termino programma
+    li      $v0,        10
+    syscall 
+.end main

test.asm

@@ -0,0 +1,16 @@
+.data                               # dichiarazione dati
+op1: .byte 3
+op2: .byte 2
+res: .space 1                       # allocazione spazio in memoria per risultato
+
+.text
+.globl main
+.ent main
+main:
+    lb      $t1,    op1             # caricamento dati
+    lb      $t2,    op2
+    add     $t1,    $t1,    $t2     # esecuzione somma
+    sb      $t1,    res             # salvataggio del risultato in memoria
+    li      $v0,    10              # codice per uscita dal programma
+    syscall                         # fine
+.end main

vigenere.asm

@@ -0,0 +1,51 @@
+    la      $s0,    plaintext
+    la      $s1,    key
+    la      $s2,    len
+    la      $s3,    chipertext
+
+.ent cifrarioVigenere
+cifrarioVigenere:
+    li      $t0,    0                               # counter current char
+    li      $t1,    0                               # counter modulo char
+    li      $v0,    0                               # current encoded chars
+
+# i registri da $t3 in poi in poi possono essere usati liberamente nel loop
+
+loop:
+    addu    $t3,    $s0,        $t0
+    lb      $t3,    0($t3)
+    bne     $t3,    0,          end                 # termina se null byte
+
+# controllo se lettera è minuscola
+    blt     $t3,    'z',        copy                # se maggiore di
+    bgt     $t3,    'a',        copy                # se minore di
+
+
+    addu    $4,     $s1,        $t1                 # risolvo indirizzo carattere chiave
+    lw      $t4,    0($t4)                          # carico in memoria
+    sub     $t4,    $t4,        'a'
+    addu    $t3,    $t3,        $t4                 # eseguo la codifica
+
+    ble     $t3,    'z',        copy
+    sub     $t1,    $t1,        'z',                +,1
+    add     $t1,    $t1,        'a'
+
+copy:
+    addu    $t4,    $s3,        $t0
+    sw      $t3,    0($t4)                          # salvo nel chipertext
+
+    bne     $t1,    $s2,        increment_modulo
+    addiu   $t1,    $0,         0                   # resetto contatore modulo
+    j       cont
+
+increment_modulo:
+    addiu   $t1,    $t1,        1                   # incremento contatore modulo
+
+cont:
+    addi    $t0,    $t0,        1                   # incremento contatore carattere
+    j       loop                                    # jump to loop
+
+end:
+
+    jr      $ra
+.end cifrarioVigenere