emu8086 find minimum and maximum in an array

I have to come up with an ASM code (for emu8086) that will find the minimum and maximum value in an array of any given size. In the sample code, my instructor provides (what appears to be) a data segment that contains an array named LIST. He claims that he will replace this list with other lists of different sizes, and our code must be able to handle it.

Here's the sample code below. I've highlighted the parts 开发者_运维知识库that I've added, just to show you that I've done my best to solve this problem:

; You may customize this and other start-up templates; 
; The location of this template is c:\emu8086\inc\0_com_template.txt

org 100h

data segment
    LIST DB 05H, 31H, 34H, 30H, 38H, 37H
    MINIMUM DB ?
    MAXIMUM DB ?
    AVARAGE DB ?
    **SIZE=$-OFFSET LIST**
ends

stack segment       **;**

    DW 128 DUP(0)   **; I have NO CLUE what this is supposed to do**

ends                **;**

code segment
start proc far

; set segment registers:

    MOV AX,DATA      **;**
    MOV DS,AX        **;I'm not sure what the point of this is, especially since I'm supposed to be the programmer, not my teacher.**
    MOV ES,AX        **;**

; add your code here

**;the number of elements in LIST is SIZE (I think)                                      
MOV CX,SIZE   ;a loop counter, I think
                          
;find the minimum value in LIST and store it into MINIMUM

;begin loop
AGAIN1:


 LEA SI,LIST
 LEA DI,MINIMUM
 MOV AL,[SI]
 CMP AL,[SI+1]
 If carry flag=1:{I got no idea}
 
LOOP AGAIN1

;find the maximum value in LIST and store it into MAXIMUM
    ;Something similar to the other loop, but this time I gotta find the max.

AGAIN2:


 LEA SI,LIST
 LEA DI,MINIMUM
 MOV AL,[SI]
 CMP AL,[SI-1]        ;???
 


LOOP AGAIN2


**
; exit to operating system.

    MOV AX,4C00H
    INT 21H

start endp

ends

end start ; set entry point and stop the assembler.

ret

I'm not positive, but I think you want to move the SIZE variable immediately after the LIST variable:

data segment
    LIST DB 05H, 31H, 34H, 30H, 38H, 37H
    SIZE=$-OFFSET LIST
    MINIMUM DB ?
    MAXIMUM DB ?
    AVARAGE DB ?
ends

What it does is give you the number of bytes between the current address ($) and the beginning of the LIST variable - thus giving you the size (in bytes) of the list variable itself. Because the LIST is an array of bytes, SIZE will be the actual length of the array. If LIST was an array of WORDS, you'd have to divide SIZE by two. If your teacher wrote that code then perhaps you should leave it alone.

I'm not entirely clear on why your teacher made a stack segment, I can't think of any reason to use it, but perhaps it will become clear in a future assignment. For now, you probably should know that DUP is shorthand for duplicate. This line of code:

DW 128 DUP(0)

Is allocating 128 WORDS of memory initialized to 0.

The following lines of code:

MOV AX,DATA
MOV DS,AX
MOV ES,AX

Are setting up your pointers so that you can loop through the LIST. All you need to know is that, at this point, AX points to the beginning of the data segment and therefor the beginning of your LIST.

As for the rest... it looks like you have an endless loop. What you need to do is this:

1. Set SI to point to the beginning of the LIST
2. Set CX to be the length of the LIST, you've done that
3. Copy the first byte from [SI] to AX
4. Compare AX to the memory variable MINIMUM
5. If AX is smaller, copy it to MINIMUM
6. Increment IS and decriment CX
7. If CX = 0 (check the ZERO flag) exit the loop, otherwise, go back to #3