Me parece que está mal editado el video, habla de funciones para convertir texto a un entero, pero no usó eso :thi
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 134
Preguntas 5
Me parece que está mal editado el video, habla de funciones para convertir texto a un entero, pero no usó eso :thi
Retos 1 y 2
package main
import "fmt"
func main() {
if isPair(6) {
fmt.Println("Number is pair")
} else {
fmt.Println("Number is odd")
}
if isValidUser("Alpha5", "MyPassword") {
fmt.Println("Credentials are valid")
} else {
fmt.Println("Credentials aren't valid")
}
}
func isPair(num int) bool {
return num % 2 == 0
}
func isValidUser(userName, pass string) bool {
return userName == "Alpha" && pass == "MyPassword"
}
Reto 😃
Mis apauntes
Atoi is equivalent to ParseInt(s, 10, 0), converted to type int.
Fatal is equivalent to Print() followed by a call to os.Exit(1).
package main
import (
"fmt"
"log"
"strconv"
)
func main() {
if true {
fmt.Println("Hello World")
} else {
fmt.Println("Bye World")
}
//Converting strings to integers
value, err := strconv.Atoi("23") // Atoi is equivalent to ParseInt(s, 10, 0), converted to type int.
if err != nil {
log.Fatal(err) //Fatal is equivalent to Print() followed by a call to os.Exit(1).
}
fmt.Println(value)
//Even or odd
numb := 10
if numb%2 != 0 {
fmt.Println("Number is odd")
} else {
fmt.Println("Number is even")
}
//login
user := "Pedro"
password := "12345"
if user == "Pedro" && password == "12345" {
fmt.Println("Logged in")
} else if user == "Pedro" {
fmt.Println("Password incorrect")
} else if password == "12345" {
fmt.Println("User incorrect")
} else {
fmt.Println("Credencials incorrect")
}
}
Reto 1:
func esPar(num int) bool {
result := num%2 == 0
if result {
fmt.Println(num, "es par")
} else {
fmt.Println(num, "NO es par")
}
return result
}
Reto 2:
func validUser(username, pass string) bool {
return username == "kuro" && pass == "kuro"
}
Puertas lógicas 😅 años que no escuchaba a los operadores lógicos, me regresé a la uni ❣️
En Go, un statement puede ser parte de un condicional. Por ejemplo, para convertir un string
a un int
se puede utilizar la función Atoi
del paquete strconv
. La función devuelve un int
si la conversión es exitosa. De lo contrario, devuelve un error
. Así:
func main() {
a := "10"
// n y err están en el scope de main
n, err := strconv.Atoi(a)
if err != nil {
panic(err)
}
fmt.Printf("The value of a is %d\n", n)
}
El statement strconv.Atoi
puede ejecutarse en la misma declaración del condicional:
func main() {
a := "10"
// Inline
if n, err := strconv.Atoi(a); err != nil {
panic(err)
} else {
fmt.Printf("The value of a is %d\n", n)
}
}
Aquí hace falta la rama else
porque las variables declaradas en el statement (n
y err
) sólo están disponibles en el scope del condicional y no en el de la función main
. Todo depende del caso de uso, pero a ustedes, ¿cuál versión les gusta más?
En Go, nil es el valor cero para punteros, interfaces, mapas, slices, canales y funciones; y corresponde a la representación de un valor no inicializado. Pero ojo, es muy importante no confundir valor “no inicializado” con estado indeterminado, pues nil no es más que otro posible valor válido. Si, por ejemplo, hablamos de la interfaz error, el valor nil será el equivalente a decir que no hay error. Otra cosa muy diferente sería decir que no sabemos si hay o no error (estado indeterminado).
Reto 1
func isPar(x int){
if x%2==0 {
fmt.Printf("¡%d es par!\n",x)
} else {
fmt.Printf("Lo siento bro, %d no es par :/",x)
}
}
Reto 2
func iniSesion(username, password string){
var usernameCorrecto string = "Lalo Quita"
var passwordCorrecto string = "password"
if username == usernameCorrecto && password==passwordCorrecto {
fmt.Println("Sesion iniciada")
} else if username == usernameCorrecto {
fmt.Println("Contraseña incorrecta")
} else if password == passwordCorrecto {
fmt.Println("Nombre de usuario incorrecto")
} else {
fmt.Println("Nombre y contraseña incorrectos")
}
}
Respuesta de los retos 1 y 2
package main
import "fmt"
func main() {
valor1 := 1
valor2 := 2
if valor1 == 1 {
fmt.Println("Es 1")
} else {
fmt.Println("No es 1")
}
//With and
if valor1 == 1 && valor2 == 2 {
fmt.Println("Es verdad")
}
//With or
if valor1 == 0 || valor2 == 2 {
fmt.Println("Es verdad con alguno de los 2")
}
numeroPar := 8
numeroImpar := 11
result := isPar(numeroPar)
if result {
fmt.Printf("El numero %d es Par\n", numeroPar)
}
result = isPar(numeroImpar)
if result {
fmt.Printf("El numero %d es Par\n", numeroPar)
} else {
fmt.Printf("El numero %d es Impar\n", numeroImpar)
}
password1 := "Password123"
password2 := "Password123"
password3 := "Password789"
if isValidPassword(password1, password2) {
fmt.Println("El password es valido!!")
} else {
fmt.Println("El password Incorrecto!!")
}
if isValidPassword(password1, password3) {
fmt.Println("El password es valido!!")
} else {
fmt.Println("El password Incorrecto!!")
}
}
func isPar(number int) (result bool) {
if number%2 == 0 {
return true
}
return false
}
func isValidPassword(password1, password2 string) (result bool) {
if password1 == password2 {
return true
}
return false
}
Primer reto:
package main
import "fmt"
func parOImpar(numero int) {
if numero % 2 == 0 {
fmt.Printf("El número %d es par", numero)
} else {
fmt.Printf("El número %d es impar", numero)
}
}
func main() {
parOImpar(13)
}
Segundo reto:
package main
import "fmt"
func validateUser(user string, password string) {
if user == "admin" && password == "admin123" {
fmt.Printf("Acceso permitido")
} else {
fmt.Printf("Acceso denegado")
}
}
func main() {
validateUser("admin", "admin123")
}
Reto 1 (Saber si un numero es par o impar):
package main
import "fmt"
func esPar(num int) {
if num%2 == 0 {
fmt.Println("Es par")
} else {
fmt.Println("Es impar")
}
}
func main() {
var num = 10
esPar(num)
}
Output:
Es par
Reto 2 (Saber si la contraseña es correcta o incorrecta):
package main
import "fmt"
func validarContrasena(contrasena, ingresado string) {
if contrasena == ingresado {
fmt.Println("Contraseña correcta")
} else {
fmt.Println("Contraseña incorrecta")
}
}
func main() {
var contrasena = "123Alex"
var ingresado = "123alex"
validarContrasena(contrasena, ingresado)
}
Output:
Contraseña incorrecta
CODIGO:
package main
import (
"fmt"
)
var users = map[string]string {
"user1": "pass1",
"user2r": "pass2",
"user3": "pass4",
"user4": "pass4",
"user5": "pass5",
}
func isOddOrEven(number int) {
var result string
isEven := number%2 == 0
if isEven {
result = "par"
} else {
result = "impar"
}
fmt.Printf("El numero = \"%d\" es %s\n", number, result)
}
func validate(username, password string) bool {
validUser := users[username] == password
if validUser {
fmt.Printf("Las credenciales del usuario \"%s\" son validas\n", username)
} else {
fmt.Printf("Las credenciales del usuario \"%s\" son invalidas\n", username)
}
return validUser
}
func main() {
// Un numero es par o impar
isOddOrEven(2020)
isOddOrEven(2021)
// Validar credenciales
validate("user1", "pass1")
validate("user3", "pass2")
validate("user7", "pass7")
}
RESULTADO:
El numero = "2020" es par
El numero = "2021" es impar
Las credenciales del usuario "user1" son validas
Las credenciales del usuario "user3" son invalidas
Las credenciales del usuario "user7" son invalidas
Mi solución al reto:
package main
import "fmt"
func esPar(n int) bool {
if n%2 == 0 {
fmt.Printf("%d es un número par.\n", n)
return true
} else {
fmt.Printf("%d es un número impar.\n", n)
return false
}
}
func validarUsuario(usr, pwd string) bool {
const usrBase = "Miguel"
const pwdBase = "qwerty"
if usr == usrBase && pwd == pwdBase {
fmt.Println("Usuario y contraseña validos")
fmt.Printf("¡Bienvenido %s!\n", usr)
return true
} else {
fmt.Println("Usuario o contraseña incorrectos")
fmt.Println("¡Acceso denegado!")
return false
}
}
func main() {
esPar(15) //15 es un número impar.
esPar(12) //12 es un número par.
fmt.Println("")
validarUsuario("Eustaquio", "qwerty")
fmt.Println("")
// Usuario o contraseña incorrectos
// ¡Acceso denegado!
validarUsuario("Miguel", "12345")
fmt.Println("")
// Usuario o contraseña incorrectos
// ¡Acceso denegado!
validarUsuario("Miguel", "qwerty")
fmt.Println("")
// Usuario y contraseña validos
// ¡Bienvenido Miguel!
}
Resultado:
15 es un número impar.
12 es un número par.
Usuario o contraseña incorrectos
¡Acceso denegado!
Usuario o contraseña incorrectos
¡Acceso denegado!
Usuario y contraseña validos
¡Bienvenido Miguel!
Ejemplo de condicionales:
//CONDITIONALS
//IF
value1 := 5
value2 := 8
if value1 == 6 {
fmt.Println("Value 6")
} else {
fmt.Println("Not 6")
}
if value1 == 6 && value2 == 8 {
fmt.Println("Both, 6 and 8 are correct")
} else {
fmt.Println("One or both are wrong")
}
if value1 == 6 || value2 == 8 {
fmt.Println("One or both, 6 and 8 are correct")
} else {
fmt.Println("Both are wrong")
}
if value1 != 6 {
fmt.Println("Isn't 6")
} else {
fmt.Println("Is 6")
}
les presento mi versión de los retos 🤠
package main
import "fmt"
func parImpar(numero int )(string){
if numero % 2 == 0{
return "Es par"
}else{
return "Es impar"
}
}
func validar(usuario string, password string) (string) {
root:="platzi"
pass:="platzii"
if usuario==root && password==pass {
return "Acceso Correcto 🚀"
}else{
return "Vuelve a intentarlo 💥💥"
}
}
func main() {
fmt.Println(parImpar(10))
fmt.Println(parImpar(5))
usuario := "Platzi"
password:= "root"
fmt.Println(validar(usuario, password))
usuario = "platzi"
password = "platzii"
fmt.Println(validar(usuario, password))
}
los resultados
Solución de los retos:
unc evenOdd(number int) bool {
return number%2 == 0
}
func userAuth(userName, password string) bool {
_userName := "gouser"
_password := "12345"
if userName == _userName && password == _password {
return true
}
return false
}
func main() {
if evenOdd(6) {
fmt.Println("Es Par")
} else {
fmt.Println("Es Impar")
}
if userAuth("gouser1", "12345") {
fmt.Println("Usuario autenticado")
} else {
fmt.Println("Usuario no existe")
}
}
Even or Odd
func main() {
result := oddOrEven(15)
println(result)
result = oddOrEven(6)
println(result)
result = oddOrEven(1523)
println(result)
}
func oddOrEven(number int) string {
if number % 2 == 0 {
return "Odd"
} else {
return "Even"
}
}
Terminal Output
λ developer src → λ git main* → go run main.go
Even
Odd
Even
Solución del ejercicio 1
package main
import (
"fmt"
)
func isOdd(numToCheck int) bool {
if numToCheck % 2 == 0 {
return false
} else {
return true
}
}
func evenChecker() {
fmt.Println("Ingresa un número: ")
var usrNum int
fmt.Scanln(&usrNum)
if isOdd(usrNum) {
fmt.Printf("El número %d es impar\n", usrNum)
} else {
fmt.Printf("El número %d es par\n", usrNum)
}
}
func main() {
/* Reto 1 : Revisar si el número dado por el usuario es par o no */
evenChecker()
}
Solución reto 2:
Para este reto usé una librería de go que recibe el password sin mostrarlo en pantalla
package main
import (
"bufio"
"fmt"
"os"
"strings"
"syscall"
"golang.org/x/crypto/ssh/terminal"
)
func usrValidator() {
allowedUsr := "test"
allowedPass := string("securepass00")
reader := bufio.NewReader(os.Stdin)
fmt.Print("Ingresa tu usuario: ")
username, _ := reader.ReadString('\n')
fmt.Print("Ingresa tu contraseña: ")
bytePass, _ := terminal.ReadPassword(syscall.Stdin)
password := string(bytePass)
username = strings.TrimSpace(username)
password = strings.TrimSpace(password)
if username == allowedUsr && password == allowedPass {
fmt.Print("\nUsuario autorizado\n")
} else {
fmt.Print("\nOpps! No tienes permisos para ver esta información\n")
}
}
func main() {
/* Reto 2 : Validar si un usuario y contraseña está autorizado para acceder a una platadorma */
usrValidator()
}
func ispar(numero int) bool {
if numero%2 == 0 {
fmt.Println("Es par")
return true
} else {
fmt.Println("Es inpar")
return false
}
}
func passwordPass(pass1 string, pass2 string) bool {
if pass1 == pass2 {
fmt.Println("Son iguales")
return true
} else {
fmt.Println("No son iguales")
return false
}
}
// Reto 1
func isPair(num int) {
if num%2 == 0 {
fmt.Printf("El numero %d es par \n", num)
} else {
fmt.Printf("El numero %d es impar \n", num)
}
}
// Reto 2
func login(username string, password string) {
if username == "david" && password == "sanchez" {
fmt.Printf("Bienvenido %s \n", username)
} else {
fmt.Printf("Credenciales incorrectas \n")
}
}
package main
import "fmt"
var user, password = "abcd123", "123456"
//reto 1
func paroImpart(number int) string {
if number%2 == 0 {
return "par"
} else {
return "impar"
}
}
//reto 2
func loggin(usuario, contraseña string) bool {
if usuario == user && contraseña == password {
return true
} else {
return false
}
}
func main() {
reto1 := paroImpart(12)
fmt.Println(reto1)
reto2 := loggin("abcd123", "123456")
fmt.Println(reto2)
}
package main
import "fmt"
// 1. se requiere crear una funcion de un numero que recibe
// esa funcion es par o impar
// 2. se requiere una funcion que reciba un usuario
// un pasword y revise si es valido o no, se espera un retorno
// true
func main() {
// 1. Declaracion de variable optima
const num int8 = 100
// Hacemos comprobacion de valores usando el operador de Modulo
if num%2 == 0 {
// Se imprime en pantalla usando el printf para construir un mesaje
fmt.Printf("El numero %d es un numero PAR\n", num)
// Agrego else en caso de que no se cumpla la condicion
} else {
fmt.Println("El numero es IMPAR")
}
// 2. Guardamos los datos del usuario optimizados
const user string = "Max"
const pasword int16 = 1995
// Validamos los datos con operador and, para comprobar ambos
if user == "Max" && pasword == 1995 {
// imprimimos con Printf para mensaje personalizado
fmt.Printf("EL usuario %s tiene permiso para iniciar secion\n", user)
// Agrego else en caso de que no se cumpla la condicion
} else {
fmt.Print("Parece hay un error en los datos")
}
}
Este es mi aporte
package main
import "fmt"
func main() {
num := 9
if num%2 == 0 {
fmt.Println("es par")
} else {
fmt.Println("es impar")
}
password := "quesochedar"
if password == "quesochedar" {
fmt.Println("esta es la contraseña")
} else {
fmt.Println("vuelvelo a intentar")
}
}
las soluciones de cada reto:
reto uno =
package main
import "fmt"
func dectarPar(number int) int {
if number%2 == 0 {
fmt.Println("el numero es par")
} else {
fmt.Println("el numero no es par")
}
return number
}
func main() {
num1 := dectarPar(4)
fmt.Println(num1)
num2 := dectarPar(5)
fmt.Println(num2)
}
reto 2 =
package main
import "fmt"
func accesoSystem(password, user string) bool {
if password == "platzi" && user == "Andres.Montes" {
fmt.Println("acceso permitido")
return true
} else {
fmt.Println("acceso denegado")
return false
}
}
func main() {
user1 := accesoSystem("platzi", "Andres.Montes")
fmt.Println(user1)
user2 := accesoSystem("jdbvjdvb", "oipdcin")
fmt.Println(user2)
}
Aqui esta mi código
package main
import (
"fmt"
)
func main() {
var n int
fmt.Println("Insert an integer")
fmt.Scanln(&n)
if n%2 == 0 {
fmt.Println("Your number is even")
} else {
fmt.Println("Your number is odd")
}
var email string = "[email protected]"
var password string = "123456"
var emailVerification string = ""
var passwordVerification string = ""
for passwordVerification != password || emailVerification != email {
fmt.Println("Enter your email")
fmt.Scanln(&emailVerification)
fmt.Println("Enter your password")
fmt.Scanln(&passwordVerification)
if emailVerification == email && passwordVerification == password {
fmt.Println("Welcome to Platzi")
} else if emailVerification != email && passwordVerification == password {
fmt.Println("Sorry invaid email please try again")
} else if emailVerification == email && passwordVerification != password {
fmt.Println("Sorry inalid password please try again")
} else {
fmt.Println("Sorry invalid email and password please try again")
}
}
}
// Challenge:
// Number is par or odd
number := 5
if (number % 2) == 0 {
fmt.Printf("Number %d es par", number)
} else {
fmt.Printf("Number %d es impar \n", number)
}
// Validate credentials (user and password) true o false
user := "admin"
password := "123"
if user == "admi" && password == "123" {
fmt.Println("Login")
} else {
log.Fatal("Invalidate credentials")
}
Reto 1:
package main
import "fmt"
func main() {
num := 4
if isPar(num) {
fmt.Println("Es par")
return
}
fmt.Println("Es impar")
}
func isPar(num int) bool {
return num%2 == 0
}
package main
import (
"fmt"
)
func esParImpar(numero int) string {
var resultado string
if numero%2 == 0 {
resultado = "Es Par"
} else {
resultado = "Es Impar"
}
return resultado
}
func main() {
respuesta := esParImpar(60)
fmt.Println(respuesta)
}
package main
import (
"fmt"
)
func logIn(user, password string) bool {
users := map[string]string{
"user1": "passwr1",
"user2": "passwr2",
}
if realPassword, userExists := users[user]; userExists && realPassword == password {
return true
}
return false
}
func isEven(number int) bool {
if number%2 == 0 {
return true
}
return false
}
func main() {
user1 := "user1"
password1 := "passwr1"
user3 := "user3"
password3 := "passwr3"
fmt.Println(fmt.Sprintf("Is %s, able to login? %v", user1, logIn(user1, password1)))
fmt.Println(fmt.Sprintf("Is %s, able to login? %v", user3, logIn(user3, password3)))
oddNumber := 5
evenNumber := 6
fmt.Println(fmt.Sprintf("Is %v an even number? %v", oddNumber, isEven(oddNumber)))
fmt.Println(fmt.Sprintf("Is %v an even number? %v", evenNumber, isEven(evenNumber)))
}
El primer challenge
package main
import (
"fmt"
)
func evenOrOdd(number int) string {
if number%2 == 0 {
return "even"
} else {
return "odd"
}
}
func main() {
// read number from console
var number int
fmt.Print("Enter a number: ")
_, err := fmt.Scanln(&number)
if err != nil {
fmt.Println("Error: ", err)
return
}
fmt.Println(evenOrOdd(number))
}
El segundo challenge
package main
import "fmt"
func validateUser(username string, password string) bool {
return username == "admin" && password == "123456"
}
func main() {
var username, password string
println("Enter username:")
_, err := fmt.Scanln(&username)
if err != nil {
println("Error: ", err)
return
}
println("Enter password:")
_, err = fmt.Scanln(&password)
if err != nil {
println("Error: ", err)
return
}
if validateUser(username, password) {
println("Welcome!")
} else {
println("Invalid username or password!")
}
}
saludos, mi solucion enforma de funcion del reto 2:
package main
import "fmt"
var user string = "anibal"
var pass string = "baires1995"
var nuevoUser string
var nuevoPass string
func main() {
fmt.Println("Ingrese su nombre de Usuario:")
fmt.Scan(&nuevoUser)
fmt.Println("Ingrese su Contraseña:")
fmt.Scan(&nuevoPass)
verificacion()
}
func verificacion() {
if nuevoUser == user && nuevoPass == pass {
fmt.Println("acceso concedido")
} else {
fmt.Println("acceso denegado")
}
}
Esta es una solución más como con seguridad, que les parece?
package main
import (
"fmt"
)
func oddOrEven(number int) {
if number%2 == 0 {
fmt.Println("es par")
} else {
fmt.Println("es inpar")
}
}
func login(email string, password string) {
const emailLogin, passLogin = "[email protected]", "Simon12345"
if email == emailLogin {
if password == passLogin {
fmt.Println("Acceso concedido")
} else {
fmt.Println("Contraseña incorrecta")
}
} else {
fmt.Println("Acceso denegado")
}
}
func main() {
oddOrEven(16)
login("[email protected]", "Simon12345")
}
// RETO NUMERO PAR O NO.
func numberPar(number int) {
if number%2 == 0 {
fmt.Println("Tu numero es par")
} else {
fmt.Println("Tu numeto es impar")
}
}
// Reto 2
func login(user, pasword string) {
if user == "Plazi" && pasword == "Neverstoplearning" {
fmt.Println("Te has registrado con exito")
} else {
fmt.Print("Usuario o pasword invalido")
}
}
package main
import (
"bufio"
"fmt"
"os"
"strconv"
)
func main() {
for {
doCalc()
fmt.Println("Desea continuar? (y/n)")
entrada := leerEntrada()
if entrada == "n" {
break
}
}
}
func doCalc() {
fmt.Println("Ingrese un numero")
entrada := leerEntrada()
numero := parsear(entrada)
if isOdd(numero) {
fmt.Println("Es impar")
} else {
fmt.Println("Es par")
}
}
func isOdd(numero int) bool {
if numero % 2 == 0 {
return false
}
return true
}
func leerEntrada() string {
scanner := bufio.NewScanner(os.Stdin)
scanner.Scan()
return scanner.Text()
}
func parsear(entrada string) int {
operador, _ := strconv.Atoi(entrada)
return operador
}
package main
import (
"fmt"
)
// Funciones Reto Condicionales
func funcEsPar(numero int) (evaluador bool) {
if numero%2 == 0 {
evaluador = true
} else {
evaluador = false
}
return evaluador
}
func logIn(user string, pass string) (evaluador bool){
if user == "EstudiantePlatzi" && pass == "LaMasSegura123" {
evaluador = true
}else {
evaluador = false
}
return evaluador
}
func main() {
//Reto funciones con condicional
//Validando PAR o IMPAR
entero := 30
validador := funcEsPar(entero)
if validador == true {
println("El valor es PAR")
} else {
println("El valor es IMPAR")
}
//Validando Usuario y contrasenia
user := "EstudiantePlatzi"
pass:= "LaMasSegura123"
admitir:= logIn(user,pass)
if admitir == true {
println("Puedes ingresar")
} else {
println("Lo siento tu usuario o contrasenia no coincide")
}
}
Reto 1:
package main
import "fmt"
func main() {
numeros := []int{1, 2, 3, 4, 5}
for _, numero := range numeros {
if esPar(numero) {
fmt.Printf("%d es par!\n", numero)
} else {
fmt.Printf("%d es impar!\n", numero)
}
}
}
func esPar(n int) bool {
resultado := false
if n%2 == 0 {
resultado = true
}
return resultado
}
Retos 1 y 2 👋:
func authorization() {
var username string
var pass string
fmt.Println("Please write your username and password:")
fmt.Scanln(&username, &pass)
if username == "Derek" {
fmt.Println("Hello", username, ", your password is", pass, "Bye :).")
} else {
fmt.Printf("%s is not authorized", username)
}
}
func isEven(n int) bool {
return n%2 == 0
}
package main
import "fmt"
func isPair(a int) bool {
return a%2 == 0
}
func login(user, pass string) bool {
return user == "admin" && pass == "admin123"
}
func main() {
// challenge 1
fmt.Println(isPair(2))
fmt.Println(isPair(1))
// challenge 2
fmt.Println(login("admin", "admin123"))
fmt.Println(login("admin", "admin"))
}
Reto 2
var user string = "jhonAcevedo26"
var password string = "platzis344"
func main () {
if user == "jhonAcevedo26" && password == "platzi1344" {
fmt.Println("access granted")
} else {
fmt.Println("access denied, user or password incorrect")
}
}
Reto numero 1
func main() {
var numero = 2
if numero % 2 == 0 {
fmt.Println("Es un numero par")
} else {
fmt.Println("es un numero impar")
}
}
package main
import “fmt”
func numPar(a int) {
if a%2 == 0 {
fmt.Println("El numero ingresado es PAR")
} else {
fmt.Println("El numero ingresado es IMPAR")
}
}
func accessUser(user, password string) bool {
if (user == "admin") && (password == "1234") {
return true
} else {
return false
}
}
func main() {
numPar(579)
fmt.Println("Acceso al sistema:", accessUser("admin", "1234"))
}
Mi sencilla solucion a los retos
Intenté resolver ambos retos en un solo bloque, perdonen mi inglés jaja, ando practicando. Saludos compañeros de todo el munod 😄
package main
import "fmt"
func main() {
var name string
var password string
var alcance int
fmt.Print("Enter your name:")
fmt.Scanf("%s", &name) // ==> Metodo para leer una entrada en la consola
fmt.Print("Enter your password:")
fmt.Scanf("%s", &password)
if (name == "marco") && (password == "enter") {
// Solo imprimir los numeros pares del 1 al 100
fmt.Println("Hasta que numero quieres encontrar los pares")
fmt.Scanf("%d", &alcance)
for i := 0; i <= alcance; i++ {
if i%2 == 0 {
fmt.Println("el numero ", i, " es par")
}
}
fmt.Println("Goodbay", name, " :)")
} else {
fmt.Println("Sorry... but I don't know who you are, try calling Marco to get access")
}
}
Reto 1:
func EsPar(num int) bool {
if num%2 == 0 {
return true
} else {
return false
}
}
Reto 2:
func autenticacion(user, pass string) bool {
userAuth := "brandon"
passAuth := "7594"
if user == userAuth && pass == passAuth {
return true
} else {
return false
}
}
package main
import "fmt"
// Detectar, el usuario correcto
func main(){
//ingresar contraseña
var valor string
fmt.Println("Ingrese su Contraseña: ")
fmt.Scanf("%s" , &valor)
pass := "Platzi"
if valor == pass {
fmt.Println("Usuario Correcto, Bienvenido")
}else {
fmt.Println("Usuario Incorrecto")
}
}
package main
import "fmt"
// Detectar, del numero ingresado si es PAR o IMPAR
func main(){
//ingresar un numero desde teclado
var valor int
fmt.Println("Ingrese un numero estero: ")
fmt.Scanf("%d" , &valor)
if (valor % 2) == 0 {
fmt.Println("El numero ingresado es PAR")
}else {
fmt.Println("El numero ingresado es IMPAR")
}
}
package main
import (
//“fmt”
“fmt”
“log”
“strconv”
)
func esPar(par string) int{
value, error := strconv.Atoi(par)
result := 0
if error!= nil{
log.Fatal(error)
}else{
module := value % 2
if module!=0{
result = 1
}else{
result = 2
}
}
return result
}
func validaPassword(user string, pass int) int{
usuario:= user
contraseña:= pass
respuesta := 0
if(usuario == "Israfel2112" && contraseña == 123){
respuesta = 1
}
return respuesta
}
func main() {
esPar:= esPar("2")
if esPar == 1{
fmt.Println("El número ingresado no es par", )
}else{
fmt.Println("El número ingresado es par")
}
validaPassword:= validaPassword("Israfel2112", 123)
if validaPassword != 1{
fmt.Println("El usuario no es valido")
}else{
fmt.Println("El usuario es valido")
}
//
}
n := 16
if n%2 == 0 {
fmt.Println("El número", n, "es par")
} else {
fmt.Println("El número", n, "es impar")
}
var user34 string
fmt.Println("¿Cual es tu usuario?")
fmt.Scanln(&user34)
var pass34 string
fmt.Println("¿Cual es tu contraseña?")
fmt.Scanln(&pass34)
guser34 := "user3456"
gpass34 := "pass3456"
if user34 == guser34 && pass34 == gpass34 {
fmt.Println("Usuario y contraseña correcto, adelate")
} else {
fmt.Println("Usuario o contraseña incorrecta, favor de validar")
}
dejo aca mi codigo con la solucion al reto:
//
:
//
Mi humilde solución:
package main
import "fmt"
func numPar(num uint) {
if num%2 == 0 {
fmt.Printf("%d es par\n", num)
} else {
fmt.Printf("%d es impar\n", num)
}
}
func access(a, x string) bool {
if a == "myusername" || x == "mypassword" {
return true
} else {
return false
}
}
func main() {
numPar(3)
myAccess := access("usuario", "password")
fmt.Printf("Acceso: %t\n", myAccess)
}
func login(user, pass string) bool {
if user == "ariel" && pass == "ariel123" {
return true
} else {
return false
}
}
func isPar(valor int) {
result := valor % 2
if result == 0 {
fmt.Printf("El numero %d es par\n", valor)
} else {
fmt.Printf("El numero %d, no par\n", valor)
}
}
Ambos retos:
package main
import "fmt"
func isEven(number int) {
fmt.Printf("%d is even?: %v\n", number, number%2 == 0)
}
func allowAcess(username, password string) bool {
const realUsername string = "Pedro"
const realPassword string = "123456"
return username == realUsername && password == realPassword
}
func main() {
fmt.Println()
// Checking even number
isEven(10)
// Allowing access
fmt.Println(allowAcess("Pedro", "123456"))
}
package main
import "fmt"
func parImpar(numero int) string {
if numero%2 == 0 {
return "Es verdadero"
} else {
return "Es falso"
}
}
func main() {
//Reto de setencia if clase 15
//No. 1, determinar si un número es par o impar
var numero int = 6
fmt.Println(parImpar(numero))
}
package main
import "fmt"
func acceso(usuario, pass string) string {
if usuario == "paquito" && pass == "d1231h" {
return "Tienes acceso"
} else {
return "No tienes acceso"
}
}
func main() {
//No. 2, Resivir un usuario y contraseña
var usuario string = "paquito"
var password string = "d1231h"
fmt.Println(acceso(usuario, password))
}
Siento que me va mejor con cada reto que puedo realizar 😄😊😋
package main
import "fmt"
func main() {
num := 50
password := "1n3My8CaSvMqwORj"
if num%2 == 0 {
fmt.Println("El numero ", num, " es par")
} else {
fmt.Printf("El numero %v es impar\n", num)
}
if password == "1n3My8CaSvMqwORj" {
fmt.Println("Contraseña correcta")
} else {
fmt.Println("Contraseña incorrecta, intentar de nuevo")
}
}
//RETO 1
//RETO 2
Mis retos :3
parImpar(5)
fmt.Println(userCompare("lluz", "lluz123"))
func parImpar(num int) {
if num%2 == 0 {
fmt.Println("Par")
} else {
fmt.Println("Impar")
}
}
func userCompare(user, password string) bool {
if user == "lluz" && password == "lluz123" {
return true
} else {
return false
}
}
Reto 1: //number even or odd
func main() {
num := 2
ret := isEven(num)
if ret {
fmt.Printf(“number %v is even”, num)
} else {
fmt.Printf(“number %v is odd”, num)
}
}
func isEven(number int) bool {
if number%2 == 0 {
return true
}
return false
}
Reto 2:
func main() {
user1 := "Pamela"
pass1 := "Pamela123"
if isUserValid(user1, pass1) {
fmt.Println(“Access approved”)
} else {
fmt.Println(“Access denied”)
}
}
func isUserValid(userName string, password string) bool {
if userName == “Pamela” && password == “Pra123” {
return true
} else {
return false
}
}
reto aceptado, aqui esta la aplicación que le requiere al usuario loguearse para que pueda ver si un numero es par o no.
package main
import (
"bufio"
"fmt"
"log"
"os"
"strconv"
"strings"
)
func main() {
usuario := pedirDatos("ingrese el nombre de usuario: ")
contrasena := pedirDatos("ingrese la contraseña: ")
isLogin, mensaje := login(usuario, contrasena)
if isLogin {
for {
num := pedirDatos("ingrese un numero: ")
numero, err := strconv.Atoi(num)
if err == nil {
if esPar(numero) {
fmt.Println("Es par")
} else {
fmt.Println("No es par")
}
} else {
fmt.Println("Ingrese a https://platzi.com/cursos/fundamentos-matematicas/ para que aprenda que es un numero")
log.Fatal(err)
}
}
} else {
fmt.Println(mensaje)
main()
}
}
func login(usuario string, contrasena string) (bool, string) {
if usuario == "andres" && contrasena == "12345" {
return true, "Bienvenido! ahora puede verificar si un numero es par"
} else {
return false, "Usuario o contraseña incorrectos"
}
}
func esPar(numero int) bool { return numero%2 == 0 }
func pedirDatos(texto string) string {
fmt.Printf(texto)
lector := bufio.NewReader(os.Stdin)
entrada, _ := lector.ReadString('\n')
return strings.TrimRight(entrada, "\r\n")
}
package main
import (
"fmt"
)
func main() {
//Reto 1 - numero par o no
numero := 31
if numero%2 == 0 {
fmt.Println("Es par")
} else {
fmt.Println("No es par")
}
//Reto 2 - comparar password
Password := "1234"
entrada := "134"
if Password == entrada {
fmt.Println("Verdadero")
} else {
fmt.Println("Falso")
}
}
<package main
import "fmt"
func even_check(number int) bool {
if number%2 == 0 {
return true
} else {
return false
}
}
func password_check(pass string) bool {
real_password := "helloworld"
if pass == real_password {
return true
} else {
return false
}
}
func main() {
var number int = 2
if even_check(number) {
fmt.Println("It's a even number")
} else {
fmt.Println("It's a odd number")
}
var pass string = "hellomoon"
if password_check(pass) {
fmt.Println("Login correct!")
} else {
fmt.Println("Login incorrect!")
}
}>
Funcion de validacion de usuario y clave
fmt.Printf("El ingreso al sistema es: %v", authLogin("El Pepe", "EsteSeth69"))
func authLogin(usr, pass string) bool {
if usr == "El Pepe" && pass == "EsteSeth69" {
return true
} else {
return false
}
}
Funcion que recibe un numero y cacula si es par o impar
resultFuncPar := parOrImpar(5)
if resultFuncPar == true {
fmt.Println("El numero es par")
} else {
fmt.Println("El numero no es par")
}
func parOrImpar(num int) bool {
result := num % 2
if result == 0 {
return true
} else {
return false
}
}
package main
import (
"fmt"
)
func pairOdd(){
var num int
fmt.Print("Ingresa tu número: ")
// Para leer datos en la terminal
fmt.Scanf("%d\n", &num)
for num >= 2 {
num = num - 2
}
if num < 0 {
println("Ingrese un número mayor a 0")
} else {
if num == 0 {
fmt.Println("Es par")
} else {
fmt.Println("Es impar")
}
}
}
func passwordCheck(){
var userPass string
const pass = "password"
fmt.Print("Ingrese su contraseña: ")
// Para leer datos en la terminal
fmt.Scanf("%s\n", &userPass)
if pass == userPass {
fmt.Println("Acceso permitido")
} else {
fmt.Println("Acceso denegado")
}
}
func main(){
pairOdd()
fmt.Println("")
passwordCheck()
}
Regularmente cuando programamos nuestros algoritmos, llega un momento donde las acciones que se deben realizar dependerán un poco o mucho del valor o el estado de alguna variable (o constante) que especifiquemos.
<aside>
<img src=“https://static.platzi.com/media/achievements/badge-go-57d6b6ee-c9de-4d9e-9e2c-29a0c879748d-1859b16d-1c87-4b38-bf0a-aee1256cc355.webp” alt=“https://static.platzi.com/media/achievements/badge-go-57d6b6ee-c9de-4d9e-9e2c-29a0c879748d-1859b16d-1c87-4b38-bf0a-aee1256cc355.webp” width=“40px” /> La sentencia if
(si, en inglés) verifica que la expresión que se le indique sea verdadera para entonces ejecutar la sección de código destinada solamente a ejecutarse cuando eso suceda. Si la condicional es falsa, se continúa ejecutando el código de forma secuencial.
</aside>
package main
import "fmt"
func main() {
/*variable local de tipo entero*/
var calificacion int = 5
/*Sentencia if, que verifica si calificación es menor a 6*/
if calificacion < 6 {
/*Si la condición se cumple, imprime*/
fmt.Println("Reprobaste")
}
fmt.Println("Tu calificación fue de: ", calificacion)
}
Cuando necesitamos que el programa ejecute ciertas sentencias cuando la condición es verdadera, pero a su vez necesitamos que ejecute otras sentencias solamente cuando la condición es falsa, necesitamos una sentencia condicional if-else
.
package main
import "fmt"
func main() {
/*variable local de tipo entero*/
var calificacion int = 7
/*Sentencia if, verifica calificación menor 6*/
if calificacion < 6 {
/*Si la condición se cumple*/
fmt.Println("Reprobaste")
}else{
/*Si la condición no se cumple*/
fmt.Println("Aprobaste")
}
fmt.Println("Tu calificación fue de: ", calificacion)
}
if
puede tener 0 o 1 else
que funciona para señalar las sentencias que se ejecutan cuando no se cumplió ninguna de las condiciones anteriores.if
puede tener de 0 a N else if
siempre y cuando no estén después de un else
(ya que el ***else
***, en caso de que exista, debe ser la sentencia final).package main
import "fmt"
func is_even(n int) bool{
if n % 2 == 0 {
return true
} else {
return false
}
}
func user_password(user, password string) string {
if user == "platzi" && password == "nuncaparesdeaprender"{
return "Bienvenido"
} else {
return "Usuario o contraseña incorrecta"
}
}
func main() {
fmt.Println(is_even(7))
fmt.Println(user_password("platzi", "nuncaparesdeaprender"))
}
Solución a los dos restos
func isPar(a int) bool {
return a%2 == 0
}
func matchPassword(a, b string) bool {
return a == b
}
Esta es mi solución para los retos
package main
import (
"fmt"
)
func tipoNumero(n int) {
if n%2 == 0 {
fmt.Println("Es un número par")
} else {
fmt.Println("No es un número impar")
}
}
func seguridad(user, password string) {
if user == "Pancho" && password == "cocacola123" {
fmt.Println("Acceso autorizado")
} else {
fmt.Println("Acceso denegado")
}
}
func main() {
// Reto 1: Determinar si un número es par o impar
tipoNumero(10)
// Reto 2: Comparar usuario y password para dar acceso a una plataforma
seguridad("Pancho", "cocacola123")
}
package main
import (
“fmt”
)
func main() {
parImpar(4)
if verification("Nicolas", "12345") {
fmt.Println("Acceso permitido")
} else {
fmt.Println("Acceso denegado")
}
}
func parImpar(value int) {
if value%2 == 0 {
fmt.Println(value, “Es par”)
} else {
fmt.Println(value, “Es impar”)
}
}
func verification(userName, pass string) bool {
return userName == “Nicolas” && pass == “123”
}
Aquí va mi solución:
func oddOrEven(num int) bool {
return num%2 == 0
}
func userPassComparison(user string, pass string) bool {
const realUser string = "luciano"
const realPass string = "admin123"
return realUser == user && realPass == pass
}
func main() {
val1 := 1
val2 := 2
fmt.Println("oddOrEven:", oddOrEven(val1))
fmt.Println("oddOrEven:", oddOrEven(val2))
fmt.Println("userPassComparison:", userPassComparison("luciano", "admin123"))
fmt.Println("userPassComparison:", userPassComparison("jose", "larralde"))
}
Saludos!!
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?