# numbers

***

**1. Integer Representation**

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

**2. Floating-Point Representation**

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

**3. Mathematical Operations**

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

**4. Arithmetic Assignment**

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

**5. Comparison Operators**

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

**6. Relational Operators**

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

**7. Bitwise Operators**

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

**8. Increment and Decrement Operators**

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

**9. Signed and Unsigned Integers**

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

**10. Constants**

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

**11. Random Numbers**

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

**12. Number Formatting**

```cpp
#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**

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

**14. Number to String Conversion**

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

**15. Hexadecimal Representation**

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

**16. Octal Representation**

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

**17. Number of Digits**

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

**18. Sum of Digits**

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

**19. Largest Digit**

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

**20. Prime Number Check**

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

**21. Factorial Calculation**

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

**22. Square Root**

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

**23. Fibonacci Sequence**

```cpp
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**

```cpp
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**

```cpp
int lcm = (num * big_num) / gcd;
```

**26. Check if a Number is Even**

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

**27. Check if a Number is Odd**

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

**28. Rounding Numbers**

```cpp
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**

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

**30. Reversing a Number**

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

**31. Palindrome Check**

```cpp
bool is_palindrome = (num == reversed_num);
```

**32. Armstrong Number**

```cpp
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**

```cpp
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**

```cpp
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**

```cpp
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**

```cpp
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**

```cpp
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**

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

**39. Calculate the Mean**

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

**40. Calculate the Median**

```cpp
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**

```cpp
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**

```cpp
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**

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

**44. Calculate the Standard Deviation**

```cpp
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**

```cpp
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**

```cpp
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**

```cpp
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**

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

**49. Check if a Number is a Fibonacci Number**

```cpp
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**

```cpp
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++;
}
```