Hi.
Ich sehe das auch, daß die Funktion nicht sauber ist, aber es funktioniert.
Wie würdest du die Funktion und Berechnung stellen.
die Konstanten:
# define SCHALL 330.0
#define ERDBESCHL 9.81
/*************************************/
double zeit,;
double tiefe, tiefe1, tiefe2;
double x, y;
Gruß
Juno
Sorry,
die Anweisung i=0 hat sich irgenwie dareinkopiert. Selbstverständlich gehört sie nicht dazu und hat überhaupt keine Bedeutung.
mfg
Juno
Ich schreibe einfach , was ich gemacht habe.
- Nach case ' I' und die Funktion:
case 'r': /* Berechning der Tiefe nach Eingabe */
case 'R': /* der gemessenen Zeit durch Rekursion */
addstr("\n\n\n\t\t Zeit vom Loslassen des Steines bis zum ");
addstr("\n\t\t Eintreffen des Schalls in Sekunden : ");
get_string(str);
sscanf(str,"%lf",&zeit);
printf("\n");
tiefe=(0.5*(zeit*zeit*ERDBESCHL));
zeit=(tiefe/SCHALL+ sqrt(2.0*tiefe/ERDBESCHL));
x = SCHALL*sqrt(2.0/ERDBESCHL);
y =SCHALL*zeit;
i=0;
schacht_tiefe(0.5*ERDBESCHL*zeit*zeit);
wait();
break;
***********************************************************************/
/* Die Funtion 'schacht_tiefe()'- Rekursive Berechnung */
/**********************************************************************/
double schacht_tiefe(double rekursion)
{
char str[100];
i++;
sprintf(str,"\t\t %1d .Berechnungslauf: %5.3lf Meter\n",i,rekursion);
addstr(str);
if (fabs(rekursion+x*sqrt(rekursion)-y)>10.e-3)
rekursion = schacht_tiefe((2.0*y*sqrt(rekursion)-x*rekursion)/(2.0*sqrt(rekursion)+x));
return(rekursion);
}
mfg
Juno
Ja das ist mir klar. Es geht eigentlich um die richtige Rekursion- Funktion.
Wie würdest Du das lösen.
mfg
Juno
Hallo.
Die Frage ist:
Statt Iterationsberechnung im Menü unter Case 'I' aufgefürte Iterationsberechnung-Rekursionfunktion -"rekursion() "anwenden .
mfg
Juno
Hi.
ich melde mich wieder mit der neuen Aufgabe zur Diskusion.
Die Tiefe eines Schachts oder Brunnen können wir in Kurzer Zeit errechnen, wenn wir einen Stein hinunterfallen lassen und die Zeitspanne vom Loslassen des Steins bis zum Eintrefen des Schalls nach dem Aufprall möglichst genau messen.
Berechnung durch Iteration.
Zu erst Rechnung von der Schachttiefe ohne Berücktsichtigung der Schallgeschwindigkeit nach der Formel :
s1=(t*t*a)/2
hierhin bedeuten:
s1-Tiefe ohne Berücksichtigung der Schallgeschwindigkeit
t - gemessene Zeit
a - Erdbeschleunigung=9,81 m/sec²
Anschließend ermittelt unser Programm, wie lange der Schall auf der errechneten Strecke unterwegs gewesen wäre. Diese Zeit ergibt sich aus der Formel:
ts = s1/V
ts = Zeit für den Schall
s1 = Tiefe ohne Berücksichtigung des Schalls
V = Schallgeschwindigkeit
Aufgabe:
Statt Iterationsberechnung ( Im Menü unter Case 'I' aufgefürt)- Rekursionfunktion -"reursion() "anwenden !!!
/***********************************************************************/
/* ue_06 Berechnung der Tiefe eines Schachtes aus der Zeit */
/* zwischen dem Loslassen eines Steins und dem Eintreffen */
/* des Schalls nach Aufschlag des Steins. Die Berechnung */
/* erfolgt: a) Mit Hilfe der exakten Loesungsformel. */
/* b) Mittels Iteration. */
/***********************************************************************/
#include <stdio.h>
#include <curses.h>
#include <math.h>
#include <ctype.h>
#define SCHALL 330.0 /* Schallgeschwindigkeit 330 m/s. */
#define ERDBESCHL 9.81 /* Erdbeschleunigung 9.81 m/(s^2).*/
#define ABWEICHUNG 0.001 /* zugel. Abweichung bei Iteration*/
#define BIL clear(); /* Bildschirm loeschen */
#define ROW 4 /* erste Ausgabezeile */
#define COL 10 /* Ausgabespalte */
#define RETURN 13
void wait(void);
void main(void)
{
char kennbuchst;
double zeit,zeit2; /* Gesamtzeit in Sekunden. */
double tiefe,tiefe1,tiefe2; /* Tiefe des Brunnens in Meter. */
double diff, x, y; /* Hilfsvariablen */
int i;
char str[100];
initscr(); /* Initialisiert das Terminal */
cbreak(); /* Zeichen sofort weiterreichen */
nonl(); /* Keine neue Zeile bei Return */
intrflush(stdscr, FALSE);
keypad(stdscr, TRUE); /* Ziffernblock aktivieren. */
clear(); /* Bildschirm loeschen */
do /* Beginn der do-while-Schleife */
{
BIL;
mvaddstr(ROW,COL," L Berechnen der Tiefe mit der Loesungsformel");
mvaddstr(ROW+2,COL," I Berechnen der Tiefe mittels Iteration");
mvaddstr(ROW+4,COL," T Ausgeben einer Tabelle ");
mvaddstr(ROW+6,COL," x Programm beenden");
mvaddstr(ROW+8,COL," Programmfortsetzung: ");
kennbuchst = getch();
BIL;
switch(kennbuchst)
{
case 'l': /* Berechnen der Tiefe nach Eingabe */
case 'L': /* der gemessenen Zeit */
addstr("\n\n\n\t\t Zeit vom Loslassen des Steins bis zum ");
addstr("\n\t\t Eintreffen des Schalls in Sekunden : ");
addstr("\n\t\t ");
getstr(str);
sscanf(str,"%lf",&zeit);
x = zeit/SCHALL + 1.0/ERDBESCHL;
y = zeit/SCHALL;
tiefe = (double)(SCHALL * SCHALL * ( x - (x * x - y * y )));
sprintf(str,"\n\n\t\t Der Schacht ist %5.1f Meter tief",tiefe);
addstr(str);
wait();
break;
case 'i': /* Berechnen der Tiefe nach Eingabe */
case 'I': /* der gemessenen Zeit */
addstr("\n\n\n\t\t Zeit vom Loslassen des Steines bis zum ");
addstr("\n\t\t Eintreffen des Schalls in Sekunden : ");
addstr("\n\t\t ");
getstr(str);
sscanf(str,"%lf",&zeit);
tiefe1 = zeit * zeit * ERDBESCHL / 2; /* Berechnung der */
zeit2 = tiefe1/SCHALL; /* beiden Grenzwerte */
tiefe2 = (zeit - zeit2) * (zeit - zeit2) /* 'tiefe1' u.'tiefe2'*/
* ERDBESCHL / 2;
sprintf(str,"\n\n\t\t Oberer Grenzwert: = %lf Meter" ,tiefe1);
addstr(str);
sprintf(str,"\n\t\t Unterer Grenzwert: = %lf Meter\n\n" ,tiefe2);
addstr(str);
i = 0;
do
{
i++;
tiefe = .5 * (tiefe1+tiefe2); /* Mitte zw. tiefe1 u. tiefe2*/
diff = (2*tiefe/ERDBESCHL) /* Abweichung der berechneten*/
+tiefe/SCHALL - zeit; /* von der gemessenen Zeit. */
if (diff >= 0.0) /* Das Intervall wird neu */
tiefe1 = tiefe; /* festgelegt. */
else
tiefe2 = tiefe;
sprintf(str,"\n\t\t %1d .Berechnungslauf: %5.2f Meter",i,tiefe);
addstr(str);
} while (fabs(diff) > ABWEICHUNG);/* solange bis die Zeit nur */
/* noch um die festgelegte */
/* Abweichung von der gemessenen entfernt ist */
wait();
break;
case 't': /* Ausgeben einer Tabelle fuer Zeiten */
case 'T': /* zwischen 1 und 10 Sekunden */
addstr("\n\n\n\n\t\t Tabelle fuer gemessene Zeiten ");
addstr("\n\t\t von 1 bis 10 Sekunden:");
addstr("\n\n\t\t Sekunden Meter");
for( zeit = 1.0; zeit <= 10.0 ; zeit++)
{
x = (double)(zeit/SCHALL + 1/ERDBESCHL);
y = (double)(zeit/SCHALL);
tiefe = (double)( SCHALL * SCHALL * ( x -(x * x - y * y )));
sprintf(str,"\n\t\t %4.1f %5.1f ",zeit,tiefe);
addstr(str);
}
wait();
break;
case 'x':
mvaddstr(23,COL,"Programmende");
break;
default: /* Anweisungsblock des */
mvaddstr(23,COL,"Falscher Kennbuchstabe");/* Fehlerfalles */
wait();
break;
}
}while(kennbuchst != 'x'); /* Ende der do - while-Schleife */
endwin();
}
/***********************************************************************/
/* Die Funktion 'wait' gibt einen Text aus und wartet auf 'RETURN' */
/***********************************************************************/
void wait(void)
{
mvaddstr(24,1,"Bitte die Taste RETURN druecken!");
while( getch() != RETURN );
}
/************************************************************************/
mfg
Juno
Hallo 
Es hat alles wunderbar geklappt.
Noch mals Danke fü die schnelle Hilfe!.
Juno.
Hi.
Hast du vieleicht eine Idee wie man die Funktion zusammenstellt.
Ich probiere hin und her aber es kommt ganz wenig raus.
- Abgelaufene Zeit - z=0.5*abstand / g_A
?
mfg
Juno
Hi.
Ich melde mich wieder.
Das Programm liefert als Ausgaben:
1. Abstand - den Vorsprung der Schildkröte in Metern, wenn Achilles die Helfte des jeweiliges Vorsprungs erreicht hat,
2. die Zeit, die bis dahin vergangen ist,
3. die Strecke, die Achilles zum Zeitpunkt der nächsten vollständigen Seunde nach Erreichen der Schildkröte zurückgelegt hat.
4. die Strecke, welche die Schildkröte zum Zeitpunkt der nächsten vollständigen Sekunde nach demEinholen durch Achilles zurückgelegt hat
Hi Cepheiden.
Im Moment weiß ich auch nicht wie ich auf die Werte komme. Aber ich kämpfe weiter. Irgendwann schaffe ich das.
Zuletzt vielen,vielen Dank für Deine Hilfe. Du hast mir sehr viel geholfen.
Ein grosses Lob für Euren Board. Hier wird man geholfen!!!
Gruß
Juno
Danke! Das sieht schon sehr gut an.
Ich habe eben noch Probleme mit der Berechnung - wie komme ich auf die Werte die vorgegeben waren?
Du hast mir schon sehr viel geholfen und ich hoffe das ist schon meine letzte Frage.
mfg
Juno
Hi.
Ja der Algorithmus ist mir bekannt. Die Ausgaben wurden vorgegeben, so wie sie sind. Die Toleranz ist ,denke ich mal, eine Art Abbruchbedingung der Rekursion wie einer Schleife.
mfg
Hallo Cepheiden!.
Zuerst danke für sehr schnelle Antwort.
In der Programmiersprache C/C++ bin kein großer Profi. Ich lerne gerade
beim Fernstudium die C Sprache (als berufliche Weterbildung) und bei dieser Aufgabe komme ich einfach nicht weiter.
Am besten ich schicke jetzt das was ich bis jetzt gemacht habe.
/*****************************************************/
/* Achilles und die Schildkroete */
/*****************************************************/
#include <stdio.h>
#define BIL printf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
double g_A; /*Geschwindigkeit Achilles in m/s */
double g_S; /*Geschwindigkeit Schildkroete in m/S */
double v_S; /*Vorsprung Schildkroete in m */
double t; /*Toleranz in cm */
double z; /* vergangene Zeit in sec */
int n;
double schritt(int n);
int main(void)
{
int n;
do
{
g_A=0;
g_S=0;
t=0;
do
{
printf("\n\tGeschwindigkeit Achilles eingeben <10m/s> :");
scanf("%lf",&g_A);
if(g_A!=0)
break;
printf("\n\tDie Geschwindigkeit von Achilles muss >0 sein");
}while(1);
do
{
printf("\tGeschwindigkeit Schildkroete eingeben <0.1m/s :");
scanf("%lf",&g_S);
if(g_S!=0)
break;
printf("\tDie Geschwindigkeit der Schildkroete muss >0 sein");
}while(1);
do
{
if(g_S<g_A)
break;
printf("\tDie Geschwindigkeit von Achilles muss > sein als die Schildkroete");
}while(0);
printf("\tVorsprung Schildkroete eingeben <100m> :");
scanf("%lf",&v_S);
do
{
printf("\tToleranz eingeben <1cm> :");
scanf("%lf",&t);
if(t!=0)
break;
printf("\tDie Toleranz muss >0 sein");
}while(1);
}while(0);
schritt(???);
/***********************************************************/
/* Funktion schritt() */
/***********************************************************/
double schritt(int n)
{
??????????????????????
}
}
/***********************************************************/
Veröffentlicht am Montag, den 24. Januar, 2005 - 14:33:
--------------------------------------------------------------------------------
Hallo.
Wer kann mir helfen. Ich soll Zenon's Paradoxon in C entwerfen. Das Programm soll sich dabei eines rekursiven Algorithmus bedienen.
Die Ausgabe auf dem Bildschirm soll so aussehen:
Geschwindigkeit Achilles eingeben :10
Geschwindigkeit Schildkroete eingeben :0.1
Vorsprung Schildkroete eingeben :100
Toleranz eingeben :1
Abstand 100.000 m nach 0.000 sec
Abstand 50.500 m nach 5.000 sec
Abstand 25.503 m nach 7.525 sec
Abstand 12.879 m nach 8.800 sec
......
......
Abstand 0.007 m nach 10.100 sec
Schildkröte nach 11.000000 sek.: = 101.1000
Achilles nach 11.000000 sek.: = 110.0000
Dabei soll das Programm auch gegen unplausible Eingaben gesichert werden:
- Die Geschwindigkeit von Achilles muss > 0 sein
- Die Geschw. von Achilles muss größer sein als die der Schildkröte.
- Die Toleranz muss > 0 sein.
- Die Geschw. von Schildkröte muss > 0 sein.
Ich habe Probleme mit der rekursiven Funktion.
