Potenz berechnen nur mit ++

sa.afina

Grünschnabel
Hi, ich soll ein Program schreiben welches x^y berechnet, aber ich darf als einzigen arithmetischen Operator ++ benutzen.

Es war einfach mit einer Schleife x+x zu berechnen.

Für die Multiplikation x*x brauche ich ja jetzt eine weitere Schleife, die das ganze x mal durchführt. Und dann für die Potenz x*x*x*… muss ich es nochmal y-mal durchführen.

Aber, ich weiß nicht so wirklich, wie ich es umsetzen soll. Ist es eine Schleife in einer Schleife? Ich hab schon ein paar Sachen ausprobiert, aber es klappt nicht.

Ich wäre echt dankbar für ein paar Denkanstöße/Hilfestellungen
Schon mal vielen Dank.
 
Zuletzt bearbeitet:

Technipion

Erfahrenes Mitglied
Hallo sa.afina,
Aber, ich weiß nicht so wirklich, wie ich es umsetzen soll. Ist es eine Schleife in einer Schleife? Ich hab schon ein paar Sachen ausprobiert, aber es klappt nicht.
Bei sowas bitte immer deinen aktuellen Code (Einfügen → Code) mit posten, sonst raten wir ins Blaue.
Im Prinzip ist es ganz einfach, wenn man es sich einmal klar gemacht hat. Du baust dir zunächst Summation aus dem ++-Operator. Darauf aufbauend dann Multiplikation, und schließlich darauf Potenzieren.
Damit du es einmal gesehen hast, wie eine mögliche Lösung aussieht, poste ich hier ein Minimalbeispiel:
C++:
#include <iostream>


void add_custom(int &x, int y) {
  for (int i = 0; i < y; i++) {
    x++;
  }
}

void mul_custom(int &x, int y) {
  int add_repeatedly = x;

  for (int i = 1; i < y; i++) {
    add_custom(x, add_repeatedly);
  }
}

void pow_custom(int &x, int y) {
  int mul_repeatedly = x;

  for (int i = 1; i < y; i++) {
    mul_custom(x, mul_repeatedly);
  }
}


int main(int argc, char* argv[]) {
  int x = 13;
  pow_custom(x, 4);
  std::cout << x << std::endl;
}

Wichtig: Lesen! Verstehen! Nachfragen!
Nicht einfach per Strg+C & Strg+V übernehmen, sonst lernst du nix.

Testfragen ob du den Code richtig verstehst:
1) Was bedeutet das int &x in den Funktionsdefinitionen?
2) Warum bietet sich die Verwendung von 1) hier an?
3) Wieso starten manche for-Schleifen mit i = 1?
4) Wie sieht es mit der Performance von pow_custom aus?
5) Kann pow_custom beliebig große Potenzen darstellen?

Gruß Technipion
 

sa.afina

Grünschnabel
Erstmal vielen, vielen Dank für die schnelle Antwort! Leider kann ich noch nicht so viel damit anfangen bzw. verstehe es nicht so richtig.

Also ich bin beim programmieren wirklich erst ganz ganz am Anfang. Viele Ausdrücke kenne ich garnicht, weil wir das noch garnicht hatten. Das dürfen wir dann auch nicht benutzen.

Das hatte ich bis jetzt geschrieben, dass ist jetzt a+a, aber das löst noch nicht mein Problem:

#include <iostream>

using namespace std;
int rechnung (int a, int b)
{
int z=0;
int s=0;
int t=0;

for (s; s<a; s++)
{ z++;

}
for (t; t<a; t++)
{
z++;
}

return z;
}
int main()
{
int x;
int y;
int n;
cout << "Bitte geben sie einen Wert fuer x ein." << endl;
cin >> x;
cout << "Bitte geben sie einen Wert fuer y ein." << endl;
cin >> y;
n = rechnung (x,y);
cout << n << endl;
return 0;
}
 

sa.afina

Grünschnabel
Sorry, ich hab ein bisschen unüberlegt geantwortet. Jetzt seh ich was du meinst....
Ist ein bisschen peinlich...Das ist einfach alles neu für mich.

Also warum man &x verwendet verstehe ich nicht, weil ich das so garnicht kenne.
Und warum man bei i=1 anfängt, liegt glaube ich daran, dass wir x ja am Anfang dazu addiert haben. Es wäre sonst einmal zu viel.
 

sa.afina

Grünschnabel
Ich hab mit deiner Hilfe den Code jetzt so verändert. Aber irgendwas stimmt noch nicht so ganz...

#include <iostream>
using namespace std;
void addition (int &x, int y)
{
for (int i=0; i<x; i++)
{
x++;
}
}
void multiplikation (int &x, int y)
{
int add = x;
for (int i =1; i <y; i++)
{
addition(x, add);
}
}
int potenz (int &x, int y)
{
int mul=x;
for (int i = 1; i < y; i++)
{
multiplikation(x, mul);
}
return x;
}

int main()
{
int x;
int y;
cout << "Bitte geben sie einen Wert fuer x ein." << endl;
cin >> x;
cout << "Bitte geben sie einen Wert fuer y ein." << endl;
cin >> y;
potenz(x,y);
cout << x << endl;
return 0;
}
 

Zvoni

Erfahrenes Mitglied
Und warum man bei i=1 anfängt, liegt glaube ich daran, dass wir x ja am Anfang dazu addiert haben. Es wäre sonst einmal zu viel.
Einmal zu viel ist richtig, aber aus dem falschen Grund.
In Technipions Beispiel:
Wenn du, wie hier, bei 1 anfängst, läuft die erste Schleife 3 mal ("Beginne bei 1 solange i kleiner als 4 ist" --> i=1, i=2, i=3, bei i=4 springst du aus der Schleife).
Und wenn du es von der Mathematik her betrachtest, führst du auch tatsächlich "nur" 3 Multiplikationen durch
1) "13x13" = 169
2) "169x13" = 2197
3) "2197x13" = 28561

Das mit dem "int &i" sage ich jetzt mal nichts dazu, da du es noch nicht kennst . Solltest aber nachschlagen.
Als Hinweis: Es gibt mehrere Möglichkeiten, einen Wert von einer Funktion/Prozedur zurückgeben zu lassen.
 

Neue Beiträge