Cambiar el string

Clase 32 de 34 • Curso de Programación en Go 2016

Jeff Velez

student•

Keep it simple XD

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(changeString("Colo"))
}

func changeString(str string) string {
	return strings.Replace(str, "o", "u", 1)
}

Diego Forero

Team Platzi•

Dejo mi desafío, cambia la última letra de una palabra a mayúscula.

package main

import (
	"fmt"
	"strings"
)

var a string

func getString() {
	fmt.Println("Escribe una palabra en minusculas")
	fmt.Scanf("%s", &a)

	a = capitalize(a)
}

func capitalize(s string) string {
	s = s[0:len(s)-1] + strings.ToUpper(s[len(s)-1:])
	return s
}

func main() {
	fmt.Println("Cambiar la última letra de una palabra a mayuscula")
	getString()
	println(a)
}

Yohan Graterol

teacher•

Muy bien! Lo único el bug de println(a) al final.

Te recomiendo que devuelvas string en la función de getString() así evitas tener que delcarar una variable global.

Diego Forero

Team Platzi•

Gracias por la recomendación, lo cambio y publico de nuevo.

Guillermo de la Iglesia

student•

Ejemplo que permite añadir textos con varias palabras:

archivo main.go

package main

import example "github.com/zguillez/tools/strings"

func main() {
	example.Replace()
}

archivo strings/replace.go

package strings

import (
	"fmt"
	"os"
	"strings"
	"bufio"
)

func Replace() {
	input := UserInput{Request:"Insert text"}
	search := UserInput{Request:"Search"}
	replace := UserInput{Request:"Replace"}
	output := ""
	complete := make(chan bool)
	go func() {
		input.RequestHandler()
		search.RequestHandler()
		replace.RequestHandler()

		output = strings.Replace(input.Insert, search.Insert, replace.Insert, -1)
		complete <- true
	}()

	for <-complete {
		fmt.Println("[output] ", output)
		os.Exit(1)
	}
}

type UserInput struct {
	Request string
	Insert  string
}

func (req *UserInput) RequestHandler() {
	fmt.Printf("[input] " + req.Request + ": ")
	reader := bufio.NewReader(os.Stdin)
	insert, err := reader.ReadString('\n')
	if err != nil {
		panic(err)
	} else {
		req.Insert = strings.Trim(insert, " \n")
	}
}

Resultado:

[input] Insert text: Hello world
[input] Search: world
[input] Replace: World!
[output] Hello World!
exit status 1

David Hernandez

student•

Aqui esta mi aportacion construi un tipo con mi nombre le hice una sobrecarga de metodo de remplazar y le hice la logica en el metodo utilizando varios temas en el curso como range, el ciclo for, if espero cumplir con el requerimiento

package main

import "fmt"

type david string

func (valor david) Replace (textoBusqueda, textoRemplazo string, repeticion int) string {
	texto := []rune(string(valor))
	busqueda := []rune(textoBusqueda)
	remplazo := []rune(textoRemplazo)

	if len(busqueda) == 0 || len(remplazo) == 0 {
		return  string(texto)
	} else {
		regreso := texto
		if repeticion == 0  {
			repeticion = len(texto)
		}

		for ciclo := 0; ciclo < repeticion; ciclo++ {
			indexInicial := -1
			indexFinal := -1
			lenBusqueda := len(busqueda)

			for index, letra := range regreso {
				if indexInicial == -1 {
					if letra == busqueda[0] {
						indexInicial = index
						indexFinal = index
					}
				} else {
					if letra == busqueda[indexFinal - indexInicial + 1] {
						indexFinal++
					} else {
						indexInicial = -1
						indexFinal = -1
					}
				}

				if indexInicial >= 0 && lenBusqueda == (indexFinal - indexInicial) + 1 {
					regreso = []rune(string(regreso[:indexInicial]) + string(remplazo) + string(regreso[indexFinal + 1:]))
					break
				}
			}
			continue
		}

		return string(regreso)
	}
}

func main() {
	var ejemplo david
	ejemplo = "Casa"
	fmt.Printf("El texto reemplazado es el siguiente: %q", ejemplo.Replace("a", "e", 0))
}

Ernesto Gabriel Mejía Montero

student•

package main


import (
        "fmt"
        "strings"
)

func changeA(str string) string {
        return strings.Replace(str, "a", "o", 1)
}

func main() {
        fmt.Println(changeA("Alaba"))
}

John Carlos Espitia Rivera

student•

https://github.com/johnksft/bases-go-platzi/blob/master/github.com/johnksft/reto1cambiostring/main.go

Ernesto Ventas Fernandez

student•

Julio Cesar Estrada Marcial

student•

package main

import (
	"fmt"
	"strings"
)

func main() {
	texto := getString()
	replaceString(texto)
}

func getString() string {
	var palabra string
	fmt.Print("Ingrese una palabra: ")
	fmt.Scanf("%s", &palabra)
	return palabra
}

//replaceString change the first letter in the string
func replaceString(palabra string) {
	old := string([]rune(palabra)[0])
	new := strings.Replace(palabra, old, strings.ToUpper(old), 1)
	fmt.Println(new)
}

Bruno Tenaglia

student•

package main

import (
	"fmt"
	"strings"
)

func main() {
	var str string
	fmt.Println("Escriba una palabra")
	fmt.Scanf("%s", &str)

	fmt.Println(changeLastWord(str))
}

func changeLastWord(str string) string {
	return str[0:len(str)-1] + strings.ToUpper(str[len(str)-1:])
}

Osmandi Gomez

student•

Mi desafío, cambia una letra “al azar” de la palabra que ingresaste por una “Z”.

package main

import (
	"fmt"
	"math/rand"
	"strings"
)

// Te reto a crear una función que reciba un string, cambie una letra y retorne el cambio

func main() {
	string()
}

func string() {
	variable := ""
	fmt.Println("Ingresa una palabra")
	fmt.Scanf("%s", &variable)
	fmt.Printf("Palabra que ingresate: %s\n", variable)
	variableModificada := strings.Split(variable, "")
	numeroAleatorio := random(len(variableModificada))
	letraModifcar := variableModificada[numeroAleatorio]
	fmt.Printf("Letra a modificar: %s\n", letraModifcar)
	fmt.Println("Resultado: " + strings.Replace(variable, letraModifcar, "Z", 1))
}

func random(a int) int {
	return rand.Intn(a)
}

Jorge Alonso Gastelum Gonzalez

student•

package main

import "fmt"

func cambiaLetra(c string, r rune, i int) string {
	out := []rune(c)
	out[i] = r
	return string(out)
}

func main() {
	var cadena string
	fmt.Print("Ingrese una cadena de texto: ")
	fmt.Scanf("%s", &cadena)
	cadena = cambiaLetra(cadena, 'x', 0)
	fmt.Printf("%s\n", cadena)
}```

Juan Camilo Sarmiento Reyes

student•

Mi aporte:

Cambia aleatoriamente una letra de la palabra, con una letra del abecedario

package main

import (
	"fmt"
	"math/rand"
	"time"
)

const LETRAS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

func main() {
	var palabra string
	fmt.Printf("Escribe la palabra: ")
	fmt.Scanf("%s", &palabra)
	fmt.Println(cambiarLetra(palabra))
}

func cambiarLetra(palabra string) string {
	// Es necesario cambiar el source del rand, para que en cada ejecución del programa genere un nuevo número
	s1 := rand.NewSource(time.Now().UnixNano())
	r1 := rand.New(s1)
	word := []rune(palabra)                   // Crea un arreglo de runes con el string palabra [l1, l2, l3] (l es letra)
	randLetter := r1.Intn(len(LETRAS))        // Genera un número aleatorio con el tamaño de la variable LETRAS
	randWord := r1.Intn(len(word))            // Genera un número al aleatorio con el tamaño de la palabra
	word[randWord] = rune(LETRAS[randLetter]) // Aquí es donde se cambian las letras dependiendo de los números generados aleatoriamente
	return string(word)
}

Rafael Antonio Hidalgo Romero

student•

func reemplazo(palabra string, n string, l string) string {

	strings.Replace(palabra, n, l, -1)
	return palabra
}

Juan Antonio Sopale

student•

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func main() {

	palabra_original := "Juan"
	palabra_modificada := cambiarLetra(palabra_original, 'T')

	fmt.Printf("Palabra original: %s\nPalabra modificada: %s\n", palabra_original, palabra_modificada)

}

//cambiarLetra modifico la letra de una palabra al azar por otra
func cambiarLetra(palabra string, letra_sustituta byte) string {
	indice_letra := indiceLetraAzar(0, len(palabra)-1)
	letras := []byte(palabra)
	letras[indice_letra] = letra_sustituta
	return string(letras)
}

//indiceLetraAzar obtengo el índice de la letra al azar que modificaré en una palabra dada
func indiceLetraAzar(min, max int) int {
	rand.Seed(time.Now().Unix())
	return rand.Intn(max-min) + min
}

Juan José Vargas Fletes

student•

Hice uno que encripta (sencillo pero lo hace XD)

package main

import (
	"fmt"
	"strings"
)

func main() {
	var texto string
	fmt.Println("Escribe tu frase a encriptar:")
	fmt.Scanf("%s", &texto)
	GetEncryptedText(texto)
}

func GetEncryptedText(texto string) {
	var encript_container = map[string]string{
		"a": "b",
		"b": "c",
		"c": "d",
		"d": "e",
		"e": "f",
		"f": "g",
		"g": "h",
		"h": "i",
		"i": "j",
		"j": "k",
		"k": "l",
		"l": "m",
		"m": "n",
		"n": "o",
		"o": "p",
		"p": "q",
		"q": "r",
		"r": "s",
		"s": "t",
		"t": "u",
		"u": "v",
		"v": "w",
		"w": "x",
		"x": "y",
		"y": "z",
		"z": "a",
		" ": "_",
	}
	i := 0
	var encrypted_text = ""
	for i < len(texto) {
		if strings.Contains(texto, string(texto[i])) {
			encrypted_text += encript_container[string(texto[i])]
		} else {
			encrypted_text += string(texto[i])
		}
		i++
	}
	fmt.Println(encrypted_text)
}

Iván Toro

student•

Genial.

package main

import (
	"fmt"
	"strings"
)

var a string

func getString() {
	fmt.Println("Escribe una palabra en minusculas")
	fmt.Scanf("%s", &a)

	a = capitalize(a)
}

func capitalize(s string) string {
	s = s[0:len(s)-1] + strings.ToUpper(s[len(s)-1:])
	return s
}

func main() {
	fmt.Println("Cambiar la última letra de una palabra a mayuscula")
	getString()
	println(a)
}

package strings

import (
	"fmt"
	"os"
	"strings"
	"bufio"
)

func Replace() {
	input := UserInput{Request:"Insert text"}
	search := UserInput{Request:"Search"}
	replace := UserInput{Request:"Replace"}
	output := ""
	complete := make(chan bool)
	go func() {
		input.RequestHandler()
		search.RequestHandler()
		replace.RequestHandler()

		output = strings.Replace(input.Insert, search.Insert, replace.Insert, -1)
		complete <- true
	}()

	for <-complete {
		fmt.Println("[output] ", output)
		os.Exit(1)
	}
}

type UserInput struct {
	Request string
	Insert  string
}

func (req *UserInput) RequestHandler() {
	fmt.Printf("[input] " + req.Request + ": ")
	reader := bufio.NewReader(os.Stdin)
	insert, err := reader.ReadString('\n')
	if err != nil {
		panic(err)
	} else {
		req.Insert = strings.Trim(insert, " \n")
	}
}

package main

import "fmt"

type david string

func (valor david) Replace (textoBusqueda, textoRemplazo string, repeticion int) string {
	texto := []rune(string(valor))
	busqueda := []rune(textoBusqueda)
	remplazo := []rune(textoRemplazo)

	if len(busqueda) == 0 || len(remplazo) == 0 {
		return  string(texto)
	} else {
		regreso := texto
		if repeticion == 0  {
			repeticion = len(texto)
		}

		for ciclo := 0; ciclo < repeticion; ciclo++ {
			indexInicial := -1
			indexFinal := -1
			lenBusqueda := len(busqueda)

			for index, letra := range regreso {
				if indexInicial == -1 {
					if letra == busqueda[0] {
						indexInicial = index
						indexFinal = index
					}
				} else {
					if letra == busqueda[indexFinal - indexInicial + 1] {
						indexFinal++
					} else {
						indexInicial = -1
						indexFinal = -1
					}
				}

				if indexInicial >= 0 && lenBusqueda == (indexFinal - indexInicial) + 1 {
					regreso = []rune(string(regreso[:indexInicial]) + string(remplazo) + string(regreso[indexFinal + 1:]))
					break
				}
			}
			continue
		}

		return string(regreso)
	}
}

func main() {
	var ejemplo david
	ejemplo = "Casa"
	fmt.Printf("El texto reemplazado es el siguiente: %q", ejemplo.Replace("a", "e", 0))
}

package main

import (
	"fmt"
	"strings"
)

func main() {
	texto := getString()
	replaceString(texto)
}

func getString() string {
	var palabra string
	fmt.Print("Ingrese una palabra: ")
	fmt.Scanf("%s", &palabra)
	return palabra
}

//replaceString change the first letter in the string
func replaceString(palabra string) {
	old := string([]rune(palabra)[0])
	new := strings.Replace(palabra, old, strings.ToUpper(old), 1)
	fmt.Println(new)
}

package main

import (
	"fmt"
	"strings"
)

func main() {
	var str string
	fmt.Println("Escriba una palabra")
	fmt.Scanf("%s", &str)

	fmt.Println(changeLastWord(str))
}

func changeLastWord(str string) string {
	return str[0:len(str)-1] + strings.ToUpper(str[len(str)-1:])
}

package main

import (
	"fmt"
	"math/rand"
	"strings"
)

// Te reto a crear una función que reciba un string, cambie una letra y retorne el cambio

func main() {
	string()
}

func string() {
	variable := ""
	fmt.Println("Ingresa una palabra")
	fmt.Scanf("%s", &variable)
	fmt.Printf("Palabra que ingresate: %s\n", variable)
	variableModificada := strings.Split(variable, "")
	numeroAleatorio := random(len(variableModificada))
	letraModifcar := variableModificada[numeroAleatorio]
	fmt.Printf("Letra a modificar: %s\n", letraModifcar)
	fmt.Println("Resultado: " + strings.Replace(variable, letraModifcar, "Z", 1))
}

func random(a int) int {
	return rand.Intn(a)
}

package main

import "fmt"

func cambiaLetra(c string, r rune, i int) string {
	out := []rune(c)
	out[i] = r
	return string(out)
}

func main() {
	var cadena string
	fmt.Print("Ingrese una cadena de texto: ")
	fmt.Scanf("%s", &cadena)
	cadena = cambiaLetra(cadena, 'x', 0)
	fmt.Printf("%s\n", cadena)
}```

package main

import (
	"fmt"
	"math/rand"
	"time"
)

const LETRAS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

func main() {
	var palabra string
	fmt.Printf("Escribe la palabra: ")
	fmt.Scanf("%s", &palabra)
	fmt.Println(cambiarLetra(palabra))
}

func cambiarLetra(palabra string) string {
	// Es necesario cambiar el source del rand, para que en cada ejecución del programa genere un nuevo número
	s1 := rand.NewSource(time.Now().UnixNano())
	r1 := rand.New(s1)
	word := []rune(palabra)                   // Crea un arreglo de runes con el string palabra [l1, l2, l3] (l es letra)
	randLetter := r1.Intn(len(LETRAS))        // Genera un número aleatorio con el tamaño de la variable LETRAS
	randWord := r1.Intn(len(word))            // Genera un número al aleatorio con el tamaño de la palabra
	word[randWord] = rune(LETRAS[randLetter]) // Aquí es donde se cambian las letras dependiendo de los números generados aleatoriamente
	return string(word)
}

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func main() {

	palabra_original := "Juan"
	palabra_modificada := cambiarLetra(palabra_original, 'T')

	fmt.Printf("Palabra original: %s\nPalabra modificada: %s\n", palabra_original, palabra_modificada)

}

//cambiarLetra modifico la letra de una palabra al azar por otra
func cambiarLetra(palabra string, letra_sustituta byte) string {
	indice_letra := indiceLetraAzar(0, len(palabra)-1)
	letras := []byte(palabra)
	letras[indice_letra] = letra_sustituta
	return string(letras)
}

//indiceLetraAzar obtengo el índice de la letra al azar que modificaré en una palabra dada
func indiceLetraAzar(min, max int) int {
	rand.Seed(time.Now().Unix())
	return rand.Intn(max-min) + min
}

package main

import (
	"fmt"
	"strings"
)

func main() {
	var texto string
	fmt.Println("Escribe tu frase a encriptar:")
	fmt.Scanf("%s", &texto)
	GetEncryptedText(texto)
}

func GetEncryptedText(texto string) {
	var encript_container = map[string]string{
		"a": "b",
		"b": "c",
		"c": "d",
		"d": "e",
		"e": "f",
		"f": "g",
		"g": "h",
		"h": "i",
		"i": "j",
		"j": "k",
		"k": "l",
		"l": "m",
		"m": "n",
		"n": "o",
		"o": "p",
		"p": "q",
		"q": "r",
		"r": "s",
		"s": "t",
		"t": "u",
		"u": "v",
		"v": "w",
		"w": "x",
		"x": "y",
		"y": "z",
		"z": "a",
		" ": "_",
	}
	i := 0
	var encrypted_text = ""
	for i < len(texto) {
		if strings.Contains(texto, string(texto[i])) {
			encrypted_text += encript_container[string(texto[i])]
		} else {
			encrypted_text += string(texto[i])
		}
		i++
	}
	fmt.Println(encrypted_text)
}

Cambiar el string

Introducción

Introducción a Go

Instalación de Go: Instalación de Go en Ubuntu

Instalación de Go: Instalación de Go en Mac

Instalación de Go: Instalación de Go en Windows

Primeros pasos

Organizando el entorno de trabajo

Hola mundo

Recibir valores del usuario

Declaración de variables y constantes

Funciones

Tipos de datos numéricos en Go: enteros, flotantes

Cadenas de texto básico

Array y Slice

Condicionales

For, break

Intermedio

Operaciones con cadenas

Uso de la instrucción: Switch

Manejo de Paquetes

Map

Structs

Methods

Interfaces

defer

Errores

Avanzados

Punteros

Goroutines

Canales

Ejemplos de Canales

Bibliotecas de Go

Consumiendo una API externa

Errores comunes en Go

Cierre del curso

Contenido Bonus

Cambiar el string

Struct para calcular

Leer un archivo del disco