func prefijos(prefijo: String, palabras: [String]) -> [Bool] {
    if palabras.isEmpty {
        return []
    }
    let primera = palabras[0]
    let resto = Array(palabras[1...]) 
    return [primera.hasPrefix(prefijo)] + prefijos(prefijo: prefijo, palabras: resto)
}


func ParejaMayorParImpar(numeros: [int]) -> (int, int){
    if numeros.isEmpty{
        return (0.0)
    }
    let primero = numeros[0]
    let resto = Array(numeros[1...])
    let (maxImparResto, MaxParResto) = ParejaMayorParImpar(numeros : resto)
    var nuevoMaxImpar = maxImparResto
    var nuevoMaxPar = MaxParResto
    if primero % 2 == 0{
        if primero > maxParResto{
            nuevoMaxPar = primero
        }
    }
    if primero % 2 == 0{
        if primero > maxImparResto{
            nuevoMaxImpar = primero
        }
    }
    return (nuevoMaxImpar, nuevoMaxPar)
}

//3
func compruebaParejas(_ numeros: [Int], funcion: (Int) -> Int) -> [(Int, Int)] {
    if numeros.count < 2{
        return[]
    }
    let primero = numeros[0]
    let segundo = numeros[1]
    let resto = Array(numeros[|1...])
    if segundo == funcion(primero){
        return[(primero,segundo)]+ compruebaParejas(resto, funcion: funcion)
    }else{
        return compruebaParejas(resto, funcion: funcion)
    }
}
func coinciden(parejas: [(Int,Int)], funcion: (Int)->Int){
    if parejas.isEmpty{
        return []
    }
    let primero = parejas[0]
    let resto = Array(parejas[1...])
    let evaluacion = funcion(primera.0) == primera.1
    return [evaluacion] + coinciden(parejas: resto, funcion: funcion)
}
//4
enum Movimiento {
    case deposito(Double)
    case cargoRecibo(String, Double)
    case cajero(Double)
}
func aplica(movimientos:[Movimiento]){
    if movimientos.isEmpty{
        return(0.0,[])
    }
    let actual = movimientos[0]
    let resto = Array(movimientos[1...])
    let (saldoResto, reciboResto) = aplica (movimientos: resto)
    switch actual{
        case .deposito(let cantidad):
        return  (cantidad + saldoResto, reciboResto)
        case .cargoRecibo (let concepto, let cantidad)
        return (saldoResto-cantidad, [concepto]+ reciboResto)
        case .cajero(let cantidad):
        return (saldoResto - cantidad, reciboResto)
    }
}

//5
enum ArbolBinario{
    case nodo(int, ArbolBinario, ArbolBinario)
    case vacio
}
func suma(arbolb: ArbolBinario){
    switch arbolb{
        case .vacio:
        return 0
        case .nodo(let valor, let hijoIzquierdo, let hijoDerecho):
        return valor + suma(arbolb : hijoIzquierdo)+ suma(arbolb + hijoDerecho)
    }
}
//6
enum Arbol{
    case nodo(int, [Arbol])
}
func suma(arbol: Arbol, cumplen :(int) -> bool) -> int{
    switch .arbol(let nodo, let hijos){
        let sumahijos = suma(bosque: hijos, cumplen: cumplen)
        if cumplen(dato){
            return dato+ sumahijos
        }else{
            return sumahijos
        }
    }
}
func suma(bosque: [Arbol], cumplen: (int)-> bool) -> int{
    if bosque.isEmpty{
        return 0
    }
    let primeraArbol = bosque[0]
    let restoArbol = Array(bosque[1...])
    return suma(arbol: primeraArbol, cumplen: cumplen) + suma(bosque: restoArbol,cumplen :cumplen)
}