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))
}