Static

solo no inicializar el max

numbers.reduce((max, item) => max > item ? max : item);

Ésta ha sido mi solucion al reto…

La solución es simplemente no pasar el segundo parametro del reduce.

El primer parametro del reduce es el callback donde se ejecuta la operación del reduce y el segundo es un parametro opcional que indica el valor inicial del acumulador, por defecto, el valor inicial del acumulador es la primera posición del array y curr empezaría desde la siguiente posición.

static max(...numbers: number[]) {
    return numbers.reduce((acc, curr) => acc > curr ? acc : curr);
}

Infinitas formas de hacer los mismo…

  static max(...numbers: number[]) {
    return numbers.reduce((max, item) => max >= item ? max: item, -Infinity);
  }

Los miembros de una clase son las propiedades y los métodos. Cuando creamos un objeto, ese objeto realiza una copia de todos los miembros(propiedades y métodos que no sean estáticos). Los miembros estáticos sólo le pertenecen a la clase y no al objeto.

class MyMath {
  public static PI:number = 3.14;
  private static getNumber():number{
    return this.PI;
  }
}

const nerd = new MyMath();
//El objeto no puede acceder a las propiedades estáticas de la clase
nerd.PI //error, esta propiedad es estática
//La Clase:
MyMath.PI; //permite acceder a esta propiedad
MyMath.getNumber(); //No puede ser accedido porque aunque es static es private

Si reduce tiene definido un valor inicial (el segundo parámetro que recibe reduce), la función reductora va a tomar este segundo parámetro como primer argumento en la primera llamada de la función callback.
Si dejamos el 0 en nuestra función max, al ser procesado por el reduce, cuando reciba valores negativos siempre tomará dicho valor cero, pues seria el valor inicial.

class MyMath {
  static readonly PI = 3.14;

// Static nos permite hacer un llamado de los valores dentro de la clase sin la necesidad de una instancia

  static max(...numbers: number[]) {
    return numbers.reduce(
	(max,item) => max >= item ? max : item
    );
  }
}

Mi respuesta, usando el último elemento en lugar del primero:

static max(...numbers: number[]) {
    return numbers.reduce((max, item) => max >= item ? max : item, numbers[numbers.length - 1]);
  }

Lo raro es que se me olvidó poner el -1 en el último arreglo, y de todas maneras funcionó, la parecer también funciona cuando el valor de comparación es “undefinded”.

se puede iniciar con el primer valor del array

class MyMath {
  static readonly PI = 3.14; // con static puedo usarlo como javascript lo usa normal, yt con readonly evito el cambio despues

  static max (...numbers: number[]) {
    console.log(numbers);
    return numbers.reduce((max, item)=> max >= item ? max: item, numbers[0]);
  }

}

initial es el primer valor del array y current el segundo, luego el reduce irá iterando y moviéndose.

static max(...numbers:number[]){
    return numbers.reduce((initial, current)=>{
      return initial >= current ? initial : current;
    });
}

console.log(MyMath.max(-5, -2, -20)) //-2

Lo resolví de la siguiente manera:

static max(...numbers: number[]) {
    return numbers.reduce((max, item) =>
      (max >= item) ? max : item,
      numbers.length == 0 ? 'Ingresa al menos un número' : -Infinity
    );
  }

Yo usé sort() para max, donde devuelvo el primer valor del nuevo array que sería el mayor, aunque reduce() es más eficiente en cuanto a rendimiento, pero sort fue lo primero que se me ocurrió:

static max(...args: number[]) {
	return args.sort((a, b) => b - a)[0];
}

Mi solucion fue esta

numbers.sort((a,b) => a - b);
return numbers[numbers.length - 1];

Mi solucion al reto:

  static max(...numbers: number[]) {
    let maxNum = numbers[0]

    for (let i = 0; i < numbers.length; i++) {
      if (numbers[i] > maxNum) {
        maxNum = numbers[i]
      }
    }
    return maxNum
  }

Paso otra forma de resolverlo, me pareció bastante ingeniosa:

static max(...numbers: number[]): number {
    try {
      numbers.sort((a: number, b: number) => {
        return b - a;
      });
    } catch {
      throw 'Error calculate max number'
    }
   return numbers[0];
  }
}

return numbers.reduce((max,item) => max >= item ? max:item);
Quitarle el punto de comparación 😃

Buenas tardes,

comparto reto:

    static max(...numbers: number[]) {
        return numbers.reduce((max, item) => max >= item ? max : item);
    }

se le quita la variable inicial ya que por defecto el toma el primer elemento del array enviado.

return numbers.reduce((max, item) => max >= item ? max : item, numbers[0]);

Asi es como hace las clases java :0

Reto

static max (...number: number[]){
        return number.reduce((max,item) => max >= item ? max: item, number[0] );
    }

mi solucion:

static max(...numbers: number[]){
        return numbers.sort((a,b)=>{return b - a})[0];
    }

Mi reto … defines el valor minimo con reduce y lo usas para el siguiente reduce.

Pero vi la solucion de Paul, es bastante mas simple aunque no entiendo como funciona el reduce a esa profundad

 max(...numbers: number[]): number {
        const minValue = numbers.reduce((min, item) => min <= item ? min : item, 0)
        return numbers.reduce((max, item) => max >= item ? max : item, minValue)
    }

El problema está en que la variable max, se está inciiando en 0, por lo que 0 siempre será mayor que cualquier número negativo. En este caso habría que iniciar la variable ya sea con el valor de la primera posición o el de la última;

profe esta mal usar otro reducer?

static max(...numbers: number[]) {
    return numbers.reduce(
      (max, item) => (max >= item ? max : item),
      numbers.reduce((a, b) => (a <= b ? a : b))
    );
  }

Una manera usando el sort

static max(...numbers: number[]) {
  return numbers.sort((a, b) => b - a)[0]
}

Mi solucion al reto

static max(...numbers: number[]) {
    return numbers.reduce((max, i) => (i > max ? i : max), numbers[0]);
}