Exercício: Capítulo 5, Exercício 2 (Nível: 2)

[vkorbes]

Exercício: Capítulo 5, Exercício 2 (Nível: 2)

Use esta thread para compartilhar sua solução, discutir o exercício com os colegas e pedir ajuda caso tenha dificuldades!

[diegoparra]

https://play.golang.org/p/dVGevKQG0s4

[basquegran2]

minha solução

https://play.golang.org/p/ImQXfGlB_fW

[guifeliper]

🚀 Ficou aquela questãozinha como é que faz para mostrar boolean mesmo, mas logo lembrei 😅

package main

import (
    "fmt"
)

func main() {
    a := (true == false)
    b := (1 > 0)
    c := (1 >= 1)
    d := (1 < 0)
    e := (1 <= 1)
    f := (true != false)
    fmt.Printf("%v\t %v\t %v\t %v\t %v\t  %v\t", a, b, c, d, e, f)
}

[Julian-ie]

https://play.golang.org/p/Dl4IxX9k9P_1

[thiagoalgo]

https://play.golang.org/p/3jeB_mZwpxr

[viniciussanchez]

https://play.golang.org/p/IwNIRCXM7-E

[tomxdev]

package main

import "fmt"

func main() { a := 10 > 100 // false b := 10 < 100 // true c := 10 >= 100 // false d := 10 <= 100 // true e := 10 == 100 // false f := 10 != 100 // true

fmt.Println("Value A: ", a)
fmt.Println("Value B: ", b)
fmt.Println("Value C: ", c)
fmt.Println("Value D: ", d)
fmt.Println("Value E: ", e)
fmt.Println("Value F: ", f)

}

[victorinno]

https://play.golang.org/p/ZtngyX6cd1J

[ygorsimoes]

package main

import (
    "fmt"
    "os"
)

func main() {
    // Declara e atribui o valor 0 a variável
    var primeiroNumero int
    var segundoNumero int

    fmt.Print("Insira o primeiro número: ")
    _, err := fmt.Scan(&primeiroNumero)

    fmt.Print("Insira o segundo número: ")
    _, err = fmt.Scan(&segundoNumero)

    //Trata o possível erro da entrada de dados
    if err != nil {
        // Sai do programa com o status diferente de 0
        os.Exit(-1)
    }

    // Declara e atribui as variáveis com as expressões boolianas
    expressaoIgualdade := primeiroNumero == segundoNumero
    expressaoDiferenca := primeiroNumero != segundoNumero
    expressaoMenor := primeiroNumero < segundoNumero
    expressaoMenorOuIgual := primeiroNumero <= segundoNumero
    expressaoMaior := primeiroNumero > segundoNumero
    expressaoMaiorOuIgual := primeiroNumero >= segundoNumero

    // Quebra de linha
    fmt.Print("\n")

    // Imprime as expressões boolianas
    fmt.Println("(==) Expressão de Igualdade:       ", expressaoIgualdade)
    fmt.Println("(!=) Expressão de Diferença:       ", expressaoDiferenca)
    fmt.Println("(<)  Expressão de Menor:           ", expressaoMenor)
    fmt.Println("(<=) Expressão de Menor ou Igual:  ", expressaoMenorOuIgual)
    fmt.Println("(>)  Expressão de Maior:           ", expressaoMaior)
    fmt.Println("(>=) Expressão de Maior ou Igual:  ", expressaoMaiorOuIgual)
}

Output:

Insira o primeiro número: 10
Insira o segundo número: 40

(==) Expressão de Igualdade:        false
(!=) Expressão de Diferença:        true
(<)  Expressão de Menor:            true
(<=) Expressão de Menor ou Igual:   true
(>)  Expressão de Maior:            false
(>=) Expressão de Maior ou Igual:   false

• [Link to Go Playground]

[JPauloMoura]

package main

//Escreva expressões utilizando os seguintes operadores, e atribua seus valores a variáveis
// <, >, <=, >=, ==, !=
import "fmt"

func main() {
    maior := 10 > 6
    menor := 10 < 6
    maiorIgual := 10 >= 10
    menorIgual := 10 <= 10
    igual := "maria" == "maria"
    diferente := "maria" != "Maria"

    fmt.Printf(`
        10 > 6 ? %v
        10 < 6 ? %v
        10 >= 10 ? %v
        10 <= 10 ? %v
        "maria" == "maria" ? %v
        "maria" != "Maria" ? %v
    `, maior, menor, maiorIgual, menorIgual, igual, diferente)
}

Resolução do Exercício

[Lucasmirandar]

https://play.golang.org/p/f0fUETlkXU3

[guilherme-de-marchi]

package main

import "fmt"

func main() {

    var param_1 int
    fmt.Print("Primeiro parâmetro: ")
    fmt.Scan(&param_1)

    var param_2 int
    fmt.Print("Segundo parâmetro: ")
    fmt.Scan(&param_2)

    equal := param_1 == param_2
    not_equal := param_1 != param_2
    lower_or_equal := param_1 <= param_2
    higher_or_equal := param_1 >= param_2
    lower := param_1 < param_2
    higher := param_1 > param_2

    fmt.Println("")

    fmt.Printf("Equal: %v\n", equal)
    fmt.Printf("Not Equal: %v\n", not_equal)
    fmt.Printf("Lower or Equal: %v\n", lower_or_equal)
    fmt.Printf("Higher or Equal: %v\n", higher_or_equal)
    fmt.Printf("Lower: %v\n", lower)
    fmt.Printf("Higher: %v\n", higher)

}

Output:

Primeiro parâmetro: 10
Segundo parâmetro: 20

Equal: false
Not Equal: true
Lower or Equal: true
Higher or Equal: false
Lower: true
Higher: false

[CarlosSMA]

package main

import (
    "fmt"
)

func main() {
    a := (10 == 10)
    b := (7 != 15)
    c := (10 < 5)
    d := (len("teste") <= 4)
    e := (4 > 7)
    f := (15 >= 45)

    fmt.Println(a, b, c, d, e, f)
}

Output

true true false false false false

[CaueFarias]

https://go.dev/play/p/ZSD4hMILTEU

[AlissonAp]

https://go.dev/play/p/0fteW1rpeZU

[lneute]

// Escreva expressões utilizando os seguintes operadores, e atribua seus valores a variáveis
// ==, !=. >=, <=, >, <

package main

import (
    "fmt"
)

func main() {
    num1, num2 := 500, 9

    equal_to := EqualTo(num1, num2)
    isDifferent := Different(num1, num2)
    gt := GreaterThan(num1, num2)
    lt := LesserThan(num1, num2)
    gtoeq := GreaterThanOrEqualTo(num1, num2)
    ltoet := LesserThanOrEqualTo(num1, num2)

    fmt.Printf("O valor %v é igual ao o valor %v: %v\n", num1, num2, equal_to)
    fmt.Printf("O valor %v é Diferente do valor %v: %v\n", num1, num2, isDifferent)
    fmt.Printf("O valor %v é Maior do que o valor %v: %v\n", num1, num2, gt)
    fmt.Printf("O valor %v é Menor do que o valor %v: %v\n", num1, num2, lt)
    fmt.Printf("O valor %v é Maior ou igual ao valor %v: %v\n", num1, num2, gtoeq)
    fmt.Printf("O valor %v é Menor ou igual ao valor %v: %v\n", num1, num2, ltoet)
}

func EqualTo(arg1 int, arg2 int) bool {
    result := (arg1 == arg2)

    return result
}

func Different(arg1 int, arg2 int) bool {
    result := (arg1 != arg2)

    return result
}

func GreaterThan(arg1 int, arg2 int) bool {
    result := (arg1 > arg2)

    return result
}

func LesserThan(arg1 int, arg2 int) bool {
    result := (arg1 < arg2)

    return result
}

func GreaterThanOrEqualTo(arg1 int, arg2 int) bool {
    result := (arg1 >= arg2)

    return result
}

func LesserThanOrEqualTo(arg1 int, arg2 int) bool {
    result := (arg1 <= arg2)

    return result
}

[M3L1M]

a := (10 == 100) b := (10 != 100) c := (10 <= 100) d := (10 < 100) e := (10 >= 100) f := (10 > 100) fmt.Printf("%v\n%v\n%v\n%v\n%v\n%v\n", a, b, c, d, e, f)

[andreeysiilva]

package main

import "fmt"

func main() {

x := 10
y := 10

igualdade := x == y
diferenca := x != y
menorIgual := x <= y
menor := x < y
maiorIgual := x >= y
maior := x > y

fmt.Println("O valor da == entre x e y = ", igualdade)
fmt.Println("O valor da != entre x e y = ", diferenca)
fmt.Println("O valor da <= entre x e y = ", menorIgual)
fmt.Println("O valor da < entre x e y = ", menor)
fmt.Println("O valor da >= entre x e y = ", maiorIgual)
fmt.Println("O valor da >= entre x e y = ", maior)

}

[adelsonsljunior]

package main

import (
    "fmt"
)

func main() {

    igual := 456 == 56
    diferente := 456 != 4236
    maior := 12 > 24
    menor := 46 < 65
    maiorIgual := 314 >= 312
    menorIgual := 346 <= 675

    fmt.Printf("Igual: %v", igual)
    fmt.Printf("\nDiferente: %v", diferente)
    fmt.Printf("\nMaior: %v", maior)
    fmt.Printf("\nMenor: %v", menor)
    fmt.Printf("\nMaior ou Igual: %v", maiorIgual)
    fmt.Printf("\nMenor ou Igual: %v", menorIgual)
}

[an4kein]

https://go.dev/play/p/EdBN_G9VDwH

// You can edit this code!
// Click here and start typing.
package main

import "fmt"

var d int
var f int
var g int
var h int

func main() {
    a := 10 == 10 // this is bool
    aa := 10 != 10
    b := 10 >= 10
    bb := 10 <= 10
    c := 10 < 10
    d = 10 + 10
    e := 10 > 10
    f = 10 * 10
    g = 10 - 10
    h = 10 / 2
    fmt.Printf("%v\n", a)
    fmt.Printf("%v\n", aa)
    fmt.Printf("%v\n", b)
    fmt.Printf("%v\n", bb)
    fmt.Printf("%v\n", c)
    fmt.Printf("%v\n", d)
    fmt.Printf("%v\n", e)
    fmt.Printf("%v\n", f)
    fmt.Printf("%v\n", g)
    fmt.Printf("%v\n", h)
}

//Escreva expressões utilizando os operadores, e atribua seus valores a variáveis.

---------------------------------------------------------------------------------------------------------------------------------------------
true
false
true
true
false
20
false
100
0
5

Program exited.
---------------------------------------------------------------------------------------------------------------------------------------------

[hiercj]

https://goplay.tools/snippet/rP0CvSV4hsm

[1r4mos]

https://go.dev/play/p/Tg6AYV3cwMQ

[DominMFD]

https://go.dev/play/p/bZeoK2pMlaD

[Vitor-Zen]

https://go.dev/play/p/eNB5EY2pT03

[Hzin]

package main

import "fmt"

func main() {
    falseValue := 10 == 11
    trueValue := 10 == 10
    fmt.Printf("10 == 11=%v\n", falseValue)
    fmt.Printf("10 == 10=%v\n", trueValue)

    falseValue = 10 != 10
    trueValue = 10 != 11
    fmt.Printf("10 != 10=%v\n", falseValue)
    fmt.Printf("10 != 11=%v\n", trueValue)

    falseValue = 11 <= 10
    trueValue = 10 <= 10
    fmt.Printf("11 <= 10=%v\n", falseValue)
    fmt.Printf("10 <= 10=%v\n", trueValue)

    falseValue = 11 < 10
    trueValue = 9 < 10
    fmt.Printf("11 < 10=%v\n", falseValue)
    fmt.Printf("9 < 10=%v\n", trueValue)

    falseValue = 9 >= 10
    trueValue = 11 >= 10
    fmt.Printf("9 >= 10=%v\n", falseValue)
    fmt.Printf("11 >= 10=%v\n", trueValue)

    falseValue = 9 > 10
    trueValue = 11 > 10
    fmt.Printf("9 > 10=%v\n", falseValue)
    fmt.Printf("11 > 10=%v\n", trueValue)
}