bennyassembly, mips assembly, מבוא למדעי המחשבLeave a Comment

שאלה 1

בתכנית זאת תוכלו ללמוד על מציאת מקסימום במערך בשפת אסמבלי

נתון בלוק של נתונים בזיכרון, כל נתון גודלו בית byte .
כתובת תחילת הבלוק נתונה ברגיסטר a0$
הנתון הראשון בבלוק )הבית הראשון( מציין כמה איברים בגודל בית יש בבלוק – לא כולל
האיבר הראשון )הנתונים מיוצגים עם סימן signed
מצא את הנתון הגדול ביותר והכנס אותו לרגיסטר v0$


.data
array : .byte 1 2 -7 7 33 4 5 100 -126 # the data
.text
la $a0 , array # the firsr array adress in $a1
li $a1 , 9 # the array size=9
lb $v0 , 0($a0) # v0 = array[0] v0=max 
loop:
lb $t1 , 0($a0) # insert the data piont by $a0 , to $t1 
slt $v1 , $v0, $t1 # if ($v0 < $t1 ){$v1=1}; else{$v1=0} beq $v1,$zero, lable # if $v1 = 0 that mean : max >= $t1 ($v0 contian now the highest value)then go to the next elemet 
add $v0, $zero , $t1 #if $v1 = 1 ($v0 < $t1 )that mean : $v0 need to updated ( 
lable:
addi $a0,$a0,1 #promote the pointer to the next element
addi $a1,$a1,-1 # size-- 
beq $a1,$zero,finish # end of array.
j loop
finish:
add $a0,$zero,$v0 # to print the result.
li $v0,1 # system service to print
syscall 
end:

שאלה 2

מיון בועות בשפת אסמבלי

נתון בלוק של נתונים )מספריים( בזיכרון הנתונים. כל נתון גודלו מילה )word .) כתובת תחילת הבלוק נתונה ברגיסטר a0$ הנתון הראשון בבלוק )המילה הראשונה( מציין כמה איברים )בגודל מילה( יש בבלוק )הנתונים מיוצגים עם סימן signed) כתוב תוכנית הממיינת את רשימת הנתונים בעזרת מיון בועות. תזכורת: מיון בועות הוא אלגוריתם הסורק את רשימת הנתונים ומשווה בין כל זוג של נתונים. אם ערכו של הנתון השמאלי גדול מערכו של הנתון הימני, התוכנית תחליף ביניהם. בכל סריקה המספר הגדול ביותר "מבעבע" לראש הרשימה

 

.data
block: .word 3,2,1,4,5,-2,120,32  # initialize data in block1.
.text

li $t0 8                 # initialize the size  for(index loop1)
li $t3 1                 # to compare bool functions

loop1:
addi $t0 $t0 -1           #index of loop1 --
li $a1 8                  # initialize index loop2
la $a0 block              #$a0->word[0]   
addi $a3 $a0 4            #$a3->word[0+1]
beq $t0 $0 finish
loop2:

lw $t1 ($a0)               # $t1=word[j]
lw $t2 ($a3)               # $t2=word[j+1]
slt $s1 $t2 $t1            #if(word[j+1]<word[j]) {$s1=1}else{$s1=1} beq $s1 $t3 swap #if s1=1 --> word[j+1]<word[j] -->swap
addi $a1 $a1 -1            # else    index loop2--  
addi $a0 $a0 4             # j++
addi $a3 $a0 4             #[j+1]++
beq $a1 $t3 loop1          # if n=1 (need to finish loop2 and go to loop1 again)
j loop2                    # if swap is not nessesry go the the next element    
swap:
sw $t1 ($a3)                
sw $t2 ($a0)
addi $a0 $a0 4           # j++
addi $a3 $a0 4           #[j+1]++
addi $a1 $a1 -1          #n--
beq $a1 $t3 loop1        # if n=1 (need to finish loop2 and go to loop1 again)
li $s1 0
j loop2
finish:

li $t0 8         # array size  [i]
la $a1 block     # $a1 = array[0] adress

printLoop:
lw $s5 ($a1)    # $s5 = array[i]
add $a0 ,$0,$s5 
li $v0,1
syscall

li $a0, ' '     # for spasec between the numbers
li $v0, 11
syscall

addi $a1 $a1 4   # promote the pointer to the next element
addi $t0 $t0 -1     #i--
beq $t0 $0 end
j printLoop
end:

כתיבת תגובה

האימייל לא יוצג באתר. שדות החובה מסומנים *