Imprima todas las subcadenas de longitud n posibles de la cadena dada

Dada una cadena calle y un entero nortees la tarea de imprimir todas las subsecuencias posibles de longitud N.

Ejemplos:

Aporte: str = «geeksforgeeks», N = 3
Salida: gee eek eks ksf sfo para org rge gee eek eks
Explicación: Todas las subcadenas posibles de longitud 3 son «gee», «eek», «eks», «ksf», «sfo», «for», «org», «rge», «gee», «eek» y «eks » .

Aporte: cadena = «GFG», N = 2
Salida: GF FG
Explicación: Todas las subcadenas posibles de longitud 2 son «GF», «FG»

Método 1: Usando el corte

Acercarse: Siga los pasos a continuación para resolver el problema:

• Inicialice una variable ‘n’ a la longitud deseada de las subcadenas.
• Use un bucle for para iterar a través de los caracteres de la cadena original, comenzando con el primer carácter.
• En cada iteración del ciclo, utilice el corte para extraer una subcadena de longitud ‘n’ de la cadena original, comenzando en el carácter actual. El corte se puede hacer usando la sintaxis de ‘cadena'[start:end]’ donde el inicio y el final son los índices del primer y último carácter de la subcadena, respectivamente.
• En cada iteración, la variable ‘i’ es el índice de inicio de la subcadena, y ‘i + n’ es el índice final de la subcadena, por lo que la subcadena se puede extraer usando la sintaxis de corte ‘cadena[i: i + n]’.
• Imprima o guarde la subcadena extraída para su posterior procesamiento.
• Repita el proceso para todos los caracteres de la cadena original.

A continuación se muestra la implementación del enfoque anterior:

// CPP implementation of the approach
#include <iostream>
#include <string.h>
using namespace std;

// Drivers code
int main()
{
    string str = "geeksforgeeks";
    int n = 3;
    for (int i = 0; i < str.length() - n + 1; i++)
        cout << str.substr(i, n) << " ";
    return 0;
}

// Java implementation of the approach
import java.util.*;

class GFG {
    public static void main(String args[])
    {
        String str = "geeksforgeeks";
        int n = 3;
        for (int i = 0; i < str.length() - n + 1; i++)
            System.out.print(str.substring(i, i + n) + " ");
    }
}
// This code is contributed by Susobhan Akhuli

# Python implementation of the approach
str = "geeksforgeeks"
n = 3

for i in range(len(str) - n + 1):
    print(str[i:i + n], end = " ")

# This code is contributed by Susobhan Akhuli

// C# implementation of the approach
using System;

class MainClass {
    public static void Main(string[] args)
    {
        string str = "geeksforgeeks";
        int n = 3;
        for (int i = 0; i < str.Length - n + 1; i++)
            Console.Write(str.Substring(i, n) + " ");
    }
}

// This code is contributed by Susobhan Akhuli

<script>
// JavaScript implementation of the approach
let str = "geeksforgeeks";
let n = 3;
for (let i = 0; i < str.length - n + 1; i++) {
    let substring = str.substring(i, i+n);
    document.write(substring+" ");
}

//  This code is contributed by Susobhan Akhuli
</script>

gee eek eks ksf sfo for org rge gee eek eks 

Complejidad del tiempo: O(|cadena|*n), donde |cadena| es la longitud de la cadena
cuarto auxiliar: En)

Método 2: usar un bucle for

Acercarse: Siga los pasos a continuación para resolver el problema:

• Inicializar una variable ‘norte‘ a la longitud deseada de las subcadenas.
• Use un bucle for para iterar a través de los caracteres de la cadena original, comenzando con el primer carácter.
• En cada iteración del ciclo externo, inicialice una variable vacía ‘subcadena‘ para guardar la subcadena extraída.
• Use un bucle for anidado para iterar a través de los siguientes «n» caracteres de la cadena original, comenzando en el carácter actual.
• En cada iteración del ciclo interno, agregue el carácter actual a la variable ‘subcadena’.
• Una vez que se completa el bucle interno, imprima o guarde la subcadena extraída para su posterior procesamiento.
• Repita el proceso para todos los caracteres de la cadena original.

A continuación se muestra la implementación del enfoque anterior:

// CPP implementation of the approach
#include <iostream>
#include <string.h>
using namespace std;

int main()
{
    string str = "geeksforgeeks";
    int n = 3;
    for (int i = 0; i < str.length() - n + 1; i++) {
        string substring = "";
        for (int j = i; j < i + n; j++)
            substring += str[j];
        cout << substring << " ";
    }
    return 0;
}
// This code is contributed by Susobhan Akhuli

// Java implementation of the approach
import java.util.*;

public class GFG {
    public static void main(String[] args)
    {
        String str = "geeksforgeeks";
        int n = 3;
        for (int i = 0; i < str.length() - n + 1; i++) {
            String substring = "";
            for (int j = i; j < i + n; j++)
                substring += str.charAt(j);
            System.out.print(substring + " ");
        }
    }
}

// This code is contributed by Susobhan Akhuli

# Python implementation of the approach
str = "geeksforgeeks"
n = 3

for i in range(len(str) - n + 1):
    substring = ""
    for j in range(i, i + n):
        substring += str[j]
    print(substring, end =' ')

# This code is contributed by Susobhan Akhuli

// C# implementation of the approach
using System;

class Program {
    static void Main(string[] args)
    {
        string str = "geeksforgeeks";
        int n = 3;
        for (int i = 0; i < str.Length - n + 1; i++) {
            string substring = "";
            for (int j = i; j < i + n; j++)
                substring += str[j];
            Console.Write(substring + " ");
        }
    }
}

// This code is contributed by Susobhan Akhuli

<script>
// JavaScript implementation of the approach
var str = "geeksforgeeks";
var n = 3;
for (let i = 0; i < str.length - n + 1; i++) {
    var substring = str[i];
    for (let j = i+1; j < i + n; j++)
        substring += str[j];
    document.write(substring + " ");
}

//  This code is contributed by Susobhan Akhuli
</script>

gee eek eks ksf sfo for org rge gee eek eks 

Complejidad del tiempo: O(|cadena|*n), donde |cadena| es la longitud de la cadena
cuarto auxiliar: En)

Método 3: Uso de la comprensión de listas (solo Python)

Acercarse: Siga los pasos a continuación para resolver el problema:

• Inicialice una variable ‘n’ a la longitud deseada de las subcadenas.
• Use una lista de comprensión para iterar a través de los caracteres de la cadena original y extraer subcadenas de longitud ‘n’ en una sola línea.
• La lista de comprensión utiliza la sintaxis de corte ‘cadena[start:end]’ donde el inicio y el final son los índices del primer y último carácter de la subcadena, respectivamente.
• La variable ‘i’ es el índice de inicio de la subcadena y ‘i+n’ es el índice final de la subcadena, por lo que la subcadena se puede extraer usando la sintaxis de corte ‘cadena[i:i+n]’ en la lista de comprensión.
• Asigne la salida de la lista de comprensión a una variable, por ejemplo, subcadenas = [string[i:i+n] for i in range(len(cadena) – n + 1)]
• A continuación, puede imprimir o acceder a subcadenas individuales de la lista a través de la indexación.

A continuación se muestra la implementación del enfoque anterior:

# Python implementation of the approach
str = "geeksforgeeks"
n = 3
substrings = [str[i:i + n] for i in range(len(str) - n + 1)]
print(substrings)

# This code is contributed by Susobhan Akhuli

['gee', 'eek', 'eks', 'ksf', 'sfo', 'for', 'org', 'rge', 'gee', 'eek', 'eks']

Complejidad del tiempo: O(|cadena|*n), donde |cadena| es la longitud de la cadena
cuarto auxiliar: O(|cadena|*n)

NÓTESE BIEN: Es importante tener en cuenta que el enfoque anterior solo funciona si la longitud de la cadena es mayor que n; de lo contrario, el índice estará fuera de rango.