N! berechnen

[Geisterkarle]

hiho!
habe hier ne aufgabe bekommen, n! für große n berechnen!
und zwar nicht mit int, sonder mit nem eigenem datentyp ‚zahl‘.

so weit so gut, darf ich diese ‚zahl‘ entweder mit nem sehr langen feld oder strings mit dezimalziffern verwenden!

also sag ich

struct zahl
{
double n[1000]; // langes feld
}

aber bei der multiplikation die ich für diese aufgabe brauche, komm ich irgendwie scho ins stolpern! bin bei den aufgaben irgendwie zu weit vorraus, des hat mer noch nich so wirklich

oder kann ich einfach sagen:

zahl zahlmult(zahl x, zahl y)
{
zahl z;
z.n= x.n * y.n;
}
???

denn auf meinem aufgabenblatt steht irgendwas von zeichenweises berechnen wie in der grundschule!
(
487*351=

487 487*1
24350 487*5
146100 487*3

170937
)
des verwirrt mich irgendwie…
kann mich vielleicht einer aufklären
thx
Geisterkarle

[Fritze]

Hallo,

so weit so gut, darf ich diese ‚zahl‘ entweder mit nem sehr
langen feld oder strings mit dezimalziffern verwenden!

also sag ich

struct zahl
{
double n[1000]; // langes feld
}

So weit, so schlecht. Du solltest den Aufgaben lieber nicht so weit vorgreifen, sondern lieber die Theorie der älteren Aufgaben richtig durchdenken und nachvollziehen. Hier wäre ein Blick in das Kapitel „Speicherverwaltung“ nicht verkehrt. Stickworte „Stack“ und „Heap“. Variablen landen per se im Stack. Der Stack ist arg begrenzt. Da kann es schon mal Ärger geben, wenn man ein 1000 double großes Feld dort ablegen möchte. Eleganter wäre da sicher eine Konstruktion unter Verwendung von malloc (und damit dem Heap).

aber bei der multiplikation die ich für diese aufgabe brauche,
komm ich irgendwie scho ins stolpern! bin bei den aufgaben
irgendwie zu weit vorraus, des hat mer noch nich so wirklich

Aber Multiplizieren hattest Du doch – wie Du selbst sagst – bereits in der Grundschule. Und was für ein Dialekt ist das eigentlich, in dem Du da schreibst?

denn auf meinem aufgabenblatt steht irgendwas von
zeichenweises berechnen wie in der grundschule!

Dann solltest Du das wohl auch so machen, wenn das da steht. Ist eigentlich irgendwo definiert, wie groß „n“ maximal werden soll, von dem die Fakultät berechnet werden soll?

Es wächst nämlich n! stärker, als c*a^n für c,a,n>1. Das ist nicht von Pappe! Bis wohin reicht denn so dein 1000-er Feld, was meinst Du?

In jedem Fall solltest Du also Vorkehrungen treffen, falls es bei Berechnungen zu einem Speicherüberlauf kommt.

Gruß

Fritze

[Geisterkarle]

So weit, so schlecht. Du solltest den Aufgaben lieber nicht so
weit vorgreifen, sondern lieber die Theorie der älteren
Aufgaben richtig durchdenken und nachvollziehen. Hier wäre ein
Blick in das Kapitel „Speicherverwaltung“ nicht verkehrt.
Stickworte „Stack“ und „Heap“. Variablen landen per se im
Stack. Der Stack ist arg begrenzt. Da kann es schon mal Ärger
geben, wenn man ein 1000 double großes Feld dort ablegen
möchte. Eleganter wäre da sicher eine Konstruktion unter
Verwendung von malloc (und damit dem Heap).

aha interessant… dabei stand des beispüiel mit dem 1000er feld sogar inner aufgabe als bsp. ^^
malloc hammer noch gar net, wie funkt das?

Aber Multiplizieren hattest Du doch – wie Du selbst sagst –
bereits in der Grundschule. Und was für ein Dialekt ist das
eigentlich, in dem Du da schreibst?

des sieht so scheisse aus, da ich hier nich mit umschalt nen abstand schaffen kann!
vielleicht erinnerst du dich ja noch an die grundschule ^^
da wurde untereinander die einzelnen zahlen abgehandelt!
und dann halt verschoben!
ka, wie ich des in c++ realisieren soll…

Dann solltest Du das wohl auch so machen, wenn das da steht.
Ist eigentlich irgendwo definiert, wie groß „n“ maximal werden
soll, von dem die Fakultät berechnet werden soll?

Es wächst nämlich n! stärker, als c*a^n für c,a,n>1. Das
ist nicht von Pappe! Bis wohin reicht denn so dein 1000-er
Feld, was meinst Du?

wir sollen das funktionieren an n=100, also 100! zeigen.
ich möcht nich wissen, wieviel zeichen des sind ^^

In jedem Fall solltest Du also Vorkehrungen treffen, falls es
bei Berechnungen zu einem Speicherüberlauf kommt.

deshalb muss ja des feld lang genug sein!

Gruß

Fritze

gruß zurück
Geisterkarle

[Anonym]

Ahoi!

Guggn wir uns mal 2 Sachen an:

struct zahl
{
double n[1000]; // langes feld
}

Eine Struktur, die einen Zeiger enthält

zahl zahlmult(zahl x, zahl y)
{
zahl z;
z.n= x.n * y.n;
}

Wie soll das funcen?
Du willst 2 Zeiger multiplizieren?
Du musst die einzelnen Werte in dem Array multiplizieren, in etwa so:

zahl zahlmult(zahl x, zahl y)
{
zahl z;
double u = 0;
for (int i = 0; i

[Fritze]

Hallo,

aha interessant… dabei stand des beispüiel mit dem 1000er
feld sogar inner aufgabe als bsp. ^^
malloc hammer noch gar net, wie funkt das?

Ich fände es wirklich nett, wenn Du Deine Fragen auf Deutsch formulieren könntest.

Alle meine Aussagen beziehen sich übrigens auf C, nicht C++. Da kann es geringfügig anders aussehen, aber das Prinzip (Stack/Heap) gilt auch da.

Wenn Du Student bist, dann hast Du doch Zugang zu einer Bibliothek? Dann besorge Dir doch da mal ein paar Bücher zur Programmierung in C oder C++.

Beispiel für malloc:

#include 
#define FELD\_BREITE

int \* pheap;

if ((pheap = (int \*) malloc(FELD\_BREITE\*sizeof(double))) == NULL)
{
 printf("Fehler bei der Speicherzuteilung!\n");
 return (EXIT\_FAILURE);
}

[…]

Es wächst nämlich n! stärker, als c*a^n für c,a,n>1. Das
ist nicht von Pappe! Bis wohin reicht denn so dein 1000-er
Feld, was meinst Du?

wir sollen das funktionieren an n=100, also 100! zeigen.
ich möcht nich wissen, wieviel zeichen des sind ^^

In jedem Fall solltest Du also Vorkehrungen treffen, falls es
bei Berechnungen zu einem Speicherüberlauf kommt.

deshalb muss ja des feld lang genug sein!

Nein, deshalb musst Du Speicherüberläufe abfangen!

1000 Stellen hast Du ca. bei 450! erreicht.

Gruß

Fritze

[Peter_TOO]

Hallo Geisterkarle,

so weit so gut, darf ich diese ‚zahl‘ entweder mit nem sehr
langen feld oder strings mit dezimalziffern verwenden!

also sag ich

struct zahl
{
double n[1000]; // langes feld
}

Du solltest auf keinen Fall Floating-Point (FP) Variablen nehmen sondern nur Integer !!

Bei der FP entstehen immer Rundungsfehler bei der Darstellung.

denn auf meinem aufgabenblatt steht irgendwas von zeichenweises
berechnen wie in der grundschule!

487\*351=
--------
 487 = 487\*1 **\* 1**
 24350 = 487\*5 **\* 10**
146100 = 487\*3 **\*100**
---------
170937

des verwirrt mich irgendwie…

So sieht es auch besser aus

MfG Peter(TOO)

[Geisterkarle]

Ahoi!
Wie soll das funcen?
Du willst 2 Zeiger multiplizieren?
Du musst die einzelnen Werte in dem Array multiplizieren, in
etwa so:

zahl zahlmult(zahl x, zahl y)
{
zahl z;
double u = 0;
for (int i = 0; i

[Geisterkarle]

Du solltest auf keinen Fall Floating-Point (FP) Variablen
nehmen sondern nur Integer !!

Bei der FP entstehen immer Rundungsfehler bei der Darstellung.

so, hab nu auf ein long int n[1000]; umgestellt.
doch nu hab ich 1 problem:
wenn ich nu 8! rechnen will und mache den ersten schritt 8*7, komm ich auf 56; und diese 56 speichere ich jetzt in einer hilfsvariablen, die dann die ganzen einzelergebnisse (wie unten) zusammenzählt!
aber nehmen wir mal dieses beispiel:

denn auf meinem aufgabenblatt steht irgendwas von zeichenweises
berechnen wie in der grundschule!

487*351=

487 = 487*1 * 1
24350 = 487*5 * 10
146100 = 487*3 *100

170937

So sieht es auch besser aus

(tuts auch *g*)

nu hab ich in meiner hilfsvariablen 170937 gespeichert!
aber wenn ich nu müsst ich ja diese zahl in 1.7.0.9.3.7 umwandeln! (also jede zahl an eine neue stelle in meiner ‚zahl‘ -> x.n[0]=1; x.n[1]=7; …)
ansonsten könnt ichs ja gleich mit int machen, was ich ja aufgabenstellungsbetont nicht darf!
gibts da ne möglichkeit dafür??? denn dann hätt ichs…

MfG Peter(TOO)