Permutaciones y Combinaciones.cpp

#include <iostream>
#include <cstdint>
#include <vector>
#include <cstdlib>
#include <string>


void pauseScreen()
{
	std::cout << "Press Enter to continue...";
	std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
	std::cin.get();
}

void clearScreen()
{
	system("cls");
}

int add(const std::vector<int>& arr)
{
	int add{};
	for (int x : arr)
	{
		add += x;
	}
	return add;
}

int product(const std::vector<int>& arr)
{
	int product{ 1 };
	for (int x : arr)
	{
		product *= x;
	}
	return product;
}

int repeatPermute(const std::uint8_t& n, const std::uint8_t& r)
{
	int pow{ 1 };
	for (int i = 0; i < r; i++)
	{
		pow *= n;
	}
	return pow;
}

std::uint64_t factorial(const std::uint8_t& n)
{
	int fact{ 1 };
	for (int i = 0; i < n; i++)
	{
		fact *= n - i;
	}
	return fact;
}

std::uint64_t nPr(const std::uint8_t& n, const std::uint8_t& r)
{
	return { factorial(n) / factorial(n - r) };
}

std::uint64_t nCr(const std::uint8_t& n, const std::uint8_t& r)
{
	return { factorial(n) / ((factorial(r) * factorial(n - r))) };
}

std::uint64_t combRep(const std::uint8_t& n, const std::uint8_t& r)
{
	return { factorial(n + r - 1) / (factorial(r) * factorial(n - 1)) };
}

std::uint64_t multinomial(const std::uint8_t& n, const std::vector<std::uint8_t>& vec)
{
	std::uint64_t result{ factorial(n) };
	for (std::uint8_t i : vec)
	{
		result /= factorial(i);
	}
	return result;
}

void pascalTriangle(const std::uint8_t& n)
{
	std::cout << '\n';
	for (std::uint8_t i = 0; i <= n; i++)
	{
		for (std::uint8_t j = 0; j <= i; j++)
		{
			std::cout << nCr(i, j) << " ";
		}
		std::cout << '\n';
	}
}

void newtonsBinomial(const std::uint8_t& n)
{
	for (std::uint8_t k = 0; k <= n; k++)
	{
		if (k == n)
		{
			std::cout << nCr(n, k) << "x^" << n - k << "y^" << unsigned(k);
		}
		else
		{
			std::cout << nCr(n, k) << "x^" << n - k << "y^" << unsigned(k) << " + ";
		}
	}
	std::cout << '\n';
}

int main()
{
	int option{ 999 };
	do
	{
		std::cout << "--- MAIN MENU ---\n\n";
		std::cout << "1. The sum rule.\n";
		std::cout << "2. The product rule.\n";
		std::cout << "3. Permutation with reptetition.\n";
		std::cout << "4. Factorial.\n";
		std::cout << "5. nPr.\n";
		std::cout << "6. nCr.\n";
		std::cout << "7. Combination with repetition.\n";
		std::cout << "8. Multinomial coefficient.\n";
		std::cout << "9. Pascal's Triangle.\n";
		std::cout << "10. Newton's Binomial.\n";
		std::cout << "11. Exit.\n\n";
		std::cout << "Insert an option: ";
		std::cin >> option;
		clearScreen();
		switch (option)
		{
			case 1:
			{
				std::vector<int> addends{};
				char insertAddends{ 's' };
				do
				{
					int input{};
					std::cout << "Insert an addend: ";
					std::cin >> input;
					addends.push_back(input);
					std::cout << "Added succesfully inserted!\n\n";
					std::cout << "Do you want to insert a new addend?(s/n): ";
					std::cin >> insertAddends;
					while (insertAddends != 's' && insertAddends != 'S' && insertAddends != 'n' && insertAddends != 'N')
					{
						std::cout << "Insert a valid value!\n\n";
						pauseScreen();
						clearScreen();
						std::cout << "Do you want to insert a new addend?(s/n): ";
						std::cin >> insertAddends;
					}
					clearScreen();
				} while (insertAddends == 's' || insertAddends == 'S');
				std::cout << "Inserted addends: ";
				for (int x : addends)
				{
					std::cout << x << " ";
				}
				std::cout << "\n\nThe sum of all the addends is: " << add(addends) << '\n';
				pauseScreen();
				clearScreen();
				option = 999;
				break;
			}

			case 2:
			{
				std::vector<int> factors{};
				char insertFactors{ 's' };
				do
				{
					int input{};
					std::cout << "Insert a factor: ";
					std::cin >> input;
					factors.push_back(input);
					std::cout << "Factor succesfully inserted!\n\n";
					std::cout << "Do you want to insert a new factor?(s/n): ";
					std::cin >> insertFactors;
					while (insertFactors != 's' && insertFactors != 'S' && insertFactors != 'n' && insertFactors != 'N')
					{
						std::cout << "Insert a valid value!\n\n";
						pauseScreen();
						clearScreen();
						std::cout << "Do you want to insert a new factor?(s/n): ";
						std::cin >> insertFactors;
					}
					clearScreen();
				} while (insertFactors == 's' || insertFactors == 'S');
				std::cout << "Inserted factors: ";
				for (int x : factors)
				{
					std::cout << x << " ";
				}
				std::cout << "\n\nThe product of all the factors is: " << product(factors) << '\n';
				pauseScreen();
				clearScreen();
				option = 999;
				break;
			}

			case 3:
			{
				int input{};
				std::cout << "Insert n: ";
				std::cin >> input;
				std::uint8_t n{ static_cast<std::uint8_t>(input) };
				std::cout << "Insert r: ";
				std::cin >> input;
				std::uint8_t r{ static_cast<std::uint8_t>(input) };
				std::cout << "\nn^r is: " << repeatPermute(n, r) << "\n\n";
				pauseScreen();
				clearScreen();
				option = 999;
				break;
			}

			case 4:
			{
				std::cout << "Insert number to calculate factorial: ";
				std::uint8_t x{};
				int input{ };
				std::cin >> input;
				x = static_cast<std::uint8_t>(input);
				std::cout << "\nFactorial of " << static_cast<int>(x) << " is: " << factorial(static_cast<int>(x)) << "\n\n";
				pauseScreen();
				clearScreen();
				option = 999;
				break;
			}

			case 5:
			{
				int input{};
				std::cout << "Insert n: ";
				std::cin >> input;
				std::uint8_t n{static_cast<std::uint8_t>(input)};
				std::cout << "Insert r: ";
				std::cin >> input;
				std::uint8_t r{static_cast<std::uint8_t>(input)};
				std::cout << '\n' << static_cast<int>(n) << "P" << static_cast<int>(r) << " = " << nPr(static_cast<int>(n), static_cast<int>(r)) << "\n\n";
				pauseScreen();
				clearScreen();
				option = 999;
				break;
			}

			case 6:
			{
				int input{};
				std::cout << "Insert n: ";
				std::cin >> input;
				std::uint8_t n{ static_cast<std::uint8_t>(input) };
				std::cout << "Insert r: ";
				std::cin >> input;
				std::uint8_t r{ static_cast<std::uint8_t>(input) };
				std::cout << '\n' << static_cast<int>(n) << "C" << static_cast<int>(r) << " = " << nCr(static_cast<int>(n), static_cast<int>(r)) << "\n\n";
				pauseScreen();
				clearScreen();
				option = 999;
				break;
			}

			case 7:
			{
				int input{};
				std::cout << "Insert n: ";
				std::cin >> input;
				std::uint8_t n{ static_cast<std::uint8_t>(input) };
				std::cout << "Insert r: ";
				std::cin >> input;
				std::uint8_t r{ static_cast<std::uint8_t>(input) };
				std::cout << '\n' << "Possible combinations with repetitions are: " << combRep(static_cast<int>(n), static_cast<int>(r)) << "\n\n";
				pauseScreen();
				clearScreen();
				option = 999;
				break;
			}

			case 8:
			{
				int input{};
				std::cout << "Insert n: ";
				std::cin >> input;
				std::uint8_t n = { static_cast<std::uint8_t>(input) };
				std::vector<std::uint8_t> subN{};
				char insertSubN{ 's' };
				clearScreen();
				do
				{
					std::cout << "Insert a number for sub n: ";
					std::cin >> input;
					subN.push_back(static_cast<std::uint8_t>(input));
					int sum{};
					for (std::uint8_t x : subN)
					{
						sum += static_cast<int>(x);
					}
					if (sum < n)
					{
						std::cout << "sub n inserted succesfully!\n\n";
					}
					else if (sum == n)
					{
						std::cout << "You have reached the limit.\n\n";
						break;
					}
					else {
						std::cout << "Insert a valid value!\n\n";
						subN.pop_back();
					}
					std::cout << "Do you want to insert a new sub n? (s/n): ";
					std::cin >> insertSubN;
					while (insertSubN != 's' && insertSubN != 'S' && insertSubN != 'n' && insertSubN != 'N')
					{
						std::cout << "Insert a valid value!\n\n";
						pauseScreen();
						clearScreen();
						std::cout << "Do you want to insert a new sub n?(s/n): ";
						std::cin >> insertSubN;
					}
					clearScreen();
				} while (insertSubN == 's' || insertSubN == 'S');
				std::cout << "n value: " << static_cast<int>(n);
				std::cout << "\nsub n values: ";
				for (std::uint8_t x : subN)
				{
					std::cout << static_cast<int>(x) << " ";
				}
				std::cout << "\n\nMultinomial coefficient is: " << multinomial(static_cast<int>(n), subN) << "\n\n";
				pauseScreen();
				clearScreen();
				option = 999;
				break;
			}

			case 9:
			{
				std::cout << "Insert a level for Pascal's Triangle: ";
				int input{};
				std::cin >> input;
				std::uint8_t n{ static_cast<std::uint8_t>(input) };
				pascalTriangle(static_cast<int>(n));
				std::cout << '\n';
				pauseScreen();
				clearScreen();
				option = 999;
				break;
			}
			
			case 10:
			{
				std::cout << "Insert an exponent for Newton's Binomial: ";
				int input{};
				std::cin >> input;
				std::uint8_t n{ static_cast<std::uint8_t>(input) };
				std::cout << '\n';
				newtonsBinomial(static_cast<int>(n));
				std::cout << '\n';
				pauseScreen();
				clearScreen();
				option = 999;
				break;
			}

			case 11:
			{
				std::cout << "See you later!\n\n";
				pauseScreen();
				clearScreen();
				break;
			}

			default:
				std::cout << "Insert a valid value!\n\n";
				pauseScreen();
				clearScreen();
				option = 999;
		}

	} while (option == 999);

	return 0;
}