Manejo de cadenas de caracteres

Para ser un “Curso Básico de Algoritmos” no veía la necesidad al inicio de implementar los algoritmos en algún lenguaje, debido a que se puede (y se debería) hacer todo un curso completo de introducción a los algoritmos sin necesidad de tocar código, pero bueno imagino que su fin pedagógico tendrá. Sin embargo, ya tocar dos lenguajes en un curso introductorio me parece muy inadecuado, hay muchos alumnos que aún no saben programar y por eso precisamente están iniciando con Algoritmos como para complicarles más el aprendizaje. Algunas personas dirán que el lenguaje no importa, bueno es verdad, no importa para alguien que ya sabe programar, pero para los que no, si importa.

La función StringReverse en JavaScript 😎:

PD hice el ejercicio solito pero dejo el link con la explicación larga y super comentada 😌😬.

• Three Ways to Reverse a String in JavaScript

1. Método JavaScript es ❤️:

function reverseString(str) {
	var strToArray = str.split(""); // cada letra es una posición
	var reverseArr = str.reverse(); // JAJAJAJA
	var arrayToStr = str.join("");

	return arrayToStr;
}

reverseString("Algoritmos"); // "somtiroglA"

1. Recursividad 🔂:

function reverseString(str) {
	if (!str.length) { // `str.isEmpty()` no existe :(
		return str;
	}

	var strFirstPos - str.charAt(0);
	var strWithoutFirstPos = str.substr(1); // substring

	return reverseString(strWithoutFirstPos) + strFirstPos;
}

reverseString("Algoritmos"); // "somtiroglA"

1. Ciclos 🔁:

function reverseString(originalStr) {
	var reversedStr = "";

	for (var i = originalStr.length - 1; i >= 0; i--) {
		reversedStr = reversedStr + originalStr[i];
	}

	return reversedStr;
}

reverseString("Algoritmos"); // "somtiroglA"

Si no sé nada de Java se me hace imposible entender algo de esta clase.

Un poco más difícil sobre todo si veníamos utilizando C y de pronto nos cambia a Java, creo que no había necesidad.

Python

def reverseString(string):
    if string == "":
        return string
    else:
        return reverseString(string[1:]) + string[0]

No me gusta cómo explica Ricardo Celis, lo que hace el método substring no es devolverte el índice del String, sino devolverte el String desde el índice que tenga como parámetro. Ejemplo:
String hi = “Hello”;
System.out.println(hi.substring(1)); //devuelve ello
System.out.println(hi.substring(3)); //devuelve lo

No es recursividad, pero Python hace esto súper fácil 😅 con sólo una instrucción:

def reverse_string(string):
    return string[::-1]

y con recursividad sería de esta manera:

def reverse_string2(string):
    if not string:
        return string
    return reverse_string2(string[1:]) + string[0]

Esta clase asume que uno ya tiene conocimientos un poco más avanzados. No me gusto ni 5.

Kotlin:

fun main(args: Array<String>) {
    val str = "Cuando Reguilón es titular en La Liga: 12 victorias y 1 derrota."
    println(str.reverseString())
}

fun String.reverseString():String{
    return if(this.isEmpty()){
        this
    }
    else{
        this.substring(1).reverseString() + this[0]
    }
}

Seria interesante y una ventaja para nosotros los estudiantes, si Platzi introduce a los cursos una clase de pre-requisito para hacer los cursos, por ejemplo, el curso básico de algoritmos he visto que necesita tres cursos antes de iniciar este:

• Curso de Pensamiento Lógico

• Curso de Introducción a Lenguaje C

• Curso de Programación Orientada a Objetos

Mala idea eso de cambiar el lenguaje, complica las cosas inecesariamente. 👎

Yo nunca he programado nada de Java, y esto se me hace un poco fuera de la ruta

Aquí código en JS:

Comparto el sentimiento de muchos compañeros en cuanto a: Tratándose de un curso de algoritmos básicos, Ricardo no se toma el tiempo necesario para hacer las pruebas en frio, además de incluir hasta el item 28 dos lenguajes de programación. Creo que deberían hacer un curso de algoritmos básicos, para las personas que tienen poco o nulo conocimiento en programación.

/**
     * <h1>reverseString</h1>
     * Se invierte el contenido del String mediante recursión
     * Ejemplo: "Keko kaka"
     *
     * La primera parte de la recursion y las llamadas anidadas del método.
     *
     * 1.-rts = "eko kaka" + K
     * 2.-rts = "ko kaka" + e
     * 3.-rts = "o kaka" + k
     * 4.-rts = " kaka" + o
     * 5.-rts = "kaka" + " "
     * 6.-rts = "aka" + k
     * 7.-rts = "ka" + a
     * 8.-rts = "a" + k
     * 9.-rts = "" + a
     *
     * La segunda parte del método recursivo.
     * El método topa con el 'if' y la llamada al método más 'alta' se retorna
     * automaticamente.
     *
     * 9.- rts " " + a = a
     * 8.- rts "a" + k = ak
     * 7.- rts "ka" + a = aka
     * 6.- rts "aka" + k = akak
     * 5.- rts "kaka" + ' ' = akak
     * 4.- rts " kaka" + o = akak o
     * 3.- rts "o kaka" + k = akak ok
     * 2.- rts "ko kaka" + e = akak oke
     * 1.- rts "eko kaka" + K = akak okeK
     * */
    public String reverseString(String str) {
        if (str.isEmpty()) {
            return str;
        } else {
            String rts = reverseString(str.substring(1)) + str.charAt(0);
            return rts;
        }
    }

En C++ usando std::string:

string inverse(string inp) {
	if(inp.length() == 1)
		return inp;
	string last = inp[inp.length() - 1];
	inp.pop_back();
	return (last + inverse(inp));
}

En C o C++ usando array de chars y librería string.h:

char* inverse(char* inp) {
	char* out;
	if(char[1] == '\0') {
		out = new char[2];
		strcpy(out, inp);
		return out;
	}
	char* aux = inverse(inp+1);
	int n = atrlen(aux);
	out = new char[n];
	strcpy(out, aux);
	out[n+1] = inp[0];
	delete aux;
	return out;
}

Haskell:

reverseString "" = ""
reverseString str = reverseString (tail str) ++ [head str]

main = do
  putStrLn (reverseString "Algoritmos")

Se puede probar en https://repl.it/languages/haskell

Eso si, creo que haskell es más rápido insertando elementos al principio de una lista que al final, hasta hay un operador para eso:

reverseString "" = ""
reverseString str = last str : reverseString (init str)

Fuente de la imagen: http://learnyouahaskell.com/starting-out

En C

#include <stdio.h>
#include <string.h>
 
void revertir(char * cadena)
{
	unsigned int i = 0;
	char temp = '\0';
	unsigned int len = strlen(cadena);
 
	for (; i < len / 2; i++)
	{
		temp = cadena[i];
		cadena[i] = cadena[len - i - 1];
		cadena[len - i - 1] = temp;
	}
}
 
int main(int argc, char * argv[])
{
	char cadena[] = "Platzi";
 
	printf("%s\n", cadena);
	revertir(cadena);
	printf("%s\n", cadena);
 
	getchar();
	return 0;
}

Me queda algo confuso el uso de los 2 métodos para poner en reversa una cadena… pero en esta liga (que ya fue proporcionada por juandc pero no funciona) se explica más a detalle y logras entender por si quedan dudas.

No tengo ninguna experiencia previa con java y honestamente me costo mucho extraer la lógica del código, me guie por los ejemplos en los comentarios principalmente. a simple vista java parece muy complicado.

No es necesario poner el else en el metodo reverseString, y se puede ahorrar el instanciar el objeto volviendo el metodo estatico. Asi lo hice yo

public class caracteres {

    public static String reverseString (String str){

        if (str.isEmpty())
            return str;

        System.out.println(str.substring(1));
        return reverseString(str.substring(1)) + str.charAt(0);
    }

    public static void main(String args[]) {
        String texto = "Hola mundo";
        String textoReversed;

        textoReversed = reverseString(texto);
        System.out.println(textoReversed);
    }
}

Codigo de String Reverse en ELIXIR

Un interesante lenguaje, un interesante paradigma

defmodule ReverseString do
  def reverse(str) when str == "" do
    ""
  end

  def reverse(str) do
    [ head | tail ] = String.graphemes(str)
    reverse(List.to_string(tail)) <> head
  end
end

Forma de Ejecucion

ReverseString.reverse("Hello World!") # !dlroW olleH

Mi clase y función en C# para invertir cadenas de caracteres,

    class StringReverse
    {
        /// <summary>
        ///  Funcion para invertir cadenas de caracteres. (String)
        /// </summary>
        /// <param name="p_cadena"> Cadena de caracteres a invertir. </param>
        /// <returns></returns>
        public static String InvertirString(String p_cadena) {

            String resultado = String.Empty;

            if ( String.IsNullOrEmpty(p_cadena) ) {

                resultado = String.Empty;

            }
            else
            {
                resultado = InvertirString(p_cadena.Substring(1)) + p_cadena[0];
            
            }

            return resultado;

        }//public static String InvertirString() 

        // Para ejecutar en el main
        // Invertir String
        // Console.WriteLine( StringReverse.InvertirString("Nunca pares de aprender.") );


    }// Fin de : class StringReverse```

Comparto mi implementación en Python:

def invertirCadena(cadena):
    if cadena =="":
        return ""
    return cadena[-1]+invertirCadena(cadena[:-1])

if __name__ == "__main__":
    
    cadena = input("Escriba una cadena para invertir los caracteres: ")
    cadena = invertirCadena(cadena)
    print(cadena)

Hay algún otro curso donde se pueda aprender Recursividad? Porque acá no entendí nada sinceramente. Quizá haya que tomar otro curso antes de entrar a este cierto? Porque todo el tiempo dice “Tu sabes”

Esta bueno el curso, pero si creo que deberían de quitarle el “Básico” del nombre, hay varios conceptos muy pesados, y si creo que se deberían tener algunas bases de POO para entenderle al cien.

Comparto apuntes con Python entendiendo con ciclos y recursividad

Una manera de inveritr una cadena en Java, mas simple es con la clase StringBuildery el metodo reverse() ejemplo:

public static void main(String[] args) {
StringBuilder cadena = new StringBuilder();
		cadena.append("java");
		cadena.reverse();
		System.out.println(cadena);
}

console

avaj

Les comparto mi solución, usando C.
Saludos!

Fue un laburo pero creo que lo logré con Python:

def inversa(texto):
    
    if isinstance(texto, str):
        resultado = ''

        for i in range(len(texto) -1, -1, -1):
            resultado += texto[i]
        return resultado
    else:
        raise TypeError('No hay cadena de caracteres.')

frase = str(input('Dame una cadena de caracteres para invertir: '))

try:
    resultado = inversa(frase)
    print(f'Original: {frase}')
    print(f'Inversa: {resultado}')
except TypeError as e:
    print('Error: ', e)

En realidad, la función “reverseString” si se podía llamar igual que la clase. Simplemente, se pone la letra inicial en minúscula.

public class StringReverse {
	public String stringReverse(...) {
	...
	}
	...
}

Mi aporte en python

def invString(cadena, n):
    
    if n == 0:
        return cadena

    return  cadena[n] + invString(cadena[:n], n - 1)



def run():
    cadena = input("Ingresa una cadena de texto --> ")
    n = len(cadena) - 1
    print(invString(cadena, n))


if __name__ == "__main__":
    run()

Definitivamente deberé tomar los cursos de Java xD

Para los fanáticos de la terminal como yo y que a su vez sea la primera vez que escriben código java, para compilar es así:

javac StringReverse.java

y para ver el output es:

java StringReverse

public class StringReverse {

  public String reverseString(String str){
    if(str.isEmpty()){
      return str;
    } else {
      return reverseString(str.substring(1)) + str.charAt(0);
    }
  }

  public static void main(String[] args){
    StringReverse obj = new StringReverse();
    String result = obj.reverseString("Algorithms r lof ");
    System.out.println(result);
  }

}

Mi aporte.

#Recursiva
def stringReverse(str):
    if not str:
        return str
    else:
        return stringReverse(str[1:])+str[0]

print(stringReverse("algoritmos"))

#Ciclos
def reverseString(str):
    array = ""
    str = list(str)
    while str:
        array = array + str[-1]
        str.pop(-1)
    return array

print(reverseString("algoritmos"))```

public class StringReverse {

public String strReverse(String cadena){

  if(cadena.isEmpty()){
      return cadena;
  }else{
      return strReverse(cadena.substring(1))+cadena.charAt(0);
  }

}

public static void main(String[] args) {

    StringReverse obj = new StringReverse();
    String cadena = obj.strReverse("!IZTALP htiw gnimmargorp nrael ot evol I");
    System.out.println(cadena);
}

}

SALIDA
run:
I love to learn programming with PLATZI!

En Python:

def reverse_string(string):
    if not string:
        return string
    else:
        return reverse_string(string[1:]) + string[0]

if __name__ == '__main__':
    string = "Algoritmos"
    reversed_string = reverse_string(string)
    print(string)
    print(reversed_string)

public class StringReverse{

    public String reverseString(String str){
      if (str.isEmpty()){
            return str;
        } else{
            return reverseString(str.substring(1))+str.charAt(0);
      
        }  
    } 
    public static void main(String[] args){
        StringReverse obj = new StringReverse();
        String result = obj.reverseString("Algorithms are love");
        System.out.println(result);
    }
    }

const reverseStringRec = (txt: string): string => {
  if (txt === '') return txt;
  return txt.charAt(txt.length -1 ) + reverseStringRec(txt.substring(0, txt.length - 1))
}

cad = input("Ingrese una cadena: ")
cad_inv = cad[::-1]
print(cad)
print(cad_inv)```

Gracias clases de python en platzi:

def stringReverse(phrase):
    if not phrase:
        return phrase

    return stringReverse(phrase[1:]) + phrase[0]

using System;

namespace CharactersWithRecursion
{
    class Program
    {
        static void Main(string[] args)
        {
             string str = ReverseString("Hello World!");
            Console.WriteLine(str);
        }

         static string ReverseString(string str)
         {
             if(string.IsNullOrEmpty(str))
             {
                 return str;
             } else{

                return ReverseString(str.Substring(1))+ str[0];
             }
              
               
         }
    }
}

me daba miedo que se me tragara la memoria del sistema

import logging
logging.basicConfig(level=logging.INFO)
def invertir_caracter(caracter,longitud):
    if longitud==0:
        return ''
    return caracter[longitud-1]+invertir_caracter(caracter,longitud-1)
caracter='pokemon'
caracter_invertido=invertir_caracter(caracter,len(caracter))
logging.info('el inverso de {} es {}'.format(caracter,caracter_invertido))```

Diablos había olvidado cómo se compilaba y ejecutaba Java en CMD jaja! Excelente clase!

No sabía sobre ese compilador y ejecutador de código de Java en linea, cada día se aprenden más cosas.

Se me hizo interesante en C

#include<stdio.h>
#include<string.h>
 
void revertir(char * cadena)
{
	unsigned int i = 0;
	char temp = '\0';
	unsigned int len = strlen(cadena);
 
	for (; i < len / 2; i++)
	{
		temp = cadena[i];
		cadena[i] = cadena[len - i - 1];
		cadena[len - i - 1] = temp;
	}
}
 
int main(int argc, char * argv[])
{
	char cadena[] = "Hola a todos";
 
	printf("%s\n", cadena);
	revertir(cadena);
	printf("%s\n", cadena);
 
	getchar();
	return 0;
}```

public class StringReverse {

    public String reverseString(String str) {
        if(str.isEmpty()) {
            return str;
        }
        else {
            return reverseString(str.substring(1)) + str.charAt(0);
        }
    }
    public static void main(String[] args) {
        StringReverse obj = new StringReverse();
        String result = obj.reverseString("Algorithms are love");
        System.out.println(result);
    }
}```

Ejemplo en reverse string en JS de forma recursiva y por medio de ciclos

const reverse = str => {
  let result = ''
  for (let i = str.length - 1; i >= 0; i--) {
    result += str[i]
  }
  return result
}

const reverse = str => str.length ? (str.substring(str.length - 1) + reverse(str.substring(0, str.length - 1))) : ''

En javascript tambien hay una forma de hacer esto facil usando built-in functions, asi:

let cadena = 'Platzi';

// Con el split('') convierto la cadena en un array separando la cadena caracter por caracter
// Con el metodo reverse se puede invertir un array, ya que la cadena es un array, puedo utilizar dicho metodo 
// Y con el metodo join('') puedo unir todas las posiciones del array en una cadena, teniendo asi la misma cadena pero al reves
let cadena_al_reves = cadena.split('').reverse().join('');
// iztalP

Pero como la clase es de recursion, trate de usar la menor cantidad de built-ins (aunque peque de usar slice para no concatenar manualmente)

Este es mi codigo:

function reverseAString(inputString, outputString = '') {
 let size = inputString.length;
 if (size === 0) { // Si ya saque todos los caracteres de la cadena de entrada, procedo a devolver la cadena con los caracteres invertidos, esta es mi condicion de parada
   return outputString;
 } else { // si no, llamo a la funcion nuevamente, enviando como cadena de entrada la cadena de entrada sin el ultimo caracter y como cadena de salida concateno cada ultimo caracter, asi voy sacando los caracteres de derecha a izquierda
   return reverseAString(inputString.slice(0, size - 1), outputString + inputString.slice(size-1));
 }

Creo que le tengo miedo a Java, por no aprenderlo me expulsaron de la escuela x.x

Otro enfoque en C:

#include <stdio.h>
#include <string.h>

int reverse(char* str, int start, int end) {
    if (strlen(str) - 1 < end) {
        return -1;
    }

    if (start < end) {
        char aux = str[start];
        str[start] = str[end];
        str[end] = aux;
        reverse(str, ++start, --end);
    }
    return 0;
}

int main() {
    char* str;
    printf("Set string to reverse\n");
    scanf("%s", str);
    int result = reverse(str, 0, strlen(str) - 1);
    if (result < 0) {
        printf("Error");
        return result;
    }
    printf("%s\n", str);
    return 0;
}```

Sufrí un poco por el tema del uso de minúsculas donde no se debían colocar, pero bueno, a la final logré identificar el error y solucionarlo… 😃

public class StringReverse{

    public String reverseString(String str){
      if (str.isEmpty()){
          return str;
      } else {
          return reverseString(str.substring(1))+str.charAt(0);
        }
    }
    public static void main(String[] args) {
        StringReverse obj = new StringReverse();
        String result = obj.reverseString("Algorithms are love");
        System.out.println(result);
    }
}

Código en Python con recursividad:

#-*- coding: utf-8 -*-

def reverse_str(string):
       
    if not string:
        return string
        
    else:
        return reverse_str(string[1:])+string[0] 

if __name__ == "__main__":
    print(' ESTE SOFTWARE DEVUELVE EL INVERSO DE LO QUE ESCRIBAS')
    print('******************************************************')
    print('')
    cadena = str(input('Escribe lo que quieras: '))
    print('Lo que escribiste al réves: {}'.format(reverse_str(cadena)))

Mi versión del código en c++:

#include <iostream>

using namespace std;
int n, c=0;
int i=0, j;
char frase[50];
int conteo(char frase[]){
	int contador = 0, j=0;
	while (frase[j] != '\0'){
		contador += 1;
		j++;
	}
	return contador;
	
}
void cambioPosicion(){
	if(c<n/2){
	char temp;
		temp = frase[i];
		frase[i]=frase[j];
		frase[j]= temp;
		i++;j--;c++;
			cambioPosicion();}
}
int main(){
	cout<<"Escribe la frase:"<<endl;
	cin>>frase;
	n = conteo(frase);
	 j=n-1;
	cambioPosicion();
	cout<<frase;
}

no me deja correr ningunos de los ejercicios que hago

Python y su simpleza

string = "Hola a todos"

print(string[::-1])

public class StringReverse{

    public String reverseString(String str){
        if(str.isEmpty()){
            return str;
        }else{
            return reverseString(str.substring(1))+str.charAt(0);
        }
    }
    public static void main(String[]args){
        StringReverse obj = new StringReverse();
        String result = obj.reverseString("Älgorithms are love");
        System.out.println(result);
    }   

}```

En Javascript.

document.write("<br>Poner al revez un string<br><br>");

		

		function reverse(str){
			if(str.length){//length devuelve 0 si le mandan un cadena vacia osea false.
				return str.substring(str.length-1)+ reverse(str.substring(0, str.length-1));
			}else{
				return str;
			}
		}
		
		document.write(reverse("love"));


		document.write("<br>Poner al revez un string con ciclos<br>");

		var str= "love";
		var result="";
		for(i=str.length-1; i>=0; i--){
			result+= str[i];
			
		}
		document.write("<br>"+result);```

public class Characters
{
	public static void main(String[] args)
	{
		Characters strings = new Characters();
		System.out.println(strings.ReverseString("Algorithms are love"));
	}
	
	public String ReverseString(String str)
	{
		if (str.isEmpty())
			return str;
		else
			return ReverseString(str.substring(1)) + str.charAt(0);
	}
}

Struggling with this challenge but I did it at the end.

import java.util.Scanner;

public class CadenaOrden {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("Please insert the String you want to get written backwards: ");
        String cadena = in.nextLine();
        System.out.println("the word written backwards is: " + flipWord(cadena));

    }

    static String flipWord(String cadena){
        if(cadena.length() < 1){
            return "";
        }else{
            return (cadena.charAt(cadena.length()-1) + flipWord(cadena.substring(0, cadena.length()-1)));
        }
    }
}

The main difference between recursion and iteration is that the first one uses the same chunk of code, runing at different layers of our program. The iteration instead, makes differents executions over the same code over the same layer. Also, recursion goes deeper and deeper until the base case is achieved, iteration runs the same code until a condition is met.

se podría hacer este programa de recursividad en C ya que que en C no se puede concatenar?

Muy bueno… lo único es que el compilador de java, traduce el código a español y queda muy raro, pero compilo perfectamente. Gracias!!

aqui mi version en C# tuve que hacer trampa y me base en el codigo de otro compañero que uso C++ en los comentarios, generaba una serie de problemas porque no removia la ultima letra y Chasheava intente de todo hasta que lo consegui.

Resultado:

public class StringReverse
{
public String reverseString (String str)
{
if (str.isEmpty())
{
return str;
}
else
{
return reverseString(str.substring(1))+str.charAt(0);
}
}

public static void main(String[] args) 
{
    StringReverse obj = new StringReverse();
    String result = obj.reverseString("algoriths are love");
    System.out.println(result);
}

}

Mi versión en Java.

package com.company;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
	    String message;
        Scanner inputKeyboard = new Scanner(System.in);
        System.out.println("Escriba el texto que desee ver al reves");
        message = inputKeyboard.nextLine();
	    String res = reorder(message);
        System.out.println(res);
    }

    public static String reorder(String word)
    {
        int wordLength = word.length();
        if(wordLength == 0)
        {
            return word;
        }

        char aux = word.charAt(wordLength-1);
        String newArray = word.substring(0, wordLength-1);

        wordLength = newArray.length();

        return aux + reorder(newArray);
    }
}

En C.

#include <stdlib.h>
#include <stdio.h>

void reverse_string(char src[], char dst[], int base_size, int size)
{
	dst[base_size - size] = src[size];
	if (size > 0)
		reverse_string(src, dst, base_size, size - 1);
}


int main(const int argc, const char *argv[])
{
	char string[] = "Esto es una prueba";
	int size = sizeof(string)/sizeof(char);
	char string2[size];

	// size - 2 to skip \0
	reverse_string(string, string2, size - 2, size - 2);

	printf("%s\n", string2);
	return 0;
}

package recursividad;

public class StringReverse {
	
	// Regrese un string al reves
	public String reverseString(String str) {
		// Base case
		if ( str.isEmpty() ) {
			return str;
		}
		
		// Recurisve
		else {
			return reverseString( str.substring(1)) +  str.charAt(0) ;
		}
	}
	
	// Dirver
	public static void main(String[] args) {
		System.out.println("Algorithms are love");
		StringReverse obj = new StringReverse();
		String result = obj.reverseString("Algorithms are love");
		System.out.println(result);

	}

}

def reverse(string):
	if string == "":
		return string
	else:
		return reverse(string[1:])+string[0]

print(reverse("Algorithms are love"))

Intente hacer el reto, con C++, pues es el lenguaje que se mejor, pero tengo problemas con mi compilador, uso DevC++, pues no me lee la variable string.
por si gustan checarlo o ver si me falta algo anexo el codigo.

#include<stdio.h>
#include<string.h>
#include<iostream>


void reveseStr(string& str)
{
	int n = str.length();
	for(int i = 0 i < n/2; i++)
	{
		swap(str[i], str[n - i 1]);
	}
}
int main()
{
	string str = "loveReverse";
	StringReverse(str);
	return 0;
}

Tambien existe una version que se me hizo interesante en Phyton que es muy corta que da risa:

cadena = "reverseCool"
print (cadena[::-1])```

Falto bastante la explicacion de que hace exactamente substring y que parametros recibe, igualmente con charAt… Tambien como funciona la “libreacion” de los stacks acumulados

Para ejecutarlo por CLI, se puede usar el comando javac (teniendo instalado el jdk previamente) y luego correr el programa con el comando java

JAVA:

Esta es mi intergración en JS:

function reverseString(string, position) {
	let pos = position
  if (!position) {
  	pos = 0
  }
	if (pos === string.length - 1) {
  	return string[pos]
  }
  return `${reverseString(string, pos + 1)}${string[pos]}`
}

console.log(reverseString('Algorithms are love'))

Mi aporte en C:

#include <stdio.h>

void nameRev( char name[], int first, int last )
{
    char temp;

    if ( last > first )
    {
        temp = name[ last ];
        name[ last ] = name[ first ];
        name[ first ] = temp;
        // 
        // printf("La variable temp es: %c\n", temp );
        // printf("EL caracter en first %d es: %c\n", first, name[first] );
        // printf("EL caracter en last %d es: %c\n", last, name[last] );

        first++;
        last--;

        nameRev( name, first, last );
    }
     // return 1;
}

void printName( char name[] )
{
    printf("El nombre al revés es %s\n", name);
}

int main(int argc, char const *argv[])
{
    char name[] = "ANITA LAVA LA TINA";
    int n = sizeof( name ) - 1;
    int first = 0;
    int last = sizeof(name) - 2;

    // printf("El primer caracter es: %d\n", first );
    // printf("El último caracter es: %d\n", last );

    printf("El nombre originalmente es %s\n", name );
    nameRev( name, first, last );
    printName( name );

    return 0;
}

```c
#include <stdio.h>

long result;
int n;

long factorial(int n)
{
    if(n == 0)
    {
        return 1;
    }        
    else
    {
      return (n* factorial(n -1)); /* code */
    }
}

int main()
{
    printf( "Ingrese el numero a calcular\n");
    scanf("%d", &n);
    if (n < 0 )
    {
        printf("El numero debe ser positivo\n");
    }
    else
    {
        result = factorial(n);
        printf("%d! = %ld \n", n, result);
    }
    return 0;
}

juliana@juliana-ubuntu:~/Documentos/Curso de algoritmos$ gcc recursividad.c -o recursividad
juliana@juliana-ubuntu:~/Documentos/Curso de algoritmos$ ./recursividad
Ingrese el numero a calcular
10
10! = 3628800

Hola. ¿como hago para configurar el path de java en VS code?

public class  StringReverse
{

  public String reverseString(String str)
  {
    if(str.isEmpty())
    {
      return str;
    }else{
      return reverseString(str.substring(1))+str.charAt(0);
    }
  }


    public static void main (String[] args)
    {
      StringReverse obj = new StringReverse();
      String result = obj.reverseString("Algorithms are love");
      System.out.println(result);
    }
}

public class StringReverse {
    public String reverseString(String str) {
        if(str.isEmpty()) return str;
        return reverseString(str.substring(1))+str.charAt(0);
    }

    public static void main(String[] args) {
        StringReverse sr = new StringReverse();
        String original = "I love potatoes";
        String reversed = sr.reverseString(original);
        System.out.println(original + " reversed is " + reversed);
    }
}

Me tomó un rato entenderlo

-public class StringReverse {
public String reverseString(String str){
if(str.isEmpty()){
return str;
} else{
return reverseString(str.substring(1))+ str.charAt(0);
}
}
public static void main(String[] args) {
StringReverse obj = new StringReverse();
String result = obj.reverseString(“algoritmos aletas”);
System.out.printf(result);
}
}

realizado en C

AQUI EN PYTHON:
![](

definvertir_cadena(cadena):
    if cadena != "":
        return cadena[-1] + invertir_cadena(cadena[:-1])
    else:
        return""
        
print("hola")
print(invertir_cadena("hola"))```

En C++:
![](

#include <iostream>
#include <string>

using namespace std;

string invertir_cadena(const string &cadena){
    if(cadena[0]){
        auto n = cadena.size() - 1;
        return cadena[n] + invertir_cadena(cadena.substr(0,n));}
    else
        return "";

}

int main()
{
    cout << "hola "<< endl <<invertir_cadena("hola")<<endl;
    return 0;
}```

En C
![](

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

void reversa(const char *contenido,int tam,char *alrrevez){
    if(contenido == NULL)return;
    int i = strlen(contenido);
    char cadena[i];
    if(i > 0){
        strncpy(cadena,contenido,i -1);
        cadena[i-1] ='\0';
        alrrevez[tam - strlen(contenido)] = contenido[strlen(contenido)-1];
        reversa(cadena,tam,alrrevez);}

    else alrrevez[tam] = '\0';}

int main(void)
{
    char alrrevez[4];
    reversa("hola", 4,alrrevez);
    printf("hola alrrevez es %s\n",alrrevez);
    return 0;
}

Mi código en JS:

var text = "Texto al reves";
console.log(stringReverse(text));

function stringReverse(str) {
    //If the string is empty, return the same string
    if (str == "") {
        return str;
    }
    /* In JS we have a way to reverse a string and is using string.split("").reverse().join("") */
    return str.split("").reverse().join("");
}

Muy bien!!

En Python:

def reverse_str(string):
    separate = list(string)
    reverse = []
    i = len(separate)-1
    while i>=0:
        reverse.append(separate[i])
        i-=1

    reverse_org = ''.join(reverse) 
    
    print('Así queda tu string al réves: {}'.format(reverse_org))
    
    


if __name__ == "__main__":
    print(' ESTE SOFTWARE DEVUELVE EL INVERSO DE LO QUE ESCRIBAS')
    print('******************************************************')
    print('')
    cadena = str(input('Escribe lo que quieras: '))
    reverse_str(cadena)

Dos algoritmos para voltear cadenas de texto en Python.
El primero es una propuesta de Daniela S que complete & el segundo es una mejora que hice con ayuda del primero.

** codigo en python**

string = "hola mundo"

nueva_cadena=[string[i*-1] for i in range(1, len(lista_string)+1) ]

print(nueva_cadena)

resultado:
[‘o’, ‘d’, ‘n’, ‘u’, ‘m’, ’ ', ‘a’, ‘l’, ‘o’, ‘h’]

Buen ejercicio aunque no se de Java.

Súper genial!!!

Que mal están utlizando class para explicar en curso y no ahi ningun video que explique es class y un objeto

El ejercicio en C

#include <stdio.h>
#include <string.h>

void stringReverse(char * str);

int main(int argc, const char * argv[]){
	char buffer[100];
	printf("Introduce la cadena de texto que deseas revertir\n");
	scanf(" %99[^\n]%*[^\n]%*s", buffer);
	
	printf("Inversión aplicada: ");
	stringReverse(buffer);

	return 0;
}

void stringReverse(char str[]){
	if(*str){
		stringReverse(str+1);
		printf("%c",*str);
	}
}

Hola,
Este es mi programa en C:

#include <stdio.h>
#include <math.h>
#include <string.h>

char message[] = "Hola mundo";

char *strflip(char *str)
{
    char str_temp[2]={'\0'};
    if(*str==0)
        return str;
    str_temp[0]= *str;
    return strcat(strflip(str+1),str_temp);
}

int main(int argc, char const *argv[])
{
    printf("Reversion de la cadena \"%s\":\n",message);
    printf("%s\n",strflip(message));
    return 0;
}

Esta clase si que me tomo tiempo para entender un poco mas sobre la recursividad.

No sé nada de Java segui el algortimo y me da error