Contenido del curso
Operadores Aritméticos en Go: Suma, Resta, Multiplicación y División
¿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
Estudiante
Nicoll Idaly Angulo Mejia
Estudiante
Juan Sebastián Caballero
Estudiante
Daniel Miguel Ruiz Tinajero
Estudiante
Ibrahim Guzmán
Estudiante
Lorena M. Flaquer García
Estudiante
Francisco Imanol Suarez
Estudiante
Ruben Dario Hernandez Centeno
EstudianteDaniel Miguel Ruiz Tinajero
Estudiante
Daniel Arturo Silva Oviedo
Estudiante
Ezequiel Vásquez
Estudiante
Rigel David Gutiérrez Carbajal
Estudiante
Miguel Andres Rendon Reyes
Estudiante
Martin Soberón Coronel
Estudiante
Cristian Camilo Rojas Capera
Estudiante
Miguel Angel Luque Acevedo
Estudiante
Osmandi Gomez
Estudiante
Cristian Orlando Rincon Bonilla
Estudiante
Josue Martin Chi Perera
Estudiante
Martin Humberto Del Carpio Cantón
Estudiante
Nahuel Fontän
Estudiante
Nicolas Alexander Rodriguez Villota
Estudiante
Joel Hurtado
EstudianteAlberto Duarte Hurtado
Estudiante
Israel Boza Hernandez
Estudiante
Daniel Arturo Dominguez Lopez
Estudiantefunc 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) }
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) }
Hola Mi amigo, solo recuerda que el area del circulo es Pir por radio al cuadrado.
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) }
Hola! Por qué el primer result lleva := y el segundo solo =? Gracias!
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 !
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
%2022.47.59.png){kind=small}
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")
Les dejo esta pequeña documentación para complementar. :D
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.
necesito más información de cómo instalar go, ya descargue el archivo pero pero no aparece la ventana de instalación.
si hiciste los paso del texto solamente debes ejecutar el visual studio y hacer los ejercicios
¿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?
En ambas opciones lo más importante es que el nombre del paquete sea main, es decir package main
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) }
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)
// Á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) }
package main
import (
"fmt"
"math"
)
func main() {
var result int
// reto
// Rectangulo, trapecio y de un circulo
// Rectangulo
baseRectangulo := 10
alruraRectangulo := 5
result = baseRectangulo * alruraRectangulo
fmt.Println("El area del rectangulo es de:", result, "cm^2")
// Trapecio
baseMaTrapecio := 10
baseMeTrapecio := 6
alturaTrapecio := 3
result = ((baseMaTrapecio + baseMeTrapecio) * alturaTrapecio) / 2
fmt.Println("El area del trapecio es de:", result, "cm^2")
// circulo
radioCirculo := 5
resultCirculo := math.Pi * float64(radioCirculo*radioCirculo)
fmt.Println("El are del circulo es de:",resultCirculo)
}
// Restos
// como calcular el area de un rectangulo, trapecio y circulo
// area de Rectangulo
base := 12
altura := 14
areaRectangulo := base * altura
fmt.Println("Area del rectangulo:", areaRectangulo)
// area de Trapecio
a := 10
b := 15
h := 40
areaTrapecio := ((a + b) / 2) * h
fmt.Println("Area del trapecio:", areaTrapecio)
// area de Circulo
const pi float64 = 3.14
radio := 10.0
areaCirculo := pi * (radio * radio)
fmt.Println("Area del circulo:", areaCirculo)
}
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)
}
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) }
por que suma :=
