Erstes Programm: Zahl potenzieren

hartmut1164

Ansonsten koenntest Du es auch recursive machen (spart die Schleife) - nur fuer Exponenten >= 0:

double Pot (double rBase, int  iExpo)
{
    if (iExpo == 0)
        return 1;
    else 
        return Pot (rBase, iExpo - 1) * rBase;
}

hartmut1164 schrieb:

(spart die Schleife)

'spart' ist irgendwie unpassend, findeste nicht?

volkard

hartmut1164 schrieb:

Ansonsten koenntest Du es auch recursive machen

lern doch bitte mal die schreibweise "rekursiv".

hartmut1164

+fricky schrieb:

hartmut1164 schrieb:

(spart die Schleife)

'spart' ist irgendwie unpassend, findeste nicht?

Naja - Ich konnte es halt nicht lassen ...

Jetzt noch die Zwischenergebnisse in einer Liste ablegen und dann ist es hartmut-style

Tim schrieb:

....ist es hartmut-style

rate mal was hartmut programmieren würde, wenn er rauskriegen will, ob eine zahl gerade oder ungerade ist...

Skalli

Zahl % 2

?

^^

Skalli schrieb:

Zahl % 2

?

niemals, das hat weder verkettete listen noch rekursion drin.

Bashar

bool IsEven(int iNumber) {
   if (iNumber == 0)
     return true;
   else if (IsOdd(iNumber - 1))
     return true;
   else
     return false; 
}

bool IsOdd(int iNumber) {
  if (IsEven(iNumber - 1))
    return true;
  else
    return false;
}

double Pot(double rBase, int iExpo) {
  if (iExpo == 0)
    return 1;
  else if (IsEven(iExpo)) {
    int Temp = Pot(rBase, iExpo/2);
    return Temp * Temp;
  }
  else
    return rBase * Pot(rBase, iExpo - 1);
}

Optimierte Version, spart außerdem den Modulo-Operator.

volkard

bool IsEven(int iNumber) {
   if (iNumber == 0)
     return true;
   else if (IsOdd(iNumber - 1))
     return true;
   else
     return false; 
}

bool IsOdd(int iNumber) {
  if (IsEven(iNumber - 1))
    return true;
  else
    return false;
}

double Mul(double rBase, int iExpo) {
  if (iExpo == 0)
    return 0;
  else if (IsEven(iExpo)) {
    int Temp = Mul(rBase, iExpo/2);
    return Temp + Temp;
  }
  else
    return rBase + Mul(rBase, iExpo - 1);
}

double Pot(double rBase, int iExpo) {
  if (iExpo == 0)
    return 1;
  else if (IsEven(iExpo)) {
    int Temp = Pot(rBase, iExpo/2);
    return Mul(Temp,Temp);
  }
  else
    return Mul(rBase,Pot(rBase, iExpo - 1));
}

doppeloptimierte version, spart außerdem die multiplikation, geht aber nur noch mit natürlichen zahlen.
(dieses Pot mit Mul habe ich übrigens sogar mal benutzt.)

volkard

int div2(int a,int b=0){
  if(a<=b)
    return a;
  else
    return div2(a-1,b+1);
}

hartmut1164

Da will ich mich nicht luppen lassen, schliesslich kann

n mod m

sich auch so vorstellen, das Ergebnis die Speichennummer eines Rades vom m Speichen ist, dass um n Speichen weitergedreht wurde. Man muss also nur einen Ring bauen, der geschlossen ist und m Elemente enthaelt, diesen laesst man n-mal schrittweise weiterlaufen und erhaelt so den mod-Wert. Dann muss man den Ring noch aufbrechen und kann ihn ueber ein Rekursion aufraeumen - also etwa so:

struct SingleSpoke
{
    int                    iSpokeNo;
    struct SingleSpoke    *pNeighbour;
}

struct SingleSpoke *CreateSpokes (struct SingleSpoke *pLast,
                                  int                 iCurrent,
                                  int                 iM)
{
    struct SingleSpokes *pTemp;

    if (iCurrent != iM)
    {
        pTemp = malloc (sizeof (SingleSpoke));

        pTemp->iSpokeNo   = iCurrent;
        pTemp->pNeighbour = pLast;

        return CreateSpokes (pTemp, iCurrent + 1, iM)
    }
    else
        return pLast;
}

struct SingleSpokes *GetFirst (struct SingleSpokes *pIn)
{
    if (pIn->pNeighbour == NULL)
        return pIn;
    else
        return GetFirst (pIn->pNeighbour);
}

struct SingleSpokes *BuildWheel (iM)
{
    struct SingleSpokes *pReturn,
                        *pLast;

    pLast = CreateSpokes (NULL, 0, iM);

    pReturn = GetFirst (pLast);

    pReturn->pNeighbour = pLast;

    return pReturn;
}

int RunWheel (int                   iN,
              struct SingleSpokes  *pWheel)
{
    if (iN == NULL)
        return pWheel->iSpokeNo;
    else
        return RunWheel (iN - 1, pWheel->pNeighbour);
}

struct SingleSpoke *BreakWheel (struct SingleSpoke *pWheel)
{
    struct SingleSpoke *pReturn;

    pReturn = pWheel->pNeighbour;

    pWheel->pNeighbour = NULL;

    pReturn;
}

void DestroyWheel (struct SingleSpoke *pWheel)
{
    struct SingleSpoke *pNeighbour;

    if (pWheel != NULL)
    {
        pNeighbour = pWheel->pNeighbour;
        free (pWheel);
        DestroyWheel (pNeighbour);
    }
}

int Mod (int    iN,
         int    iM)
{
    struct SingleSpoke    *pWheel;
    int                    iResult;

    pWheel = BuildWheel (iM);

    iResult = RunWheel (iN, pWheel);

    DestroyWheel (BreakWheel (pWheel));

    return iResult;
}

volkard

und das wiederum erinnert mich an

MOD
PUSHZERO result        >
DUP1 count             <[->>+>+<<<]>>>[-<<<+>>>]<
DEC count              -
// divisor=5 dividend=2 result=0 (count=2) tmp
go divisor             <<<
WHILE divisor          [
 go count               >>>
 DUP0 tmp               [->+>+<<]>>[-<<+>>]<
 NOT tmp                >+<[[-]>-<]>[-<+>]<
 IF tmp                 [[-]
  go result              <<
  INC result             +
  DUP2 count             <[->>+>+<<<]>>>[-<<<+>>>]<
  go tmp                 >
 ENDIF tmp              ]
 go count               <
 DEC count              -
 go divisor             <<<
 DEC divisor            -
ENDWHILE divisor       ]
// (divisor=0) dividend result=? count=?
go count               >>>
sub from dividend      [-<<->>]
POP0 count             <
POP result             [-]<
DEC dividend           -
ADD                    [-<+>]<

hartmut1164

Nun, in Brainfuck schreibe ich noch nicht, aber wer weiss ...

Bashar schrieb:

bool IsEven(int iNumber) {
   if (iNumber == 0)
     return true;
   else if (IsOdd(iNumber - 1))
     return true;
   else
     return false; 
}

bool IsOdd(int iNumber) {
  if (IsEven(iNumber - 1))
    return true;
  else
    return false;
}

so ungefähr wollt ich das sehen
http://en.wikipedia.org/wiki/Mutual_recursion