How does the program find that a 16-bit data1 is less than data2?

It does SUB on the low bytes and SBB on the high bytes; a final borrow CY = 1 means data1 < data2

It compares only the high bytes with CMP M

It adds the two numbers and checks the zero flag

It does SUB on the high bytes only; CY = 0 means data1 < data2

Why is it safe to use INR L between SUB M and SBB M?

INR does not affect CY, so the borrow from SUB is kept for SBB

INR L clears CY, so SBB starts with no borrow

INR L sets CY when L overflows, which SBB needs

SBB does not use the carry flag

When data1 < data2, how does 1FFFH appear in table 3 memory?

FFH at the lower address, then 1FH at the next address

1FH at the lower address, then FFH at the next address

Why does the program change only L (not H) to move between the three tables?

Because all three tables are in the same page (20xxH), so H stays 20H

Because H is used as the loop counter

Because INX H would change the carry flag

Because the tables are stored in reverse order

2073 Magh · 8 marks

8085 ALP: compare two tables of 16-bit data

Short answer

For each of 10 pairs of 16-bit numbers (low byte first), subtract table2 from table1 using SUB and SBB. If borrow (CY=1) indicates table1 < table2, store 1FFFh (FFH, 1FH) in table3; else store 0000h. Tables at 2000H, 2020H, 2040H.

Two tables contain ten 16-bit data each. Write an assembly language program to generate the 3rd table which contains 1FFFh if the corresponding data in the 1st table is less than that of 2nd table, else store 0000h.

Assumptions: table 1 at 2000H, table 2 at 2020H, table 3 at 2040H, each element stored low byte first (little-endian). The tables are in the same page, so only L is changed.

Method: data1 - data2 is calculated with SUB (low bytes) and SBB (high bytes). The final borrow, CY = 1, means data1 < data2. INR L is used to move to the next byte because it does not change CY. If CY = 1, 1FFFH is stored; otherwise 0000H.

        LXI H,2000H     ; HL -> table 1 (2000H); L = index
        MVI C,0AH       ; 10 pairs
LOOP:   MOV B,M         ; B = low byte of data 1
        INR L
        MOV D,M         ; D = high byte of data 1
        MOV A,L
        ADI 1FH         ; L -> table 2 low byte (2020H + 2i)
        MOV L,A
        MOV A,B
        SUB M           ; low bytes: data1 - data2
        INR L           ; INR does not affect CY
        MOV A,D
        SBB M           ; high bytes with borrow; CY = 1 if data1 < data2
        JC LESS
        MVI B,00H       ; data1 >= data2 -> 0000H
        MVI D,00H
        JMP SAVE
LESS:   MVI B,0FFH      ; data1 < data2 -> 1FFFH
        MVI D,1FH
SAVE:   MOV A,L
        ADI 1FH         ; L -> table 3 low byte (2040H + 2i)
        MOV L,A
        MOV M,B         ; store low byte
        INR L
        MOV M,D         ; store high byte
        MOV A,L
        SUI 3FH         ; back to table 1, next element (i + 2)
        MOV L,A
        DCR C
        JNZ LOOP
        HLT

Note: the program stores the low byte first, so 1FFFH appears as FFH, 1FH in memory.

✓ Answer checked by Claude Opus 5.5 (high effort)

8085 ALP: transfer data with more than 3 ones · Microprocessor, chapter 2
8085 ALP: square of ten numbers · Microprocessor, chapter 2
8085 ALP: copy data within a range · Microprocessor, chapter 2
8085 ALP: add two tables, sum and carry · Microprocessor, chapter 2
8085 ALP: transfer with bit set/reset · Microprocessor, chapter 2
8085 ALP: multiplication table of a number · Microprocessor, chapter 2
C program: sum of two 8-bit BCD numbers · Embedded System, chapter 9
3-phase IM principle; speed less than sync · Electrical Machine, chapter 5
Detection gain of DSB-AM is less than 1 · Communication Systems, chapter 9
When terminal voltage is less or more than emf · Electric Machines II, chapter 1

All Microprocessor chapter 2 questions →

8085 ALP: compare two tables of 16-bit data

Related questions