Subsegmentos contiguos de una string que tiene distintos caracteres posteriores

Dada la string str de longitud L y un número entero N , la tarea es formar un total de (L / N) subsegmentos contiguos de la string que contienen distintos caracteres posteriores. 
Nota: que el número entero N será un factor de la longitud de la string, es decir , L .

Ejemplos: 

Entrada: str = “geeksforgeeksgfg”, N = 4 
Salida: 
gek 
sfor 
gek 
sgf 
La longitud de “geeksforgeeksgfg” es 16, por lo que habrá 4 subsegmentos. 
El primer subsegmento contendrá los caracteres g, e, e y k pero el alfabeto ‘e’ se repite, 
así que descartamos una ‘e’. Por lo tanto, el subsegmento final será «gek». 
Asimismo, los otros tres subsegmentos serán “sfor”, “gek” y “sgf”. 
Cada subsegmento debe tener caracteres distintos posteriores.

Entrada: str = “aabdekfgf”, N = 3 
Salida: 
ab 
dek
fg 

Enfoque: se crea una array cada vez que se inicia la iteración sobre el nuevo subsegmento. Esos elementos se almacenan en una secuencia en esa array. Si algún elemento ya existe en la array, entonces no se inserta en la array.
A continuación se muestra la implementación del enfoque anterior: 

// C++ implementation of the approach
#include<bits/stdc++.h>
using namespace std;
 
// Function that prints the segments
void sub_segments(string str, int n)
{
    int l = str.length();
    for (int x = 0; x < l; x += n)
    {
        string newlist = str.substr(x, n);
         
        // New array for every iteration
        list<char> arr;
 
        // Iterator for new array
        list<char>::iterator it;
 
        for(auto y:newlist)
        {
            it = find(arr.begin(), arr.end(), y);
             
            // Check if iterator points to end or not
            if(it == arr.end())
                arr.push_back(y);
        }
 
        for(auto y:arr)
            cout << y;
        cout << endl;
    }
}
 
// Driver code
int main()
{
    string str = "geeksforgeeksgfg";
    int n = 4;
    sub_segments(str, n);
}
 
// This code is contributed by Sanjit_Prasad

// Java implementation of the approach
import java.util.*;
 
class GFG
{
 
// Function that prints the segments
static void sub_segments(String str, int n)
{
    int l = str.length();
    for (int x = 0; x < l; x += n)
    {
        String newlist = str.substring(x, x + n);
 
        // New array for every iteration
        List<Character> arr = new ArrayList<Character>();
        for (char y : newlist.toCharArray())
        {
 
            // Check if the character is in the array
            if (!arr.contains(y))
                arr.add(y);
        }
        for (char y : arr)
            System.out.print(y);
        System.out.println();
    }
}
 
// Driver code
public static void main(String[] args)
{
    String str = "geeksforgeeksgfg";
    int n = 4;
    sub_segments(str, n);
}
}
 
// This code is contributed by Rajput-Ji

# Python3 implementation of the approach
 
# Function that prints the segments
def sub_segments (string, n):
    l = len (string)
    for x in range (0, l, n):
        newlist = string[x : x + n]
 
        # New array for every iteration
        arr = []
        for y in newlist:
 
           # Check if the character is in the array
            if y not in arr:
                arr.append (y)
        
        print (''.join (arr))
 
# Driver code
string = "geeksforgeeksgfg"
n = 4
sub_segments (string, n)

// C# implementation of the approach
using System;
using System.Collections.Generic;
 
class GFG
{
 
// Function that prints the segments
static void sub_segments(String str, int n)
{
    int l = str.Length;
    for (int x = 0; x < l; x += n)
    {
        String newlist = str.Substring(x, n);
 
        // New array for every iteration
        List<char> arr = new List<char>();
        foreach (char y in newlist.ToCharArray())
        {
 
            // Check if the character is in the array
            if (!arr.Contains(y))
                arr.Add(y);
        }
        foreach (char y in arr)
            Console.Write(y);
        Console.WriteLine();
    }
}
 
// Driver code
public static void Main(String[] args)
{
    String str = "geeksforgeeksgfg";
    int n = 4;
    sub_segments(str, n);
}
}
 
// This code is contributed by Rajput-Ji

<script>
// Javascript implementation of the approach
 
 
// Function that prints the segments
function sub_segments(str, n) {
    let l = str.length;
    for (let x = 0; x < l; x += n) {
        let newlist = str.substr(x, n);
 
        // New array for every iteration
        let arr = [];
 
        for (let y of newlist) {
 
            // Check if the character is in the array
            if (!arr.includes(y))
                arr.push(y);
        }
        for (let y of arr)
            document.write(y);
        document.write("<br>");
    }
}
 
// Driver code
 
let str = "geeksforgeeksgfg";
let n = 4;
sub_segments(str, n);
 
// This code is contributed by gfgking
 
</script>

gek
sfor
gek
sgf