a) Defina uma função para obter o máximo entre dois números

IP, Resoluções comentadas, Semana 2
jrg, vs 002, Out-2012
a) Defina uma função para obter o máximo entre dois números
A versão mais imediata talvez seja esta:
public static int maior ( int a, int b ) {
if ( a > b )
return a;
else
return b;
}
O raciocínio é o seguinte: recebemos dois números, a e b, e temos que escolher entre
return a, que devolve o primeiro número, ou
return b, que devolve o segundo.
Para fazer a escolha a estrutura adequada é o if. Sendo a>b escolhemos return a; caso
contrário...
Esta outra versão também serve:
public static int maior ( int a, int b ) {
if ( a > b )
return a;
// ! se chegarmos aqui é porque a > b não é verdade
return b;
}
Aqui o raciocínio será talvez mais de eliminação de hipóteses. Primeiro vemos se a>b; sendo
está resolvido, o resultado é o a; não sendo, concluímos que é o b.
Esta outra versão é parecida. Aqui a ideia é obter o maior, que fica em m.
public static int maior ( int a, int b ) {
int m = a;
if ( b > m )
m = b;
return m;
}
Primeiro fazemos m = a (presumimos que o maior é o a). Se, afinal, se verificar o b é maior,
mudamos de ideias, e passamos o b para m.
Este último é talvez o raciocínio mais extensível mais três ou mais casos...
No exemplo seguinte recebemos três números para escolher o maior:
public static int maior ( int a, int b, int c) {
int m = a;
if ( b > m )
m = b;
if ( c > m )
m = c;
return m;
}

) Defina uma função para obter o valor absoluto de um número.
A solução mais imediata talvez seja esta:
Outra
public static int abs ( int a ) {
if ( a > 0 )
return a;
else
return -a;
}
public static int abs ( int a ) {
if ( a < 0 )
a = -a;
return a;
}
c) Defina uma função que permita verificar se um número é múltiplo de um outro
número
A solução normal seria
public static boolean eMultiplo ( int a, int b ) {
if ( a % b == 0 )
return true;
else
return false;
}
ou, mais simplesmente,
public static boolean eMultiplo ( int a, int b ) {
return a %b == 0;
}
Mas, para complicar, vamos admitir que não é permitido usar o operador %. Podemos obter o
mesmo efeito por subtracções sucessivas: se subtrairmos b da enquanto pudermos acabaremos
por encontrar o resto da divisão de b por a.
Por exemplo, vamos supor que queremos saber o resto da divisão de 11 por 3.
Fazemos
11 – 3 dá 8
8 – 3 dá 5
5 – 3 dá 2
sobra 2 (porque já não conseguimos subtrair mais); é este o resto.
Estas contas traduzem-se no seguinte esqueleto:
public static void resto ( int a, int b ) {
}
while ( a >= b ) {
}
...
a = a - b;

Ou seja, enquanto der (isto é enquanto for a=>b) vamos subtraindo a a o valor de b.
Quando deixar de dar paramos e o que sobrar em a é o resto.
A versão completa será então:
public static int resto( int a, int b ) {
while ( a >= b ) {
a = a - b;
}
return a;
}
É muito importante perceber a lógica do
a = a - b;
A operação a - b dá o valor da subtracção. Mas isso não chega! É indispensável que este
resultado vá de novo para a (ou seja fazer a = a -b ) para que na repetição seguinte do ciclo
o valor de a já seja o que resultou da subtracção anterior.
Este versão apura o resto da divisão. O exercício pede para dizer se, "sim ou não", a é múltiplo
de b. Mas tendo o resto calculado é fácil chegar lá:
public static int eMultiplo ( int a, int b ) {
while ( a >= b ) {
a = a - b;
}
return a == 0;
}
d) O Defina uma função para obter o quociente da divisão inteira, sem recorrer ao
operador de divisão
Para obter o quociente podemos também fazer subtracções sucessivas (commo exercício
anterior). Vamos supor que queríamos obter 11 / 3. Fazemos:
11 – 3 dá 8
8 – 3 dá 5
5 – 3 dá 2
e termina (porque já não conseguimos subtrair mais) e é este o resto.
O resultado é o número de vezes que se consegue subtrair, ou seja 3.
Consideremos a estrutura da versão anterior:
public static int quociente( int a, int b ) {
}
...
while ( a >= b ) {
// quantas vezes se passa aqui ?
a = a - b;
}
...

Para obter o resultado arranja-se uma variável que conte o número de vezes que se passa no
ponto assinalado. Seja uma variável com nome c. Então, c começa em 0 e cada vez que se
passar no ponto assinalado faz-se c = c +1 (fazendo, portanto, c passar para o valor
seguinte).
Juntando c ao programa anterior temos então:
public static int quociente( int a, int b ) {
}
int c = 0;
while ( a >= b ) {
c = c + 1;
a = a - b;
}
return c;
e) Defina uma função que recebe como argumento um número natural n (diferente de
zero) e devolve a potência 2^n.
Para obter 2^n temos que repetir n vezes a operação
r = r * 2; (começando com r = 1).
Vamos só rever como é que se faz para repetir uma coisa N vezes.
O esqueleto é:
public static void pot2 ( int n ) {
}
int i=0;
while ( i < n) {
}
// o que estiver aqui é repetido n vezes...
i = i + 1;
Ou seja, arranjamos uma variável que percorra n valores diferentes.
Neste caso a variável é o i que percorre valores de 0 a n-1 (são portanto n valores diferentes).
Dado este esqueleto, o que estiver o ponto assinalado pelo comentário será repetido N vezes
(sendo que em cada repetição o valor de i vai variando).
Neste caso o que pretendemos repetir N vezes é a tal instrução r=r*2. Fica então:
public static int pot2( int n ) {
}
int i=0, r = 0;
while ( i < n) {
r = r * 2;
i = i + 1;
}
return r;

f) Defina uma função que recebe como argumento um número natural n e devolve a soma
dos números naturais até n.
Podemos começar por arranjar uma variável que percorra o leque de números em jogo.
Neste caso uma variável que percorra os números de 1 a n (vamos admitir que seja inclusive).
O esqueleto para isso é:
public static void somaN( int n ) {
}
int i=1;
while ( i

public static int somaIntervalo( int n, int p ) {
}
int i=n;
int soma = 0;
while ( i

E se o número inicial n não for par ? Uma pequena dificuldade: podemos nessa caso somar 1,
avançando para o par seguinte:
public static int somaIntervalo( int n, int p ) {
}
int i=n;
if ( i % 2 == 0 )
i = i + 1;
int soma = 0;
while ( i = 10 ) {
numero = numero / 10;
}
return numero;
i) Defina uma função que recebe como argumento um número natural n e devolve o nésimo
número da sequência de Fibonacci
Os números de Fibonacci são
F(0) = 0
F(1) = 1 e, daí para a frente
F(n) = F(n-2) + F(n-1)
Para saber calcular o número n é preciso saber os dois anteriores.
É este o ponto principal do raciocínio que vamos implementar. As variáveis u e p representam o
último e o penúltimo número. Inicialmente u = 1 e p = 0. Com este valores calcula-se o
Fibonacci seguinte, f = u + p.
Depois, prepara-se o cálculo do Fibinacci seguinte. E para isso:
- o número que era último passará a ser o penúltimo ( p = u; )
- e o último passará a ser o acabado de calcular ( u = f; ).que último passará a ser o +

public static int fibonacci( int n ) {
}
if ( n < 2 )
return n;
int p = 0;
int u = 1;
int i=2;
while ( i a ) {
M = b;
m = a;
}
while ( m != 0 ) {
M = M - m;
if ( m > M ) {
int t = M;
M = m;
m = t;
}
}
return M;
}