(define (factorial n)
(cond ((= n 0) 1)
((= n 1) 1)
(else (* n (factorial (- n 1))) )
)
)
(define (pow x n)
(cond ((= n 0) 1)
(else (* x (pow x (- n 1))))
)
)
(define (exponent x n sum)
(cond ((= n 0) (+ 1 sum))
((= n 1) (exponent x (- n 1) (+ x sum)))
(else (exponent x (- n 1) (+ (/ (pow x n) (factorial n)) sum)))
)
)
(exponent 1 10 0)
рекурсия для расчета суммы
Пожалуйста, помогите разобраться и написать программу:
Использовать рекурсию для расчета суммы 2+1/(2!) + 1/(3!) +...+1/(N!). (выражение "N!" - обозначает произведение всех целых чисел от 1 до N: N! = 1 * 2 * ... * N). Полученное число является приближенным значением константы e = exp(1) (=2,718281...). Количество членов последовательности задается пользователем как аргумент функции.
Использовать рекурсию для расчета суммы 2+1/(2!) + 1/(3!) +...+1/(N!). (выражение "N!" - обозначает произведение всех целых чисел от 1 до N: N! = 1 * 2 * ... * N). Полученное число является приближенным значением константы e = exp(1) (=2,718281...). Количество членов последовательности задается пользователем как аргумент функции.
пожалуйста, вы бы могли прокомментировать код, спасибо.
На C++ можно так сделать (как вариант, возможно не самый лучший):
Код:
#include <iostream>
#include <iomanip>
using namespace std;
double FactorSum(double factor, long curCount, long endCount)
{
factor /= static_cast<double>(curCount);
return factor +
(curCount < endCount ? FactorSum(factor, curCount + 1, endCount) : 0.0);
}
int main()
{
long N;
cout << "Enter N: ";
cin >> N;
if(N < 1)
{
cout << "Incorrect value of N\n";
return 0;
}
cout << "Result = " << setprecision(15) << (1.0 + FactorSum(1.0, 1, N))
<< endl;
}
#include <iomanip>
using namespace std;
double FactorSum(double factor, long curCount, long endCount)
{
factor /= static_cast<double>(curCount);
return factor +
(curCount < endCount ? FactorSum(factor, curCount + 1, endCount) : 0.0);
}
int main()
{
long N;
cout << "Enter N: ";
cin >> N;
if(N < 1)
{
cout << "Incorrect value of N\n";
return 0;
}
cout << "Result = " << setprecision(15) << (1.0 + FactorSum(1.0, 1, N))
<< endl;
}
JS
[highlight=html]
<html>
<head>
<title>Exponent calculation</title>
<script>
function factSumEl(aInit,nInit, n) {
if(isNaN(n))
return "Error";
aNext = aInit/(nInit+1);
if((nInit+1)==n)
return aNext
else
return aInit+factSumEl(aNext,nInit+1,n);
}
</script>
</head>
<body>
<input type="text" id="n" />
<input type="button" value="calculate" onclick="alert('Sum is '+factSumEl(1,0,document.getElementById('n').value))" />
</body>
</html>
[/highlight]
[highlight=html]
<html>
<head>
<title>Exponent calculation</title>
<script>
function factSumEl(aInit,nInit, n) {
if(isNaN(n))
return "Error";
aNext = aInit/(nInit+1);
if((nInit+1)==n)
return aNext
else
return aInit+factSumEl(aNext,nInit+1,n);
}
</script>
</head>
<body>
<input type="text" id="n" />
<input type="button" value="calculate" onclick="alert('Sum is '+factSumEl(1,0,document.getElementById('n').value))" />
</body>
</html>
[/highlight]
Цитата: Нездешний
Код:
(define (factorial n)
(cond ((= n 0) 1)
((= n 1) 1)
(else (* n (factorial (- n 1))) )
)
)
(cond ((= n 0) 1)
((= n 1) 1)
(else (* n (factorial (- n 1))) )
)
)
Чего такой кривой факториал то?)) Он же в цикл не развернётся)
Надо примерно так, основной смысл будет понятен думаю(на F# правда, но этот код точно раскрывается в цикл):
Код:
let fact = function
| N when N >= 0L ->
let rec _fact n res =
match n with
| 0L -> 1L * res
| x -> _fact (n - 1L) (res*x)
_fact N 1L
| _ -> failwith "invalid N"
| N when N >= 0L ->
let rec _fact n res =
match n with
| 0L -> 1L * res
| x -> _fact (n - 1L) (res*x)
_fact N 1L
| _ -> failwith "invalid N"
_fact разворачивается в след. при release сборке(код выданный рефлектором на C#):
Код:
internal static long _fact@5(long n, long res)
{
while (n != 0)
{
res *= n;
n -= 1L;
}
return (1L * res);
}
{
while (n != 0)
{
res *= n;
n -= 1L;
}
return (1L * res);
}
F# такой F# :)
Впрочем, вот без ПМ-а вариант на Nemerle:
Оптимизация хвостовых вызовов здесь рефлектору оказалась не по зубам :)
Впрочем, вот без ПМ-а вариант на Nemerle:
Код:
Fact(x : long) : long
requires x >= 0L
{
def fact(n, res)
{
if(n == 0L) res else fact(n - 1L, res * n)
}
fact(x, 1L)
}
requires x >= 0L
{
def fact(n, res)
{
if(n == 0L) res else fact(n - 1L, res * n)
}
fact(x, 1L)
}
Оптимизация хвостовых вызовов здесь рефлектору оказалась не по зубам :)
Цитата: hardcase
F# такой F# :)
Впрочем, вот без ПМ-а вариант на Nemerle:
...
Оптимизация хвостовых вызовов здесь рефлектору оказалась не по зубам :)
Впрочем, вот без ПМ-а вариант на Nemerle:
...
Оптимизация хвостовых вызовов здесь рефлектору оказалась не по зубам :)
т.е. компилятор Nemerle не смог развернуть это в цикл? Зачем такой плохой оптимизатор юзатете тогда? Ведь должен же разворачиваться вызов fact(n - 1L, res * n), т.к. тут именно хвостовая рекурсия, иначе весь смысл в передаче двух аргументов теряется...
Без ПМ на F# это выглядит точно так же (разве что requires нету).
Цитата: Norgat
т.е. компилятор Nemerle не смог развернуть это в цикл? Зачем такой плохой оптимизатор юзатете тогда?
Я вроде русским языком написал:
Цитата:
рефлектору не по зубам
Наш кодогенератор совершенно не обязан генерировать код, который можно декомпилировать. Более того, метод там один - Fact, функция fact полностью заинлайнилась.
Код:
#include <iostream>
#include <iomanip>
using namespace std;
double FactorSum(double factor, long curCount, long endCount)
{
factor /= static_cast<double>(curCount);
return factor +
(curCount < endCount ? FactorSum(factor, curCount + 1, endCount) : 0.0);
}
int main()
{
long N;
cout << "Enter N: ";
cin >> N;
if(N < 1)
{
cout << "Incorrect value of N\n";
return 0;
}
cout << "Result = " << setprecision(15) << (1.0 + FactorSum(1.0, 1, N))
<< endl;
}
#include <iomanip>
using namespace std;
double FactorSum(double factor, long curCount, long endCount)
{
factor /= static_cast<double>(curCount);
return factor +
(curCount < endCount ? FactorSum(factor, curCount + 1, endCount) : 0.0);
}
int main()
{
long N;
cout << "Enter N: ";
cin >> N;
if(N < 1)
{
cout << "Incorrect value of N\n";
return 0;
}
cout << "Result = " << setprecision(15) << (1.0 + FactorSum(1.0, 1, N))
<< endl;
}
пожалуйста, вы бы могли прокомментировать код. спасибо!
Цитата: life4fun
пожалуйста, вы бы могли прокомментировать код. спасибо!
Поясню использованную мной идею выкладками:
Код:
1 1 1 1
2 + -- + -- + -- + ... + -- =
2! 3! 4! N!
1 1 1 1 1
= 1 + - + --- + ----- + ------- + ... + --------- =
1 1*2 1*2*3 1*2*3*4 1*2*...*N
1 1 1 1 1 1 1 1 1
= 1 + 1 * - + - * - + --- * - + ----- * - + ... + ------------- * -
1 1 2 1*2 3 1*2*3 4 1*2*...*(N-1) N
|_____| |_____| |_______| |_________| |_________________|
1 2 3 4 N
2 + -- + -- + -- + ... + -- =
2! 3! 4! N!
1 1 1 1 1
= 1 + - + --- + ----- + ------- + ... + --------- =
1 1*2 1*2*3 1*2*3*4 1*2*...*N
1 1 1 1 1 1 1 1 1
= 1 + 1 * - + - * - + --- * - + ----- * - + ... + ------------- * -
1 1 2 1*2 3 1*2*3 4 1*2*...*(N-1) N
|_____| |_____| |_______| |_________| |_________________|
1 2 3 4 N
Насчет самого кода - а что именно вам непонятно?