URLifique una string dada (reemplace los espacios con% 20)

 Escriba un método para reemplazar todos los espacios en una string con ‘%20’. Puede suponer que la string tiene suficiente espacio al final para contener los caracteres adicionales y que se le da la longitud «verdadera» de la string.
Ejemplos: 

Input: "Mr John Smith", 13
Output: Mr%20John%20Smith

Input: "Mr John Smith   ", 13
Output: Mr%20John%20Smith

Una solución simple es crear una string auxiliar y copiar los caracteres uno por uno. Siempre que encuentre espacio, coloque %20 en su lugar.

Una mejor solución para hacerlo en el lugar suponiendo que tenemos espacio adicional en la string de entrada. Primero contamos el número de espacios en la string de entrada. Usando este conteo, podemos encontrar la longitud de la string modificada (o resultado). Después de calcular la nueva longitud, llenamos la string en el lugar desde el final. 

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

C++

// C++ program to replace spaces with %20
#include<stdio.h>
 
// Maximum length of string after modifications.
const int MAX = 1000;
 
// Replaces spaces with %20 in-place and returns
// new length of modified string. It returns -1
// if modified string cannot be stored in str[]
int replaceSpaces(char str[])
{
    // count spaces and find current length
    int space_count = 0, i;
    for (i = 0; str[i]; i++)
        if (str[i] == ' ')
            space_count++;
 
    // Remove trailing spaces
    while (str[i-1] == ' ')
    {
       space_count--;
       i--;
    }
 
    // Find new length.
    int new_length = i + space_count * 2 + 1;
 
    // New length must be smaller than length
    // of string provided.
    if (new_length > MAX)
        return -1;
 
    // Start filling character from end
    int index = new_length - 1;
 
    // Fill string termination.
    str[index--] = '\0';
 
    // Fill rest of the string from end
    for (int j=i-1; j>=0; j--)
    {
        // inserts %20 in place of space
        if (str[j] == ' ')
        {
            str[index] = '0';
            str[index - 1] = '2';
            str[index - 2] = '%';
            index = index - 3;
        }
        else
        {
            str[index] = str[j];
            index--;
        }
    }
 
    return new_length;
}
 
// Driver code
int main()
{
    char str[MAX] = "Mr John Smith   ";
 
    // Prints the replaced string
    int new_length = replaceSpaces(str);
    for (int i=0; i<new_length; i++)
        printf("%c", str[i]);
    return 0;
}

Java

// Java program to replace spaces with %20
class GFG
{
 
    // Maximum length of string
    // after modifications.
    static int MAX = 1000;
 
    // Replaces spaces with %20 in-place
    // and returns new length of modified string.
    // It returns -1 if modified string
    // cannot be stored in str[]
    static char[] replaceSpaces(char[] str)
    {
 
        // count spaces and find current length
        int space_count = 0, i = 0;
        for (i = 0; i < str.length; i++)
            if (str[i] == ' ')
                space_count++;
 
        // count spaces and find current length
        while (str[i - 1] == ' ')
        {
            space_count--;
            i--;
        }
 
        // Find new length.
        int new_length = i + space_count * 2;
 
        // New length must be smaller than length
        // of string provided.
        if (new_length > MAX)
            return str;
 
        // Start filling character from end
        int index = new_length - 1;
 
        char[] old_str = str;
        str = new char[new_length];
 
        // Fill rest of the string from end
        for (int j = i - 1; j >= 0; j--)
        {
 
            // inserts %20 in place of space
            if (old_str[j] == ' ')
            {
                str[index] = '0';
                str[index - 1] = '2';
                str[index - 2] = '%';
                index = index - 3;
            }
             
            else
            {
                str[index] = old_str[j];
                index--;
            }
        }
        return str;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        char[] str = "Mr John Smith ".toCharArray();
 
        // Prints the replaced string
        str = replaceSpaces(str);
 
        for (int i = 0; i < str.length; i++)
            System.out.print(str[i]);
    }
}
 
// This code is contributed by
// sanjeev2552

Python3

# Maximum length of string after modifications.
MAX = 1000;
 
# Replaces spaces with %20 in-place and returns
# new length of modified string. It returns -1
# if modified string cannot be stored in str[]
def replaceSpaces(string):
     
    # Remove remove leading and trailing spaces
    string = string.strip()
 
    i = len(string)
 
    # count spaces and find current length
    space_count = string.count(' ')
 
    # Find new length.
    new_length = i + space_count * 2
 
    # New length must be smaller than length
    # of string provided.
    if new_length > MAX:
        return -1
 
    # Start filling character from end
    index = new_length - 1
 
    string = list(string)
 
    # Fill string array
    for f in range(i - 2, new_length - 2):
        string.append('0')
 
    # Fill rest of the string from end
    for j in range(i - 1, 0, -1):
 
        # inserts %20 in place of space
        if string[j] == ' ':
            string[index] = '0'
            string[index - 1] = '2'
            string[index - 2] = '%'
            index = index - 3
        else:
            string[index] = string[j]
            index -= 1
 
    return ''.join(string)
 
# Driver Code
if __name__ == '__main__':
    s = "Mr John Smith "
    s = replaceSpaces(s)
    print(s)
 
# This code is contributed by Vinayak

C#

// C# program to replace spaces with %20
using System;
 
class GFG
{
 
    // Maximum length of string
    // after modifications.
    static int MAX = 1000;
 
    // Replaces spaces with %20 in-place
    // and returns new length of modified string.
    // It returns -1 if modified string
    // cannot be stored in []str
    static char[] replaceSpaces(char[] str)
    {
 
        // count spaces and find current length
        int space_count = 0, i = 0;
        for (i = 0; i < str.Length; i++)
            if (str[i] == ' ')
                space_count++;
 
        // count spaces and find current length
        while (str[i - 1] == ' ')
        {
            space_count--;
            i--;
        }
 
        // Find new length.
        int new_length = i + space_count * 2;
 
        // New length must be smaller than
        // length of string provided.
        if (new_length > MAX)
            return str;
 
        // Start filling character from end
        int index = new_length - 1;
 
        char[] new_str = str;
        str = new char[new_length];
 
        // Fill rest of the string from end
        for (int j = i - 1; j >= 0; j--)
        {
 
            // inserts %20 in place of space
            if (new_str[j] == ' ')
            {
                str[index] = '0';
                str[index - 1] = '2';
                str[index - 2] = '%';
                index = index - 3;
            }
            else
            {
                str[index] = new_str[j];
                index--;
            }
        }
        return str;
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
        char[] str = "Mr John Smith ".ToCharArray();
 
        // Prints the replaced string
        str = replaceSpaces(str);
 
        for (int i = 0; i < str.Length; i++)
            Console.Write(str[i]);
    }
}
 
// This code is contributed by 29AjayKumar

Producción: 

Mr%20John%20Smith

Complejidad de tiempo: O(n), donde n es la verdadera longitud de la string. 
Espacio auxiliar: O(1), porque el programa anterior es un algoritmo in situ .

Enfoque 2:  recorte la string y llame al método replaceAll() para reemplazar todo el espacio Unicode a %20. 

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

Java

// Java implementation of above approach
class GFG
{
    public static void main(String[] args)
    {
        // Instantiate the string
        String str = "Mr John Smith   ";
         
        // Trim the given string
        str = str.trim();
         
        // Replace All space (unicode is \\s) to %20
        str = str.replaceAll("\\s", "%20");
         
        // Display the result
        System.out.println(str);
    }
}

Python3

# Python3 implementation of above approach
 
# Instantiate the string
s = "Mr John Smith "
 
# Trim the given string
s = s.strip()
 
# Replace All space (unicode is \\s) to %20
s = s.replace(' ', "%20")
 
# Display the result
print(s)
 
# This code is contributed by vinayak

C#

// C# implementation of above approach
using System;
     
class GFG
{
    public static void Main()
    {
        // Instantiate the string
        String str = "Mr John Smith   ";
          
        // Trim the given string
        str = str.Trim();
          
        // Replace All space (unicode is \\s) to %20
        str = str.Replace(" ", "%20");
          
        // Display the result
        Console.Write(str);
    }
}
 
// This code is contributed by Rajput-Ji

Javascript

<script>
 
      // JavaScript implementation of above approach
       
      // Instantiate the string
      var str = "Mr John Smith ";
 
      // Trim the given string
      str = str.trim();
 
      // Replace All space (unicode is \\s) to %20
      str = str.replaceAll(" ", "%20");
 
      // Display the result
      document.write(str);
       
</script>
Producción

Mr%20John%20Smith

Complejidad temporal: O(N) donde N es la longitud de la string.

Complejidad del espacio auxiliar: O(1). 

Enfoque 3: usando la función string.replace() :

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

C++

#include <bits/stdc++.h>
using namespace std;
 
void replaceSpaces(string input)
{
    string rep = "%20";
    for(int i=0 ; i<input.length() ; i++)
    {
        if(input[i] == ' ')
            input.replace(i,1,rep);
    }
    cout<<input;
}
 
int main()
{
    string input = "Mr John Smith";
    replaceSpaces(input);
 
    return 0;
}

Python3

#Python code for the same approach
def replaceSpaces(input):
    rep = "%20"
    for i in range(len(input)):
        if(input[i] == ' '):
            input = input.replace(input[i],rep)
    print(input)
 
# driver code
input = "Mr John Smith"
replaceSpaces(input)
 
# This code is contributed by shinjanpatra

Javascript

<script>
 
// JavaScript code for the approach
function replaceSpaces(input)
{
    let rep = "%20"
    for(let i=0 ; i<input.length ; i++)
    {
        if(input[i] == ' ')
            input = input.replace(input[i],rep);
    }
    document.write(input);
}
 
// driver code
let input = "Mr John Smith"
replaceSpaces(input)
 
// This code is contributed by shinjanpatra
 
</script>
Producción

Mr%20John%20Smith

Complejidad temporal: O(N) donde N es la longitud de la string.
Complejidad del espacio auxiliar: O(1). 

Este artículo es una contribución de Aarti_Rathi y Brahmani Sai . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.

Publicación traducida automáticamente

Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *