a) Defina uma função para obter o máximo entre dois números
a) Defina uma função para obter o máximo entre dois números
a) Defina uma função para obter o máximo entre dois números
Create successful ePaper yourself
Turn your PDF publications into a flip-book with our unique Google optimized e-Paper software.
IP, Resoluções comentadas, Semana 2<br />
jrg, vs 002, Out-2012<br />
a) <strong>Defina</strong> <strong>uma</strong> <strong>função</strong> <strong>para</strong> <strong>obter</strong> o <strong>máximo</strong> <strong>entre</strong> <strong>dois</strong> <strong>números</strong><br />
A versão mais imediata talvez seja esta:<br />
public static int maior ( int a, int b ) {<br />
if ( a > b )<br />
return a;<br />
else<br />
return b;<br />
}<br />
O raciocínio é o seguinte: recebemos <strong>dois</strong> <strong>números</strong>, a e b, e temos que escolher <strong>entre</strong><br />
return a, que devolve o primeiro número, ou<br />
return b, que devolve o segundo.<br />
Para fazer a escolha a estrutura adequada é o if. Sendo a>b escolhemos return a; caso<br />
contrário...<br />
Esta outra versão também serve:<br />
public static int maior ( int a, int b ) {<br />
if ( a > b )<br />
return a;<br />
// ! se chegarmos aqui é porque a > b não é verdade<br />
return b;<br />
}<br />
Aqui o raciocínio será talvez mais de eliminação de hipóteses. Primeiro vemos se a>b; sendo<br />
está resolvido, o resultado é o a; não sendo, concluímos que é o b.<br />
Esta outra versão é parecida. Aqui a ideia é <strong>obter</strong> o maior, que fica em m.<br />
public static int maior ( int a, int b ) {<br />
int m = a;<br />
if ( b > m )<br />
m = b;<br />
return m;<br />
}<br />
Primeiro fazemos m = a (presumimos que o maior é o a). Se, afinal, se verificar o b é maior,<br />
mudamos de ideias, e passamos o b <strong>para</strong> m.<br />
Este último é talvez o raciocínio mais extensível mais três ou mais casos...<br />
No exemplo seguinte recebemos três <strong>números</strong> <strong>para</strong> escolher o maior:<br />
public static int maior ( int a, int b, int c) {<br />
int m = a;<br />
if ( b > m )<br />
m = b;<br />
if ( c > m )<br />
m = c;<br />
return m;<br />
}
) <strong>Defina</strong> <strong>uma</strong> <strong>função</strong> <strong>para</strong> <strong>obter</strong> o valor absoluto de um número.<br />
A solução mais imediata talvez seja esta:<br />
Outra<br />
public static int abs ( int a ) {<br />
if ( a > 0 )<br />
return a;<br />
else<br />
return -a;<br />
}<br />
public static int abs ( int a ) {<br />
if ( a < 0 )<br />
a = -a;<br />
return a;<br />
}<br />
c) <strong>Defina</strong> <strong>uma</strong> <strong>função</strong> que permita verificar se um número é múltiplo de um outro<br />
número<br />
A solução normal seria<br />
public static boolean eMultiplo ( int a, int b ) {<br />
if ( a % b == 0 )<br />
return true;<br />
else<br />
return false;<br />
}<br />
ou, mais simplesmente,<br />
public static boolean eMultiplo ( int a, int b ) {<br />
return a %b == 0;<br />
}<br />
Mas, <strong>para</strong> complicar, vamos admitir que não é permitido usar o operador %. Podemos <strong>obter</strong> o<br />
mesmo efeito por subtracções sucessivas: se subtrairmos b da enquanto pudermos acabaremos<br />
por encontrar o resto da divisão de b por a.<br />
Por exemplo, vamos supor que queremos saber o resto da divisão de 11 por 3.<br />
Fazemos<br />
11 – 3 dá 8<br />
8 – 3 dá 5<br />
5 – 3 dá 2<br />
sobra 2 (porque já não conseguimos subtrair mais); é este o resto.<br />
Estas contas traduzem-se no seguinte esqueleto:<br />
public static void resto ( int a, int b ) {<br />
}<br />
while ( a >= b ) {<br />
}<br />
...<br />
a = a - b;
Ou seja, enquanto der (isto é enquanto for a=>b) vamos subtraindo a a o valor de b.<br />
Quando deixar de dar <strong>para</strong>mos e o que sobrar em a é o resto.<br />
A versão completa será então:<br />
public static int resto( int a, int b ) {<br />
while ( a >= b ) {<br />
a = a - b;<br />
}<br />
return a;<br />
}<br />
É muito importante perceber a lógica do<br />
a = a - b;<br />
A operação a - b dá o valor da subtracção. Mas isso não chega! É indispensável que este<br />
resultado vá de novo <strong>para</strong> a (ou seja fazer a = a -b ) <strong>para</strong> que na repetição seguinte do ciclo<br />
o valor de a já seja o que resultou da subtracção anterior.<br />
Este versão apura o resto da divisão. O exercício pede <strong>para</strong> dizer se, "sim ou não", a é múltiplo<br />
de b. Mas tendo o resto calculado é fácil chegar lá:<br />
public static int eMultiplo ( int a, int b ) {<br />
while ( a >= b ) {<br />
a = a - b;<br />
}<br />
return a == 0;<br />
}<br />
d) O <strong>Defina</strong> <strong>uma</strong> <strong>função</strong> <strong>para</strong> <strong>obter</strong> o quociente da divisão inteira, sem recorrer ao<br />
operador de divisão<br />
Para <strong>obter</strong> o quociente podemos também fazer subtracções sucessivas (commo exercício<br />
anterior). Vamos supor que queríamos <strong>obter</strong> 11 / 3. Fazemos:<br />
11 – 3 dá 8<br />
8 – 3 dá 5<br />
5 – 3 dá 2<br />
e termina (porque já não conseguimos subtrair mais) e é este o resto.<br />
O resultado é o número de vezes que se consegue subtrair, ou seja 3.<br />
Consideremos a estrutura da versão anterior:<br />
public static int quociente( int a, int b ) {<br />
}<br />
...<br />
while ( a >= b ) {<br />
// quantas vezes se passa aqui ?<br />
a = a - b;<br />
}<br />
...
Para <strong>obter</strong> o resultado arranja-se <strong>uma</strong> variável que conte o número de vezes que se passa no<br />
ponto assinalado. Seja <strong>uma</strong> variável com nome c. Então, c começa em 0 e cada vez que se<br />
passar no ponto assinalado faz-se c = c +1 (fazendo, portanto, c passar <strong>para</strong> o valor<br />
seguinte).<br />
Juntando c ao programa anterior temos então:<br />
public static int quociente( int a, int b ) {<br />
}<br />
int c = 0;<br />
while ( a >= b ) {<br />
c = c + 1;<br />
a = a - b;<br />
}<br />
return c;<br />
e) <strong>Defina</strong> <strong>uma</strong> <strong>função</strong> que recebe como argumento um número natural n (diferente de<br />
zero) e devolve a potência 2^n.<br />
Para <strong>obter</strong> 2^n temos que repetir n vezes a operação<br />
r = r * 2; (começando com r = 1).<br />
Vamos só rever como é que se faz <strong>para</strong> repetir <strong>uma</strong> coisa N vezes.<br />
O esqueleto é:<br />
public static void pot2 ( int n ) {<br />
}<br />
int i=0;<br />
while ( i < n) {<br />
}<br />
// o que estiver aqui é repetido n vezes...<br />
i = i + 1;<br />
Ou seja, arranjamos <strong>uma</strong> variável que percorra n valores diferentes.<br />
Neste caso a variável é o i que percorre valores de 0 a n-1 (são portanto n valores diferentes).<br />
Dado este esqueleto, o que estiver o ponto assinalado pelo comentário será repetido N vezes<br />
(sendo que em cada repetição o valor de i vai variando).<br />
Neste caso o que pretendemos repetir N vezes é a tal instrução r=r*2. Fica então:<br />
public static int pot2( int n ) {<br />
}<br />
int i=0, r = 0;<br />
while ( i < n) {<br />
r = r * 2;<br />
i = i + 1;<br />
}<br />
return r;
f) <strong>Defina</strong> <strong>uma</strong> <strong>função</strong> que recebe como argumento um número natural n e devolve a soma<br />
dos <strong>números</strong> naturais até n.<br />
Podemos começar por arranjar <strong>uma</strong> variável que percorra o leque de <strong>números</strong> em jogo.<br />
Neste caso <strong>uma</strong> variável que percorra os <strong>números</strong> de 1 a n (vamos admitir que seja inclusive).<br />
O esqueleto <strong>para</strong> isso é:<br />
public static void somaN( int n ) {<br />
}<br />
int i=1;<br />
while ( i
public static int somaIntervalo( int n, int p ) {<br />
}<br />
int i=n;<br />
int soma = 0;<br />
while ( i
E se o número inicial n não for par ? Uma pequena dificuldade: podemos nessa caso somar 1,<br />
avançando <strong>para</strong> o par seguinte:<br />
public static int somaIntervalo( int n, int p ) {<br />
}<br />
int i=n;<br />
if ( i % 2 == 0 )<br />
i = i + 1;<br />
int soma = 0;<br />
while ( i = 10 ) {<br />
numero = numero / 10;<br />
}<br />
return numero;<br />
i) <strong>Defina</strong> <strong>uma</strong> <strong>função</strong> que recebe como argumento um número natural n e devolve o nésimo<br />
número da sequência de Fibonacci<br />
Os <strong>números</strong> de Fibonacci são<br />
F(0) = 0<br />
F(1) = 1 e, daí <strong>para</strong> a frente<br />
F(n) = F(n-2) + F(n-1)<br />
Para saber calcular o número n é preciso saber os <strong>dois</strong> anteriores.<br />
É este o ponto principal do raciocínio que vamos implementar. As variáveis u e p representam o<br />
último e o penúltimo número. Inicialmente u = 1 e p = 0. Com este valores calcula-se o<br />
Fibonacci seguinte, f = u + p.<br />
Depois, pre<strong>para</strong>-se o cálculo do Fibinacci seguinte. E <strong>para</strong> isso:<br />
- o número que era último passará a ser o penúltimo ( p = u; )<br />
- e o último passará a ser o acabado de calcular ( u = f; ).que último passará a ser o +
public static int fibonacci( int n ) {<br />
}<br />
if ( n < 2 )<br />
return n;<br />
int p = 0;<br />
int u = 1;<br />
int i=2;<br />
while ( i a ) {<br />
M = b;<br />
m = a;<br />
}<br />
while ( m != 0 ) {<br />
M = M - m;<br />
if ( m > M ) {<br />
int t = M;<br />
M = m;<br />
m = t;<br />
}<br />
}<br />
return M;<br />
}