Ir ao conteúdo
  • Cadastre-se

Anatanael Barbosa

Membro Júnior
  • Posts

    13
  • Cadastrado em

  • Última visita

Reputação

5
  1. Dada a classe ItemOrcamento que representa um item de um orçamento: public class ItemOrcamento { private String historico; private float valor; public ItemOrcamento(String historico, float valor) { this.historico = historico; this.valor = valor; } public String getHistorico() { return historico; } public float getValor() { return valor; } } Escreva uma classe herdeira de ItemOrcamento denominada ItemOrcamentoComplexo que mantenha um vetor com subitens de orçamento que podem ser da classe ItemOrcamento ou da classe ItemOrcamentoComplexo. A classe implementa os seguintes métodos: Construtor: Além dos parâmetros da superclasse, recebe como parâmetro o vetor com os subitens de orçamento. getValor: Sobrescreve o método da superclasse, retornando a soma de valores de todos os subitens de orçamento. encontraItem: Recebe como parâmetro o histórico de um subitem (String) e retorna o objeto correspondente ao subitem que possui este histórico, se existir. Se não existir retorna null. Eu fiz a classe ItemOrcamentoComplexo public class ItemOrcamentoComplexo extends ItemOrcamento{ ItemOrcamento subItens[]; public ItemOrcamentoComplexo(String historico, float valor, ItemOrcamento[] subItens) { super(historico, valor); this.subItens = subItens; } @Override public float getValor() { float somaValores = 0; for (int i = 0; i < subItens.length; i++) { somaValores += subItens[i].getValor(); } return somaValores; } public ItemOrcamento encontraItem(String historico) { for (int i = 0; i < this.subItens.length; i++) { if (this.subItens[i].getHistorico().equals(historico)) { return subItens[i]; } } return null; } } E a main public class Questao02 { public static void main(String[] args) { ItemOrcamento[] subItens = new ItemOrcamento[4]; subItens[0] = new ItemOrcamento("Pão de centeio", 1.25f); subItens[1] = new ItemOrcamento("Marraqueta", 1.30f); subItens[2] = new ItemOrcamento("Hallula", 1.90f); subItens[3] = new ItemOrcamento("Pão alentejano", 2.4f); ItemOrcamentoComplexo itemComplexo = new ItemOrcamentoComplexo("Paes", 20, subItens); ItemOrcamento procurar; procurar = itemComplexo.encontraItem("Hallula"); if (procurar != null) { System.out.println(procurar.getHistorico() +" R$" + procurar.getValor()); } else { System.out.println("Não existe"); } ItemOrcamento itemNormal = new ItemOrcamento("Cabo", 25.3f); System.out.println(itemNormal.getHistorico() +" R$" + itemNormal.getValor()); } } Minha duvida é: "Escreva uma classe herdeira de ItemOrcamento denominada ItemOrcamentoComplexo que mantenha um vetor com subitens de orçamento que podem ser da classe ItemOrcamento ou da classe ItemOrcamentoComplexo" Como o vetor pode ser da classe "ItemOrcamentoComplexo" ? Porque se o vetor for do tipo "ItemOrcamentoComplexo", quando eu for instanciar um novo subitem, este vai precisa de um outro sub item e este de outro, assim por diante. E outra duvida, quando for criar um "ItemOrcamentoComplexo", é necessário passar o nome, o valor e o vetor de subItens. Para que serve este valor, já que o calculo do "valor do ItemOrcamentoComplexo" é a soma dos subitens ?
  2. Obrigado pelas observações. Fiz as atualizações. #include <stdio.h> #include <stdlib.h> #include <math.h> int main() { int i, j, primo = 0, raizQuad; float somaPrim = 2; long int somaPrimLI = 2; long long somaPrimLL = 2; float somaPrimF = 2; double somaPrimD = 2; /* i -> Contador de 3 a 2000000 obs. (inicia no 3 pois o unico numero primo par é 2) e (conta de 2 em 2) j -> Contador de 1 ate o i (atual) para verificar quantos divisores tem o numero primo -> Se o resultado final for 1 então é primo senão não é primo raizQuad -> Calcula a raiz quadrada do i atual somaPrim -> soma dos primos (inicia no 2 pois o 2 é o unico numero primo par */ for (i = 3; i < 2000000; i += 2) { primo = 1; raizQuad = (int)sqrt(i); for (j = 3; j <= raizQuad; j += 2) { if (i % j == 0) { primo = 0; break; // Se entrar no if significa que quantidade de divisores eh maior que 2 logo sai do loop for } } if (primo) { somaPrim += i; somaPrimLI += i; somaPrimLL += i; somaPrimF += i; somaPrimD += i; } } //printf("A soma dos numeros primos abaixo de 2 milhoes eh: %lld\n\n", somaPrim); printf("long int: %ld\n\n", somaPrimLI); printf("long long: %lld\n\n", somaPrimLL); printf("float: %f\n\n", somaPrimF); printf("double: %lf\n\n", somaPrimD); system("pause"); return 0; } Realizei um teste com long int, long long, float e double. long int -> 11 79 908 154 long long -> 142 913 828 922 float -> 142 915 960 832 double -> 142 913 828 922 O resultado do long long deu igual ao do double, porém o double que tem precisão maior que o float encontrou um resultado menor. Porque ocorre isso ?
  3. O long int não foi suficiente, me parece que o long long funcionou. Realizei um teste com long int, long long, float e double. #include <stdio.h> #include <stdlib.h> #include <math.h> int main() { int i, j, quantDiv = 0; float somaPrim = 2; long int somaPrimLI = 2; long long somaPrimLL = 2; float somaPrimF = 2; double somaPrimD = 2; /* i -> Contador de 3 a 2000000 obs. (inicia no 3 pois o unico numero primo par é 2) e (conta de 2 em 2) j -> Contador de 1 ate o i (atual) para verificar quantos divisores tem o numero quantDiv -> Quantidade de divisores o numero autal tem somaPrim -> soma dos primos (inicia no 2 pois o 2 é o unico numero primo par */ for (i = 3; i < 2000000; i += 2) { quantDiv = 2; // quantDiv = 2; -> Divisores o numero 1 e o proprio numero for (j = 3; j <= (int)sqrt(i); j += 2) { if (i % j == 0) { quantDiv += 2; // Incrementa 2 pois o teste é ate a raiz quadrada break; // Se entrar no if significa que quantidade de divisores eh maior que 2 logo sai do loop for } } if (quantDiv == 2) { somaPrim += i; somaPrimLI += i; somaPrimLL += i; somaPrimF += i; somaPrimD += i; } } //printf("A soma dos numeros primos abaixo de 2 milhoes eh: %f\n\n", somaPrim); printf("long int: %ld\n\n", somaPrimLI); printf("long long: %lld\n\n", somaPrimLL); printf("float: %f\n\n", somaPrimF); printf("double: %lf\n\n", somaPrimD); system("pause"); return 0; } O resultado do long long deu igual ao do double, porém o double que tem precisão maior que o float encontrou um resultado menor. long int -> 11 79 908 154 long long -> 142 913 828 922 float -> 142 915 960 832 double -> 142 913 828 922
  4. Muito obrigado pela excelente explicação. Fiz umas mudanças no código e funcionou perfeitamente. #include <stdio.h> #include <stdlib.h> #include <math.h> int main() { int i, j, quantDiv = 0; float somaPrim = 2; /* i -> Contador de 3 a 2000000 obs. (inicia no 3 pois o unico numero primo par é 2) e (conta de 2 em 2) j -> Contador de 1 ate o i (atual) para verificar quantos divisores tem o numero quantDiv -> Quantidade de divisores o numero autal tem somaPrim -> soma dos primos (inicia no 2 pois o 2 é o unico numero primo par */ for (i = 3; i <= 2000000; i += 2) { quantDiv = 2; // quantDiv = 2; -> Divisores o numero 1 e o proprio numero for (j = 3; j <= (int)sqrt(i); j += 2) { if (i % j == 0) { quantDiv += 2; // Incrementa 2 pois o teste é ate a raiz quadrada break; // Se entrar no if significa que quantidade de divisores eh maior que 2 logo sai do loop for } } if (quantDiv == 2) { somaPrim += i; } } printf("A soma dos numeros primos abaixo de 2 milhoes eh: %.0f\n\n", somaPrim); system("pause"); return 0; } 01º Modificação: Iniciei a variável 'quantDiv' com 2, pois todo numero já e divisível por ele mesmo e por 1, se encontrar algum outro divisor já pode sair loop retirando um 'if' desnecessário. 02º Modificação: O teste do 'for' é ate a raiz quadrada conforme a sua explicação. 03º Modificação: Modifiquei a variável 'somaPrim' para 'float' pois o resultado é superior ao espaço de uma 'int'. Muito obrigado pelo auxilio.
  5. O número 175 tem divisores acima da raiz quadrada. Raiz quadrada 175 -> 13.2 Divisores 175 -> 1, 5, 7, 25, 35, 175
  6. Faça um programa que calcule a soma de todos os números primos abaixo de dois milhões. Código que eu fiz. #include <stdio.h> #include <stdlib.h> int main() { int i, j, somaPrim = 2, quantDiv = 0; /* i -> Contador de 3 a 2000000 obs. (inicia no 3 pois o unico numero primo par é 2) e (conta de 2 em 2) j -> Contador de 1 ate o i (atual) para verificar quantos divisores tem o numero quantDiv -> Quantidade de divisores o numero autal tem somaPrim -> soma dos primos (inicia no 2 pois o 2 é o unico numero primo par */ for (i = 3; i <= 2000000; i += 2) { quantDiv = 0; for (j = 1; j <= i; j++) { if (i % j == 0) { quantDiv++; } // Se quantidade de divisores for maior que 2 sair do loop if (quantDiv > 2) { break; } } if (quantDiv == 2) { somaPrim += i; } } printf("A soma dos numeros primos abaixo de 2 milhoes eh: %d\n\n", somaPrim); system("pause"); return 0; } Mesmo iniciando a soma dos primos com o 2 (pois é o único numero par primo), e com um loop para testar apenas números impares o programa não termina. Minha duvida é se entrou em um loop infinito ou são muitos cálculos.
  7. Quando encontra um numero palíndromo testa com o produto de i * j, se o produto for menor então sair do loop. Entendi, excelente resolução. Muito obrigado pela ajuda!
  8. Muito obrigado, com sua solução consegui resolver o exercicio. #include <stdio.h> #include <stdlib.h> #include <math.h> int main() { int num1, num2, prod, numInverso = 0, temp, quantDig = 0, cifra, maiorPalindromo = 0, fatorMaior1, fatorMaior2; /* num1 -> 1º Numero de tres digitos num2 -> 2º Numero de tres digitos prod -> Produto entre o 1º e 2º numeros temp -> Temporaria utilizada para contagem de digitos do produto e para inverter o produto quantDig -> Quantidade de digitos do produto cifra -> Um algarismo do produto (Utilizada para inverter o produto) maiorPalindromo -> O maior palindromo formado pelo produto fatorMaior1 e fatorMaior2 -> Sao os fatores que resultam no maior numero palindromo */ for (num1 = 999; num1 >= 100; num1--) { for (num2 = num1; num2 >= 100; num2--) { prod = num1 * num2; if (prod > maiorPalindromo) { // Contagem de digitos do produto temp = prod; while (temp != 0) { quantDig++; temp /= 10; } // Inversao do produto temp = prod; numInverso = 0; while(temp != 0) { cifra = temp % 10; numInverso += cifra * pow(10, quantDig - 1); temp /= 10; quantDig--; } // Comparacao se eh um numero palindromo if (prod == numInverso) { maiorPalindromo = numInverso; fatorMaior1 = num1; fatorMaior2 = num2; } } } } printf("O maior palindromo eh formado pela multiplicacao de %d x %d = %d\n\n", fatorMaior1, fatorMaior2, maiorPalindromo); system("pause"); return 0; }
  9. #include <stdio.h> #include <stdlib.h> int main() { // Todos os palindromos de 6 digitos int a, b, c; c = 99; for (a = 99; a >= 10; a--) { if (c < 0) { c = ((a % 10) * 10 + (a / 10)); } for (b = 99; b >= 0; b -= 11) { printf("%d\n", a * 10000 + b * 100 + c); } c -= 10; } system("pause"); return 0; } Aqui eu tenho todos os palíndromos de 6 dígitos, porém não acho uma forma de verificar se o número é formado por uma multiplicação de dois números de 3 dígitos cada.
  10. Faça um programa que calcule o maior número palíndromo feito a partir do produto de dois números de 3 dígitos. Ex: O maior palíndromo feito a partir do produto de dois números de dois dígitos é 9009 = 91*99. Tentei multiplicar 100 x 100, 100 x 101, 100 x 102, ... ate 999 x 999 mas o numero de cálculos é grande demais.
  11. Tentei trocar o "1" da idade por "30000", resolveu o problema do "menos" porém o mais sempre fica "30000". adicionado 3 minutos depois Refiz tudo, e troquei a parte do "caso" por "se", e também o "enquanto" por "repita". Deu certo agora algoritmo "Média_de_idades" var idade,cont,soma,maior,menor:inteiro media:real inicio soma<-0 cont<-0 repita escreva("Digite a idade:") leia(idade) cont<-cont+1 se cont = 1 então maior <- idade menor <- idade fimse se idade<>0 então se idade > maior então maior <- idade senao se idade < menor então menor <- idade fimse fimse fimse soma<-soma+idade ate idade = 0 media<-soma/(cont-1) escreval("A média de idades é:",media) escreval("A menor idade é:",menor) escreval("A maior idade é:",maior) fimalgoritmo Só ficou uma dúvida, esse código poderia ser feito com o "enquanto" em vez do "repita" ? Tentei aqui mais não deu certo.
  12. Fazer um algoritmo que: • Leia um número indeterminado de linhas contendo cada uma a idade de um indivíduo. • A última linha que não entrará nos cálculos, contém o valor da idade igual a zero. • Calcule e escreva a idade média deste grupo de indivíduos. • Escreva também a maior idade e a menor Conseguir fazer ele, o problema é quando vai escrever a idade menor sempre da 1: algoritmo "Média_de_idades" // Função : Calcular a média de idades de qualquer número de pessoas // Autor : Anatanael Fonseca Barbosa // Data : 13/04/2018 // Seção de Declarações var cont,soma,idade,maior,menor:inteiro media:real inicio cont<-0 soma<-0 idade<-1 menor<-idade maior<-idade enquanto (idade>0) faca escreva("Digite a idade:") leia(idade) escolha idade caso 0 outrocaso se (idade < menor) então menor <- idade senao se idade > maior então maior <- idade fimse fimse fimescolha cont<-cont+1 soma<-soma+idade fimenquanto media<-soma/(cont-1) escreval("A média de idades é:",media) escreval ("MAIOR:",maior) escreval ("MENOR:",menor) fimalgoritmo

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas comunidades sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×
×
  • Criar novo...