Apostila de Java, Capítulo 3 - Variáveis primitivas e Controle de Fluxo - Tipos primitivos e valores

Nesse artigo iremos comentar e resolver os exercícios propostos no capítulo 3, sobre Variáveis primitivas e Controle de Fluxo - Tipos primitivos e valores da apostila FJ-11: Java e Orientação a Objetos, da Caelum.
Clique aqui para saber sobre a Caelum e sua apostila.

Clique aqui para baixar a apostila.
Recomendamos que tentem ao máximo resolver os exercícios, e só quando conseguir (ou depois de MUITO tentar) veja o código. Caso tenha dificuldades, veja a Solução, que conterá uma explicação a respeito do código, e tente criar seu código.

Programação é criatividade, logo existem mais de uma solução para o mesmo exercício.

Página 30, Exercício 3.3: Variáveis e Tipos primitivos

Enunciados

QUESTÃO 1:

Na empresa onde trabalhamos, há tabelas com o quanto foi gasto em cada mês. Para fechar o balanço do primeiro trimestre, precisamos somar o gasto total. Sabendo que, em Janeiro, foram gastos 15000 reais,

em Fevereiro, 23000 reais e em Março, 17000 reais, faça um programa que calcule e imprima o gasto total

a) Crie uma classe chamada BalancoTrimestral com um bloco main, como nos exemplos anteriores;

b) Dentro do main (o miolo do programa), declare uma variável inteira chamada gastosJaneiro e

inicialize-a com 15000;

c) Crie também as variáveis gastosFevereiro e gastosMarco, inicializando-as com 23000 e 17000, respectivamente, utilize uma linha para cada declaração;

d) Crie uma variável chamada gastosTrimestre e inicialize-a com a soma das outras 3 variáveis:

int gastosTrimestre = gastosJaneiro + gastosFevereiro + gastosMarco;

e) Imprima a variável gastosTrimestre.

QUESTÃO 2:
Adicione código (sem alterar as linhas que já existem) na classe anterior para imprimir a média mensal
de gasto, criando uma variável mediaMensal junto com uma mensagem. Para isso, concatene a String
com o valor, usando "Valor da média mensal = "+ mediaMensal.

Soluções

QUESTÃO 1:
Esse exemplo é bem simples e não há muito o que explicar, o passo-a-passo do enunciado é bem claro.
Mostramos uma maneira diferente de declarar várias variáveis do mesmo tipo (no caso, inteiro), bastante organizada e muito utilizada por programadores.

Ao invés de:
int variavel1;
int variavel2;

Fizemos:
int variavel1,
     variavel2;

public class BalancoTrimestral {

    public static void main(String[] args) {
        
        int gastosJaneiros = 15000,
            gastosFevereiro = 23000,
            gastosMarco = 17000;
        
        int gastosTrimestre = gastosJaneiros + gastosFevereiro + gastosMarco;
        
        System.out.println(gastosTrimestre);

    }

}

QUESTÃO 2:
Como no trimestre há 3 meses, apenas temos que dividir o valor de 'gastosTrimestre' por 3 para obter a média mensal.

public class BalancoTrimestral {

    public static void main(String[] args) {
        
        int gastosJaneiros = 15000,
            gastosFevereiro = 23000,
            gastosMarco = 17000;
        
        int gastosTrimestre = gastosJaneiros + gastosFevereiro + gastosMarco;
        
        System.out.println(gastosTrimestre);
        
        int mediaMensal = gastosTrimestre/3;
        System.out.println("Valor da média mensal = "+ mediaMensal);

    }

}

Página 40, Exercício 3.13: Fixação de Sintaxe

Enunciados

QUESTÃO 1:
Imprima todos os números de 150 a 300.

QUESTÃO 2:
Imprima a soma de 1 até 1000.

QUESTÃO 3:
Imprima todos os múltiplos de 3, entre 1 e 100.

QUESTÃO 4:
Imprima os fatoriais de 1 a 10.
O fatorial de um número n é n * n-1 * n-2 ... até n = 10. Lembre-se de utilizar os parênteses.
O fatorial de 0 é 1
O fatorial de 1 é (0!) * 1 = 1
O fatorial de 2 é (1!) * 2 = 2
O fatorial de 3 é (2!) * 3 = 6
O fatorial de 4 é (3!) * 4 = 24

Faça um for que inicie uma variável n (número) como 1 e fatorial (resultado) como 1 e varia n de 1 até 10:

int fatorial = 1;
for (int n = 1; n <= 10; n++) {
}

QUESTÃO 5:
No código do exercício anterior, aumente a quantidade de números que terão os fatoriais impressos, até 20, 30, 40. Em um determinado momento, além desse cálculo demorar, vai começar a mostrar respostas completamente erradas. Por quê? Mude de int para long, e você poderá ver alguma mudança.

QUESTÃO 6: 
Imprima os primeiros números da série de Fibonacci até passar de 100. A série de Fibonacci é a seguinte: 0,1,1,2,3,5,8,13,21, etc... Para calculá-la, o primeiro elemento vale 0, o segundo vale 1, daí por diante, o n-ésimo elemento vale o (n-1)-ésimo elemento somado ao (n-2)-ésimo elemento (ex: 8= 5 + 3).

QUESTÃO 7: 
Escreva um programa que, dada uma variável x (com valor 180, por exemplo), temos um novo
x de acordo com a seguinte regra:
• se x é par, x = x / 2
• se x é impar, x = 3 * x + 1
• imprime x
• O programa deve parar quando x tiver o valor igual a 1. Por exemplo, para x = 13, a saída será:
40 -> 20 -> 10 -> 5 -> 16 -> ˜8 -> 4 -> 2 -> 1

QUESTÃO 8: 
Imprima a seguinte tabela, usando fors encadeados:
1
2 4
3 6 9
4 8 12 16
n n*2 n*3 .... n*n



Clique aqui para aprender sobre o laço for em Java.
Clique aqui para aprender sobre o laço while em Java.

Soluções

QUESTÃO 1:
O que fizemos foi usar a variável 'numero' iniciar em 150 e terminar em 300.
Dentro do for fazemos ela começar em 150, terminar em 300 e ser incrementada em 1, cada iteração.

No laço while, a idéia é semelhante. Porém a variável tem que ser inicializada antes do laço, e ser incrementada dentro do próprio laço while.


Usando o laço for:

public class Caelum1 {

    public static void main(String[] args) {
        
        int numero;
        
        for(numero = 150 ; numero <= 300 ; numero++){
            System.out.println(numero);
        }

    }

}

Usando o laço while:

public class Caelum1 {

    public static void main(String[] args) {
        
        int numero=150;
        
        while(numero<=300){
            System.out.println(numero);
            numero++;
        }

    }

}

QUESTÃO 2:
Definimos duas variáveis inteiras, a 'numero' que irá percorrer do número 1 até 1000. A variável 'soma' é inicializada em 0 e servirá para armazenar o valor de todos os números, de 1 até 1000.
Isso acontece no código: soma = soma + numero;
Ou seja, o valor da variável 'soma' é seu antigo valor somado com o valor da variável 'numero'.


Usando o laço for:

public class Caelum2 {

    public static void main(String[] args) {
        
        int numero,
            soma=0;
        
        for(numero = 1 ; numero <= 1000 ; numero++){
            soma = soma + numero;
        }
        
        System.out.println("Soma: "+soma);

    }

}

Usando o laço while:

public class Caelum2 {

    public static void main(String[] args) {
        
        int numero=1,
            soma=0;
        
        while(numero<=1000){
            soma = soma + numero;
            numero++;
        }
        
        System.out.println("Soma: "+soma);

    }

}

QUESTÃO 3:
Assim como nos exemplos anteriores, vamos usar a variável inteira 'numero' para percorrer do número 1 até 100. Porém, não vamos imprimir todos os números, somente os que são divisíveis por 3.

Para tal, vamos usar o teste condicional if else, que fará com que somente os números que deixam resto 0 na divisão por 3: numero % 3 == 0
Clique aqui para estudar o símbolo % (módulo ou resto da divisão).

Assim, colocamos o print dentro dos colchetes do if, para que somente os número divisíveis por 3 que sejam impressos na tela.
Note que no laço while, o incremento (numero++) é feito fora do teste condicional if, pois a variável deve crescer sempre, não somente 'numero' for divisível por 3.

Usando o laço for:

public class Caelum3 {

    public static void main(String[] args) {
        
        int numero;
        
        for(numero = 1 ; numero <= 100 ; numero++){
            if( numero%3 == 0){
                System.out.println(numero);
            }
        }

    }

}

Usando o laço while:

public class Caelum3 {

    public static void main(String[] args) {
        
        int numero=1;
        
        while(numero <= 100){
            if( numero%3 == 0){
                System.out.println(numero);
            }
            numero++;
        }

    }

}

QUESTÃO 4:
Essa questão é bem interessante! O segredo dela é dado no próprio enunciado.
Por exemplo, 5! = 5x4x3x2x1 , ok?
Se você é iniciante e tentou, provavelmente fez assim. Porém isso não é necessário.
Porque calcular tudo isso se você, ao calcular '5!' já possui o valor de '4!'?

Inicialmente fazemos fatorial=1
Essa variável, como o próprio nome diz, irá armazenar o valor dos fatoriais de 1 até 10.
A chave de tudo é o: fatorial = fatorial * n
Essa linha diz: o novo valor de 'fatorial' é o valor antigo dessa variável - que é (fatorial-1)! - multiplicado por um número 'n', onde esse n vai de 1 até 2.

Ora, inicialmente fazemos fatorial=1.
Então a primeira iteração é: fatorial = (1!) * 1 = 1
Depois, para n=2: fatorial = (1!) * 2 = 2!
Para n=3: fatorial = (2!) * 3 = 3!
Para n=4: fatorial = (3!) * 4 = 4!
...
Para n=10: fatorial = (9!) * 10 = 10!

public class CaelumFatorial {

    public static void main(String[] args) {
        
        int n,
            fatorial=1;
        
        for(n=1 ; n<=10 ; n++){
            fatorial = fatorial * n;
            System.out.println("O fatorial de "+ n + " é (" +(n-1)+"!) * "+n+" = "+fatorial);            
        }
        
    }

}

QUESTÃO 5:
Fatorial é um cálculo um pouco trabalhoso para o Java, pois é um número que cresce assustadoramente.
Segundo a documentação oficial, a variável do tipo int pode variar de -2.147.483.648 até o máximo 2.147.483.647

Note que:
12! = 479.001.600
13! = 6.227.020.800

Ou seja, até n=12, tudo ok. Passou disso, o Java imprime valores errados, pois extrapola o máximo que a variável inteira pode suportar.

Já o tipo long pode armazenar inteiros de tamanho até 9.223.372.036.854.775.807
Ou seja, suporte até 20! = 2.432.902.008.176.640.000


QUESTÃO 6: 
Vamos chamar o n-ésimo termo da série de 'numero', o (n-1)-ésimo termo de 'ultimo' e o (n-2)-ésimo de 'penultimo'.
Assim, temos a fórmula geral: numero = ultimo + penultimo;

Até aqui, sem segredos. Imprimimos o 'numero' e tudo ok.
O problema é na hora de descobrir o próximo número.

Para calcularmos o próximo termo da série ('numero'), temos que mudar os valores de 'ultimo' e 'penultimo'.
Para tal, o valor de 'penultimo' agora será o valor de 'ultimo', e o valor de 'ultimo' será agora o valor de 'numero'. Após fazer isso, podemos calcular o novo valor de 'numero', que é 'ultimo + penultimo'.

Por exemplo, chegamos em um ponto que:
numero = 21
ultimo = 13
penultimo = 8

Para calcular o próximo termo, fazemos 'penultimo=ultimo', ou seja, agora:
penultimo = 13
Analogamente, fazemos 'ultimo=numero', e temos:
ultimo=21

De posse desses novos valores, temos o novo valor de 'numero', que é: 21 + 13 = 34, que é o próximo termo da série.

public class caelumFibonacci {

    public static void main(String[] args) {
        int numero, 
            ultimo=1, 
            penultimo=0;
        
        numero = ultimo + penultimo;
        
        while(numero<=100){
            System.out.println(numero);
            
            penultimo=ultimo;
            ultimo=numero;
            numero = ultimo + penultimo;
            
        }
    }
}

QUESTÃO 7:
A primeira coisa a se fazer é declarar o inteiro 'x' e inicializá-lo com algum valor (13, por exemplo).
Após isso, o aplicativo entra um loop através do laço while, que só termina quando x for 1.
Fazemos isso assim: while( x !=1 )
Isso quer dizer: "enquando x não for 1, continue nesse looping".

A cada iteração, o valor de x irá mudar.
Se x for par, ele mudará seu valor para 'x/2', e caso seja ímpar mudará seu valor para '3*x + 1'.

Para controlar como ocorrerão essas mudanças de valores, vamos usar o teste condicional if else.
Vamos checar se x é par através do seguinte código: if ( x % 2 == 0)
Ou seja, se x deixa resto 0 na divisão de por 2, é porque x é par.
Se isso for verdade, x assumirá a metade de seu valor: x = x/2;

Mas ora, um número só poderá ser par ou ímpar. Se o if for falso, é porque o número é impar e o que vai ocorrer nesse caso será o que está dentro do bloco do else : x = 3*x + 1

Após cada mudança, apenas imprimimos o valor de x.

public class caelum7 {

    public static void main(String[] args) {
        int x=13;
        
        while(x != 1){
            if( x%2== 0){
                x = x/2;
            } else {
                x = 3*x +1;
            }            
            
            System.out.print(" -> "+x);
        }
    }
}

QUESTÃO 8: 
Como é pedido, vamos usar dois laços for para resolver essa questão. O primeiro laço é para controlar quantas linhas existem no nosso resultado final. Assim, se n=5, existirá 5 linhas.
O segundo laço vai imprimir o resultado de cada linha, suas colunas.
Assim, se n=5, o resultado é: 5*1 5*2 5*3  5*4  5*5
Ou seja, a linha é a 5, e as colunas são 1, 2, 3, 4, e 5 (sempre variam de 1 até o valor da linha).

O grande segredo de tudo é revelado na última linha do enunciado: n*1   n*2   n*3 .... n*n
Essa é a fórmula geral. Onde 'n' é a linha atual, e em cada linha é impresso o produto de 'n' por um número que varia de 1 até o próprio valor da linha, o 'n'. Construímos isso com os laços for encadeados:
        for(linha=1 ; linha <= n ; linha++){
            for(coluna=1 ; coluna <= linha ; coluna++){
                System.out.print(linha*coluna + " ");
            }
            System.out.println();
        }

Após cada linha ser expressa (ou seja, após cada iteraçao do primeiro laço, temos que imprimir uma quebra de linha, por isso o println ali no final.

public class Caelum8 {

    public static void main(String[] args) {
        int n=5,
            linha,
            coluna;
        
        for(linha=1 ; linha <= n ; linha++){
            for(coluna=1 ; coluna <= linha ; coluna++){
                System.out.print(linha*coluna + " ");
            }
            System.out.println();
        }
        
    }
}

Página 41, Exercício 3.14 - Desafios: Fibonacci

QUESTÃO 1:
Faça o exercício da série de Fibonacci usando apenas duas variáveis.

Solução:
Essa questão é um pouco mais complicada, vai precisar de conhecimentos em Programação e um pouco de Matemática, mas não deixa de ser simples e engenhosa.

Na seção passada usamos três variáveis: 'numero', 'ultimo' e 'penultimo', para descrever o n-ésimo, (n-1)-ésimo e o (n-2)-ésimo termo, respectivamente.
Vamos excluir a variável 'numero', e trabalhar somente com o 'ultimo' e 'penultimo'.

Vamos supor que em um determinado ponto temos:
ultimo=5
penultimo=3

É fácil ver que o próximo termo é sempre (ultimo + penultimo), que nesse caso é 8.
Nosso objetivo então é fazer com que as variáveis tenham o valor ultimo=8 e penultimo=5, concorda?

Para que consigamos gerar mais números de Fibonacci, fazemos com que 'ultimo' receba seu antigo valor somado com o valor de 'penultimo', pois assim a variável 'ultimo' terá a soma dos dois números anteriores, como diz a regra de Fibonacci. Em Java, fica assim:
ultimo = ultimo + penultimo

Agora ultimo = 8, e penultimo = 3.
Nosso objetivo agora é fazer com que penultimo receba o valor 5. Mas como, se nenhuma das variáveis possui valor 5? De onde obter esse valor?
De uma relação matemática da série de Fibonacci! Note que sempre: ultimo = numero - penultimo
Veja como obter 5:  5 = 8 -3 , ou seja, é o novo valor de 'ultimo' subtraído do atual valor de 'penultimo'.

Em Java fica assim: penultimo = ultimo - penultimo

Note no desenho como variam os valores das variáveis no decorrer da execução:

Veja como fica o resultado:

public class Caelum_Desafio_Fibonacci {

    public static void main(String[] args) {
        int ultimo=1, 
            penultimo=0;
        
        while( (ultimo + penultimo) <=100){
            System.out.println(ultimo + penultimo);
            
            ultimo = ultimo + penultimo;
            penultimo = ultimo - penultimo;
        }
        
    }
}