Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Operadores aritméticos

8/36
Recursos

Aportes 76

Preguntas 4

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

func main() {
	// Rectángulo
	baseRectangulo := 20
	alturaRectangulo := 10

	areaRectangulo := baseRectangulo * alturaRectangulo

	fmt.Println("El Area del Rectángulo es :", areaRectangulo)

	// Circulo : AreaCirculo = pi por radio al cudrado
	const PI float64 = 3.14 // Constant
	var radioCirculo float64 = 10

	areaCirculo := PI * radioCirculo * radioCirculo

	fmt.Println("El Area del Circulo es :", areaCirculo)

	// Trapecio
	var baseUno float64 = 6
	var baseDos float64 = 15
	var alturaTrapecio float64 = 25

	areaTrapecio := ((baseUno + baseDos) * alturaTrapecio) / 2

	fmt.Println("El Area del Trapecio es :", areaTrapecio)
}

Trabajo honesto

package main

import "math"

func main() {
	// area del rectangulo
	base := 4
	altura := 2
	println("Area del rectangulo ", base * altura )

	// area del trapecio
	base = 3
	baseAbajo := 2
	areaTrapecio := altura * (base + baseAbajo) / 2
	println("Area del trapecio ", areaTrapecio)

	// area del circulo
	radio := 2
	areaCirculo := math.Pi * math.Pow(float64(radio), 2)
	println(areaCirculo)
}

  • Ejecuta tu codigo con un click en VSCode, con la extension Code Runner.

Ejecuta tu codigo.

Ejercicio de áreas:

package main

import "fmt"

func main() {

	//Constant Declaration
	const pi float64 = 3.14

	base := 12
	var height int = 14

	//Area Exercise
	base = 24
	height = 12
	fmt.Println("Rectangule area:", base*height)

	upperBase := 20
	fmt.Println("Trapeze Area: ", ((upperBase+base)*height)/2)

	var radius float64 = 5
	fmt.Println("Circle Area: ", pi2*radius)

}

Las operaciones se hacen clásicamente. + para suma, - para resta, * para multiplicación, / para división y % para módulo, También a tener en cuenta, que en python, una división, sea cuál sea el resultado, lo convierte en un flotante, en Go no.

package main

import (
	"fmt"
	"math"
)

func main() {
	//VARIABLES
  a := 10
	b := 20
  radio := 5
  h := 15

  //OPERACIONES
	rect := a*b
  circ := math.Pi*math.Pow(float64(radio),2)
  trap := ((a+b)*h)/2
	
  //RESULTADOS
	fmt.Println("Área del Rectángulo:",rect)
  fmt.Println("Área del Círculo:",circ)
  fmt.Println("Área del Trapecio",trap)
}

// Área rectángulo
	const baseRectangulo = 24
	const alturaRectangulo = 12
	areaRectangulo := baseRectangulo * alturaRectangulo
	fmt.Println("Área rectángulo:", areaRectangulo)

	// TRAPECIO
	const base_A = 24
	const base_B = 12
	const al = 6
	areaTrapecio := (base_A + base_B) * al / 2
	fmt.Println("Área trapecio:", areaTrapecio)

	// CÍRCULO
	const pipi = 3.14
	const radio = 6
	areaCirculo := pipi * (radio*radio) / 2
	fmt.Println("Área círculo:", areaCirculo)
package main

import (
	"fmt"
	"math"
)


func main (){
	fmt.Println("Hello world")

	//Area cuadrado
	const baseCuadrado = 10
	areaCuadrado := baseCuadrado * baseCuadrado

	fmt.Println("El area del cuadrado es:", areaCuadrado)

	x := 10
	y := 50

	// Suma
	result := x+y
	fmt.Println("Suma:", result)

	// Resta
	result = y-x
	fmt.Println("Resta:", result)

	// Multiplicar
	result = x*y
	fmt.Println("Multiplicacion:", result)

	// Dividir
	result = y/x
	fmt.Println("Dividision:", result)

	// Modulo 
	result = y%x
	fmt.Println("Modulo:", result)

	// Incremental
 	x++ //or assign to a var x + 1 
	fmt.Println("Incremental:", x)

	// Decremental
	x--
	fmt.Println("Decremental:", x)

	// Area triangulo rectangulo
	cateto1 := 12
	cateto2 := 26

	areaTrianguloRectangulo := (cateto1 * cateto2) / 2
	fmt.Println("Area triangulo rectangulo:", areaTrianguloRectangulo)

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

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

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

	areaTrapecio := (base + base2) * altura / 2
	println("Area trapecio:", areaTrapecio)
}


var baseUno float64 = 6
var baseDos float64 = 15
var alturaTrapecio float64 = 25

areaTrapecio := ((baseUno + baseDos) * alturaTrapecio) / 2

fmt.Println("El Area del Trapecio es :", areaTrapecio)

Les dejo esta pequeña documentación para complementar. 😄

Challenge Completed!!

	// Area de un rectángulo
	baseRectangulo := 20
	alturaRectangulo := 10
	fmt.Println("Área rectangulo = ", baseRectangulo*alturaRectangulo)

	// Área trapecio 
	base1Trapecio := 20
	base2Trapecio := 10
	alturaTrapecio := 5
	resultado = ((base1Trapecio + base2Trapecio) / 2) * alturaTrapecio
	fmt.Println("Área trapecio = ", resultado)

	// Área círculo
	var radioCirculo float64 = 10
	phi := 3.141516

	resultadoCirculo := phi * (radioCirculo * radioCirculo)
	println("Área circulo = ", resultadoCirculo)
const PI float64 = 3.1415926535
x := 10
y := 50
z := 16

// Area Rectángulo
areaRectangulo := x * y
fmt.Println(“Area Rectángulo:”, areaRectangulo)

// Area Trapecio
areaTrapecio := ((x+y) * z) / 2
fmt.Println("Area Trapecio", areaTrapecio)

// Area Círculo
diametroCirculo := z
radioCiruclo := diametroCirculo / 2
areaCirculo := PI * ((float64(radioCiruclo)) * (float64(radioCiruclo)))
fmt.Println("Area Circulo", areaCirculo)

Operadores Aritméticos


Los operadores aritméticos nos permiten realizar operaciones básicas sobre nuestras variables y constantes

  • X = 10
  • Y = 5
Operador Descripción Ejemplo
+ Suma los operandos de los extremos. X + Y resulta 15
Substrae el operando de la derecha al operando de la izquierda. X – Y resulta 5
* Multiplica los operandos de los extremos. X * Y resulta 50
/ División de el número de la izquierda (numerador) entre el número de derecha (denominador). X / Y resulta 2
% Operador modular o de residuo de división entera. X / Y resulta 0
++ Operador de incremento. Incrementa en 1 el operador de la izquierda. No permite el decremento prefijo (pre-decremento). X++ resulta 11
Operador de decremento. Decrementa en 1 el operador de la izquierda, es decir, no permite el decremento prefijo. X– resulta 9
//Rectangulo
	var base_rectangulo = 10
	var altura_rectangulo = 25
	areaRectangulo := base_rectangulo * altura_rectangulo
	fmt.Println("Area rectangulo:", areaRectangulo)

	//Trapecio
	var baseMenor = 9
	var baseMayor = 12
	var altura_trapecio = 18

	areaTrapecio := (baseMayor + baseMenor / 2) * altura_trapecio
	fmt.Println("Area Trapecio:", areaTrapecio)

	//Círculo
	var radio = 7.5
	areaCirculo := pi * (radio * radio)
	fmt.Println("Area círculo", areaCirculo)

tuve que googlear como multiplicar un valor con decimal con entero. lo demas lo hice solo 😃

tambien se puede poner como constante el area del circulo pero me gusta complicarme xD

package main

import (
	"fmt"
	"math"
)

func main() {
	//declaracion de constante
	const pi float64 = 3.14
	const pi2 = 3.145

	//fmt.Println("El valor de Pi es: y pi2 es:", pi, pi2)
	//fmt.Println(pi, pi)
	// fmt.Println("p1:", pi)
	// fmt.Println("p2:", pi2)

	//declaracionde variables entera
	base := 12
	var altura int = 14
	var area int
	fmt.Println(base, altura, area)

	//Zero Value
	var a int
	var b float64
	var c string
	var d bool

	fmt.Println(a, b, c, d)

	//Area de un cuadrado
	const baseCuadrado = 10
	areaCuadrado := baseCuadrado * baseCuadrado
	fmt.Println("Area Cuadrado:", areaCuadrado)

	x := 10
	y := 50

	//Suma
	result := x + y
	fmt.Println("La Suma es:", result)
	//Resta
	result = y - x
	fmt.Println("La Resta es:", result)

	//Multiplicaicon
	result = x * y
	fmt.Println("La Multiplicaicon es:", result)

	//Division
	result = y / x
	fmt.Println("La Division es:", result)

	//Modulo ó Residuo
	result = y % x
	fmt.Println("El Residuo es:", result)

	//Incremental
	x++
	fmt.Println("incremental es:", x)

	//Decremental
	x--
	fmt.Println("incremental es:", x)

	//Reto Calcular Area del Rectangulo
	//Base * Altura
	base = 10
	altura = 6
	result = base * altura

	fmt.Println("Base de Triangulo es ", base)
	fmt.Println("Altura de Triangulo es ", altura)
	fmt.Println("El Area del Triangulo es ", result)

	//Reto Calcular Area del Trapecio
	//El área del trapecio es igual a la suma de las bases por la altura, y dividido por dos.
	base = 10
	base2 := 4
	altura = 4
	result = (base + base2) * altura / 2
	fmt.Println("Base N° 1 del trapecio  es ", base)
	fmt.Println("Base N° 2 trapecio es ", altura)
	fmt.Println("Altura del trapecio es ", altura)
	fmt.Println("El Area del Trapecio  es ", result)

	//Reto Calcular Area del Circulo
	//El área del Circulo es area * area * pi
	area = 25
	var resultOfCirculo float64 = math.Ceil(float64(area*area) * pi)
	fmt.Println("El Area del Circulo  es ", resultOfCirculo)

}

Me pregunté qué pasaba con el pre-decremento/incremento, y resulta que go no lo tiene.

Según un usuario en SO, esto es así para evitar la confusión entre los operadores de pre y post decremento/incremento de otros lenguajes.

Tarea:

var altura int = 5
	var longitudA int = 6
	var longitudB int = 7
	var radio int = 9

	areaTrapecio := altura * ((longitudA + longitudB) / 2)
	areaRectangulo := altura * longitudA
	areaCirculo := math.Pi * math.Exp2(float64(radio))
	
	fmt.Println("Area Trapecio: ", areaTrapecio)
	fmt.Println("Area Rectangulo : ", areaRectangulo)
	fmt.Println("Area Circulo : ", areaCirculo)

Apuntes de clase:

var x int = 5
	var y int = 6
	result := x + y
	fmt.Println("sum: ", result)

	//Resta
	result = y - x
	fmt.Println("subtract: ", result)

	//Multiplicación
	result = y * x
	fmt.Println("Multiply: ", result)

	//División
	result = y / x
	fmt.Println("Division: ", result)

	//Modulo
	result = y % x
	fmt.Println("Modulo: ", result)

	//Incrementar
	x++
	fmt.Println("Incrementar x: ", x)

	//Decrementar
	x--
	fmt.Println("Decrementar: ", x)

Les dejo mi solución al reto:

package main

import "fmt"

func circuleArea() {
	pi := 3.1416
	radius := 15.43
	resutl := pi * (radius * radius)

	fmt.Println("El área del círuclo es: ", resutl)

}

func trapezoidArea() {
	a := 2
	b := 300
	h := 520
	resutl := (a + b) * h

	fmt.Println("El área del trapecio es: ", resutl)

}

func squareArea() {
	x := 15
	result := x * x

	fmt.Println("El área del cuadrado es: ", result)

}

func main() {
	// Cálcular el área de un cuadrado, trapecio y un círculo.
	squareArea()
	trapezoidArea()
	circuleArea()

}

Mi solucion al reto:

//RETOS DE AREA
	//Rectangulo - Base*Altura
	baserectangulo := 10
	alturarectangulo := 5
	arearectangulo := baserectangulo * alturarectangulo

	fmt.Println("El area del rectangulo es:", arearectangulo)

	//Trapecio -((Base+BaseMayor)*altura)/2
	basetrapecio := 15
	baseMtrapecio := 20
	alturatrapecio := 4
	areatrapecio := ((basetrapecio + baseMtrapecio) * alturatrapecio) / 2

	fmt.Println("El area del trapecio es:", areatrapecio)

	//Circulo -radio a la dos * PI
	const PI float64 = 3.14
	var radiocicurlo float64 = 5
	areaCirculo := PI * (math.Pow(radiocicurlo, 2))

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

Brutal.

package main

import (
	"fmt"
	"math"
)

func main() {

	var base int
	var base2 int
	var altura int
	var radio float64
	const pi float64 = 3.14

	// Area de un rectangulo

	base = 10
	altura = 12

	result := base * altura

	fmt.Println("El area del rectangulo es: ", result)

	// Area de un Trapecio

	base = 10
	base2 = 4
	altura = 4

	result = (base + base2) * altura / 2

	fmt.Println("El area del Trapecio es: ", result)

	// Area de un Circulo


	radio = 12
	areaCirculo := math.Pi * math.Pow(float64(radio), 2)

	fmt.Println("El area del circulo es: ", areaCirculo)
// - Área rectángulo

baseRectangulo := 10
alturaRectangulo := 50
fmt.Println("Área total del rectángulo:", baseRectangulo*alturaRectangulo)

// - Área trapecio

baseMenor := 10
baseMayor := 50
alturaTrapecio := 10

BasesTrapecio := baseMenor + baseMayor
fmt.Println("Área total del trapecio:", BasesTrapecio*alturaTrapecio/2)

// - Área círculo

piCirculo := 3.1415
radio := math.Pow(50, 2)

totalCirculo := piCirculo * radio

fmt.Println("Área total del círculo:", totalCirculo)
package main

import "fmt"

func main() {

	// Declaración de constantes

	const pi float64 = 3.14
	const pi2 = 3.1415

	fmt.Println("PI", pi)
	fmt.Println("PI2", pi2)

	// Declaración de variables enteras

	base := 12
	var altura int = 14
	var area int

	fmt.Println(base, altura, area)

	// Zero values
	var a int
	var b float64
	var c string
	var d bool

	fmt.Println(a, b, c, d)

	// Area de un cuadrado

	const baseCuadrado = 10
	areaCuadrado := baseCuadrado * baseCuadrado

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

	x := 10
	y := 50

	// Suma
	result := x + y

	fmt.Println("Suma: ", result)

	// Resta
	result = x - y

	fmt.Println("Resta: ", result)

	// Multiplicación
	result = x * y

	fmt.Println("Multiplicación: ", result)

	// División
	result = y / x

	fmt.Println("División: ", result)

	// Modulo
	result = y % x
	fmt.Println("Modulo: ", result)

	//Incremental
	x++

	fmt.Println("Incremental :", x)

	//Decremental
	y--

	fmt.Println("Decremental :", y)

}

Puedes concatenar los string del print asi:

fmt.Println(x, ¨/¨, y, ¨equals to: ¨, result)
package main

import (
	"fmt"
	"math"
)

func areas() {
	var base int = 2
	var altura int = 10
	fmt.Println("Area de un rectangulo: ", base*altura)
	var baseAbajo int = 20
	fmt.Println("Area de un Trapecio: ", ((base+baseAbajo)/2)*altura)
	var diametro int = 10
	fmt.Println("Area de un Trapecio: ", math.Pi*math.Pow(float64(diametro/2), 2))

}

func main() {

	areas()
}

	//Reto Area Rectangulo a=b*h
	base := 30
	altura := 10
	result = base * altura
	fmt.Println("Area rectangulo:", result)
	//Reto Area trapecio a=((B+b)*h)/2
	B := 30
	b := 10
	h := 12
	result = ((B + b) * h) / 2
	fmt.Println("Area trapecio", result)
	//Reto Area circulo a=Pi*r^2
	pi := math.Pi
	radio := 5
	area_circulo := pi * (math.Pow(float64(radio), 2))

	fmt.Println("Area circulo", area_circulo)

Resolución de los retos

package main

import (
	"fmt"
	"math"
)

func main() {
	// Retos

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

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

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

func main() {

// Area de un rectángulo
const baseR = 10
const alturaR = 5
areaR := alturaR * baseR
fmt.Println("El Área del rectángulo es:", areaR, "m2")

// Area de un triángulo
const baseT = 10
const alturaT = 5
areaT := (baseT * alturaT) / 2
fmt.Println("El Área del triángulo es:", areaT, "m2")

// Area de un círculo
const diam = 10
const radio = diam / 2
areaC := pi2 * (radio * radio)
fmt.Println("El Área del círculo es:", areaC, "m2")

// Area de un trapecio
const baseTra1 = 10
const baseTra2 = 6
const alturaTra = 2
areaTra := alturaTra * ((baseTra1 + baseTra2) / 2)
fmt.Println("El Área del trapecio es:", areaTra, "m2")

}
package main

import (
	"fmt"
	"math"
)

func main() {
	// Calcular area de un cuadrado
	const base_cuadrado = 10
	areaCuadrado := base_cuadrado * base_cuadrado
	fmt.Println("Area del Cuadrado es:", areaCuadrado)

	x := 10
	y := 50

	// Suma
	result := x + y
	fmt.Println("Suma", result)

	//Resta
	result = y - x
	fmt.Println("Resta", result)

	//Multiplicacion
	result = x * y
	fmt.Println("Multiplication", result)

	//Division
	result = y / x
	fmt.Println("Division", result)

	//Modulo
	result = y % x
	fmt.Println("Residuo", result)

	//Incremental
	x++
	fmt.Println("Incremental", x)

	//Decrecion
	x--
	fmt.Println("Decremental", x)

	//Area rectangulo
	// a = b x h
	base_rectangulo := 10
	altura_rectangulo := 15
	area_rectangulo := base_rectangulo * altura_rectangulo
	fmt.Println("Area rectangulo:", area_rectangulo)

	//Area trapecio
	// a = ((b+b)/2)*h
	base_mayor := 30
	base_menor := 20
	altura_trapecio := 10
	area_trapecio := ((base_mayor + base_menor) / 2) * altura_trapecio
	fmt.Println("Area trapecio:", area_trapecio)

	//Area circulo
	// a = pi x r^2
	pi := math.Pi
	radio := 20.0
	var area_circulo float64 = pi * math.Pow(2, radio)
	fmt.Println("Area circulo", area_circulo)
}

// Area de un rectangulo
	const baseRectangulo = 3
	const alturaRectangulo = 5
	areaRectangulo := baseRectangulo * alturaRectangulo

	fmt.Println("Área rectangulo: ", areaRectangulo)

	// Area de un trapecio
	const baseSuperiorTrapecio = 4
	const baseInferiorTrapecio = 10
	const alturaTrapecio = 5
	areaTrapecio := (baseInferiorTrapecio + baseSuperiorTrapecio) * 4 / 2

	fmt.Println("Área trapecio: ", areaTrapecio)

	// Area de un circulo
	const radioCirculo = 19
	areaCirculo := math.Pi * math.Pow(radioCirculo, 2)

	fmt.Println("Área circulo: ", areaCirculo)
func main() {

	// Area cuadrado
	const baseCuadrado int = 10
	areaCuadrado := baseCuadrado * baseCuadrado
	fmt.Println("El area del cuadrado es ", areaCuadrado)

	// Area rectangulo
	const baseRectangulo int = 30
	const alturaRectangulo int = 4
	areaRectangulo := baseRectangulo * alturaRectangulo
	fmt.Println("El area del rectangulo es ", areaRectangulo)

	// Area trapecio
	const baseMenorTrapecio int = 10
	const baseMayorTrapecio int = 15
	const alturaTrapecio int = 12
	areaTrapecio := ((baseMayorTrapecio + baseMenorTrapecio) / 2) * alturaTrapecio
	fmt.Println("El area del trapecio es ", areaTrapecio)

	// Area circulo
	const pi float64 = 3.14
	const radio = 10
	areaCirculo := pi * math.Pow(radio, 2)
	fmt.Println("El area del circulo es ", areaCirculo)

}

Mi solución al reto:

	//Retos
	//Calcular el área de un rectángulo, trapecio y de un círculo

	// ---> Calculando el área de un reactángulo
	var largo int = 3
	var ancho int = 5
	var areaRectángulo int = largo * ancho
	fmt.Println("El área del rectángulo es: ", areaRectángulo)

	// ---> Calculando el área de un círculo
	var radio float64 = 4
	var pi float64 = 3.1416
	var areaCirculo float64 = pi * radio * radio
	fmt.Println("El área del círculo es: ", areaCirculo)

	// ---> Calculando el área de un trapecio
	var baseMayor int = 5
	var baseMenor int = 3
	var altura int = 5
	var areaTrapecio = (baseMayor + baseMenor) * (altura / 2)
	fmt.Println("El área del trapecio es: ", areaTrapecio)

Aquí respuesta:

	//Calcular el área de rectángulo, trapecio y círculo
	//Rectángulo
	baseRectangulo := 40
	alturaRectangulo := 15
	result = baseRectangulo * alturaRectangulo
	fmt.Println("Área de rectángulo: ", result)

	//Trapecio
	base1Trapecio := 40
	base2Trapecio := 30
	alturaTrapecio := 25
	result = ((base1Trapecio * base2Trapecio) * alturaTrapecio) / 2
	fmt.Println("Área de trapecio: ", result)

	//Círculo
	diametroCirculo := 20
	radioCirculo := diametroCirculo / 2
	areaCirculo := pi * float64(radioCirculo*radioCirculo)
	fmt.Println("Área de círculo: ", areaCirculo)

Mi aporte

// Area del rectangulo
	baseRectangulo := 15
	alturaRectangulo := 12
	fmt.Println("El area del rectangulo con base 15 y altura 12 es -> ", baseRectangulo*alturaRectangulo)

	// Area del trapecio
	var baseMenorTrapecio float64 = 3.5
	var baseMayorTrapecio float64 = 9.5
	var alturaTRapecio int = 4
	var areaTrapecio float64 = ((baseMayorTrapecio + baseMenorTrapecio) / 2) * float64(alturaTRapecio)
	fmt.Println("Base de un trapecio", " con base menor ", baseMenorTrapecio, ", base mayor", baseMayorTrapecio, "y altura", alturaTRapecio, "-> ", areaTrapecio)

	// Area de un circulo
	var radioCirculo int = 12
	areaCirculo := pi * float64(radioCirculo)

	fmt.Println("EL area del circulo con radio ", radioCirculo, "es -> ", areaCirculo)

😃

// Challenge
// Area Rectangle
length := 10
width := 5

result = length * width
fmt.Println("Rectangle Area =", result)

// Area Trapezium
base1 := 10
base2 := 5
height := 3

result = (base1 * base2 / 2) * height
fmt.Println("Trapezium Area =", result)

// Area circle
radius := 8.88
var circleArea float64
const piValue float64 = 3.141516

circleArea = radius * piValue
fmt.Println("Cicle Area =", circleArea)

Reto

package main

import (
	"fmt"
)

func main() {

	//Area de un Rectángulo

	base := 12
	altura := 6
	AreaR := base * altura
	fmt.Println("El Area del rectangulo es:", AreaR)

	//Area de un Trapecio
	base = 4
	baseMayor := 10
	altura = 4
	AreaT := ((base + baseMayor) * altura) / 2
	fmt.Println("El Area del trapecio es:", AreaT)

	//Area de un Circulo
	radio := 2.1
	const pi = 3.14
	AreaC := pi * (radio * radio)
	fmt.Println("El Area del Circulo es:", AreaC)

}

package main

import (
	"fmt"
	"math"
)

func main() {
	// Area del rectángulo
	const r_base int = 10
	const r_height int = 20
	var r_area = r_base * r_height
	fmt.Println("Area del rectángulo:", r_area)

	// Area del trapecio
	const t_base1 int = 10
	const t_base2 int = 20
	const t_height int = 15
	var t_area = ((t_base1 + t_base2) / 2) * t_height
	fmt.Println("Area del trapecio:", t_area)

	// Area del círculo
	const radio float64 = 5
	var c_area float64 = (radio * radio) * math.Pi
	fmt.Println("Area del círculo:", c_area)
}

//area de un circulo
	const pi float64 = 3.14
	radioCirculo := 4
	areaCirculo := pi * (float64(radioCirculo) * float64(radioCirculo))
	fmt.Println("area del circulo ", areaCirculo)

lo interesante es al realizar la operación areaCirculo, go detecta que en la operación existe **pi **que es de tipo **float **y automaticamente al resto de variables de la formula le agrega float64, es decir := determinar que tipo de variable se esta utilizando.

Reto

	//Reto
	//Area de un rectangulo, trapecio y circulo

	//Rectángulo
	var baseRectangulo uint8 = 12
	var alturaRectangulo uint8 = 4

	areaRectangulo := baseRectangulo * alturaRectangulo

	fmt.Println("Base del rectangulo: ",areaRectangulo)

	//Trapecio
	var baseSuperiorTrapecio uint8 = 6
	var baseInferiorTrapecio uint8 = 10
	var alturaTrapecio uint8 = 8

	areaTrapecio := alturaTrapecio * ((baseInferiorTrapecio + baseSuperiorTrapecio ) / 2)

	fmt.Println("Área del trapecio: ",areaTrapecio)

	//Circulo
	var radioCirculo float64 = 2.5
	areaCirculo := pi * (radioCirculo * radioCirculo)

	fmt.Println("El área del circulo es: ",areaCirculo)

Intente ordenarlo un poco utilizando funciones.

package main
import "fmt"
import "math"

func main() {
    area_rectangulo := areaRectangulo(20,20,5)
    area_circulo := areaCirculo(20)
    fmt.Println("AREA DEL RECTANGULO ",area_rectangulo)
    fmt.Println("AREA DEL CIRCULO ",area_circulo)

}

func areaRectangulo(B int, b int, h int) int {
    a:= ((B + b) / 2 ) * h
    return a
}

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

Calculando las areas

// area rectangle
sideOne := 15
sideTwo := 7
rectangleArea := sideOne * sideTwo
fmt.Println("Rectangle Area:", rectangleArea)

// area trapeze
trapezeBaseUp := 10
trapezeBaseDown := 10
trapezeHeight := 10
trapezeArea := ((trapezeBaseUp + trapezeBaseDown) * trapezeHeight) / 2
fmt.Println("Trapeze Area:", trapezeArea)

// area circle
radio := 10.0
circleArea := pi * radio * radio
fmt.Println("Circle Area:", circleArea)

Comparto mi código del reto

// Retos //

	// Area of a rectangle //
	base := 4.5
	height := 5.5

	fmt.Println("El Área del rectangulo es:", base * height)

	// Area of a trapeze //
	base1 := 4
	base2 := 6
	heightTrapeze := 3
	trapezeArea := (base1 + base2) * heightTrapeze / 2

	fmt.Println("El Área del trapecio:", trapezeArea)

	// Area of a circle //

	const pi float64 = 3.141516
	radio := 5.0

	fmt.Println("El Área del círculo es:", pi * radio * radio)

Incrementar es como en muchos lenguajes: ++, y también para dercrementar --

La división de go, es exacta de por sí.

No tenemos que poner dos puntos a la hora de reasignar a una variable que declaramos con dos puntos.

Es muy sencillo declarar e inicializar en la misma linea, lo interesante, es que tu puedes reasignar valores sin necesidad de inicializar de nuevo la variable, pero tiene que estar ya inicializada.

Los operadores aritméticos en Go, son extremadamente fáciles.

	// Rectangle
	var r_base int = 10
	var r_altura int = 11
	var r_area int = r_base * r_altura
	fmt.Println("Area del Rectangulo: ", r_area)

	// Trapeze
	var t_altura int = 12
	var t_base_a int = 22
	var t_base_b int = 10
	t_area := ((t_base_a + t_base_b) / 2) * t_altura
	fmt.Println("Area del Trapecio: ", t_area)

	// Circle
	var c_radio int = 35
	var c_area float64 = math.Round((math.Pow(float64(c_radio), 2)*math.Pi)*100) / 100
	fmt.Println("Area del Circulo: ", c_area)```

En mi caso quise usar la librería math en el calculo del área del circulo

package main

import (
	"fmt"
	"math"
)

func main() {
	// Área rectángulo
	baseRectangulo := 20
	alturaRectangulo := 10
	areaRectangulo := baseRectangulo * alturaRectangulo

	fmt.Println("El área del rectángulo es:", areaRectangulo)

	// Área trapecio
	baseMayor := 6
	baseMenor := 15
	alturaTrapecio := 25
	areaTrapecio := (baseMayor + baseMenor) * alturaTrapecio / 2
	
	fmt.Println("El área del trapecio es:", areaTrapecio)

	// Área circulo
	radio := 2.0
	areaCirculo := math.Pi * math.Pow(radio, 2.0)
	// Se utiliza math.Round para aproximar el área del circulo, la multiplicación y división por 100 es para que se muestre con dos decimales
	fmt.Println("El área del circulo  es:", math.Round(areaCirculo * 100) / 100)
}

Les comparto el reto:

var area1 int = 14
var area2 int = 20
var alt int = 5
result = area1 + area2/2*alt
fmt.Println("El area del trapecio es:", result, "cm")

Mi solucion al reto 😄

// RECTANGULO
lado_a := 10
lado_b := 5
area_rectangulo := lado_a * lado_b

// TRAPECIO
var base_larga_trapecio float64 = 15
var base_corta_trapecio float64 = 12
var altura_trapecio float64 = 6
area_trapecio := ((base_larga_trapecio + base_corta_trapecio) / 2) * altura_trapecio

// CIRCULO
var radio_circulo float64 = 3
var area_circulo float64 = math.Floor((math.Pi*radio_circulo*radio_circulo)*100) / 100

// PRINTS
fmt.Println("Rectangulo:", area_rectangulo)
fmt.Println("Trapecio:", area_trapecio)
fmt.Println("Circulo:", area_circulo)

// Golang program to show how
// to take input from the user
package main

import “fmt”

// main function
func main() {

// Println function is used to
// display output in the next line
fmt.Println("Lado del Rectangulo: ")

// var then variable name then variable type
var first int

// Taking input from user
fmt.Scanln(&first)
fmt.Println("Lado del Rectangulo: ")
var second int
fmt.Scanln(&second)

// Print function is used to
// display output in the same line
fmt.Print("La Area del rectangulo es: ")

// Addition of two string
fmt.Print(first * second)

}

Adjunto mi Código del Reto

package main

import "fmt"

func main() {

	fmt.Printf("%-55s", fmt.Sprintf("%55s", "RETOS\n\n\n"))
	//Circulo
	var Radio float64 = 15
	var Pi float64 = 3.1416

	resultC := Pi * (Radio * Radio)

	fmt.Println("1)\nCalcula el Area de un circulo si su radio es: ", Radio)
	fmt.Print("El Area del circulo es: ", resultC, "\n")

	fmt.Println("\n------------------------------------------------")

	//Triangulo
	BaseT := 9
	AlturaT := 6

	resultT := (BaseT * AlturaT) / 2
	fmt.Println("\n\n2)\nCalcula el Area de un triangulo si su base es: ", BaseT, "y su altura es :", AlturaT)
	fmt.Print("El Area del triangulo es: ", resultT, "\n")

	fmt.Println("\n------------------------------------------------")

	//Rectangulo
	BaseR := 175
	AlturaR := 98
	resultR := BaseR * AlturaR

	fmt.Println("\n\n3)\nCalcula el Area de un rectangulo si su base es: ", BaseR, "y su altura es :", AlturaR)
	fmt.Print("El Area del rectangulo es: ", resultR, "\n\n\n")

	fmt.Print("©               ( ( (\n")
	fmt.Print("ル               ) ) )\n")
	fmt.Print("ク              ( ( (\n")
	fmt.Print("サ            '. ___ .'\n")
	fmt.Print("チ           '  (> <)  '\n")
	fmt.Print("ャ   --------ooO-(_)-Ooo----------\n")
	fmt.Print("®      © Creado por Ruku Sacha ®\n")

}

Y así se imprime en la consola

Aqui el reto 😄
//Area Rectangulo
baseRectangulo := 5
alturaRectangulo := 10
areaRectangulo := baseRectangulo * alturaRectangulo

fmt.Println("Area de un rectangulo:", areaRectangulo)

//Area de un trapecio

var baseUno int = 13
var baseDos float64 = 16.5
var alturaTrapecio int

alturaTrapecio = 5

var areaTrapecio int = ((baseUno + int(baseDos)) * alturaTrapecio) / 2

fmt.Println("Area de un trapecio:", areaTrapecio)

// Area de un circulo
var radioCirculo float64
radioCirculo = 4.5
AreaCirculo := pi * (radioCirculo * radioCirculo)

fmt.Println("Area de un circulo:", AreaCirculo)
// Rectangle
	rectangleBase := 150
	rectangleHeight := 18

	rectangleArea := rectangleBase * rectangleHeight
	fmt.Println("Rectangle area:", rectangleArea)

	// Trapezoid
	trapezoidLongBase := 15
	trapezoidShortBase := 7
	trapezoidHeight := 9

	trapezoidArea := ((trapezoidLongBase + trapezoidShortBase) / 2) * trapezoidHeight
	fmt.Println("Trapezoid area:", trapezoidArea)

	// Circle
	const PI float64 = 3.1415
	circleRadius := 5

	circleArea := PI * float64(circleRadius) * float64(circleRadius)
	fmt.Println("Circle area:", circleArea)

Mi solución del ejercicio

package main

import "fmt"

func main()  {

	/* Retos
	Calcular el área de:
	Rectángulo
	Trapecio
	Círculo
	*/

	/* Aŕea del Rectángulo
		Fórmula = b*h
	*/
	baseRectangulo := 6
	alturaRectangulo := 10

	fmt.Println("Área Rectángulo:",baseRectangulo*alturaRectangulo)

	/* Aŕea del Trapecio
		Fórmula = h * a+b/2
	*/
	alturaTrapecio := 5
	aTrapecio := 3
	bTrapecio := 8
	areaTrapecio := alturaTrapecio * (aTrapecio+bTrapecio)/2
	fmt.Println("Área Trapecio:",areaTrapecio)

	/* Aŕea del Círculo 
		Fórmula = pi * r**2
	*/
	pi := 3.1416
	radioCirculo := 2
	areaCirculo := pi * (float64(radioCirculo)*float64(radioCirculo))
	fmt.Println("Área Círculo:",areaCirculo)
}

Mi pequeño aporte.

package main
import "fmt"

func main() {
	//Area de un circulo
	const pi float64 = 3.1416
	var radio float64 = 10
	AreaCircular := pi*(radio*radio)
	fmt.Println("area del circulo: ",AreaCircular)
	//Area de trapecio
	var Bmayor float64 = 15
	var Bmenor float64 = 12
	var altura float64 = 6
	AreaTrapecio := ((Bmayor+Bmenor)/2)*altura
	fmt.Println("area del trapecio: ",AreaTrapecio)
	//Area del rectangulo
	var base float64 = 12
	AreaRectangulo := base*altura
	fmt.Println("area del rectagulo: ",AreaRectangulo)
}```

¡Mi solución!

	const altura2 int = 4
	const base2 int = 7
	areaRectangulo := altura2 * base2
	fmt.Println("Área rectángulo: ", areaRectangulo)

	const base3 int = 2
	const base4 int = 8
	const altura3 int = 10
	areaTrapecio := ((base3 + base4) * altura3) / 2
	fmt.Println("Área trapecio: ", areaTrapecio)

	const PI float64 = 3.14
	const radio float64 = 5.0
	areaCirculo := pi * (radio * radio)
	fmt.Println("Área círculo: ", areaCirculo)
```go

Comparto la forma en la que realicé el reto 😃

package main

import "fmt"

func main() {
	// Área del rectángulo
	baseRectangulo := 10
	alturaRectangulo := 7
	areaRectangulo := baseRectangulo * alturaRectangulo
	fmt.Println("Área del rectángulo:", areaRectangulo)

	// Área del trapecio
	BaseTrapecio := 25
	baseTrapecio := 15
	alturaTrapecio := 10
	areaTrapecio := ((BaseTrapecio + baseTrapecio) * alturaTrapecio) / 2
	fmt.Println("Área del trapecio:", areaTrapecio)

	// Área del círculo
	const pi float64 = 3.1416
	const radio float64 = 50
	const areaCirculo float64 = pi * (radio * radio)
	fmt.Println("Área del círculo:", areaCirculo)
}

CODIGO:

package main

import "fmt"

func main() {
	// Area de un Rectangulo
	rectBase := 30.0
	rectHigh := 10.0
	rectArea := rectBase * rectHigh
	fmt.Printf("\nRectangle:\n  base = %.2f\n  high = %.2f\n  area = %.2f\n",
		rectBase, rectHigh, rectArea)

	// Area de un Trapecio
	trapTop := 30.0
	trapBase := 50.0
	trapHigh := 20.0
	trapArea := (trapTop+trapBase)/2 * trapHigh
	fmt.Printf("\nTrapeze:\n  top = %.2f\n  base = %.2f\n  high = %.2f\n  area = %.2f\n",
		trapTop, trapBase, trapHigh, trapArea)

	// Area de un Circulo
	pi := 3.14
	circleRadio := 15.0
	circleArea := pi * circleRadio * circleRadio
	fmt.Printf("\nCircle:\n  pi = %.2f\n  radio = %.2f\n  area = %.2f\n\n",
		pi, circleRadio, circleArea)
} 

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.50

Mi solución al reto:

package main

import "fmt"

func main() {
	// Rectángulo
	var baseRectangulo float64 = 17.7
	var alturaRectangulo float64 = 5.2

	var areaRectangulo float64 = baseRectangulo * alturaRectangulo
	fmt.Println("Con base de:", baseRectangulo)
	fmt.Println("Con altura de:", alturaRectangulo)
	fmt.Println("Area del Rectangulo:", areaRectangulo)
	fmt.Println("")

	// Trapecio
	var baseMayor float64 = 13.7
	var baseMenor float64 = 9.2
	var alturaTrapecio float64 = 5

	var areaTrapecio float64 = ((baseMayor + baseMenor) * alturaTrapecio) / 2
	fmt.Println("Con base mayor de:", baseMayor)
	fmt.Println("Con base menor de:", baseMenor)
	fmt.Println("Con altura de:", alturaTrapecio)
	fmt.Println("Area del Trapecio:", areaTrapecio)
	fmt.Println("")

	// Círculo
	const pi float64 = 3.14159
	var rad float64 = 1.5

	var areaCirculo float64 = rad * rad * pi
	fmt.Println("Con rádio de:", rad)
	fmt.Println("Area del circulo:", areaCirculo)
}

func main() {
	var area float64
	const pi = 3.14152
	// Calculate rectangle area
	var base float64 = 123
	var height float64 = 3
	area = base * height
	fmt.Println("Rectangle area: ", area)

	// Calculate triangle area
	base = 123
	height = 32
	area = base * height / 2
	fmt.Println("Triangle area: ", area)

	// Calculate circle area
	var radio float64 = 3
	area = pi * (radio * radio)
	fmt.Println("Circle area: ", area)

}

Aquí la solución al reto:

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

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

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

func main() {
	//var_declaration()
	//arithmetic_operators()
	fmt.Println("Rectangle area:", area_rectangle(3, 4))
	fmt.Println("Trapezoid area:", area_trapezoid(6, 12, 4))
	fmt.Println("Circle area:", area_circle(7))

}

He aquí mi solución al reto 🥳

	//Retos
	//Rectángulo
	ancho := 12
	largo := 24

	areaRect := ancho * largo
	fmt.Println("El área de un rectángulo de ancho:", ancho, "y largo:", largo, "es:", areaRect)

	//Trapecio
	baseMenor := 18
	baseMayor := 24
	altura := 5

	areaTrap := ((baseMayor + baseMenor) / 2) * altura
	fmt.Println("El área de un trapecio con base Mayor de:", baseMayor, "base menor:", baseMenor, "y altura:", altura, "es:", areaTrap)

	//Círculo
	var radio float64 = 10
	const pi float64 = 3.1415

	areaCirculo := pi * ((radio * radio) / 2)
	fmt.Println("Él área de un cículo de radio:", radio, "es:", areaCirculo)```
package main

import (
	"fmt"
)

func main() {

	//Area Rectangulo
	baseR := 10
	alturaR := 10
	areaR := baseR * alturaR
	fmt.Println("Area Rectangulo: ", areaR)

	//Area Trapecio
	baseMayor := 10
	baseMenor := 5
	alturaT := 6
	areaT := ((baseMayor + baseMenor) / 2) * alturaT
	fmt.Println("Area Trapecio: ", areaT)

	//Area Circulo
	const pi float64 = 3.141516
	var radio float64 = 4.0
	areaC := pi * radio * radio
	fmt.Println("Area circulo", areaC)
}
package main

import "fmt"

func main() {
	//Declaracion de constantes
	const pi float64 = 3.14
	const pi2 = 3.16

	fmt.Println("Pi:", pi)
	fmt.Println("Pi2:", pi2)

	//Declaracion de variables
	base := 12            //Primera forma
	baseM := 10           //Se agrega por ejercicio de trapecio
	var radio float64 = 4 //Se agrega por ejercicio de círculo
	var altura int = 14   //Segunda forma
	var area int          //Go no compila si las variables no son usadas

	fmt.Println(base, altura, area)

	//Zero values
	//Go asigna valores a variables vacías
	var a int
	var b float64
	var c string
	var d bool

	fmt.Println(a, b, c, d)

	//Ejercicio
	//Calcular el área del cuadrado
	const baseCuadrado = 10
	areaCuadrado := baseCuadrado * baseCuadrado

	fmt.Println("El área del cuadrado es:", areaCuadrado)

	//Calcular el área de un rectángulo
	areaRectangulo := base * altura

	fmt.Println("El área del rectángulo es:", areaRectangulo)

	//Calcular el área de un trapecio
	areaTrapecio := ((base + baseM) / 2) * altura

	fmt.Println("El área del trapecio es:", areaTrapecio)

	//Calcular el área de un círculo
	areaCirculo := pi * radio * radio

	fmt.Println("El área del círculo es:", areaCirculo)

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

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

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

Comparto mi resolución al reto

	//RETO
	// - Rectangulo
	baseR := 10
	alturaR := 20
	areaRectangulo := baseR * alturaR
	fmt.Println("Área del Rectangulo: ",areaRectangulo)

	//Trapecio
	baseMenor := 10
	baseMayor := 30
	alturaT := 5
	areaTrapecio := (baseMayor + baseMenor) / 2 * alturaT
	fmt.Println("Área del Trapecio: ", areaTrapecio)

	//Circulo
	const pi float64 = 3.1416
	radio := 30
	areaCirculo := pi * float64((radio)^2)
	fmt.Println("Área del Circulo: ", areaCirculo)
package main

import (
	"fmt"
	"math"
)

func main() {

	// Rectangle Area
	const rectangleHeight int = 40
	const rectangleBase int = 60

	rectangleArea := rectangleBase * rectangleHeight

	fmt.Println("Rectangle area -> ", rectangleArea) 

	// Trapezium Area

	const trapeziumHeight int = 20
	const minorBase int = 20
	const mayorBase int = 30 

	trapeziumArea := (mayorBase + minorBase) * trapeziumHeight / 2

	fmt.Println("Trapezium area -> ", trapeziumArea)

	// Circle Area
	const radio float64 = 5
	perimeter := (2 * math.Pi) * radio

	circleArea := perimeter * radio / 2

	fmt.Println("Circle area -> ", circleArea)
	
}

Me quedé con una duda:
La variable de la suma la declaraste con :=
y el de la resta solo con un =
¿Porqué solo el primer resultado va con “:=” y las demás solo con “=”?

	//Suma
	result := x + y
	fmt.Println("El resultado de la suma es:", result)

	//Resta
	result = y - x
	fmt.Println("El resultado de la resta es:", result)

Reto cumplido 😄

	//RETOS
	//Hallar área del rectángulo, trapecio y del círculo

	//Área del rectangulo: b*h

	b := 10
	h := 5
	areaRect = b*h
	
	fmt.Println("El área del recatángulo es:", areaRect)

	//Área del trapecio b1*b2/2 * h

	b1 := 15
	b2 := 12
	alturaTra := 6
	areaTra := (float64(b1+b2) / float64(2)) * float64(alturaTra) //Usé float porque mis variables lo requieren

	fmt.Println("El área del trapecio es:", areaTra)

	//Área del circulo Pi * r2

	const pie = 3.14
	rdio := 10
	circleArea := (pie) * float64(rdio*rdio)

	fmt.Println("El área del circulo es:", circleArea)

Les dejo mi codigo de esta clase:

package main

import "fmt"

func main() {
	// Valores:
	x := 1000
	y := 500

	//Suma:
	sumaResult := x + y
	//Resta:
	restaResult := x - y

	fmt.Println("La suma de los 2 valores es ", sumaResult, ".Mientras que su resta equivale a ", restaResult, ".")

	//Multiplicacion:
	multiResult := x * y
	// División:
	diviResult := x / y

	fmt.Println("La multiplicación de los dos valores es", multiResult, " y su divisón es igual a", diviResult, ".")

	// Modulo:
	modulResult := x % y

	fmt.Println("El modulo de los dos valores es: ", modulResult)

	// Incremental:
	x++
	fmt.Println("El incremental de x es: ", x)
	// Decremental:
	x--
	x--
	fmt.Println("El decremental de x es: ", x)

}

El área del rectangulo la calcule así:

package main

import "fmt"

func main() {
	// Información de mi rectángulo:
	ladoRectangulo := 100
	altoRectangulo := 20

	areaRectangulo := ladoRectangulo * altoRectangulo

	fmt.Println("El Area del Rectángulo es :", areaRectangulo)

}

El área del trapecio así:

package main

import "fmt"

func main() {
	baseUno := 6
	baseDos := 15
	alturaTrapecio := 25

	areaTrapecio := ((baseUno + baseDos) * alturaTrapecio) / 2

	fmt.Println("El Área del Trapecio es :", areaTrapecio)

}

Y finalmente el del circulo así:

package main

import "fmt"

func main() {
	// Defino el valor de pi
	const pi = 3.14
	var radioCirculo float64 = 50

	areaCirculo := pi * radioCirculo * radioCirculo

	fmt.Println("El Area del Circulo es :", areaCirculo)

}

package main

import “fmt”

func main() {

// Area rectangulo
var baseRectangulo = 10
var alturaRectangulo = 5
areaRectangulo := baseRectangulo * alturaRectangulo

fmt.Println(areaRectangulo)

// Area trapecio

var baseMenor = 5
var baseMayor = 10
var altura = 3

areaTrapecio := (baseMenor + baseMayor) * altura / 2

fmt.Println(areaTrapecio)

// Area circulo
const pi float64 = 3.14
var radio float64 = 10

areaCirculo := pi * radio * radio

fmt.Println(areaCirculo)

}