Operadores Aritméticos en Go: Suma, Resta, Multiplicación y División

Clase 8 de 36 • Curso Básico de Programación en Go

Resumen

¿Cuáles son los operadores aritméticos en Go?

La programación en Go se enriquece con la implementación de operadores aritméticos, fundamentales para realizar cálculos y operaciones básicas en proyectos de software. Estos operadores son esenciales para la manipulación de datos numéricos y la ejecución de algoritmos eficientes. A continuación, exploraremos cómo se utilizan estos operadores en Go y cómo pueden integrarse en sus proyectos de programación.

¿Cómo se realiza una suma en Go?

La suma es una de las operaciones matemáticas más básicas y se utiliza para añadir dos o más números. En Go, esta operación se realiza de manera sencilla, asignando la suma a una variable.

x := 50
y := 10
resultado := x + y
fmt.Println("Suma:", resultado)

En este ejemplo, resultado almacena la suma de x e y, que debería ser 60.

¿Cómo se efectúa la resta en Go?

La resta permite calcular la diferencia entre dos números. En Go, esto se realiza modificando una variable existente sin necesidad de redeclararla.

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

Al ejecutar esta operación, la salida será 40, ya que la diferencia entre 50 y 10 es 40.

¿Cómo se implementa la multiplicación en Go?

La multiplicación se lleva a cabo multiplicando dos números. En el lenguaje Go, esta operación es tan simple como mencionamos a continuación.

resultado = x * y
fmt.Println("Multiplicación:", resultado)

Aquí el resultado es 500 porque 50 multiplicado por 10 da 500.

¿Qué es y cómo se hace la división en Go?

La división se utiliza para dividir un número entre otro, obteniendo el cociente. La forma de operar la división en Go se representa de modo estándar.

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

El argumento de la función fmt.Println presentará un resultado de 5, puesto que 50 dividido por 10 es igual a 5.

¿Cómo se calcula el módulo en Go?

El módulo es el residuo de una división. Go emplea el operador % para esta operación, esencial para diversas aplicaciones lógicas.

resultado = x % y
fmt.Println("Módulo:", resultado)

El resultado en este caso es 0, dado que 50 entre 10 es una división exacta sin residuo.

¿Qué significan y cómo funcionan los operadores de incremento y decremento?

Los operadores de incremento y decremento son cruciales en la iteración de bucles, aumentando o disminuyendo en uno el valor de una variable, respectivamente.

Incremento:
```
x++
fmt.Println("Incremento:", x)
```
Aquí, x originalmente es 10 y después del incremento se convierte en 11.
Decremento:
```
x--
fmt.Println("Decremento:", x)
```
Al revertir el incremento, x regresa a ser 10.

¿Qué retos adicionales puedes intentar?

Para asimilar mejor estos conceptos, se plantea el desafío de calcular áreas de figuras como el rectángulo, triángulo y trapecio, aprovechando las fórmulas adecuadas. Familiarizarse con estas operaciones matemáticas potencia la habilidad para enfrentar problemas de programación de manera creativa y eficiente.

Incorporar los operadores aritméticos en Go es una habilidad esencial que abre puertas a proyectos más complejos y funcionales. A medida que avanzas en tu aprendizaje, usa estos operadores para explorar y experimentar con nuevas posibilidades en tus proyectos de programación. ¡Sigue adelante con entusiasmo!

Fernando Hernandez

student•

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

Nicoll Idaly Angulo Mejia

student•

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

Juan Sebastián Caballero

student•

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)

}

Daniel Miguel Ruiz Tinajero

student•

Hola Mi amigo, solo recuerda que el area del circulo es Pir por radio al cuadrado.

Ibrahim Guzmán

student•

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

Lorena M. Flaquer García

student•

Hola! Por qué el primer result lleva := y el segundo solo =? Gracias!

Francisco Imanol Suarez

student•

Hola Lorena ¿Cómo estas?

En Go := sirve para declarar y asignar al mismo tiempo, y = solo para asignar un valor a la variable previamente declarada.

Te dejo un Articulo donde se explica esto.

Espero que te sea de ayuda !

Saludos !

Ruben Dario Hernandez Centeno

student•

Daniel Miguel Ruiz Tinajero

student•

duda: ¿Por que dividir la altura del trapecio nuevamente por 2? Lo que se hace ahi solo es multiplicar por la altura, segun la formula, no hace falta que divida nuevamente la altura.

Area Trapecio = (Base Mayor + base Menor) / 2 * Altura

Daniel Arturo Silva Oviedo

student•

package main

import (
	"fmt"
	"math"
)

func main() {
	//Trapecio
	a, b, h := 14, 20, 5

	area := ((a + b) / 2) * h

	fmt.Println("Medidas del trapecio:  a, b, h = (", a, ",", b, ",", h, ") cm")
	fmt.Println("Área del trapecio:", area, "cm^2")

	fmt.Println("-----------------------------------------------------------------------")
	//Circulo
	var r float64 = 4

	areaCirculo := math.Pi * r * r

	fmt.Println("Radio del circulo", r, "cm")
	fmt.Println("Área del ciculo:", areaCirculo, "cm^2")

Ezequiel Vásquez

student•

Rigel David Gutiérrez Carbajal

student•

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

Miguel Andres Rendon Reyes

student•

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.

Martin Soberón Coronel

student•

necesito más información de cómo instalar go, ya descargue el archivo pero pero no aparece la ventana de instalación.

Cristian Camilo Rojas Capera

student•

si hiciste los paso del texto solamente debes ejecutar el visual studio y hacer los ejercicios

Miguel Angel Luque Acevedo

student•

¿Cómo puedo tener diferentes códigos en la misma carpeta? Por ejemplo suponiendo que tenemos la carpeta "~/go/src/clase3-operadores" con los siguientes archivos:

drwxr-xr-x 2 mluque1 mluque1 4096 Apr  8 18:06 ./
drwxr-xr-x 5 mluque1 mluque1 4096 Apr  8 17:59 ../
-rw-r--r-- 1 mluque1 mluque1  657 Apr  8 18:05 main.go
-rw-r--r-- 1 mluque1 mluque1   31 Apr  8 18:08 reto.go

¿Cómo debo tener mi código en reto.go para poderlo ejecutar?

Osmandi Gomez

student•

Si quieres que reto.go sea un archivo independiente, lo que puedes hacer es agregar la función main en ese mismo archivo.
Si quieres que solo haya una función main en la carpeta, en main.go agregas la función main. Y en _reto.go _agregas las funciones a ejecutar de los operadores.

En ambas opciones lo más importante es que el nombre del paquete sea main, es decir package main

Cristian Orlando Rincon Bonilla

student•

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

Josue Martin Chi Perera

student•

AQUÍ DE DEJO LO QUE HICMOS EN CLASE Y LOS RETOS Nota: comence hacer el área del circulo y lo fui mejorando poco a poco hasta que vi que use muchas funciones, hasta hice una mini invetigación de una librería.

package main

import (
	"fmt"
	"math"
)

func main() {

	//Area 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 = y - x
	fmt.Println("Resta:", result)

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

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

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

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

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

	//Retos
	//Area de un rectangulo, trapecio y de un circulo
	//Rectangulo
	a := 4
	b := 3
	areaRectangulo := a * b
	fmt.Println("Área de un rectángulo:", areaRectangulo)

	//Trapecio
	a = 5
	b = 8
	areaTrapecio := (5 + 8) / 2
	fmt.Println("Área de un trapecio:", areaTrapecio)

	//Circulo
	diametro := 5
	pi := math.Pi
	diametroCuadrado := math.Pow(float64(diametro), 2)
	areaCirculo := (pi * diametroCuadrado) / 4
	fmt.Println("Área de un circulo:", math.Round(areaCirculo*100)/100)

Martin Humberto Del Carpio Cantón

student•

// Á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)

Nahuel Fontän

student•

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

Alberto Duarte Hurtado

student•

package main

import "fmt"

func main() {

// declaracion de constantes|

const pi float64 = 3.14

const pi2 = 3.1416

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)

//área cuadrado

const baseCuadrado = 10

areaCuadrado := baseCuadrado * baseCuadrado

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

//Retos

//Calcular el area de un Rectangulo, trapecio y un círculo

//Rectangulo

baseR := 23

alturaR := 32

areaRectangulo := baseR * alturaR

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

//Trapecio

ladoMayor := 30

ladoMenor := 15

alturaT := 7

areaTrapecio := (ladoMayor + ladoMenor) * alturaT / 2

fmt.Println("Area del trapecio:", areaTrapecio)

//Circulo

radio := 10.00

areaCirculo := pi * radio * radio

fmt.Println("Area del circulo:", areaCirculo)

}

Israel Boza Hernandez

student•

package main


import (
    "fmt"
    "math"
)


func main() {

    base := 12
    height := 14
    upperBase := 20
    radio := 2


    // Rectangle area
    areaRect := base * height
    fmt.Println("Área del rectángulo:", areaRect)


    // Trapezoid area
    areaTrap := ((upperBase + base) * height) / 2
    fmt.Println("Área del trapecio:", areaTrap)


    // Circle area
    areaCircle := math.Pi * float64(radio*radio)
    fmt.Println("Área del círculo:", areaCircle)


}

Daniel Arturo Dominguez Lopez

student•

por que suma :=

Luis Angel Galvan Benavides

student•

¿Por que es mas comun colocar las variables como x:= que var x int= ?

no seria mejor de la segunda forma ya que es mas tipado??

Lautaro Strappazzon

student•

Hola Ángel! Para variables con un scope (alcance) más limitado, y cuando el tipado puede ser inferido suele usarse la declaración corta como en el caso de

x :=

Para variables con un alcance de paquete suele usarse la otra síntaxis. No son formas obligatorias, pero son convenciones seguidas por la comunidad y por el equipo interno de Google que desarrolla Go. Otra convención bastante general, por ejemplo, es utilizar la forma larga para inicializar variables a su valor cero

var z int
var s string

Luis Gerardo Fosado

student•

yo tengo una duda en mi caso segui el ejemplo tal cual hasta el modulo; pero como pueden ver en los incrementos y decrementos hice un pequeño cambio

en lugar de incrementar la variable X lo que hice fue pasarle el result

package main

import "fmt"

func main() {
	// Declaracion de constantes
	const pi float64 = 3.14
	const pi2 = 3.1415
	fmt.Println("pi", pi)
	fmt.Println("pi2", pi2)

	// Declaracion 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("resultado suma: ", result)

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

	// Multiplicacion

	result = x * y
	fmt.Println("multiplicacion: ", result)

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

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

	//Incremental
	result++
	fmt.Println("incremento: ", x)

	//decremental
	result--
	fmt.Println("decremento: ", x)
}
```la duda esta en la respuesta:

```js
pi 3.14
pi2 3.1415
12 14 0
0 0  false
area cuadrado: 100
resultado suma:  60
resultado resta:  -40
multiplicacion:  500
división: 5
modulo:  0
incremento:  10
decremento:  10
```al final el incremento me da 10 y el decremento da 10&#x20;
segun yo el valor de result es cero entonces deberia ser algo como 1, y 0 los valores esperados

que ocurrio?