Nombre pair ou impair Langage d'Assembleur

Fermé
sibidel - 24 janv. 2021 à 13:52
 Pat - 30 janv. 2021 à 09:59
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

1 réponse

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
0