Програмиране на С++

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