Achilles und die Schildkröte

    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.

    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)
    {
    ??????????????????????
    }


    }
    /***********************************************************/

    Hi,


    mmhh etwas extravagante Realissierung der Eingabe, sie sollte aber richtig arbeiten. Naja evtl arbeiteten die while(0) sachen nicht so wie du willst.


    Die Berechnung des Paradoxsons scheint dein Problem zu sein. Der Algorithmus ist dir bekannt? ansonsten z. B. http://www.math-kit.de/2003/co…Manifest295/einstieg.html


    Wie kommst du auf die Ausgaben? Nach der Berechnungsmethode wie ich sie verstanden hab berechnet man diese Werte nie. Man berechnet nur die Werte der Reihe. Also in dem oben angegebenen Fall nach 100m dann 10m, 1m 0.1m usw


    ehrlich gesagt weiß ich aber nicht wie man da die Toleranz einbringen soll. :rolleyes:


    Achso Rekursion an sich ist dir ein Begriff oder soll ich dazu noch was sagen?


    mfg

    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

    Ja die Toleranz wird eine Abbruchbedingung sein.


    Die Ausgaben, sind mir aber nicht ganz schluessig.


    Rekursion bedeutet ja das sich die Function in sich selbst aufruft.


    Das grundgeruest wuerde ich so gestallten


    /***********************************************************/
    /* Funktion schritt() */
    /***********************************************************/
    double schritt(double Abstand, float vA, float vS,float toleranz, int z)
    {


    // Berechnung
    // und Abbruchbedingung


    result = Abstand+ schritt(Abstand,vA, vS, toleranz, z);
    }


    Rueckgabewert ist in dem Fall die Strecke nach der die Schildkroete "eingeholt" wurde.


    Die Berechnungen und die Abrruchbedingung hab ich erstmal noch weggelassen. Ich weiss nicht genau wo du Fragen hast ?(

    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

    ehrlich gesagt hab ich keine Ahnung wie die Werte zustande kommen. Denn mit dem eigentlichen Zenon Paradoxon haben die wenig zutun.


    Immerhin geht es ja darum das Achilles die Schildkröte nie überholt


    die werte
    Schildkröte nach 11.000000 sek.: = 101.1000
    Achilles nach 11.000000 sek.: = 110.0000


    sind also bisschen merkwürdig

    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, wir geben uns Muehe, auch wenn wir uns mehr hier Leute wuenschen die anderen helfen.


    Was deine Aufgabe angeht, da versteh ich die Ausgaben in keinster Weise als Ergebnisse des Zenon Paradoxon.
    Die Werte sind einfach nur Ergebnisse der Weg-Zeit-Funktionen von Achilles und der Schildkroete.


    sA = vA * t
    sS = vS *t +s0


    s0 ... Vorsprung der Schildkroete



    Wie gesagt ist das aber nicht das Paradoxon von Zenon.

    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

    Achso, also das Paradoxon etwas abgewandelt, und es werden die Werte für die Hälfte des Abstandes und nciht wie beim orginal der ganze Abstand genommen.


    Also ist die erste berechnung für den Zeitpunkt wo Achilles 50m zurückgelegt hat.


    naj ist im prinzip nichts anderes.


    Das Einholen wird Definiert als unterschreiten der Toleranzgrenze und die Berechnungen 3 und 4 wird dann nicht mehr in der Rekursionsschleife berechnet (denk ich)