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

Transcrição

1 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 ) 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 caso contrário... Esta outra versão também serve: public static int maior ( int a, int b ) { if ( a > b ) //! 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;

2 b) 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 ) else return -a; public static int abs ( int a ) { if ( a < 0 ) a = -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á dá 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 ) {...

3 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 ) { É muito importante perceber a lógica do 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 ) { 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á dá 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 ) {... // quantas vezes se passa aqui?...

4 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; c = c + 1; 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... 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; return r;

5 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 <= n) { //aqui veremos passar os valores de i = 1,... até n A questão agora é a seguinte: queremos ir somando cada um dos números i que vai passando nesse tal ponto. Para isso o mecanismo é fazer: Chama-se a isto um "acumulador": começa em 0 e vai juntando cada um dos i que aparece. Juntando esta ideia à função fica: public static void soman( int n ) { int i=1; while ( i <= n) { g) Defina uma função que recebe como argumento dois números naturais n e p e devolve a soma dos números naturais pares compreendidos entre n e p (intervalo fechado). Se não fosse pela questão dos pares era muito parecido. Para começar, arranjamos uma variável que percorra os números de n a p. public static int somaintervalo( int n, int p ) { //... A variável i começa em n e vai andando até p. Acaba por ser muito parecido com o programa anterior: no anterior o i começa em 0 e vai até n; neste o i começa em n e vai até p. Depois, como no programa anterior, usa-se um acumulador para ir juntando os i...

6 public static int somaintervalo( int n, int p ) { O exercício pede para somar apenas os pares. O raciocínio pode ser o seguinte: fazemos soma = soma + i sim senhor, mas não sempre; só se i for par. Ou seja enquadramos o soma = soma + i num if if ( i % 2 == 0 ) // isto é se i for par // só fazemos esta se i for par!!! public static int somaintervalo( int n, int p ) { if ( i % 2 == 0 ) Outro raciocínio pode ser este: como queremos só os pares vamos percorrer os números de 2 em dois. Ficaria então, supondo que o número inicial é par: public static int somaintervalo( int n, int p ) { i = i + 2;

7 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 ) { if ( i % 2 == 0 ) i = i + 2; h) Defina uma função que recebe como argumento um número natural n e devolve o primeiro algarismo da representação decimal de n. O raciocínio para ver o primeiro algarismo por ser este (por exemplo, com o número 7234) 7234 / 10 dá / 10 dá / 10 dá 7 e está feito. Ou seja, divide sucessivamente por 10 até obter um número < 10. public static primeiroalgarismo( int numero ) { while ( numero >= 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 +

8 public static int fibonacci( int n ) { if ( n < 2 ) return n; int p = 0; int u = 1; int i=2; while ( i <= n) { f = p + u; // o novo fibonacci p = u; u = f; i= i +1; return f; j) Defina uma função que recebe como argumento dois números naturais m e n e que calcula o máximo divisor comum desses dois números, usando o algoritmo de Euclides. O algoritmo pode-se traduzir no seguinte: seja M o maior dos dois números e m o menor. Subtrai-se m de M enquanto se puder. Quando, por via destas subtracções M ficar menor em m, troca-se. Quando m chegar a 0 o algoritmo termina e o resultado é o M remanescente. A função seguinte reflecte este algoritmo: public static int mdc2 ( int a, int b) { int M = a, m=b; if (b > a ) { M = b; m = a; while ( m!= 0 ) { M = M - m; if ( m > M ) { int t = M; M = m; m = t; return M;