• Задача 5.

    #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;
    }
    

    Задача 6.

    #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);
    }
    

    Задача 7.

    #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));
    }
    
    

    Задача 8.

    #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);
    }
    

    Задача 9.

    #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);
    }
    

    Задача 10.

    #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);
    	}
    }
    
    

    Задача 11.

    #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);
    }