No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Static

11/25
Recursos

Aportes 26

Preguntas 2

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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 鈥渦ndefinded鈥.

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]);
}