Demystifying Modulo in C++

#include <iostream>

int main() {
    // Define two integers
    int a = 17; // Dividend
    int b = 5;  // Divisor

    // Calculate the remainder using the modulo operator
    int remainder = a % b;

    // Print the result in a readable format
    std::cout << a << " % " << b << " = " << remainder << "\n";

    // Additional examples demonstrating various cases
    std::cout << "10 % 3 = " << 10 % 3 << "\n";  // Remainder is 1
    std::cout << "8 % 4 = " << 8 % 4 << "\n";    // Remainder is 0
    std::cout << "15 % 7 = " << 15 % 7 << "\n";  // Remainder is 1

    return 0; // End of program
}

#include <iostream>
#include <string>

int main() {
    // Initialize a number
    int number = 12345;

    // Convert the number to a string
    std::string num_str = std::to_string(number);

    // Get the last digit using modulo
    int last_digit = (number % 10);

    // Print the original number and last digit obtained through modulo
    std::cout << "Number: " << number << "\n";
    std::cout << "Last digit using modulo: " << last_digit << "\n";

    // Retrieve the last digit using the string representation
    std::cout << "Last digit using to_string: "
              << num_str[num_str.length() - 1] << "\n";

    // Format a smaller number with leading zeros
    int value = 7;
    std::string formatted = std::to_string(value % 100); // Ensure it's within two digits

    // Add a leading zero if the length is less than 2
    if (formatted.length() < 2) {
        formatted = "0" + formatted;
    }

    // Print the formatted result
    std::cout << "Formatted number: " << formatted << "\n";

    return 0; // End of program
}

#include <iostream>

int main() {
    // Integer modulo: Standard operation
    int int_result = 17 % 5; // Remainder is 2

    // Note: Modulo with floating-point numbers is not allowed directly
    // Uncommenting the following line would cause a compilation error:
    // double float_mod = 17.5 % 5.0;

    // Modulo with larger integer types
    long long big_num = 1234567890LL; // A large number
    int divisor = 1000;              // Divisor

    // The result type matches the dividend (big_num in this case)
    long long big_result = big_num % divisor; // Remainder is 890

    // Output the results
    std::cout << "Integer modulo: " << int_result << "\n";
    std::cout << "Large number modulo: " << big_result << "\n";

    // Modulo with smaller integer types
    short small_num = 256; // A smaller integer type
    short small_result = small_num % 10; // Remainder is 6

    std::cout << "Short integer modulo: " << small_result << "\n";

    return 0; // End of program
}

#include <iostream>
#include <cmath> // Required for std::fmod

int main() {
    // Attempting modulo with floating-point numbers
    double a = 17.5;
    double b = 5.2;

    // C++ does not support the '%' operator with floating-point numbers.
    // Use std::fmod for floating-point modulo operations.
    double float_remainder = std::fmod(a, b);
    std::cout << "Floating-point remainder: " << float_remainder << "\n";

    // Handling division by zero
    int num = 10;
    int zero = 0;

    // Safe way to handle modulo when divisor might be zero
    if (zero != 0) {
        // Perform modulo operation only if divisor is non-zero
        int result = num % zero;
        std::cout << "Modulo result: " << result << "\n";
    } else {
        // Inform user about the division by zero restriction
        std::cout << "Cannot divide by zero!\n";
    }

    return 0; // End of program
}

#include <iostream>

int main() {
    // Modulo with positive dividend and divisor
    std::cout << "17 % 5 = " << 17 % 5 << "\n"; // Remainder is 2

    // Modulo with negative dividend and positive divisor
    std::cout << "-17 % 5 = " << -17 % 5 << "\n"; // Remainder is -2

    // Modulo with positive dividend and negative divisor
    std::cout << "17 % -5 = " << 17 % -5 << "\n"; // Remainder is 2

    // Modulo with both dividend and divisor negative
    std::cout << "-17 % -5 = " << -17 % -5 << "\n"; // Remainder is -2

    // Common use case: ensuring a positive result
    // This formula adjusts the result to always be positive
    int ensure_positive = (-17 % 5 + 5) % 5;
    std::cout << "Ensuring positive result: " << ensure_positive << "\n";

    return 0; // End of program
}

#include <iostream>
#include <string>
#include <vector>

// Circular buffer implementation using modulo
class CircularBuffer {
    std::vector<int> buffer; // Internal storage
    size_t size;                 // Maximum size of the buffer
    size_t head = 0;             // Points to the next write position

public:
    CircularBuffer(size_t s) : size(s), buffer(s, 0) {}

    // Add an element to the circular buffer
    void add(int value) {
        buffer[head] = value;             // Overwrite at the current head position
        head = (head + 1) % size;         // Move head to the next position (wraps around using modulo)
    }

    // Get an element from the buffer at a given index
    int get(size_t index) {
        return buffer[index % size];      // Ensure index wraps within buffer size
    }
};

// Convert total minutes to formatted time (HH:MM)
std::string formatTime(int totalMinutes) {
    int hours = totalMinutes / 60;        // Calculate hours
    int minutes = totalMinutes % 60;     // Calculate remaining minutes

    // Format time with leading zero for minutes
    return std::to_string(hours) + ":" +
           (minutes < 10 ? "0" : "") + std::to_string(minutes);
}

int main() {
    // Circular buffer example
    CircularBuffer cb(3); // Buffer of size 3
    for (int i = 1; i <= 5; ++i) {
        cb.add(i); // Add elements (will overwrite older ones)
    }

    // Print the contents of the circular buffer
    for (size_t i = 0; i < 3; ++i) {
        std::cout << "Buffer[" << i << "]: " << cb.get(i) << "\n";
    }

    // Time formatting example
    int minutes = 185; // Example: 185 minutes = 3 hours and 5 minutes
    std::cout << "Time formatted: " << formatTime(minutes) << "\n";

    // Hash table index calculation example
    int tableSize = 10; // Hash table size
    std::string key = "test";
    size_t hash = 0;

    // Compute hash index using modulo to stay within table size
    for (char c : key) {
        hash = (hash * 31 + c) % tableSize; // Hash formula
    }
    std::cout << "Hash table index for 'test': " << hash << "\n";

    return 0; // End of program
}