Potenzierung durch einfache Operatoren

[NewJava895]

Hallo Java Gemeinde,

ich bin neu hier. Ersteinmal wünsch ich allen einen guten Rutsch ins neue Jahr 🙂

Nun zu meiner Frage. Ich habe ein Programm angefangen, welches mir eine Potenzrechnung durchführen soll. Die einzige Restrektion hierbei ist, ich darf nur einfache Operatoren verwenden, also Addition und Subtraktion. Ich habe mir bisher umfassend Gedanken gemacht und komme einfach nicht weiter. Ich habe versucht, ersteinmal das einfache Produkt zu berechnen:

 int result = 0;
       	    for (int i = 1; i <= a; i++) {
       	    	    result += a;
       	    	     }

und anschließend hiermit weiterzurechnen. Leider komme ich an einem Punkt, bei dem mir entweder die Grundkentnisse fehlen oder ich einfach zu kompliziert denke oder einfach dumm bin 🙂

Ich habe also so versucht :

for (int i = 1; i <= b; i++) {
       	    	    result += c;
       	    	    }

dann so

for (int k = 1; k <= b; k++) {
for (int i = 1; i <= a; i++) {
       	    	    c += c;
       	    	    }

...

Also habe ich überlegt wie ich es anstellen kann:

5^5 = 3125 -->
5+5+5+5+5 =25 5^2
25+25+25+25+25=125 5^3
125+125+125+125+125=625 5^4
625+625+625+625+625=3125 5^5

Aber mir fehlt einfach noch ein Stück, wie ich weiter mache. Ich habe auch versucht im Methodenkopf eine Schleife zu platzieren (einfach zum probieren) hat aber auch nicht geklappt, könnt ihr mir einen kleinen Denkanstoß geben?

 

[hüteüberhüte]

Versuche so:

int/long potenz = 1;
for (int i = 0; i < exponent; i++) {
  potenz *= basis;
}

 

[NewJava895]

Hallo Hüteüberhüte,

danke für deine prompte Antwort. Ich darf keine Multiplikation verwenden sondeern nur Addition und Subtraktion.

 

[pro2]

Hey,

das hier sollte helfen.

 

[hüteüberhüte]

Ach so! Dann versuche so:

    public static long pow(int basis, int exponent) {
        long potenz = 1;
        for (int i = 0; i < exponent; i++) {
            long produkt = potenz;
            for (int j = 1; j < basis; j++) {
                potenz += produkt;
            }
        }
        return potenz;
    }

    public static void main(String[] args) {
        System.out.println(pow(5, 3));
        System.out.println(Math.pow(5, 3));
        System.out.println(pow(5, 4));
        System.out.println(Math.pow(5, 4));
        System.out.println(pow(5, 5));
        System.out.println(Math.pow(5, 5));
    }

Guten Rutsch Dir Auch!

 

[utnovetur]

Um es klarer zu machen, würde ich das mutliplizieren und das potenzieren trennen:

public class Potenz {
	public static void main(String[] args) {
		int basis = 5;
		int exponent = 4;
		int ergebnis = potenziere(basis, exponent);
		System.out.println(ergebnis);
	}

	private static int multipliziere(int faktor1, int faktor2) {
		int produkt = 0;
		// in einer for-Schleife "+" (von Java) benutzen
		return produkt;
	}

	private static int potenziere(int basis, int exponent) {
		int potenz = 1;
		// in einer for-Schleife die eigene Funktion multipliziere(int faktor1, int faktor2) benutzen
		return potenz;
	}
}

Du hast dann auch die Möglichkeit, erst einmal zu testen, ob das multiplizieren richtig funktioniert, z.B. durch:

	public static void main(String[] args) {
		int faktor1 = 5;
		int faktor2 = 4;
		int ergebnis = multipliziere(faktor1 , faktor2);
		System.out.println(ergebnis);
	}

(Das Ergebnis sollte in der Größenordnung von 20 liegen)

Ein gute neues Jahr
utnovetur

 

[Landei]

Zum Jahresabschluss eine herrliche Rube-Goldberg-Maschine:

import java.util.Iterator;

public class Moessner implements Iterable<Integer> {

    private final int k;
    private final int d;

    private Moessner(int k, int d) {
        this.k = k;
        this.d = d;
    }

    public Iterator<Integer> iterator() {
       return new Iterator<Integer>() {

           private int f = 1;
           private int s = 0;
           private Iterator<Integer> it = k == 1 ? null : new Moessner(k-1,d+1).iterator();

           @Override
           public boolean hasNext() {
               return true;
           }

           @Override
           public Integer next() {
               if (k == 1) {
                   return ++s;
               }
               if (f == d) {
                   f = 1;
                   it.next();
               }
               f++;
               s += it.next();
               return s;
           }

           @Override
           public void remove() {
               throw new UnsupportedOperationException();
           }
       };
    }

    public static int pow(int a, int b) {
        if (a < 0 || b < 0) throw new IllegalArgumentException();
        if (b == 0) return 1;
        if (a == 0 || a == 1) return a;
        for(int x : new Moessner(b,2)) {
            if (--a == 0) return x;
        }
        return 666;
    }

}

Wer (ohne nach "Moessner" zu googlen) sagen kann, wie das funktioniert, hat meine Hochachtung...

 

[Marco13]

public class A
{
    static long _(long i, long í, long ì)
    {
        return i==0?ì+1:ì==0?i==1?í:i==2?0:1:_(i-1,í,_(i,í,ì-1));
    }

    public static void main(String args[])
    {
        System.out.println("Increasing second arg by one");
        System.out.println("0 0 = " + _(0, 0, 0));
        System.out.println("4 1 = " + _(0, 4, 1));
        System.out.println("2 8 = " + _(0, 2, 8));
        System.out.println("\n");

        System.out.println("Adding the args");
        System.out.println("0 0 = " + _(1, 0, 0));
        System.out.println("2 1 = " + _(1, 2, 1));
        System.out.println("5 4 = " + _(1, 5, 4));
        System.out.println("\n");

        System.out.println("Multiplying the args");
        System.out.println("0 0 = " + _(2, 0, 0));
        System.out.println("2 3 = " + _(2, 2, 3));
        System.out.println("5 4 = " + _(2, 5, 4));
        System.out.println("\n");

        System.out.println("First to the power of second");
        System.out.println("0 0 = " + _(3, 0, 0));
        System.out.println("0 2 = " + _(3, 0, 1));
        System.out.println("2 3 = " + _(3, 2, 3));
        System.out.println("3 4 = " + _(3, 3, 4));
        System.out.println("\n");

        System.out.println(" x^x^x...^x  (y times)");
        System.out.println("0 0 = " + _(4, 0, 0));
        System.out.println("0 2 = " + _(4, 0, 1));
        System.out.println("2 3 = " + _(4, 2, 3));
        System.out.println("\n");
    }
}

:smoke:

 

[NewJava895]

Danke euch allen für die Hilfe. Ich habe den oben gen. Code noch etwas verbessert insgesamt sieht es jetzt so aus:

import java.io.*;
 
class potenz {
    public static void main(String[] args) throws IOException {
 
        int a = leseA();//Basis
        int b = leseB();//Exponent
        int c = rechnePotenz(a,b);
        ausgabePotenz(c,b,a);
    }
 
    public static int leseA() throws IOException {
        BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
 
        System.out.println("Geben Sie die Basis ein.");
        String input = stdin.readLine();
        return Integer.parseInt(input);
    }
    
     public static int leseB() throws IOException {
        BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
 
        System.out.println("Geben Sie den Exponenten ein.");
        String input = stdin.readLine();
        return Integer.parseInt(input);
    }
    
    public static int rechnePotenz(int a, int b) {
       	   
   {
	
  if (b == 0)
    return 1;
  int answer = a;
  int increment = a;
  if (b < 0)
  	  b = -b;
  if (a < 0)
  	  a = -a;
  for(int i = 1; i < b; i++)
  {
     for(int j = 1; j < a; j++)
     {
        answer += increment;
     }
     increment = answer;
  }
  return answer;
  }
    }
    
    public static void ausgabePotenz(int c, int b, int a) {
        if (a < 0 && (b % 2==0))
    	    System.out.println("Potenz: " + ( - c));
    else
    	System.out.println("Potenz: " + c);    
    }
}

Mit der Rechnung erkennt er auch bei einer negativen Basis, dass bei ungeraden Exponenten das Ergebnis negativ wird! Dies habe ich durch

if (b < 0)
  	  b = -b;
  if (a < 0)
  	  a = -a;

Damit er einfach mit den Zahlen weiterrechnet und

public static void ausgabePotenz(int d, int b, int a) {
        if (a < 0 && (b % 2==0))
    	    System.out.println("Potenz: " + ( - d));
    else
    	System.out.println("Potenz: " + d);

Damit er die Ausgabe korrekt gestaltet. Soweit so gut. Aber jetzt habe ich weiter überlegt, was ist mit negativen Exponenten ?! Das hieße ja a^-b = 1/a^b. Ich glaube hier endet die Möglichkeit mit Addition und Subtraktion auf das Ergebnis zu kommen oder? Was haltet ihr von meinem gesamten Programmcode? Gibt es Dinge zu verbessern?

Ich danke euch allen vielmals und wünsch ein Frohes neues Jahr!

 

[hüteüberhüte]

Vieles ist mit Addition (und Subtraktion) möglich. 😉

Um Schnelligkeit geht es hier wohl nicht, sonst schieden die rekursiven Verfahren aus.

@Landei: Ohne zu googlen, dauert es wohl etwas länger, den Code zu verstehen, aber zumindest der Ansatz lässt sich erkennen.

@utnovetur: Warum sollte ich eine so einfach verschachtelte Schleife zusätzlich noch auslagern? Blödsinn, wer das nicht erkennt, ist kein guter Programmierer.

 

[Marco13]

Und wer nicht erkennt, was die 5. Zeile in meinem Code macht, ist auch kein guter Programmierer 😛ueh: Ich hatte in Potenzieren durch plus und minus mit Methoden - Byte-Welt Forum (schon aus "didaktischen" Gründen!) den gleichen Hinweis gegeben. Es wäre fast noch "schöner" gewesen, wenn man das ganze auf eine Successor function - Wikipedia, the free encyclopedia hätte zurückführen müssen... :reflect:

 

[Landei]

@Landei: Ohne zu googlen, dauert es wohl etwas länger, den Code zu verstehen, aber zumindest der Ansatz lässt sich erkennen.

Glaube ich nicht, denn das Verfahren ist alles andere als einsichtig. Nehmen wir mal das Vorgehen für die 4. Potenz.

Wir beginnen mit der Folge der natürlichen Zahlen:

1,2,3,4,5,6,7,8,9,10,11,12,13,14,15...

Davon wird jede 4. Zahl gestrichen:

1,2,3,5,6,7,9,10,11,13,14,15...

Die kumulierte Zahlenfolge:

1,3,6,11,17,24,33,43,54,67,81,95...

Davon jede 3. Zahl gestrichen:

1,3,11,17,33,43,67,81...

Die kumulierte Zahlenfolge:

1,4,15,32,65,108,175,256...

Davon jede 2. Zahl gestrichen:

1,15,65,175...

Die kumulierte Zahlenfolge:

1,16,81,256...

Und das ist überraschenderweise die Reihe der 4. Potenzen.

Ich mache das mit meinen Iteratoren "rückwärts", lasse mir also die Werte der jeweils vorigen Reihe "just in time" liefern (sonst wäre es schwer auszurechnen, mit wieviel Werte man eigentlich starten muss für eine gegebene Basis).

Mit leicht abgewandelter Bildungsregel lassen sich übrigens auch Fakultäten berechnen.

 

[NewJava895]

@ Landei

Das is krass ... Wie kommt man bitte auf sowas? Macht aber Sinn. Nur gehen hier (wenn ich es richtig sehe) auch nur ganzzahlige Potenzen und Potenzen bei denen Basis und Exponent nur positiv sein können. Wobei die Ausgabe bei negativer Basis nicht schwer ist nur bei negativen Exponenten habe ich so meine Probleme. Beim googeln habe ich eine Reihe gefunden, die immer wieder das Komma verschiebt und den Rest ausgibt, also wie beim schriftlich rechnen. Aber fand ich sehr kompliziert.

 

[hüteüberhüte]

Glaube ich nicht, denn das Verfahren ist alles andere als einsichtig.

Ok, haste recht, ich habs (zumindest erstmal) nicht kapiert. 😀 Danke für Erklärung und schönen Abend. :toll: