## Laboratorio 5 li $a0,10

syscall #imprime un line feed

# ===============================================
# ==================Prob1======================== # ================

# falta li $t0,95020
.data li $a0,1
str: move $a0,$t0
syscall
.asciiz "Hola a todos"
.asciiz "Welcomes to MIPS - Iván Panta"
li $v0,11
.globl main # especifica a main como un símbolo global li $a0,10
.text syscall #imprime un line feed

main:
li $t1,"U"
li $v0, 4 # llamada al sistema para imprimir cadena li $v0,11
la $a0, str # dirección de la cadena a imprimir move $a0,$t1
syscall # imprime la cadena syscall
li $v0, 10 # llamada al sistema para terminar y
syscall # salir
li $v0,10 # llamaa al sistema para terminar
# =============================================== syscall # termina
# ===================Prob2=======================
# ==============================================
.data # ====================Prob3=====================
str: # Código ok

.asciiz "Hola a todos" # Suma de los números 7 y 8

.asciiz "Welcomes to MIPS - Iván Panta"
.text
.globl main # especifica a main como un símbolo global .globl main # se empieza la ejecución en main
.text
main:
main:
li $t1, 7 # carga 7 en $t1.
li $v0, 4 # llamada al sistema para imprimir cadena add $t0, $t1, 8 # calcula la suma de $t1 y 8, y lo guarda en
la $a0, str # dirección de la cadena a imprimir $t0.
syscall # imprime la cadena
li $v0, 10 # llamada al sistema para terminar y li $v0,4
syscall # salir la $a0,nom
# =============================================== syscall
# ====================Prob2v=====================
li $v0,1
# falta move $a0,$t0
syscall
# (1) Imprime un entero
li $v0,1 li $v0,10 # syscall code 10 es para "exit".
li $a0,25 syscall

syscall #imprime el valor 25 .data

#(2) Imprime un caracter nom:

li $v0,11
.asciiz "El resultado es: " syscall # hace el syscall.
move $t1, $v0 # muevo el número leido en $t1.
# ==============================================
# ====================Prob4===================== ## pone el mas grande de $t0 y $t1 en $t2.
bgt $t0, $t1, t0_smaller # si $t0 < $t1, branch a t0_bigger,
# Código ok move $t2, $t1 # de otro modo, copia $t1 a $t2.
b endif # y luego salta a endif
.text
.globl main t0_smaller:
move $t2, $t0 # copia $t0 a $t2
main: endif: ## Imprime $t2.

li $v0,5
syscall move $a0, $t2 # muevo el número a imprimir en $a0.
move $t1,$v0 li $v0, 1 # carga el modo de impresión de un entero en $v0.
syscall # hace el syscall.
li $v0,5
syscall li $v0, 10 # salida.
move $t2,$v0 syscall # hace el syscall.
# ==============================================
# ====================Prob5=====================
add $t0,$t1,$t2

li $v0,4 # Falta
la $a0,nom
syscall main:
## Consigue el primer número desde el usuario, y lo pone
li $v0,1 en $t0.
move $a0,$t0 li $v0, 5 # carga el modo lectura de syscall en $v0.
syscall syscall # hace el syscall.
move $t0, $v0 # muevo el número leido en $t0.
li $v0,10 # syscall code 10 es para "exit".
syscall ## Consigue el segundo número desde el usuario, y lo pone
en $t1.
.data li $v0, 5 # carga el modo lectura de syscall en $v0.
syscall # hace el syscall.
nom: move $t1, $v0 # muevo el número leido en $t1.

.asciiz "El resultado es: " ## pone el mas grande de $t0 y $t1 en $t2.
# =============================================== bgt $t0, $t1, t0_smaller # si $t0 < $t1, branch a t0_bigger,
# ====================Prob5====================== move $t2, $t1 # de otro modo, copia $t1 a $t2.
b endif # y luego salta a endif

# Falta t0_smaller:
move $t2, $t0 # copia $t0 a $t2
main: endif: ## Imprime $t2.
## Consigue el primer número desde el usuario, y lo pone
en $t0.
li $v0, 5 # carga el modo lectura de syscall en $v0. move $a0, $t2 # muevo el número a imprimir en $a0.
syscall # hace el syscall. li $v0, 1 # carga el modo de impresión de un entero en $v0.
move $t0, $v0 # muevo el número leido en $t0. syscall # hace el syscall.

## Consigue el segundo número desde el usuario, y lo pone li $v0, 10 # salida.

en $t1. syscall # hace el syscall.
li $v0, 5 # carga el modo lectura de syscall en $v0.
# ============================================== syscall
# ====================Prob6=====================
move $a0,$t3
## Codigo ok li $v0,1
syscall
## Inicializamos el mínimo y el máximo con a{0}
## Y luego vamos verificando a través del arreglo (count-1) .data
veces array: .word 53,9,77,66,12,115,18,26,44,14,19,78,8,12,13
## $t0 es un apuntador de cada elemento del arreglo count: .word 15
## $t1 guarda la cantidad de elementos del arreglo ans1: .asciiz " Min: = "
## $t2 guarda el valor mínimo endl: .asciiz "\n"
## $t3 guarda o contiene el valor máximo ans2: .asciiz "max = "
## $t4 guarda el valor siguiente del arreglo
# ============================================
.text # ============================================
.globl __start
__start: # ej_fibonacci.asm
# Calcula el noveno termino de la serie de fibonacci
la $t0, array # f(n)=f(n-1)+f(n-2)
lw $t1, count # El noveno termino de la serie :
lw $t2,($t0) # inicializo con el valor mínimo 1,1,2,3,5,8,13,21,34,55,..... es 34
lw $t3,($t0)
add $t0,$t0,4 #el puntero aqui va a empezar en a {1} .text
add $t1,$t1,-1 #Decremento el contador , $t1=$t1-1 .globl main
main:
loop: li $t0, 1 # usa $t0 para almacenar f(n-2)
lw $t4,($t0) #Carga la palabra siguiente desde el li $t1, 1 # usa $t1 para almacenar f(n-1)
arreglo li $t8, 0 # empieza el loop
bge $t4,$t2,notMin loop:
move $t2,$t4 bge $t8, 7, loopexit # si $t8 >= 7, sale a loopexit

notMin: add $t2, $t0, $t1 # Usa $t2 para almacenar

ble $t4,$t3, notMax f(n)
move $t3,$t4 move $t0, $t1 # $t0 va almacenar ahora el
contenido de $t1
notMax: move $t1, $t2 # $t1 va almacenar ahora el
add $t1,$t1,-1 contenido de $t2
add $t0,$t0,4
bnez $t1,loop addi $t8, $t8, 1 # Incrementa el contador en $t8
b loop # salta a loop
la $a0,ans1 loopexit:
li $v0,4 la $a0,ans1
syscall li $v0,4
syscall
move $a0,$t2
li $v0,1 move $a0,$t2
syscall li $v0,1
syscall
#==
la $a0,endl li $v0,10 # termina y sale del
li $v0,4 programa
syscall syscall

la $a0,ans2 .data
li $v0,4 ans1: .asciiz "El noveno termino de la serie es :"
 li $v0,1
# ============================================== syscall # imprime el valor minimo
# ==============================================
la $a0,ans2
## minmax.asm - imprime el minimo y maximo de los li $v0,4
elementos de un arreglo. syscall # imprime "max = "
##
## Asume que el arreglo tiene al menos dos elementos move $a0,$t3
(a[0] li $v0,1
## and a[1]). Inicializa el min y max a a[0] syscall # imprime el valor maximo
## y luego se repite el lazo (count-1) veces.
## Este programa usará punteros. la $a0,endl # llama al sistema para imprimir
## li $v0,4 # una nueva línea
## t0 - apunta a los elementos del arreglo syscall
## t1 - contiene la cantidad de elementos
## t2 - contiene el min li $v0,10
## t3 - contiene el max syscall # termina la ejecución del programa
## t4 - cada palabra del arreglo
## ################################################
################################################ # #
# segmento de texto # # segmento de datos #
# # # #
################################################ ################################################
# #

.text .data
.globl __start array: .word 53,9,77,66,12,115,18,26,44,14,19,78,8,12,13
__start: count: .word 15
la $t0,array # $t0 apuntará a los elementos endl: .asciiz "\n"
lw $t1,count # exit loop when $t1 is 0 ans1: .asciiz "min = "
lw $t2,($t0) # inicializa el minimo ($t2) ans2: .asciiz "\nmax = "
lw $t3,($t0) # y maximo ($t3) a a[0]
add $t0,$t0,4 # puntero va empezar en a[1] ##
add $t1,$t1,-1 # y se repite count-1 veces ## fin del archivo minmax.asm
# =============================================
# =============================================
loop: lw $t4,($t0) # carga siguiente palabra desde el ## promedio_numeros.asm - imprime la suma y el
arreglo promedio de los elementos de un arreglo.
bge $t4,$t2,notMin .data
# salta si a[i] >= min datos: .word 10, 5, 12, 9, 3, 4, 55, 22, 17, 9, 15 # 11
move $t2,$t4 # se mueve a[i] a minimo(es un enteros
nuevo minimo) n: .word 11
notMin: ble $t4,$t3,notMax adicion:.asciiz "La suma es :"
# salta si a[i] <= max promedio: .asciiz "El promedio es :"
move $t3,$t4 # se mueve a[i] a maximo(es un suma: .word 0
nuevo maximo) prom: .word 0
notMax: add $t1,$t1,-1 # decrementa contador nlinea: .asciiz "\n"
add $t0,$t0,4 # incrementa puntero por palabra
bnez $t1,loop # y continua si contador>0 .text
la $t0, datos # t0 apunta a
la $a0,ans1 datos[0]
li $v0,4 la $t1, n # t1 apunta a n
syscall # imprime "min = " lw $t1, ($t1) # t1 tiene el valor
de n
move $a0,$t2 li $s0, 0 # suma = 0
 # Calcula la suma de los datos ##
ciclo: ## fin del archivo promedio_numeros.asm
lw $t2, ($t0) # t2 = datos[t0]
add $s0, $s0, $t2 # suma = suma + ===========================
datos[t0] ############################
addi $t0, $t0, 4 # t0 = t0 + 4 (siguiente ============================
elemento de datos)
addi $t1, $t1, -1 #n=n-1 .data
bgtz $t1, ciclo # if (n > 0) goto ciclo str:

# Guarda la suma en la variable suma .asciiz "Hola a todos"

la $t1, suma # t1 apunta a suma .asciiz "Welcomes to MIPS - Iván Panta"
sw $s0, ($t1) # Memoria[t1] = s0 .globl main # especifica a main como un símbolo global
.text
# Calcula el promedio
la $t1, n # t1 apunta a n main:
lw $t1, ($t1) # t1 tiene el valor
de n li $v0, 4 # llamada al sistema para imprimir cadena
div $s0, $t1 # prom = suma / n la $a0, str # dirección de la cadena a imprimir
mflo $s0 # s0 = suma / n syscall # imprime la cadena
mfhi $s1 # s1 = suma % n li $v0, 10 # llamada al sistema para terminar y
syscall # salir
# Guarda el promedio en la variable prom
la $t1, prom # t1 apunta a prom
sw $s0, ($t1) # Memoria[t1] = s0
#Imprime la suma
la $a0,adicion # imprime
li $v0,4 # mensaje
syscall

la $s0,suma .data
lw $t1,($s0)
move $a0,$t1 str:
li $v0,1 #
syscall .asciiz "Hola mundo"
.text
la $a0,nlinea # nueva linea
li $v0,4 # main:
syscall
#Imprime el promedio li $v0, 4 # llamada al sistema para print_str
la $a0,promedio # imprime la $a0, str # dirección del string a imprimir
li $v0,4 # mensaje syscall # imprime el string
syscall li $v0, 10 # llamad

la $s0,prom
lw $t1,($s0)
move $a0,$t1
li $v0,1 #
syscall

# El programa se ha terminado. Sale.

li $v0, 10
syscall # Sale