[9 Settembre 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


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

#inizializzo le variabili 
	li $v0,0 #contatore consecutivi uguali
	li $v1,0 #contatore somma cifre
	
	jal contaOccorrenze
	
	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
	
	contaOccorrenze:			#preciclo per il primo elemento dato che non ha elementi precedenti, questo può essere implementato diversamente ma ritengo che questo sia il più chiaro e semplice.
		lb $t0,($a0)			#carico in $t0 il primo byte del vettore
		beq $t0,'\n',fine		#se è anche l'ultimo, cioè, se il vettore non esiste vado a "fine"
		subi $t0,$t0,48			#altrimenti trasform oil numero da "carattere" a "cifra" togliendogli 48 (zero a carattere)
		addi $a0,$a0,1			#aggiungo 1 al puntatore per scorrere per andare all'elemento successivo
		add $v1,$v1,$t0
	while:
		lb $t2,($a0)				#carico in $t2 il byte successivo del vettore
		beq $t2,'\n',fine			#se questo è l'ultimo vado a fine
		subi $t2,$t2,48				#converto...
		addi $a0,$a0,-1 			#vedo se il valore precedente ($t0), che nel primo caso troviamo nel preciclo mentre in tutti gli altri casi nel ciclo, è uguale al valore presenter in $t2 
		lb $t0,($a0)				#carico $t0, (nel primo ciclo è superfluo)
		subi $t0,$t0,48				#converto...
		bne $t0,$t2,nonugualealprecedente	#se i due registri contengono valori differenti salto a "nonugualealprecedente"
		addi $v0,$v0,1				#altrimenti il contatore dei consecutivi uguali sale
		nonugualealprecedente:
		addi $a0,$a0,2
		add $v1,$v1,$t2				#sommo a $v1 il nuovo valore
		j while					#ritorno all'inizio del ciclo
					
	fine:	
		jr $ra #ritorno nel main per le syscall	

[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


##########################################
## INSERIRE IL CODICE QUI
	li $v0,0
	li $v1,0
	
	jal contaOccorrenzeRec #chiamo la funzione principale
	
	#syscall
	
	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
	
	contaOccorrenzeRec:
	
		#prericorsione per scandire il primo valore dell'array dato che non ha precedenti
		lb $t0,($a0)				#carico in $t0il primo valore dell'array
		beq $t0,'\n',casobase 			#controllo che non sia anche l'ultimo (array vuoto)
		subi $t0,$t0,48				#converto da carattere a valore
		addi $a0,$a0,1				#faccio salire il puntatore di un byte
		add $v1,$v1,$t0				#sommo alla somama degli elementi il valore contenuto in $t0
		
		ricorsione:
		
		lb $t2,($a0)				#carico in $t2 il valore contenuto nella memoria all'indirizzo contenuto in $a0
		beq $t2,'\n',casobase			#se mi trovo sull'ultimo elemento salto al caso base
		subi $t2,$t2,48				#altrimenti converto...
		subi $a0,$a0,1				#faccio scendere il puntatore di 1 byte per prendere il carattere precendente
		lb $t0,($a0)				#carico in $t0, il byte (il carattere) precedente
		subi $t0,$t0,48				#converto...
		addi $a0,$a0,1				#incremento l'indirizzo di 1 (byte)
		
		subi $sp,$sp,16				#carico lo stack con i valori che mi serviranno nella ricorsione
		sw $a0,12($sp)	
		addi $a0,$a0,1				#incremento l'indirizzo di uno per scorrere l'array
		sw $ra,8($sp)
		sw $t0,4($sp)
		sw $t2,($sp)
		
		jal ricorsione				#la funzione richiama se stessa con l'indirizzo contenuto in $a0 incrementato di 1
		
		lw $a0,12($sp)				#svuoto lo stack
		lw $ra,8($sp)
		lw $t0,4($sp)
		lw $t2,($sp)
		addi $sp,$sp,16				# //////////////
		
		bne $t0,$t2,nonuguali			#controllo come nel caso iterativo se due valori consecutivi sono uguali
		addi $v0,$v0,1
		nonuguali:
		add $v1,$v1,$t2				#a prescindere dal controllo precedente la somma degli elementi sale del valore memorizzato in $t2
		jr $ra
		
	casobase:
		jr $ra

[CiottoloMaggico]

.data
string: .asciiz "11234566\n"

.text
main:
	la $a0, string
	jal contaOccorrenze
	
	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
	
contaOccorrenze:
	# $a0 base address of string
	# $v0 number of times that a char is followed by a same value
	# $v1 sum of values
	subi $sp, $sp, 12
	sw $fp, 0($sp)
	sw $ra, 4($sp)
	sw $s0, 8($sp)
	
	li $v0, 0
	li $v1, 0
	li $s0, 48
	move $t0, $a0 # base address
	lb $t1, ($t0) # load first character
	sub $v1, $t1, $s0 # get the numerical value of the char
	addi $t0, $t0, 1 # next character address
	add $v1, $zero, $v1 # add the value to result
	
	while:
		lb $t2, ($t0) # load next char
		beq $t2, 0xA, endOfString # check if we arrived to string end
		bne $t2, $t1, notEqualToPrevious # check if current char is equal to the previous
			addi $v0, $v0, 1 # add 1 to result
		notEqualToPrevious: #
		sub $t1, $t2, $s0 # get the numerical value of the char
		add $v1, $v1, $t1 # add the value to result
		move $t1, $t2 # current char becomes previous char
		addi $t0, $t0, 1 # next char address
		j while # jump!
	endOfString: #
	
	lw $fp, 0($sp)
	lw $ra, 4($sp)
	lw $s0, 8($sp)
	addi $sp, $sp, 12
	jr $ra

[LiciaMor18]

.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 $v0, 0                                       #somma dei numeri uguali al precendente
li $v1,0                                       #somma cifre in tutta la stringa
li $t0,0                                       #indice

jal contaOccorenze

move $a0,$v0                                 #se facessi il contrario avrei $v0=1 e perderei il 
li $v0,1                                            #numero di occorenze
syscall

li $v0,11
la $a0,0xA                                 #stampo \n
syscall

move $a0,$v1                           #stampo la somma delle cifre nella tringa
li $v0,1     
syscall

li $v0,10
syscall

contaOccorenze:
add $t1,$t0,$a0                                         # carico in $t1 indice+indirizzo
lb $t2,($t1)                                                 #carico in $t2 l'elemento della stringa in posizione 0
beq $t2,0xA,fine                                         #controllo se è uguale a \n
subi $t2,$t2,48                                           #ottengo il valore decimale
add $v1,$v1,$t2                                         #aggiungo a $v1 il primo elemento 

lb $t3,1($t1)                        # carico in $t3 l'elemento della stringa in posizione 1
beq $t3,0xA,fine                 #controllo se è uguale a \n
subi $t3,$t3,48                    #ottengo il valore decimale

beq $t2,$t3,aggiungi1            #se sono uguali aggiungo 1 a $v0
j Incremento 

aggiungi1:
addi $v0,$v0,1
j Incremento


Incremento:
addi $t0,$t0,1                #aumento l'idice di uno

j contaOccorenze

fine:
jr $ra