Etiquetas de Params y Variadics

Reto

func mediaGeometrica(_ numbers: Double...) -> Double{
    var total: Double = 0
    for number in numbers {
        //Se multiplican todos los elementos
        if total == 0 {
            total = number
        }else{
            total *= number
        }
    }
    /* pow lo que hace es darnos la potencia del valor proporcionado
        pero de acuerdo con la formula de la media geometrica
        necesitamos obtener la raiz de N elementos por eso hay que
        dividir la cantidad de elementos para obtener el valor correcto */
    return pow(total, 1/Double(numbers.count))
    
}
print(mediaGeometrica(1.20,1.15,1.33,1.25))

y por qué no simplemente nombrar las variables como los alias ? 🧐

En los Variadics no seria mejor enviar un array?, a menos que tengan una utilidad mayor no le encuentro el sentido a incorporar nuevos conceptos para realizar algo que ya se podia resolver de una manera mas intuitiva.

func meanGeometry (_ numbers:Double...) ->Double {
    
    var expo = numbers.count
    var product = numbers.reduce(1,*)
    
    return pow(product, 1/Double(expo))
}

print(meanGeometry(1,2,3,4))

func geometricMean(_ numbers: Double...) -> Double {
    let product = numbers.reduce(
        1.0,
        { x, y in x * y}
    )
    //nth root https://stackoverflow.com/questions/30203542/how-to-find-the-nth-root-of-a-value
    return pow(
        product,
        (1/Double(numbers.count))
    )
}

func geomean(_ numbers:Double...)->Double{
    var total:Double = 1.0
    for number in numbers {
        total *= number
    }
    return pow(total,1/Double(numbers.count))
}
geomean(1,2,3,4)

// TAREA: Hacer función para la media geometrica
func geometricMean(_ numbers: Double...) -> Double {
    let numberToElevate = Double(numbers.count)
    var multiplying : Double = 1.0
    
    for number in numbers {
        multiplying *= number
    }
    
    return pow(multiplying, 1.0/numberToElevate)
}

geometricMean(2,4,8)

func geoMean(_ numbers: Double) -> Double {
    var total: Double = 1 //si no se multiplicarian todos por 0
    var n: Int = numbers.count
    for number in numbers {
        total *= number
    }
    return pow(total, 1/Double(n))
}

Reto ✓
el método pow resuelve la raíz de un número, y recibe como parámetros dos números, en donde el primer parámetro representa el radicado y el indice es el segundo parámetro

func mediaGeometrica(_ numbers: Double...) -> Double{
    var total: Double = 0
    let expo = Double(numbers.count)
    for number in numbers {
        total *= number
    }
    return pow(total, 1.0/expo)
}

Listo!!
func mediaGeometrica(_ numbers: Double…) -> Double {
var total:Double = 1.0
for number in numbers{
total *= number
}
return pow(total,1 / Double(numbers.count))

}

arreglando la de mean, lo hice asi:

func mean(_ numbers: Double...) -> Double{
    var total : Double = 1
    for number in numbers{
        total *= number
    }
    return pow(total, 1/Double(numbers.count))
}

func GetMediGeometrica(_ numbers:Double...) -> Double {
    var total:Double = 1.0
    for number in numbers{
        total *= number
    }
    return pow(total,1/Double(numbers.count))
    
}
print(GetMediGeometrica(1.20,1.15,1.33,1.25)) 

func mediaGeometrica(numbers: Double...) -> Double {
    var resultado = 1.0
    for num in numbers {
        resultado *= num
    }
    return pow(resultado, 1/Double(numbers.count))
}

print(mediaGeometrica(numbers: 1,2,3,4,5))

func arithmeticAverage(_ numbers2: Double ...) -> Double{
    var total2: Double = 1
    for number2 in numbers2{
        total2 *= number2
    }
    return powl(total2, 1/Double(numbers2.count))
}
arithmeticAverage(1,2,3,4,5,6,7,8,9)

func mediaGeometrica(de numeros: [Double]) -> Double {
    guard !numeros.isEmpty else { return -1}
    var mediaGeometrica = numeros.first!
    
    for numero in numeros[1..<numeros.count] {
        mediaGeometrica *= numero
    }
    
    mediaGeometrica = sqrt(mediaGeometrica)
    return mediaGeometrica
}

func minMax(array:[Int]) -> (min: Int, max: Int)?{
    if array.isEmpty{
        return nil
    }
    var currentMin = array[0]
    var currentMax = array[0]
    
    for value in array[1..<array.count]{
        if value < currentMin{
            currentMin = value
        }else if value > currentMax{
            currentMax = value
        }
    }
    
    return (currentMin, currentMax)
}

let bounds = minMax(array: [-6,8,100,0,-9,16])
let bounds2 = minMax(array: [])

func someFunction(f1 firsParamName: String, f2 secondParamName: String){
    //f1 es la etiqueta de firsParamName
    //firsParamName es el primer parámetro de tipo String
    
    //f2 es la etiqueta de secondParamName
    //secondParamName es el segundo parámetro de tipo String
}

someFunction(f1: "Hi", f2: "Hello")
// es lo mismo que usar firsParamName y secondParamName


//usar valores por defecto:
func anotherFunction(_ firstPersonName: String, f2 secondParamName: String = "Goku"){
    // _ es que no pondré nombre a la variable 1 a la hora de llamarla
    
    //Goku es el valor por defecto de f2.
    /*
     Si yo llamo a anotherFunction y no le paso f2, tomará el valor por defecto.
     */

}


// si hay muchas variables y no sé cuáles:

func mean(_ numbers: Double...) -> Double{
    var total: Double = 0
    for number in numbers{
        total += number
    }
    return total / Double(numbers.count)
}

var media = mean(18.0, 19.0, 20.0, 19.5)

func midlGeo (_ number : Double...) -> Double {
    var resul : Double = 1
    for i in number {
        
        resul *= i
    }
    
    return pow(resul,(1/Double(number.count)))
}

var arch = midlGeo(10, 20)

print(arch)

func mediaGeometrica(_ numbers: Double...) -> Double{
    var total : Double = 1;
    for number in numbers {
        total *= number;
    }
    return pow(total, 1/Double(numbers.count));
}

func mediaGeometrica(_ numeros:Double...) -> Double? {
    if numeros.count == 0 {
        return nil
    }
    var total: Double = numeros[0]
    for valor in numeros[1..<numeros.count] {
        total *= valor
    }
    return pow(total, 1.0/Double(numeros.count))
}
mediaGeometrica(1,2,3)

func geometricMean(_ numbers: Double...) -> Double {
    var total : Double = 1
    for number in numbers{
        total *= number
    }
    return pow(total, 1/Double(numbers.count))
}

geometricMean(4, 5)

func geoMean(_ numbers: Double...) -> Double{
    var total: Double = 1
    for number in numbers {
        total *= number
    }
    return pow(total,1 / Double(numbers.count))
}

geoMean(1,2,3)

Reto:

func geometricMean(_ numbers:Double...) -> Double{
    var total:Double = 1
    for number in numbers {
        total *= number
    }
    return pow(total, (1/Double(numbers.count)))
}
geometricMean(2, 8)
geometricMean(2, 50)
geometricMean(1, 2, 3, 4)
geometricMean(1.2, 4.3)

func mediaGeometrica(_ numbers:Double...) -> Double? {
    if numbers.count == 0 {
        return nil
    }
    var total: Double = numbers[0]
    for number in numbers[1..<numbers.count] {
        total *= number
    }
    return pow(total, 1.0/Double(numbers.count))
}

mediaGeometrica(1,2,3,4,5)

//Reto

func geometricMean(_ numbers: Double...) -> Double{
    var total : Double = 1
    for number in numbers {
        total *= number
    }
    return pow(total, 1/Double(numbers.count))
}
geometricMean(3,5,12)

Que bonito es lo bonito!!!

func mg(_ numbers: Double...) -> Double {
    var total: Double = 1
    for number in numbers{
        total = total * number
    }
    return pow(total, 1/Double(numbers.count))
}


let value = mg(1.1,1.2,1.3,1.4)```

Sentimientos encontrados con las etiquetas

// reto

func mediaGeometrica(_ numbers: Double...) -> Double{
    var total: Double = 1
    for number in numbers{
        total *= number
    }
    
    return pow(total, 1/Double(numbers.count))
}

print(mediaGeometrica(1.20, 1.15, 1.33, 1.25))