nombre pair ou impair Langage d'Assembleur

Question

Bonjour, 
Je dois écrire un programme qui affiche si un nombre est pair ou impair en langage d'assembleur mais j'y arrive pas  est ce que vous pouvez m'aider à trouver l'erreur

.model small
.data
 
    x db 22
    pair db 'le nombre est pair',13,10,'$'
    impair db 'le nombre est impair',13,10,'$'
.code
   main proc
     mov ax,@data
     mov ds,ax 
     mov al,x
      
     jp even
     jnp odd
even:
     mov ah,9
     mov dx,offset pair
     int 21h
      jmp fin
odd:
     mov ah,9
     mov dx,offset impair
     int 21h
      fin:

endp
 end main

Pat · Answer

Bonjour,

Pour tester si un nombre est pair ou impair, vous vérifiez le bit 0 de ce numéro. si bit0 est définie, alors le nombre est impair. rien d'autre.
REmarque : Ne pas confondre PF (parité drapeau) et JP/JNP conditions. 

Pour tester si un nombre est pair ou impair, juste le déplacer à droite une fois et vérifier le drapeau de portage:

    mov     al, 09
    shr     al       ; shifts all bits right 1, lowest bit to carry flag
    jc      _odd     ; carry set - there was a bit in lowest position
_even:
    ; Do something with even numbers and exit
_odd:
    ; Do something with odd numbers and exit

assume cs:cseg,ds:dseg,ss:sseg
    cseg segment
    start:  
    mov ax, dseg
    mov ds, ax

mov ah, 01h ; Here, im adding a number
    int 21h

and al,00000001

jp even
    jnp odd

even: 
    mov ah,09
    lea dx,par
    int 21h  
    jmp exit
    odd: 
    mov ah,09
    lea dx,odd1 
    int 21h   
    jmp salir
    salir:
    mov ax,4C00h
    int 21h

cseg ends

dseg segment byte         
    even Db 'Even number$'
    odd11 Db 'Odd number$'
    dseg ends

sseg segment stack
    db 100h dup(?)
    sseg ends

end start


Un petit effort en interactif



 .MODEL SMALL
 .STACK 100H

.DATA
   PROMPT_1  DB  'Enter a number: $'
   PROMPT_2  DB  0DH,0AH,'The given number in binary is: $'
   PROMPT_3  DB  0DH,0AH,'$' 
   MSG1 DB 10,13,’Number is Odd $’
   MSG2 DB 10,13,’Number is Even $’

.CODE
   MAIN PROC
     MOV AX, @DATA                
     MOV DS, AX

LEA DX, PROMPT_1                
     MOV AH, 9
     INT 21H

XOR BL, BL                  
     MOV CX, 8                   
     MOV AH, 1

@INPUT:                     
       INT 21H                   
       CMP AL, 0DH                
       JE @END                   
       AND AL, 0FH                
       SHL BL, 4                 
       OR BL, AL                  
     LOOP @INPUT

@END:

MOV AL, BL                   
     MOV CX, 8

@LOOP:                       
       SHR AL, 1                  
       RCL BL, 0                  
     LOOP @LOOP

LEA DX, PROMPT_2             
     MOV AH, 9
     INT 21H

MOV CX, 8                    
     MOV AH, 2

@OUTPUT:                     
       SHL BL, 1

JNC @ZERO                  
         MOV DL, 31H              
         JMP @DISPLAY

@ZERO:                     
         MOV DL, 30H

@DISPLAY:                  
         INT 21H                  
     LOOP @OUTPUT

MOV AH,01H
INT 21H

mov ah,01h

SAR AL,01h
JC ODD

LEA SI,MSG1
CALL PRINT

JMP TERMINATE

ODD:
LEA SI,MSG2
CALL PRINT

TERMINATE:
MOV AH,4CH
INT 21H

PRINT PROC
MOV DX,SI
MOV AH,09H
INT 21H

MOV AH, 4CH                 
     INT 21H

END MAIN

À quoi ça sert, et pourquoi est-il utile de répondre à cette question? Est shr al,1 / rcl bl, 0 / loop censé peu inversée, AL? Il n'en est rien; rcl avec un nombre de zéro cher no-op, et n'est pas pris en charge sur 8086. rcl bl, 1 fonctionne sur 8086, et ferait un bon peu-boucle de retournement. De toute façon, vous avez seulement besoin de regarder la dernière décimale de un à plusieurs chiffres du numéro de décider si c'est pair ou impair.

L'assembleur est un très bon langage mais hard facile à apprendre long à coder

Nombre pair ou impair Langage d'Assembleur

1 réponse

Discussions similaires

Newsletters