A煤n no tienes acceso a esta clase

Crea una cuenta y contin煤a viendo este curso

Uso de funciones

11/36
Recursos

Aportes 61

Preguntas 2

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesi贸n.

reto completado 馃

package main

import (
	"fmt"
	"math"
)

func areaCirculo(radio float64) float64{ 
	return math.Pi*radio*radio
}
func areaRectangulo(base float64, altura float64) float64 {
	return base*altura
}

func areaTrapezoide (B float64,b float64,h float64) float64{
	return h*(B+b)/2
}

func main() {
	fmt.Printf("Circulo %.2f \n",areaCirculo(2))
	fmt.Printf("Rectangulo %.2f \n",areaRectangulo(5,10))
	fmt.Printf("Trapezoide %.2f \n",areaTrapezoide(10,5,3))

}

Como para variar un poco quise hacer la problem谩tica del inicio en una sola fila ^^

Practicando con Go y mi ingles 馃槃

package main

import "fmt"

//Creando funciones
func calculateRectangleArea(b, h int) {
	rectangleArea := b * h
	fmt.Println("El 谩rea del rect谩ngulo es:", rectangleArea)
}

func calculateTrapezeArea(b1, b2, h1 float64) {
	trapezeArea := (b1 + b2) * h1 / 2
	fmt.Println("El 谩rea del trapecio es:", trapezeArea)
}

func calculateCircleArea(r float64) {
	const pi float64 = 3.14
	circleArea := pi * (r * r)
	fmt.Println("El 谩rea del circulo es:", circleArea)
}

//En main epezar谩 a correr en c贸nsola
func main() {
	calculateRectangleArea(5, 10)
	calculateTrapezeArea(15, 12, 6)
	calculateCircleArea(10)
}

Dato curioso sobre el uso del guion bajo para recibir una variable.

En Go a diferencia de por ejemplo Python, el mismo compilador te muestra un error "cannot use _ as value"
si se te ocurre hacer algo como:

value1, _ := twoValuesReturn()
fmt.Println("La variable ", _)

En Python, guardar una variable con guion bajo es meramente una convenci贸n para que cuando otro programador est茅 trabajando sobre el mismo c贸digo, sepa que el valor de dicha variable no tiene importancia. Dado que si podemos hacer algo como sin tener alguna clase de error:

names = ("Gopher", "Go")
value1, _ = names
print("El valor de guion es ", _)  # Imprimir谩 Go

Extra:
Go es tan buena onda que te permite usar varias veces el guion bajo sobre la misma expresi贸n:

value1, _, _ := threeValuesReturn()

馃惐鈥嶐煉 Funciones para determinar 谩rea de un triangulo, trapecio y circulo.

package main

import "fmt"

funcrArea(base , height int)int {
	return base * height
}

functArea(higher , less, size int)int {
	return (higher + less) * size / 2
}

funccArea(radio, pi float64)float64 {
	return (radio * radio) * pi
}

funcmain() {
	base := 80
	height := 40
	fmt.Println("Area del rectangulo: ", rArea(base, height))

	higher := 90
	less := 45
	size := 55
	fmt.Println("Area del trapecio: ", tArea(higher, less, size))

	radio := 45.5
	const pi = 3.14
	fmt.Println("Area del circulo: ", cArea(radio, pi))
}

Reto 馃槂

package main

import (
	"fmt"
	"math"
)

// Calcular area circulo
func areaCirculo(diametro float64) {
	const pi float64 = math.Pi
	var area_circulo = pi * (diametro * diametro / 4)
	fmt.Printf("Area circulo: %.2f \n", area_circulo)
}

//Calcular area rectangulo
func areaRectangulo(largo, ancho float64) {
	var area_rectangulo = largo * ancho
	fmt.Printf("Area rectangulo: %.2f \n", area_rectangulo)
}

// Calcular area traprecio
func areaTraprecio(base1, base2, altura float64) {
	var area_trapecio = altura * ((base1 + base2) / 2)
	fmt.Printf("Area trapecio: %.2f \n", area_trapecio)
}

func main() {
	areaCirculo(5)
	areaRectangulo(25, 50)
	areaTraprecio(6, 3, 4)

	/*
		Area circulo: 19.63
		Area rectangulo: 1250.00
		Area trapecio: 18.00
	*/
}

Ese gui贸n bajo vale su peso en oro

package main

import (
鈥渇mt鈥
)

func calcularCirculo(r float64) {
const pi float64 = 3.14
areaCirculo := pi * (r * r)
fmt.Println(鈥淓l area es鈥, areaCirculo)
}

func calcularRectangulo(a, b float64) {
areaRectangulo := a * b
fmt.Println(鈥淓l area es鈥, areaRectangulo)
}

func calcularTrapecio(b1, b2, h float64) {
areaTrapecio := h * (b1 + b2) / 2
fmt.Println(鈥淓l area es鈥, areaTrapecio)
}

func main() {
calcularCirculo(10)
calcularRectangulo(5, 6)
calcularTrapecio(5, 6, 7)

}

package main

import "fmt"

func areaCuadrado(base int)(area int){
    return base * base
}

func areaRectangulo(base, height int)(area int){
    return base * height
}

func areaTrapecio(base1, base2, height int)(area int){
    return ((base1 + base2) / 2) * height
}

func areaCirculo(diametro int, PI float64)(area float64){
    radio := diametro / 2
    return PI * ((float64(radio)) * (float64(radio)))
}

func main(){
    const PI float64 = 3.1415926535
    x := 10
    y := 50
    z := 16

    // Area cuadrado
    fmt.Println("Area cuadrado:", areaCuadrado(x))

    // Area Rect谩ngulo
    fmt.Println("Area Rect谩ngulo:", areaRectangulo(x, y))

    // Area Trapecio
    fmt.Println("Area Trapecio:", areaTrapecio(x, y, z))

    // Area C铆rculo
    fmt.Println("Area Circulo:", areaCirculo(x, PI))
    fmt.Println("Area Circulo:", areaCirculo(y, PI))
    fmt.Println("Area Circulo:", areaCirculo(z, PI))
}
package main

import (
	"fmt"
	"math"
)

func areaCuadrado(base float64) float64 {
	return base * base
	
}

func areaRectangulo(base, altura float64) float64 {
	return base * altura
	
}

func areaCirculo(radio float64) float64 {
	return math.Pi * radio * radio
}

func main() {
	cuadrado := areaCuadrado(9)
	rectangulo := areaRectangulo(12, 18)
	circulo := areaCirculo(7.5)
	fmt.Println("Area cuadrado:", cuadrado)
	fmt.Println("Area rectangulo:", rectangulo)
	fmt.Println("Area circulo:", circulo)

}
package main

import (
	"fmt"
	"math"
)

func calcularAreaRectagulo(base, altura float64) float64 {
	return base * altura
}

func calcularAreaTrapecio(base1, base2, altura float64) float64 {
	return altura * ((base1 + base2) / 2)
}

func calcularAreaCirculo(r float64) float64 {
	return (r * r) * math.Pi
}
func main() {
	//Area Rectagulo
	areaRectangulo := calcularAreaRectagulo(4.5, 2)
	fmt.Println("Area rectangulo:", areaRectangulo)

	//Area trapecio
	areaTrapecio := calcularAreaTrapecio(6, 3, 4)
	fmt.Println("Area trapecio:", areaTrapecio)

	//Area circulo
	areaCirculo := calcularAreaCirculo(5)
	fmt.Println("Area circulo:", areaCirculo)
}
	// Area triangulo rectangulo
	cateto1 := 12
	cateto2 := 26

	areaTrianguloRectangulo := areaTrianguloR(cateto1, cateto2)
	fmt.Println("Area triangulo rectangulo:", areaTrianguloRectangulo)

	// Area circulo
	var diametro float64 = 25
	var radio float64 = diametro/2

	areaCirculo := areaCirculo( radio, diametro)
	fmt.Println("Area circulo:", areaCirculo)

	// Area trapecio
	base1 := 3
	base2 := 5
	altura := 7

	areaTrapecio := areaTrapecio(base1, base2, altura)
	println("Area trapecio:", areaTrapecio)

func areaTrianguloR(c1, c2 int) int{
	var area int = (c1 * c2) / 2

	return area
}

func areaCirculo(r, d float64) float64{
	var pi float64 = 3.14159
	if r > 0 {

		return pi * math.Pow(r, 2)
	}

	return pi * (math.Pow(d, 2) / 4)
}

func areaTrapecio(b1, b2, a int) int{
	var area int = (b1 + b2) * a / 2

	return area
}

La forma en que se maneja la l贸gica en Go me parece extra帽a
Este c贸digo es completamente valido:

func calcTuple(n int) (sum, mul int) {
	sum = n + 2
	mul = n * 2
	return
}

Soluci贸n al reto

package main

import "fmt"

func imprimePantalla(message string){

	fmt.Println(message)
	
}

func calculaAreaCuadarado(ladoCuadrado int) int{

	areaCuadrado := ladoCuadrado * ladoCuadrado
	return areaCuadrado

}

func calculaAreaRectangulo(baseRectangulo, alturaRectangulo int) int{

	areaRectangulo := baseRectangulo * alturaRectangulo
	return areaRectangulo

}

func calculaAreaTrapecio (base1Trapecio, base2Trapecio, alturaTrapecio, x int)  int{

	areaTrapecio := ((base1Trapecio*base2Trapecio)*alturaTrapecio)/x
	return areaTrapecio

}

func calculaAreaCirculo (radioCirculo, pi float32) float32{

	var areaCirculo float32 = (radioCirculo * radioCirculo) * pi
	return areaCirculo

}

func main() {

	const pi float32 = 3.14
	const x = 2
	var message string

	ladoCuadrado := 2
	areaCuadrado := calculaAreaCuadarado(ladoCuadrado)
	message = fmt.Sprintf("El area del cuadrado es %d", areaCuadrado)
	imprimePantalla(message)

	baseRectangulo := 10
	alturaRectangulo := 5
	areaRectangulo := calculaAreaRectangulo(baseRectangulo, alturaRectangulo)
	message = fmt.Sprintf("El area del rextangulo es %d", areaRectangulo)
	imprimePantalla(message)

	base1Trapecio := 10
	base2Trapecio := 5
	alturaTrapecio := 6
	areaTrapecio := calculaAreaTrapecio(base1Trapecio, base2Trapecio, alturaTrapecio, x)
	message = fmt.Sprintf("El area del trapecio es %d", areaTrapecio)
	imprimePantalla(message)

	var radioCirculo float32 = 10
	var areaCirculo float32 = calculaAreaCirculo(radioCirculo, pi)
	message = fmt.Sprintf("El area del circulo es %g", areaCirculo)
	imprimePantalla(message)
	
}

Mi soluci贸n al reto:

//RETO DE AREA CON FUNCIONES
func areaRectangulo(base, altura float64) float64 {
	return base * altura
}

func areaTrapecio(base, baseMayor, altura float64) float64 {
	return ((base + baseMayor) * altura) / 2
}

func areaCirculo(radio float64) float64 {
	const PI float64 = 3.14
	return PI * (math.Pow(radio, 2))
}

Y en el main:

fmt.Println("El area del rectangulo es:", areaRectangulo(10, 5))

	fmt.Println("El area del trapecio es:", areaTrapecio(15, 20, 4))

	fmt.Println("El area del circulo es:", areaCirculo(5)) 

Comparto el c贸digo de la clase

package main

import "fmt"

func normalFunction(message string) {
	fmt.Println(message)
}

func tripeArgument(a, b int, c string) {
	fmt.Println(a, b, c)
}

func returnValue(a int) int {
	return a * 2
}

func doubleReturn(a int) (c, d int) {
	return a, a * 2
}

func main() {
	normalFunction("Hola mundo")
	tripeArgument(1, 2, "hola")

	value := returnValue(2)
	fmt.Println("Value:", value)

	value1, value2 := doubleReturn(2)
	fmt.Println("value1 y value2:", value1, value2)

	//si solo queremos retornar un valor cuando usamos doubleReturn, podemos usar _

	//value1, _ := doubleReturn(2)
	//fmt.Println("value1:", value1)
}

Dejo el snippet para el reto

package main

import (
	"fmt"
	"math"
)

func circleArea(radius float64) float64 {
	return math.Pi * math.Pow(radius, 2)
}

func rectangleArea(base, height float64) (square float64) {
	return base * height
}

func trapezeArea(a, b, height float64) float64 {
	return ((a + b) / 2) * height
}

func main() {
	fmt.Printf("rectangle area: %.2f\n", rectangleArea(2, 2))
	fmt.Printf("circle area: %.2f\n", circleArea(15))
	fmt.Printf("Trapeze area: %.2f\n", trapezeArea(12, 10, 15))
}

package main

import (
	"fmt"
	"math"
)

/**
* Calcular Area, perimetro y volumen de figuras geom茅tricas
 */
/**
* Cuadrado
* area = base * base
* perimetro = 4 * base
* volumen = 0
 */
func areaCuadrado(base int) int {
	return base * base
}

/**
* Triangulo
* area = base * altura / 2
* perimetro = base + altura + hipotenusa
* volumen = 0
 */
func areaTriangulo(base int, altura int) int {
	return base * altura / 2
}

/**
* Circulo
* area = pi * radio * radio
* perimetro = 2 * pi * radio
* volumen = 0
 */
func areaCirculo(radio float64) float64 {
	return math.Pi * radio * radio
}

/**
* Rectangulo
* area = base * altura
* perimetro = 2 * (base + altura)
* volumen = 0
 */
func areaRectangulo(base int, altura int) int {
	return base * altura
}

/**
* Piramide
* area = (base * altura) / 3
* perimetro = base + 2 * hipotenusa
* volumen = base * altura
 */
func areaPiramide(base int, altura int) int {
	return (base * altura) / 3
}

/**
* Cubo
* area = 6 * base * base
* perimetro = 12 * base
* volumen = base * base * base
 */
func areaCubo(base int) int {
	return 6 * base * base
}

/**
* Esfera
* area = 4 * pi * radio * radio
* perimetro = 4 * pi * radio * radio
* volumen = (4/3) * pi * radio * radio * radio
 */
func areaEsfera(radio float64) float64 {
	return 4 * math.Pi * radio * radio
}

/**
* Calcula el perimetro de un cuadrado
* @param base int
* @return int
 */
func perimetroCuadrado(base int) int {
	return 4 * base
}

/**
* Calcula el perimetro de un triangulo
* @param base int
* @param altura int
* @return int
 */
func perimetroTriangulo(base int, altura int) int {
	return base + altura + hipotenusa(base, altura)
}

func hipotenusa(base int, altura int) int {
	return int(math.Sqrt(float64(base*base + altura*altura)))
}

func main() {
	fmt.Println("area cuadrado", areaCuadrado(5))
	fmt.Println("area triangulo", areaTriangulo(5, 10))
	fmt.Println("area circulo", areaCirculo(5))
	fmt.Println("area rectangulo", areaRectangulo(5, 10))
	fmt.Println("area piramide", areaPiramide(5, 10))
	fmt.Println("area cubo", areaCubo(5))
	fmt.Println("area esfera", areaEsfera(5))
	fmt.Println("perimetro cuadrado", perimetroCuadrado(5))
	fmt.Println("perimetro triangulo", perimetroTriangulo(5, 10))
}

Reto cumplido, c贸digo humilde se帽oreh.

package main
import "fmt"

func rectangleArea(base, height uint) uint {
	return base * height
}

func trapezeArea(base1, base2, height uint) uint {
	return (base1 * base2) * height
}

func circleArea(radius float64) float64 {
	const pi float64 = 3.14
	return pi * (radius * radius)
}

func SquareArea(squareBase uint) uint {
	return squareBase * squareBase
}

func main () {
	fmt.Println(rectangleArea(15, 30))
	fmt.Println(trapezeArea(10, 10, 20))
	fmt.Println(circleArea(13))
	fmt.Println(SquareArea(10))
}
package main

import (
	"fmt"
	"math"
)

func areaRectangle(b, h int) int {
	return b * h
}

func areaTrapezoid(b, B, h int) int {
	return ((b + B) / 2) * h
}

func areaCircle(d int) float64 {
	return math.Pi * math.Pow(float64(d/2), 2)
}

func main() {
	fmt.Printf("El area del rectangulo es: %d \n", areaRectangle(2, 10))
	fmt.Printf("El area del Trapecio es: %d \n", areaTrapezoid(2, 5, 10))
	fmt.Printf("El area del Circulo es: %.2f \n", areaCircle(10))
}
package main

import (
	"fmt"
	"math"
)

func calcCircle(radio float64) float64{
  result := math.Pi*math.Pow(float64(radio),2)
  return result
}

func calcTrapezoid(a,b,h float64) float64{
  return ((a+b)*h)/2
}

func calcRectangle(a,b float64) float64{
  return a*b
}

func main() {
	//VARIABLES
  const a float64 = 10
	const b float64 = 20
  const radio float64 = 5.4
  const h float64 = 15

  //OPERACIONES
  rect := a*b
  circ := math.Pi*math.Pow(float64(radio),2)
  trap := ((a+b)*h)/2
	
  //RESULTADOS
  fmt.Printf("SIN funciones\n")
	fmt.Println("脕rea del Rect谩ngulo:",rect)
  fmt.Println("脕rea del C铆rculo:",circ)
  fmt.Println("脕rea del Trapecio",trap)
  fmt.Println("")
  
  fmt.Printf("CON funciones\n")
  value1 := calcCircle(radio)
  value2 := calcRectangle(a,b)
  value3 := calcTrapezoid(a,b,h)
  fmt.Println("脕rea del rect谩ngulo",value2)
  fmt.Println("脕rea del c铆rculo:",value1)
  fmt.Println("脕rea del trapezoide",value3)
}

Definitivamente Go me hace sentir como estar programando en C++ y TS jeje.

*Diferencia: Hice que PI sea una variable p煤blica para ser accedida desde cualquier lugar en la que sea necesaria.

//Nombre del paquete
package main

import "fmt"

//Public variable
const pi float64 = 3.1416

func calcularAreaCuadrado(base float64) float64 {
	return base * base
}

func calcularAreaRectangulo(largo, ancho float64) float64 {
	return largo * ancho
}

func calcularAreaTrapecio(base1, base2, altura float64) float64 {
	return (base1 + base2) * altura / 2
}

func calcularAreaCirculo(radio float64) float64 {
	return (pi * (radio * radio))
}

func main() {
	//Funci贸n para cuadrado
	areaCuadrado := calcularAreaCuadrado(10)
	fmt.Println("脕rea del cuadrado:", areaCuadrado)

	//Funcion para rectangulo
	areaRectangulo := calcularAreaRectangulo(6, 2)
	fmt.Println("脕rea del rect谩ngulo:", areaRectangulo)

	//Funcion para trapecio
	areaTrapecio := calcularAreaTrapecio(4, 10, 4)
	fmt.Println("脕rea del trapecio:", areaTrapecio)

	//Funcion para circulo
	areaCirculo := calcularAreaCirculo(2)
	fmt.Println("脕rea del circulo:", areaCirculo)

}

package main

import (
	"fmt"
	"math"
)

func main() {
	const base = 10
	const height = 7
	area := areaRectangle(base, height)
	fmt.Println("脕rea rectangulo:", area)

	const baseInferior = 12
	area = areaTrapeze(baseInferior, base, height)
	fmt.Println("脕rea trapecio:", area)

	const radio = 3.2
	areaC := areaCircle(radio)
	fmt.Println("脕rea circulo:", areaC)
}

func areaRectangle(b, h int) int {
	return b * h
}

func areaTrapeze(B, b, h int) int {
	return (B + b) * h / 2
}

func areaCircle(r float64) float64 {
	return math.Pi * math.Pow(r, 2)
}
func areaRectangulo(base, altura float64) float64 {
	return base * altura
}

func areaTrapecio(baseMenor, baseMayor, altura float64) float64 {
	return ((baseMayor + baseMenor) / 2) * altura
}

func areaCirculo(radio float64) float64 {
	return 3.14 * (radio * radio)
}

Reto resuelto utilizando variadic-function 馃悑:

package main

import (
   "fmt"
   "math"
 )

func area(args... int)(int,int,int,float64){
        Cuadrado   := 40 * 90
        Rectangulo :=  76 * 20
        Trapecio   := ((80 + 32) / 2) * 24 
        Circulo    :=  3.14 * math.Pow(44.5, 2)
        return Cuadrado, Rectangulo, Trapecio, Circulo
}

func main(){
        fmt.Println(area())
}

Holi ac谩 el RETO

package main

import (
	"fmt"
	"math"
)


func areaCalcCuadrado(base int64) int64 {
	return base*base
}
func areaCalcRectangulo(base, altura int64) int64 {
	return base*altura
}
func areaCalCirculo(radio float64) float64{
	return math.Pi * radio 
}

func main()  {
	calculadoraAreaCuadrado :=  areaCalcCuadrado(3)	
	calculadoraAreaRectangulo := areaCalcRectangulo(3,4)
	calculadoraAreaCirculo := areaCalCirculo(344.4)

	fmt.Printf(" El valor del area del cuadrado es: %v \n El valor del area del rectangulo es: %v \n El valor del area del circulo es: %v \n" ,  calculadoraAreaCuadrado, calculadoraAreaRectangulo, calculadoraAreaCirculo)
}

package main

import 鈥渇mt鈥

func normalMessage(message string) {
fmt.Println(message)
}
func suma(a int, b int) {
adicion := a + b
fmt.Println(adicion)
}
func resta(a int, b int) {
sustraccion := a - b
fmt.Println(sustraccion)
}
func
func main() {
normalMessage(鈥渉ola mundo鈥)
suma(2, 3)
resta(5, 2)
}

Mi aporte

// Practica
// Area del rectangulo
func calcularAreaRectanfulo(base, altura int) int  {
	return base * altura
}

// Area del Trapecio
func calcularAreaTrapecio(baseMayor, baseMenor, altura float64) float64  {
	return ((baseMayor + baseMenor) / 2) * float64(altura)
}

// Area del circulo
func calcularAreaCirculo(radioCirculo int) float64  {
	return 3.14 * float64(radioCirculo)
}

	// Practica: Pasar el area de la fuguras calculadas a Funciones
	valorAreaRectangulo := calcularAreaRectanfulo(12,10)
	fmt.Println("El resultado de la funcion para calcular el area del rectangulo es -> ", valorAreaRectangulo)
	valorAreaTrapecio := calcularAreaTrapecio(3.5, 9.5, 4)
	fmt.Println("El resultado de la funcion para calcular el area del trapecio es -> ", valorAreaTrapecio)
	valorAreaCirculo := calcularAreaCirculo(4)
	fmt.Println("El resultado de la funcion para calcular el area del circulo es -> ", valorAreaCirculo)

馃槂

Reto

package main

import "fmt"

//Funci贸n Area de un Rect谩ngulo
func areaRectangulo(base, altura int) (a int) {
	return base * altura
}

//Funci贸n Area de un Trapecio
func areaTrapecio(base, baseMayor, altura int) (a int) {
	return ((base + baseMayor) * altura) / 2
}

//Funcion Area de un Circulo
func areaCirculo(radio float64, pi float64) (a float64) {
	return pi * (radio * radio)
}

func main() {

	//Area de un Rect谩ngulo
	value := areaRectangulo(4, 2)
	fmt.Println("El Area del rectangulo es:", value)

	//Area de un Trapecio
	value = areaTrapecio(3, 5, 2)
	fmt.Println("El Area del trapecio es:", value)

	//Area de un Circulo
	const pi = 3.14
	valueC := areaCirculo(2, pi)
	fmt.Println("El Area del Circulo es:", valueC)

}

馃槑

package main

import (
	"fmt"
	"math"
)

func calcRectangleArea(base, height int) int {
	// Calculates the area of a rectangle

	return base * height
}

func calcTrapezoidArea(base1, base2, height int) int {
	// Calculates the area of a trapezoid

	return ((base1 + base2) / 2) * height
}

func calcCircleArea(radio float64) float64 {
	// Calculates the area of a circle

	return math.Pow(radio, 2) * math.Pi
}

func main() {
	// Prints the area of a rectangle, a trapezoid and a circle
	fmt.Println("Area del rect谩ngulo:", calcRectangleArea(10, 20))
	fmt.Println("Area del trapecio:", calcTrapezoidArea(10, 15, 20))
	fmt.Println("Area del c铆rculo:", calcCircleArea(5))
}

Reto figuras ge贸metricas

package main

import "fmt"

//Reto figuras ge贸metricas
func calcularAreaRectangulo(base, altura float64) float64 {
	return base * altura
}

func calcularAreaTrapecio(baseS, baseI, altura float64) float64 {
	return ((baseS + baseI) / 2) * altura
}

func calcularAreaCirculo(radio float64) float64 {
	return 3.1416 * (radio * radio)
}

func main() {
	areaRectangulo := calcularAreaRectangulo(4, 2)
	fmt.Println("El 谩rea del rect谩ngulo es:",areaRectangulo)

	areaTrapecio := calcularAreaTrapecio(4, 6, 5)
	fmt.Println("El 谩rea del trapecio es:",areaTrapecio)

	areaCirculo := calcularAreaCirculo(5)
	fmt.Println("El 谩rea del circulo es:", areaCirculo)
}

Creando funciones para calcular areas

package main

import "fmt"

func calcSquareArea(side int) int {
	return side * side
}

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

func calcTrapezeArea(sideUp, sideDown, height float64) float64 {
	return ((sideUp + sideDown) * height) / 2
}

func calcCircleArea(radio float64) float64 {
	return 3.1416 * radio * radio
}

func main() {
        fmt.Println("Square area: ", calcSquareArea(5))
	fmt.Println("Rectangle area: ", calcRectangleArea(10, 5))
	fmt.Println("Trapeze area: ", calcTrapezeArea(6, 10, 5))
	fmt.Println("Circle area: ", calcCircleArea(3))
}


Comparto mi c贸digo del reto

package main
import "fmt"
import "math"

func calculateAreaCircle (radio float64) float64 {
	return math.Pi * math.Pow(radio, 2)
}

func calculateAreaRectangle (base float64, height float64) float64 {
	return base * height
}

func calculateAreaTrapeze (base1 float64, base2 float64, heightTrapeze float64) float64 {
	return (base1 + base2) * heightTrapeze / 2
}


func main () {
	/* normalFunction("Aprendiendo funciones con go")
	res := sum(4,20)
	fmt.Println("La suma es:", res) */

	areaCircle := calculateAreaCircle(6)
	fmt.Println("脕rea del c铆rculo:", areaCircle)

	areaRectangle := calculateAreaRectangle(10, 5)
	fmt.Println("脕rea del rect谩ngulo:", areaRectangle)

	areaTrapeze := calculateAreaTrapeze(4,6,6)
	fmt.Println("脕rea del trapecio:", areaTrapeze)
}

Reto de areas 馃槂

package main

import "fmt"

func areaCuadrado(lado int) int {
	return lado * lado
}

func areaRectangulo(base, altura float64) float64 {
	return base * altura
}

func areaTrapecio(baseMenor, baseMayor, altura float64) float64 {
	return ((baseMayor + baseMenor) / 2) * altura
}

func areaCirculo(radio, pi float64) float64 {
	return pi * radio * radio
}

func main() {
	//Area cuadrado
	areaCuadrado := areaCuadrado(3)
	fmt.Println("Area cuadrado: ", areaCuadrado)

	//Area Rectanglo
	areaRectangulo := areaRectangulo(4, 5)
	fmt.Println("脕rea Rectangulo: ", areaRectangulo)

	//Trapecio
	areaTrapecio := areaTrapecio(6, 8, 5)
	fmt.Println("脕rea Trapecio: ", areaTrapecio)

	//Circulo
	const pi float64 = 3.1416
	areaCirculo := areaCirculo(2, pi)
	fmt.Println("脕rea Circulo", areaCirculo)
}

Toda la Clase

<package main

import "fmt"

func normalFuncion(message string) {
	// Esta es una funcion
	fmt.Println(message)
}

func tripleArgument(first, second int, third string) {
	fmt.Println(first, second, third)
}

func returnValue(value int) int {
	return value * 2
}

func doubleReturn(value int) (value2, value3 int) {
	return value * 2, value * 3
}

func calcularAreaTriangulo(base, altura float64) float64 {
	return (base * altura) / 2
}

func main() {
	// Aqui estamos llamando a la funcion normalFuncion
	normalFuncion("Hola mundo")
	tripleArgument(1, 2, "Hola")

	value := returnValue(10)
	fmt.Println("El valor de la value es: ", value)
	value2, value3 := doubleReturn(100)
	fmt.Println("El valor de la value2 es: ", value2)
	fmt.Println("El valor de la value3 es: ", value3)

	// Si una funcion retorna mas de 2 variables y solo se necesita uno
	// se puede usar '_' para descartar el valor que no necesites

	// Ejemplo:

	value4, _ := doubleReturn(100)

	fmt.Println("El valor de la value4 es: ", value4)

	// Reto Calcular el area de un triangulo

	areaTriangulo := calcularAreaTriangulo(19.2, 200.8)
	fmt.Println("El area de un triangulo es: ", areaTriangulo)> 

Ejecutar el siguiente c贸digo para tener la clase en formato autodescriptivo

package main

import "fmt"

func imprimeMensaje(palabra1, palabra2 string, numero1, numero2 int) {

	fmt.Println(palabra1, numero1, palabra2, numero2)
}

func multiplicaPorDos(entrada int) int {

	return entrada * 2
}

func retornoMultiple(numero int) (igual int, separacion string, doble int) {

	return numero, "_>>>>>_", numero * 2
}

func main() {

	fmt.Println()
	fmt.Println("************************")
	fmt.Println("Trabajando con Funciones")
	fmt.Println("************************")
	fmt.Println()

	fmt.Println("El pr贸ximo mensaje se imprime dentro de otra funci贸n que es invocada:")
	fmt.Println()

	imprimeMensaje("Hola", "mundo", 7, 777)
	fmt.Println()

	fmt.Println("Tener en cuenta que si los par谩metros de las funciones tienen el mismo tipo de dato, se pueden declarar los nombres de",
		"las mismas separados por coma y al final indicar el tipo de ellas.")
	fmt.Println()

	fmt.Println("func imprimeMensaje(palabra1, palabra2 string, numero1, numero2 int) {")
	fmt.Println()

	fmt.Println("La siguiente impresi贸n utiliza una funci贸n que retorna un n煤mero:")
	fmt.Println()

	const valorMultiplicar int = 7
	fmt.Println("El pr贸ximo n煤mero '", valorMultiplicar, "' se multiplicar谩 por Dos:", multiplicaPorDos(7))
	fmt.Println()

	fmt.Println("-----------------------------------------------------------------------------------------")
	fmt.Println("A continuaci贸n algo terrible: La funci贸n que retorna 3 valores... o todos los que quieras")
	fmt.Println("_________________________________________________________________________________________")
	fmt.Println()

	fmt.Println("func retornoMultiple(numero int) (igual int, separacion string, doble int) { ")
	fmt.Println("...")
	fmt.Println("return numero, \"_>>>>>_\", numero * 2")
	fmt.Println("}")
	fmt.Println()

	fmt.Println("Se recibe la informaci贸n de la siguiente forma:")
	fmt.Println()

	fmt.Println("mismoNumero, separacion, doble := retornoMultiple(7)")
	fmt.Println()

	fmt.Println("Puedo ver que solo se asignan sus valores a variables y no se puede declarar",
		"explicitamente su tipo. Supongo que es porque para el compilador le es claro por la declaraci贸n",
		"del tipo de retorno.")
	fmt.Println()

	mismoNumero, separacion, doble := retornoMultiple(7)

	fmt.Println("Se imprime el resultado del llamado:")
	fmt.Println()

	fmt.Println("Algo adicional que descubr铆. El lenguaje permite hacer lo siguiente (aunque el corrector de estilo de",
		"VS Code lo cambia)")
	fmt.Println("fmt.Print(mismoNumero); fmt.Print(separacion); fmt.Print(doble)")
	fmt.Println()

	fmt.Print(mismoNumero)
	fmt.Print(separacion)
	fmt.Print(doble)
	fmt.Print("\n")
	fmt.Print("\n")

	fmt.Println("Para escapar valores de retorno que no se quieren usar, en vez de declararla se pone un caracter '_'")
	fmt.Println("mismoNumero, _, doble = retornoMultiple(7)")
	fmt.Println("Y funciona:")
	fmt.Println()

	mismoNumero, _, doble = retornoMultiple(7)

	fmt.Println(mismoNumero, "==doble==>", doble)
	fmt.Println()

	fmt.Println("En lo anterior 'doble' y la flecha se colcoa manualmente, eso no lleg贸 de la funci贸n.")
	fmt.Println()
}

Reto completado!! Cree las funciones de tal manera que me devolviera per铆metro y area en las variables

package main

import (
	"fmt"
	"math"
)

func helloWorld() {
	fmt.Println("Hello, World!")
}

func squareArea(side float64) (perimeter, area float64) {
	return 4 * side, float64(math.Pow(side, 2.0))
}

func rectangleArea(width, height float32) (perimeter, area float32) {
	return (2*width + 2*height), width * height
}

func circleArea(radio float64) (perimeter, area float64) {
	return 2 * math.Pi * radio, math.Pi * math.Pow(radio, 2)
}

func main() {
	squareP, squareA := squareArea(2)
	rectangleP, rectangleA := rectangleArea(3, 5)
	circleP, circleA := circleArea(7)

	// Under score is written to tell go that we just want to call one variable when it is supposed to return 2
	circlePQ, _ := circleArea(7)

	fmt.Println("Perimetro y area del cuadrado", squareP, squareA)
	fmt.Println("Perimetro y area del rectangulo", rectangleP, rectangleA)
	fmt.Println("Perimetro y area del circulo", circleP, circleA)
	fmt.Println("Perimetro del circulo", circlePQ)

}

asi fue como quedo mi codigo luego de hacer el calculo de las
areas con funciones

package main

import 鈥渇mt鈥

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

func areaTrapecio(base1, base2, altura int) int {
sumB := base1 + base2
return sumB * altura
}

func areaCirculo(pi float32, radio float32) float32 {
//area = pi * radio^2
radio2 := radio * radio
return pi * radio2
}

func main() {

respuestaRect := areaRectangulo(18, 12)
fmt.Println("el area del rectangulo es:", respuestaRect)

respuestaTrap := areaTrapecio(18, 14, 12)
fmt.Println("el area del trapecio es:", respuestaTrap)

respuetaCirc := areaCirculo(3.14, 8)
fmt.Println("el area del circulo es:", respuetaCirc)

}

Reto completado 馃槂

Les comparto mi codigo del reto 馃槂

package main

import (
	"fmt"
	"math"
)

func areaRectangulo(a, b float64) float64 {
	return a * b
}

func areaTrapecio(a, b, c float64) float64 {
	return ((a + b) * c) / 2
}

func areaCirculo(a float64) float64 {
	return (math.Pi * a * a)
}

func main() {

	//Area Rectangulo b * h
	AreaRectangulo := areaRectangulo(5, 2)
	fmt.Println("Area rectangulo:", AreaRectangulo)

	//Area Trapecio ((Base mayor + base menor) * altura ) / 2
	AreaTrapecio := areaTrapecio(14, 20, 5)
	fmt.Println("Area Trapecio:", AreaTrapecio)

	//Area Circulo (PI * radio al cuadrado)
	AreaCirculo := areaCirculo(5)
	fmt.Println("Area Circulo:", AreaCirculo)
}

Mi solucion 馃槃

package main

import (
	"fmt"
	"math"
)

func areaRectangulo(lado_a, lado_b int) int {
	return lado_a * lado_b
}

func areaTrapecio(base_larga, base_corta, altura float64) float64 {
	return ((base_larga + base_corta) / 2) * altura
}

func areaCirculo(radio float64) float64 {
	return math.Floor((math.Pi*radio*radio)*100) / 100
}

func main() {
	// RECTANGULO
	area_rectangulo := areaRectangulo(10, 5)
	// TRAPECIO
	area_trapecio := areaTrapecio(15, 12, 6)
	// CIRCULO
	area_circulo := areaCirculo(3)

	fmt.Println("Rectangulo:", area_rectangulo)
	fmt.Println("Trapecio:", area_trapecio)
	fmt.Println("Circulo:", area_circulo)
}
package main

import "fmt"

func areaCuadrado(base int) {
	result := base * base
	fmt.Println("El area de un cuadrado es:", result)
}

func areaRectangulo(base2, h int) {
	result1 := base2 * h
	fmt.Println("El area de un rectangulo es:", result1)
}

func areaTrapecio() {
	base1 := 5
	base2 := 5
	h := 8
	area := h * (base1 + base2) / 2
	fmt.Println("El areade un trapecio es:", area)
}

func main() {
	areaCuadrado(5)
	areaRectangulo(5, 8)
	areaTrapecio()
}

Reto con funciones 馃槂

package main

import "fmt"

func areaRectangulo(base float64, altura float64) {
	resultado := base * altura
	fmt.Printf("El 谩rea del rect谩ngulo es %f\n", resultado)
}

func areaTrapecio(Base float64, base float64, altura float64) {
	resultado := ((Base + base) * altura) / 2
	fmt.Printf("El 谩rea del trapecio es %f\n", resultado)
}

func areaCirculo(radio float64) {
	const pi float64 = 3.1416
	resultado := pi * (radio * radio)
	fmt.Printf("El 谩rea del c铆rculo es %f\n", resultado)
}

func main() {
	// 脕rea del Rect谩ngulo
	areaRectangulo(10, 5)

	// 脕rea del trapecio
	areaTrapecio(25, 15, 10)

	// 脕rea del c铆rculo
	areaCirculo(10)
}

Ejercicio de funciones para 谩rea:

package main

import (
	"fmt"
	"math"
)

func squareArea(base float64) float64 {
	return base * base
}
func rectangleArea(base, height float64) float64 {
	return base * height
}
func trapezeArea(base, upperBase, height float64) float64 {
	return ((upperBase + base) * height) / 2
}
func circleArea(radius float64) float64 {
	return math.Pi * math.Pow(radius, 2)
}

func main() {
	fmt.Println("Area program initialized!")

	base := 23.12
	height := 14.78
	upperBase := 18.32
	radius := 5.39

	square := squareArea(base)
	rectangle := rectangleArea(base, height)
	trapeze := trapezeArea(base, upperBase, height)
	circle := circleArea(radius)

	fmt.Printf("Square area of base %g: %g\n", base, square)
	fmt.Printf("Rectangle area with base %g and height %g: %g\n", base, height, rectangle)
	fmt.Printf("Trapeze area of base %g, upperBase %g and height %g: %g\n", base, upperBase, height, trapeze)
	fmt.Printf("Circle area of radius %g: %g\n", radius, circle)

}

Resuelto 馃槃

package main

import "fmt"

func AreaCirculofun(radioCirculo2 float64) float64 {
	return (pi * (radioCirculo2 * radioCirculo2))
}

func AreaRectangulo2(baseRectangulo2, alturaRectangulo2 int) int {
	return (baseRectangulo2 * alturaRectangulo2)
}

func areaTrapecio2(baseUno2, baseDos2, alturaTrapecio2 int) int {
	return ((baseUno2 + baseDos2) * alturaTrapecio2 / 2)
}

const pi = 3.14

func main() {

	circulo := AreaCirculofun(5.6)
	fmt.Println("Area del circulo:", circulo)

	rectangulo:= AreaRectangulo2(5, 10)
	fmt.Println("Area del rectangulo:", rectangulo)

	trapecio := areaTrapecio2(3, 5, 9)
	fmt.Printf("%d Es el area del trapecio", trapecio)

}

Mi aportaci贸n referente al reto

package main

import (
	"fmt"
	"math"
)

func main() {
	area := rectangleArea(10.5, 5.0)
	fmt.Println("[Rectangle area]:", area)

	area = trapezoidArea(5.0, 14.0, 10.0)
	fmt.Println("[Trapezoid area]:", area)

	area = circleArea(3.0)
	fmt.Println("[Circle area]:", area)
}

func rectangleArea(length, width float64) (area float64) {
	return length * width
}

func trapezoidArea(height, firstBase, secondBase float64) (area float64) {
	return .5 * height * (firstBase + secondBase)
}

func circleArea(radio float64) (area float64) {
	return math.Pi * math.Pow(radio, 2)
}

package main

import "fmt"

func normalFunction(message string) {
	fmt.Println(message)
}

func tripleArgument(a, b int, c string) {
	fmt.Println(a, b, c)
}

func returnValue(a int) int {
	return a * 2
}

func doubleReturn(a int) (c, d int) {
	return a, a*2
}

func main() {
	normalFunction("Hola")
	normalFunction("Hola")
	normalFunction("Hola")

	tripleArgument(1, 2, "Hola")

	value := returnValue(3)
	fmt.Println(value)

	value1, value2 := doubleReturn(2)
	fmt.Println("1:", value1, "\n2:", value2)

}
func circleArea(radio float32) float32 {
	var circulo float32 = math.Pi * (radio * radio)

	fmt.Println("Circulo ->", circulo)

	return circulo
}

func rectangleArea(base, high int) int {
	result := base * high
	fmt.Println("Rectangulo ->", result)
	return result
}

func trapezeArea(base_a, base_b, h int) int {
	return h * ((base_a * base_b) / 2)
}
package main

import (
	"fmt"
	"math"
)

//Declarar funcion
func calculoArea(base, altura, U_base int, radio float64) (cuadrado,
	rectangulo, trapecio int, circulo float64) {

	return base * base,
		base * altura,
		((U_base + base) * altura) / 2,
		math.Pi * math.Pow(radio, 2)
}

//Programa principal
func main() {
	A_cuadrado, a_rectangulo, a_trapecio, a_circulo := calculoArea(15, 6, 12, 1)
	fmt.Println("Calculo de 谩rea figuras geometricas:")
	fmt.Printf("- 脕rea Cuadrado = %d\n", A_cuadrado)
	fmt.Printf("- 脕rea rectangulo = %d\n", a_rectangulo)
	fmt.Printf("- 脕rea trapecio = %d\n", a_trapecio)
	fmt.Printf("- 脕rea Circulo = %f\n", a_circulo)
}

package main

import (
鈥渇mt鈥
鈥渕ath鈥
)

func main() {

areaCircle := circle(0.5)
fmt.Printf("El area del circulo es : %.2f\n", areaCircle)

areaCuadrado := cuadrado(5, 5)
fmt.Printf("El area del cuadrado es: %.2f\n", areaCuadrado)

areaTrapecio := trapecio(4, 5, 10)
fmt.Printf("El area del trapecio es: %.2f\n", areaTrapecio)
}

func cuadrado(base, altuara float32) (area float32) {
return base * altuara
}

func trapecio(baseLower, baseHigher, altura float32) (area float32) {
return cuadrado(baseLower, baseHigher) * altura
}

func circle(radio float64) (area float64) {
return math.Pi * math.Pow(radio, 2)
}

CODIGO:

package main

import (
	"fmt"
	"math"
)

func rectArea(base, high float64) {
	fmt.Printf("\nRectangle:\n  base = %.2f\n  high = %.2f\n  area = %.2f\n",
		base, high, base * high)
}

func trapArea(top, base, high float64) {
	fmt.Printf("\nTrapeze:\n  top = %.2f\n  base = %.2f\n  high = %.2f\n  area = %.2f\n",
		top, base, high, (top+base)/2 * high)
}

func circleArea(radio float64) {
	fmt.Printf("\nCircle:\n  pi = %.2f\n  radio = %.2f\n  area = %.2f\n\n",
		math.Pi, radio, math.Pi * radio * radio)
}

func main() {
	fmt.Println("Reto (operaciones arimeticas):")
	rectArea(30, 10)
	trapArea(30, 50, 20)
	circleArea(15)
} 

RESULTADO:

Rectangle:
  base = 30.00
  high = 10.00
  area = 300.00

Trapeze:
  top = 30.00
  base = 50.00
  high = 20.00
  area = 800.00

Circle:
  pi = 3.14
  radio = 15.00
  area = 706.86 

Ejemplo de funciones:

package main

import "fmt"

func firstFunction(message string) {
	fmt.Println(message)
}

func threeArguments(first, second int, third string) {
	fmt.Printf("Two numbers: %d and %d. One string: %s\n", first, second, third)
}

func returningFunction(number int) int {
	return number * 2
}

func doubleReturn(number int) (c, d int) {
	return number, number * 2
}

func main() {
	fmt.Println("Function program initialized!")

	message := "First message in a function example"
	firstFunction(message)

	threeArguments(15, 7, "String!")

	fmt.Println(returningFunction(4))

	num, twiceNum := doubleReturn(2)
	fmt.Printf("%d multiplied by 2 is: %d\n", num, twiceNum)

	_, twiceEight := doubleReturn(8)
	fmt.Printf("8 multiplied by 2 is: %d\n", twiceEight)
}

Ese guin bajo vale su peso en oro

Mi implemtacion de las formulas

func areaRectangulo(base, altura int) int {
	resultado := base * altura
	return resultado
}

func areaTrapecio(baseSuperior, baseInferior, altura int) int {
	resultado := ((baseInferior + baseSuperior) / 2) * altura
	return resultado
}

func areaCirculo(radio float64) float64 {
	resultado := math.Pi * math.Pow(radio, 2)
	return resultado
}

aqu铆 el reto con funciones:

func area_rectangle(base float64, height float64) float64 {
	return base * height
}

func area_trapezoid(base1, base2, height float64) float64 {
	return (base1 + base2) * height / 2
}

func area_circle(r float64) float64 {
	return 3.14159 * (r * r)
}

Challenge 馃敟馃敟馃敟

func circleArea(r float64) float64 {
	return math.Pi * math.Sqrt(r)
}

func rectangleArea(width, height float64) float64 {
	return width * height
}

func trapezoidArea(longBase, sortBase, height float64) float64 {
	return ((longBase + sortBase) / 2) * height
}

Yo lo hice de esta forma:

package main

import "fmt"

func AreaRectangulo(baseRectangulo, alturaRectangulo int) {
	var areaRectangulo int = baseRectangulo * alturaRectangulo
	fmt.Println(areaRectangulo)
}

func AreaTrapeze(baseMenor, baseMayor, altura int) {
	var areaTrapeze int = (baseMenor + baseMayor) * altura / 2

	fmt.Println(areaTrapeze)
}

func areaCircle(radio float64) {
	const pi float64 = 3.14
	var areaCircle float64 = pi * radio * radio

	fmt.Println(areaCircle)
}

func main() {

	AreaRectangulo(10, 20)

	AreaTrapeze(15, 7, 25)

	areaCircle(50)

}

Todos los ejercicios del curso estan en mi repositorio.

package main

import "fmt"

func calcularAreaRectangulo(baseRectangulo, alturaRectangulo int) {
	areaRectangulo := baseRectangulo * alturaRectangulo
	fmt.Println(areaRectangulo)
}

func calcularAreaTrapecio(baseMenor, baseMayor, altura int) {
	areaTrapecio := (baseMenor + baseMayor) * altura / 2
	fmt.Println(areaTrapecio)
}

func calcularAreaCirculo(radio float64) {
	const pi float64 = 3.14
	areaCirculo := pi * radio * radio

	fmt.Println(areaCirculo)
}

func main() {

	calcularAreaRectangulo(5, 10)

	calcularAreaTrapecio(5, 10, 3)

	calcularAreaCirculo(10)

}

Reto calcular areas con funciones

package main

import (
	"fmt"
	"math"
)

func main()  {
	fmt.Println("The area of rectangle is:", getAreaRectangle(9.0, 5.0))
	fmt.Printf("The area of trapezoid is: %.2f\n", getAreaTrapezoid(38.0, 18.0, 7.0))
	fmt.Printf("The area of circle is: %.4f\n", getAreaCircle(3.5))
}

func getAreaRectangle(width, high float32) float32 {
	return width * high
}

func getAreaTrapezoid(baseA, baseB, high float32) float32 {
	return ((baseA + baseB) / 2) * high
}

func getAreaCircle(radio float64) float64 {
	return math.Pi * math.Pow(radio, 2)
}
package main

import (
	"fmt"
	"math"
)

func main() {

	fmt.Println("Area del rectangulo:", getAreaRectangulo(10, 10))
	fmt.Println("Area del trapecio:", getAreaTrapecio(10, 15, 10))
	fmt.Println("Area del circulo:", getAreaCirculo(10.0))

}

func getAreaRectangulo(base, altura int) int {
	return base * altura

}

func getAreaTrapecio(base1, base2, altura int) int {
	return (base1 + base2) * altura / 2

}

func getAreaCirculo(radio float64) float64 {
	return math.Pi * math.Pow(radio, 2)

}

Tambien me hubiese parecido interesante meter todas estas funciones dentro de una funcion macro que trajera todas las areas y asi dentro, hacer uso de funciones anonimas como para emplear todas las bases que nos has ense帽ado, por el momento asi lo deje, muy contento con el curso!