Parámetros de entrada

// Reto

func anotherGreeting(person: String, isMale: Bool, age: Int) -> String{
    if isMale && age > 20{
        return "Bienvenido Caballero \(person)"
    }else if isMale && age <= 20{
        return "Bienvenido Señorito \(person)"
    }else if !isMale && age > 20{
        return "Bienvenida Señora \(person)"
    }else {
        return "Bienvenida Señorita \(person)"
    }
}```

func greeting(person: String, isMale: Bool, age: UInt8){
    var message: String = "Hola, bienvenid"
    isMale ? (message += "o") : (message += "a")
    
    switch age {
    case 0..<18:
        message += " joven \(person)"
        print(message)
    case 18...:
        isMale ? (message += " señor \(person)") : (message += " señorita \(person)")
        print(message)
    default:
        print("Error. No puede tener edad negativa")
    }
    
}

greeting(person: "Bradley", isMale: true, age: 20)

func greeting (personName: String, isMale : Bool, personAge : UInt8) -> String {
    var saludo = isMale ? "Bienvenido" : "Bienvenida" //operador ternario para ahorrar lineas de codigo
    
    switch personAge {
    case 1..<25:
        saludo += " joven"
    case 25...:
        if isMale {
            saludo += " senhor"
        } else {
            saludo += " senhora"
        }
    default:
        break
    }
    return "\(saludo) \(personName)"
}

greeting(personName: "Kendall", isMale: true, personAge: 21)
//Prompt: "Bienvenido joven Kendall"

Greeting dynamic function with ternary 😃

func greetingDynamic(name: String, isMale: Bool) -> String {
    isMale ? "Welcome Sr. \(name)!"
           : "Welcome Mr. \(name)"
}

func greeting(person: String, isMale: Bool, age: Int) -> String {
    if age <= 20 {
        return isMale ? "Bienvenido, señor \(person)" : "Bienvenida, señorita \(person)"
    } else {
        return isMale ? "Bienvenido, caballero \(person)" : "Bienvenida, dama \(person)"
    }
}

func greeting(person: String, isMale: Bool, age: Int){
    var mensaje = isMale ? "Bienvenido" : "Bienvenida"
    if isMale{
        switch age{
        case ..<18:
            mensaje += " joven \(person)"
        case 18..<40:
            mensaje += " señor \(person)"
        default:
          break
        }
    }else{
        switch age{
        case ..<18:
            mensaje += " joven \(person)"
        case 18..<40:
            mensaje += " señora \(person)"
        default:
            break
        }
    }
    return
}

greeting(person: "Joan", isMale: true, age: 20)
greeting(person: "Mary", isMale: false, age: 17)

Listo
func greetingByAge(personName: String, age: Int, isMale: Bool) -> String {
if isMale {
if age > 30 {
return “Bienvenido Señor (personName)”
}else {
return “Bienvenido Joven (personName)”
}
}else {
if age > 40 {
return “Bienvenida Señora (personName)”
}else {
return “Bienvenida Señorita (personName)”
}
}
}

Reto:

func anothergreetin(person:String, isMale:Bool, age:Int) -> String {
    if isMale {
        switch age {
            case 0...20:
                return "Bienvenido Señorito \(person)"
            default:
                return "Bienvenido Señor \(person)"
            }
    }else{
        switch age {
            case 0...20:
                return "Bienvenido Señorita \(person)"
            default:
                return "Bienvenido Señora \(person)"
            }
    }
}

Usando el switch con where 😄

Mi solución es la siguiente,

func greetToPerson(name:String,age:Int,genere:String)->String {
    
    var greet  = ""
   
    if( genere == "Femenino" ){
        greet = age > 20 ? "hola dama" : "hola señorita"
    } else {
        greet = age > 20 ? "hola caballero" : "hola señorito"
    }
    
    return greet
}

<func greeting2(person: String, isMale: Bool, age: Int) -> String {
    if isMale && age > 18 {
        return "Hola Caballero \(person)"
    }else if isMale && age < 18 {
        return "Hola niño \(person)"
    }else if !isMale && age > 18 {
        return " Hola Señora \(person)"
    }else {
        return "Hola señorita \(person)"
    }
}

greeting2(person: "Juan", isMale: true, age: 20)
greeting2(person: "Jary", isMale: false, age: 50)
greeting2(person: "Gaby", isMale: false, age: 9)
greeting2(person: "Esteban", isMale: true, age: 9)
> 

func greetingss(person: String, isMales: Bool, age: Int) -> String {
    if isMales && age <= 20 {
        return "Bienvenido joven \(person)"
    }else if isMales && age >= 40 {
        return "Bienvenido señor \(person)"
    }else if isMales && age <= 19 {
        return "Bienvenida señrita \(person)"
    }else{
        return "Bienvenida señora \(person)"
    }
}

greetingss(person: "Carlitos ", isMales: true, age: 20)
greetingss(person: "Pedro", isMales: true, age: 43)
greetingss(person: "Dariana", isMales: true, age: 19)
greetingss(person: "Maria", isMales: false, age: 40)

asi lo hice, pero no entiendo como arreglarlo:

func welcomePerson(person: String, isMale:Bool, age:Int)-> String{
    if isMale == true {
        let info = (age)
        switch info {
        case 0...10 :
            return ("bienvenido al parque niño: \(person)")
        case 11..<25 :
            return ("Bienvenido al parque adolcente: \(person)")
        case 25..<100 :
            return("bienvenido al parque señor \(person)")
        default:
            return("usted es muy grande no puede entrar al parque")
        }
        else  {
    let info2 = (age)
    switch info2{
        case 0...10 :
            return ("bienvenido al parque niña: \(person)")
        case 11..<25 :
            return ("Bienvenido al parque serñorita: \(person)")
        case 25..<100 :
            return("bienvenida al parque señora \(person)")
        default:
            return("usted es muy grande no puede entrar al parque")
        }
    }
        print(welcomePerson(person: "lisan", isMale: false, age: 15))
}
print(welcomePerson(person: "lisan", isMale: false, age: 12))
}

func getGrettingMale(age:Int, isMale:Bool) -> String
{
    var responseGretting = ""
    if( isMale)
    {
        
        responseGretting =  age < 20 ? "Bienvenido Joven " : "Bienvenido Caballero "
        return responseGretting
    }
    else{
        responseGretting =  age < 20 ? "Bienvenido Señorita " : "Bienvenido Dama "
        return responseGretting
    }
   
}

func gretting(person: String, isMale:Bool, age:Int) ->String{
    if(isMale)
    {
        return getGrettingMale(age:age,isMale:isMale) + person
       
    }
    else{
        
        return getGrettingMale(age:age,isMale:isMale) + person
    }
}
gretting(person:"Alejandro", isMale:true, age:19)
gretting(person:"Simon", isMale:true, age:21)

gretting(person:"Marta", isMale:false, age:19)
gretting(person:"Daniela", isMale:false, age:21)

func greeting(person: String, age: Int, isMale: Bool) -> String {
    if age >= 18 && isMale{
        return ("Bienvenido \(person), eres mayor de edad")
    }else if age >= 18 && !isMale{
        return ("Bienvenida \(person), eres mayor de edad")
    }
    else {
        return ("Hola \(person) eres menor de edad, no puedes pasar")
    }
    
}

greeting(person: "Juan", age: 10, isMale: true)

func greeting(person: String, isMale: Bool) -> String{
    if isMale{
        return "Bienvenido \(person)"
    }else{
        return "Bienvenida \(person)"
    }
}

greeting(person: "Carlos", isMale: true)
greeting(person: "Juana la alpaca", isMale: false)

Solo conocedores de Juana la alpaca

func goToParty(person : String, isMale : Bool, age : Int ) -> String {
    switch age {
        case 0...18:
            return "Hola " + (isMale ? "señorito": "señorita") + " \(person), eres menor de edad, lo sentimos!"
        case 19...30:
            return "Hola querid" + (isMale ? "o caballero": "a dama") + " \(person), Disfruta!"
        default:
            return "Hola " + (isMale ? "Sr": "Sra") + " \(person), Bienvenido!, aun te queda energia para divertirte!"
    }
}

var firstPerson = goToParty(person : "Carlos Hernandez", isMale : true, age : 79)
var secondPerson = goToParty(person : "Francys Meza", isMale : false, age : 29)
var thirdPerson = goToParty(person : "Fernando Castillo", isMale : true, age : 9)

print(firstPerson)
print(secondPerson)
print(thirdPerson)


/*
Salidas:

Hola Sr Carlos Hernandez, Bienvenido!, aun te queda energia para divertirte!
Hola querida dama Francys Meza, Disfruta!
Hola señorito Fernando Castillo, eres menor de edad, lo sentimos!

*/

func greeting(name: String, isMale: Bool, age: UInt8) -> String {
    if isMale {
        return "Welcome \(age >= 18 ? "Mr." : "yougn") \(name)"
    }
    
    return "Welcome \(age >= 18 ? "Ms." : "miss") \(name)"
}

greeting2(name: "Julian", isMale: true, age: 15)
greeting2(name: "Laura", isMale: false, age: 19)

func saludar(person:String, edad:Int) -> String{
    if edad >= 21 {
        return "hola señor o señora \(person)"
    }else {
        return "hola niño o niña \(person)"
    }
}


saludar(person: "andy", edad: 21)
saludar(person: "aleida", edad: 30)
saludar(person: "daniel", edad: 15)

func welcomeMess ( personaName : String ,isMale:Bool, age: Int) -> String {
  //  let agep
    if !isMale {
    switch age {
        case 5..<10 :
           return "Bienvenida a la fiesta niña \(personaName)"
        case 10..<18 :
            return "Bienvenida a la fiesta Señorita \(personaName)"
        default :
            return "Bienvenida a la fiesta Señora \(personaName)"
    }
        
    } else {
        switch age {
            case 5..<10 :
               return "Bienvenido a la fiesta niño \(personaName)"
            case 10..<18 :
                return "Bienvenido a la fiesta Señorito \(personaName)"
            default :
                return "Bienvenido a la fiesta Señor \(personaName)"
    }
    } 
}

print(welcomeMess(personaName: "Maria", isMale: false, age: 20))
print(welcomeMess(personaName: "Jose", isMale: true, age: 5))

func greeting (person:String, isMale:Bool, edad: Int)-> (Saludo: String, MayorEdad: String){
    if isMale {
        if edad>17 {
            return ("Bienvenido amigo: \(person)","Mayor de edad")
        }
        else {return ("Bienvenido amigo: \(person)","Menor de edad")
            }
    } else{ if edad>17 {
            return ("Bienvenida amiga: \(person)","Mayor de edad")
            }
        
    else { return ("Bienvenida amiga: \(person)" ,"Menor de edad")}
    }
}

print(greeting(person: "Alex", isMale: true, edad:17))

func greetingByGender(person: String, gender: String, age: UInt16) -> String{
    var typeUser = ""
    var txtToReturn = ""
    var welcome = ""
    if gender.lowercased() == "male"{
        welcome = "Bienvenido "
        switch age {
        case 0...12:
            typeUser = "niño"
        case 12...30:
            typeUser = "joven"
        case 25...130:
            typeUser = "señor"
        default:
            return "La edad ingresada es humanamente inaceptable"
        }
        txtToReturn = "\(welcome) \(typeUser)"
    }
    else if gender.lowercased() == "female"{
        welcome = "Bienvenida "
        switch age {
        case 0...12:
            typeUser = "niña"
        case 12...30:
            typeUser = "señorita"
        case 25...130:
            typeUser = "señora"
        default:
            return "La edad ingresada es humanamente inaceptable"
        }
        txtToReturn = "\(welcome) \(typeUser)"
    }
    else{
        return "Para este programa el género ingresado debería ser \"Female\" o \"Male\" "
    }
    
    txtToReturn += " \(person)"
    
    return txtToReturn
}

greetingByGender(person: "Fernando Moreno", gender: "Male", age: 23)

func anotherGreeting(person: String, gender: String, age: Int) -> String {
    switch  (gender, age) {
    case ("m", 0...20):
        return "Hola joven \(person)"
    case ("m", 21...100):
    return "Hola señor \(person)"
    case ("f", 0...20):
    return "Hola señorita \(person)"
    case ("f", 21...100):
    return "Hola señora \(person)"
    default:
        return "none"
    }
  
}
anotherGreeting(person: "Jose Perez", gender: "m", age: 18)
anotherGreeting(person: "Maria Lopez", gender: "f", age: 25)
anotherGreeting(person: "David Lombana", gender: "m", age: 30)
anotherGreeting(person: "Celilia Acosta", gender: "f", age: 16)

func greeting(person: String, isMale: Bool, Age: Int) -> String{
    if isMale {
        if Age <= 30 {
            return "Bienvenido senorito \(person)"
        }else{
            return "Bienvenido Caballero \(person)"
        }
    }else{
        if Age <= 30 {
            return "Bienvenido senorita \(person)"
        }else{
            return "Bienvenida Senora \(person)"
        }
    }
}
greeting(person: "RicardoCelis", isMale: true, Age: 20)
greeting(person: "Olivia", isMale: false, Age: 40)

Reto

func greeting(person: String, isMale: Bool, age: Int) -> String {
    var message = "Bienvenid"

    switch age {
    case 1...20:
        message += isMale ? "o joven " : "a señorita "
        return message + person
    case 21...:
        message += isMale ? "o caballero " : "a señora "
        return message + person
    default:
        return "No puede haber una edad menor que 0"
    }
}
greeting(person: "Ricardo Celis", isMale: true, age: 25)
greeting(person: "Olivia", isMale: false, age: 15)

func greetingWithDic(personInfo : (name:String, age:Int, isMale:Bool)) {
    switch personInfo {
    case let (name, age, isMale) where age < 19 && isMale:
        print("Hola pequeño \(name), no tienes edad suficiente para entrar")
    case let (name, age, isMale) where age < 19 && !isMale:
        print("Hola pequeña \(name), no tienes edad suficiente para entrar")
    case let (name, age, isMale) where age > 19 && isMale:
        print("Hola Mr \(name), Bienvenido!")
    case let (name, age, isMale) where age > 19 && !isMale:
        print("Hola Ms \(name), Bienvenida")
    default:
        break
    }
}```

func greeting(person: String, isMale:Bool, age:UInt8) -> String {
    if age < 20 {
        if isMale {
            return "Bienvenido Señorito \(person)"
        } else {
            return "Bienvenida Señorita \(person)"
        }
    } else {
        if isMale {
            return "Bienvenido Caballero \(person)"
        } else {
            return "Bienvenida Dama \(person)"
        }
    }
    
}

[](

func greeting(person: String, isMale:Bool, age:Int)-> String {
    let info = (age, isMale)
    switch info {
    case (0...18, true):
        return "Bienvenido Señorito, \(person), tu edad es \(age)"
    case (0...18, false):
        return "Bienvenida Señorita, \(person), tu edad es \(age)"
    case (18..., true):
        return "Bienvenido \(person) tu edad es \(age)"
    case (18..., false):
        return "Bienvenida \(person) tu edad es \(age)"
    default:
        return ""
    }
}


greeting(person: "Carlos Petit", isMale: true, age: 15)

🧑🏻‍💻

Mi solucion al reto:

func greeting(person: String, isMale:Bool, edad:Int8) -> String {
    
    let baseMsg = "Bienvenid%genreIndicator% %personCategory% \(person)"
    var genreIndicator = ""
    var personCategory = ""
    var finalMsg:String
    
    if isMale {
        genreIndicator = "o"
    } else {
        genreIndicator = "a"
    }
    
    switch edad {
    case 0...15:
        if isMale {
            personCategory = "niño"
        } else {
            personCategory = "niña"
        }
    case 16...35:
        if isMale {
            personCategory = "joven"
        } else {
            personCategory = "jovencita"
        }
    default:
        if isMale {
            personCategory = "señor"
        } else {
            personCategory = "señora"
        }
    }
    
    finalMsg = baseMsg.replacingOccurrences(of: "%genreIndicator%", with: genreIndicator)
    finalMsg = finalMsg.replacingOccurrences(of: "%personCategory%", with: personCategory)
        
    return finalMsg
}

//Ejercicio
func greeting(person: String, isMale: Bool, age: Int) -> String
{
    if isMale && age <= 20
    {
        return "Bienvenido joven \(person)"
    }else if !isMale && age <= 20
    {
        return "Bienvenida jovencita \(person)"
    }else{
        return "Bienvenido señor/a \(person)"
    }
}

func greeting(person:String, isMale:Bool, age: UInt8) -> String {
    if isMale {
        return "Bienvenido \(age > 20 ? "caballero":"jovencito") \(person)"
    } else {
        return "Bienvenida \(age > 20 ? "Señorita":"jovencita") \(person)"
    }
}

greeting(person: "Luis",isMale: true,age:40)
greeting(person: "Fernanda",isMale: false,age:10)

func greeting(person: String, isMale:Bool, age: Int) -> String{
    
    switch age {
    case 0..<15:
        if isMale{
            return "Bienvenido niño \(person)"
        }else{
            return "Bienvenida niña \(person)"
        }
    case 15..<30:
        if isMale{
            return "Bienvenido joven \(person)"
        }else{
            return "Bienvenida señorita \(person)"
        }
    case 30..<120:
        if isMale{
            return "Bienvenido señor \(person)"
        }else{
            return "Bienvenida señora \(person)"
        }
    default:
        return "La edad ingresada no es válida"
    }
}

greeting(person: "Julio", isMale: true, age: 15)
greeting(person: "Fiorella", isMale: false, age: 30)

// Challenge add new parameter age in the function and add some validation with this

func greetingPerson(person: String, isMale: Bool, age: UInt8) -> String {

    switch age {
    case 0..<18:
        return "Hola Bienvenid\(isMale ? "o" : "a") \(isMale ? "niño" : "niña") \(person)"
    case 18..<30:
        return "Hola Bienvenid\(isMale ? "o" : "a") joven \(person)"
    case 30...:
        return "Hola Bienvenid\(isMale ? "o" : "a") sr\(isMale ? ".":"a.") \(person)"
    default:
        return "Edad no puede ser menor a 0"
    }
}

print(greetingPerson(person: "Felipe", isMale: true, age: 28))
print(greetingPerson(person: "Enrique", isMale: true, age: 57))

func saludo(person: String, isOlder30: Bool, isMale: Bool) -> String
{
    if isOlder30 == true && isMale == true{
        return "Hola Señor, \(person)"
    }
    else if isOlder30 == true && isMale == false{
        return "Hola Señorita, \(person)"
    }
    else if isOlder30 == false && isMale == true{
        return "Hola Joven, \(person)"
    }
    else if isOlder30 == false && isMale == false{
        return "Hola Jovencita, \(person)"
    }
    else {
        return "Hola \(person)"
    }
}

saludo(person: "Yael", isOlder30: false, isMale: true)

func helloPerson(person: String, isMale: Bool, age: Int) -> String {
    var message = "Bienvenid"
    isMale ? (message += "o") : (message += "a")
    
    if isMale && age <= 20 {
        return "\(message) joven \(person)"
    }else if !isMale && age <= 20{
        return "\(message) joven \(person)"
    }else if isMale && age > 20{
        return "\(message) Caballero \(person)"
    } else {
        return "\(message)) Señorita \(person)"
    }
}

Saludos compañeros, podemos llamar a otras funciones desde una función para que el código quede mejor organizado.

![](

func greeting(person: String, isMale: Bool, age: Int) -> String{

if isMale && age > 20{
    return "Bienvenido Caballero \(person)"
}else if isMale && age <= 20{
    return "Bienvenido Señorito \(person)"
}else if !isMale && age > 20{
    return "Bienvenida Señora \(person)"
}else {
    return "Bienvenida Señorita \(person)"
}

}
greeting(person: “Santiago”, isMale: true, age: 21)```