cout << 1/3;FallArk said:When I do things likein C++, it will typically output 0.333333, but the actual answer should be 0.3333333 with an infinite amount of 3s, how should I make a function such that will mimic this division recursively?Code:cout << 1/3;
I like Serena said:Hey FallArk! ;)
Do you know how to do long divisions?
That's the way to do it - with a recursive function to make it happen.
(Btw, your example code will output [m]0[/m] instead of [m]0.3333333[/m]. Know why?)
FallArk said:I know it's int so it outputs 0. Since that's the integer part. But would you mind explaining the long division and how it works? Thank you!
I like Serena said:Well... divide 1 by 3 as integers and output the result 0.
The remainder is 1.
Multiply the remainder by 10 and repeat.
Oh, and we need to output the decimal point after the first division.
More specifically:
\begin{array}{ccccc}
Dividend & Divisor & Quotient & Remainder & Output \\
1 & 3 & 0 & 1 & 0. \\
10 & 3 & 3 & 1 & 0.3 \\
10 & 3 & 3 & 1 & 0.33 \\
10 & 3 & 3 & 1 & 0.333 \\
...
\end{array}
double longDivision (int dividend, int divisor, int decimalplaces){} // Are the data types correct?int decimalplacesFallArk said:If I want to output to, let's say, 10 decimal places. And I do a recursive function:
What would be the general case when the function returns an output?Code:double longDivision (int dividend, int divisor, int decimalplaces){} // Are the data types correct?
I want to say that when the amount of numbers after the decimal matches,Code:int decimalplaces
is that correct?
I like Serena said:Looks fine to me.
Keep going! (Nod)
Oh, and the function shouldn't return a double.
Either it should return a string, or it should simply output the result to cout (and return void).
squidsk said:Since making it print infinite decimal places would be pointless as that's the equivalent of an infinite loop why not just use the iomanip library or printf to output the number of decimal places you want to be output.
#include <stdio.h>
int main() {
printf("%.20f\n", 1.0/3);
return 0;
}0.33333333333333331483I like Serena said:Looks fine to me.
Keep going! (Nod)
Oh, and the function shouldn't return a double.
Either it should return a string, or it should simply output the result to cout (and return void).
void longDivision(int dividend, int divisor, int decimalplace){
int x = dividend / divisor;
cout << x;
dividend = (dividend - (x * divisor)) * 10;
cout << dividend / divisor;
}FallArk said:I know how to do long division but how should I make it recursive?
Code:void longDivision(int dividend, int divisor, int decimalplace){ int x = dividend / divisor; cout << x; dividend = (dividend - (x * divisor)) * 10; cout << dividend / divisor; }
I like Serena said:Instead of the 2nd cout, we should have a call to longDivision(dividend, divisor, decimalPlaces -1).
Oh, and there should be an if to stop doing that when we have all the decimal places.
void longDivision(int dividend, int divisor, int decimalplace){
if (decimalplace == 0) {
return;
}
else {
cout << dividend / divisor;
longDivision((dividend % divisor) * 10, divisor, decimalplace - 1);
}
}void longDivision(int dividend, int divisor, int decimalplace){
if (decimalplace > 0) {
cout << dividend / divisor;
longDivision((dividend % divisor) * 10, divisor, decimalplace - 1);
}
}Recursion in C++ is a process where a function calls itself repeatedly until a certain condition is met. This allows for solving complex problems by breaking them down into smaller, simpler versions of the same problem.
Recursion works by breaking down a problem into smaller versions of the same problem, until a base case is reached. The base case is a condition that stops the function from calling itself again, and allows it to return a result. This result is then used to solve the previous levels of the problem until the original problem is solved.
Some advantages of using recursion in C++ include writing more concise and elegant code, solving complex problems more efficiently, and easier debugging as the code is broken down into smaller parts. Additionally, certain problems are easier to solve using recursion compared to other methods.
One limitation of using recursion in C++ is that it can lead to stack overflow if the recursive function is called too many times, as each function call takes up memory on the stack. Additionally, if the base case is not properly defined, the function may continue to call itself infinitely, leading to an infinite loop.
Recursion in C++ can be optimized by using tail recursion, where the recursive call is the last statement in the function. This allows the compiler to optimize the code and potentially reduce the risk of stack overflow. Additionally, using dynamic programming techniques can also improve the efficiency of recursive algorithms.