Galera…
Alguem sabe como faço para somar numeros inteiros gigantes?
Acho que preciso implementar uma classe atraves de arrays pq quero somar qualquer tamanho de numeros bem maior que 32 bits…
me parece que tem uma classe feita em uma biblioteca que já faz isso…
alguém sabe qual é?
tem alguma implementada que me sirva de exemplo?
valew
Oi Dryca,
Para trabalhar com números de precisão arbitrária, tanto inteiros como em ponto flutuante, você pode usar respectivamente as classes java.math.BigInteger e java.math.BigDecimal.
[]´s
galera valew por lembrar dessa classe…
eu sei que seria muto mais facil usar essa classe
mas preciso de implementar essa classe…
nao posso usar o pacote, preciso faze-la
estava pensando em transformar o numero em String e depois pegar caracter por caracter colocar em doias arrays e somar…
mas queria um exemplo de codigo que fizesse isso.
Exemplo:
[code]public class NumerosLongos {
//com inteiros
int soma;
int n1, n2, n3;
//com bigInteger
BigInteger somaBig;
BigInteger n1Big, n2Big, n3Big;
//usando inteiros já soma com o operador normal.
public int somaInt(){
return this.soma = this.n1 + this.n2 + this. n3;
}
//com bigInteger é com método.
public BigInteger somaBigInteger(){
this.somaBig = this.n1Big;
this.somaBig = this.somaBig.add(n2Big);
this.somaBig = this.somaBig.add(n3Big);
/**
*De forma mais reduzida:
* this.somaBig.add(n1Big).add(n2Big).add(n3Big);
*/
return somaBig;
}
}[/code]
Pq vc não poderia utilizar? Elas não são pacotes de terceiros, fazem parte da API padrão do java.
nao posso usar pq é um trabalho que estou fazendo e é necessário que eu faça uma classe que faça exatamente a soma que a java.math.BigInteger faz.
Obrigado.
Trabalho da faculdade, aposto.
aaaaaaa taaaaaaa. não tinha percebido q era um trabalho. :roll:
boa sorte.
vc pode armazenar em um long, pois ele guarda diversos números, vc pode ver o padrão Money Implementado em java, pode te ajudar
http://www.javabuilding.com/academy/patterns/money.html
esse post do Sergio Taborda é muito interessante.
Vou dar um exemplo do que você pode fazer.
Digamos que você tenha os seguintes números:
31415926535897932384626433832795
e
27182818284590452353602874713527
Você sabe que ao somar esses dois números, o resultado deve ser
58598744820488384738229308546322
Vamos ver como se chega a esse resultado.
A primeira coisa é você criar um método que receba uma string, e converta para um array de ints, cada int contendo 9 algarismos.
Você põe os algarismos de trás para frente, de 9 em 9 posições.
Vou mostrar o que eu quero que você faça.
O comprimento da string 31415926535897932384626433832795 é 32. Isso quer dizer que eu tenho de quebrar em (32 + 9 - 1) / 9 = 4 pedaços. Então você cria um array de 4 ints, com o seguinte conteúdo:
a [0] = 433832795
a [1] = 932384626
a [2] = 926535897
a [3] = 31415
Mostro abaixo com os números de 1 a 9, para ficar mais fácil você entender de onde eu peguei os dígitos.
31415 926535897 932384626 433832795
56789 123456789 123456789 123456789
A mesma coisa você faz com 27182818284590452353602874713527, que vai dar:
b [0] = 874713527
b [1] = 452353602
b [2] = 818284590
b [3] = 27182
27182 818284590 452353602 874713527
56789 123456789 123456789 123456789
Agora é que vou realmente fazer a soma. Crie um array de ints cujo tamanho é igual ao maior tamanho entre os arrays a e b, mais um:
c[0] = a[0] + b[0] = 1308546322
c[1] = a[1] + b[1] = 1384738228
c[2] = a[2] + b[2] = 1744820487
c[3] = a[3] + b[3] = 58597
c[4] = 0
Você já está começando a entender? Agora vamos fazer uma correção porque, na nossa notação, todos os números não podem ter mais de 9 algarismos. Se o número tiver mais de 9 algarismos, então tire o algarismo que sobrar, e some-o com o número que está na próxima posição do array. Nesse caso:
c[0] = 1308546322, mas é >= 1000000000, então vamos achar o resto da divisão por 1000000000, que vai dar 308546322
Ou seja, c[0] = 308546322. A divisão de 1308546322 por 1000000000 dá 1, que será somada a c[1].
c[1] = 1384738228 + 1 = 1384738229
Achando o resto e fazendo a divisão, vemos que c[1] = 384738229 e devemos somar 1 a c[2].
c[2] = 1744820487 + 1 = 1744820488
Então c[2] = 744820488, devemos somar 1 a c[3]
c[3] = 58597 + 1 = 58598
c[4] = 0
Para converter o número de novo para uma string, devemos então pegar cada int no array c, e imprimi-lo com 9 algarismos, completando com zeros à esquerda se for o caso. Não se esquecer que é para pegar cada número de trás para frente. Pus alguns espaços para você entender melhor.
000000000 000058598 744820488 384738229 308546322
Agora, vamos comparar com o resultado esperado:
58598744820488384738229308546322
Viu? Deu igualzinho.
O que mostrei funciona em Java, C, VB, não importa a linguagem.
oi galera,
nao é trabalho de faculdade nao…
essa faz parte d uma serie de questoes que me foram passadas no meu trabalho.
esta é a unica que estou com duvida de como fazer, e gostaria só de algum exemplo ou ideia.
Obrigado entanglement :
vou tentar fazer o codigo e depois posto aqui.
A multiplicação é um bocadinho mais chata de fazer, e o algoritmo “ingênuo” (que é igual ao que você faria à mão) é um pouco ineficiente. Existem algoritmos mais eficientes para efetuar multiplicações de números grandes.
[quote=Felagund]vc pode armazenar em um long, pois ele guarda diversos números, vc pode ver o padrão Money Implementado em java, pode te ajudar
http://www.javabuilding.com/academy/patterns/money.html
esse post do Sergio Taborda é muito interessante.
[/quote]
O truque do long só se aplica ao padrão Money e não à soma de numero arbitráriamente grandes. É que o máximo valor de um long em dinheiro,em qualquer moeda, é grande o suficiente.
Para aritmética de inteiros enormes, BigInteger é o cara. A mecanismo do BigInteger é separar os algarismos numa array de int em que cada elemento vai de 0 a 9 e somar como fazemos à mão. mas o biginteger também é limitado ao numero de elementos num array que é a quantidade de inteiros positivos.
[quote=sergiotaborda][quote=Felagund]vc pode armazenar em um long, pois ele guarda diversos números, vc pode ver o padrão Money Implementado em java, pode te ajudar
http://www.javabuilding.com/academy/patterns/money.html
esse post do Sergio Taborda é muito interessante.
[/quote]
O truque do long só se aplica ao padrão Money e não à soma de numero arbitráriamente grandes. É que o máximo valor de um long em dinheiro,em qualquer moeda, é grande o suficiente.
Para aritmética de inteiros enormes, BigInteger é o cara. A mecanismo do BigInteger é separar os algarismos numa array de int em que cada elemento vai de 0 a 9 e somar como fazemos à mão. mas o biginteger também é limitado ao numero de elementos num array que é a quantidade de inteiros positivos.[/quote]
Sim normalmente uso o BigInteger, porém ela citou que não podia usar a API padrão na questão. por isso citei o money mas como referencia do que como solução.
Eu lembro de ter implementado isso em uma calculadora programável (TI-59) há várias décadas atrás.
Eu tinha implementado a adição, subtração, multiplicação e divisão.
Não sei se já falaram, mas você pode implementar o ALGORITMO BigNum.
Soma e subtração são bem fáceis de fazer… É na multiplicação e divisão que o bicho pega.
Editado: ali eles usam o BigInteger do Java pra mostrar como é feito na linguagem… Mas o princípio teórico acho que pode ser o mesmo. Veja este site, do Vinícius Fortuna (um dos top em algoritmos, na minha opinião), que tem os notebooks. O da PUC tem o algoritmo implementado em C.
Aliás, acho que ± (ou exatamente) o que o entanglement explicou.
oi galera
comecei a fazer o codigo de acordo com as instruçoes do entanglement:
dai tahficando assim
public class NumerosGigantes {
String pri = “311415926535897932384626433832795”;
String seg = " 58598744820488384738229308546322";
private void Somar(){
int i = Integer.parseInt(pri);
int j = Integer.parseInt(seg);
int[] a = new int[4];
a[0]= 433832795;
a[1]= 932384626;
a[2]= 926535897;
a[3]= 31415;
int[] b = new int[4];
b[0]= 874713527;
b[1]= 452353602;
b[2]= 818284590;
b[3]= 27182;
int[] c = new int[5];
c[0] = a[0] + b[0];
if (c[0]>= 1000000000){
c[0]= c[0]% 1000000000;
c[1]= c[0];
}
c[1]= a[1]+b[1];
if (c[1]>= 1000000000){
c[1]= c[1]% 1000000000;
c[2]= c[1];
}
c[2]= a[2]+b[2];
if (c[2]>= 1000000000){
c[2]= c[2]% 1000000000;
c[3]= c[2];
}
c[3]= a[3]+b[3];
c[4]=0;
}
}
qunado chega nessa parte:
Para converter o número de novo para uma string, devemos então pegar
cada int no array c, e imprimi-lo com 9 algarismos, completando com
zeros à esquerda se for o caso. Não se esquecer que é para pegar cada
número de trás para frente. Pus alguns espaços para você entender
melhor.
eu nao tenho ideia de como fazer…
uma ajuda?
Só vou indicar que, para imprimir um número com zeros à esquerda e com 9 casas, você pode usar String.format:
int n = 12345;
String s = String.format ("%09d", n); // 0 indica que devem ser usados 0's à esquerda. 9 é o número de casas. d é porque é um inteiro em decimal.
// s deve ficar com o valor "000012345"