Рекурсия

#include <iostream>
 
using namespace std;
 
unsigned int fibonachi(unsigned int n, unsigned int *foudned);
 
int main()
{
    int k, n;
 
    std::cout << "Input k: ";
    std::cin >> k;
    std::cout << std::endl;
 
    // Масив, в който ще се запомнят намерените числа
    unsigned int foudnedArray[5000] = {0};
 
    for( int i=1; i<=k; i++ ) {
        std::cout << "fibonachi(" << i << "): " << fibonachi(i, foudnedArray) << std::endl;;
    }
 
    return 0;
}
 
unsigned int fibonachi(unsigned int n, unsigned int *foudned)
{
    // Ако е 1-то или 2-то число на фибоначи (условие за край)
    if( n <= 2 ) return 1;
 
    // Ако числото вече е било намерено(условие за край)
    if( foudned[n] > 0 ) return foudned[n];
 
    // Променлива, в която се запомня търсеното число
    unsigned int fibonachiNum;
 
    // Прави се рекурсивно извикване, за да се намери числото
    fibonachiNum = fibonachi(n-1, foudned) + fibonachi(n-2, foudned);
 
    // Запомня намереното n-то число на съответната позиция в масива
    foudned[n] = fibonachiNum;
 
    return fibonachiNum;
}

#include <iostream>
 
using namespace std;
 
unsigned int factoriel(unsigned int n);
 
int main()
{
    unsigned int a, b;
 
    do {
        std::cout << "Input a: ";
        std::cin >> a;
        std::cout << "Input b: ";
        std::cin >> b;
        std::cout << std::endl;
 
        if( b > a && a >= 0 ) break;
 
        std::cout << "Incorect values for a,b!" << std::endl;
 
    } while(true);
 
    unsigned long long int result;
 
    result = (factoriel(a) + factoriel(b) ) / (b - a);
 
    std::cout << "R = (" << a << "!+" << b << "!)/(" << b << " − " << a << ") = " << result << std::endl;;
 
    return 0;
}
 
unsigned int factoriel(unsigned int n)
{
    // Ако n е 1 или 0, то стойността е 1 (условие за край)
    if( n < 2 ) return 1;
 
    return n*factoriel(n-1);
}

#include <iostream>
 
using namespace std;
 
double pow_rec(double a, int n);
 
int main()
{
    unsigned int a, b, c, k, p, r;
 
    std::cout << "Input a: ";
    std::cin >> a;
    std::cout << "Input b: ";
    std::cin >> b;
    std::cout << "Input c: ";
    std::cin >> c;
    std::cout << "Input k: ";
    std::cin >> k;
    std::cout << "Input p: ";
    std::cin >> p;
    std::cout << "Input r: ";
    std::cin >> r;
    std::cout << std::endl;
 
    // Променливи, в които ще се изчислят числителя и знаменателя
    double numerator, denumerator;
 
    numerator   = pow_rec(a+b, k);
    denumerator = pow_rec(a, p) - pow_rec(c, r);
 
    // Проверява се знаменателя да не е нула
    if( 0 == denumerator ) {
        std::cout << "Denominator (a^p − c^r) = (" << a << "^" << p << "-" << c << "^" << r << ") = 0 !"
                  << std::endl;
    }
    else {
        std::cout << "R = (a + b)^k / (a^p − c^r) = "
                  << "(" << a << "+" << b << ")^" << k // числителя
                  << " / "
                  << "(" << a << "^" << p << "-" << c << "^" << r << ")" // знаменателя
                  << " = " << numerator/denumerator << std::endl;
    }
 
    return 0;
}
 
/**
 * Намира степента на a ^ n
 *
 * @param double a
 * @param int n
 * @return double
 */
double pow_rec(double a, int n)
{
    if( n == 0 ) return 1.0;
    if( n < 0 ) return 1/pow_rec(a, -n);
 
    return (double)(a*pow_rec(a, n-1));
}

#include <iostream>
 
using namespace std;
 
int nod_rec(int a, int b);
 
int main()
{
    unsigned int n;
 
    std::cout << "Input n: ";
    std::cin >> n;
    std::cout << std::endl;
 
    int nod;
    for (int i=0; i<n; i++) {
 
        int num;
        do {
            std::cout << "Input number " << i+1 << ": ";
            std::cin >> num;
 
            if( 0 != num ) break;
 
            std::cout << "Number can not be 0! " << std::endl;
        }
        while(true);
 
        if( num < 0 ) num = -num;
 
        if( 0 == i) {
            nod = num;
        }
        else {
            nod = nod_rec(nod, num);
        }
    }
 
    std::cout << "NOD = " << nod << std::endl;
 
    return 0;
}
 
/**
 * Намира НОД(a,b)
 *
 * @param int a
 * @param int b
 * @return int
 */
int nod_rec(int a, int b)
{
    if( a == b ) return a;
 
    if( a > b ) return nod_rec(b, a-b);
    else return nod_rec(a, b-a);
}

#include <iostream>
 
using namespace std;
 
void inputNumbers(int *numbers, int &size);
 
bool binary_check(int number);
 
int main()
{
    int numbers[90], numbersCnt;
 
    // Въвежда числата
    inputNumbers(numbers, numbersCnt);
 
    for(int i=0; i<numbersCnt; i++){
        if( numbers[i] > 0 && binary_check(numbers[i]) ){
            std::cout << numbers[i] << " ";
        }
    }
 
    std::cout << std::endl;
 
    return 0;
}
 
/**
 * Въвежда масива с числата
 *
 * @param int[] numbers
 * @param int cnt
 * @return void
 */
void inputNumbers(int *numbers, int &cnt)
{
    std::cout << "Input numbers size: ";
    std::cin >> cnt;
    std::cout << std::endl;
 
    int i=0, *pNumbers;
    pNumbers = numbers;
    while(i<cnt) {
        std::cout << "numbers[" << i << "] = ";
        std::cin >> *pNumbers++;
        i++;
    }
    std::cout << std::endl;
}
 
/**
 * Намира НОД(a,b)
 *
 * @param int a
 * @param int b
 * @return int
 */
bool binary_check(int number)
{
    if( 0 == number ) return true;
 
    if( number%2 == 1 ) {
        return !binary_check(number/2);
    }
    return binary_check(number/2);
}

#include <iostream>
#include <cmath>
 
using namespace std;
 
bool is_prime_rec(unsigned number, unsigned divisor);
 
int main()
{
    int intervalBegining, intervalEnd;
 
    std::cout << "Input begining number for interval:";
    std::cin >> intervalBegining;
    std::cout << "Input end number for interval:";
    std::cin >> intervalEnd;
    std::cout << std::endl;
 
    if( intervalBegining > intervalEnd ) {
        std::cout << "Error input:\nEnd of interval muss be  greater then the begining!\n";
    }
 
    while( intervalBegining <= intervalEnd ){
 
        if( intervalBegining >= 2 ) {
            unsigned divisor = sqrt(intervalBegining);
            if( is_prime_rec(intervalBegining, divisor) ) {
                std::cout << intervalBegining <<", ";
            }
        }
        intervalBegining++;
    }
    std::cout << std::endl;
 
    return 0;
}
 
 
/**
 * Намира дали дадено естествено число е просто
 *
 * @param unsigned number
 * @param unsigned divisor
 * @return bool
 */
bool is_prime_rec(unsigned number, unsigned divisor)
{
    // Проверка за коректност на данните
    if( number < 2 || divisor < 1 ) return false;
 
    // Ако делителят е станал 1-ца, без да е делил числото, то е просто
    if( 1 == divisor ) return true;
 
    // Ако текущият делител дели числото, то не е просто и връща false
    // В противен случай се връща стойността от същата функция, извикана
    // със стойност за делителя, намалена с единица
    if( number%divisor == 0 ) {
        return false;
    }
    else {
        return is_prime_rec(number, divisor-1);
    }
}

#include <iostream>
 
using namespace std;
 
void inputNumbers(int *numbers, int &size);
 
double sum_even_indexes_rec(int *numbers, int size, int currentPos);
 
int main()
{
    int numbers[90], size;
 
    // Въвежда числата
    inputNumbers(numbers, size);
 
    // Ако размерността (брояt на елементите) на масива е по-малко от 2, то няма четни индекси
    if( size < 2 ) {
        std::cout << "Not found even indexes!" << std::endl;
        return 0;
    }
 
    // Рекурсивното извикване започва с индекс 2
    std::cout << "Sum even indexes: " << sum_even_indexes_rec(numbers, size, 2);
    std::cout << std::endl;
 
    return 0;
}
 
/**
 * Въвежда масива с числата
 *
 * @param int[] numbers
 * @param int size
 * @return void
 */
void inputNumbers(int *numbers, int &size)
{
    std::cout << "Input numbers size: ";
    std::cin >> size;
    std::cout << std::endl;
 
    int i=0, *pNumbers;
    pNumbers = numbers;
    while(i<size) {
        std::cout << "numbers[" << i << "] = ";
        std::cin >> *pNumbers++;
        i++;
    }
    std::cout << std::endl;
}
 
/**
 * Намира сумата на елементите на масива с четни индекси и я връща като резултат
 *
 * @param int numbers (указател към масива с числата)
 * @param int size  (размерността на масива)
 * @param int shift (задава отместването към съответния четен индекс)
 * @return double
 */
double sum_even_indexes_rec(int *numbers, int size, int shift)
{
    if( shift >= size ) return 0.0;
 
    return *(numbers+shift) + sum_even_indexes_rec(numbers, size, shift+2);
}