Questao 1: -------------------------------------------------------------------

--- Primeira solucao: mantem num e soma em variaveis na memoria

        jmp     inicio          ; pula a area de dados

        ;; area de dados
        
num :   dw      ?               ; inteiro num
soma:   dw      ?               ; inteiro soma

        ;; area de codigo executavel
inicio:
        mov     r0, 0           ; soma = 0
        mov     [soma], r0      ;
        
      ; mov     r0, 0           ; leia num (a instrucao "mov r0, 0" esta'
        syscall                 ;           comentada porque r0 ja' contem 0)
        mov     [num], r1       ; 
laco:
        cmp     r1, r0          ; enquanto (num != 0) {
        jz      saida           ;
        
        jl      le_proximo      ;     se (num > 0) {
        mov     r2, [soma]      ;         soma = soma + num
        add     r2, r1          ;     }
        mov     [soma], r2      ;
le_proximo:     
      ; mov     r0, 0           ;                           (r0 ja' contem 0)
        syscall                 ;     leia num
        mov     [num], r1       ;
        jmp     laco            ; }
saida:
        mov     r0, 1           ; imprima soma
        mov     r1, [soma]      ;
        syscall
        
        mov     r0, 2           ; termine o programa
        syscall                 ;

--- Segunda solucao: nao usa variaveis na memoria. Mantem a soma no 
                     registrador r2 e o ultimo numero lido no registrador r1.
        
        mov     r2, 0           ; soma = 0
        mov     r0, 0           ; leia num para r1
        syscall                 ; 
laco:
        cmp     r1, r0          ; enquanto (num != 0) {
        jz      saida           ;
        jl      le_proximo      ;     se (num > 0) {
        add     r2, r1          ;         soma = soma + num
                                ;     }
le_proximo:                     ;           (a instrucao logo abaixo esta'
      ; mov     r0, 0                        comentada porque r0 ja' contem 0)
        syscall                 ;     leia num para r1
        jmp     laco            ; }
saida:
        mov     r0, 1           ; imprima soma
        mov     r1, r2          ;
        syscall
        
        mov     r0, 2           ; termine o programa
        syscall                 ;

Questao 2(a): ----------------------------------------------------------------

--- Primeira solucao: Vai incrementando r, a partir de zero, 
                      ate' chegar na raiz quadrada de n.

int raiz_quadrada(int n)
{
    int r;

    for (r = 0; r * r <=  n; r++)
        ;
    return r - 1;
}

--- Segunda solucao: Vai decrementando r, a partir de n, 
                     ate' chegar na raiz quadrada de n.

int raiz_quadrada1(int n)
{
    int r;
    for (r = n; r * r > n; r--)
        ;
    return r;
}

Questao 2(b): ----------------------------------------------------------------

#include <stdio.h>

int raiz_quadrada(int n);

int main()
{
    int m, num;

    scanf("%d", &m);
    while (m > 0) {
        scanf("%d", &num);
        printf("%d\n", raiz_quadrada(num));
        m--;
    }
    return 0;
}

--- A mesma solucao, reescrita com for em vez de while: 

int main()
{
    int m, num;

    for (scanf("%d", &m); m > 0; m--) {
        scanf("%d", &num);  
        printf("%d\n", raiz_quadrada(num));
    }   
    return 0;
}

Questao 3: -------------------------------------------------------------------

#include <stdio.h>

int main()
{
    int n, i, j;

    scanf("%d" , &n);
    for (i = 0; i * i <= n; i++) {
        for (j = 0; j * j <= n - i * i; j++) {
            if (i * i + j * j == n) {
                printf("SIM (%d e %d)\n", i, j);
                return 0;
            }
        }
    }
    printf("NAO\n");
                
    return 0;
}

Questao 4: -------------------------------------------------------------------

--- Primeira solucao (nao usa getchar):

#include <stdio.h>

int main()
{
    unsigned n;
    unsigned pot10;
    int count;
    unsigned result;

    scanf("%u", &n);
    
    pot10 = 1;
    while (n / pot10 >= 10) {
        pot10 *= 10;
    }

    count = 0;
    result = 0;
    while (pot10 > 0) {
        if (count % 2 == 0) {
            result = result * 10 + n / pot10;
        }
        n %= pot10;
        pot10 /= 10;
        count++;
    }
    printf("%u\n", result);

    return 0;
}

--- Segunda solucao (quase igual `a primeira, mas com uma variavel 
                     logica em vez do contador count):

#include <stdio.h>
#define TRUE 1

int main()
{
    unsigned n;
    unsigned pot10;
    int include_digit; /* variavel logica (pode valer TRUE ou FALSE) */
    unsigned result;

    scanf("%u", &n);
    
    pot10 = 1;
    while (n / pot10 >= 10) {
        pot10 *= 10;
    }

    include_digit = TRUE;
    result = 0;
    while (pot10 > 0) {
        if (include_digit) {
            result = result * 10 + n / pot10;
        }
        n %= pot10;
        pot10 /= 10;
        include_digit = !include_digit; /* complementa (nega) include_digit */
    }
    printf("%u\n", result);

    return 0;
}

--- Terceira solucao (usa getchar):

#include <stdio.h>
#define TRUE 1

int main()
{
    int result;
    int include_digit; /* variavel logica (pode valer TRUE ou FALSE) */
    int c;

    result = 0;
    include_digit = TRUE;
    c = getchar();
    while (c >= '0' && c <= '9') {
        if (include_digit) {
            result = result * 10 + c - '0';
        }
        include_digit = !include_digit; /* complementa (nega) include_digit */
        c = getchar();
    }
    printf("%u\n", result);

    return 0;
}