Consider the following array with the contents given (you have to declare it in your program):

Question

5 9 11 16 20 25 19 7 30 13

Write an assembly program using index addressing to convert each of the even numbers in the array to its next higher odd numbers and each of the odd numbers in the array to its immediate lower even numbers. then add all modified numbers in the array and store result in a memory location 'RESULT'. consider each of the element is of WORD size

Answer 1

Here is an assembly program that uses index addressing to convert the numbers in the array according to the given requirements and stores the result in a memory location called 'RESULT':

```assembly
ORG 1000h

SECTION .data

array DW 5, 9, 11, 16, 20, 25, 19, 7, 30, 13
array_size equ ($ - array) / 2

SECTION .text

GLOBAL _start
_start:
mov cx, array_size ; initialize loop counter with the size of the array
mov bx, 0 ; initialize sum of modified numbers to 0
lea si, array ; load array base address into SI register

loop_start:
mov ax, [si] ; load the current element from the array into AX

test ax, 1 ; check if the number is odd (if the least significant bit is set)
jnz odd_number ; jump to odd_number if the number is odd

add ax, 1 ; if the number is even, add 1 to convert it to the next higher odd number

jmp next_iteration ; jump to the next iteration of the loop

odd_number:
sub ax, 1 ; if the number is odd, subtract 1 to convert it to the immediate lower even number

next_iteration:
add bx, ax ; add the current modified number to the sum in BX

add si, 2 ; move to the next element in the array by adding 2 to SI (because each element is WORD size)
loop loop_start ; decrement the loop counter and jump to loop_start if it is not zero

mov WORD [RESULT], bx ; store the sum of modified numbers in memory location 'RESULT'

; Exit program
mov eax, 1 ; prepare for exit syscall
xor ebx, ebx ; exit code 0
int 0x80

SECTION .bss

RESULT resw 1
```

Note:
- This program assumes the NASM assembly syntax and is for x86 architecture.
- The array is declared in the .data section with the given contents.
- 'array_size' is a constant that holds the size of the array (number of elements).
- The loop iterates for each element of the array.
- The current element is loaded into AX using index addressing (`mov ax, [si]`).
- The `test` instruction checks if the number is odd by checking the least significant bit.
- If the number is even, 1 is added to convert it to the next higher odd number.
- If the number is odd, 1 is subtracted to convert it to the immediate lower even number.
- The modified number is added to the sum in BX.
- The loop continues until all elements of the array have been processed.
- Finally, the sum of modified numbers in BX is stored in the memory location 'RESULT' using `mov WORD [RESULT], bx`.
- The program then exits with an exit code 0 using the exit syscall.