Vetores em JAVA

Olá,
Pretendo criar um programa que leia um conjunto de valores, analise-os e calcule a melhor forma de omar esses valores utilizando o menor numero possivelpara dar um determinado valor. Como faço isso?
Por ex:. os valores: 40, 30, 70, 10, 15
O menor numero de somas para dar 100 seria 30 + 70.
Obrigado

primeiro, vc precisa declarar um vetor de N posições. depois de declarar, leia as N posições e ordene o vetor, vai facilitar muito.

caso seu prof ainda n tenha ensinado, procure por “métodos de ordenação”, tem bastante conteúdo na internet.

dps de ordenar, já com o vetor pronto,

[10, 15, 30, 40, 70]

vc vai ler um inteiro S, (que vai ser a soma), e verificar quais as duas menores parcelas que formam a soma lida pelo usuário.

por exemplo:

10

10 + 15 = 100?
não

10 + 30 = 100?
não

10 + 40 = 100?
não

10 + 70 = 100?
não

ent vamos tentar com outro número:

15

15 + 15 = 100?
não

15 + 30 = 100?
não

15 + 40 = 100?
não

15 + 70 = 100?
não

outro número:

30

30 + 15 = 100?
não

30 + 30 = 100?
não

30 + 40 = 100?
não

30 + 70 = 100?
opa, encontramos!

o programa vai retornar 30 e 70 como sendo as menores parcelas do total de 100

não vou disponibilizar o código-fonte pq o exercício é de raciocínio, mas n é um bicho de sete cabeças. no começo a gente tem q quebrar a cabeça msm

se precisar de mais ajuda, pode subir o código aqui, to disposto a ajudar

1 curtida

vou facilitar um pouquinho, mas acho show de bola vc pesquisar dps sobre métodos de ordenação.

segue o código com o método de ordenação bubble sort, eu acho mais didático

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        // declarando vetor
        int vet[] = new int[5];

        // lendo vetor
        for(int i = 0; i < 5; ++i) {
            vet[i] = sc.nextInt();
        }

        /* ordenando vetor
         * (pesquise por bubble sort)
         */ 
        for(int i = 0; i < 5; ++i) {
            for(int j = 0; j < 4; ++j) {
                if(vet[j] > vet[j + 1]) {
                    int aux = vet[j];
                    vet[j] = vet[j + 1];
                    vet[j + 1] = aux;
                }
            }
        }

        // exibindo vetor
        for(int i = 0; i < 5; ++i) {
            System.out.print(vet[i] + " ");
        }
    }
}

obs.: é um código genérico, vc pode resolver vários exercícios com ele

1 curtida

Olá, não é bem isso que eu pretendo.
Se eu tiver os seguintes valores: 13, 15, 15, 19
e eu quero saber quais as somas a efectuar de forma a dar no minimo 29 ou o menor valor possivel a cima.
E utilizando o menor numero de somas possivel

Neste exemplo o programa tinha que retornar 15 + 15 = 30

entendi. mas no código-fonte só mudaria o operador, ent dá no msm

número: 10

10 + 15 >= 100?
não

10 + 30 >= 100?
não

10 + 40 >= 100?
não

10 + 70 >= 100?
não

outro número: 15

15 + 15 >= 100?
não

15 + 30 >= 100?
não

15 + 40 >= 100?
não

15 + 70 >= 100?
não

outro número:

30

30 + 15 >= 100?
não

30 + 30 >= 100?
não

30 + 40 >= 100?
não

30 + 70 >= 100?
encontramos de novo

1 curtida

como posso passar essa logica para java?

vou mostrar como faz por etapas, mas é importante que vc entenda. n tem como aprender se n praticar

seguinte, dps de ler e ordenar o vetor com bubble sort, vc pode criar dois laços.
dois laços pq vc precisa comparar um número fixo com os demais.

por ex.:
número fixo: 10
os demais: 15, 30, 40, 70

10 + 15 >= 100?
10 + 30 >= 100?
10 + 40 >= 100?
10 + 70 >= 100?

o primeiro laço vai “fixar” um dos números:

for(int i = 0; i < 5; ++i) {

}

já o segundo, dentro do primeiro:

for(int i = 0; i < 5; ++i) {
	for(int j = 0; j < 5; ++j) {

	}
}

vai percorrer o vetor comparando os demais com o número fixo.

uma coisa que n ficou mt clara, mas q tem como resolver no código, é se ele pode se somar e comparar a soma dele com a soma q o usuário informou. se n for, tem como corrigir com um if:

for(int i = 0; i < 5; ++i) {
	for(int j = 0; j < 5; ++j) {
		if(i != j) {
		
		}
	}
}

dps, vc verifica se a soma do vet[i] (número fixo) com o vet[j] (outro número) é maior ou igual à variável S, ou seja, a soma informada pelo usuário

for(int i = 0; i < 5; ++i) {
	for(int j = 0; j < 5; ++j) {
		if(i != j) {
			if(vet[i] + vet[j] >= S) {
				System.out.println("o menor número de somas para dar " + S + " seria " + vet[i] + " + " + vet[j]);
			}
		}
	}
}

mas tem coisa estranha q n vai funcionar com os laços aí
seu último exemplo:

[13, 15, 15, 19]

tem certeza q a saída do programa é 15 + 15? pq na teoria, 13 é menor q 15 e o programa retornaria 13 + 19 = 32…