Uso de funciones

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

Una observación: En el titulo se mencionan las funciones anónimas pero no se habla de ellas 😃

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

Ese guión bajo vale su peso en oro

🐱‍💻 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
	*/
}

Mi humilde solución:

Reto completado

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("Área del rectángulo: ", areaRectangle(7, 10))
	fmt.Println("Área del trapecio: ", areaTrapeze(9, 13, 5))
	fmt.Println("Área del circulo: ", areaCircle(8))
}

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

func areaTrapeze(majorBaseTrapeze, minorBaseTrapeze, height float64) float64 {
	return height * ((majorBaseTrapeze + minorBaseTrapeze) / 2)
}

func areaCircle(radiusCircle float64) float64 {
	return math.Pi * math.Pow(float64(radiusCircle), 2)
}

Mi solución al reto asignado
.
.
.
.
.
.
.
.
.
.

package main

import "fmt"

// Área del rectángulo
func areaRectangulo(b, a float64) float64 {
	area := b * a
	return area
}

// Área del trapezio
func areaTrapezio(l1, l2, a float64) float64 {
	area := ((l1 + l2) * a) / 2
	return area
}

// Área del círculo
func areaCirculo(r float64) float64 {
	const pi float64 = 3.1416
	return pi * r * r
}

func main() {
	aRectangulo := areaRectangulo(2, 5)
	fmt.Println("El área del rectángulo es: ", aRectangulo)
	aTrapezio := areaTrapezio(2, 5, 3)
	fmt.Println("El área del trapezio es: ", aTrapezio)
	aCirculo := areaCirculo(5)
	fmt.Println("El área del trapezio es: ", aCirculo)
}

package main

import (
	"fmt"
	"math"
)

func circleArea(radius float64) float64 {
	area := 2 * math.Pi * radius
	return area
}

func rectangleArea(base, height float64) float64 {
	area := base * height
	return area
}

func trapezoidArea(base1, base2, height float64) float64 {
	area := height * (base1 + base2) / 2
	return area
}

func main() {
	fmt.Println("Rectangle area:", rectangleArea(10, 25.4))
	fmt.Println("Trapezoid area:", trapezoidArea(7.5, 9.3, 10))
	fmt.Println("Circle area:", circleArea(8.2))
}

Reto de la clase:

func calcularAreaRectangulo(base, altura int) {
	areaRectangulo := base * altura
	fmt.Println("Area del Rectangulo:", areaRectangulo)
}

func calcularAreaTrapecio(a, b1, b2 float64) {
	areaTrapecio := a * (b1 + b2) / 2
	fmt.Println("Area del Trapecio:", areaTrapecio)
}

func calcularAreaCirculo(r float64) {
	const pi float64 = 3.14
	areaCirculo := pi * (r * r)
	fmt.Println("Area del circulo:", areaCirculo)
}

func main() {
	calcularAreaRectangulo(5, 6)
	calcularAreaTrapecio(11, 8, 6)
	calcularAreaCirculo(10)
}

Listo el reto

func areaCirculo() {
	radioCirculo := 2.5
	var areaCirculo float64 = 3.1416 * (radioCirculo * radioCirculo)
	println("Area de un circulo", areaCirculo)
}

func areaTrapecio() {
	baseArriba := 14
	baseAbajo := 20
	alturatrapecio := 5
	var areaTrapecio int = ((baseArriba + baseAbajo) * alturatrapecio) / 2
	println("Area trapecio", areaTrapecio)
}

func areRectangulo() {
	baseRectangulo := 10
	alturaRectangulo := 4
	var areaRectangulo int = baseRectangulo * alturaRectangulo
	println("El area del rectangulo es:", areaRectangulo)
} 

Comparto el ejercicio de funciones aritmeticas:

package main

import "fmt"

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

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

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

func calcularAreaTrapecio(base, altura, lado float32) float32 {
	return (base + lado) / 2 * altura
}

func main() {
	areaCuadrado := calcularAreaCuadrado(20)
	fmt.Println("Area cuadrado:", areaCuadrado)
	areaRectangulo := calcularAreaRectangulo(20, 30)
	fmt.Println("Area rectangulo:", areaRectangulo)
	areaCirculo := calcularAreaCirculo(7)
	fmt.Println("Area circulo:", areaCirculo)
	areaTrapecio := calcularAreaTrapecio(20, 30, 15)
	fmt.Println("Area Trapecio", areaTrapecio)
}

Reto completado 😃

/* Funcion simple sin parametros ni return */
func funcionSimple() {
	fmt.Println("Este es el uso de una funcion simple")
}

/* Funcion con parametros declarados con su tipo en cada uno */
func funcionConParametros(a int, b int, c string) {
	fmt.Println("Esta es funcion con parametros", a, b, c)
}

/* Funcion con parametros declarados con su tipo en uno por cada tipo */
func funcionConParametrosAlt(a, b, f int, c, r string) {
	fmt.Println("Esta es funcion con parametros simplificado", a, b, c)
}

/* Funcion con parametros y un return */
func funcionConParametrosYReturnSimple(a int, b int, c string) int {
	fmt.Println("Esta es funcion con parametros y un return simple", a, b, c)
	return a + b
}

/* Funcion con parametros y doble return  */
func funcionConParametrosYReturnDoble(a int, b int, c string) (return1, return2 int) {
	fmt.Println("Esta es funcion con parametros", a, b, c)
	fmt.Println("Se realiza la suma de a y b")
	return a, a + b
}

func areaDeTriangulo(base, altura float64) float64 {
	area := base * altura / 2
	return area
}

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

func areaDeTrapecio(baseMenor, baseMayor, altura float64) float64 {
	area := (baseMayor + baseMenor) / 2 * altura
	return area
}

Por si alguien no entendió como se ejecuta la función de retorno

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

func main () {
value := returnValue(2)
} ;

/*se ejecuta la función main, dentro se declara una variable con un valor igual a la función declarada (esto se conoce como función de valor)
y se le entrega un argumento (2), este argumento se recibe en la declaración de la función returnValue y luego se indica el tipo de dato que se devolverá, más el valor que se dolverá hacia la variable value, utilizando la palabre clave o keyword "return", esto queda con la siguiente estructura*/

func returnValue (parametro_que_recibe) tipo_dato_que_retorna{
return valor_variable_u_operación
}

return: /*Es una palabra clave en Go que se utiliza para finalizar la ejecución de una función y retornar uno o varios valores al lugar desde donde se llamó la función. Es una parte integral de la sintaxis de las funciones en Go.
La función puede o no retornar un valor o valores, dependiendo de su definición. Si una función no tiene una declaración "return" o si tiene una declaración "return" sin especificar ningún valor, la función retornará "nil.*/

/*Una vez que se ejecuta el codigo value deja de ser value := returnValue(2)
y pasa a ser value := 4, como se ve a continuación */

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

func main () {
value :=  4
} ;
/* ese valor puede ser impreso por alguna de las funciones fmt*/

Mi solución:

package main

import "fmt"

const PI float64 = 3.14159

// Función main inicia ejecución de programa.
func main() {
	// Área de un rectangulo
	var base, altura float64 = 10.0, 5
	var area float64 = areaRectangulo(base, altura)
	fmt.Printf("Area de un rectangulo de base %.2f y altura %.2f = %.2f\n", base, altura, area)

	// Area de un circulo.
	var radio float64 = 10.0
	area = areaCirculo(radio)
	fmt.Printf("Area de un circulo de radio %.2f = %.2f\n", radio, area)

	// Area de un trapecio.
	var base1, base2, h float64 = 10, 8, 5
	area = areaTrapacio(base1, base2, h)
	fmt.Printf("Area trapecio de bases %.2f, %.2f y altura %.2f = %.2f\n", base1, base2, h, area)
}

// Calculo area de un cículo.
func areaCirculo(radio float64) float64 {
	var area float64 = PI * radio * radio
	return area
}

// Cálculo area de un rectangulo.
func areaRectangulo(base, altura float64) float64 {
	var area float64 = base * altura
	return area
}

// Cálculo area de un trapecio.
func areaTrapacio(B, b, h float64) float64 {
	var area float64 = (h / 2.0) * (b + B)
	return area
}

mi solucion

package funciones

import (
	"fmt"
	"math"
)

func areaRectangulo(largo int, ancho int) int {
	area := largo * ancho
	return area
}

func areaTrapecio(altura int, paraleloA int, paraleloB int) int {
	area := altura * ((paraleloA + paraleloB) / 2)
	return area
}

func areaCirculo(pi float64, radio float64) float64 {
	area := pi * math.Pow(radio, 2)
	return area

}

func main() {
	areaRec := areaRectangulo(20, 50)
	areaTra := areaTrapecio(100, 50, 70)
	areaCir := areaCirculo(math.Pi, 43.96)

	fmt.Println("El area del rectangulo es: ", areaRec)
	fmt.Println("El area del trapecio es: ", areaTra)
	fmt.Println("El area del circulo es: ", areaCir)
}

package main

import "fmt"
import “math”

func areaRect(l1, l2 int){
areaR := l1 * l2
fmt.Println(“el areal del rectangulo es:”, areaR)
}
func areaTrap(a, b, h int){
areaT := ((a+b)h)/2
fmt.Println(“el area del trapecio es:”, areaT)
}
func areaCirc(r int){
const pi = 3.1415
areaC := pimath.Pow(float64®, 2)
fmt.Println(“El area del circulo es:”, areaC)

}

func main() {
areaRect(5,2)
areaTrap(2,2,4)
areaCirc(25)
}

Reto sobre funciones completado, me parece super bien aprender a separar las cosas mediante funciones

package main

import (
	"fmt"
	"math"
)

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

func areaOfTrapezoid(base, baseAbajo, altura float64) float64 {
	return altura * (base * baseAbajo) / 2
}
func areaOfCircle(radio int) float64 {
	return (math.Pi * math.Pow(float64(radio), 2))
}
func main() {
	fmt.Println("=========EJERCICIOS DE FUNCIONES=======")
	// Calcular el area de un rectangulo
	base := 4
	altura := 2
	arearectangle := areaOfRectangle(float64(base), float64(altura))
	fmt.Printf("El area de un rectangulo es %f\n", arearectangle)

	// Calcular el area de un Trapecio
	base = 3
	baseBottom := 2
	altura = 5
	areaTrapezoid := areaOfTrapezoid(float64(base), float64(baseBottom), float64(altura))
	fmt.Printf("El area de un Trapzoide es: %f\n", areaTrapezoid)

	// Calcular el area de un circulo
	radio := 2
	areaCircle := areaOfCircle(radio)
	fmt.Printf("El area de un circulo es: %f\n", areaCircle)
}
 

Funciones anónimas

func mapX(x int, f func(int) int) int {
	return f(x)
}

func makeFunction(x int) func(int) int {
	return func(i int) int {
		return x * i
	}
}

func wrapFunction(x int) func(int) func() int {
	return func(i int) func() int {
		return func() int {
			return makeFunction(x)(i)
		}
	}
}

func main() {
	var result int

	result = mapX(10, func(i int) int {
		return i * 2
	})

	result = mapX(result, func(i int) int {
		return i * i
	})

	fmt.Printf("Result: %v\n", result)

	value := 10

	doubledValue := makeFunction(value)(2)
	squaredValue := makeFunction(value)(value)

	fmt.Println("Doubled:", doubledValue, "Squared:", squaredValue)

	squared := wrapFunction(200)(200)()
	fmt.Println("Squared from wrapFunction:", squared) // 40000
}

func calculaAreaRectangulo(a int, b int) (c int) {
return a * b
}

func main() {

areaRectangulo := calculaAreaRectangulo(10, 20)
fmt.Println("El Area del Rectangulo es:", areaRectangulo)

}

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)

}

Reto resuelto:

//Area de rectangulo
func areaRectangulo(baseRec, alturaRec int) int {
	return baseRec * alturaRec
}

//Area de trapecio
func AreaTrapecio(base1Trap, base2Trap, alturaTrap int) int {
	area := ((base1Trap + base2Trap) * alturaTrap / 2)
	return area
}
//Area de circulo
func areaCirculo(radio float64) float64 {
	areaCir := 3.1416 * radio * radio
	return areaCir
}

package main

import (
	"fmt"
	"math"
)

//Area rectagulo
func areaRectangulo(base, altura int) int {
	return base * altura

}

//Area trapecio
func areaTrapecio(baseMayor, baseMenor, alturaTrapecio float64) float64 {
	//((B+b) / 2) * h es la formula de area de un trapecio
	return ((baseMayor + baseMenor) / 2) * alturaTrapecio

}

//Area circulo
func areaCirculo(radio float64) float64 {
	return math.Round(math.Pi*math.Pow(radio, 2)*100) / 100
}

func main() {
	
	//RETO AREA DE FIGURAS GEOMETRICAS CON FUNCIONES
	//HALLAR ÁREA: rectangulo, trapecio y circulo
	//Area de rectangulo
	var areaRectangulo int = areaRectangulo(2, 3)
	fmt.Println("Área de rectangulo:", areaRectangulo)
	//Area de trapecio
	var areaTrapecio float64 = areaTrapecio(10, 7, 4)
	fmt.Println("Área de trapecio:", areaTrapecio)
	//Area de circulo
	var areaCirculo float64 = areaCirculo(4)
	fmt.Println("Área de circulo:", areaCirculo)

}

package main

import (
	"fmt"
	"math"
)

//Retos Calcular Area
//Rectangulo
func areaRectangulo(anchorectangulo int, altorectangulo int) {
	areaRectangulo := anchorectangulo * altorectangulo
	fmt.Println("Area Rectangulo:", areaRectangulo)

}
func areaTrapecio(baseMayor int, baseMenor int, alturaTrapecio int) {
	areaTrapecio := ((baseMayor + baseMenor) * alturaTrapecio) / 2
	fmt.Println("Area Trapecio:", areaTrapecio)

}

func areaCirculo(pi float64, radio float64) {

	areaCirculo := pi * math.Pow(radio, 2)
	fmt.Println("Area Circulo:", areaCirculo)

}

func main() {
	const pi = math.Pi
	areaRectangulo(3, 5)
	areaTrapecio(6, 2, 6)
	areaCirculo(pi, 4)

}

Mi reto B)

package main

import (
	"fmt"
	"math"
)

func areaTrapecio(a, b, h float64) float64 {
	area := ((a + b) / 2) * h
	return area
}
func areaCirculo(r float64) float64 {
	area := math.Pi * r * r
	return area
}
func separador() {
	fmt.Println("-----------------------------------------------------------------------")
}

func main() {
	var a, b, h float64 = 14, 20, 5
	var r float64 = 4
	aT := areaTrapecio(a, b, h)
	aC := areaCirculo(r)
	fmt.Println("Medidas del trapecio:  a, b, h = (", a, ",", b, ",", h, ") cm")
	fmt.Println("Área del trapecio:", aT, "cm^2")
	separador()
	fmt.Println("Radio del circulo", r, "cm")
	fmt.Println("Área del ciculo:", aC, "cm^2")

}

package main

import "fmt"

//FUNCTIONS
//structure
func basicFunction() {
	fmt.Println("Hello Wolrd")
}

//Parameter function
func parameterFunction(value, value2 int) {
	fmt.Println(value * value2)
}

//Returning function
func returningFunction(value, value2 int) int {
	return value * value2
}

//Double Returning function
func doubleReturningFunction(value, value2 int) (a, b int) {
	return value + value2, value * value2
}

func main() {

	basicFunction()
	parameterFunction(2, 4)
	fmt.Println(returningFunction(2, 4))
	a, b := doubleReturningFunction(2, 4)
	fmt.Println(a, b)
	//If you just want to receive one returning value
	c, _ := doubleReturningFunction(10, 1)
	fmt.Println(c)

}

• Anonymus Functions

Reto terminado:

package main

import "fmt"

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

func areaCirculo(radio float64) float64 {
	const pi float64 = 3.14
	return pi * (radio * radio)
}

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

func main() {
	// rectangulo
	rectangulo := areaRectangulo(4, 10)
	//circulo
	circulo := areaCirculo(3.455)
	//trapecio
	trapecio := areaTrapecio(14, 20, 5)

	message := fmt.Sprintf("El area del rectangulo es: %f \nEl area del circulo: %f \nEl area del trapecio %f", rectangulo, circulo, trapecio)
	fmt.Println(message)
}

package main

import (
“fmt”
“math”
)

func printMessage(msj string, result float64) {
fmt.Printf("%s %.2f\n", msj, result)
}

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() {
printMessage(“Circulo”, areaCirculo(2))
printMessage(“Rectangulo”, areaRectangulo(5, 10))
printMessage(“Trapezoide”, areaTrapezoide(10, 5, 3))
}

Yo por mi lado creé una función que calcula el área de un círculo:)

func calcCircleArea(diameter float64) string {
	radius := diameter / 2
	return fmt.Sprintf("The area is approximately: %fmm", math.Pi*(math.Pow(radius, 2)))
}

Todoooo 😄

<package main

import (
	"fmt"
)

func squareArea(side float64) float64 {
	return side * side
}

func sum(a float64, b float64) float64 {
	return a + b
}

func minus(a float64, b float64) float64 {
	return a - b
}

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

func divide(a float64, b float64) float64 {
	return a / b
}

func modulus(a int, b int) int {
	return a % b
}

func increment(value int) int {
	value++
	return value
}

func decrement(value int) int {
	value--
	return value
}

func rectangleArea(side float64, base float64) float64 {
	return side * side
}

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

func circleArea(r float64) float64 {
	const pi float64 = 3.1415
	return pi * r * r
}

func main() {
	fmt.Printf("Square Area = %.2f\n", squareArea(4))
	fmt.Printf("Sum result = %.2f\n", sum(5, 10))
	fmt.Printf("Minus result = %.2f\n", minus(5, 10))
	fmt.Printf("Multiply result = %.2f\n", multiply(20, 2.5))
	fmt.Printf("Divide result = %.2f\n", divide(150, 2))
	fmt.Printf("Remainder result = %d\n", modulus(100, 5))
	fmt.Printf("Increment result = %d\n", increment(9))
	fmt.Printf("Decrement result = %d\n", decrement(10))
	fmt.Printf("Rectangle area result = %.2f\n", rectangleArea(5, 10))
	fmt.Printf("Trapezoid area result = %.2f\n", trapezoidArea(8, 5, 2))
	fmt.Printf("Circle area result = %.2f\n", circleArea(8))
}
> 

package main

import (
“fmt”
)

func calcularCirculo(r float64) {
const pi float64 = 3.14
areaCirculo := pi * (r * r)
fmt.Println(“El area es”, areaCirculo)
}

func calcularRectangulo(a, b float64) {
areaRectangulo := a * b
fmt.Println(“El area es”, areaRectangulo)
}

func calcularTrapecio(b1, b2, h float64) {
areaTrapecio := h * (b1 + b2) / 2
fmt.Println(“El 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)
}

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 “fmt”

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(“hola 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 “fmt”

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 (
“fmt”
“math”
)

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!