Calcular la longitud de la última palabra de un string

En este blog, te enseñaré cómo resolver el ejercicio Calcular la longitud de la última palabra de un string en Java, Python, PHP, C++ y JavaScript.

En este artículo, vamos a ver lo siguiente:

✅ Una explicación del problema
✅ Una solución eficiente
✅ Implementaciones en Java, Python, PHP, C++ y JavaScript


                       

Hay que determinar la longitud de la última palabra en una cadena de texto.



¡Aprende a invertir las palabras de un string en tus lenguajes de programación favoritos!  En este tutorial, te guiaremos paso a paso a través de soluciones en C++, Python, Java, JavaScript y PHP. ¡Perfecto para principiantes y programadores intermedios!

Pasos para realizar el algoritmo:
1.- Se utiliza el método trim() para eliminar los espacios en blanco del principio y del final del string.

2.- Se declara la variable tamaño y se le asigna la cantidad de caracteres - 1, ya que siempre se recorren los strings desde la posición 0.

3.- Se recorre el string desde el final hasta el inicio. En cada paso del recorrido se verifica si el carácter evaluado es un espacio en blanco. Si lo es, el bucle se detiene (break).

4.- La longitud de la última palabra es la diferencia entre el valor de i y la variable tamaño.

¿Quieres aprender a calcular la longitud de la última palabra en un string? En este tutorial, te enseñaremos cómo hacerlo en C++, Java, Python, PHP y JavaScript. ¡Perfecto para principiantes y programadores intermedios!

Código en Java

class Solution {
    public int lengthOfLastWord(String s) {
        //paso#1
        s =  s.trim();

        //paso#2
        int tamano = s.length()-1;

        //paso#3
        int i;
        for(i=tamano;i>=0;i--) 
            if(s.charAt(i) == ' ') break;  

        //paso#4
        return (tamano-i);
    }
 }

Código en C++

class Solution {
public:
  int lengthOfLastWord(string s) {
    int tamano = s.length() - 1;
    while(s[tamano] == ' ')tamano--;
    int i;
    for (i = tamano; i >= 0; i--) {
        if (s[i] == ' ') break;
    }
    return (tamano - i);
  }
};

Código en PHP

class Solution {
    /**
     * @param String $s
     * @return Integer
     */
    public function lengthOfLastWord($s) {
        //paso#1
        $s = trim($s);

        //paso#2
        $tamano = strlen($s) - 1;

        //paso#3
        for ($i = $tamano; $i >= 0; $i--) {
            if ($s[$i] === ' ') {
                break;
            }
        }

        //paso#4
        return $tamano - $i;
    }

}

Código en Python

class Solution(object):
    def lengthOfLastWord(self, s):
        # Paso #1: Eliminar espacios en blanco al principio y al final
        s = s.strip()

        # Paso #2: Obtener la longitud de la cadena sin espacios
        tamano = len(s) - 1

        # Paso #3: Recorrer la cadena desde el final hasta encontrar un espacio
        i = tamano
        while i >= 0 and s[i] != ' ':
            i -= 1

        # Paso #4: Retornar la diferencia entre la longitud de la cadena sin espacios y el índice del primer espacio
        return tamano - i
        

Código en JavaScript

/**
 * @param {string} s
 * @return {number}
 */
var lengthOfLastWord = function(s) {
      //paso#1
    s = s.trim();

    //paso#2
    const length = s.length - 1;

    //paso#3
    let i;
    for (i = length; i >= 0; i--) {
      if (s.charAt(i) === " ") {
        break;
      }
    }

    //paso#4
    return length - i;
};

        
    
Conclusión
En este blog, hemos visto cómo realizar el ejercicio Calcular la longitud de la última palabra de un string en Java, Python, PHP, C++ y JavaScript.

Hemos visto ejemplos de código en cada lenguaje de programación.