numbers

---

1. Integer Representation

int num = 123; // 32-bit integer
long long big_num = 1234567890123456789; // 64-bit integer

2. Floating-Point Representation

float fnum = 1.23f; // 32-bit floating-point
double dnum = 1.23456789; // 64-bit floating-point

3. Mathematical Operations

int result = num + big_num; // addition
float product = fnum * dnum; // multiplication

4. Arithmetic Assignment

num += 10; // num is now 133
big_num /= 2; // big_num is now 617283945061728445

5. Comparison Operators

if (num > big_num) {
    // This condition won't be true
}
if (fnum == 1.23f) {
    // This condition will be true
}

6. Relational Operators

if (num < 100) {
    // This condition will be true
}
if (big_num >= 1000000000000000000) {
    // This condition will be true
}

7. Bitwise Operators

int mask = 0b1111; // binary bitmask
int masked_num = num & mask; // perform bitwise AND operation

8. Increment and Decrement Operators

num++; // increment num by 1
big_num--; // decrement big_num by 1

9. Signed and Unsigned Integers

int signed_num = -123; // 32-bit signed integer
unsigned int unsigned_num = 123; // 32-bit unsigned integer

10. Constants

const int MAX_VALUE = 100; // constant integer
const double PI = 3.14159265; // constant floating-point

11. Random Numbers

#include <random>
std::random_device rd;
std::mt19937 gen(rd());
int random_num = gen(); // generate a random number

12. Number Formatting

#include <iomanip>
std::cout << std::fixed << std::setprecision(2) << dnum; // format as a fixed-point number with 2 decimal places

13. String to Number Conversion

#include <sstream>
int num_from_string = std::stoi("123"); // convert a string to an integer

14. Number to String Conversion

#include <sstream>
std::string string_from_num = std::to_string(num); // convert an integer to a string

15. Hexadecimal Representation

int hex_num = 0x123; // hexadecimal integer (0x prefix)

16. Octal Representation

int oct_num = 0123; // octal integer (0 prefix)

17. Number of Digits

int num_digits = std::to_string(num).length(); // count the number of digits in a number

18. Sum of Digits

int sum_digits = 0;
while (num > 0) {
    sum_digits += num % 10;
    num /= 10;
}

19. Largest Digit

int largest_digit = 0;
while (num > 0) {
    int digit = num % 10;
    if (digit > largest_digit) {
        largest_digit = digit;
    }
    num /= 10;
}

20. Prime Number Check

bool is_prime = true;
for (int i = 2; i <= (int)sqrt(num); i++) {
    if (num % i == 0) {
        is_prime = false;
        break;
    }
}

21. Factorial Calculation

int factorial = 1;
for (int i = 1; i <= num; i++) {
    factorial *= i;
}

22. Square Root

#include <cmath>
double sqrt_num = std::sqrt(dnum); // calculate the square root using math library

23. Fibonacci Sequence

int fib_num;
if (num <= 1) {
    fib_num = num;
} else {
    int a = 0, b = 1;
    for (int i = 2; i <= num; i++) {
        fib_num = a + b;
        a = b;
        b = fib_num;
    }
}

24. Greatest Common Divisor

int gcd = 0; 
for (int i = 1; i <= std::min(num, big_num); i++) {
    if (num % i == 0 && big_num % i == 0) {
        gcd = i;
    }
}

25. Least Common Multiple

int lcm = (num * big_num) / gcd;

26. Check if a Number is Even

bool is_even = (num % 2 == 0);

27. Check if a Number is Odd

bool is_odd = (num % 2 != 0);

28. Rounding Numbers

std::round(dnum); // round to the nearest integer
std::floor(dnum); // round down to the nearest integer
std::ceil(dnum); // round up to the nearest integer

29. Counting Set Bits

int set_bits = 0;
for (int i = 0; i < 32; i++) {
    if ((num & (1 << i)) != 0) {
        set_bits++;
    }
}

30. Reversing a Number

int reversed_num = 0;
while (num > 0) {
    reversed_num = reversed_num * 10 + num % 10;
    num /= 10;
}

31. Palindrome Check

bool is_palindrome = (num == reversed_num);

32. Armstrong Number

int sum_cubes = 0;
int temp_num = num;
while (temp_num > 0) {
    int digit = temp_num % 10;
    sum_cubes += digit * digit * digit;
    temp_num /= 10;
}
bool is_armstrong = (sum_cubes == num);

33. Perfect Number

int sum_divisors = 0;
for (int i = 1; i < num; i++) {
    if (num % i == 0) {
        sum_divisors += i;
    }
}
bool is_perfect = (sum_divisors == num);

34. Amicable Numbers

int sum_div1 = 0, sum_div2 = 0;
for (int i = 1; i < num; i++) {
    if (big_num % i == 0) {
        sum_div1 += i;
    }
}
for (int i = 1; i < big_num; i++) {
    if (num % i == 0) {
        sum_div2 += i;
    }
}
bool are_amicable = (sum_div1 == big_num && sum_div2 == num);

35. Mersenne Prime

bool is_mersenne_prime = true;
for (int i = 2; i <= (int)sqrt(num); i++) {
    if (num % i == 0 || (num - 1) % i == 0) {
        is_mersenne_prime = false;
        break;
    }
}

36. Inverse Modulo

int inverse_mod = 1;
for (int i = 1; i < num; i++) {
    if ((num * i) % big_num == 1) {
        inverse_mod = i;
        break;
    }
}

37. Binary Search for a Number

int start = 0, end = arr.size() - 1;
while (start <= end) {
    int mid = (start + end) / 2;
    if (arr[mid] == num) {
        return mid;
    } else if (arr[mid] < num) {
        start = mid + 1;
    } else {
        end = mid - 1;
    }
}
return -1;

38. Sort a List of Numbers

std::vector<int> numbers = {5, 2, 7, 3, 1, 4};
std::sort(numbers.begin(), numbers.end());

39. Calculate the Mean

int sum = 0;
for (int i = 0; i < numbers.size(); i++) {
    sum += numbers[i];
}
double mean = (double)sum / numbers.size();

40. Calculate the Median

std::vector<int> sorted_numbers = numbers;
std::sort(sorted_numbers.begin(), sorted_numbers.end());
int median;
if (sorted_numbers.size() % 2 == 0) {
    int mid1 = sorted_numbers[sorted_numbers.size() / 2 - 1];
    int mid2 = sorted_numbers[sorted_numbers.size() / 2];
    median = (mid1 + mid2) / 2;
} else {
    median = sorted_numbers[sorted_numbers.size() / 2];
}

41. Calculate the Mode

std::map<int, int> freq;
for (int i = 0; i < numbers.size(); i++) {
    freq[numbers[i]]++;
}
int mode = -1;
int max_freq = 0;
for (auto& [num, count] : freq) {
    if (count > max_freq) {
        max_freq = count;
        mode = num;
    }
}

42. Find the Minimum and Maximum

int min_num = *std::min_element(numbers.begin(), numbers.end());
int max_num = *std::max_element(numbers.begin(), numbers.end());

43. Find the Sum of Squares

int sum_squares = 0;
for (int i = 0; i < numbers.size(); i++) {
    sum_squares += numbers[i] * numbers[i];
}

44. Calculate the Standard Deviation

double mean = 0;
for (int i = 0; i < numbers.size(); i++) {
    mean += numbers[i];
}
mean /= numbers.size();

double variance = 0;
for (int i = 0; i < numbers.size(); i++) {
    variance += (numbers[i] - mean) * (numbers[i] - mean);
}
variance /= numbers.size();

double std_dev = sqrt(variance);

45. Convert to Different Number Bases

std::string binary_num = std::bitset<8>(num).to_string();
std::string octal_num = std::oct(num);
std::string hexadecimal_num = std::hex(num);

46. Perform Arithmetic Operations on Vectors of Numbers

std::vector<double> vec1 = {1.0, 2.0, 3.0};
std::vector<double> vec2 = {4.0, 5.0, 6.0};

std::vector<double> sum_vec;
for (int i = 0; i < vec1.size(); i++) {
    sum_vec.push_back(vec1[i] + vec2[i]);
}

std::vector<double> product_vec;
for (int i = 0; i < vec1.size(); i++) {
    product_vec.push_back(vec1[i] * vec2[i]);
}

47. Generate a Random Number Generator

std::mt19937 gen;
std::uniform_int_distribution<int> dis(0, 100);
int random_num = dis(gen);

48. Check if a Number is a Power of 2

bool is_power_of_2 = ((num & (num - 1)) == 0);

49. Check if a Number is a Fibonacci Number

int sqrt_num = round(sqrt(5 * num));
bool is_fibonacci = ((sqrt_num * sqrt_num == 5 * num) || ((sqrt_num - 1) * (sqrt_num - 1) == 5 * num));

50. Find the N-th Prime Number

int count = 0;
int n_th_prime = 2;
for (int i = 3; ; i += 2) {
    bool is_prime = true;
    for (int j = 2; j <= (int)sqrt(i); j++) {
        if (i % j == 0) {
            is_prime = false;
            break;
        }
    }
    if (is_prime) {
        count++;
    }
    if (count == n_th_prime) {
        break;
    }
    n_th_prime++;
}