Hola mundo en Go
Introducción al Curso de Golang
¿Qué es, por qué y quienes utilizan Go?
Instalar Go en Linux
Instalar Go en Mac
Instalar Go en Windows
Nuestras primeras líneas de código con Go
Variables, funciones y documentación
Variables, constantes y zero values
Operadores aritméticos
Tipos de datos primitivos
Paquete fmt: algo más que imprimir en consola
Uso de funciones
Go doc: La forma de ver documentación
Estructuras de control de flujo y condicionales
El poder de los ciclos en Golang: for, for while y for forever
Operadores lógicos y de comparación
El condicional if
Múltiple condiciones anidadas con Switch
El uso de los keywords defer, break y continue
Estructuras de datos básicas
Arrays y Slices
Recorrido de Slices con Range
Llave valor con Maps
Structs: La forma de hacer clases en Go
Modificadores de acceso en funciones y Structs
Métodos e interfaces
Structs y Punteros
Stringers: personalizar el output de Structs
Interfaces y listas de interfaces
Concurrencia y Channels
¿Qué es la concurrencia?
Primer contacto con las Goroutines
Channels: La forma de organizar las goroutines
Range, Close y Select en channels
Manejo de paquetes y Go Modules
Go get: El manejador de paquetes
Go modules: Ir más allá del GoPath con Echo
Modificando módulos con Go
Despedida del curso
Despedida
Bonus
Cheat Sheet Go
Librerías para desarrollo web con Go
Data Science con Go
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Aportes 88
Preguntas 6
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()
Una observación: En el titulo se mencionan las funciones anónimas pero no se habla de ellas 😃
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)
}
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!
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?
o inicia sesión.