Respuestas Ejercicio 51 (JS Noviembre)

Comparte tu respuesta del ejercicio 51. (ESNext)

const max = (...arreglo)=> {
  let auxiliar = arreglo[0];
  arreglo.map(valor => {
    if(auxiliar<valor){
      auxiliar = valor;
    }
  })
  return auxiliar;
} 
// código de prueba
console.log(max(1, 2, 3, 4)) // 4
console.log(max(63, 85, 39, 24, 3)) // 85

Ejercicio51.

const max = (...arr) => {

    arr.sort()

    return arr[arr.length - 1]

}

console.log( max(6,7,8,1,2))

console.log(max(63, 85, 39, 24, 3))
const max = (...argumentos) => {
  let mayor=0;
  for(let index=0;index<argumentos.length;index++){
    if (argumentos[index]>mayor){
      mayor = argumentos[index];
    }
  }
  return mayor;
};

function max(arreglo)
{
const max=Math.max(…arreglo)
return max

}

Encontré estas dos opciones

let max = (...ar) => ar.sort((a,b)=>a<b? 1:-1)[0];

let max1 = (...ar) => ar.reduce((a,b)=>a>b? a:b);

const max = (…args) => {
return Math.max(…args)
}

My approach:

const max = (...num)=> {
  let maxValue = num[0];
  num.map(item => {
    if(maxValue < item){
      maxValue = item;
    }
  })
  return maxValue;
} 
// código de prueba
console.log(max(1, 2, 3, 4)) // 4
console.log(max(63, 85, 39, 24, 3)) // 85

2- approach:

const reducer = (a, b) => a > b ? a : b

let max= (...arr) => arr.reduce(reducer);
const max = (...numeros) => Math.max(...numeros);
const  max = (...num)=>{
  let nMax= 0;
  const maximo = num.forEach(number =>{
    if(number > nMax)nMax = number
  })
  return nMax
};

let max_ = (…arreglo) => {
let aux = -1;
for (let index = 0; index < arreglo.length; index++) {
if (arreglo[index] > aux) {
aux = arreglo[index];
}
}
return aux;
};

Mi propuesta de solución es la siguiente:


let max = (…numbers) => numbers.reduce((num1,num2) => num1>num2? num1:num2)


Hola, mi respuesta es:

const max = (...nums) =>{
nums.sort()
return nums[nums.length - 1]
}

Buen día, comparto resultado del ejercicio #51, feliz semana.

Ejercicio 51 (Bonus)
Modifica el ejercicio anterior para que la función max no reciba un arreglo sino un número indeterminado de argumentos.


const max = (...array) => array.reduce((acc,item) => {
        if (acc > item){
            return acc;
        }else{
            return item;
        }
    },0);


// código de prueba
console.log(max(1, 2, 3, 4)) // 4
console.log(max(63, 85, 39, 24, 3)) // 85

function max(…arreglo) {
let x = arreglo[0];
arreglo.forEach(element => {
if(element>x) {
x = element;
}
});
return x;
};

Esta es mi respuesta a este Ejercicio:


const max = (...array) => array.reduce((acc,item) => {
        if (acc > item){
            return acc;
        }else{
            return item;
        }
    },0);

console.log(max(1, 2, 3, 4)) // 4
console.log(max(63, 85, 39, 24, 3)) // 85

const max = (...nums) => Math.max(...nums)

Mi respuesta para el ejercicio 51 :

function max(...elem) {
    let mayor = 0;
    for (let i = 0; i < elem.length; i++) {
        if (elem[i] > mayor) {
            mayor = elem[i];
        }
    }
    return mayor;
}

// código de prueba
console.log(max(1, 2, 3, 4)) // 4
console.log(max(63, 85, 39, 24, 3)) // 85