Cómo rehacer un string en zigzag

Aprende a convertir strings en patrones en zigzag con este tutorial paso a paso. Perfecto para quienes quieren mejorar sus habilidades en algoritmos y estructuras de datos. ¡Resuelve este clásico problema de programación con Java y C!

El objetivo del problema es escribir un algoritmo que tome una cadena y el número de filas y devuelva la cadena reorganizada en un patrón zigzag a través de las filas

           

Mejora tus habilidades en programación con nuestro video sobre el ejercicio de conversión en zigzag. Explora diferentes soluciones y aprende a optimizar tu código para este desafío de LeetCode. Ideal para programadores de todos los niveles, desde principiantes hasta expertos.

¿Quieres resolver problemas de programación más complejos? Dominar la conversión en zigzag es clave. En este video, te mostraremos diferentes enfoques para resolver este desafío de LeetCode y mejorar tus habilidades en algoritmos y estructuras de datos.



Aquí, las letras se escriben en un patrón zigzag a través de las tres filas.

¿Quieres resolver problemas de programación más complejos? Dominar la conversión en zigzag es clave. En este video, te mostraremos diferentes enfoques para resolver este desafío de LeetCode y mejorar tus habilidades en algoritmos y estructuras de datos.

¿Quieres aprender a convertir strings en patrones en zigzag? ¡Este tutorial de programación en Java y C te enseñará cómo! #EjercicioDeStrings2 #ConversiónEnZigzag #LeetCode #algoritmos #estructurasDeDatos #programación

✅ Pasos para realizar el ejercicio:
1.- Se crea un array llamado posiciones, con un tamaño igual al tamaño del total de filas, y se llena con valores vacíos (‘’). Este array será utilizado para guardar las palabras reorganizadas construidas en el ejercicio por posición.

2.- Se obtiene el tamaño del string s y se inicializa la variable fila actual  en 0 y la variable dirección en 1.

La variable fila actual será la encargada se concatenar la letra a la posición de fila correspondiente del array posiciones

Y la variable dirección es la encargada de determinar si subimos o bajamos en el recorrido del zigzag del array posiciones.

3.- Se inicia el recorrido desde la posición i hasta que llegue al final del string s.

4.- Se agrega la letra actual de s a la posición correspondiente en el array posiciones, utilizando la variable fila actual como índice.

5.- Se verifica si la variable fila actual es igual a 0, o al total de filas-1.

5.1.- Si es igual a 0, se establece la variable dirección en 1.
        
5.2.- Si es igual al total de filas-1, se establece la variable dirección en -1.

6.- Se actualiza el valor de la fila actual sumándole el valor de dirección. Esto permite que la siguiente iteración del ciclo agregue el próximo carácter en la fila correspondiente.

7.- Se devuelve el string que se obtiene al unir todos los elementos del array posiciones. 
               

Código en Java

public class Solution {
                 
                    /**
                     * @param String s
                     * @param Integer totalFilas
                     * @return String
                     */
                     public String convert(String s, int totalFilas) {
                        if(totalFilas==1) return s;
                 
                        // paso#1
                        String[] posiciones = new String[totalFilas];
                        Arrays.fill(posiciones, "");
                 
                        // paso#2
                        int size = s.length();
                        int direccion = 1;
                        int filaActual = 0;
                 
                        // paso#3
                        for (int i = 0; i < size; i++) {       
                            // paso#4
                            posiciones[filaActual] += s.charAt(i);
                 
                            // paso#5
                            if (filaActual == 0) direccion = 1;
                            else if (filaActual == totalFilas-1) direccion = -1;
                 
                            // paso#6
                            filaActual += direccion;
                        }
                 
                        // paso#7
                        return String.join("", posiciones);
                    }
                }

Código en C++

class Solution {
public:
  std::string convert(const std::string& s, int totalFilas) {
    if (totalFilas == 1) {
      return s;
    }

    // Paso #1
    std::vector<std::string> posiciones(totalFilas);
    for (auto& posicion : posiciones) {
      posicion = "";
    }

    // Paso #2
    int size = s.length();
    int direccion = 1;
    int filaActual = 0;

    // Paso #3
    for (int i = 0; i < size; i++) {
      // Paso #4
      posiciones[filaActual] += s[i];

      // Paso #5
      if (filaActual == 0) {
        direccion = 1;
      } else if (filaActual == totalFilas - 1) {
        direccion = -1;
      }

      // Paso #6
      filaActual += direccion;
    }

    // Paso #7
    std::string resultado;
    for (const auto& posicion : posiciones) {
      resultado += posicion;
    }
    return resultado;
  }
};

Código en php

class Solution {
 
    /**
     * @param String $s
     * @param Integer $totalFilas
     * @return String
     */
     function convert($s, $totalFilas) {
 
        //paso#1
        $posiciones=array_fill(0, $totalFilas, '');
 
        //paso#2
        $size=strlen($s);
        $direccion=1;
        $filaActual=0;
 
 
        //paso#3
        for ($i=0; $i<$size; $i++) {
            //paso#4
            $posiciones[$filaActual].=$s[$i];
 
            //paso#5
            if ($filaActual == 0)              $direccion = 1;
            elseif ($filaActual == $totalFilas-1) $direccion = -1;
 
            //paso#6
            $filaActual += $direccion;
        }
 
        //paso#7
        return implode('', $posiciones);
    }
}
 

Código en Python

class Solution:
     
        def convert(self, s, total_filas):
            if total_filas == 1:
                return s
     
            # Paso #1
            posiciones = [""] * total_filas
     
            # Paso #2
            size = len(s)
            direccion = 1
            fila_actual = 0
     
            # Paso #3
            for i in range(size):
                # Paso #4
                posiciones[fila_actual] += s[i]
     
     
                # Paso #5
                if fila_actual == 0:
                    direccion = 1
                elif fila_actual == (total_filas - 1):
                    direccion = -1
     
                # Paso #6
                fila_actual += direccion
     
            # Paso #7
            return "".join(posiciones)