1. Este site usa cookies. Ao continuar a usar este site está a concordar com o nosso uso de cookies. Saber Mais.

Assembly factorial de um numero!

Discussão em 'Programação' iniciada por moody, 22 de Junho de 2007. (Respostas: 4; Visualizações: 4445)

  1. Boas!

    Estou com alguns problemas em colocar a funcionar um programazito que calcula o factorial de um determinado numero(8086) e agradecia se alguém me pudesse ajudar...Eis o código:



    Código:
    ...
     
       numero db 5
       factorial db ?
     
    ...
     
      mov ax,dados
      mov ds,ax
      mov ax,b800h
      mov es,ax
      mov dl,numero
      xor ax,ax
      mov al,numero
      mov cx,ax
     
    ciclo:
          dec dl
          mov al,factorial
          mul dl
          mov factorial,al
          loop ciclo
     
    mov dl,factorial
    mov bx,0000h
    mov byte ptr es:[bx],dl
     
    mov ah,4ch                
    int 21h
     
    ...
    
     
  2. liquido

    liquido Power Member

    Código:
    .model  tiny
    CR      equ     0DH
    LF      equ     0AH
    
            extern  _atoi:near, _print:near
    
    $pushr  macro           ; salvaguarda registos na pilha
            push    bx
            push    cx
            push    dx
            push    bp
    endm
    $popr   macro           ; recupera registos da pilha
            pop     bp
            pop     dx
            pop     cx
            pop     bx
    endm
    
    _code   segment word public 'CODE'
            org     0100H
            assume cs:_code,ds:_code,ss:_code
    
    _start:
            mov     ax, offset top  ; fixa espaco para pilha
            mov     sp,ax           ;
    
            mov     dx, offset msg1         ; imprime mensagem introducao
            mov     ah,09h                  ;
            int     21h                     ;
            mov     dx, offset msg2         ; pede numero
            mov     ah,09h                  ;
            int     21h                     ;
            mov     dx, offset buffer       ; recolhe o numero
            mov     ah,0ah                  ;
            int     21h                     ;
            mov     dx, offset newline      ;
            mov     ah,09h                  ;
            int     21h                     ;
    
            mov     bx, offset buffer       ; converte para inteiro
            add     bx,2                    ;
            push    bx                      ;
            mov     cl,[bx-1]               ;
            mov     ch, 0                   ;
            push    cx                      ;
            call    _atoi                   ;
            push     ax
            call    _fact
            push    ax
    
    ; imprime resultado e termina programa
    _res:
            mov     dx, offset msg3         ; imprime resultado
            mov     ah,09h                  ;
            int     21h                     ;
            call    _print                  ;
            mov     dx, offset newline      ;
            mov     ah,09h                  ;
            int     21h                     ;
            mov     al,00                   ; faz exit com sucesso
            mov     ah,04ch                 ;
            int     21h                     ;
    
    _fact   proc    near
    $pushr
            mov     bp,sp
            mov     dx,[bp+10]
            cmp     dx,1
            jle     _f1
            mov     cx,dx
            dec     cx
            push    cx
            call    _fact
            imul    dx
            jmp     _f2
    _f1:    mov     ax,1
    
    _f2:
    $popr
            ret     2
    _fact   endp
    
    msg1    byte    "Cálculo de Factorial",CR,LF,"$"
    msg2    byte    "Introduza um numero: $"
    msg3    byte    "Factorial = $"
    newline byte    CR,LF,"$"
    buffer  byte    1 dup(20)
            byte    20 dup(?)
    stk     word    100 dup(?)
    top     label   word
    _code   ends
    
            end _start
    espero que ajude..tinha feito na faculdade..:msmiley1:
     
  3. sdvferreira

    sdvferreira Power Member

  4. liquido

    liquido Power Member

    obg...tá meio complexo secalhar para o k ele queria porque usa uma stack mas acho k do the trick ;)
     
  5. Factorial Assembly

    Neste codigo que estou a fazer, ao meter um múmero ele devolve codigo Asqui.
    alguem me pode ajudar?


    .MODEL SMALL
    .STACK
    .DATA

    msg1 db 13,10, "Insira numero: $"
    msg2 db 13,10, "O Factorial e: $"


    .code
    mov ax, @data
    mov ds, ax
    lea dx, msg1
    mov ah, 09h
    int 21h
    mov bx, 0

    start:
    mov ah, 01
    int 21h
    cmp al, 0dh
    je next
    mov ah, 0
    sub al, 30h
    push ax
    mov ax, 10d
    mul bx
    pop bx
    add bx, ax
    jmp start

    next:
    mov cx, bx
    mov ax, 1

    top:
    mul cx
    loop top
    mov bx,10d
    mov dx, 0

    break:
    div bx
    push dx
    inc cx
    mov dx, 0
    or ax, ax
    jnz break
    mov ah, 09
    lea dx, msg2
    int 21h
    mov dx, 0

    print:
    pop dx
    mov ah, 02
    add dl, 03h
    int 21h
    loop print
    mov ah, 4ch
    int 21h
    end
     

Partilhar esta Página