Laborator 2

Prob.1
#Sa se obtina in t3 valoarea [x/y]*{y/x}, x in t1, y, in t2 [] - catul, {} - restul

.data
.text
.main:
div $t1,$t2
mflo $t3
div $t2,$t1
mfhi $t2
mulo $t3,$t3,$t2
li $v0,10
syscall

Prob.2
#in t3 punem valoarea modul(x-y) x=t1, y=t2

.data
.text
.main:
sub $t1,$t1,$t2
abs $t3,$t1
li $v0,10
syscall

Prob.3
#Introduceti in t1 valoarea 0x25 folosind doar instructiuni logice

.data
.text
.main:
ori $t1,$0,0x25
li $v0,10
syscall

1
Prob.4
#In t0=1001000110100(binary). Vrem ca prin shiftare t2=1001000110100000

.data
.text
.main:
li $t0,0x1234
sll $t2, $t0, 3
li $v0,10
syscall

Prob.5 (cerinta ca la 4)
#t0=10010001101000101011001111000 . Prin shiftare t2=100100011010001010110011

.data
.text
.main:
li $t0,0x12345678
sll $t2, $t0,3
rol $t2,$t2,$t0
li $v0,10
syscall

Laborator 3

Prob. 1
#interschimba t1 si t2 unde t1=1, t2=2

.data
.text
main:
li $t1,1
li $t2,2
move $t3,$t1
move $t1,$t2
move $t2,$t3
li $v0,10
syscall

2
Prob. 2
#Calculati in var3=8*var1-[var2/16], var1=16, var2=31

.data
var1: .word 16
var2: .word 31
var3: .word 0
.text
main:
lw $s1,var1
lw $s2,var2
mulo $s3,$s1,8
div $s4,$s2,16
sub $s3,$s3,$s4
sw $s3,var3
li $v0,10
syscall

Prob. 3
# x,y,z-word,10,,11,12
# a) $t1=word x+4(doar cu x)
# b) stocati pe 2 octeti,la x+8 val 14

.data
x: .word 10
y: .word 11
z: .word 12
.text
main:
lw $t1,x+4
li $t2,14 (punctul b)
sh $t2,x+8
li $v0,10
syscall

Prob.4
#x eticheta la care se memoreaza 5 ca word
#Mamoreaza in x+4 valoarea functiei f=2x^2-4x+12

.data
x: .word 5
.text

3
 main:
lw $s1,x
mulo $s2,$s1,$s1
mulo $s2,$s2,2
mulo $s3,$s1,4
sub $s2,$s2,$s3
add $s2,$s2,12
sw $s2,x+4
li $v0,10
syscall

Laborator 4

Prob. 1
# Determinai dac intr-unul din regitrii $t1 - $t5 se gsete valoarea 7.
# Dac da, introducei valoarea 1 in registrul $t0. Dac nu, introducei valoarea 0 in registrul $t0.

.data
x:.word 5
y:.word 9
z:.word 10
.text
main:
lw $t1,x
lw $t2,y
lw $t3,z

li $t0,1

beq $t1,7,sfarsit
beq $t2,7,sfarsit
beq $t3,7,sfarsit
li $t0,0

sfarsit:
li $v0,10
syscall

4
Prob. 2
# Verificai dac numrul stocat in registrul $t1 este pozitiv. Dac da, punei 0 in registrul $t2.
# Dac nu, punei 1 in registrul $t2.

.data
x:.word -5
.text
main:

lw $t1,x
li $t2,0

bgez $t1,sfarsit
li $t2,1

sfarsit:
li $v0,10
syscall

Prob.3
# Declarai un ir oarecare de caractere. Determinai lungimea irului, prin parcurgerea i contorizarea
locaiilor de memorie, pn cnd intlnii caracterul delimitator de final.

.data
string:.asciiz "ana are mere."
.text
main:

la $a0,string
li $t0,-1 #elimina caracterul final: 0

citire:
lb $s1,($a0)
addi $a0,1
addi $t0,1
bnez $s1, citire

li $v0,10
syscall

5
Prob. 4
# Definii un vector de numere intregi de lungime cunoscut. Determinai suma elementelor pozitive din
vector.

.data
vector: .word 2 3 4 -2 1 -5
n:.word 6
.text
main:

la $s0,vector
lw $t0,n
li $t1,1
li $t3,0

loop:
beq $t0,$t1,end_loop
addi $t1,1
lw $t2, ($s0)
addi $s0,4
bltz $t2,loop
add $t3,$t3,$t2
b loop

end_loop:

li $v0,10
syscall

Prob. 5
# S se citeasc i s se afieze un vector de n elemente intregi, unde n este introdus de la tastatur. S se
afieze un meniu cu urmtoarele opiuni:
#1. Suma elementelor;
#2. Ultimul element;
#3. Elementele mai mari dect n;
#4. Ieire din program.

.data
string1:.asciiz "Dati numarul de elemente ale vectorului.\n"
string3:.asciiz "Dati elementele vectorului.\n"
string2:.asciiz "Vectorul este: "
alege:.asciiz "\n 1.Suma elementeleor;\n 2.Ultimul element; \n 3.Elementele mai mari decat n; \n
4.Iesire din program. \n "
n:.word 0
elem:.space 50
x:.word 0

6
.text
main:

li $v0,4
la $a0,string1
syscall

li $v0,5
syscall
sw $v0,n
lw $t0,n

li $t1,0

la $t2,elem

li $v0,4
la $a0,string3
syscall

loop:
beq $t0,$t1,end_loop
addi $t1,1

li $v0,5
syscall

sw $v0,($t2)
lw $t5,($t2)
add $t4,$t5,$t4
addi $t2,4
b loop

end_loop:

li $v0,4
la $a0,string2
syscall

li $t1,0
la $t2,elem

7
loop_afisare:

beq $t0,$t1,end_loop_afisare
addi $t1,1

lw $a0,($t2)
li $v0,1
syscall
addi $t2,4
b loop_afisare

end_loop_afisare:

li $t1,0
la $t2,elem

li $v0,4
la $a0,alege
syscall

li $v0,5
syscall
sw $v0,x
lw $t3,x
beq $t3,1,suma
beq $t3,2,ultimul
beq $t3,3,loop_afisare_mai_mare
beq $t3,4,sfarsit

suma:
move $a0,$t4
li $v0,1
syscall
b end_loop_afisare

ultimul:
move $a0,$t5
li $v0,1
syscall
b end_loop_afisare

8
loop_afisare_mai_mare:

beq $t0,$t1,end_loop_afisare_mai_mare
addi $t1,1
lw $s1,($t2)
addi $t2,4
blt $s1,$t0,loop_afisare_mai_mare
move $a0,$s1
li $v0,1
syscall
b loop_afisare_mai_mare

end_loop_afisare_mai_mare:

b end_loop_afisare

sfarsit:

li $v0,10
syscall

Laborator 5

Prob .1
# Pentru un sir de caractere cunoscut, s se determine irul de caractere obinut prin oglindirea irului
iniial. De exemplu: pentru irul sir se va obine ris. Utilizai operaiile PUSH i POP.

.data
string1: .asciiz "Dati sirul de caractere: "
string: .space 10
.text
main:

la $a0,string1
li $v0,4
syscall

li $v0,8
syscall

9
citire:
lb $s1,($a0)
addi $a0,1
subu $sp,$sp,1
sb $s1,0($sp)
bnez $s1,citire

addu $sp,$sp,1

la $a0,($sp)
li $v0,4
syscall

li $v0,10
syscall

Prob. 2
#Verificai dac un numr dat este palindrom. Utilizai stiva.

.data
nr:.word 0
string: .asciiz "Dati numarul: "
string1:.asciiz "Numarul este palindrom"
string2:.asciiz "Numarul nu este palindrom"
.text
main:
la $a0, string
li $v0,4
syscall

li $v0,5
syscall
sw $v0,nr
lw $t1,nr

subu $sp,$sp,4
sw $0,0($sp)

move $t2,$t1

loop:

rem $s1,$t2,10
subu $sp,$sp,4
sw $s1,0($sp)
div $t2,$t2,10
bnez $t2,loop

10
comparare:
lw $t0,0($sp)
addu $sp,$sp,4
rem $t3,$t1,10
bne $t3,$t0,sfarsit1
div $t1,$t1,10
bnez $t1,comparare

li $v0,4
la $a0,string1
syscall

li $v0,10
syscall

sfarsit1:
li $v0,4
la $a0,string2
syscall

li $v0,10
syscall

Prob. 3
# Fie irul urmtor definit recursiv:
a1 = 1;
a2 = 2;
an = 3*an-2 + an-1.
Determinai al 5-lea element al irului, folosind o subrutin care primete 2 termeni consecutivi i
intoarce urmtorul element al irului.

.data
string: .asciiz "an = ? , dati n: "
x1:.word 1
x2:.word 2
n:.word 0
.text

calcul:
move $t0,$a0
move $t1,$a1
mulo $t3,$t0,3
add $t3,$t3,$t1
move $v0,$t3
jr $ra

11
main:

la $a0, string
li $v0,4
syscall

li $v0,5
syscall
sw $v0,n
lw $s0,n

lw $a0,x1
lw $a1,x2

sub $s0,$s0,2

loop:
jal calcul
move $a0,$a1
move $a1,$v0
sub $s0,$s0,1
bnez $s0,loop

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

li $v0,10
syscall

Prob. 4
# Determinati lungimea maxima a unei secvente de caractere repetitive dintr-un sir de caractere. De
exemplu pentru sirul aaabbcdddee se va intoarce 3, fiindca aaa si ddd au lungimea maxima,
egala cu 3.

.data
sir: .asciiz "ddddeeeaaaaa"
.text

main:
la $s0,sir
li $s1,0

12
loop:
la $a0,($s0)
jal max
move $s2,$v0
add $s0,$s0,$s2
bge $s1,$s2,salt
move $s1,$s2
salt:
lb $s4,($s0)
bnez $s4,loop

li $v0,10
syscall

max:
la $t0,($a0)
li $t1,0
loop2:
add $t1,$t1,1
lb $t2,($t0)
lb $t3,1($t0)
bne $t2,$t3,sar
add $t0,$t0,1
b loop2
sar:
move $v0,$t1
jr $ra

Prob. 5
# Se citesc de la consol un numr natural i o cifr. S se afieze Da dac printre cifrele numrului
citit se gsete aceast cifr i Nu n caz contrar.

.data
string1: .asciiz "Dati numarul: "
string2: .asciiz "Dati cifra: "
nr:.word 0
x:.word 0
r1:.asciiz "DA"
r2:.asciiz "NU"
.text

cauta:
move $t1,$s1
move $t0,$s0

13
 loop:
rem $t2,$t0,10
div $t0,$t0,10
seq $t3,$t1,$t2
bnez $t3,sfarsit
bnez $t0,loop
sfarsit:
move $v0,$t3
jr $ra

main:

la $a0, string1
li $v0, 4
syscall

li $v0,5
syscall
sw $v0,nr
lw $s0,nr

la $a0, string2
li $v0, 4
syscall

li $v0,5
syscall
sw $v0,x
lw $s1,x

jal cauta

move $s2,$v0

bnez $s2,sfarsit1
beqz $s2,sfarsit2

sfarsit1:

la $a0,r1
li $v0,4
syscall

li $v0,10
syscall

14
sfarsit2:

la $a0,r2
li $v0,4
syscall

li $v0,10
syscall

Prob. 6
# S se determine dac o matrice are numai elemente impare pe diagonala principal.

.data
n : .word 3
m : .word 3
matrice: .word 1 2 3 5 5 6 7 8 9
string1: .asciiz "Da"
string2: .asciiz "Nu"
.text
b main
subrutina:
lw $t0,n
lw $t1,m
la $t2,matrice
li $t3,0
li $t4,0
li $t5,1
loop:
li $t3,0
loop2:
bne $t3,$t4,pop
lw $t6,($t2)
rem $t6,$t6,2
bnez $t6,pop
li $t5,0

pop:
add $t3,$t3,1
beq $t3,$t1,loop3
add $t2,$t2,4
b loop2
loop3:
add $t4,$t4,1
beq $t4,$t0,stop
b loop

15
stop:
move $v0,$t5
jr $ra
main:
jal subrutina
move $s0,$v0
li $s1,1
bne $s0,$s1,pam
li $v0,4
la $a0,string1
syscall
pam:
beq $s0,$s1,pa
li $v0,4
la $a0,string2
syscall
pa:
li $v0,10
syscall

Prob.7
# Ordonai cresctor un vector de numere ntregi.

.data
vector:.space 30
n:.word 0
string1:.asciiz "Dati n: \n"
string2:.asciiz "Dati elementele vectorului: \n"
string3:.asciiz "Elementele ordonate sunt: \n"
.text

citire:
move $t1,$s1
li $t2,0
loop:
addi $t2,1
li $v0,5
syscall
sw $v0,vector($t0)
addi $t0,4
bne $t2,$t1,loop
jr $ra

16
afisare:
li $t2,0
li $t0,0
move $t1,$s1
loop1:
addi $t2,1
lw $a0,vector($t0)
li $v0,1
syscall
addi $t0,4
bne $t2,$t1,loop1
jr $ra

sortare:
li $t0,0
mulo $t0,$s2,4
move $t2,$s2
move $t3,$s3
move $t1,$s1
loop3:
beq $t2,$t1,end_loop3
addi $t2,1
lw $t4,vector($t0)
move $t5,$t0
addi $t0,4
blt $t3,$t4,loop3
sw $t3,vector($t5)
sw $t4,vector($s0)
b loop3
end_loop3:
jr $ra

main:
li $v0,4
la $a0,string1
syscall

li $v0,5
syscall
sw $v0,n
lw $s1,n

li $v0,4
la $a0,string2
syscall

17
jal citire

li $s2,0
li $s0,0

loop2:
addi $s2,1
lw $s3,vector($s0)
jal sortare
addi $s0,4
bne $s2,$s1,loop2

li $v0,4
la $a0,string3
syscall

jal afisare

li $v0,10
syscall

Laborator 6(1)

Prob.1
#1. Se citesc de la tastatur:
- un numr natural n;
- o matrice ptratic n x n, element cu element;
- 2 numere 1 l1, l2 n;

Se cere:
- sa se interschimbe n memorie elementele de pe liniile l1 i l2.
- s se afieze rezultatul la consol.

.data
matrice:.space 400
n:.word 0
string1:.asciiz "Dati n: \n"
string2:.asciiz "Dati elemetentele: \n"
string3:.asciiz "Dati prima linie: \n"
string4:.asciiz "Dati a doua linie: \n"
enter:.asciiz "\n"
l1: .word 0
l2: .word 0

18
.text

citire:
move $t1,$s0
li $t0,0
li $t2,0
loop:
addi $t2,1
li $v0,5
syscall
sw $v0,matrice($t0)
addi $t0,4
bne $t2,$t1,loop
jr $ra

afisare:
move $t1,$s0
li $t0,0
li $t2,0
li $t3,0
lw $t4,n
loop2:
beq $t2,$t1,end_loop2
li $v0,1
lw $a0,matrice($t0)
syscall
addi $t0,4
addi $t2,1
addi $t3,1
bne $t3,$t4,loop2
li $v0,4
la $a0,enter
syscall
li $t3,0
b loop2
end_loop2:
jr $ra

interschimbare:
lw $t0,n
lw $t1,l1
lw $t2,l2
sub $t1,1
sub $t2,1

19
 multu $t1,$t0
mflo $t1
multu $t2,$t0
mflo $t2
li $t3,4
multu $t1,$t3
mflo $t1
multu $t2,$t3
mflo $t2
li $t5,0
loop1:
lw $t3,matrice($t1)
lw $t4,matrice($t2)
sw $t3,matrice($t2)
sw $t4,matrice($t1)
addi $t5,1
addi $t1,4
addi $t2,4
bne $t5,$t0,loop1
jr $ra

main:

li $v0,4
la $a0,string1
syscall
li $v0,5
syscall
sw $v0,n

li $v0,4
la $a0,string2
syscall
lw $s0,n
mulo $s0,$s0,$s0
jal citire

li $v0,4
la $a0,string3
syscall
li $v0,5
syscall
sw $v0,l1

20
li $v0,4
la $a0,string4
syscall
li $v0,5
syscall
sw $v0,l2

jal interschimbare

lw $s0,n
mulo $s0,$s0,$s0

jal afisare

li $v0,10
syscall

Prob.2
# Se citesc de la tastatur:
- un numr natural n;
- un vector de n elemente, element cu element;
- o putere p;

Se cere:
- o subrutin care s calculeze puterea p a unui numr;
- folosind subrutina, s se determine suma puterilor p corespunzatoare elementelor vectorului;
- s se afieze rezultatul la consol.

.data
n:.word 0
vector:.space 100
p:.word 0
string1:.asciiz "Dati n: \n"
string2:.asciiz "Dati elementele: \n"
string3:.asciiz "Dati puterea: \n"
.text

putere:
move $t0,$s5
move $t1,$s4
li $t2,1
loop:
mulo $t1,$t1,$t1
addi $t2,1
bne $t2,$t0,loop
move $v0,$t1
jr $ra

21
main:

li $v0,4
la $a0,string1
syscall
li $v0,5
syscall
sw $v0,n

li $v0,4
la $a0,string2
syscall
li $s0,0
lw $s1,n
li $s2,0

citire:
addi $s2,1
li $v0,5
syscall
sw $v0,vector($s0)
addi $s0,4
bne $s2,$s1,citire

li $v0,4
la $a0,string3
syscall
li $v0,5
syscall
sw $v0,p

li $s0,0
li $s2,0
li $s3,0
lw $s5,p
lw $s1,n

calcul:
addi $s2,1
lw $s4,vector($s0)
jal putere
move $s6,$v0
addi $s0,4
add $s3,$s3,$s6
bne $s2,$s1,calcul

22
li $s0,0
li $s2,0
lw $s1,n

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

li $v0,10
syscall

Prob.3
#Se citesc de la tastatur:
- un numr n;
- un ir de caractere de lungime maxim n;

Se cere:
- o subrutina care s nlocuiasc n memorie a cu A i A cu a;
- s se apeleze subrutina pentru irul citit;
- s se afieze rezultatul la consol;

#ATENTIE: Eu am facut problema generala si imi defineam la inceput

# cele doua caractere care ar trebui inlocuite.

.data
n:.word 0
string:.space 100
string1:.asciiz "c"
string4:.asciiz "C"
string2:.asciiz "Dati n:\n"
string3:.asciiz "Dati sirul de caractere:\n"

.text

inlocuire:
li $t0,0
lb $t2,string1($t0) # incarc in t2 c
lb $t3,string4($t0) # incarc in t3 C
li $t1,1
loop:
beqz $t1,end_loop #conditia de oprire in caz de se ajunge la sf sirului
lb $t1,string($t0) #incarc in $t1 primul element din sir, iar la urmatoarea executare a buclei se va
incarca al doilea...si tot asa
move $t5,$t0 #salvez in t5 adresa primului element din sir(dupa fiecare bucla va deveni
urmatorul) pentru a putea face inlocuirea
addi $t0,1 #trec la urmatorul element din sir

23
 bne $t1,$t2,loop1 # verific daca elementul din sir este egal cu c, iar daca nu, sar la loop1
lb $t4,string($t5) #incarc in $t4 ce se afla la adresa lui t5..in cazul nostru c
sub $t4,32 #pentru a transforma c in C trebuie scazut 32 (ascii)
sb $t4,string($t5) #pun pe adresa lui t5 din sir litera transformata
b loop # reiau de la capat
loop1:
bne $t1,$t3,loop #verific daca elementul din sir este egal cu C
lb $t4,string($t5) #incarc ce se afla la adresa lui $t5 in $t4
addi $t4,32 #pentru a transforma C in c trebuie adunat 32
sb $t4,string($t5) #si stochez C pe adresa lui $t5
b loop
end_loop:
jr $ra

main:

li $v0,4
la $a0,string2
syscall
li $v0,5
syscall
sw $v0,n

li $v0,4
la $a0,string3
syscall

la $a0,string
li $v0,8
syscall

jal inlocuire

li $v0,4
la $a0,string
syscall

li $v0,10
syscall

24
 Laborator 6(2)
Prob.1
# Se citesc de la tastatur:
- un numr natural n;
- o matrice ptratic n x n, element cu element;

Se cere:
- o subrutin care s calculeze suma elementelor de pe diagonala principal;
- s se apeleze subrutina pentru matricea citit;
- s se afieze rezultatul la consol;

.data
matrice:.space 200
n:.word 0
string1:.asciiz "Dati n: \n"
string2:.asciiz "Dati elementele:\n"
.text

calcul:
lw $t1,n
lw $t3,n
li $t0,0
li $t2,0
addi $t3,1
mulo $t3,$t3,4
loop:
mulo $t4,$t3,$t2
lw $t0,matrice($t4)
addi $t2,1
add $t5,$t5,$t0
bne $t2,$t1,loop
move $v0,$t5
jr $ra

main:

li $v0,4
la $a0,string1
syscall

li $v0,5
syscall
sw $v0,n

25
li $v0,4
la $a0,string2
syscall

lw $s1,n
mulo $s1,$s1,$s1
li $s0,0
li $s2,0

citire:
addi $s2,1
li $v0,5
syscall
sw $v0,matrice($s0)
addi $s0,4
bne $s2,$s1,citire

jal calcul

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

li $v0,10
syscall

Prob.2
# Se citesc de la tastatur:
- un numr natural n;
- un vector de n elemente, element cu element;

Se cere:
- o subrutina care sa calculeze factorialul unui numr;
- folosind subrutina, s se determine suma factorialelor elementelor vectorului;
- s se afieze rezultatul la consol.

.data
vector:.space 100
n:.word 0
string1:.asciiz "Dati n:\n"
string2:.asciiz "Dati elementele: \n"
.text

26
factorial:
move $t0,$s3
li $t1,1
loop:
mulo $t1,$t1,$s3
sub $s3,1
bnez $s3,loop
move $v0,$t1
jr $ra

main:

li $v0,4
la $a0,string1
syscall
li $v0,5
syscall
sw $v0,n

li $v0,4
la $a0,string2
syscall

lw $s1,n
li $s0,0
li $s2,0

citire:
addi $s2,1
li $v0,5
syscall
sw $v0,vector($s0)
addi $s0,4
bne $s2,$s1,citire

li $s2,0
li $s0,0
li $s4,0

calcul:
addi $s2,1
lw $s3,vector($s0)
jal factorial
add $s4,$s4,$v0
addi $s0,4
bne $s2,$s1,calcul

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

li $v0,10
syscall

Prob.3
#3. Se citesc de la tastatur:
- un numr n;
- un cuvnt de lungime maxim n care conine numai majuscule (textul clar);
- un numr k (cheia de criptare);

Se cere:
- o subrutin care sa ntoarc textul criptat corespunztor (fiecare liter este nlocuit cu litera aflat n
alfabet peste k poziii, considernd alfabetul circular: A> B > ... > Y > Z > A);
- s se apeleze subrutina pentru irul citit;
- s se afieze rezultatul la consol;

.data
string:.space 100
n:.word 0
k:.word 0
string1:.asciiz "Dati n: \n"
string2:.asciiz "Dati cuvantul de lungime n: \n"
string3:.asciiz "Dati cheia de criptare: \n"
.text

criptare:
li $t0,0
lw $t3,k
loop:
lb $t1,string($t0)
move $t2,$t1
add $t1,$t1,$t3
sb $t1,string($t0)
addi $t0,1
bnez $t2,loop
jr $ra
main:

li $v0,4
la $a0,string1
syscall

28
li $v0,5
syscall
sw $v0,n

li $v0,4
la $a0,string2
syscall

la $a0,string
li $v0,8
syscall

li $v0,4
la $a0,string3
syscall

li $v0,5
syscall
sw $v0,k

jal criptare

li $v0,4
la $a0,string
syscall

li $v0,10
syscall

29