Struct para calcular

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

Diego Forero

Team Platzi•

Así lo hice yo 😃

package main

import "fmt"

// Definimos la estructura
type Rectangle struct {
	base   int
	height int
}

// Función para recibir la información del usuario, retorna una instancia de Rectangle
func getInfo() *Rectangle {
	// Creamos una instancia de la struct
	rectangle := new(Rectangle)

	fmt.Println("Calcular el area de un rectangulo")
	fmt.Println("Ingrese el valor de la Base")
	// Recibimos el valor y lo almacenamos en la struct
	fmt.Scanf("%d", &rectangle.base)
	fmt.Println("Ingrese el valor de la Altura")
	// Recibimos el valor y lo almacenamos en la struct
	fmt.Scanf("%d", &rectangle.height)

	return rectangle
}

// Definimos el metodo del struct para calcular el area
func (r Rectangle) getArea() {
	area := r.base * r.height
	fmt.Printf("El área del cuadrado de base %d y altura %d es: %d\n", r.base, r.height, area)
}

// Definimos el metodo del struct para calcular el perímetro
func (r Rectangle) getPerimeter() {
	perimeter := 2 * (r.base + r.height)
	fmt.Printf("El perímetro del cuadrado de base %d y altura %d es: %d\n", r.base, r.height, perimeter)
}

func main() {
	// Almacenamos en r la struct que retorna get info
	r := getInfo()
	// Llamamos a los metodos de la struct
	r.getArea()
	r.getPerimeter()
}

Yohan Graterol

teacher•

Está muy bien! Que bueno de verdad.

Iván Toro

student•

¡Muy bueno!

Guillermo de la Iglesia

student•

Ejemplo de calculo de area y perímetro:

archivo main.go

package main

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

func main() {
	example.Rectangle()
}

archivo geometry/rectangle.go

package strings

import (
	"fmt"
	"os"
	"strconv"
)

func Rectangle() {
	rectangle := Shape{}
	width := UserInput{Request:"Insert rectangle width"}
	height := UserInput{Request:"Insert rectangle height"}
	complete := make(chan bool)
	go func() {
		width.RequestHandler()
		height.RequestHandler()

		rectangle.Width = width.Value
		rectangle.Height = height.Value
		rectangle.Area = width.Value * height.Value
		rectangle.Perimeter = width.Value * 2 + height.Value * 2

		complete <- true
	}()

	for <-complete {
		fmt.Println("[output] Rectangle area:", rectangle.Area)
		fmt.Println("[output] Rectangle perimeter:", rectangle.Perimeter)
		os.Exit(1)
	}
}

type Shape struct {
	Width     float64
	Height    float64
	Area      float64
	Perimeter float64
}

type UserInput struct {
	Request string
	Insert  string
	Value   float64
}

func (req *UserInput) RequestHandler() {
	fmt.Printf("[input] " + req.Request + ": ")
	fmt.Scanf("%s", &req.Insert)

	number, err := strconv.ParseFloat(req.Insert, 64)
	if err != nil {
		panic(err)
	} else {
		req.Value = number
	}
}

Resultado:

[input] Insert rectangle width: 30
[input] Insert rectangle height: 25
[output] Rectangle area: 750
[output] Rectangle perimeter: 110
exit status 1

Maday Choque

student•

package main

import (
“fmt”
)

func main(){
dimensiones := getDimension()
dimensiones.getArea()
dimensiones.getPerimetro()
}

type dimensionCuadrado struct {
base int
altura int
}

func getDimension() *dimensionCuadrado {
dimensionCuadrado := new(dimensionCuadrado)

fmt.Println("Ingrese el valor de la base: ")
fmt.Scanf("%d", &dimensionCuadrado.base)

fmt.Println("Ingrese el valor de la altura: ")
fmt.Scanf("%d", &dimensionCuadrado.altura)

return dimensionCuadrado

}

func (d dimensionCuadrado) getArea(){
area := d.base * d.altura
fmt.Println(“El área del cuadrado es: %d”, area)
}

func (d dimensionCuadrado) getPerimetro(){
perimetro := 2*(d.base + d.altura)
fmt.Println(“El perimetro del cuadrado es: %d”, perimetro)
}

Alexander Armúa Abregu

student•

type Square struct{
	Height float32
	Width float32
}

func (s *Square) calcArea() float32 {
	return s.Height * s.Width
}```

David Hernandez

student•

El desafio 2 aqui esta

package main

import "fmt"

type Cuadrado struct {
	Alto, Ancho float64
}

func (c Cuadrado) Area() float64 {
	return c.Alto * c.Ancho
}

func (c Cuadrado) Perimetro() float64 {
	return (2 * c.Alto) + (2 * c.Ancho)
}

func (c Cuadrado) ToSting() {
	fmt.Println("Cuadrado:", c)
	fmt.Println("Area:", c.Area())
	fmt.Println("Perimetro:", c.Perimetro())
}

func main() {
	Cuadrado{Alto: 3, Ancho: 3}.ToSting()
	Cuadrado{Alto: 3, Ancho: 4}.ToSting()
	Cuadrado{Alto: 5, Ancho: 9}.ToSting()
}

resutado

Cuadrado: {3 3}
Area: 9
Perimetro: 12
Cuadrado: {3 4}
Area: 12
Perimetro: 14
Cuadrado: {5 9}
Area: 45
Perimetro: 28

Process finished with exit code 0

Saludos

Manuel Alejandro Pamplona Rosado

student•

package main

import (
“fmt”
)

func main() {
var height int
var width int
fmt.Println(“Escribe base para cuadrado: “)
fmt.Scanf(”%d”, &height)
fmt.Println(“Escribe altura para cuadrado: “)
fmt.Scanf(”%d”, &width)
fmt.Printf(“El área es %d\n”, calculateArea(height, width))
fmt.Printf(“El perímetro es %d\n”, calculatePerimeter(height, width))
}

func calculateArea(height int, width int) int {
return height * width
}

func calculatePerimeter(height int, width int) int {
return (height * 2) + (width * 2)
}

Ernesto Gabriel Mejía Montero

student•

package main

import "fmt"

// Declarando el tipo rectangulo
type Rectangle  struct {
        width int
        heigh int
}

// Obtener el ancho y el alto del rectangulo
func getParameters(rect *Rectangle) {
        fmt.Print("Ingrese el ancho: ")
        fmt.Scanf("%d", &rect.width)
        fmt.Print("Ahora el alto: ")
        fmt.Scanf("%d", &rect.heigh)
}

// Calcular y devolver el area y el perimetro
func areaAndperimeter(w int, h int) (int, int) {
        return w * h, 2 * w + 2 * h
}

func main() {
        rect := new(Rectangle)
        getParameters(rect)
        area, perimeter := areaAndperimeter(rect.width, rect.heigh)
        fmt.Printf("Area: %d\n", area)
        fmt.Printf("Perimetro: %d\n", perimeter)
}

David Gutierrez

student•

package main

import (
	"fmt"
)

type Rectangles struct {
	width  float32
	height float32
}

func main() {
	//rec := Rectangles{height: 10, width: 20}
	rectangle := getInfo()
	fmt.Println("el perimetro del rectangulo es = ", rectangle.perimeter())
	fmt.Println("el area del rectangulo es = ", rectangle.area())
}

func getInfo() *Rectangles {
	rec := new(Rectangles)

	fmt.Println("ingresa el ancho del rectangulo:")
	fmt.Scanf("%f", &rec.width)

	fmt.Println("ingresa el alto del rectangulo:")
	fmt.Scanf("%f", &rec.height)
	return rec
}
func (rec Rectangles) area() float32 {

	area := rec.width * rec.height

	return area
}

func (rec Rectangles) perimeter() float32 {

	per := 2*rec.width + 2*rec.height

	return per
}

John Carlos Espitia Rivera

student•

Mi ejemplo https://github.com/johnksft/bases-go-platzi/tree/master/github.com/johnksft/reto2cuadrado

Ernesto Ventas Fernandez

student•

Julio Cesar Estrada Marcial

student•

package main

import (
	"github.com/yulio94/changestring/squarecalcs"
)

func main() {
	// texto := replacestring.GetString()
	// replacestring.ReplaceString(texto)
	squarecalcs.Calcs()
}

package squarecalcs

import "fmt"

type square struct {
	size float32
}

type area struct {
	area float32
}

type perimeter struct {
	perimeter float32
}

//Calcs make and return the calcs.
func Calcs() {
	square := squareSize()
	area := calcArea(square)
	perimeter := calcPerimeter(square)

	fmt.Println("The area is: ", area)
	fmt.Println("The perimeter is: ", perimeter)
}

func squareSize() square {

	var size float32

	fmt.Print("Type the square size: ")
	fmt.Scanf("%g\n", &size)

	square := square{size: size}

	return square
}

func calcArea(size square) area {

	result := size.size * size.size

	area := area{area: result}

	return area
}

func calcPerimeter(size square) perimeter {

	result := 4 * size.size

	perimeter := perimeter{perimeter: result}

	return perimeter
}

Bruno Tenaglia

student•

package main

import (
	"fmt"
)

type Rectangulo struct {
	base, altura int
}

func main() {
	rect := new(Rectangulo)

	fmt.Println("Escriba la base:")
	fmt.Scanf("%d", &rect.base)

	fmt.Println("Escriba la altura:")
	fmt.Scanf("%d", &rect.altura)

	fmt.Println("El área es: ", calculateArea(rect.base, rect.altura))
	fmt.Println("El perímetro es: ", calculatePerimetro(rect.base, rect.altura))
}

func calculateArea(base, altura int) int {
	return base * altura
}

func calculatePerimetro(base, altura int) int {
	return (2 * base) + (2 * altura)
}

Osmandi Gomez

student•

Por ser un cuadrado consideré más eficiente solo pedir un lado y calcular área y perímetro en una misma función.

package main

import "fmt"

func main() {
	desafio2()
}

type cuadrado struct {
	Lado int
}

func desafio2() {
	ladoStruct := new(cuadrado)
	fmt.Println("Ingrese el valor de lado de un cuadrado")
	fmt.Scanf("%d", &ladoStruct.Lado)
	area, perimetro := AreaPerimetro(ladoStruct.Lado)
	fmt.Printf("El área es %d y \nel perímetro es %d\n", area, perimetro)
}

// AreaPerimetro determina área y perímetro de un cuadrado
func AreaPerimetro(lado int) (int, int) {
	return lado * lado, lado * 4
}

Jorge Alonso Gastelum Gonzalez

student•

package main

import "fmt"

type cuadrado struct {
	lado float32
}

func (cuadrado) calculaArea(l float32) float32 {
	return l * l
}

func (cuadrado) calculaPerimetro(l float32) float32 {
	return l * 4
}
func main() {
	cuadro := new(cuadrado)
	fmt.Print("Ingrese cuando mide un lado de su cuadrado: ")
	fmt.Scanf("%f", &cuadro.lado)
	fmt.Printf("El area de su cuadrado es: %f\n", cuadro.calculaArea(cuadro.lado))
	fmt.Printf("El perimetro de su cuadrado es: %f\n", cuadro.calculaPerimetro(cuadro.lado))
}

Juan Camilo Sarmiento Reyes

student•

Aquí está el mió! 😃

package main

import "fmt"

type Cuadrado struct {
	Alto  float32
	Ancho float32
}

func main() {
	var alto, ancho float32
	fmt.Printf("Escribe el alto del cuadrado: ")
	fmt.Scanf("%f\n", &alto)
	fmt.Printf("Escribe el ancho del cuadrado: ")
	fmt.Scanf("%f", &ancho)
	cuadrado := Cuadrado{Alto: alto, Ancho: ancho}
	fmt.Printf("Área del cuadrado: %f\n", calcularArea(cuadrado))
	fmt.Printf("Perímetro del cuadrado: %f\n", calcularPerimetro(cuadrado))
}

// El área del cuadrado es el producto de la base(ancho) por la altura
func calcularArea(cuadrado Cuadrado) float32 {
	return cuadrado.Alto * cuadrado.Ancho
}

// El perímetro del cuadrado es la suma de la longitud de cada uno de sus lados
func calcularPerimetro(cuadrado Cuadrado) float32 {
	return 2.0 * (cuadrado.Alto + cuadrado.Ancho)
}

Rafael Antonio Hidalgo Romero

student•

/*
estructura cuadrado que reciba el alto y ancho
metodos area y perimetro
*/
package Bonus

type Cuadrado struct {
	Alto  float64
	Ancho float64
}

func (p Cuadrado) CalcArea() float64 {
	return p.Alto * p.Ancho
}

func (p Cuadrado) CalcPerim() float64 {
	return 2 * (p.Alto + p.Ancho)
}

Juan Antonio Sopale

student•

Defino mis geometrías:

package geometria

//Interfaz de la figura
type Figura interface {
	area() float64
	perimetro() float64
}

//Definición del rectángulo
type Rectangulo struct {
	Alto, Ancho float64
}

//Cálculo del área del rectángulo
func (r Rectangulo) area() float64 {
	return r.Alto * r.Ancho
}

//Cálculo del perímetro del rectángulo
func (r Rectangulo) perimetro() float64 {
	return 2*r.Alto + 2*r.Ancho
}

//Cálculo del área de la figura geométrica
func AreaFigura(f Figura) float64 {
	return f.area()
}

//Cálculo del perímetro de la figura geométrica
func PerimetroFigura(f Figura) float64 {
	return f.perimetro()
}

Ejecuto ejemplo en el main:

package main

import (
	"fmt"
	"github.com/usuario/platzi/geometria"
)

func main() {
	r := geometria.Rectangulo{4, 5}
	fmt.Println("Rectángulo:", r)
	fmt.Println("Área del rectángulo:", geometria.AreaFigura(r))
	fmt.Println("Perímetro del rectángulo", geometria.PerimetroFigura(r))
}

package main

import "fmt"

// Definimos la estructura
type Rectangle struct {
	base   int
	height int
}

// Función para recibir la información del usuario, retorna una instancia de Rectangle
func getInfo() *Rectangle {
	// Creamos una instancia de la struct
	rectangle := new(Rectangle)

	fmt.Println("Calcular el area de un rectangulo")
	fmt.Println("Ingrese el valor de la Base")
	// Recibimos el valor y lo almacenamos en la struct
	fmt.Scanf("%d", &rectangle.base)
	fmt.Println("Ingrese el valor de la Altura")
	// Recibimos el valor y lo almacenamos en la struct
	fmt.Scanf("%d", &rectangle.height)

	return rectangle
}

// Definimos el metodo del struct para calcular el area
func (r Rectangle) getArea() {
	area := r.base * r.height
	fmt.Printf("El área del cuadrado de base %d y altura %d es: %d\n", r.base, r.height, area)
}

// Definimos el metodo del struct para calcular el perímetro
func (r Rectangle) getPerimeter() {
	perimeter := 2 * (r.base + r.height)
	fmt.Printf("El perímetro del cuadrado de base %d y altura %d es: %d\n", r.base, r.height, perimeter)
}

func main() {
	// Almacenamos en r la struct que retorna get info
	r := getInfo()
	// Llamamos a los metodos de la struct
	r.getArea()
	r.getPerimeter()
}

package strings

import (
	"fmt"
	"os"
	"strconv"
)

func Rectangle() {
	rectangle := Shape{}
	width := UserInput{Request:"Insert rectangle width"}
	height := UserInput{Request:"Insert rectangle height"}
	complete := make(chan bool)
	go func() {
		width.RequestHandler()
		height.RequestHandler()

		rectangle.Width = width.Value
		rectangle.Height = height.Value
		rectangle.Area = width.Value * height.Value
		rectangle.Perimeter = width.Value * 2 + height.Value * 2

		complete <- true
	}()

	for <-complete {
		fmt.Println("[output] Rectangle area:", rectangle.Area)
		fmt.Println("[output] Rectangle perimeter:", rectangle.Perimeter)
		os.Exit(1)
	}
}

type Shape struct {
	Width     float64
	Height    float64
	Area      float64
	Perimeter float64
}

type UserInput struct {
	Request string
	Insert  string
	Value   float64
}

func (req *UserInput) RequestHandler() {
	fmt.Printf("[input] " + req.Request + ": ")
	fmt.Scanf("%s", &req.Insert)

	number, err := strconv.ParseFloat(req.Insert, 64)
	if err != nil {
		panic(err)
	} else {
		req.Value = number
	}
}

fmt.Println("Ingrese el valor de la base: ")
fmt.Scanf("%d", &dimensionCuadrado.base)

fmt.Println("Ingrese el valor de la altura: ")
fmt.Scanf("%d", &dimensionCuadrado.altura)

return dimensionCuadrado

package main

import "fmt"

type Cuadrado struct {
	Alto, Ancho float64
}

func (c Cuadrado) Area() float64 {
	return c.Alto * c.Ancho
}

func (c Cuadrado) Perimetro() float64 {
	return (2 * c.Alto) + (2 * c.Ancho)
}

func (c Cuadrado) ToSting() {
	fmt.Println("Cuadrado:", c)
	fmt.Println("Area:", c.Area())
	fmt.Println("Perimetro:", c.Perimetro())
}

func main() {
	Cuadrado{Alto: 3, Ancho: 3}.ToSting()
	Cuadrado{Alto: 3, Ancho: 4}.ToSting()
	Cuadrado{Alto: 5, Ancho: 9}.ToSting()
}

package main

import "fmt"

// Declarando el tipo rectangulo
type Rectangle  struct {
        width int
        heigh int
}

// Obtener el ancho y el alto del rectangulo
func getParameters(rect *Rectangle) {
        fmt.Print("Ingrese el ancho: ")
        fmt.Scanf("%d", &rect.width)
        fmt.Print("Ahora el alto: ")
        fmt.Scanf("%d", &rect.heigh)
}

// Calcular y devolver el area y el perimetro
func areaAndperimeter(w int, h int) (int, int) {
        return w * h, 2 * w + 2 * h
}

func main() {
        rect := new(Rectangle)
        getParameters(rect)
        area, perimeter := areaAndperimeter(rect.width, rect.heigh)
        fmt.Printf("Area: %d\n", area)
        fmt.Printf("Perimetro: %d\n", perimeter)
}

package main

import (
	"fmt"
)

type Rectangles struct {
	width  float32
	height float32
}

func main() {
	//rec := Rectangles{height: 10, width: 20}
	rectangle := getInfo()
	fmt.Println("el perimetro del rectangulo es = ", rectangle.perimeter())
	fmt.Println("el area del rectangulo es = ", rectangle.area())
}

func getInfo() *Rectangles {
	rec := new(Rectangles)

	fmt.Println("ingresa el ancho del rectangulo:")
	fmt.Scanf("%f", &rec.width)

	fmt.Println("ingresa el alto del rectangulo:")
	fmt.Scanf("%f", &rec.height)
	return rec
}
func (rec Rectangles) area() float32 {

	area := rec.width * rec.height

	return area
}

func (rec Rectangles) perimeter() float32 {

	per := 2*rec.width + 2*rec.height

	return per
}

package squarecalcs

import "fmt"

type square struct {
	size float32
}

type area struct {
	area float32
}

type perimeter struct {
	perimeter float32
}

//Calcs make and return the calcs.
func Calcs() {
	square := squareSize()
	area := calcArea(square)
	perimeter := calcPerimeter(square)

	fmt.Println("The area is: ", area)
	fmt.Println("The perimeter is: ", perimeter)
}

func squareSize() square {

	var size float32

	fmt.Print("Type the square size: ")
	fmt.Scanf("%g\n", &size)

	square := square{size: size}

	return square
}

func calcArea(size square) area {

	result := size.size * size.size

	area := area{area: result}

	return area
}

func calcPerimeter(size square) perimeter {

	result := 4 * size.size

	perimeter := perimeter{perimeter: result}

	return perimeter
}

package main

import (
	"fmt"
)

type Rectangulo struct {
	base, altura int
}

func main() {
	rect := new(Rectangulo)

	fmt.Println("Escriba la base:")
	fmt.Scanf("%d", &rect.base)

	fmt.Println("Escriba la altura:")
	fmt.Scanf("%d", &rect.altura)

	fmt.Println("El área es: ", calculateArea(rect.base, rect.altura))
	fmt.Println("El perímetro es: ", calculatePerimetro(rect.base, rect.altura))
}

func calculateArea(base, altura int) int {
	return base * altura
}

func calculatePerimetro(base, altura int) int {
	return (2 * base) + (2 * altura)
}

package main

import "fmt"

func main() {
	desafio2()
}

type cuadrado struct {
	Lado int
}

func desafio2() {
	ladoStruct := new(cuadrado)
	fmt.Println("Ingrese el valor de lado de un cuadrado")
	fmt.Scanf("%d", &ladoStruct.Lado)
	area, perimetro := AreaPerimetro(ladoStruct.Lado)
	fmt.Printf("El área es %d y \nel perímetro es %d\n", area, perimetro)
}

// AreaPerimetro determina área y perímetro de un cuadrado
func AreaPerimetro(lado int) (int, int) {
	return lado * lado, lado * 4
}

package main

import "fmt"

type cuadrado struct {
	lado float32
}

func (cuadrado) calculaArea(l float32) float32 {
	return l * l
}

func (cuadrado) calculaPerimetro(l float32) float32 {
	return l * 4
}
func main() {
	cuadro := new(cuadrado)
	fmt.Print("Ingrese cuando mide un lado de su cuadrado: ")
	fmt.Scanf("%f", &cuadro.lado)
	fmt.Printf("El area de su cuadrado es: %f\n", cuadro.calculaArea(cuadro.lado))
	fmt.Printf("El perimetro de su cuadrado es: %f\n", cuadro.calculaPerimetro(cuadro.lado))
}

package main

import "fmt"

type Cuadrado struct {
	Alto  float32
	Ancho float32
}

func main() {
	var alto, ancho float32
	fmt.Printf("Escribe el alto del cuadrado: ")
	fmt.Scanf("%f\n", &alto)
	fmt.Printf("Escribe el ancho del cuadrado: ")
	fmt.Scanf("%f", &ancho)
	cuadrado := Cuadrado{Alto: alto, Ancho: ancho}
	fmt.Printf("Área del cuadrado: %f\n", calcularArea(cuadrado))
	fmt.Printf("Perímetro del cuadrado: %f\n", calcularPerimetro(cuadrado))
}

// El área del cuadrado es el producto de la base(ancho) por la altura
func calcularArea(cuadrado Cuadrado) float32 {
	return cuadrado.Alto * cuadrado.Ancho
}

// El perímetro del cuadrado es la suma de la longitud de cada uno de sus lados
func calcularPerimetro(cuadrado Cuadrado) float32 {
	return 2.0 * (cuadrado.Alto + cuadrado.Ancho)
}

/*
estructura cuadrado que reciba el alto y ancho
metodos area y perimetro
*/
package Bonus

type Cuadrado struct {
	Alto  float64
	Ancho float64
}

func (p Cuadrado) CalcArea() float64 {
	return p.Alto * p.Ancho
}

func (p Cuadrado) CalcPerim() float64 {
	return 2 * (p.Alto + p.Ancho)
}

package geometria

//Interfaz de la figura
type Figura interface {
	area() float64
	perimetro() float64
}

//Definición del rectángulo
type Rectangulo struct {
	Alto, Ancho float64
}

//Cálculo del área del rectángulo
func (r Rectangulo) area() float64 {
	return r.Alto * r.Ancho
}

//Cálculo del perímetro del rectángulo
func (r Rectangulo) perimetro() float64 {
	return 2*r.Alto + 2*r.Ancho
}

//Cálculo del área de la figura geométrica
func AreaFigura(f Figura) float64 {
	return f.area()
}

//Cálculo del perímetro de la figura geométrica
func PerimetroFigura(f Figura) float64 {
	return f.perimetro()
}

package main

import (
	"fmt"
	"github.com/usuario/platzi/geometria"
)

func main() {
	r := geometria.Rectangulo{4, 5}
	fmt.Println("Rectángulo:", r)
	fmt.Println("Área del rectángulo:", geometria.AreaFigura(r))
	fmt.Println("Perímetro del rectángulo", geometria.PerimetroFigura(r))
}

Struct para calcular

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