C++ program to divide a string into N equal parts

In this article, you will learn about how divide a string into N equal parts in C++. String manipulation and fundamental arithmetic are used in the C++ program to split a string into N equal pieces.

1. Input:

Two user inputs are required at the beginning of the program:

A user-supplied string (input) that they desire to split into equal pieces.
The user can divide a string into as many equal pieces (N) as desired by providing an integer (n) to symbolize this.

2. Length Calculation

Measurement of length using the length() function of the string class, the program measures the length of the supplied string. The length is kept in the variable len. You must first know its length to divide a string into equal pieces.

3. Check for errors:

The string's length must be divisible by n to split it into equal pieces. Len% n is tested to see if it equals zero by the program. If it's not, the program will exit after displaying an error notice and indicating that the string cannot be split into equal parts.

4. Calculation of Part Size:

If the length of the string is divisible by n, the program determines how big each part should be. To achieve this, multiply the string's length by n, which creates the variable partSize. Every component must be this size.

5. Loop for Division:

The n is the number of components that the user requested, and the loop iterates n times. Every time the loop is executed:

The program using the substr function of the string class to extracts a section of the input string. The substr function requires two inputs: the beginning position, which is updated after each iteration, and the length of the substring, which is partSize.
After that, the extracted part is included in a vector called "parts" that will hold all of the parts.

6. Printing:

The program prints each portion of the string on a separate line after successfully splitting it into equal parts. After that, it shows a message indicating that the string has been divided.

7. Conclusion:

The program finally returns 0 to show that it ran successfully.

Program:

Let's take an example to demonstrate how to divide a string into N strings in C++:

#include <iostream>
#include <string>
#include <vector>
// Function to divide a string into N equal parts
std::vector<std::string> divideString(const std::string& input, int n) 
{
    int len = input.length(); 
    // Calculate the length of the input string
    std::vector<std::string> parts; 
    // Create a vector to store the parts
    // Check if it's possible to divide the string into equal parts
    if (len % n != 0) 
    {
        std::cout << "Cannot divide the string into equal parts." << std::endl;
        return parts; // Return an empty vector if not possible
    }
    int partSize = len / n; // Calculate the size of each part
    int startPos = 0;
    // Loop to extract each part of the string
    for (int i = 0; i < n; ++i)
    {
        std::string part = input.substr(startPos, partSize); // Use substr to extract a part
        parts.push_back(part); // Add the part to the vector
        startPos += partSize; // Update the starting position for the next part
    }
    return parts; // Return the vector containing the parts
}
int main() 
{
    std::string input;
    int n;
    // Input the string and the number of parts (N) from the user
    std::cout << "Enter a string: ";
    std::getline(std::cin, input); 
    // Read the entire input line
    std::cout << "Enter the number of parts (N): ";
    std::cin >> n;
    // Call the divideString function to divide the string into parts
    std::vector<std::string> parts = divideString(input, n);
    // Check if the division was successful
    if (!parts.empty())
    {
        std::cout << "The string is divided into " << n << " equal parts:" << std::endl;
        // Print each part of the string
        for (const std::string& part : parts) 
        {
            std::cout << part << std::endl;
        }
    }
    return 0;
}

Output:

Enter a string: Ravan was killed by Rama
Enter the number of parts (N): 3
The string is divided into 3 equal parts:
Ravan wa
s killed
 by Rama

Explanation:

The divideString function
- Determines the input string's length (len).
- Ensures len% n == 0 to determine whether it is possible to divide the string into equal sections.
- Returns an empty vector (parts) and shows an error message if it is not feasible.
- Determines the partSize of each component.
- Extracts each component of the string using a loop and substr.
- Each part is added to the parts vector.
- Returns a vector of parts that includes the separated sections.
main Function
- Use std::getline to read the complete input line.
- Obtains from the user the number of pieces (n).
- Divide the string into pieces by using the divideString function.
- Upon success, distinct lines are printed for the total number of equal parts and each portion.
return 0
- Returning 0 indicates that the program has run successfully.