Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 5 years ago.
Improve this question
I must calculate X to the power of Y with recursion and only addition. I really can't figure out how to do it without using loops or using multiplication. This is not my homework. It is a question from last years exams I am stuck on.
import java.util.Scanner;
public class Season4Task7 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("Enter X");
int x = sc.nextInt();
System.out.println("Enter y");
int y = sc.nextInt();
System.out.println(findXY(x, y, 0));
}
static int findXY(int x, int y, int result){
if(y==0){
return 1;
}
if(x==0){
return 0;
}
if(y==1){
return result+x;
}
result+=x;
return findXY(x, y-1, result);
}
}
First two ifs look fine, maybe the 'y-1' as well but after that it might be incorrect, also is there a chance not to use 'int result' but only to pass x and y to the function?
Since we cannot using multiplication, we need to use recursive addition. check my code below. Your first 3 if conditions are correct. Modify the later code to below method.
package com.java;
import java.util.Scanner;
public class Season4Task7 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("Enter X");
int x = sc.nextInt();
System.out.println("Enter y");
int y = sc.nextInt();
System.out.println("Final :: " + findXPowerY(x, y));
sc.close();
}
static int findXPowerY(int x, int y) {
if (y == 0) {
return 1;
}
if (x == 0) {
return 0;
}
if (y == 1) {
return x;
}
return multiply(x, findXPowerY(x, y - 1));
}
static int multiply(int x, int y) {
if (y != 0)
return (x + multiply(x, y - 1));
else
return 0;
}
}
What your findXY method really does is simple multiplication, not exponentiation. First of all, it could be improved from using 3 parameters to only 2:
static int findXY(int x, int y){
if(y==0){
return 1;
}
if(x==0){
return 0;
}
if(y==1){
return x;
}
return x + findXY(x, y-1);
}
Secondly, you are halfway done! You just found a way to multiply with only using addition and recursion. What you now need to do, is call this multiplication certain numer of times, again, using recursion.
Before we start, let's rename the method from findXY to multiply, since it better indicates its intent and functionality.
Thirdly, we need to implement the method that calculates the power. Keeping in mind that we renamed your findXY method to multiply and changed the number of parameters from 3 to 2, our implementation might look like this:
static int power(int x, int y) {
if(y == 0) {
return 1;
}
if(y == 1) {
return x;
}
return x * power(x, y-1));
}
Hey, but we are not allowed to use multiplication! Fortunately, we made our own implementation! The final product looks like this:
static int power(int x, int y) {
if(y == 0) {
return 1;
}
if(y == 1) {
return x;
}
return multiply(x, power(x, y-1));
}
Please do note that this approach does not work with negative numbers. If they are the case, you could wrap this method in another one that simply calls power with abs value and inverts the result
Related
Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 2 years ago.
Improve this question
I got this Java function and I have to write the piece of code which results by unfolding the loop three times. What does it mean?
int f(int x, int y) {
while (true) {
int m = x % y;
if(m == 0) return y;
x = y;
y = m;
}
}
It means to repeat the code inside the loop a number of times, then refactoring the code to optimize it.
Let's see how it goes if we repeat once.
int f(int x, int y) {
while (true) {
int m = x % y;
if(m == 0) return y;
x = y;
y = m;
m = x % y;
if(m == 0) return y;
x = y;
y = m;
}
}
By rotating the use of the variables, we can eliminate the two simple assignments in the middle, thereby optimizing the code.
int f(int x, int y) {
while (true) {
int m = x % y;
if(m == 0) return y;
x = y % m;
if(x == 0) return m;
y = x;
x = m;
}
}
Now repeat it one more time, and rotate the variables in the third copy, for a total of 3 times the "same" code, as specified in the assignment.
I'll leave it to you to do that, since it is your assignment to complete. If done correctly, you'll find that there are no simple assignments in the result.
public class recursionTester {
public static void main(String[] args) {
System.out.println("Your recursion is " + Recursion(5,4));
}
private static int Recursion(int recursive1, int recursive2) {
if(recursive2 == 0)
return 1;
else if (recursive2 >= 0)
return Recursion(recursive1 * Recursion(recursive1,recursive2-1), recursive2);
}
}
// I am looking more for a fix rather than a suggetion because I already know my problems
It looks like you want to calculate the value of x raised to the power of y (i.e. x ^ y) using recursion. The important thing you need to keep in mind is, you need to terminate the function call with some condition; otherwise, it will become endless.
public class RecursionTester {
public static void main(String[] args) {
System.out.println("5 ^ 4 = " + power(5, 4));
}
private static int power(int x, int y) {
if (y == 0) // Because x ^ 0 = 1
return 1;
return x * power(x, y - 1);
}
}
Output:
5 ^ 4 = 625
Is this what you were looking for? Feel free to comment if it isn't the case.
I have tried:
static public void power(int n, int X) {
System.out.print( + " ");
if (n>0) {
power(n-1, X);
}
}
This does not yield a value as I'm not sure how to do that.
public int calculatePower(int base, int powerRaised)
{
if (powerRaised != 0)
return (base*calculatePower(base, powerRaised-1));
else
return 1;
}
static int power(int x, int y)
{
// Initialize result
int temp;
if( y == 0) // Base condition
return 1;
temp = power(x, y/2); // recursive calling
if (y%2 == 0) //checking whether y is even or not
return temp*temp;
else
return x*temp*temp;
}
Well others have written solution which gives you correct answer but their time complexity is O(n) as you are decreasing the power only by 1. Below solution will take less time O(log n). The trick here is that
x^y = x^(y/2) * x^(y/2)
so we only need to calculate x^(y/2) and then square it. Now if y is even then there is not problem but when y is odd we have to multiply it with x. For example
3^5 = 3^(5/2) * 3^(5/2)
but (5/2) = 2 so above equation will become 3^2 * 3^2, so we have to multiply it with 3 again then it will become 3 * 3^(5/2) * 3^(5/2)
then 3^2 will be calculated as 3^(2/1) * (3^2/1) here it no need to multiply it with 3.
public static double pow(int a, int pow) {
if (pow == 0)
return 1;
if (pow == 1)
return a;
if (pow == -1)
return 1. / a;
if (pow > 1)
return a * pow(a, pow - 1);
return 1. / (a * pow(a, -1 * (pow + 1)));
}
Considering X as number and n as power and if both are positive integers
public static int power(int n, int X) {
if (n == 0) {
return 1;
} else if(n == 1) {
return X;
} else {
return X * power(n-1, X);
}
}
Let's re-write your function:
static public void power(int n, int X) {
System.out.print( + " ");
if (n>0) {
power(n-1, X);
}
}
First of all, lets change void to int.
Afterthat, when n equals to 1, we return the result as X, because X^1 = X:
static public int power(int n, int X) {
if (n>1) {
return X * power(n-1, X);
}
return X;
}
Scanner s = new Scanner(System.in) ;
System.out.println("Enter n");
int n = s.nextInt();
System.out.println("Enter x");
int x =s.nextInt();
if (n>0){
double pow =Math.pow(n,x);
System.out.println(pow);
}
While others have given you solutions in terms of code, I would like to focus on why your code didn't work.
Recursion is a programming technique in which a method (function) calls itself. All recursions possess two certain characteristics:
When it calls itself, it does so to solve a smaller problem. In your example, to raise X to the power N, the method recursively calls itself with the arguments X and N-1, i.e. solves a smaller problem on each further step.
There's eventually a version of the problem which is trivial, such that the recursion can solve it without calling itself and return. This is called base case.
If you are familiar with mathematical induction, recursion is its programming equivalent.
Number two above is what your code is lacking. Your method never returns any number. In the case of raising a number to a power, the base case would be to solve the problem for the number 0 as raising zero to any power yields one, so the code does not need to call itself again to solve this.
So, as others have already suggested, you need two corrections to your code:
Add a return type for the method.
State the base case explicitly.
public class HelloWorld{
public long powerfun(int n,int power,long value){
if(power<1){
return value;
}
else{
value = value * n;
return powerfun(n,power-1,value);
}
}
public static void main(String []args){
HelloWorld hello = new HelloWorld();
System.out.println(hello.powerfun(5,4,1));
}
}
I've tried to add comments to explain the logic to you.
//Creating a new class
public class RecursivePower {
// Create the function that will calculate the power
// n is the number to be raised to a power
// x is the number by which we are raising n
// i.e. n^x
public static int power(int n, int x){
// Anything raised to the 0th power is 1
// So, check for that
if (x != 0){
// Recursively call the power function
return (n * power(n, x-1));
// If that is true...
}else{
return 1;
} //end if else
} //end power
// Example driver function to show your program is working
public static void main(String[] args){
System.out.println("The number 5 raised to 6 is " + power(5,6));
System.out.println("The number 10 raised to 3 is " + power(10,3));
} //end psvm
} //end RecursivePower
Can I extend the program’s functionality to additionally tell the user the smallest number, by creating a separate method, smaller, in a similar fashion to the larger method?
public static void main(String[] args)
{
System.out.println("Please enter two numbers");
Scanner scan = new Scanner(System.in);
int first = scan.nextInt();
int second = scan.nextInt();
System.out.println("The largest "+larger(first, second));
}// end of main
public static double larger(double x, double y)
{
if (x >= y)
return x;
return y;
} //end of larger
This is trivial, e.g. (keeping the same code conventions)
public static double smaller(double x, double y)
{
if (x >= y)
return y;
return x;
} //end of larger
The above is not optimal, but it aligns with the existing code.
You can also use Math.min(double a, double b), or ternary operator: a < b ? a : b.
P.S. One number is not greater than another if they are equal.
My assignment is to write a recursive function to multiply two numbers together, using only an addition function, ++, and --. My addition function is:
public static int peanoplus(int x, int y) {
if(y==0) return x;
else return peanoplus(++x,--y);
}
What I have so far for my multiplication function is:
public static int peanotimes(int x, int y)
{
if(y==0) return x;
else return peanotimes(peanoplus(x,x),--y);
}
I am not exactly sure what to put in the first parameter for the peanotimes function. Right now the issue is that I'm doubling the number, rather than adding it to the original number. I know that I need to maintain the x variable so that the recursive calls can continue adding the original number (instead of doubling every time), but then where would I actually add the numbers?
I found this which is very similar to my question, but even with those tips I am unable to find a solution.
if( y == 0 || x == 0 ) { return 0; }
else { return peanoplus(x, peanotimes(x,--y)); }
This version closest matches the formal Peano axiom of x * S(y) = x + (x * y)
public static int peanotimes(int x, int y)
{
if (y == 0) {
return 0; // terminate recursion, NB: not "x"
} else {
return peanoplus(x, peanotimes(x, --y));
}
}