# Autor:

# Fecha:
# Institucion: Universidad de Antioquia
# Programa: Ingenieria de Sistemas a Distancia
# Curso: Lab. Arquitectura de computadores

##############zona de menus###############################
.data
vec: .space 10 #10 elementos
men1: .ascii "\n\n\n-------------MENU
PRINCIPAL-----------------\n"
.ascii "|
|\n"
.ascii "| Practica Laboratorio 1
|\n"
.ascii "| Creado por: Luis Fernando Cadavid Zuluaga
|\n"
.ascii "| Fecha: 24/Febrero/2010
|\n"
.ascii "|
|\n"
.ascii "| Seleccione una opcion
|\n"
.ascii "| 1- Ordenar 10 números
|\n"
.ascii "| 2- Salir
|\n"
.ascii "|
|\n"
.asciiz "| Ingrese el valor:"
men2: .asciiz "\n\n Los datos ordenados ascendentemente son: "
men3: .asciiz "\n Cuantos numeros desea ingresar?: "
men4: .asciiz "\n Los datos ordenados descendentemente son:
\n"
men6: .asciiz "\n Por favor digite el nombre del usuario: "
men7: .asciiz "\n Hasta pronto......... "
men8: .asciiz "\n !!!!!!!ELECCION
ERRADA¡¡¡¡¡¡¡¡¡¡\n\n\n\n"
men9: .asciiz "\n Por favor sumistre un entero: "

men11: .ascii "\n Practica 1 laboratorio de Arquitectura

de Computadores "

men10: .asciiz "\n el nuevo vector es: \n"

men12: .asciiz ","
men13: .asciiz "\nLos numeros son:"
men14: .asciiz "\n\n"
men15: .ascii "\n\n\n----Seleccione Criterio de
Ordenamiento-----\n"
.ascii "|
|\n"
 .ascii "| 1- Ascendente
|\n"
.ascii "| 2- Descendente
|\n"
.ascii "| 3- Salir
|\n"
.asciiz "| Ingrese el valor:"

##########definicion de variables para el

programa#################

.text
.globl main

main:
li $v0, 4 # v0 = imprimir un string
la $a0, men1 # a0 = direccion men1
syscall #hago la llamada para imprimr la cadena

li $v0, 5 # v0 = lee un entero

syscall #hago la llamada para imprimr la cadena
move $t1, $v0 #mueve valor ingresado a un reg temp

beq $t1, 1, ordenar #eligió opcion 1

beq $t1, 2, salir #eligió opcion 2

li $v0, 4 # v0 = imprimir un string

la $a0, men8 # carga como argumento la cadena 8
syscall # hago la llamada para imprimr la
cadena

j main #elección errada

salir: #Fin del programa

li $v0, 4 # v0 = imprimir un string
la $a0, men7 # a0 = direccion men 7
syscall #hago la llamada para imprimr la
cadena

li $v0, 10 #v0=Fin del programa

syscall #hago la llamada para imprimr la
cadena

########################### Ordenar
###############################
#Diseñar un algoritmo que permita ordenar de mayor a menor o de
menor a mayor, según
#la selección del usuario, un vector de tamaño 10 de números
enteros que son generados
#aleatoriamente.
ordenar:
 la $t0, vec #$t0<-direccion base del arreglo, Carga
en Rd la dirección dir (no su contenido)
# la $t5, vec
la $s1, vec #$s1<-direccion base del arreglo, Carga
en Rd la dirección dir (no su contenido)
li $v0, 4 # v0 = imprimir un string
la $a0, men3 # carga como argumento men3
syscall # hago la llamada para imprimr la cadena

li $v0, 5 # v0 = lee un entero

syscall #hago la llamada para imprimr la cadena
move $t1, $v0 #mueve valor ingresado a un reg temp
addi $s0, $zero, 0 #controlar ciclo

loop1: beq $t1, $s0 select #va para fin sin t0=ti
addi $s0, $s0, 1 #incrementa en 1 a $s0
li $v0, 4 # llama al servicio de imprimir una
cadena
la $a0, men9 # carga como argumento men9
syscall # hago la llamada para imprimr la cadena
la $v0, 5 # v0 = lee un entero
syscall #hago la llamada para imprimr la cadena

move $t2, $v0 #mueve valor ingresado a un reg temp

sw $t2, 0($t0)#Almacena en vector de memoria el valor de t2
addi $t0, $t0, 4 #incrementa en 4 a t0 para ir al sgte
posicion del vector
j loop1 #retorna a la etiqueta loop1

select:
li $v0, 4 # v0 = imprimir un string
la $a0, men15 # a0 = direccion men15
syscall #hago la llamada para imprimr la cadena

li $v0, 5 # v0 = lee un entero

syscall #hago la llamada para imprimr la cadena
move $s2, $v0 #mueve valor ingresado a un reg temp
j Ordenar #retorna a la etiqueta Ordenar

Ordenar:
move $t0, $s1 #$t0<-direccion base del arreglo, Carga
en Rd la dirección dir (no su contenido)
addi $t2, $zero, 0 #se inicializa en 0 en el algoritmo
representa la i
addi $t3, $zero, 0 #se inicializa en 0 en el algoritmo
representa la j
addi $t4, $zero, 0 #se inicializa en 0 en el algoritmo
representa a minx
addi $t5, $zero, 0 #se inicializa en 0 en el algoritmo
representa a minj
addi $t6, $zero, 0 #
 addi $t6, $t1, -1 #t6=n-1
slt $t7, $t2, $t6 #i<(n-1)
beq $t7, $zero Fin1
# move $t2, $t0 #t2<-direccion base del arrego
j para1

para1: slt $t7, $t2, $t6 #i<(n-1)

beq $t7, $zero Finloop #t7=0 debe salir del ciclo max
externo según algoritmo
add $t5, $t2, $zero #minj=i
mul $t9, $t2, 4 #multiplico el indice del vec por
4
add $t9, $t0, $t9 #incremento la pos del vector 4veces
lw $t4, 0($t9) #minx=vec[i]
j vaimprimir #mostrara como va quedando el vector por
cada cambio de posicion

continuapara1:
slt $t7, $t3, $t1 #j<n
beq $t7, $zero,finpara2 # si no es j<n no debe hacer nada y
saltar al final de la pregunta segun algoritmo
move $t3, $t2 #copia el valor de t2 a t3
beq $s2, 1, paraAsce #eligió opcion 1
beq $s2, 2, paraDesc #eligió opcion 2
# j para2 #j=1 para2 ***************

#en este procedicimiento minx y minj se deben interpretar como

maxx y maxj
paraAsce: mul $t9, $t3, 4 #multiplico el indice del vec por
4
add $t9, $t0, $t9 #incremento la pos del vector 4veces
lw $t8, 0($t9) #$t8=a[j]
slt $t7, $t8, $t4 #vec[j] < minx
beq $t7, $zero, sino1
move $t5, $t3 #minj=j
move $t4, $t8 #minx=a[j]
# lw $t4, 0($t9) #minx=a[j]
addi $t3, $t3, 1
j paraAsce #
sino1:
addi $t3, $t3, 1
slt $t7, $t3, $t1 #j<n
beq $t7, $zero, finpara2
# addi $t3, $t3, 1
j paraAsce #
****************************

paraDesc: mul $t9, $t3, 4 #multiplico el indice del vec por 4

add $t9, $t0, $t9 #incremento la pos del vector 4veces
lw $t8, 0($t9) #$t8=a[j]
slt $t7, $t8, $t4 #vec[j] < minx
bne $t7, $zero, sino2
 move $t5, $t3 #minj=j
move $t4, $t8 #minx=a[j]
# lw $t4, 0($t9) #minx=a[j]
addi $t3, $t3, 1
j paraDesc #
sino2:
addi $t3, $t3, 1
slt $t7, $t3, $t1 #j<n
beq $t7, $zero, finpara2
# addi $t3, $t3, 1
j paraDesc #
****************************

finpara2: mul $t9, $t2, 4 #multiplico el indice del vec por 4

add $t9, $t0, $t9 #incremento la pos del vector
4veces

lw $t8, 0($t9) #a[i]

mul $t9, $t5, 4 #multiplico el indice del vec por 4
add $t9, $t0, $t9 #incremento la pos del vector
4veces
sw $t8, 0($t9) #a[minj]=a[i]

mul $t9, $t2, 4 #multiplico el indice del vec por 4

add $t9, $t0, $t9 #incremento la pos del vector
4veces

sw $t4, 0($t9) #a[i]=minx

move $t3, $t2
addi $t2, $t2, 1 #i+1

# mul $t9, $t2, 4 #multiplico el indice del vec por

4
# add $t9, $t0, $t9 #incremento la pos del vector
4veces
# addi $t2, $t2, 1 #i+1
# move $t2, $t9
j para1

Finloop:
li $v0, 4 # v0 = imprimir un string
la $a0, men2 # a0 = direccion men2
syscall #hago la llamada para imprimr la cadena
move $t0, $s1 #$t0<-direccion base del arreglo, Carga
en Rd la dirección dir (no su contenido)
addi $s0, $zero, 0 #controlar ciclo
j loop2

loop2: beq $t1, $s0, Fin1 #va para fin sin t0=ti
addi $s0, $s0, 1 #incrementa en 1 a $s0
lw $t2, 0($t0)
 li $v0, 1 # cargar el código adecuado sistema de
llamada en el registro $v0, codigo para imprimir enteros 1
move $a0, $t2 # move integer to be printed into $a0:
$a0 = $t2
syscall # hago la llamada para imprimr la cadena
li $v0, 4 # v0 = imprimir un string
la $a0, men12 # a0 = direccion men10
syscall #hago la llamada para imprimr la cadena
addi $t0, $t0, 4
j loop2

#borrar
vaimprimir:
li $v0, 4 # v0 = imprimir un string
la $a0, men10 # a0 = direccion men10
syscall #hago la llamada para imprimr la cadena

move $s5, $s1 #$s5<-direccion base del arreglo, Carga

en Rd la dirección dir (no su contenido)
addi $s6, $zero, 0 #controlar ciclo
j imprimir

imprimir: beq $t1, $s6, continuapara1 #va para fin sin s5=ti
addi $s6, $s6, 1 #incrementa en 1 a $s6
lw $s7, 0($s5)#lee de la direccion de memoria $s5 y la
almacena en $s7
li $v0, 1 # cargar el código adecuado sistema de
llamada en el registro $v0, codigo para imprimir enteros 1
move $a0, $s7 # move integer to be printed into $a0:
$a0 = $s7
syscall # hago la llamada para imprimr la cadena
li $v0, 4 # v0 = imprimir un string
la $a0, men12 # a0 = direccion men10
syscall #hago la llamada para imprimr la cadena
addi $s5, $s5, 4 #a s5 se le suma 4 para la proxima
posicion del vector
j imprimir #retorna a la etiqueta imprimir

Fin1:
j main