seehr große zahlen addieren

count0r schrieb:

// wie jetzt weiter, die zahlen a und b müsste ich jetzt rechtsbündig

geht, muss aba nit unbedingt.
geh ans ende von a und b mit je einem zeiger und dann arbeite quasi von hinten.
oda mach string reversion und arbeite von vorne.

mfg

SeppJ

count0r schrieb:

z.b. a > DOUBLE_MAX etc.

Wow, größer noch als unendlich?
:p

SeppJ schrieb:

count0r schrieb:

z.b. a > DOUBLE_MAX etc.

Wow, größer noch als unendlich?
:p

DOUBLE_MAX == ∞ ?!
Uaaau!! (uaau == wow (;)))

hier nen ansatz wennze von vorne lieber hast.
guckste hier brudah:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define USER_PC_EXPLODE exit(0)

// cute help0r functionz ***********************
unsigned clear_stdin(void)
{
	int c;
	unsigned n = 0;
	while((c = getchar()) != '\n' && c != EOF)
		n++;
	return n;
}

char* remlf(char buf[])
{
	char* p = strrchr(buf, '\n');
	if(p != NULL)
		*p = 0;
	return p;
}
// *********************************************

// a und b haben die einer an index-position 0
char* add_biiiiig_integers(char* a, char* b, char* result) 
{
	int carry = 0;
	while(*a || *b)
	{
		int sum = 0;
		if(*a)
			sum = *a - '0', a++;
		if(*b)
			sum += *b - '0', b++;
		sum += carry;
		if(sum > 9)
			carry = 1, sum = sum % 10;
		else
			carry = 0;
		*result += sum + '0';
		result++;
	}
	if(carry)
		*result = carry + '0';
}

int main(void)
{
	char a[100], b[100];
	char* result=0;
	size_t result_size;

	memset(a, 0, sizeof(a));
	memset(b, 0, sizeof(b));

	puts("Gib 2 groooße Zahlen ein, die addiert werden sollen.(maximal 98 ziffern!)");
	printf("Zahl 1: ");
	fgets(a, sizeof(a), stdin);
	if(NULL == remlf(a) && 1 != clear_stdin())
	{
		puts("Depp! Sooo große nu auch wieda net!");
		USER_PC_EXPLODE;
	}

	printf("Zahl 2: ");
	fgets(b, sizeof(b), stdin);
	if(NULL == remlf(b) && 1 != clear_stdin())
	{
		puts("Depp! Sooo große nu auch wieda net!");
		USER_PC_EXPLODE;
	}

	if(strlen(a) > strlen(b))
		result = malloc(result_size = (strlen(a)+2)); // +1 terminator, +1 möglicher übertrag -> 1+1 = 2 :O
	else
		result = malloc(result_size = (strlen(b)+2));

	memset(result, 0, result_size);

	strrev(a);
	strrev(b);
	add_biiiiig_integers(a,b,result);
	strrev(result);
	puts(result);
	free(result);
	getchar();
	return 0;
}

wennze bug findest poste pls.
greez

l.s.

SeppJ

count0r schrieb:

DOUBLE_MAX == ∞ ?!
Uaaau!! (uaau == wow (;)))

Nun, ganz streng genommen nicht, da das Makro DBL_MAX als größter, endlicher, repräsentierbarer Wert definiert ist, aber jede gängige Fließkommaimplementierung (es gibt praktisch nur eine) hat auch eine Darstellung für Unendlichkeiten und rechnet damit auch mathematisch korrekt.
Da du oben schriebst, dass du Werte größer DBL_MAX addieren möchtest, auch da habe ich so meine Zweifel: Der gängige Wert dafür ist ungefähr 2*10^308, also viel, viel, viel größer als alles, was in deine 100 chars rein passt.

Das Geheimnis dahinter ist, dass Fließkommazahlen nicht alle Ganzzahlen bis zu diesem Wert darstellen, eine Rechnung mit solchen Werten also "nur" eine gute^* Näherung wäre.

^*: Gut⁺, sofern man halbwegs weiß, was man tut.
⁺: Das heißt für alle praktischen Zwecke, außer Zahlentheorie, vollkommen ausreichend.

SeppJ schrieb:

count0r schrieb:

DOUBLE_MAX == ∞ ?!
Uaaau!! (uaau == wow (;)))

Nun, ganz streng genommen nicht, da das Makro DBL_MAX als größter, endlicher, repräsentierbarer Wert definiert ist,

war mir klar das es ein scherz war, darum hab ich zurückgespaßelt.

SeppJ schrieb:

Da du oben schriebst, dass du Werte größer DBL_MAX addieren möchtest, auch da habe ich so meine Zweifel: Der gängige Wert dafür ist ungefähr 2*10^308, also viel, viel, viel größer als alles, was in deine 100 chars rein passt.

das array größer zu machen ist ja nicht wirlich das problem. irgendwann kann ich auch speicher mit malloc reservieren ...

little sista schrieb:

wennze bug findest poste pls.

dafür müsste ich den code erstmal verstehen. das kommmt aber früher oder später.
danke jedenfalls für den code

little sista schrieb:

wennze bug findest poste pls.

da ist nen bug drinnen, schwestachen.
add_biiiiig_integers gibt nix zurück und wenn, dann wird es vermutlich der inkrementierte zeiger sein oder was haste dir dabei gedacht?!
statt dessen zeiger kopieren(*1)!
und wenn result nicht calloct oder 0-memsettet(*2) übergeben wird, kommt grütze raus!
hab dir das a bisserl optimiert, flexibilisiert und verschönert wegen langeweile
guckst du hier sista:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
// cute help0r functi0nz ***********************

unsigned clear_stdin(void) 
{
	int c;
	unsigned n = 0;
	while((c = getchar()) != '\n' && c != EOF)
		n++;
	return n; // gibt die anzahl der zeichen zurück, die noch im stream-buffer waren und verworfen wurden
}

char* remlf(char buf[])
{
	char* p = strrchr(buf, '\n');
	if(p != NULL)
		*p = 0;
	return p;
}

char* strrv(char s[])
{
	char* a = s, *b = s;
	while(*b)
		b++;
	for(b -= 1; a < b; a++, b--)
	{
		char c = *a;
		*a = *b;
		*b = c;
	}
	return s;
}

char* read_line(FILE* fp, size_t* line_len)
{
	int c = 0;
	size_t line_buf_size = 2;
	size_t linelen = 0;
	char* line = malloc(line_buf_size);

	if(line == NULL)
		return NULL;
	while((c = fgetc(fp)) != '\n' && c != EOF)
	{
		line[linelen] = c;
		linelen += 1;
		if(linelen + 1 >= line_buf_size)
		{
			char* tmp = line;
			line = realloc(line, line_buf_size *= 2);
			if(line == NULL)
			{
				line = tmp;
				break;
			}
		}
	}
	line[linelen] = 0;
	if(line_len)
		*line_len = linelen;
	return line;
}

int check_big_unsigned_int(char* big_int)
{
	while(*big_int)
		if(!isdigit(*big_int++))
			return 0;
	return 1; // ok
}

// *********************************************

// a und b haben die einer an index-position 0
char* add_biiiiig_integers(char* a, char* b, char* result) 
{
	char* p = result; // (*1)
	int carry = 0;
	while(*a || *b)
	{
		int sum = 0;
		if(*a)
			sum = *a - '0', a++;
		if(*b)
			sum += *b - '0', b++;
		sum += carry;
		if(sum > 9)
			carry = 1, sum = sum % 10;
		else
			carry = 0;
		*p = 0; // (*2)
		*p += sum + '0';
		p++;
	}
	if(carry)
	{
		*p++ = carry + '0';
		*p = 0;
	}
	else
	{
		*p = 0;
	}
	return result;
}

int main(void)
{
	char* a = 0, *b = 0, *result = 0;
	size_t alen, blen;

	puts("Gib 2 groooße Zahlen ein, die addiert werden sollen.");
	printf("Zahl 1: ");
	a = read_line(stdin, &alen);
	printf("Zahl 2: ");
	b = read_line(stdin, &blen);

	if(a == NULL || b == NULL)
		goto ERR;
	if( ! check_big_unsigned_int(a) || ! check_big_unsigned_int(b))
		goto ERR;

	if(alen > blen)
		result = malloc(alen+2); // +1 terminator, +1 möglicher übertrag -> 1+1 = 2 :O
	else
		result = malloc(blen+2);

	if(result == NULL)
		goto ERR;

	strrv(a);
	strrv(b);
	puts(strrv(add_biiiiig_integers(a,b,result)));

ERR:
	free(a);
	free(b);
	free(result);
	getchar();
	return 0;
}

volkard

sist0r jiggl0r schrieb:

*p = 0; // (*2)
		*p += sum + '0';//nur = statt =0;+=, oder?
		p++;
	}
	if(carry)
	{
		*p++ = carry + '0';
		*p = 0;//vorsorglich nullen? einmal nach der schleife geht sicher auch
	}
	else
	{
		*p = 0;
	}
	return result;
}

ja, du hast völlig recht.
ich war ≤ (0.5 * herzig) bei der sache

char* add_biiiiig_integers(char* a, char* b, char* result) 
{
	char* p = result;
	int carry = 0;
	while(*a || *b)
	{
		int sum = 0;
		if(*a)
			sum = *a - '0', a++;
		if(*b)
			sum += *b - '0', b++;
		sum += carry;
		if(sum > 9)
			carry = 1, sum = sum % 10;
		else
			carry = 0;
		*p++ = sum + '0';
	}
	if(carry)
		*p++ = carry + '0';
	*p = 0;
	return result;
}

ahja.
naja.
hm.
relativ simpel. wie in der schule halt
schwer ist es allerdings das in code zu gießen
und wie mache ich das mit

char* multiply_biiiiiig_integers(char* a, char* b, char* result)
{
	// ???????????????????
	return result;
}

auch so wie in der schule oder lieber mit der finckschen pyramide?

count0r schrieb:

auch so wie in der schule?

yo!

gonzo++ schrieb:

count0r schrieb:

auch so wie in der schule?

yo!

macht ma erstma minus rechnen.
inner schule kommt nach plus erstmal minus!
hugh!