1. Sa se scrie programul urmator în forma hexadecimala si apoi în forma binara.

00:load R0,stop_string || 00: 20 16 || 00000000: 00100000 00100100

02:load R1,start_string || 02: 21 14 || 00000010: 00100001 00010100
04:load R2,1 || 04: 22 01 || 00000100: 00100010 00000001
06:load R3,[R1] || 06: D0 31 || 00000110: 11010000 00110001
08:move RF,R3 || 08: 40 3F || 00001000: 01000000 00111111
salt: 0A:addi R1,R1,R2 || 0A: 51 12 || 00001010: 01010001 00010010
0C:addi R1,R1,R2 || 0C: 51 12 || 00001100: 01010001 00010010
0E:jmpEQ R0=R1 stop || 0E: B1 12 || 00001110: 10110001 00010010
10:jmp salt || 10: B0 0A || 00010000: 10110000 00001010
stop: 12:halt || 12:C0 00 || 00010010 :11000000 00000000
start_string:db “sir de caractere” || 14: 73 69 72 20 64 65 20 63 61 72 61 63 74 65 72 65
stop_string:db 0x0 || 16: 00

2. Se da urmatorul program scris în forma hexadecimala. Sa se convereteasca in limbaj de

asamblare.

00:20 0A || 00:load R0,0x0A

02:21 01 || 02:load R1,0x01
04:22 01 || 04:load R2,0x01
06:23 18 || 06:load R3,0x18
08:24 19 || 08:load R4,0x19
0A:54 43 || salt:0A:addi R4,R4,R3
0C:53 32 || 0c:addi R3,R3,R2
0E:51 12 || 0E:addi R1,R1,R2
10:40 1F || 10:move RF,R1
12:B1 16 || 12:jmpEQ R1=R0,stop
14:B0 0A || 14:jmp salt
16:C0 00 || stop:16:halt

3. Sa se scrie un program in limbaj de asamblare care sa adune numerele 1d, 2d, 0x02,
-1d, 0000 1010b. Toate numerele vor fi transformate in format hexazecimal. Rezulatul va
fi plasat in registrul RB. Ce valoare va contine registrul RB.

00:load R1,1d
02:load RB,0
04:addi RB,RB,R1
06:load R1,2d
08:addi RB,RB,R1
0A:load R1,0x02
0C:addi RB,RB,R1
0E:load R1,-1d
10:addi RB,RB,R1
12:load R1,00001010b
14:addi RB,RB,R1
16:halt
5. Sa se scrie un program in limbaj de asamblare care sa calculeze primii 5 termeni ai
unei progresii aritmetice de ratie 2. Primul termen este considerat 4. Rezultatele vor fi
asezate pe rand in registrul RE. ----- AIA 10202
00:load RE,4d
02:load R2,2d
04:addi RE,RE,R2
06:addi RE,RE,R2
08:addi RE,RE,R2
0A:addi RE,RE,R2
0C:halt

6. Sa se scrie un program in limbaj de asamblare care sa calculeze primii 5 termeni ai

unei progresii aritmetice de ratie 7. Primul termen este considerat 7. Rezultatele vor fi
asezate in registri incepand cu registrul R1.

load R1,7
load R6,7
addi R2,R1,R6
addi R3,R2,R6
addi R4,R3,R6
addi R5,R4,R6

7. Sa se scrie un program in limbaj de asamblare care sa calculeze primele 6 elemente

din sirul lui Fibbonaci si sa se afiseze folosind registrul RF.

load R1,0x00
load R2,0x01
addi R3,R1,R2
addi R4,R2,R3
addi R5,R3,R4
addi R6,R4,R5

8.Sa se scrie un program in limbaj de asamblare care sa afiseze de la inceput la sfarit si

de la sfarsit la inceput sirul de caractere ascii aflate in memorie. Sirul este descris mai
jos. Se cunosc adresa de inceput si caracterul care termina sirul.
start_sir db “luna”
db 0h

00:load R1,start_sir
02:load R0,0
04:load R2,1
06:load R3,-1
08:bucla: load RF,[R1]
0A:jmpEQ RF=R0,bucla2
0C:addi R1,R1,R2
0E:jmp bucla
10:bucla2:addi R1,R1,R3
12:load RF,[R1]
14:jmpEQ RF=R0,stop
16:jmp bucla2
18:stop: halt
1A:start_sir: db "luna"
1C:stop_sir: db 0h

9. Sa se scrie un program in limbaj de asamblare care sa numere de cate ori apare

caracterul "a" in urmatorul sir de caractere aflat in memorie.”zdreanta cel cu ochii de
faianta”.
00:load R1,text
02:load R2,1
bucla: 04:load R3,[R1]
06:load R0,0X61
08:jmpEQ R3=R0,inc
0A:load R0,0
0C:jmpEQ R3=R0,stop
0E:addi R1,R1,R2
10:jmp bucla
inc:12:addi R5,R5,R2
14:addi R1,R1,R2
16:jmp bucla
18:stop:halt
1A:text: db "zdreanta cel cu ochii de faianta"

10. Sa se copieze sirul de mai jos in memorie incepand cu adresa E0h din 2 in 2 caractere.
start_sir: db “acesta este un program care demonstreaza afisarea sirurilor”
00:load R1,start_sir
02:load R0,0
04:load R2,1
06:load R3,2
08:load R4,0xE0
bucla: 0A: load R5,[R1]
0C: jmpEQ R5=R0,stop
0E: store R5,[R4]
10: addi R1,R1,R3
12: addi R4,R4,R2
14: jmp bucla
stop: 16: halt
start_sir: 18: db "acesta este un program care demonstreaza afisarea sirurilor"

11. Sa se copieze invers(de la coada la cap) sirul urmator, in memorie, incepand cu

adresa A0h.
start_sir: db “acesta este un program care demonstreaza afisarea sirurilor”
00:load R1,start_sir
02:load R0,0
04:load R2,1
06:load R3,-1
08:load R4,0xA0
0A:bucla1:load R5,[R1]
0C: jmpEQ R5=R0,bucla2
0E: addi R1,R1,R2
10: jmp bucla1
bucla2:12:addi R1,R1,R3
14: load R5,[R1]
16: jmpEQ R5=R0,stop
18: store R5,[R4]
1A: addi R4,R4,R2
1C: jmp bucla2
stop:1E: halt
start_sir:20: db "acesta este un program care demonstreaza afisarea sirurilor"

12. Sa se scrie un program in limbaj de asamblare care sa numere cuvintele din urmatorul
sir de caractere. Cuvintele sunt subsiruri de caractere despartite de unul sau mai multe
caractere " ".
“Sa vedem cum ar trebui codificate instructiunile unui calculator obisnuit.”
00: load R1,text
02: load R4,1
04: load R3,1
06: load R2,0
08: load R7,0
bucla:0A: move RA,R7
0C: load R7,[R1]
0E: load R0,0
10: jmpEQ R7=R0,iesi
12: load R0,00100000b
14: jmpEQ R7=R0,buc3
16: addi R1,R1,R3
18: jmp bucla
buc3:1A: addi R1,R1,R3
1C: jmpEQ RA=R0,bucla
1E: jmp inc
inc:20: addi R2,R2,R3
22: addi R1,R1,R3
24: jmp bucla
iesi:26: addi R2,R2,R3
28: halt
text:2A: db "Sa vedem cum ar trebui codificate instructiunile unui calculator obisnuit."
13. Sa se copieze primele sase caractere din sirul urmator in memorie incepand cu adresa
D0h. Programul sa fie scris in memorie incepand cu adresa 0x60.
start_sir: db “ sir citit de la inceput - tisrafs al ed titic ris”
db 0h

60: org 0x60

62: load R1,start_sir
64: load R2,1
66: load R3,0xD0
68: load R0,6
6A: load R5,0
bucla:6C: load R4,[R1]
6E: store R4,[R3]
70: addi R1,R1,R2
72: addi R3,R3,R2
74: addi R5,R5,R2
76: jmpEQ R5=R0,exit
78: jmp bucla
exit:7A: halt
start_sir:7C: db "sir citit de la inceput - tisrafs al ed titic ris"

14. Sa se copieze din sirul de mai jos in registrii de la R2 la R8 fiecare al cincelea

caracter.
start_sir: db “acesta este un program demonstrativ”
db 0h
00: load RA,start_sir
02: load R1,4
04: load R9,5
06: addi RA,RA,R1
08: load R2,[RA]
1A: addi RA,RA,R9
1C: load R3,[RA]
1E: addi RA,RA,R9
20: load R4,[RA]
22: addi RA,RA,R9
24: load R5,[RA]
26: addi RA,RA,R9
28: load R6,[RA]
2A: addi RA,RA,R9
2C: load R7,[RA]
2E: addi RA,RA,R9
30: load R8,[RA]
32: halt
start_sir:34: db "acesta este un program demonstrativ"

15. Sa se copieze fiecare al treilea caracter din sirul de mai jos, in memorie, incepand cu
adresa E0h.
start_sir: db “acesta este un program demonstrativ”
00: load R1,start_sir
02: load R0,0
04: load R2,1
06: load R3,3
08: load R6,2
0A: load R4,0xE0
0C: addi R1,R1,R6
bucla:0E: load R5,[R1]
10: jmpEQ R5=R0,stop
12: store R5,[R4]
14: addi R1,R1,R3
16: addi R4,R4,R2
18: jmp bucla
stop:1A: halt
start_sir:1C: db "acesta este un program demonstrativ"

16. Sa se scrie un program in limbaj de asamblare care sa numere si sa afiseze folosind

registrul RF, cite caractere are urmatorul sir.
”program”.
00: load R1,text
02: load R2,1
04: load R0,0
06: load R4,0
08: load R5,0x30
bucla:0A: load R3,[R1]
0C: jmpEQ R3=R0,iesire
0E: addi R4,R4,R2
10: addi R1,R1,R2
12: jmp bucla
iesire:14: addi RF,R4,R5
16: halt
text:18: db "program"