Descobrir dois numeros em java

Programação
#1

Olá amigos. Existem dois numeros inteiros A e B. A soma de todos os inteiros, entre A e B resulta em 184468. Preciso criar um algoritmo que retorne esses dois numeros, porém nao consigo nem começar a descobrir isso. Poderiam me ajudar?
Obrigado

#2

Buenas @Kaique_Torres
Essa pergunta ficou bem vaga, mas para exibir os números voce pode usar o sys out:

public void exibirValores(){
System.out.println(“Valor de A:” + A + "\n Valor de B: " + B );
}

#3

Deixa ver se eu entendi corretamente, vamos dizer que o resultado fosse 15, entao A e B poderia ser:
1 e 5 (1 + 2 + 3 + 4 + 5 = 15)
4 e 6 (4 + 5 + 6 = 15)

É isso?

Problema interessante! Deve ter uma fórmula matemática para ajudar nisso, mas já que nao é meu forte, uma forma de achar esses números é basicamente tentar “todas” combinaçoes! Isso criaria um algoritmo quadrático, mas se abortar assim que encontrar a primeira combinaçao pode dar uma melhorada.

Pense assim, A pode ser qualquer valor entre 1 e 184468. Na realidade, por sempre ser a soma de pelo menos dois números, você pode contar apenas até a metade 92234.
Depois B pode ser qualquer valor entre A + 1 e 92234.

Para cada combinaçao, você verifica se a soma de todos números entre A e B é 184468.

Uma dica importante é que para fazer a soma de todos números entre, você usa a fórmula de uma P.A. Assim fica um simples cálculo (ao invés de mais um loop).

#4

Ola @Joao_Pilger no caso seria achar o intervalo que somado resultaria em 184.468. Um exemplo que sempre é usado é o intervalo de 1 a 100. A soma de todos os inteiros nessa sequência dá 5050.

#5

Seja “a[i]” os números da sequência, “a[0]” o primeiro termo, e “n” a quantidade de números da sequência

numero =    a[0]    +    a[1]    +    a[2]    + ... +     a[n - 1]    ; // O "a[1]" é igual a "a[0] + 1", "a[2]" é igual a "a[0] + 2",...
numero = (a[0] + 0) + (a[0] + 1) + (a[0] + 2) + ... + (a[0] + (n - 1)); // Separando o "a[0]"
numero = n * a[0] + 0 + 1 + 2 + ... + (n-1); // A soma "0" a "(n-1)" é uma somatória de progressão aritmética
numero = n * a[0] + (n * (0 + (n-1))) / 2; // Removendo o zero
numero = n * a[0] + (n * (n - 1) / 2);

Agora tem duas opções, chutar o valor de “n” ou de “a[0]”, farei uma simulação chutando valor de “n” para o número 18:

para n = 1 => 18
para n = 2 => 8.5 + 9.5
para n = 3 => 5 + 6 + 7
para n = 4 => 3 + 4 + 5 + 6
para n = 5 => 1.6 + 2.6 + 3.6 + 4.6 + 5.6
para n = 6 => 1/3 + 4/3 + 7/3 + 10/3 + 13/3 + 16/3 => 1/3 < 1, então termina

Se converter as sequências [2], [5] e [6] para inteiros e somar os números, não serão iguais a 18

#6

O peso maior é matemático.

Veja o desenvolvimento:

Progressão Aritimética + Soma dos Números de uma PA

Sn = soma dos números,
a1 = 1º termo da PA
an = enésimo/último termo da PA
r = razão
n = total de termos da PA

Início:

an = a1 + (n-1)r

Sn = (a1 + an)n/2

(a1 + an)n - 2Sn = 0

(a1 + (a1 + (n -1)r))n - 2Sn = 0

(a1 + (a1 + nr -r))n - 2Sn = 0

(a1 + a1 + nr -r)n - 2Sn = 0

(a1n + a1n + n²r -rn) - 2Sn = 0

(a1n + a1n + n²r -rn) - 2Sn = 0

n²r + 2a1n -rn - 2Sn = 0

rn² + (2a1 - r)n - 2Sn = 0

a = r
b = 2a1 -r
c = -2Sn

n = baskaraPositivo -> (-b + √ Delta)/2a

Como:

an = a1 + (n-1) r, então:

an = a1 + ( (-b + √ Delta)/2a - 1) r

É mais matemática e menos programação.
Corrigindo: Tem muito + matemática, pois só está capturando as somas quando a razão é 1.

#7

Vê se esse código te ajuda, utilizei mais ou menos a logica ai do amigo AbelBueno
Mas esse código só servira se o valor for um numero par, pois se for impar o valormetade ficara XX,05 então para números impares vc ainda terá q arrumar o código

int valor = 184468;
      int valormetade;
      valormetade = valor/2;
      int a,b;
        for (a = 1; a <=valormetade; a++) {
            b=valor-a;
            System.out.println("Valor de A:" + a + "\n Valor de B: " + b );
1 curtida
#8

Editando:
Consegui “desbloquear” a lógica, para aceitar razões diversas, inclusive com ponto flutuante, mas ainda não consigo compreender o porque do ajuste ser necessário.

Para a razão 28, foi gerado:

-> {a1: -24015, an: 24229.0, n: 1724.0, soma: 184468.0}
-> {a1: -11840, an: 12268.0, n: 862.0, soma: 184468.0}
-> {a1: -5592, an: 6448.0, n: 431.0, soma: 184468.0}
-> {a1: -5547, an: 6409.0, n: 428.0, soma: 184468.0}
-> {a1: -2120, an: 3844.0, n: 214.0, soma: 184468.0}
-> {a1: 240, an: 3208.0, n: 107.0, soma: 184468.0}
-> {a1: 46075, an: 46159.0, n: 4.0, soma: 184468.0}
-> {a1: 92220, an: 92248.0, n: 2.0, soma: 184468.0}

Com ponto flutuante:

Para a razão 0.6, foi gerado:

-> {a1: -110680, an: 110681.0, n: 368936.0, soma: 184468.0}

Para a razão 153.8

-> {a1: -32639, an: 33495.0, n: 431.0, soma: 184468.0}

A razão 1, já postei, e perdeu a graça, pena que não consegui entender porque seria necessário o ajuste a seguir:

n = baskaraPositivo -> (-b + √ Delta)/2a
n = Math.abs® != 1 ? n / (r * r) : n;

Espero que não fique decepcionado, pois, no momento, não pretendo postar a implementação. Mas o farei em alguns dias, pois o objetivo é que você procure uma forma de solucionar, creio que você possa compreender no momento.

Como a implementação está baseada no desenvolvimento que postei anteriormente, assim, é possível que algum membro ou até mesmo você possa postar a implementação antes, ou a própria versão mesmo.
Para o seu caso o ajuste que fiz não é necessário, pois quando a razão é 1 não tem “divergência”.

Go ahead.

#9

@anon62916717 Realmente é bastante matemática. Interessante esse Range que você colocou. A resposta dessa questão está na linha em que a1 = 213 e an = 643. A soma de todos os números nesse intervalo é 184468. Muito obrigado pela ajuda de todos

#10

É possível fazer sem tanta matemática:

int numero = 184468;
int a0 = numero - 1;
int aN = a0;
int soma = 0;

while (aN > 0) {
  soma += aN;
  if (soma == numero) imprime(a0, aN);
  if (soma >= numero) { soma -= a0; a0 -= 1; } // remove a0 da soma e move o a0
  aN -= 1; // move aN
}

// 23062 23055
// 1777 1671
// 643 213