[1 Luglio 2022] Assembly

[Elia-Belli]

Soluzione del Prof

Le soluzioni fornite dal professore potrebbero essere incomplete o poco chiare, quindi sono benvenute soluzioni che le completano, oppure soluzioni alternative e/o con spiegazioni più approfondite: Soluzione.txt

[CarloDaRomadev]

#Soluzione iterativa

.data
    buffer: .space 20

.text

main:
    li $v0, 8       # Codice per input stringa
    la $a0, buffer  # Carica indirizzo base in $a0
    li $a1, 20      # Alloca al massimo 20 caratteri
    syscall         # $a0 contiene l'indirizzo base della stringa

	jal contaDivDueQuattro
	
	move $a0,$v0
	subi $a0,$a0,8 #sottraggo il valore usato per la prima syscall
	li $v0,1
	syscall
	
	li $a0,'\n'
	li $v0,11
	syscall
	
	move $a0,$v1
	li $v0,1
	syscall
	
	li $v0,10
	syscall

##########################################
## INSERIRE IL CODICE QUI
	
	contaDivDueQuattro:
	li $t1,'\n'		#carico in $t1 il carattere finale della stringa
	lb $t2,($a0)		#carico in $t2 il carattere della stringa nell'indirizzo contenuto in $a0
	addi $a0,$a0,1          #faccio salire $a0 di un byte
	beq $t2,$t1,fine        #se questi due registri contengono lo stesso valore significa che sono sull'ultimo carattere della stringa
	subi $t2,$t2,48 	#trasformo il carattere in numero e lo inserisco in $t2
	beq $t2,$0,zero 	#se il nuemro è zero torno all'inizio del ciclo 
	divu $t0,$t2,2 		#controllo se è divisibile per 2
# blt $t0,$0,nonmultiplo2	#controllo se il numero è positivo
	mfhi $t3 		#sposto il resto della divisione in $t3
	bne $t3,$0,nonmultiplo2 #se non è multiplo di 2 salto a nonmultiplo2
	addi $v0,$v0,1 		#altrimwnti il contatore sale di 1
	
	nonmultiplo2:
	
	divu $t0,$t2,4 		#controllo se è divisibile per 4
# blt $t0,$0,fine		#controllo se il nuemero è positivo
	mfhi $t3 		#sposto il resto della divisione in $t3
	bne $t3,$0,nonmultiplo4 #...
	addi $v1,$v1,1 		#...
	
	nonmultiplo4:
	
	j contaDivDueQuattro #salgo a inizio ciclo
	
	zero:
	
	j contaDivDueQuattro #salgo a inizio ciclo
	
	fine:
	
	jr $ra #ritorno nel main

[CarloDaRomadev]

#Soluzione ricorsiva

.data
    buffer: .space 20

.text

main:
    li $v0, 8       # Codice per input stringa
    la $a0, buffer  # Carica indirizzo base in $a0
    li $a1, 20      # Alloca al massimo 20 caratteri
    syscall         # $a0 contiene l'indirizzo base della stringa

	jal contaDivDueQuattroRec
	
	move $a0,$v0
	subi $a0,$a0,8 #sottraggo il valore usato per la prima syscall
	li $v0,1
	syscall
	
	li $a0,'\n'
	li $v0,11
	syscall
	
	move $a0,$v1
	li $v0,1
	syscall
	
	li $v0,10
	syscall

##########################################
## INSERIRE IL CODICE QUI
	
	contaDivDueQuattroRec:
	lb $t2,($a0)
	beq $t2,'\n',casobase		#se arrivo all'ultimo elemento vado ne caso base
	
	subi $sp,$sp,12			#carico lo stack con:
	sw $a0,8($sp)			#$a0, l'indirizzo che mi serve per scorrere il vettore
	addi $a0,$a0,1			#dopodiche $a0 sale di un byte (per scorrere il vettore)
	sw $ra,4($sp)			#il return address che mi servira per tornare alla chiamata ricorsiva chiamante
	sb $t2,($sp)			#il valore presente nel vettore all'indirizzo contenuto in $a0
	
	jal contaDivDueQuattroRec	#salto alla funzione e salvo in $ra l'indirizzo dell'istruzione successiva
	
	lw $a0,8($sp)   		#svuto lo stack
	lw $ra,4($sp)			
	lb $t2,($sp)
	addi $sp,$sp,12
	
	subi $t2,$t2,48			#tolgo al numero presente in $t2 48 perpassare dal numero "carattere" a numero "cifra"
	
	beq $t2,$0,zero			#salto a zero se il numero è zero
	
	divu $t5,$t2,2			#altrimenti controllo se è divisibile per 2 (in $t5 c'è il risultato della divisione tra il valore contenuto nel registro $t2 e 2)
	mfhi $t3			#sposto il resto della divisione tra il contenuto di $t2 e 2 in $t3
	bne $t3,$0 nonmultiplo2		#se il resto non è 0, il numero presente in %t2 non è divisibile per due, salto a nonmultiplo2
	addi $v0,$v0,1			#in caso contario aggiungo 1 al contatore
	
	nonmultiplo2:
	
	divu $t5,$t2,4			#controllo se è divisibile per 4
	mfhi $t3
	bne $t3,$0 nonmultiplo4		#procedimento simile a quello sopra...
	addi $v1,$v1,1
	
	nonmultiplo4:
	
	jr $ra #ritorno alla funzione chiamante
	
	zero:
	
	jr $ra #ritorno alla funzione chiamante 
	
	casobase:
	
	jr $ra #ritorno alla funzione chiamante

[CiottoloMaggico]

Versione iterativa e versione ricorsiva

.data
S: .asciiz "00004278756\n"

.text
main:
	la $a0, S
	
	jal contaDivDueQuattroRec

	move $a0, $v0
	li $v0, 1
	syscall
	
	li $a0, '\n'
	li $v0, 11
	syscall
	
	move $a0, $v1
	li $v0, 1
	syscall

	li $v0, 10
	syscall

contaDivDueQuattro:
	# $a0 base address of string
	# $v0 sum of even occurrences
	# $v1 sum of number divisible by 4
	subi $sp, $sp, 8
	sw $ra, 0($sp)
	sw $fp, 4($sp)
	
	li $v0, 0
	li $v1, 0
	move $t0, $a0
	
	while:
		lb $t1, ($t0) # load current char
		beq $t1, '\n', endWhile # check if we arrived to the end of string
		subi $t1, $t1, 48 # subtract ASCII value of 0
		beqz $t1, notDivisibleBy4 # check if the value is 0
		rem $t2, $t1, 2 # calculate the reminder of current/2
		bnez $t2, notEven # if not zero, skip to next division
			addi $v0, $v0, 1 # if equal to zero add one to the result
		notEven: 
		rem $t2, $t1, 4 # calculate the reminder of current/4
		bnez $t2, notDivisibleBy4 # if not zero, skip to next division
			addi $v1, $v1, 1 # if equal to zero add one to the result
		notDivisibleBy4:
		addi $t0, $t0, 1 # update the address for the next char
		j while	
	endWhile:
	
	lw $ra, 0($sp)
	lw $fp, 4($sp)
	addi $sp, $sp, 8	
	jr $ra
	
contaDivDueQuattroRec:
	# $a0 base address of string
	# $v0 sum of even occurrences
	# $v1 sum of number divisible by 4
	lb $t0, ($a0) # load the current char
	beq $t0, '\n', baseCase # check if we arrived to the end of string
	recursiveCase:
		################# Save important registers
		subi $sp, $sp, 16
		sw $ra, 0($sp)
		sw $fp, 4($sp)
		sw $a0, 8($sp)
		sw $t0, 12($sp)
		#################
		
		addi $a0, $a0, 1 # prepare args for recursive call
		jal contaDivDueQuattroRec # recursive call
		
		################# Reload important registers
		lw $ra, 0($sp) 
		lw $fp, 4($sp)
		lw $a0, 8($sp)
		lw $t0, 12($sp)
		addi $sp, $sp, 16
		#################
		
		################# same checks of iterative version
		subi $t0, $t0, 48
		beqz $t0, notDivBy4Rec
		rem $t1, $t0, 2
		rem $t2, $t0, 4
		
		bnez $t1, notEvenRec
			addi $v0, $v0, 1
		notEvenRec: #
		bnez $t2, notDivBy4Rec
			addi $v1, $v1, 1
		notDivBy4Rec: #
		#################
		
		jr $ra
	
	baseCase:
		# base case
		li $v0, 0
		li $v1, 0
		jr $ra

[Andrii04]

.data
    buffer: .space 20

.text

main:
    li $v0, 8       # Codice per input stringa
    la $a0, buffer  # Carica indirizzo base in $a0
    li $a1, 20      # Alloca al massimo 20 caratteri
    syscall         # $a0 contiene l'indirizzo base della stringa


##########################################
## INSERIRE IL CODICE QUI

jal DivisibleTwoFour

move $a0, $v0
li $v0, 1
syscall

li $a0, '\n'
li $v0, 11
syscall

move $a0, $v1
li $v0, 1
syscall

li $v0, 10
syscall

DivisibleTwoFour:
	li $t0, 0 #occorrenze numeri divisibli per 2
	li $t1, 0 #occorrenze numeri divisibili per 2
	li $s2, 2 #2
	li $s4, 4 #4
	li $t3, '\n' #newLine
	#t4: intero corrispondente
	#t5: resto divisione 2
	#$t6: resto divisone 4
	li $t7, 0 #0
	li $s5, '0' #'0'
	
	cycle:
		lb $s0, ($a0)
		beq $s0, $t3, returnToMain
		beq $s0, $s5, DigitZero
		
		subi $t4, $s0, 0x30 #converto in intero corrispondente
		div $t4, $s2
		mfhi $t5
		div $t4, $s4
		mfhi $t6
		
		beq $t5, $t7, DivByTwo
		beq $t6, $t7, DivByFour
		
		addi $a0, $a0, 1
		j cycle
		
		DivByTwo:
			addi $t0, $t0, 1
			beq $t6, $t7, DivByFour
			
			addi $a0, $a0, 1
			j cycle
			
		DivByFour:
			addi $t1, $t1, 1
			
			addi $a0, $a0, 1
			j cycle
			
		DigitZero:
			addi $a0, $a0, 1
			j cycle
			
		returnToMain:
			move $v0, $t0
			move $v1, $t1
			jr $ra
		

[LiciaMor18]

##########################################
# INSERIRE I PROPRI DATI QUI
# Nome:
# Cognome:
# Matricola:
##########################################

# NON MODIFICARE QUESTA PARTE
.data
    buffer: .space 20

.text

main:
    li $v0, 8       # Codice per input stringa
    la $a0, buffer  # Carica indirizzo base in $a0
    li $a1, 20      # Alloca al massimo 20 caratteri
    syscall         # $a0 contiene l'indirizzo base della stringa


##########################################
## INSERIRE IL CODICE QUI
   
li $t0,0 #indice
li $v0,0 #somma occorenze cifre divisibili per 2
li $v1,0 #somma occorenze cifre divisibili per 4
li $t3,2

jal contaDiDueQuattro

move $a0,$v0 #stampo valore numero di cifre divisibili per 2
li $v0,1
syscall

li $v0,11 #stampo a capo
la $a0,0xA
syscall

move $a0,$v1 #stampo valore numero cifre divisibili oer 4
li $v0,1
syscall

li $v0,10
syscall

contaDiDueQuattro:

add $t1, $t0,$a0 #il mio offset
lb $t1,($t1) #prendo l'elemento in posizione 0

beq $t1,0xA, fine  #se il carattere è uguale a \n 

subi  $t1,$t1,48
divu $t1,$t3
mfhi $t2
bne $t2,0,Incremento

beq $t1,0,Incremento #controllo se è uguale a 0, in quel caso continuo senza aggiungere nulla
bge $t1,4,AggiungiQuattro    #deve essere più grande o uguale a 4
bge  $t1,2, AggiungiDue   # deve essere più grande o uguale a 2

AggiungiQuattro:
addi $v1,$v1,1
addi $v0,$v0,1
j Incremento

AggiungiDue:
addi $v0,$v0,1

Incremento:

addi $t0,$t0,1 #aumento per viuaggiare nella mia stringa
j contaDiDueQuattro #ritorno alla mia funzione 

fine:
jr $ra #fine 

[Dadaismo0]

Mia soluzione iterativa

##########################################
# INSERIRE I PROPRI DATI QUI
# Nome: Dadaismo
# Cognome: Dadaismo
# Matricola: Dadaismo
##########################################

# NON MODIFICARE QUESTA PARTE
.data
    buffer: .space 20

.text

main:
    li $v0, 8       # Codice per input stringa
    la $a0, buffer  # Carica indirizzo base in $a0
    li $a1, 20      # Alloca al massimo 20 caratteri
    syscall         # $a0 contiene l'indirizzo base della stringa


##########################################
## INSERIRE IL CODICE QUI

.eqv indice, $t1  	          #Assegno le mie stringhe equivalenti ai registri
.eqv strI, $t3	                  #strI contiene il mio indirizzo offsettato e il byte a cui indicherà
.eqv counter2, $v0	          #counter di num divisibili per 2
.eqv counter4, $v1	          #counter di num divisibili per 4	
.eqv resto, $t5             	  #dove caricherò il resto dal registro hi

move $v0, $0	                  #In v0 c'è ancora l' 8 della syscall, lo tolgo
li quattro, 4	                  #Per divu ho bisogno della divisione tra due registri, devo loaddare 4 e 2
li due, 2

jal contaDivDueQuattro

move $a0, $v0
li $v0, 1		         #Carico counter2
syscall

li $v0, 11
li $a0, 10		         #Carico '\n'
syscall

li $v0, 1
move $a0, $v1	#Carico counter4
syscall

li $v0, 10
syscall		#:-)


contaDivDueQuattro:

add strI, $a0, indice		#Carico indirizzo offsettato in strI
lb strI, (strI)		                #Carico byte associato a strI in strI
beq strI, 10, Fine		        #Se il carattere è '\n', termino l'iterazione
beq strI, 48, Ritorno		#Se il carattere è 0, skippo a prossima iterazione

subi strI, strI, 48		#Sottraggo 48 dal mio carattere ottenendo il numero associato

divu strI, quattro		#Divido il numero per 4
mfhi resto			#Sposto il resto della divisione in resto

beqz resto, addTo4		#Se il resto è 0, il numero è multiplo di 4 e di 2, vado in addTo4
	
divu strI, due		        #Divido il numero per 2
mfhi resto			#Sposto il resto della divisione in resto

beqz resto, addTo2		#Se il resto è 0, il numero è multiplo di 2, vado in addTo2

Ritorno:
addi indice, indice, 1	#Mi sposto al prossimo carattere della stringa
j contaDivDueQuattro      #Itero!

addTo4:
addi counter4, counter4, 1	#counter4++
addTo2:
addi counter2, counter2, 1	#counter2++
j Ritorno

Fine:
jr $ra