Question

Write a MIPS code that finds the highest value, lowest value and average of 10 numbers that are given as the global values (in the address range:0×10000000 to 0×10000009) and stores them in the next addresses and write a MIPS code module to sort the numbers in ascending order. Mention your sorting algorithm clearly.

Answer 1

Please find the code below::

.data
array:   .word 123,-124,44,123,4490,2,85,2,13,55,0,0,0
size:   .word 10  
space:   .asciiz " "              
colonsp:   .asciiz ": "   #
  

prompt:   .asciiz "\nSorted array is : "
prompt1:   .asciiz "Array before sorting : "
min:   .asciiz "\nMinimum in array is : "
max:   .asciiz "\nMaximum in array is : "
avg:   .asciiz "\nAverage of the elements is : "
msg2: .asciiz "Enter element "
msg3: .asciiz " : "

.text
.globl   main
main:

lw $s0,size
li $s1,0 #index for loop
la $t0,array #save address of array
read_values_loop_exit:

li   $v0, 4
la   $a0, prompt1
syscall
jal   printArray           # call print routine.

la   $t0, array       # load array to $t0.
lw   $t1, size       # load array size to $t1.
li   $t2, 1           # loop runner, starting from 1.

li $t3,0
li $t7,0 #store max
li $t6,9999 #store min
li $t5,0 #store sum

loop:
mul $t4,$t3,4
add $t4,$t4,$t0 #get base address of a[i]
lw $t4,($t4) #get value of a[i]
blt $t4,$t7,notMax
move $t7,$t4 #set max
notMax:
bgt $t4,$t6,notMin
move $t6,$t4 #set min
notMin:
add $t5,$t5,$t4 #total sum
addi $t3,$t3,1
blt $t3,10,loop

li   $v0, 4
la   $a0, max
syscall
li $v0,1
move $a0,$t7
syscall
sw $t7,40($t0) #store max at index 11 of array

li   $v0, 4
la   $a0, min
syscall
li $v0,1
move $a0,$t6
syscall

sw $t6,44($t0) #store min at index 12 of array

li   $v0, 4
la   $a0, avg
syscall
li $v0,1
div $t5,$t5,$s0
move $a0,$t5
syscall
sw $t5,48($t0) #store avg at index 13 of array
sort_xloop:
la   $t0, array       # load array to $t0.
bge   $t2, $t1, sort_xloop_end   # while (t2 < $t1).
move   $t3, $t2       # copy $t2 to $t3.
sort_iloop:
la   $t0, array       # load array to $t0.
mul   $t5, $t3, 4       # multiply $t3 with 4, and store in $t5
add   $t0, $t0, $t5       # add the array address with $t5, which is the index multiplied with 4.
ble   $t3, $zero, sort_iloop_end   # while (t3 > 0).
lw   $t7, 0($t0)       # load array[$t3] to $t7.
lw   $t6, -4($t0)       # load array[$t3 - 1] to $t6.
bge   $t7, $t6, sort_iloop_end   # while (array[$t3] < array[$t3 - 1]).
lw   $t4, 0($t0)
sw   $t6, 0($t0)
sw   $t4, -4($t0)
subi   $t3, $t3, 1
j   sort_iloop       # jump back to the beginning of the sort_iloop.
sort_iloop_end:
addi   $t2, $t2, 1       # increment loop runner by 1.
j   sort_xloop       # jump back to the beginning of the sort_xloop.
sort_xloop_end:
li   $v0, 4           # 4 = print_string syscall.
la   $a0, prompt
syscall               # issue a system call.

jal   printArray           # call print routine.
exit:
li   $v0, 10           # 10 = exit syscall.
syscall               # issue a system call.

printArray:

la   $t0, array
lw   $t1, size
li   $t2, 0
printLoop:
bge   $t2, $t1, exitPrint
li   $v0, 1
lw   $a0, 0($t0)
syscall
li   $v0, 4
la   $a0, space
syscall
addi   $t0, $t0, 4
addi   $t2, $t2, 1
j   printLoop
exitPrint:
jr   $ra

output: