3. sehr merkwürdig (Ackermann)

sehr merkwürdig (Ackermann)

  • S

    hallo leute!

    Ich hab was (für mich) äußerst merkwürdiges entdeckt. Ich hab mir neulich eine Ackermann Funktion geschrieben und dort entdeckte ich das Unfassbare...

    Während mein Programm beim Aufruf der Funktion einen schönen Schreibfehler bei Laufzeit verpasste,

    int acker(int n,int m)
{
 	if (m==0) {
          return n+1;
        } else if (n==0) {
          return acker(m-1,1);
        } else {
          return acker(m-1, acker(m,n-1));
        }
}

    ging bei dieser Funktion alles glatt:

    int acker(int m,int n)
{
        if (m==0) {
          return n+1;
        } else if (n==0) {
          return acker(m-1,1);
        } else {
          return acker(m-1, acker(m,n-1));
        }
}

    Wie ihr vielleicht seht, ist nicht wirklich viel verändert worden...außer, dass m und n im Funktionsaufruf vertauscht worden. Die Funktion wurde immer mit acker(1,1) aufgerufen, so dass stehts m und n die gleichen Ausgangswerte hatten.

    Ich bin nun echt am Zweifeln, das ist für mich ein Phänomen 😮

    0
  • C
    Mod 

    int acker(int n,int m)
{
     if (m==0) {
          return n+1;
        } else if (n==0) {
          return acker(m-1,1);
        } else {
          return acker(m-1, acker(m,n-1));
        }
}

    acker( 1, 1 ) --> 3. fall: acker( 0, acker( 1, 0 ) )

    acker( 1, 0 ) --> 1.fall: 2

    acker( 0, 2 ) --> 2.fall: acker( 1, 1 )

    du hängst also schön in einer endlos rekursion fest 😉

    0
  • S

    ja aber ist nicht deine Theorie nicht auch genauso auf die andere Funktion übertragbar??

    Wenn ich m und m beim Aufruf vertausche, passiert doch auch nichts...

    0
  • ?

    Wenn du die Parameter in der Signatur vertauschst, musst du sie auch in allen Aufrufen vertauschen. Wenn du also

    int acker(int n,int m)
{
        if (m==0) {
          return n+1;
        } else if (n==0) {
          return acker(1,m-1);
        } else {
          return acker(acker(m,n-1), m-1);
        }
}

    schreibst, müsste es gehen.

    0
  • C
    Mod 

    int acker(int m,int n)
{
        if (m==0) {
          return n+1;
        } else if (n==0) {
          return acker(m-1,1);
        } else {
          return acker(m-1, acker(m,n-1));
        }
}

    acker( 1, 1 ) --> 3. fall - acker( 0, acker( 1, 0 ) )

    acker( 1, 0 ) --> 2. fall - acker( 0, 1 )

    acker( 0, 1 ) --> 1. fall - 2

    acker( 0, 2 ) --> 1. fall - 3

    das ist etwas ganz anderes 🙂

    0
  • O

    wenn beide werte gleich sind, nicht, und der autor hat ja geschrieben, das beide werte 1 sind. mich wundert der fehler desshalb auch...

    0
  • K

    nur im ersten durchgang sind beide werte gleich, sobald die rekursion anspringt, stimmts nicht mehr und es kommt nicht mehr zum terminierungsfall

    0
  • S

    ja, das hab ich mittlerweile auch gecheckt, das Problem ist, dass sich die Funktion selber aufruft und wenn man dann m und n vertauscht, wird die Funktion dann beim nächsten Aufruf in sich verdreht....

    0
  • P

    http://de.wikipedia.org/wiki/Ackermann-Funktion#Implementation

    0
  • S

    oh! ich liebe leute, die einfach mal nur den titel des threads durchlesen und dann sofort den erst besten link aus ihren bookmarks holen...bzw. den ersten treffer bei google!

    glaubst du nicht auch, dass ich den link auch schon gefunden habe?
    und inwiefern wolltest du damit mein problem lösen (mal abgesehen davon, dass es schon gelöst ist...)?

    irgendwie muß man die 4000 ja voll machen.....

    0
Anmelden zum Antworten