Exercícios de apoio - Semana 4_ PROGRAMAÇÃO DE COMPUTADORES - ILP001

Prévia do material em texto

PROGRAMAÇÃO DE COMPUTADORES
Condicionais e Laços3
 
EXERCÍCIOS DE APOIO
Apenas para praticar. Não vale nota.
Determine o que cada um dos trechos de código a seguir irá imprimir:1.
for(int cont = 1; cont <= 5; cont++) 
 System.out.println("Oi");
Oi 
Oi 
Oi 
Oi 
Oi
 
 
a.
for(int cont = 1; cont <= 5; cont++) System.out.print("Oi");
OiOiOiOiOi
 
 
b.
for(int cont = 1; cont <= 3; cont++) { 
 System.out.print("Oi"); 
 System.out.print(" Programador"); } 
}
Oi ProgramadorOi ProgramadorOi ProgramadorOi Programador
 
 
c.
class Resolve { 
 
 static void horiz() { 
 for (int comp = 1; comp < 11; comp++) 
 System.out.print("*"); 
 System.out.println(); 
 } 
 
 static void lado() { 
d.
 
 
 System.out.print("*"); 
 for (int espaco = 1; espaco <= 8; espaco++) 
 System.out.print(" "); 
 System.out.println("*"); 
 } 
 
 public static void main(String[] args) { 
 horiz(); 
 for (int vert = 1; vert < 4; vert++) lado(); 
 horiz(); 
 } 
}
********* 
* * 
* * 
* * 
*********
 
 
O que o programa a seguir faz? O que será impresso na tela?
/* misterio */ 
class Misterio { 
 public static void main(String[] args) { 
 int numero; 
 for(numero = 1; numero<=10; numero++) 
 System.out.println(numero*numero); 
 } 
}
O programa imprime o quadrado dos dez primeiros números inteiros. A saída do programa
será: 
1 
4 
9 
16 
25 
36 
49 
64 
81 
100
2.
 
 
Faça um programa que imprima uma tabela com os 15 primeiros inteiros positivos, seus
quadrados e cubos. Cada linha deve se referir a um inteiro. Por exemplo, uma das linhas
impressas deve ser “3 9 27”. Para deixar a saída impressa do seu programa mais legível,
não deixe de imprimir um espaço ou uma tabulação (\t) entre os número de uma mesma
linha.
Três exemplos de soluções alternativas:
void exercicio3() { 
 for (int i=1;i<=15;i++){ 
 int quadrado = i*i; 
 int cubo = quadrado*i; 
 System.out.println(i + " " + quadrado + " " + cubo); 
 } 
} 
 
void exercicio3_alt1() { 
 for (int i=1;i<=15;i++) 
 System.out.println(i + "\t" + i*i + "\t" + i*i*i); 
} 
 
void exercicio3_alt2() { 
 int i = 1; 
 while (i<=15) { 
 System.out.println(i + " " + i*i + " " + i*i*i); 
 i++; 
 } 
}
 
 
3.
Escreva um método que desenhe um retângulo de "*" de n × m (n linhas × m colunas), n e m
serão parâmetros inteiros do seu método. Segue exemplo de 3 linhas e 4 colunas:
**** 
* * 
****
Dois exemplos de soluções alternativas:
void desenha(int n, int m) { 
 for (int i=1;i<=n;i++){ 
 for (int j=1;j<=m;j++){ 
 if (j==1 || j==m || i==1 || i==n) 
 System.out.print("*"); 
 else System.out.print(" "); 
4.
 } 
 System.out.println(); 
 } 
} 
 
void desenha_alt(int n, int m) { 
 for (int i=1;i<=m;i++) System.out.print("*"); 
 System.out.println(); 
 for (int i=2;i<n;i++){ 
 System.out.print("*"); 
 for (int j=2;j<m;j++) System.out.print("*"); 
 System.out.println(); 
 } 
 for (int i=1;i<=m;i++) System.out.print("*"); 
}
 
 
Produza três versões de um método que escreva asteriscos em uma linha, sendo o
valor passado como parâmetro. A primeira versão deve utilizar o comando for, a segunda
o comando while e a terceira o comando do-while.
Um exemplo de cada uma das três implementações solicitadas. Observe que para o do-
while é necessária a existência de um if para tratar o caso de n valer zero.
void asterisco1(int n) { 
 for (int i=1;i<=n;i++) System.out.print("*"); 
} 
 
void asterisco2(int n) { 
 int i=0; 
 while (i<n){ 
 System.out.print("*"); 
 i++; 
 } 
} 
 
void asterisco3(int n) { 
 if (n>0){ 
 int i=0; 
 do{ 
 System.out.print("*"); 
 i++; 
 } while (i<n); 
 } 
}
 
 
5.
Escreva um método, que determine o valor do maior elemento de um arranjo de elementos
do tipo float dado como parâmetro, imprima este valor e o retorne.
Exemplo de solução:
float maiorElemento(float[] arranjo) { 
 float max = arranjo[0]; 
 for (int i=1;i<arranjo.length;i++){ 
 if (arranjo[i]>max) max = arranjo[i]; 
 } 
 System.out.println(max); 
 return max; 
}
 
 
6.
Escreva um método, que determine o índice do arranjo (posição) onde se encontra o maior
elemento de um arranjo de elementos do tipo float dado como parâmetro, imprima o índice e
o retorne.
Dois exemplos de solução:
int indiceMaiorElemento(float[] arranjo) { 
 int indice = 0; 
 for (int i=1;i<arranjo.length;i++){ 
 if (arranjo[i] ;arranjo[indice]) indice = i; 
 } 
 System.out.println(indice); 
 return indice; 
} 
 
int indiceMaior_alt(float[] arranjo) { 
 int indice = 0; 
 float max = arranjo[0]; 
 for (int i=1;i<arranjo.length;i++){ 
 if (arranjo[i]>max) { 
 indice = i; 
 max = arranjo[i]; 
 } 
 } 
 System.out.println(indice); 
 return indice; 
}
 
 
7.
Em uma competição de ginástica olímpica a nota é determinada por um painel de seis
juízes. Cada um dos juízes atribui uma nota entre zero e dez para o desempenho do atleta.
8.
Para calcular a nota final, a nota mais alta e a nota mais baixa são descartadas e é
calculada a média das quatro restantes. Escreva um método que receba por parâmetro um
arranjo contendo as 6 notas entre zero e dez e calcule e retorne a média após o descarte da
maior e da menor nota. Considere que cada nota é representada por um elemento do tipo
double.
Dois exemplos de soluções alternativas:
double mediaGinastica(double[] notas) { 
 double min = 10; 
 double max = 0; 
 double soma = 0; 
 for (int i=0;i<6;i++){ 
 soma = soma + notas[i]; 
 if (notas[i] < min) min = notas[i]; 
 if (notas[i] > max) max = notas[i]; 
 } 
 return ((soma-min-max)/4); 
} 
 
 
double mediaGinastica_alt(double[] notas) { 
 double soma = notas[0]; 
 double min = soma; 
 double max = soma; 
 for (int i=1;i<6;i++){ 
 soma = soma + notas[i]; 
 if (notas[i] < min) min = notas[i]; 
 else if (notas[i] > max) max = notas[i]; 
 } 
 return ((soma-min-max)/4); 
}
 
 
Dados dois polinômios 
,
escrever um método que retorne a soma destes polinômios, na forma de um arranjo de
elementos. Os três arranjos que representarão os polinômios de entrada e de saída (retorno)
deverão ser arranjos de elementos do tipo double, nos quais a primeira posição (índice zero
do arranjo) contém o valor que não multiplica x, a segunda posição contém o valor que
multiplica x elevado a primeira, a terceira contém o valor que multiplica x elevado a segunda
potência e assim por diante.
 
double[] somaPolinomios(double[] p, double[] q) { 
 double[] res = new double[p.length]; 
9.
 for (int i=0;i return res; 
}
 
 
Escreva um método chamado contagem que receba como parâmetro um arranjo de inteiros
chamado valores e um inteiro chamado x e retorna o número de vezes que o valor x aparece
dentro do arranjo valores. Implemente uma solução que iteraja pelos índices do arranjo
(utilizando um laço while ou for).
Exemplo de solução:
public static int contagem(int[] valores, int x){ 
 int resposta = 0; 
 for (int i=0; i<valores.length; i++){ 
 if (valores[i] == x) resposta++; 
 } 
 return resposta; 
}
Outro exemplo de solução:
public static int contagem2(int[] valores, int x){ 
 int resposta = 0; 
 int i = 0; 
 while (i<valores.length){ 
 if (valores[i] == x) resposta++; 
 i++; 
 } 
 return resposta; 
}
 
 
10.
A potenciação serve para simplificar cálculos com números extensos, e em programação
isso é muito mais simplificado, apenas utiliza-se a função math.pow.Uma outra forma para
realizar cálculos dessa natureza é utilizando o laço de repetição for através de um método
que tem como parâmetros valores double e int.
Com base na informação acima, realize o cálculo da potenciação utilizando o laço de
repetição for conforme as orientações abaixo:
11.
Escreva um método em que receba em seus parâmetros um valor double x e um
inteiro y; 
 
 
 
•
De acordo com as recomendações acima, o código correto para o cálculo da potenciação é:
O método deve retornar um valor double de x ; 
 
 
 
• y
Considerar o valor de . 
 
•
static double eleva (double x, int y) { 
 double resp = 1; 
 for (int i=0; i=y; i++) 
 resp *= x; // ou resp = resp * x; 
 return(resp); 
}
 
 
a.
static double eleva (double x, int y) { 
 double resp = 0; 
 for (int i=0; i<y; i++) 
 resp *= x; // ou resp = resp * x; 
 return(x); 
}
 
 
b.
static double eleva (double x, int y) { 
 double resp = 1; 
 for (int i=0; i<y; i--) 
 resp *= x; // ou resp = resp * x; 
 return(resp); 
}
 
 
c.
static double eleva (double x, int y) { 
 double resp = 1; 
 for (int i=0; i<y; i++) 
 resp *= x; // ou resp = resp * x; 
 return(resp); 
}
 
 
d.
static double eleva (double x, int y) { 
 double resp = 1; 
e.
Alternativa (d)
static double eleva (double x, int y) { 
 double resp = 1; 
 for (int i=0; i<y; i++) 
 resp *= x; // ou resp = resp * x; 
 return(resp); 
}
 
 
 for (int i=0; i=y; i++) 
 resp *= x; // ou resp = resp * x; 
 return(resp); 
}
 
 
O fatorial de um número natural n é utilizado na ciência matemática e também na ciência da
computação. Seu uso é de extrema importância na análise combinatória, no cálculo e na
teoria da probabilidade. O fatorial de um número n é representado por n! e é calculado
fazendo o produto de todos os números naturais menores ou iguais a n. Quando o número
natural é igual a 0, o seu fatorial é igual a 1.
De acordo com o que foi exposto, o método que descreve corretamente o fatorial do número
20 é:
12.
public static void main(String[] args) 
 { 
 long fat = 1; 
 for (int i = 1; i <= 5; i++){ 
 fat = fat * i; 
 } 
 }
 
 
a.
public static void main(String[] args) 
 { 
 long fat = 1; 
 for (int i = 1; i <= 20; i++){ 
 fat = fat * i; 
 } 
 }
 
 
b.
Alternativa (b)
public static void main(String[] args) 
 { 
 long fat = 1; 
 for (int i = 1; i <= 20; i++){ 
 fat = fat * i; 
 } 
 }
Enunciado Base
Os polinômios são expressões algébricas formadas por um arranjo de coeficientes e letras
(partes literais). As letras (por exemplo, a variável x) de um polinômio representam os
valores desconhecidos da expressão. O cálculo de um polinômio depende do valor dessa
variável x. O grau do polinômio é definido pelo número de elementos do arranjo. Por
exemplo, para o polinômio p(x)=a0+a1x+a2x2+a3x3" />,
public static void main(String[] args) 
 { 
 long fat = 20; 
 for (int i = 1; i <= 20; i++){ 
 fat = fat * i; 
 } 
 }
 
 
c.
public static void main(String[] args) 
 { 
 long fat = 1; 
 for (int i = 1; i <= 20; i++){ 
 fat = fat + i; 
 } 
 }
 
 
d.
public static void main(String[] args) 
 { 
 long fat = 1; 
 for (int i = 20; i >= 20; i++){ 
 fat = fat * i; 
 } 
 }
 
 
e.
o arranjo de coeficientes conterá sendo seu grau (3) obtido a partir do
tamanho do arranjo.
Baseado nas informações acima, observe as recomendações a seguir para a escrita de um
método que calcule o valor de um polinômio em um determinado ponto x:
 
 
O método deve receber um double que representa o ponto x e um arranjo de doubles,
representando os coeficientes do polinômio 
 
•
O método deverá retornar como resposta o valor de p(x) recebendo x e o arranjo de
coeficientes por parâmetro; 
 
•
Para elevar os x a seus expoentes, crie um método de potenciação ou utilize um
método já anteriormente abordado. 
 
•
Para começarmos a calcular o valor do polinômio, é necessário que nos parâmetros
tenhamos um arranjo de doubles. Arranjos são estruturas de dados, de tamanho fixo, que
permitem armazenar um conjunto de valores de um mesmo tipo. Para a implementação de
um arranjo de doubles de tamanho 10, o código correto está na alternativa:
13.
public static void main(String[] args){ 
 int[] d = new int[10]; 
 for (int i=0; i<10; i++){ 
 d[i] = i; 
 System.out.println("O vetor de double na posição "+i+ " é: "+d[i]); 
 } 
}
 
 
a.
public static void main(String[] args){ 
 for (int i=0; i<10; i++){ d[i] = i; 
 System.out.println("O vetor de double na posição "+i+ " é: "+d[i]); 
 } 
}
 
 
b.
public static void main(String[] args){ 
 double[] d = new double; 
 for (int i=0; i<10; i++){ 
 d[i] = i; 
 System.out.println("O vetor de double na posição "+i+ " é: "+d[i]); 
 }}
c.
Alternativa (e)
public static void main(String[] args){ 
 double[] d = new double[10]; 
 for (int i=0; i<10; i++){ 
 d[i] = i; 
 System.out.println("O vetor de double na posição "+i+ " é: "+d[i]); 
 } 
}
 
 
 
 
public static void main(String[] args){ 
 double[] d = new double[10]; 
 for (int i=0; i<10; i++){ 
 d[i] = 10; 
 System.out.println("O vetor de double na posição "+i+ " é: "+d[i]); 
 } 
}
 
 
d.
public static void main(String[] args){ 
 double[] d = new double[10]; 
 for (int i=0; i<10; i++){ 
 d[i] = i; 
 System.out.println("O vetor de double na posição "+i+ " é: "+d[i]); 
 } 
}
 
 
e.
Objetivo de aprendizagem: Calcular o valor de um polinômio utilizando o laço de
repetição for.
Com base nas orientações apresentadas, o código para o cálculo do valor de um polinômio
p(x) é:
14.
static double valor(double x, double[] coef) { 
 double resp = 0; 
 for (int i=0; i<coef.length; i++) 
 resp += coef[i] * eleva (x, i); 
 // ou resp = resp + coef[i] * eleva(x,i); 
 return(coef); 
}
a.
Alternativa (d)
public static void main(String[] args){ 
 double[] d = new double[10]; 
 
 
static double valor(double x, double[] coef) { 
 double resp = 0; 
 for (int i=0; i<coef.length; i--) 
 resp += coef[i] + eleva (x, i); 
 // ou resp = resp + coef[i] + eleva (x, i); 
 return(resp); 
}
 
 
b.
static double valor(double x, double[] coef) { 
 double resp = 0; 
 for (int i=0; i<coef.length; i++) 
 resp += coef[i] * eleva (x, i); 
 // ou resp = resp + coef[i] * eleva (x, i); 
 return(resp); 
}
 
 
c.
public static void main(String[] args){ 
 double[] d = new double[10]; 
 for (int i=0; i<10; i++){ 
 d[i] = 10; 
 System.out.println("O vetor de double na posição "+i+ " é: "+d[i]); 
 } 
}
 
 
d.
static double valor(double x, double[] coef) { 
 double resp = 0; 
 for (int i=0; i<coef.length; i++) 
 resp += coef[i] * eleva (x, i); 
 // ou resp = resp + coef[i] * eleva (x, i); 
 return(resp); 
}
 
 
e.
 for (int i=0; i<10; i++){ 
 d[i] = 10; 
 System.out.println("O vetor de double na posição "+i+ " é: "+d[i]); 
 } 
}
 
 
Escreva um método chamado contagemElementos que receba como parâmetro um arranjo
de inteiros chamado valores e um inteiro chamado x e retorna o número de vezes que o
valor x aparece dentro do arranjo valores. Implemente uma solução que iteraja pelos
elementos do arranjo (e não pelos índices) usando o segundo tipo de laço for ensinado
nesta semana).
Exemplo de solução:
public static int contagemElementos(int[] valores, int x){ 
 int resposta = 0; 
 for (int atual: valores){ 
 if (atual == x) resposta++; 
 } 
 return resposta; 
}15.
Escreva um método chamado contagemMaior que recebe dois arranjos de inteiros como
parâmetros (chamados arranjo1 e arranjo2), encontra o valor do maior elemento do arranjo1,
verifica quantas vezes esse valor ocorre no arranjo2 e imprime uma frase da seguinte forma:
O numero yyy aparece zzz vezes no arranjo2.
Sendo yyy o valor do maior elemento do arranjo1 e zzz a quantidade de vezes que esse
número ocorre no arranjo2. Você pode considerar que todos os valores presentes no
arranjo1 e no arranjo2 serão positivos.
Exemplo de solução:
static void contagemMaior(int[] arranjo1, int[] arranjo2){ 
 int maior = 0; 
 int contagem = 0; 
 for (int i=0;i<arranjo1.length;i++){ 
 atual = arranjo1[i]; 
 contagem = 0; 
 for (int i=0;i<arranjo1.length;i++){ 
 if (arranjo2[j] == maior) contagem++; 
 } 
 System.out.println("O numero " + maior + " aparece " + contagem + " vezes no arranjo2."); 
}
16.
 
 
Escreva um método chamado contagemTodos que recebe dois arranjos de inteiros como
parâmetros (chamados arranjo1 e arranjo2), e para cada elemento do arranjo1 verifica
quantas vezes esse elemento ocorre no arranjo2 e imprime uma frase da seguinte forma:
O numero yyy aparece zzz vezes no arranjo2.
Sendo yyy o valor de um elemento do arranjo1 e zzz a quantidade de vezes que esse
número ocorre no arranjo2. Note que se o arranjo1 possuir, por exemplo, cinco elementos,
então cinco linhas serão impressas.
Exemplo de solução:
static void contagemTodos(int[] arranjo1, int[] arranjo2){ 
 int atual; 
 int contagem; 
 for (int i=0;i<arranjo1.length;i++){ 
 atual = arranjo1[i]; 
 contagem = 0; 
 for (int j=0;j<arranjo2.length;j++){ 
 if (arranjo2[j] == atual) contagem++; 
 } 
 System.out.println("O numero " + atual + " aparece " + contagem + " vezes no arranjo2."); 
 } 
}
 
 
17.
Crie um método que, dados dois vetores vec e sub, verifica se sub é uma subsequência de
vec. Por exemplo, o vetor {9, 5} é uma subsequência de {3, 9, 5, 4, 8}, mas o vetor {9, 4} não
é.
Dois exemplos de implementação possíveis:
static boolean subSequencia(int[] vec, int[] sub) { 
 int i = 0; 
 for (int val : vec) { 
 //i = (sub[i] == val) ? i + 1 : 0; 
 if (sub[i] == val) { 
 i++; //sequência batendo! 
 } else { 
 i = 0; //valor não é parte da sequência: volta à estaca zero 
 } 
 if (i == sub.length) { 
 // final de "sub" atingido: ele está contido em "vec"! 
 return true; 
 } 
18.
 } 
 return false; //só chegamos aqui se sub não for parte de vec 
}
static boolean subSequencia(int[] vec, int[] sub) { 
 int i = 0; 
 for (int val : vec) { 
 //incrementa i se valor estiver na sequência de "sub" 
 i = (sub[i] == val) ? i + 1 : 0; 
 if (i == sub.length) { 
 // final de "sub" atingido: ele está contido em "vec"! 
 return true; 
 } 
 } 
 return false; //só chegamos aqui se sub não for parte de vec 
}
 
 
(DESAFIO) Crie um método “inverteVec(int[] vec)” que inverta o conteúdo de um vetor. Por
exemplo, se o conteúdo do vetor for [1, 2, 3, 4, 5], ele se torna [5, 4, 3, 2, 1]. Testar seu
código com o método main dado abaixo.
class Testador { 
 static void inverteVec(int[] vec){ 
 //seu código aqui 
 } 
 
 public static void main(String[] args) { 
 int[] vec = {1, 2, 3, 4, 5}; // cria vetor para teste 
 for (int i : vec) { // imprime vetor de testes 
 System.out.print(i + " "); 
 } 
 System.out.println(""); // pula uma linha 
 inverteVec(vec); // inverte vetor de testes 
 for (int i : vec) { // deve imprimir ordem invertida 
 System.out.print(i + " "); 
 } 
 } 
}
static void inverteVec(int[] vec){ 
 // Deve-se percorrer apenas metade do vetor, ou então a troca acaba ocorrendo duas vezes... 
 for (int i = 0; i < vec.length/2; i++) { 
 //guarda valor do lado esquerdo 
 int aux = vec[i]; 
 //sobrescreve valor da esquerda com o da direita 
 vec[i] = vec[vec.length - i - 1]; 
19.
 
 
 //sobrescreve valor da direita com o (antigo) da esquerda 
 vec[vec.length - i - 1] = aux; 
 } 
}
 
 
(DESAFIO) Crie um método caixaAlta(char[] frase) que, dado um vetor de caracteres, coloca
todos os caracteres em caixa alta. Ou seja, ‘a’ é transformado em ‘A’, ‘b’ é transformado em
B, e assim por diante. Faça a conversão de caixa baixa para alta usando operações
aritméticas apenas, não uma “tabela de tradução” ou algo assim.
DICA: procure na internet pela tabela ASCII e verifique a distância entre um caractere em
caixa baixa qualquer e sua versão em caixa alta.
static void caixaAlta(char[] frase){ 
 //seu código aqui 
}
static void caixaAlta(char[] frase){ 
 for (int i = 0; i < frase.length; i++) { 
 if(frase[i] >= 'a' && frase[i] <= 'z'){ 
 frase[i] = (char) (frase[i] - 32); 
 } 
 } 
}
 
 
20.
MOSTRAR GABARITO