Divide a string in N equal parts

Difficulty Level: Rookie
Question:
Write a program to print N equal parts of a given string. 

Solution:
1) Get the size of the string using string function strlen() (present in the string.h) 
2) Get the size of a part. 

part_size = string_length/n 

3) Loop through the input string. In loop, if index becomes multiple of part_size then put a part separator(“\n”)

Implementation:

C

// C program to divide a string
// in n equal parts
#include <stdio.h>
#include <string.h>

// Function to print n equal parts of str
void divideString(char* str, int n)
{
    int str_size = strlen(str);
    int i;
    int part_size;

    // Check if string can be divided in
    // n equal parts
    if (str_size % n != 0) {
        printf("Invalid Input: String size");
        printf(" is not divisible by n");
        return;
    }

    // Calculate the size of parts to
    // find the division points
    part_size = str_size / n;
    for (i = 0; i < str_size; i++) {
        if (i % part_size == 0)
            printf("\n");
        printf("%c", str[i]);
    }
}

int main()
{
    // length of string is 28
    char* str = "a_simple_divide_string_quest";

    // Print 4 equal parts of the string
    divideString(str, 4);

    getchar();
    return 0;
}

C++

// C++ program to divide a string
// in n equal parts
#include <iostream>
#include <string.h>

using namespace std;

class gfg {

    // Function to print n equal parts of str
public:
    void divideString(char str[], int n)
    {

        int str_size = strlen(str);
        int i;
        int part_size;

        // Check if string can be divided in
        // n equal parts
        if (str_size % n != 0) {
            cout << "Invalid Input: String size";
            cout << " is not divisible by n";
            return;
        }

        // Calculate the size of parts to
        // find the division points
        part_size = str_size / n;
        for (i = 0; i < str_size; i++) {
            if (i % part_size == 0)
                cout << endl;
            cout << str[i];
        }
    }
};

// Driver code
int main()
{
    gfg g;

    // length of string is 28
    char str[] = "a_simple_divide_string_quest";

    // Print 4 equal parts of the string
    g.divideString(str, 4);
    return 0;
}

// This code is contributed by SoM15242

Java

// Java program to divide a string
// in n equal parts

class GFG {
    // Method to print n equal parts of str
    static void divideString(String str, int n)
    {
        int str_size = str.length();
        int part_size;

        // Check if string can be divided in
        // n equal parts
        if (str_size % n != 0) {
            System.out.println("Invalid Input: String size"
                               + "is not divisible by n");
            return;
        }

        // Calculate the size of parts to find
        // the division points
        part_size = str_size / n;

        for (int i = 0; i < str_size; i++) {
            if (i % part_size == 0)
                System.out.println();
            System.out.print(str.charAt(i));
        }
    }

    // Driver Code
    public static void main(String[] args)
    {
        // length of string is 28
        String str = "a_simple_divide_string_quest";

        // Print 4 equal parts of the string
        divideString(str, 4);
    }
}

Python3

# Python program to print n equal parts of string

# Function to print n equal parts of string


def divideString(string, n):
    str_size = len(string)

    # Check if string can be divided in n equal parts
    if str_size % n != 0:
        print ("Invalid Input: String size is not divisible by n")
        return

    # Calculate the size of parts to find the division points
    part_size = str_size/n
    k = 0
    for i in string:
        if k % part_size == 0:
            print ()
        print (i,end='')
        k += 1


# Driver program to test the above function
# Length of string is 28
string = "a_simple_divide_string_quest"

# Print 4 equal parts of the string
divideString(string, 4)

# This code is contributed by Bhavya Jain

C#

// C# program to divide a string
// in n equal parts
using System;

class GFG {

    // Method to print n
    // equal parts of str
    static void divideString(String str, int n)
    {
        int str_size = str.Length;
        int part_size;

        // Check if string
        // can be divided in
        // n equal parts
        if (str_size % n != 0) {
            Console.Write("Invalid Input: String size"
                          + "is not divisible by n");
            return;
        }

        // Calculate the size
        // of parts to find
        // the division points
        part_size = str_size / n;

        for (int i = 0; i < str_size; i++) {
            if (i % part_size == 0)
                Console.WriteLine();
            Console.Write(str[i]);
        }
    }

    // Driver Code
    static void Main()
    {

        // length of string is 28
        String str = "a_simple_divide_string_quest";

        // Print 4 equal parts of the string
        divideString(str, 4);
    }
}

// This code is contributed by Anuj_67

PHP

<?php
// PHP program to divide a string
// in n equal parts

// Function to print n
// equal parts of str
function divideString($str, $n)
{
    $str_size = strlen($str);
    $i;
    $part_size;

// Check if string can be divided
// in n equal parts
if ($str_size % $n != 0)
{
    echo "Invalid Input: String size";
    echo " is not divisible by n";
    return;
}

// Calculate the size of parts to
// find the division point
$part_size = $str_size / $n;
for ($i = 0; $i< $str_size; $i++)
{
    if ($i % $part_size == 0)
        echo "\n";
    echo $str[$i];
}
}

    // Driver Code
    // length of string is 28
    $str = "a_simple_divide_string_quest";

    // Print 4 equal parts of the string
    divideString($str, 4);

// This code is contributed by ajit.
?>

Javascript

<script>
    // Javascript program to divide a string
    // in n equal parts

    // Method to print n
    // equal parts of str
    function divideString(str, n)
    {
        let str_size = str.length;
        let part_size;

        // Check if string
        // can be divided in
        // n equal parts
        if (str_size % n != 0)
        {
            document.write("Invalid Input: String size" +
                          "is not divisible by n");
            return;
        }

        // Calculate the size
        // of parts to find
        // the division points
        part_size = parseInt(str_size / n, 10);

        for (let i = 0; i< str_size; i++)
        {
            if(i % part_size == 0)
                document.write("</br>");
            document.write(str[i]);
        }
    }

    // length of string is 28
    let str = "a_simple_divide_string_quest";

    // Print 4 equal parts of the string
    divideString(str, 4);

    // This code is contributed by rameshtravel07
</script>

Output

a_simpl
e_divid
e_strin
g_quest

Time Complexity: O(n), where n is the length

C

#include <stdio.h>
#include <string.h>

void divide(char* str, int n)
{
    if (strlen(str) % n != 0) {
        printf("Invalid Input: String size is not "
               "divisible by n\n");
        return;
    }

    int parts = strlen(str) / n;
    int start = 0;

    while (start < strlen(str)) {
        char substr[parts + 1];
        strncpy(substr, str + start, parts);
        substr[parts] = '\0';
        printf("%s\n", substr);
        start += parts;
    }
}

int main()
{
    char str[] = "a_simple_divide_string_quest";
    divide(str, 4);
    return 0;
}

C++

#include <iostream>

using namespace std;

void divide(string str, int n)
{

    if (str.length() % n != 0) {
        cout << "Invalid Input: String size";
        cout << " is not divisible by n";
        return;
    }

    int parts = str.length() / n;
    int start = 0;

    while (start < str.length()) {
        cout << str.substr(start, parts) << endl;
        start += parts;
        // if(start < str.length()) cout << endl; to ignore
        // final new line
    }
}

int main()
{
    string str = "a_simple_divide_string_quest";
    divide(str, 4);
}

//Contributed By Jagadeesh

Java

import java.util.*;

class GFG {

    static void divide(String str, int n) {

        if (str.length() % n != 0) {
            System.out.print("Invalid Input: String size");
            System.out.print(" is not divisible by n");
            return;
        }

        int parts = str.length() / n;
        int start = 0;
        int t = parts;
        while (start < str.length()) {
            String temp = new String(str);

            System.out.print(temp.substring(start, parts) + "\n");
            start = parts;
            parts += t;
            // if(start < str.length()) System.out.println(); to ignore
            // final new line
        }
    }

  // Driver code
    public static void main(String[] args) {
        String str = "a_simple_divide_String_quest";
        divide(str, 4);
    }
}

// This code is contributed by umadevi9616

Python3

# Python code for the same approach
def divide(Str,n):

    if (len(Str) % n != 0):
        print("Invalid Input: String size",end="")
        print(" is not divisible by n")
        return

    parts = len(Str) // n
    start = 0

    while (start < len(Str)):
        print(Str[start: start + parts])
        start += parts
        # if(start < len(Str)) cout << endl; to ignore
        # final new line

# driver code
Str = "a_simple_divide_string_quest"
divide(Str, 4)

# This code is contributed By shinjanpatra

C#

// C# program to divide a string
// in n equal parts
using System;

public class GFG {
  public static void divide(String str, int n)
  {

    // Check if string
    // can be divided in
    // n equal parts
    if (str.Length % n != 0) {
      Console.Write("Invalid Input: String size");
      Console.Write(" is not divisible by n");
      return;
    }
    // Calculate the size
    // of parts to find
    // the division points
    var parts = (int)(str.Length / n);
    var start = 0;
    var t = parts;
    while (start < str.Length) {
      var temp = new String(str);
      Console.Write(
        temp.Substring(start, parts - start)
        + "\n");
      start = parts;
      parts += t;
    }
  }
  // Driver code
  public static void Main(String[] args)
  {
    var str = "a_simple_divide_String_quest";
    divide(str, 4);
  }
}

// This code is contributed by Aarti_Rathi

Javascript

<script>

function divide(str,n)
{

    if (str.length % n != 0) {
        document.write("Invalid Input: String size");
        document.write(" is not divisible by n");
        return;
    }

    let parts = Math.floor(str.length / n);
    let start = 0;

    while (start < str.length) {
        document.write(str.substring(start, start+parts),"</br>");
        start += parts;

        // if(start < str.length()) cout << endl; to ignore
        // final new line
    }
}

// driver code
let str = "a_simple_divide_string_quest";
divide(str, 4);

// This code is contributed By shinjanpatra

</script>

 of string.

Auxiliary Space: O(1).

In the above solution, n equal parts of the string are only printed. If we want individual parts to be stored, we need to allocate part_size + 1 memory for all N parts (1 extra for string termination character ‘\0’) and store the addresses of the parts in an array of character pointers. 

Another Approach: Using STL in C++
Implemention:

Output

a_simpl
e_divid
e_strin
g_quest

Time Complexity: O(n), where n is the length of string.

Auxiliary Space: O(n), because when string is passed to the function it creates a copy of itself (passing by value).

Plein case write comments if you find anything incorrect, or you want to share more information about the topic discussed above.