1190 lines
38 KiB
C
1190 lines
38 KiB
C
#include <stdio.h>
|
|
|
|
#define DAYS_IN_MONTH 30
|
|
#define MONTHS_IN_YEAR 12
|
|
#define ONE_HUNDRED 100
|
|
#define ONE_THOSEND 10000
|
|
#define BOOLEAN unsigned short
|
|
#define TRUE 1
|
|
#define FALSE 0
|
|
#define TEN 10
|
|
#define TWELVE 12
|
|
#define THIRTY 30
|
|
#define ZERO 0
|
|
#define ONE 1
|
|
#define TWO 2
|
|
#define THREE 3
|
|
#define FOUR 4
|
|
#define TAKE_SIGNED(x) (((2 * (x)) + 1) % 2)
|
|
#define ABS(x) (x) * (((2 * (x)) + 1) % 2)
|
|
#define MAX(x, y) (x > y) ? x : y
|
|
#define MIN(x, y) (x < y) ? x : y
|
|
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ChangeYearsToMonths
|
|
// -------------------
|
|
//
|
|
// General : Change years to months.
|
|
//
|
|
// Parameters :
|
|
// years - number (short)
|
|
//
|
|
// Return value : years as month.
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 26.09.2019
|
|
//---------------------------------------------------------------------------------------
|
|
int ChangeYearsToMonths(short years)
|
|
{
|
|
int days = years * MONTHS_IN_YEAR;
|
|
return days;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ChangeMonthsToDays
|
|
// ------------------
|
|
//
|
|
// General : change months to days.
|
|
//
|
|
// Parameters :
|
|
// month - first number (short)
|
|
//
|
|
// Return value : month as days.
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 26.09.2019
|
|
//---------------------------------------------------------------------------------------
|
|
int ChangeMonthsToDays(short months)
|
|
{
|
|
int days = months * DAYS_IN_MONTH;
|
|
return days;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ChangeDateToDays
|
|
// ----------------
|
|
//
|
|
// General : change date to days (from ddmmyyyy).
|
|
//
|
|
// Parameters :
|
|
// date - first number (int)
|
|
//
|
|
// Return value : date as days.
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 26.09.2019
|
|
//---------------------------------------------------------------------------------------
|
|
int ChangeDateToDays(int date)
|
|
{
|
|
short years,
|
|
month;
|
|
int days;
|
|
|
|
years = date % ONE_THOSEND;
|
|
date /= ONE_THOSEND;
|
|
month = date % ONE_HUNDRED;
|
|
date /= ONE_HUNDRED;
|
|
days = date;
|
|
month += ChangeYearsToMonths(years);
|
|
days += ChangeMonthsToDays(month);
|
|
return days;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ChangeDaysToMonths
|
|
// ------------------
|
|
//
|
|
// General : Change days to months.
|
|
//
|
|
// Parameters :
|
|
// days - first number (int)
|
|
//
|
|
// Return value : Days as months.
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 26.09.2019
|
|
//---------------------------------------------------------------------------------------
|
|
int ChangeDaysToMonths(int days)
|
|
{
|
|
int months = days / DAYS_IN_MONTH;
|
|
return months;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ChangeMonthsToYears
|
|
// -------------------
|
|
//
|
|
// General : Change months to years.
|
|
//
|
|
// Parameters :
|
|
// month - first number (int)
|
|
//
|
|
// Return value : months as years.
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 26.09.2019
|
|
//---------------------------------------------------------------------------------------
|
|
int ChangeMonthsToYears(int months)
|
|
{
|
|
int years = months / MONTHS_IN_YEAR;
|
|
return years;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ChangeDaysToDate
|
|
// ----------------
|
|
//
|
|
// General : Change days to date (format: ddmmyyyy)
|
|
//
|
|
// Parameters :
|
|
// days - first number (int)
|
|
//
|
|
// Return value : days as date by format ddmmyyyy
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 26.09.2019
|
|
//---------------------------------------------------------------------------------------
|
|
int ChangeDaysToDate(int days)
|
|
{
|
|
int date,
|
|
month = ChangeDaysToMonths(days),
|
|
years = ChangeMonthsToYears(month);
|
|
date = (days - (month * DAYS_IN_MONTH));
|
|
date *= ONE_HUNDRED;
|
|
date += (month - (years * MONTHS_IN_YEAR));
|
|
date *= ONE_THOSEND;
|
|
date += years;
|
|
return date;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// DifferentDates
|
|
// ---------------
|
|
//
|
|
// General : Sub between two dates (ddmmyyyy).
|
|
//
|
|
// Parameters :
|
|
// date1 - first date (int)
|
|
// date2 - second date (int)
|
|
//
|
|
// Return value : the different between two dates.
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 26.09.2019
|
|
//---------------------------------------------------------------------------------------
|
|
int DifferentDates(int date1, int date2)
|
|
{
|
|
int new_date = ChangeDateToDays(date1) - ChangeDateToDays(date2);
|
|
new_date = ChangeDaysToDate(new_date);
|
|
return new_date;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// EvenNumber
|
|
// ----------
|
|
//
|
|
// General : Check if the num is even
|
|
//
|
|
// Parameters :
|
|
// num - first num (int)
|
|
//
|
|
// Return value : 0 - FALSE, 0 - TRUE.
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 26.09.2019
|
|
//---------------------------------------------------------------------------------------
|
|
BOOLEAN EvenNumber(int num)
|
|
{
|
|
BOOLEAN answer = !(num % TWO);
|
|
|
|
return (answer);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// OppositeNumber
|
|
// --------------
|
|
//
|
|
// General : Change number order to Opposite. (123 -> 321)
|
|
//
|
|
// Parameters :
|
|
// num - first number (int)
|
|
//
|
|
// Return value : Number order opposite
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 26.09.2019
|
|
//---------------------------------------------------------------------------------------
|
|
int OppositeNumber(int num)
|
|
{
|
|
int temp_num = num,
|
|
new_num = ZERO;
|
|
for (; temp_num; temp_num /= TEN)
|
|
{
|
|
new_num *= TEN;
|
|
new_num += temp_num % TEN;
|
|
}
|
|
|
|
return (new_num);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// OddDigitsInNumber
|
|
// -----------------
|
|
//
|
|
// General : Take tne odd digits from number and component a
|
|
// new number
|
|
//
|
|
// Parameters :
|
|
// num - first number (int)
|
|
//
|
|
// Return value : A number that consists of odd numbers.
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 26.09.2019
|
|
//---------------------------------------------------------------------------------------
|
|
int OddDigitsInNumber(int num)
|
|
{
|
|
int temp = num,
|
|
new_num = ZERO;
|
|
short digit = ZERO;
|
|
|
|
for (; temp; temp /= TEN)
|
|
{
|
|
digit = temp % TEN;
|
|
if (!EvenNumber(digit))
|
|
{
|
|
new_num *= TEN;
|
|
new_num += digit;
|
|
}
|
|
}
|
|
|
|
return (new_num);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// EvenDigitsInNumber
|
|
// ------------------
|
|
//
|
|
// General : Take tne even digits from number and component a
|
|
// new number
|
|
//
|
|
// Parameters :
|
|
// num - first number (int)
|
|
//
|
|
// Return value : A number that consists of even numbers.
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 26.09.2019
|
|
//---------------------------------------------------------------------------------------
|
|
int EvenDigitsInNumber(int num)
|
|
{
|
|
int temp = num,
|
|
new_num = ZERO;
|
|
short digit = ZERO;
|
|
|
|
for (; temp; temp /= TEN)
|
|
{
|
|
digit = temp % TEN;
|
|
if (EvenNumber(digit))
|
|
{
|
|
new_num *= TEN;
|
|
new_num += digit;
|
|
}
|
|
}
|
|
|
|
return (new_num);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// SumOfNumberWithPositiveDigitsAndNumberWithNegativeDigits
|
|
// --------------------------------------------------------
|
|
//
|
|
// General : Sum Of Number With Positive Digits And Number With Negative Digits.
|
|
//
|
|
// Parameters :
|
|
// num - first number (int)
|
|
//
|
|
// Return value : Sum Of Number With Positive Digits And Number With Negative Digits.
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 26.09.2019
|
|
//---------------------------------------------------------------------------------------
|
|
int SumOfNumberWithPositiveDigitsAndNumberWithNegativeDigits(int num)
|
|
{
|
|
int temp_num = OppositeNumber(num);
|
|
int new_num = EvenDigitsInNumber(temp_num) +
|
|
OddDigitsInNumber(temp_num);
|
|
|
|
return (num);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// Power
|
|
// -----
|
|
//
|
|
// General : Power on number.
|
|
//
|
|
// Parameters :
|
|
// num - first number (float)
|
|
// pow - first second (short)
|
|
//
|
|
// Return value : number powerd.
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 26.09.2019
|
|
//---------------------------------------------------------------------------------------
|
|
double Power(float num, short pow)
|
|
{
|
|
double new_num = ONE;
|
|
short sign = ZERO;
|
|
|
|
for (sign = (TAKE_SIGNED(pow) * -ONE); pow; pow += sign)
|
|
{
|
|
new_num *= num;
|
|
}
|
|
new_num = (sign == -ONE) ? (new_num) : ((float)ONE / new_num);
|
|
return (new_num);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// GetRest
|
|
// -------
|
|
//
|
|
// General : Get the rest from double number.
|
|
//
|
|
// Parameters :
|
|
// num - first number (double)
|
|
// count_digits - second number (unsigned short)
|
|
//
|
|
// Return value : The rest of a number like int.
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 26.09.2019
|
|
//---------------------------------------------------------------------------------------
|
|
int GetRest(double num, unsigned short count_digits)
|
|
{
|
|
int tens = Power((float)TEN, count_digits);
|
|
return (int)(((int)(num * tens)) % tens);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// CountDigits
|
|
// -----------
|
|
//
|
|
// General : COunt digit in number.
|
|
//
|
|
// Parameters :
|
|
// num - first number (int)
|
|
//
|
|
// Return value : Number of digits count in a number.
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 26.09.2019
|
|
//---------------------------------------------------------------------------------------
|
|
unsigned short CountDigits(int num)
|
|
{
|
|
unsigned short count;
|
|
for (count = ZERO; num; num /= TEN, count++);
|
|
|
|
return (count);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ConvertBaseToDeciaml
|
|
// --------------------
|
|
//
|
|
// General : Convert a number from some base to base 10.
|
|
//
|
|
// Parameters :
|
|
// num - first number (float)
|
|
// base - second number (float)
|
|
// rest_size - third number (unsigned short)
|
|
//
|
|
// Return value : A number that converted from some base to number from base 10.
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 26.09.2019
|
|
//---------------------------------------------------------------------------------------
|
|
float ConvertBaseToDeciaml(float num, float base, unsigned short rest_size)
|
|
{
|
|
int temp_num = num;
|
|
float new_num = ZERO;
|
|
int rest = GetRest(num, (rest_size % TEN));
|
|
short pow;
|
|
float new_rest = ZERO;
|
|
float result = ZERO;
|
|
for (pow = ZERO; temp_num; temp_num /= TEN)
|
|
{
|
|
new_num += ((temp_num % TEN) * Power(base, pow));
|
|
pow++;
|
|
}
|
|
for (pow = (CountDigits(rest) * -ONE); rest; rest /= TEN)
|
|
{
|
|
new_rest += ((rest % TEN) * Power(base, pow));
|
|
pow++;
|
|
}
|
|
|
|
return new_num + new_rest;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// Sum
|
|
// ---
|
|
//
|
|
// General : Sum of two numbers.
|
|
//
|
|
// Parameters :
|
|
// number1 - first number (double)
|
|
// number2 - second number (double)
|
|
//
|
|
// Return value : Sum of two numbers (double).
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 21.10.2019
|
|
//---------------------------------------------------------------------------------------
|
|
double Sum(double number1, double number2)
|
|
{
|
|
double result = number1 + number2;
|
|
|
|
return (result);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// SumOfDigitsNumber
|
|
// -----------------
|
|
//
|
|
// General : Sum digits of number.
|
|
//
|
|
// Parameters :
|
|
// number - first number (double)
|
|
//
|
|
// Return value : Sum digits of number (int).
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 21.10.2019
|
|
//---------------------------------------------------------------------------------------
|
|
int SumOfDigitsNumber(double number)
|
|
{
|
|
int new_num = number * Power(TEN, 6);
|
|
int sum = 0;
|
|
for (; new_num; new_num /= TEN)
|
|
{
|
|
sum += new_num % TEN;
|
|
}
|
|
|
|
return (sum);
|
|
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// SumEvenDigits
|
|
// -------------
|
|
//
|
|
// General : Sum even digits of number.
|
|
//
|
|
// Parameters :
|
|
// number - first number (double)
|
|
//
|
|
// Return value : Sum even digits of number (int).
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 21.10.2019
|
|
//---------------------------------------------------------------------------------------
|
|
int SumEvenDigits(double number)
|
|
{
|
|
int new_num = number * Power(TEN, 6);;
|
|
|
|
return (SumOfDigitsNumber(EvenDigitsInNumber(new_num)));
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// SumOddDigits
|
|
// ------------
|
|
//
|
|
// General : Sum odd digits of number.
|
|
//
|
|
// Parameters :
|
|
// number - first number (double)
|
|
//
|
|
// Return value : Sum odd digits of number (int).
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 21.10.2019
|
|
//---------------------------------------------------------------------------------------
|
|
int SumOddDigits(double number)
|
|
{
|
|
int new_num = number * Power(TEN, 6);;
|
|
|
|
return (SumOfDigitsNumber(OddDigitsInNumber(new_num)));
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// CommonDigitsInTwoNumbers
|
|
// ------------------------
|
|
//
|
|
// General : Check if have common digits in two numbers.
|
|
//
|
|
// Parameters :
|
|
// number1 - first number (double)
|
|
// number2 - second number (double)
|
|
//
|
|
// Return value : If have common digits in two numbers (BOOLEAN).
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 21.10.2019
|
|
//---------------------------------------------------------------------------------------
|
|
BOOLEAN CommonDigitsInTwoNumbers(double number1, double number2)
|
|
{
|
|
int new_number1 = number1 * Power(10, 6);
|
|
int new_number2 = number2 * Power(10, 6);
|
|
short num1_digit;
|
|
BOOLEAN answer = FALSE;
|
|
|
|
for (num1_digit = new_number1 % TEN; new_number1 && !answer; new_number2 /= TEN)
|
|
{
|
|
if (new_number2)
|
|
{
|
|
new_number1 /= TEN;
|
|
num1_digit = new_number1 % TEN;
|
|
new_number2 = number2;
|
|
}
|
|
answer = (num1_digit == new_number2 % TEN) ? TRUE : FALSE;
|
|
}
|
|
|
|
return(answer);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// Sqrt
|
|
// ----
|
|
//
|
|
// General : Math sqrt
|
|
//
|
|
// Parameters :
|
|
// number - number (double)
|
|
// root - root of sqrt, second number (short)
|
|
//
|
|
// Return value : Math sqrt on number (double).
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 21.10.2019
|
|
//---------------------------------------------------------------------------------------
|
|
double Sqrt(double number, short root)
|
|
{
|
|
double max = number,
|
|
min = ZERO,
|
|
temp_min,
|
|
difference = ONE,
|
|
power_min;
|
|
while(number != Power(min, root))
|
|
{
|
|
difference = (max - min) / TWO;
|
|
|
|
temp_min = min + difference;
|
|
|
|
power_min = Power(temp_min, root);
|
|
number = ((float)temp_min == (float)min) ? power_min: number;
|
|
|
|
min = (power_min <= number) ? temp_min : min;
|
|
max = (power_min > number) ? temp_min : max;
|
|
}
|
|
|
|
return min;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// PrimeNumber
|
|
// -----------
|
|
//
|
|
// General : Check if number is a prime number.
|
|
//
|
|
// Parameters :
|
|
// number - first number (int)
|
|
//
|
|
// Return value : If the number is a prime (BOOLEAN).
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 21.10.2019
|
|
//---------------------------------------------------------------------------------------
|
|
BOOLEAN PrimeNumber(int number)
|
|
{
|
|
BOOLEAN answer = TRUE;
|
|
short counter,
|
|
max = Sqrt(number, TWO) + ONE;
|
|
for (counter = TWO; counter < max; counter++)
|
|
{
|
|
answer *= (number % counter != ZERO) ? TRUE : FALSE;
|
|
}
|
|
|
|
return (answer);
|
|
}
|
|
|
|
double Module(double number, double div) // TODO : FIX IT
|
|
{
|
|
unsigned int count;
|
|
double temp_number = number;
|
|
for (count = ZERO; temp_number > div; temp_number -= div)
|
|
{
|
|
count++;
|
|
}
|
|
|
|
return (temp_number);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// DigitInNumber
|
|
// -------------
|
|
//
|
|
// General : Check if digit in the number.
|
|
//
|
|
// Parameters :
|
|
// number - first number (double)
|
|
// digit - second number (unsigned short)
|
|
//
|
|
// Return value : If the the digit exists in the number (BOOLEAN).
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 21.10.2019
|
|
//---------------------------------------------------------------------------------------
|
|
BOOLEAN DigitInNumber(double number, unsigned short digit)
|
|
{
|
|
int new_num = (number * 6) + GetRest(number, 6);
|
|
BOOLEAN answer = FALSE;
|
|
for (; new_num && !answer; new_num /= TEN)
|
|
{
|
|
answer = (new_num % 10 == digit);
|
|
}
|
|
|
|
return (answer);
|
|
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ConcatenationNumbers
|
|
// --------------------
|
|
//
|
|
// General : Concatenation two numbers to one number.
|
|
//
|
|
// Parameters :
|
|
// number1 - first number (short)
|
|
// number2 - second number (short)
|
|
//
|
|
// Return value : Number with two number (int).
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 21.10.2019
|
|
//---------------------------------------------------------------------------------------
|
|
int ConcatenationNumbers(short number1, short number2)
|
|
{
|
|
int new_number = number1;
|
|
new_number *= Power(TEN, CountDigits(number2));
|
|
new_number += number2;
|
|
|
|
return (new_number);
|
|
}
|
|
|
|
int Multiplication(short number1, short multiply) // TODO : FIX IT
|
|
{
|
|
int new_number = ZERO;
|
|
for (; multiply > ZERO; multiply--)
|
|
{
|
|
new_number += number1;
|
|
}
|
|
|
|
return (new_number);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// GetDenominator
|
|
// ---------------
|
|
//
|
|
// General : Calculates the denominator of a number with a decimal point.
|
|
//
|
|
// Parameters :
|
|
// number - first number (double)
|
|
//
|
|
// Return value : Denominator (int).
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 21.10.2019
|
|
//---------------------------------------------------------------------------------------
|
|
int GetDenominator(double number)
|
|
{
|
|
int denominator;
|
|
double temp_number = number;
|
|
for (denominator = ONE ; (float)((short)temp_number != (float)temp_number);
|
|
temp_number += number)
|
|
{
|
|
denominator++;
|
|
}
|
|
|
|
return (denominator);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// GetCounter
|
|
// ----------
|
|
//
|
|
// General : Calculates the numerator of a number with a decimal point.
|
|
//
|
|
// Parameters :
|
|
// number - first number (double)
|
|
//
|
|
// Return value : Counter (int).
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 21.10.2019
|
|
//---------------------------------------------------------------------------------------
|
|
short GetCounter(double number)
|
|
{
|
|
double temp_number = number;
|
|
while ((float)((short)temp_number) != (float)temp_number)
|
|
{
|
|
temp_number += number;
|
|
}
|
|
|
|
return (temp_number);
|
|
}
|
|
|
|
double Divide(double number, double div) // TODO : FIX IT
|
|
{
|
|
double count_high,
|
|
temp_number = number;
|
|
for (count_high = ZERO; temp_number >= div; temp_number -= div)
|
|
{
|
|
count_high++;
|
|
}
|
|
return (count_high);
|
|
}
|
|
|
|
double MultiplicationFractions(float number1, float number2) // TODO : FIX IT
|
|
{
|
|
short number1_counter = GetCounter(number1),
|
|
number2_counter = GetCounter(number2),
|
|
number1_denominator = GetDenominator(number1),
|
|
number2_denominator = GetDenominator(number2),
|
|
final_counter,
|
|
final_denominator;
|
|
double result;
|
|
printf("%hd\n%hd\n%hd\n%hd\n", number1_counter, number1_denominator, number2_counter, number2_denominator);
|
|
final_counter = Multiplication(number1_counter, number2_counter);
|
|
final_denominator = Multiplication(number1_denominator, number2_denominator);
|
|
|
|
result = Divide(final_counter, final_denominator);
|
|
|
|
return (result);
|
|
}
|
|
|
|
double MultiplicationFloat(float number1, float multiply) // TODO : FIX IT
|
|
{
|
|
double new_number = ZERO,
|
|
temp_number1;
|
|
|
|
for (; multiply -ONE > ZERO; multiply--)
|
|
{
|
|
new_number += number1;
|
|
}
|
|
temp_number1 = number1 - new_number;
|
|
new_number += MultiplicationFractions(temp_number1, multiply);
|
|
|
|
//new_number += Divide(number1, Divide(ONE, multiply));
|
|
|
|
return (new_number);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// SumInArray
|
|
// ----------
|
|
//
|
|
// General : Checks if there are two numbers whose sum is equal to
|
|
// the number entered as "sum".
|
|
//
|
|
// Parameters :
|
|
// array[] - array (int)
|
|
// size - array size (unsigned int)
|
|
// sum - The amount required (int)
|
|
//
|
|
// Return value : Counter (int).
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 21.10.2019
|
|
//---------------------------------------------------------------------------------------
|
|
BOOLEAN SumInArray(int array[], unsigned int size, int sum)
|
|
{
|
|
BOOLEAN answer = FALSE;
|
|
unsigned int temp_size = size,
|
|
count;
|
|
double temp_sum;
|
|
|
|
for (count = ZERO; count < temp_size && !answer;)
|
|
{
|
|
temp_sum = array[count] + array[temp_size];
|
|
answer = (temp_sum == sum) ? TRUE : FALSE;
|
|
count += (temp_sum < sum) ? ONE : ZERO;
|
|
temp_size -= (temp_sum > sum) ? ONE : ZERO;
|
|
}
|
|
|
|
return (answer);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ChangeBool
|
|
// ----------
|
|
//
|
|
// General : Boolean variable inverse.
|
|
//
|
|
// Parameters :
|
|
// bool1 - Boolean variable (BOOLEAN)
|
|
//
|
|
// Return value : Boolean variable (BOOLEAN).
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 21.10.2019
|
|
//---------------------------------------------------------------------------------------
|
|
BOOLEAN ChangeBool(BOOLEAN bool1)
|
|
{
|
|
BOOLEAN answer = ++bool1 % TWO;
|
|
return answer;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// Equality
|
|
// --------
|
|
//
|
|
// General : Checks whether two numbers are equal in value.
|
|
//
|
|
// Parameters :
|
|
// number1 - first number (int)
|
|
// number2 - second number (int)
|
|
//
|
|
// Return value : If there is an equality between the two numbers (BOOLEAN).
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 21.10.2019
|
|
//---------------------------------------------------------------------------------------
|
|
BOOLEAN Equality(int number1, int number2)
|
|
{
|
|
int sub = number1 - number2;
|
|
BOOLEAN answer = (ONE / (ABS(sub) + ONE));
|
|
return answer;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// NumBBiggerThenNumA
|
|
// ------------------
|
|
//
|
|
// General : Checks if the second number (B) is greater than the first number (A).
|
|
//
|
|
// Parameters :
|
|
// number1 - first number (int)
|
|
// number2 - second number (int)
|
|
//
|
|
// Return value : If the second number (B) is greater than the first number (A) (BOOLEAN).
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 21.10.2019
|
|
//---------------------------------------------------------------------------------------
|
|
BOOLEAN NumBBiggerThenNumA(int a, int b)
|
|
{
|
|
int sub = a - b + ONE;
|
|
BOOLEAN answer = (ONE / (ABS(sub) + (sub) + ONE));
|
|
return answer;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// SumOfTimesCharsArray1InCharsArray2
|
|
// ----------------------------------
|
|
//
|
|
// General : Checks the number of times the first array values are in the
|
|
// second array in the appropriate order.
|
|
//
|
|
// Parameters :
|
|
// array1[] - first array (char[])
|
|
// array1_size - size of array1 (unsigned int)
|
|
// array2[] - second array (char[])
|
|
// array2_size - size of array2 (unsigned int)
|
|
//
|
|
// Return value : The number of times the first array is in the
|
|
// second array (unsigned int).
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 21.10.2019
|
|
//---------------------------------------------------------------------------------------
|
|
unsigned int SumOfTimesCharsArray1InCharsArray2(char array1[],
|
|
unsigned int array1_size,
|
|
char array2[],
|
|
unsigned int array2_size)
|
|
{
|
|
unsigned int count = ZERO,
|
|
is_in = TRUE,
|
|
count_loop_array1,
|
|
count_loop_array2;
|
|
|
|
for (count_loop_array2 = ZERO; count_loop_array2 < array2_size; count_loop_array2++)
|
|
{
|
|
for (count_loop_array1 = ZERO;
|
|
count_loop_array1 < array1_size && is_in; count_loop_array1++)
|
|
{
|
|
is_in *= Equality(array1[count_loop_array1],
|
|
array2[count_loop_array2 + count_loop_array1]);
|
|
}
|
|
count += is_in;
|
|
}
|
|
|
|
return (count);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// CreateMask
|
|
// ----------
|
|
//
|
|
// General : Creates a number with identical digits.
|
|
//
|
|
// Parameters :
|
|
// size - digits count of number (unsigned short)
|
|
// digit_of_mask - type of digits (unsigned short)
|
|
//
|
|
// Return value : A number that all the digits are the same (unsigned int)
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 21.10.2019
|
|
//---------------------------------------------------------------------------------------
|
|
unsigned int CreateMask(unsigned short size, unsigned short digit_of_mask)
|
|
{
|
|
unsigned int mask = digit_of_mask;
|
|
unsigned short counter;
|
|
for (counter = ONE; counter < size; counter++)
|
|
{
|
|
mask *= TEN;
|
|
mask += digit_of_mask;
|
|
}
|
|
|
|
return mask;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// CountADigitInNumber
|
|
// -------------------
|
|
//
|
|
// General : Count the number of times her story appears in number.
|
|
//
|
|
// Parameters :
|
|
// number - a number (int)
|
|
// digit - a digit (unsigned short)
|
|
//
|
|
// Return value : The number of times the number appears in the number (unsigned short)
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 21.10.2019
|
|
//---------------------------------------------------------------------------------------
|
|
unsigned short CountADigitInNumber(int number, unsigned short digit)
|
|
{
|
|
int temp_num = number;
|
|
unsigned count = FALSE;
|
|
for (; temp_num; temp_num /= TEN)
|
|
{
|
|
count += Equality(temp_num % TEN, digit);
|
|
}
|
|
|
|
return (count);
|
|
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// GetDigit
|
|
// --------
|
|
//
|
|
// General : Takes the digit from the required location.
|
|
//
|
|
// Parameters :
|
|
// number - a number (int)
|
|
// location - index of digit (unsigned short)
|
|
//
|
|
// Return value : The number that is in the number where you want it (short)
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 21.10.2019
|
|
//---------------------------------------------------------------------------------------
|
|
short GetDigit(int number, unsigned short location)
|
|
{
|
|
int temp_num = number;
|
|
unsigned short digit;
|
|
for (; location; location--)
|
|
{
|
|
temp_num /= TEN;
|
|
}
|
|
digit = temp_num % TEN;
|
|
|
|
return (digit);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// CountOfIdenticalDigitsInSomeIndex
|
|
// ---------------------------------
|
|
//
|
|
// General : Count the number of times there are identical digits between
|
|
// two numbers and in the same location.
|
|
//
|
|
// Parameters :
|
|
// number1 - first number (int)
|
|
// number2 - second number (int)
|
|
//
|
|
// Return value : The number of times there are identical
|
|
// digits between two numbers and in the same location (unsigned short)
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 21.10.2019
|
|
//---------------------------------------------------------------------------------------
|
|
unsigned short CountOfIdenticalDigitsInSomeIndex(int number1, int number2)
|
|
{
|
|
int temp_num1,
|
|
temp_num2;
|
|
unsigned short count = ZERO;
|
|
for (temp_num1 = MIN(number1, number2), temp_num2 = MAX(number1, number2);
|
|
temp_num1;
|
|
temp_num1 /= TEN, temp_num2 /= TEN)
|
|
{
|
|
count += Equality(temp_num1 % TEN, temp_num2 % TEN);
|
|
}
|
|
|
|
return (count);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// CountOfIdenticalDigits
|
|
// ----------------------
|
|
//
|
|
// General : Count the number of times there are identical digits
|
|
// between two numbers.
|
|
//
|
|
// Parameters :
|
|
// number1 - first number (int)
|
|
// number2 - second number (int)
|
|
//
|
|
// Return value : The number of times there are identical digits
|
|
// between two numbers (unsigned short)
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 21.10.2019
|
|
//---------------------------------------------------------------------------------------
|
|
unsigned short CountOfIdenticalDigits(int number1, int number2)
|
|
{
|
|
int temp_num1,
|
|
temp_num2;
|
|
unsigned short count = ZERO,
|
|
digit_num1;
|
|
for (temp_num1 = number1; temp_num1; temp_num1 /= TEN)
|
|
{
|
|
digit_num1 = temp_num1 % TEN;
|
|
for (temp_num2 = number2; temp_num2; temp_num2 /= TEN)
|
|
{
|
|
count += Equality(digit_num1, temp_num2 % TEN);
|
|
}
|
|
temp_num2 = number2;
|
|
}
|
|
|
|
return (count);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// ForeignDigits
|
|
// -------------
|
|
//
|
|
// General : Checks whether all digits are foreign to each other by number.
|
|
//
|
|
// Parameters :
|
|
// number - first number (int)
|
|
//
|
|
// Return value : If all the numbers are foreign to each other in number (BOOLEAN)
|
|
//
|
|
//---------------------------------------------------------------------------------------
|
|
// Programmer : Cohen Idan
|
|
// Student No : None
|
|
// Date : 21.10.2019
|
|
//---------------------------------------------------------------------------------------
|
|
BOOLEAN ForeignDigits(int number)
|
|
{
|
|
int temp_num = number;
|
|
BOOLEAN answer = TRUE;
|
|
for (; temp_num; temp_num /= TEN)
|
|
{
|
|
answer *= NumBBiggerThenNumA(CountADigitInNumber(temp_num, temp_num % TEN), TWO);
|
|
}
|
|
|
|
return (answer);
|
|
} |