Respuestas Ejercicio 50 (JS Noviembre)

Comparte tu respuesta del ejercicio 50. (ESNext)

//Crea una función llamada max (puede ser normal o función flecha) que reciba un arreglo de números como argumento y retorne el número mayor.

Mi respuesta:

// escribe tu solución acá
    const max = arr => {
      let maxNum = arr[0];
      for(let i = 1; i < arr.length; i++) {
        if(arr[i] > maxNum) 
          maxNum = arr[i];
      }
      return maxNum;
    } 

    // código de prueba
    console.log(max([1, 2, 3, 4])) // 4
    console.log(max([63, 85, 39, 24, 3])) // 85
// escribe tu solución acá
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

//Ejercicio50.

const max = arr => {

    arr.sort()

    return arr[arr.length - 1]

}

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

function max(arreglo)
{
maxi = 0;
for(var i=0;i<arreglo.length;i++)
{
if(maxi< arreglo [i])
maxi = arreglo [i];
}
return maxi;
}

let max = (array) => array.sort((a,b)=>a<b? 1:-1)[0];
const max = (arreglo) => {
  let mayor=0;
  for(let index=0;index<arreglo.length;index++){
    if (arreglo[index]>mayor){
      mayor = arreglo[index];
    }
  }
  return mayor;
};
let max1 = (array) => array.reduce((a,b)=>a>b? a:b);

Respuesta ejercicio 50

const array=[1,2,3,4]
let max=0
for(let num of array){
  if(max<num)
  max=num
}
console.log(max)

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

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

La respuesta al ejercicio seria

function max(objeto) {
    return Math.max(...objeto)
};
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)


Mi respuesta al ejercicio es:

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

Hola, mi respuesta es:

const max = (numeros) => numeros.reduce((a,b)=>a>b? a:b)

Buen día, comparto a continuación la respuesta al ejercicio #50, feliz noche.

Ejercicio 50

Crea una función llamada max (puede ser normal o función flecha) que reciba un arreglo de números como argumento y retorne el número mayor.

Nota: No utilices el método Math.max de JavaScript.


const max = array=> array.reduce(function (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

const max = arr => {
  let maxVal = arr[0];
  
  arr.filter(item => item > maxVal ?    maxVal = item : null)
  return maxVal;
}

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

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