Turmas - 1º Semestre de 2020Desenvolver um programa monolítico, utilizando instruções rotuladas, sobre uma máquina genérica, que converta o número decimal fornecido pelo usuário para um número binário. Caso o usuário forneça um valor inválido para o número decimal (valor negativo), o programa deverá apresentar uma mensagem de erro.
Observação: considere que todas as variáveis utilizadas no programa são do tipo inteiro (int).
R01: Faça ler(decimal) vá_para R02;
R02: Se (decimal < 0) então vá_para R03 senão vá_para R04;
R03: Faça escrever(erro) vá_para RX;
R04: Faça binario = 0 vá_para R05;
R05: Faça base = 1 vá_para R06;
R06: Se (decimal > 0) então vá_para R07 senão vá_para R12;
R07: Faça resto = decimal % 2 vá_para R08;
R08: Se (resto != 0) então vá_para R09 senão vá_para R10;
R09: Faça binario = binario + base vá_para R10;
R10: Faça decimal = decimal / 2 vá_para R11;
R11: Faça base = base * 10 vá_para R06;
R12: Faça escrever(binario) vá_para RX;
Desenvolver um programa iterativo, sobre uma máquina genérica, que indique se o número fornecido pelo usuário é um número deficiente, perfeito ou abundante.
Um número é considerado deficiente (defectivo) se a soma de seus divisores próprios é menor que o próprio número, como por exemplo o número 15, cuja soma de seus divisores próprios (1 + 3 + 5) é menor do que 15.
Um número é considerado perfeito se a soma de seus divisores próprios é igual ao próprio número, como por exemplo o número 6, cuja soma de seus divisores próprios (1 + 2 + 3) é igual a 6.
Um número é considerado abundante se a soma de seus divisores próprios é maior que o próprio número, como por exemplo o número 12, cuja soma de seus divisores próprios (1 + 2 + 3 + 4 + 6) é maior do que 12.
Caso o número seja considerado deficiente, o programa deverá retornar -1. Caso o número seja considerado perfeito, o programa deverá retornar 0. Caso o número seja considerado abundante, o programa deverá retornar 1. Caso o número fornecido pelo usuário seja menor do que 2, o programa deverá retornar -9.
ler(numero);
se (numero > 1) então
soma = 0;
contador = 1;
enquanto (contador < numero) faça
resto = numero % contador;
se (resto == 0) então
soma = soma + contador;
fim se;
contador = contador + 1;
fim enquanto;
se (soma < numero)
então escrever(-1);
senão se (soma > numero)
então escrever(1);
senão escrever(0);
fim se;
fim se;
senão
escrever(-9);
fim se;
Desenvolver um programa recursivo, sobre uma máquina genérica, que calcule o número de grupos distintos com k pessoas que podem ser formados a partir de um conjunto de n pessoas.A definição da função comb(n, k) é a seguinte:<\p>
função comb(n, k)
se (k == 1)
então retornar n;
senão se (k == n)
então retornar 1;
senão se ((1 < k) && (k < n))
então retornar comb(n - 1, k - 1) + comb(n - 1, k);
senão retornar 0;
fim se;
fim se;
fim se;
fim função;
função principal()
ler(n);
ler(k);
se ((n > 0) && (k > 0))
então escrever(comb(n, k));
senão escrever(erro);
fim se;
fim função;
Considere a especificação da máquina 4REG apresentada a seguir:
4REG = (N4, N, N, armazenar, retornar, {decA, incB, decB, incC, decC, incD}, {nilA, nilB, nilC}), onde:
A, zerando os demais;D;A em uma unidade, caso o mesmo seja maior do que zero;B em uma unidade;B em uma unidade, caso o mesmo seja maior do que zero;C em uma unidade;C em uma unidade, caso o mesmo seja maior do que zero;D em uma unidade;A seja zero, caso contrário, falso;B seja zero, caso contrário, falso;C seja zero, caso contrário, falso;Desenvolver um programa monolítico, utilizando instruções rotuladas, sobre a máquina 4REG, que retorne a somatória de 0 até n. Apresentar a computação e a função computada para a entrada 5.
R01: Se nilA então vá_para RX senão vá_para R02;
R02: Faça decA vá_para R03;
R03: Faça incB vá_para R04;
R04: Faça incD vá_para R05;
R05: Se nilA então vá_para R06 senão vá_para R02;
R06: Faça decB vá_para R07;
R07: Se nilB então vá_para RX senão vá_para R08;
R08: Faça decB vá_para R09;
R09: Faça incC vá_para R10;
R10: Faça incD vá_para R11;
R11: Se nilB então vá_para R12 senão vá_para R08;
R12: Faça decC vá_para R13;
R13: Se nilC então vá_para RX senão vá_para R14;
R14: Faça decC vá_para R15;
R15: Faça incB vá_para R16;
R16: Faça incD vá_para R17;
R17: Se nilC então vá_para R06 senão vá_para R14;
(R01, (5, 0, 0, 0))
(R02, (5, 0, 0, 0))
(R03, (4, 0, 0, 0))
(R04, (4, 1, 0, 0))
(R05, (4, 1, 0, 1))
(R02, (4, 1, 0, 1))
(R03, (3, 1, 0, 1))
(R04, (3, 2, 0, 1))
(R05, (3, 2, 0, 2))
(R02, (3, 2, 0, 2))
(R03, (2, 2, 0, 2))
(R04, (2, 3, 0, 2))
(R05, (2, 3, 0, 3))
(R02, (2, 3, 0, 3))
(R03, (1, 3, 0, 3))
(R04, (1, 4, 0, 3))
(R05, (1, 4, 0, 4))
(R02, (1, 4, 0, 4))
(R03, (0, 4, 0, 4))
(R04, (0, 5, 0, 4))
(R05, (0, 5, 0, 5))
(R06, (0, 5, 0, 5))
(R07, (0, 4, 0, 5))
(R08, (0, 4, 0, 5))
(R09, (0, 3, 0, 5))
(R10, (0, 3, 1, 5))
(R11, (0, 3, 1, 6))
(R08, (0, 3, 1, 6))
(R09, (0, 2, 1, 6))
(R10, (0, 2, 2, 6))
(R11, (0, 2, 2, 7))
(R08, (0, 2, 2, 7))
(R09, (0, 1, 2, 7))
(R10, (0, 1, 3, 7))
(R11, (0, 1, 3, 8))
(R08, (0, 1, 3, 8))
(R09, (0, 0, 3, 8))
(R10, (0, 0, 4, 8))
(R11, (0, 0, 4, 9))
(R12, (0, 0, 4, 9))
(R13, (0, 0, 3, 9))
(R14, (0, 0, 3, 9))
(R15, (0, 0, 2, 9))
(R16, (0, 1, 2, 9))
(R17, (0, 1, 2, 10))
(R14, (0, 1, 2, 10))
(R15, (0, 1, 1, 10))
(R16, (0, 2, 1, 10))
(R17, (0, 2, 1, 11))
(R14, (0, 2, 1, 11))
(R15, (0, 2, 0, 11))
(R16, (0, 3, 0, 11))
(R17, (0, 3, 0, 12))
(R06, (0, 3, 0, 12))
(R07, (0, 2, 0, 12))
(R08, (0, 2, 0, 12))
(R09, (0, 1, 0, 12))
(R10, (0, 1, 1, 12))
(R11, (0, 1, 1, 13))
(R08, (0, 1, 1, 13))
(R09, (0, 0, 1, 13))
(R10, (0, 0, 2, 13))
(R11, (0, 0, 2, 14))
(R12, (0, 0, 2, 14))
(R13, (0, 0, 1, 14))
(R14, (0, 0, 1, 14))
(R15, (0, 0, 0, 14))
(R16, (0, 1, 0, 14))
(R17, (0, 1, 0, 15))
(R06, (0, 1, 0, 15))
(R07, (0, 0, 0, 15))
(RX , (0, 0, 0, 15))
<PROG4, 4REG> : 5 -> 15
Ybadoo - Soluções em Software Livre • Copyright 2009/2024 • 