Ajuda - Programa em Assembly

[renatavsm]

Pessoal boa tarde,

Preciso de uma ajuda, um professor de SO I me passou um trabalho para programar em Assembly o programa abaixo, o problema é que não tenho nem ideia de por onde começar.

Alguem pode me ajudar???

O programa é :

Leia um valor n e calcule a soma = 1 + 2 + 3 + ... + n

Mostre o resultado da soma.

Ex:

n = 5

soma = 1 + 2 + 3 + 4 + 5 = 15


Obrigada!!!

[Tecno-Java]

O programa nem é dificil, o problema é como fazer em assembly ne..

Procure no baixaki por assembly, veja algum compilador e se nele contem exemplos...

Procure algum que contenha um loop.. depois disso so comemorar.. ;D

Abraços

[Alison_PC]

loop pra que? lol

não programo em assembly, mas seria isso:

1. Criar duas variaveis
2. Pegar o valor digitado pela pessoa
3. armazenar na variavel "1"
4. Pegar o valor 2 digitado pela pessoa
5. Armazenar na variavel "2"
6. Fazer o calculo
7. Exibir


Se quiser ir fazendo numero + numero + numero + numero ... enfim
criei uma terceira variavel, e adicione o resultado de cada operacao a ela, e no final, exibe tudo de uma vez, com o resultado final


só isso -.-

[Tecno-Java]

Logica:

var1 = 1, var2;

loop(var1){
var1 += var1 + var1++;
}

Nao testei mas acredito que assim funcionaria, se minha logica nao estiver tao enferrujada... Veja se funciona.

Abraços

[dbfn]

Bom,fiz pra você.nasm syntax.No caso tá completo só para o linux,mas com pequenas modificações você faz ele funcionar no windows e tal.A...tinha coisas que ficariam mais legais genéricas,e dá pra depurar bastante...
Usei a fórmula da soma da PG:
S = (a[1] + a[n])*n/2
No caso:
a[n] = valor digitado (z)
a[1] = 0
n = a[n]+1
Logo:
S = (0 + z)*(z+1)/2 => S = (z² + z)/2
Eis o código:

sys_macros.inc:

%macro sys_exit 1
	mov	eax,1
	mov	ebx,%1
	int	80h
%endmacro

%macro sys_print 2
	mov	eax,4
	mov	ebx,1
	mov	edx,%2
	lea	ecx,[%1]
	int	80h
%endmacro

%macro sys_print 1
	sys_print %1,%1_l
%endmacro

%macro sys_read 2
	mov	eax,3
	mov	ebx,0
	mov	edx,%2
	lea	ecx,[%1]
	int	80h
%endmacro

programa.asm:

      %include "sys_macros.inc"

       

      ;Macros

      %macro ulj 4

        cmp %1,%2

        jl    %4

        cmp %1,%3

        jg    %4

      %endmacro

       

      %macro check_val 0

        cmp bl,00h

        je    %%check_done

        sub bl,'0'

        ulj bl,0,9,%%invalid_value

        jmp %%check_done

        %%invalid_value:

          sys_print invalidValue

          sys_exit    0

        %%check_done:

          nop

      %endmacro

       

      ;Program

      section .data

        msg1:

          db    "Exercicio - somador de 0 a n.", 0Ah, 0Ah

          db    "Digite n [0 a 999]:"

        msg1_l: \

          equ $ - msg1

        invalidValue:

          db    "Digite um valor de 0 a 999!", 0Ah

        invalidValue_l: \

          equ $ - invalidValue

        msg2:

          db    "Resultado da soma:"

        msg2_l: \

          equ $ - msg2

       

      section .bss

        n_s:  resq  1

        res:  resb  7

       

      section .text

        global  main

      main:

        sys_print msg1

        sys_read    n_s,4

        mov   ebx,dword [n_s]

        mov   dl,4

        sub   dl,al

        mov   al,dl

        mov   dl,8

        mul   dl

        mov   cl,al

        shl   ebx,cl

        check_val

        mov   al,bl

        mov   cl,100

        mul   cl

        mov   dx,ax

        ror   ebx,8

        check_val

        mov   al,bl

        mov   cl,10

        mul   cl

        add   dx,ax

        ror   ebx,8

        check_val

        mov   al,bl

        movzx   ax,al

        add   dx,ax

        mov   ax,dx

        movzx   ecx,dx

        mul   dx

        mov   bx,ax

        rol   ebx,16

        mov   bx,dx

        rol   ebx,16

        add   ebx,ecx

        mov   edx,0

        mov   eax,ebx

        mov   ebx,2

        div   ebx

        mov   ecx,eax

        mov   ebx,100000

        div   ebx

        add   al,'0'

        mov   byte [res],al

        mov   eax,edx

        mov   edx,0

        mov   ebx,10000

        div   ebx

        add   al,'0'

        mov   byte [res+1],al

        mov   ax,dx
        mov   dx,0
        mov   cx,1000
        div   cx
        add   al,'0'
        mov   byte [res+2],al
        mov   ax,dx
        mov   cl,100
        div   cl
        add   al,'0'
        mov   byte [res+3],al
        movzx   ax,ah
        mov   cl,10
        div   cl
        add   al,'0'
        mov   byte [res+4],al
        add   ah,'0'
        mov   byte [res+5],ah
        mov   byte [res+6],0Ah
        sys_print msg2
        sys_print res,7
        sys_exit    0

[dbfn]

Bom,fiz pra você.nasm syntax.No caso tá completo só para o linux,mas com pequenas modificações você faz ele funcionar no windows e tal.A...tinha coisas que ficariam mais legais genéricas,e dá pra depurar bastante...
Usei a fórmula da soma da PG:
S = (a[1] + a[n])*n/2
No caso:
a[n] = valor digitado (z)
a[1] = 0
n = a[n]+1
Logo:
S = (0 + z)*(z+1)/2 => S = (z² + z)/2
Eis o código:

sys_macros.inc:

%macro sys_exit 1
	mov	eax,1
	mov	ebx,%1
	int	80h
%endmacro

%macro sys_print 2
	mov	eax,4
	mov	ebx,1
	mov	edx,%2
	lea	ecx,[%1]
	int	80h
%endmacro

%macro sys_print 1
	sys_print %1,%1_l
%endmacro

%macro sys_read 2
	mov	eax,3
	mov	ebx,0
	mov	edx,%2
	lea	ecx,[%1]
	int	80h
%endmacro

programa.asm:

%include "sys_macros.inc"

;Macros
%macro ulj 4
	cmp	%1,%2
	jl		%4
	cmp	%1,%3
	jg		%4
%endmacro

%macro check_val 0
	cmp	bl,00h
	je		%%check_done
	sub	bl,'0'
	ulj	bl,0,9,%%invalid_value
	jmp	%%check_done
	%%invalid_value:
		sys_print	invalidValue
		sys_exit		0
	%%check_done:
		nop
%endmacro

;Program
section .data
	msg1:
		db		"Exercicio - somador de 0 a n.", 0Ah, 0Ah
		db		"Digite n [0 a 999]:"
	msg1_l: \
		equ $ - msg1
	invalidValue:
		db		"Digite um valor de 0 a 999!", 0Ah
	invalidValue_l: \
		equ	$ - invalidValue
	msg2:
		db		"Resultado da soma:"
	msg2_l: \
		equ	$ - msg2

section .bss
	n_s:	resq	1
	res:	resb	7

section .text
	global	main
main:
	sys_print	msg1
	sys_read		n_s,4
	mov			ebx,dword [n_s]
	mov			dl,4
	sub			dl,al
	mov			al,dl
	mov			dl,8
	mul			dl
	mov			cl,al
	shl			ebx,cl
	check_val
	mov			al,bl
	mov			cl,100
	mul			cl
	mov			dx,ax
	ror			ebx,8
	check_val
	mov			al,bl
	mov			cl,10
	mul			cl
	add			dx,ax
	ror			ebx,8
	check_val
	mov			al,bl
	movzx			ax,al
	add			dx,ax
	mov			ax,dx
	movzx			ecx,dx
	mul			dx
	mov			bx,ax
	rol			ebx,16
	mov			bx,dx
	rol			ebx,16
	add			ebx,ecx
	mov			edx,0
	mov			eax,ebx
	mov			ebx,2
	div			ebx
	mov			ecx,eax
	mov			ebx,100000
	div			ebx
	add			al,'0'
	mov			byte [res],al
	mov			eax,edx
	mov			edx,0
	mov			ebx,10000
	div			ebx
	add			al,'0'
	mov			byte [res+1],al
	mov			ax,dx
	mov			dx,0
	mov			cx,1000
	div			cx
	add			al,'0'
	mov			byte [res+2],al
	mov			ax,dx
	mov			cl,100
	div			cl
	add			al,'0'
	mov			byte [res+3],al
	movzx			ax,ah
	mov			cl,10
	div			cl
	add			al,'0'
	mov			byte [res+4],al
	add			ah,'0'
	mov			byte [res+5],ah
	mov			byte [res+6],0Ah
	sys_print	msg2
	sys_print	res,7
	sys_exit		0