Erstes Programm: Zahl potenzieren

Hallo ihr alle miteinander!
Ich schreibe gerade an meinem ersten C-Programm und bin verzweifelt... es will nicht so wie ich will...
Über Hilfe würde ich mich freuen.

/*
Hier wird die Potenz a einer Zahl x berechnet.
Der Eingabeparameter ist a natürliche Zahl als Potenz
sowie die Basis als reele Zahl x.
Das Ergebnis wird ausgegeben.
*/

#include <stdio.h>

main()
{
int a, float x, p, potenz=1;

printf("Gib die Zahl x ein:\n ");
printf("Gib die gewünschte Potenz a ein:\n ");
scanf("%f",&x);
printf("\n");
scanf("%d", &a);
printf("\n");

for(p=1 ; p<=a ; p++)
potenz * = p;

printf("mult(p=1..%d) = %d\n",a,potenz);
}

1. Nutze [cpp]-Tags
2. Was ist denn der Fehler?
3. Dein Programm macht keinen Sinn bzgl. der Aufgabenstellung.

volkard

` for(i=1 ; i<=a ; i++)

potenz * = x;

printf("mult(p=1..%d) = %d\n",a,potenz);

}`

Ich sehe nirgendwo eine Multiplikation mit der Basis 'x' ...?!

Konfusius

#include <stdio.h>

main()
{
  // deklarationen geändert
  int a,p;
  float x,potenz=1;

  printf("Gib die Zahl x ein:\n ");
  printf("Gib die gewünschte Potenz a ein:\n ");
  scanf("%f",&x);
  printf("\n");
  scanf("%d", &a);
  printf("\n");

  for(p=1 ; p<=a ; p++)
    potenz * = x; // von p zu x geändert

  printf("mult(p=1..%d) = %d\n",a,potenz);
}

hartmut1164

Ansonsten kannst Du es Dir auch billig machen und eine der drei Fkt. benutzen (finden sich in der math.h):

double  pow  (double x, double y)
long    powl (long double x, long double y)
float   powf (float x, float y)

Danke euch.
Ich glaube es klappt jetzt.
Ich werde unseren Skrip wohl mal noch ausführlicher studieren müssen.

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;
}