Recorrido de Slices y Detección de Palíndromos en Go
Contenido del curso
Alexia Vetere
Tomás Lautaro Elizondo
Daniel Fuentes
Tan Zuñiga
Andrea Aranda
Tan Zuñiga
Wilson Fernando Antury Torres
Wilson Jerez
Jonathan David Olivos
Nicolás Peralta Páez
Cristian Orlando Rincon Bonilla
cpmunoz Carlos Muñoz
Enzo Venturi
Michael Merchan
Ronny
Nicolas Alexander Rodriguez Villota
Esteban Blanco Ortuno
Josue Martin Chi Perera
Alejandro Ching
Mario David Alvarez Vallejo
AGEO ANDRÉS FUENTES MERIÑO
César David García Narro
Roberto Medina
Wilbertson Mojica Cifuentes
Omar Daniel Centeno
Osmandi Gomez
Yenci Brito
Yenci Brito
Alejandro Martinez
Alejandro Martinez
Gustavo Quispe Ramos
Diego Karabin
Santiago Martínez Varela
Sebastian Rodríguez Murillo
Solución al reto:
Muy buena solución pero yo pondría el "strings.ToLower" en la función esPalindromo con el parámetro (text)
strings.ToLower dentro de la función EsPalindromo para que no sea responsabilidad encargarse de enviarlo con minísculas
Lo pense un poco diferente 🐹
Me gustó mucho! Muy ingenioso 😃
Muchas gracias 🙈
Solución al reto:
func isPalindrome(text string) { var textReverse string text = strings.ToLower(text) for i := len(text) - 1; i >= 0; i-- { textReverse += string(text[i]) } if text == textReverse { fmt.Println("Es palindromo") } else { fmt.Println("No es palindromo") } }
muy buena solución
Range
The range keyword is used in for loop to iterate over items of an array, slice, channel or map. With array and slices, it returns the index of the item as integer. With maps, it returns the key of the next key-value pair. Range either returns one value or two. If only one value is used on the left of a range expression, it is the 1st value in the following table.
package main import "fmt" func main() { /* create a slice */ numbers := []int{0,1,2,3,4,5,6,7,8} /* print the numbers */ for i:= range numbers { fmt.Println("Slice item",i,"is",numbers[i]) } /* create a map*/ countryCapitalMap := map[string] string {"France":"Paris","Italy":"Rome","Japan":"Tokyo"} /* print map using keys*/ for country := range countryCapitalMap { fmt.Println("Capital of",country,"is",countryCapitalMap[country]) } /* print map using key-value*/ for country,capital := range countryCapitalMap { fmt.Println("Capital of",country,"is",capital) } }
Palindrome exercise
package main import ( "fmt" "strings" ) func isPalindrome(text string) bool { var reverseText string var lowerText string = strings.ToLower(text) fmt.Println(lowerText) for i := len(lowerText) - 1; i >= 0; i-- { reverseText += string(lowerText[i]) } if reverseText == lowerText { return true } else { return false } } func main() { var slice = []string{"Hola", "que", "tal"} //For range for i, value := range slice { fmt.Printf("%d %s\n", i, value) } if isPalindrome("Amor a roma") { fmt.Println("Es palíndromo") } else { fmt.Println("No es palíndromo") } countryCapitalMap := map[string]string{"France": "Paris", "Italy": "Rome", "Japan": "Tokyo"} /* print map using keys*/ for country := range countryCapitalMap { fmt.Println("Capital of", country, "is", countryCapitalMap[country]) } }
Crack!
Mi solución del reto
package main import ( "fmt" "strings" ) func isPalindrome(text string) bool { var textReverse string /* Reto: validar que si el texto contiene mayúsculas igual siga validando el palíndromo. */ text = strings.ToLower(text) // Pasamos el texto a minúsculas text = strings.ReplaceAll(" ", text, text) // Eliminamos los espacios for i := len(text) - 1; i >= 0; i-- { textReverse += string(text[i]) } if text == textReverse { return true } else { return false } } func main() { /* Recorrer slices */ /* slice := []string{"hola", "golang"} for _, v := range slice { fmt.Println(v) } */ fmt.Println(isPalindrome("Anita lava la tina")) }
Excelente
Comparto la solución redactada en The Go Playground:
package main import "fmt" func isPalindrome(input string) bool { for i := 0; i < len(input)/2; i++ { if input[i] != input[len(input)-i-1] { return false } } return true } func main() { fmt.Println(isPalindrome("anna")) } // Output: True
Consulte más información aquí
Comparto mi solución además realice otra lógica con recursividad para reconocer si es palindromo.
package main import ( "fmt" "strings" "reflect" ) func reverseString(input []string) []string { if len(input) == 0 { return input } return append(reverseString(input[1:]), input[0]) } func isPalindromo(word string) bool{ splitWord := strings.Split(strings.ToUpper(word), "") return reflect.DeepEqual(splitWord, reverseString(splitWord)) } func main() { word :="Ama" if(isPalindromo(word)){ fmt.Println("Es palindromo") }else{ fmt.Println("No es palindromo") } }
Justo lo q pensé !! C:
package main import ( "fmt" "strings" ) func isPalindromo(text string) { var reverse string textoNormal := strings.ToLower(text) for i := len(text) - 1; i >= 0; i-- { reverse += string(textoNormal[i]) } if textoNormal == reverse { fmt.Println("Es un palindromo") } else { fmt.Println("No es un palindromo") } } func main() { isPalindromo("Amor A Roma") }
Go es de los mas rápidos, aquí encontré bastante cosa para complementar el curso. https://www.golinuxcloud.com/golang-interview-questions-answers/
Mi reto cumplido:
package main import ( "fmt" "strings" ) func isPalindromo(text string) { var textReverse string for i := len(text) - 1; i >= 0; i-- { textReverse += string(text[i]) } if text == textReverse { fmt.Println("Es un palindromo") } else { fmt.Println("No es un palindromo") } } func main() { isPalindromo(strings.ToLower("Ama")) }
Muy recursiva y sencilla, excelente!
func esPalindromo(texto string) { var textReverse string fmt.Println("El texto:", texto) // convertir a minúsculas y eliminar espacios texto = strings.ToLower(texto) for i := len(texto) - 1; i >= 0; i-- { textReverse += string(texto[i]) } if textReverse == texto { fmt.Println("Es un palíndromo") } else { fmt.Println("No es un palíndromo") } }
package main import ( "fmt" "strings" ) func main() { isPalindromo("Casac") } func isPalindromo(text string) { var textReverse string for i := len(text) - 1; i >= 0; i-- { textReverse += string(text[i]) } fmt.Println("TEXTO", text) fmt.Println("TEXTO REVERSO", textReverse) if strings.EqualFold(text, textReverse) { fmt.Println("Es un Palíndromo!!!") } else { fmt.Println("No es un Palíndromo!!!") } }
Prof. Entendi el funcionamiento de metodo, solo me quedo una dura sobre que hace el siguiente codigo: string(text[i])
separemos la respuesta en 2 partes:
que hace** text[i]** ?
Regresa el equivalente en ascii del carácter que tiene en ese momento.
Ejemplo: si text[i] = "A", entonces tu sabes que tiene una A, pero en Go, estará almacenando un 65 (el 65 es el equivalente a la letra A, en ASCII).
que hace string(text[i]) ? Convierte ese numero 65 a su equivalente en ascii, es decir a la letra A, para que en lugar de almacenar el numero 65, almacene la letra "A".
Espero te sirva.
Saludos!!
Puedo tener un array o slice con distintos tipos de datos?
Hola
Los datos en Go son fijos, por lo que un array o slice debes de especificar el tipo de datos que manejará.
"Go's slice type provides a convenient and efficient means of working with sequences of typed data".
Te comparto dos páginas de mucha utilidad para que domines estos conceptos:
Idealmente no, porque los array/slice son de un tipo específico de datos. Pero en la sección de Bonus he dejado cómo crear slices que reciben cualquier tipo de datos, úsalo con cuidado jejejeje
Solucion al reto y adicional una forma simple de optimizar algo de codigo: package main import ( "fmt" "strings") func isPalindromo(text string) { var textReverse string var result string for i := len(text) - 1; i >= 0; i-- { textReverse += string(text[i]) } if strings.ToLower(text) == strings.ToLower(textReverse) { result = "Si" } else { result = "No" } fmt.Println(result + " es palindromo")}func main() { slice := []string{"hola", "que", "hace"} for i, valor := range slice { fmt.Println(i, valor) } isPalindromo("Amor a Roma")}
Aca se ve mejor el código:
Esta es mi implementación de la función isPalindrome:
Esta sería mi implementación, ignorando el capitalización de las letras:
Decidí hacerlo así porque convertir toda la palabra para luego iterarla, implicaría iterarla dos veces, una para convertirla toda a mayúscula o a minúscula, y otra para ver si es palindroma.
func isPalindromo(text string) { var textReverse string for i := len(text) - 1; i >= 0; i-- { textReverse += string(text[i]) } if strings.ToLower(text) == strings.ToLower(textReverse) { fmt.Println("Es palindromo") } else { fmt.Println("No es palindromo") } } ```func isPalindromo(text string) { var textReverse string for i := len(text) - 1; i >= 0; i-- { textReverse += string(text\[i]) } if strings.ToLower(text) == strings.ToLower(textReverse) { fmt.Println("Es palindromo") } else { fmt.Println("No es palindromo") }}
package main import ( "fmt" "strings" ) func isPalindrome(text string) bool { var textUppercased string = strings.ToUpper(text) var textReversed string = "" for i := len(textUppercased) - 1; i >= 0; i-- { textReversed += string(textUppercased[i]) } if textUppercased == textReversed { return true } return false } func main() { var text = "Ama" if isPalindrome(text) { fmt.Println("Is a palindrome") } else { fmt.Println("Ain't a palindrome") } }
Solución al reto y otra forma de hacer el método del palíndromo:
aplicación de la función:
func isPalindrome(s string) bool { var reverse string var convertString string   for i := len(s) - 1; i >= 0; i-- { reverse += string(s\[i]) } convertString += strings.ToLower(reverse) if convertString == s { fmt.Println("Is palindrome") return true } else { fmt.Println("Not a palindrome") return false }}```
