Aprovecha el precio especial y haz tu profesión a prueba de IA

Antes: $249

Currency
$209
Suscríbete

Termina en:

0 Días
5 Hrs
17 Min
27 Seg

Reto 9: traduce un algoritmo a JavaScript

6/17

Lectura

¡Hola, Platzinauta!

...

Regístrate o inicia sesión para leer el resto del contenido.

Aportes 1007

Preguntas 21

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Aquí va mi aporte!!

//declaramos el array

let numbers = [2,3,6,1,8,4];

//variable que mide/almacena el tamaño del array

let length = numbers.length;

//variable que almacena el número más grande

let maxNumber = 0;

//ciclo que inicia en la posición 0 del array, lo recorre por completo y, cuando se encuentra un número mayor al "maxNumber", lo sustituye

for (let i = 0; i < length; i++) {
  if(maxNumber < numbers[i]) {
    maxNumber = numbers[i];
  }
}

//Imprimimos en consola el resultado

console.log("El número más alto es " + maxNumber);
 
let array = [10,20,6,567,9,4,13];
let max = 0;

for (let i = 0; i < array.length; i++) {
  if(array[i] > max) {
    max = array[i];
  }
}

console.log(max);

espero se entienda


//Declaramos el array (se declara con la palabra let +el nombre deseado)
let nums = [1, 0, 69, 5, 90, 13];

//variable para guardar el muero maximo, incializada en 0
var maxima = 0;

//ciclo for para recorres el Array
//usamos .length para saber la cantidad de elemptos en el arrayn y hacer la iteracion
for (var i = 0; i < nums.length; i++)
{
  if (maxima < nums[i]) //nums[i] para caopara cada posion del array
  {
    maxima = nums[i]; //se va guardando el numero mas grande
  }
}

console.log(maxima); //imprimimos el numero mas grande

Apenas empezando y entendiendo algunas palabras sobre programación y salen con esto, la verdad es que desanima

si uno solo conoce lo que se ha enseñado en los cursos vistos y antes de eso tenia cero conocimiento en el tema, este tipo de ejercicios me parecen absurdos en tanto que se desconoce completamente como se utilizan las palabras etc.

Che, creo que podrían explicar un poco más antes de largar algo como esto, se supone que es un curso para principiantes. En el curso anterior de pensamiento lógico explicaron el concepto de array pero no aplicado al código y tampoco explicaron casi nada de la sintaxis de javascript. El curso de javascript está mucho más adelante en la ruta de desarrollo web.

Aunque no lo crean, algunas veces este mismo ejercicio es usado en pruebas técnicas.

buenas tardes yo estoy desde cero y estoy perdido gracias

Aquí está mi solución, he decidido usar un while, ya que he visto que muchos usaban un for, así hay más variedad en la solución 😃

var array = [3, 2, 1];
var max = 0;
var i = 0

while (i < array.length){
    if (max < array[i]){
        max = array[i]
    }
    i++
}
console.log (max) 

Hola, siento que fue un ejercicio avanzado para los que hasta ahora estamos familiarizándonos con el tema, me guie revisando varios ejemplos de los otros estudiantes 😃

Aqui una explicacion paso por paso de las partes del algoritmo, a mi me costo bastante entender el significado de “i” en su momento por que es un poco abstracto, asi que les dejo mi humilde aporte para quien le pueda servir, saludos!

//declaracion del array numeros y la variable max:

let numeros = [8, 556, 15, 78, 2318, 54, 74]
let max = 0;

// la variable "i" dentro del bucle nos permite iterar dentro del array, es decir que es la posicion en la que vamos a estar evaluando la condicion IF, en la primera vuelta evaluaremos la condicion en el espacio 0 del array (cuyo valor es 8), en la segunda vuelta la posicion de "i" sera 1, con lo cual el valor que evaluaremos sera 556 etc.
//explicacion del bucle FOR: (partiendo de que i = 0; siempre que i sea menor a la longitud del array; sumaremos una vuelta)
//explicacion comprobacion IF (Siempre que max sea menor a el valor que encontramos en i, el valor de max sera modificado por el valor que encontramos en i)

for (let i = 0; i < numeros.length; i++) {
  if (max < numeros[i]) {
    max = numeros[i];
  }
}
console.log(max)

//para un mejor entendimiento es posible colocar varios console.log dentro 
// El primero de ellos muestra el valor que se va a estar comprobando en cada vuelta, en caso de que la condicion se cumpla el mismo ingresa al bucle, en caso de que no, vuelve a inicar el bucle con la siguiente posicion del array.
//El segundo console.log muestra cual es el valor actual de max1
//El tercer console.log muestra cual es el nuevo valor de max1

let numeros1 = [8, 556, 15, 78, 2318, 54, 74]
let max1 = 0;

for (let i = 0; i < numeros1.length; i++) {
  console.log("valor de numeros1 que se va a comprobar: " + numeros1[i])
  if (max1 < numeros1[i]) {
    console.log("valor de max1: " + max1);
    max1 = numeros1[i]
    console.log("nuevo valor de max1: " + max1);
  }
}
console.log("Este es el valor final de max1: " + max1)


<code> 

El Diagrama de flujo en la primera decisión está mal elaborada la pregunta para todo array de Números Naturales . La condición nunca se cumpliría y por ende no se podría conocer el valor máximo.

Además el Código javascript usado en la solución del reto no corresponde al mismo del diagrama de flujo.

let matriz = [22,43,5,8,31];
let max = 0;
let longitud = matriz.length;

for (let i = 0; i<longitud; i++){

if (matriz[i] > max){
 max = matriz[i];
 }
 }
console.log('Máximo valor es de = ',max)

Les quiero presumir que logre hacerlo, se me complico, revise apuntes de los cursos de pensamiento lógico anteriores, investigue en la pagina de javascript que recomendó la profe y taran!, se logro el objetivo.

Si se me dificultó, pero después de leer mucho, lo logre.

En Javascript, puedes utilizar un bucle for para encontrar el número mayor de una lista. El algoritmo sería:

  • Inicializa una variable llamada max con el primer elemento de la lista.
  • Recorre cada elemento de la lista con un bucle for.
  • Compara cada elemento con la variable max. Si el elemento es mayor que max, asigna el valor del elemento a max.
  • Al final del bucle, la variable max contendrá el número mayor de la lista.

Aquí está el código en Javascript que implementa este algoritmo:

var lista = [10, 2, 5, 8, 3]; // ejemplo de lista de números
var max = lista[0]; // inicializa max con el primer elemento de la lista

for (var i = 1; i < lista.length; i++) { // recorre cada elemento de la lista
  if (lista[i] > max) { // compara el elemento actual con max
    max = lista[i]; // si es mayor, actualiza max
  }
}

console.log(max); // imprime el número mayor de la lista

Este código imprimirá 10 en la consola, que es el número mayor de la lista [10, 2, 5, 8, 3].

  • Esta es mi solución
let numeros = [20, 10, 122, 660, 8]
let max = 0
let tamano = numeros.length

for (let i=0; i<tamano; i++) {
  if(max < numeros[i]) {
    max = numeros[i]
  }
}

console.log("el numero mas alto es " + max)

DECLARAR UNA VARIABLE : Var,let, const
• Las declaraciones var tienen un ámbito global o un ámbito función/local, mientras que let y const tienen un ámbito de bloque.

• Las variables var pueden ser modificadas y re-declaradas dentro de su ámbito; las variables let pueden ser modificadas, pero no re-declaradas; las variables const no pueden ser modificadas ni re-declaradas.

• Todas ellas se elevan a la parte superior de su ámbito. Pero mientras que las variables var se inicializan con undefined, let y const no se inicializan.

Mientras que var y let pueden ser declaradas sin ser inicializadas, const debe ser inicializada durante la declaración.

https://www.freecodecamp.org/espanol/news/var-let-y-const-cual-es-la-diferencia/

CREAR UN ARRAY :

Referencia: https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Array

que???
es una broma???
apenas escribí mi primer lineal de código y me piden esto???
changos, esto es mas difícil de lo que pensé.

costo pero salio 😄

let numbers = [1, 2, 3, 4, 5, 6, 10, 100, 564, 693]
let max = 0
encontrarNumeroMayor()
function encontrarNumeroMayor(){
    for(let i = 0; i < numbers.length; i++)
      if(max < numbers[i]){
        max = numbers[i]
      }
    console.log(max)  
} 

Buenas noches comparto mi código

// Creando el arreglo
let array = [15,20,35,35,6452,45,78,35,54,95,65,12]
numMaximo = 0;

for ( let i = 0; i < array.length ; i++)
{
    if ( numMaximo > array[i])
    {
        numMaximo
    }
    else
    {
        numMaximo = array[i]
    }
    
}
console.log(numMaximo);

.

Quiero empezar los cursos siguiendo la ruta pero la neta es que no enseñan nada bien, ni siquiera nos han enseñado a recorrer el array y ya nos ponen un ejercicio, desanima y aparte hace dudar la calidad de la plataforma, dicho sea de paso la calidad de estos 3 cursos es bajísima.

no pues si para hacer esto tengo que investigar la mayoria de cosas (porque no se han visto) para que pague? cada clase me arrepiento mas

Esto es muy avanzado, y no hemos visto esos comandos. Tengo dolor de cabeza pensando como resolverlo.

Mi aporte en imagen, y debo decir que procrastiné por muchos días y tuve que leer información técnica de JavaScript para poder entender bien esto. Soy una persona que le tienen que explicar todo, como decimos aquí en México, con palitos y bolitas, es decir, muy meticulosamente, para poder entender bien las cosas. Adjunto mi código con notas de que hace cada cosa, a ver si a alguien le funciona así para entenderlo mejor, a ver si con tanta nota no les confundo más.

Para Platzi: aquí lo que veo que faltó fue uno o dos videos antes de esto donde explicasen nociones básicas de que son las palabras reservadas, las estructuras de las sentencias y cosas así, para gente que jamás había visto código en su vida. Yo tengo experiencia muy pero muy limitada en cuanto a código, al final pude, pero si veo en los comentarios que generó mucha frustración.

Creo que hay algo mal aqui, estoy haciendo la ruta de aprendizaje de fundamentos de Programacion de la escuela de desarrollo web, y este ejercicio es muy avanzado para verse luego de una clase de “primeros pasos”, cuando recien veré un curso Basico de Javascript cuando llegue a la parte de Perfiles Profesionales, si bien se recomienda en la clase anterior realizar ese curso, creo que hay un mal diseño en la ruta y debe ser revisado.

Esto fue lo que logré, le pregunté al chatGPT como se recorria un array valor por valor en js y de ahí lo razone un poco… fue algo dificil debido a que no tengo mucho conocimiento

let Array = [3,5,6,9,14,1,8,22,27]
let maxima = 0


for (let i = 0; i < Array.length; i++) {
    let valor = Array[i];
    console.log("valor de la lista actual: " + valor);
//aqui preguntamos si el valor en el que estamos es mayor al valor de maxima.
    if (valor > maxima) {
        //en caso de que si sea mayor maxima va a pasar a ser el valor en el que sea que estemos del ciclo, empieza en 0, luego sigue 3 y pasara a 3 y asi sucesivamente.
         maxima = valor 
         console.log("valor actual de maxima: " + maxima)
    } else {
        console.log("valor más pequeño que maxima")
    }
    
} 
console.log('El valor maximo del Array fue: ' + maxima)


Así queda al ejecutarse:

valor de la lista actual: 3
valor actual de maxima: 3
valor de la lista actual: 5
valor actual de maxima: 5
valor de la lista actual: 6
valor actual de maxima: 6
valor de la lista actual: 9
valor actual de maxima: 9
valor de la lista actual: 14
valor actual de maxima: 14
valor de la lista actual: 1
valor más pequeño que maxima
valor de la lista actual: 8
valor más pequeño que maxima
valor de la lista actual: 22
valor actual de maxima: 22
valor de la lista actual: 27
valor actual de maxima: 27
El valor maximo del Array fue: 27

Estos nuevos 3 cursos de pensamiento lógico excelentes, están bastante optimizados a comparación del anterior, que bueno que actualizaron.
Aquí mi aporte 😃

let a = Number(prompt("Ingrese 1er numero del array: "));
let b = Number(prompt("Ingrese 2do numero del array: "));
let c = Number(prompt("Ingrese 3er numero del array: "));
let numeros = [a,b,c];
let max = 0;

  for(let i=0; i<numeros.length; i++){
    if(numeros[i]>max){
      max = numeros[i];
    }
  }
console.log("El mayor de todos es : "+max);
Llegué a este curso porque le pedí a ADA una ruta para aprender Python desde cero. Este curso es el primero de la ruta, así que hay términos que no domino y conozco. Busqué en internet y un **"array"** es en programación es una estructura de datos que permite organizar y almacenar información relacionada. También se le conoce como arreglo o vector.
//dado un array encontrar el numero mayor let numeros = \[5,12,508,73,2,4,97,8,101,173]; maxima = 0; for (let i=0; i\<numeros.length; i++){ if (maxima < numeros\[i]) maxima = numeros\[i] } console.log (maxima)
![](https://static.platzi.com/media/user_upload/image-58bd1c79-2c47-4518-8fba-c8d4accf1e55.jpg)
Mi aporte. ![](https://static.platzi.com/media/user_upload/image-c23afc34-c0ec-44ba-94ff-01d8e46b5c22.jpg)

Si estas empezando, puede que esta sea una duda común:
i es un contador, es decir, una variable que lleva un conteo que sirve para recorrer el arreglo, puesto que el arreglo tiene que avanzar para “leer y comparar”, por así decirlo, todos los elementos (o números en este caso) para determinar cuál es el más grande. Puedes imaginártelo como una recta numérica, los números se encuentran en la recta, y el contador i es el “salto” que se hace para ir avanzando en la recta. Por eso cuando números está en la primera posición de i o números en la posición 0 obtenemos el primer numero de la recta, e i++ lo puedes interpretar como i + 1, que quiere decir que una vez estes en la primera posición del arreglo i avanza a la siguiente posición y así sucesivamente hasta recorrer todo el arreglo. Otro dato que me gustaría darte es que i solo es el nombre que se le asigna a la variable, puede ser cualquier otra letra, pero es la más usada debido a que se entiende que es un índice que recorre cada posición del arreglo, de ahí el i.

Espero te sirva, te recomiendo profundizar en el tema de arreglos y estructuras de control repetitivas, así te quedará mucho más claro.

function encontrarNumeroMasGrande(lista) {
  // Paso 2: Inicializamos la variable "máxima" con el primer elemento de la lista
  let maximo = lista[0];

  // Paso 3: Recorremos el array valor por valor (a partir del segundo elemento)
  for (let i = 1; i < lista.length; i++) {
    // Paso 4: Comparamos si el valor actual es mayor que el valor almacenado en "maximo"
    if (lista[i] > maximo) {
      // Paso 5: Asignamos el valor actual a la variable "maximo"
      maximo = lista[i];
    }
  }

  // Paso 6: Imprimimos el número más grande
  console.log("El número más grande es: " + maximo);
}

// Ejemplo de uso:
const numeros = [10, 5, 40, 8, 30, 99];
encontrarNumeroMasGrande(numeros);

Después de un par de horas investigando quise realizar este ejercicio con el detalle extra de que los números en el array se generan aleatoriamente. ¡Estoy bastante emocionado de que si funcionó!
Les comparto mi código y el link al proyecto en Replit: https://replit.com/@jossmo/Numero-mas-alto-en-un-array#index.js

function getRandomNum(min, max) {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() * (max - min + 1) + min);
}

let a, b, c, x, y;
a = getRandomNum(1, 50);
b = getRandomNum(1, 50);
c = getRandomNum(1, 50);
x = getRandomNum(1, 50);
y = getRandomNum(1, 50);

let array = [a, b, c, x , y];
let max = 0;

for (let i = 0; i < array.length; i++) {
  if(array[i] > max) {
    max = array[i];
  }
}

console.log("Array aleatorio: " + array);
console.log("\nEl número más alto en el array es: " + max);

Estos ejercicios son geniales! Pero por favor, esto es para alguien que ya tiene una noción ligera, no para alguien que apenas es novato, que no sabe como manipular los elementos del arrays. Por mas talleres y ejercicios de esta forma, pero que sean a nivel!

//Buscar un valor maximo entre 6 números. 

const arreglo = [3, 7, 2, 4, 8, 9];
let maximus = 0;



for (let i = 0; i < arreglo.length; i++) {
  //c = c+1  
  if (arreglo[i] > maximus) {
    
    maximus = arreglo[i];
      
  }
}

console.log(maximus);
console.log(arreglo)
const numeros = [44, 245, 81, 500, 112];
const maximo = Math.max(...numeros);
console.log(maximo)

Hola!
Quisiera compartir con ustedes mis resultados del reto, sinceramente me costotrabajo resolverlo pero apoyándome de la documentación oficial de javascript y después de darle muchas vueltas, por fin lo logre!
Se los comento para que si sienten que estan atorados en algun momento, se tomen un respiro, se relajen y vuelvan a intentar. 😃
No se rindan!!
Disculpen si lo subi como imagen, pero tuve problemas para poner los comentarios utilizando la opción de agregarlo como código.
Espero que les sea util, cualquier duda o sugerencia es bien recibida. 😃
.

mi aporte

const numeros = [
  1, 42, 5, 5, 57, 3, 67, 3, 44, 6, 23, 6, 56, 3, 5674, 457, 6, 4567, 10000,
];
function maxNumber(array) {
  let maxnum = 0;
  array.forEach((item) => {
    if (item > maxnum) {
      maxnum = item;
    }
  });
  return maxnum;
}

console.log(maxNumber(numeros));```

para mi fue difícil, pero me gusta, aquí dejo mi aporte
les agradezco si tienen alguna corrección para hacer

 var array = [5, 2, 1, 8,];
 var max = 0;
 var i = 0;

while (i < array.length){
    if (max < array[i]){
        max = array[i]
    }
    i++
}
console.log (max)

Me parece que quedaría así, usando una función y el console.log:

function maxNum (numeros){
let mayor = 0;
for(let i = 0; i <= numeros.length - 1; i++){
if(numeros [i] > mayor){
mayor = numeros[i];
}
return mayor;
}

//Se declara el arreglo
let numeros= [20, 15, 5, 30, 24, 18, 50];

/*
Se llama a la función con el arreglo de parámetro. Se muestra el resultado por el console.log.
*/

console.log(maxNum(numeros));

Estoy siguiendo la ruta de desarrollo de software y en este punto no sé lo que es un array o las funciones que piden, voy a buscar a detalle cada una.

Voy iniciando en esto de programación desde cero, y me resultó bastante complejo.

Me guié por las actividades los compañeros para poder practicar, así que gracias a todos por sus aportes, sin esa ayuda no hubiera entendido lo del Reto 9, ya que la explicación del video anterior y las instrucciones no ayudaron mucho para aprender a traducir el algoritmo a lo de programación :S

let numbers = [2, 5, 18, 14, 27, 21];
let length = numbers.length;
let maxNumber = 0;

for (let i = 0; i < length; i++){
  if(maxNumber < numbers[i]) {
    maxNumber = numbers[i];
  }
}

console.log("El número más alto es " + maxNumber);

let numeros =[1,3,5,26,5,9,58,25];

let maxima =0;

for(let i =0; i < numeros.length;i++){
if(maxima < numeros[i]){
maxima = numeros[i]
}

}
console.log("numero mas alto es "+maxima)

La verdad, me perdí en el ejercicio anterior de Javascript y no estoy entendiendo nada de esto

Yo lo solucione de esta manera con un for y un if comparando cada numero con la variable máxima en caso de que algún numero sea mayor a máxima el valor de máxima se actualiza y continua el recorrido hasta terminar con el array

numeros = [2, 10, 100, 20, 6, 8]
maxima = 0
for(i in numeros){
  n = numeros[i]
  if( n > maxima){
    maxima = n
  }
}
console.log(maxima)

Why did it cost me so much?
I still have a hard time understanding good, how does function the reference i in array and how compared the values.

mi resultado del reto 9:

let numbers = [10,20,30,40,50,100,500]

let maxima = 0; 

for (i in numbers)
{
    if (numbers[i] > maxima)
    {
        maxima = numbers[i];
    }
}
console.log(maxima);

Este es mi programa:
let arreglo=[800,10,200000,150,60,7000]
maxima=0
for (i=0 ;i<=5;i++){
if(arreglo[i]>maxima)
maxima=arreglo[i]
else
maxima=maxima
}
console.log(maxima)

let honeyJars = [-10, -18, 20, 30, 40, 60];
let maxNum = 0;
let groupDimen = honeyJars.length;

for ( let i = 0; i < groupDimen; i++) {
    if ( maxNum < honeyJars[i] ) {
        maxNum = honeyJars[i];
    }
}

console.log(Math.max(maxNum))

La forma mas comun para recorrer un array es con la sentencia for tal que asi

numbers = [2, 4, 6, 4, 1, 12, 9, 10];
for (let i = 0; i < numbers.length; i++)

Pero existe una forma mas simple de hacerlo. Utilizando la sentencia for in

numbers = [2, 4, 6, 4, 1, 12, 9, 10];
for (i in numbers)

Que seria directamente lo mismo que el for del principio. De forma que el ejercicio haciendo uso de este seria

numbers = [2, 4, 6, 4, 1, 12, 9, 10];
max = 0;

function maxNumber() {
  for (i in numbers) {
    if (numbers[i] > max) {
      max = numbers[i];
    }
  }
  return console.log(max, "Es el numero mas grande");
}

maxNumber(); 

Lo que hice fue encapsular este algoritmo en una funcion para que la hora de querer usarlo en otra parte del codigo no se duplica y lo vuelva reutilizable.
Si deseas leer mas a detalle sobre la sentencia for in les recomiendo la documentacion de MDN
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...in

const numbers = [1,5,7,65,5,8,9];
max = 0

for (i in numbers){
    if (numbers[i] > max){
        max = numbers[i]
    }

}

console.log(max)

Hola. Que buen ejercicio.

El desarrollo del reto lo desarrollé, en PSeInt. Este programa esta configurado en opción de lenguaje “flexible” por eso no es necesario declarar algunas variables ni usar ; (punto y coma).

<code> 
Algoritmo numero_mayor_de_array

	**//Solicito la longitud del arreglo - larray- **
	Escribir 'Ingrese cantidad de elementos  del arreglo'
	Leer larray

	**// Muestro al usuario el valor ingresado**
	Escribir 'La cantidad a ingresar en el arreglo es ', larray
	Escribir 'Ahora ingrese los valores de los elementos 1x1'

	**// Creo arreglo a traves del constructor**
  **// -Dimensiòn- teniendo**
	**// en cuenta la se longitud solitada anteriormente**
	Dimension arr[larray]

	**// Genero ciclo for para ingresar cada uno de los valores **
	**// solicitados dentro del arreglo teniendo en cuenta su**
	**// longitud la cual tambien se solicitó**
	Para i<-1 Hasta larray Hacer
		Escribir 'Ingrese el valor ',i,' de ',larray
		Leer arr[i]
		Escribir 'El valor ingresado es ',arr[i]
	FinPara

	**// Se crean variables -maxima- y -num1- con valor inicial**
  **//-0-**
	maxima <- 0
	num1 <- 0
	**// Genero -ciclo for- para revisar uno a uno los valores**
	**// del arreglo se inicia en -1- hasta el valor de longitud** 
	**//  total de la variable-larray-**
	Para i<-1 Hasta larray Con Paso 1 Hacer

		**// asigno a la variable -num1- la posiciòn del arreglo**
		**// de acuerdo al valor de -i-**
		num1<-arr[i]

		**// si -num1- es mayor al valor en -maxima- entonces**
		**// -maxima- adquiere un nuevo valor de acuerdo a la**
		**// posiciòn -i- del arreglo, sino maxima continua con el**
		**// mismo valor**
		Si num1>maxima Entonces
			maxima <- arr[i]
		SiNo
			maxima <- maxima
		Fin Si
	Fin Para
	**// Fin del ciclo -for-**

	**// Imprimo el numero mayor dentro del arreglo**
	Escribir 'El valor mayor dentro del arreglo es ', maxima
FinAlgoritmo

Imagen de Diagrama de flujo.

Imagen de la ejecución del código en PSeInt.

![](https://static.platzi.com/media/user_upload/upload-7e2aad04-fa53-49f0-92c5-3ca50d7847c2.png)Hola, aquí está mi aporte basado en investigación en GAS y el propio replit que me ayudaron a formular 4 opciones de solución, que me aseguré de entender los conceptos y el modo de funcionamiento para que me sirvan en el futuro. Me sentí un poco desarmado para realizar esta actividad sin haber revisado antes mucha de la nomenclatura que utilicé, sin embargo es muy enriquecedor de cualquier manera tener los fundamentos de partida para realizar la investigación.
Comparto el mío: //declaramos el array let arraynum = \[4,56,45,9675,83726]; //declaramos el tamaño del array tamarray = arraynum.length; //declaramos la variable para el numero mayor let maxnumb = arraynum\[0]; // 3. For para encontrar el número mayor for (let i = 1; i < arraynum.length; i++) { if (arraynum\[i] > maxnumb) { maxnumb = arraynum\[i]; } } console.log("\nNúmero mayor:", maxnumb);
![](https://static.platzi.com/media/user_upload/upload-eb451e70-a8ac-4f75-944a-91b437054136.png)
// funcion array function array() { let maximo = 0 let numeros = \[52, 18, 14, 26, 70, 90, 12, 48, 68] let tamano = numeros.length for (let i = 0; i < tamano; i++) { if (numeros\[i] > maximo) { maximo = numeros\[i] } } console.log(maximo) } array()
![](https://static.platzi.com/media/user_upload/image-88dd2f02-5caf-4946-a862-4a97582dfd2d.jpg)
`// crear funcion para designar numero mas grande de un array` `const number = [5, 20, 10, 15, 1, 200];` `function Max(){` `for (` ` let i = 0; i < number.length; i++` `){` ` max = 0` ` if (number[i] > max)` ` max = number[i];` ` else ` ` max = max;` `}` `console.log(max) ` `}` `Max()`
Este es mi ejemplo ```js /encontrar el número mayor let miArreglo = [2, 7, 3, 10]; max = 0; for(let i = 0; i<miArreglo.length; i++){ if(miArreglo[i]>max){ max = miArreglo[i]; } console.log("El número mayor es: " + max); ```/encontrar el número mayor let miArreglo = \[2, 7, 3, 10]; max = 0; for(let i = 0; i\<miArreglo.length; i++){ if(miArreglo\[i]>max){ max = miArreglo\[i]; } } console.log("El número mayor es: " + max);
dejo mir epsuesta.![](https://static.platzi.com/media/user_upload/image-d71c40a5-7394-4d2e-a963-f6d3568db96b.jpg)
```js const elements = [0,1,23,45,64,67,89,90,13]; let max = 0; for(let i = 0; i < elements.length; i++){ if(elements[i]>max){ max = elements[i]; } } console.log(max) ```const elements = \[0,1,23,45,64,67,89,90,13]; let max = 0; for(let i = 0; i < elements.length; i++){ if(elements\[i]>max){ max = elements\[i]; } } console.log(max)
Aqui mi aporte: `const numbers = [31, 22, 37, 49, 25];` `function getMax(numbers) {` ` numbers.sort((a, b) => a - b);` ` return numbers[numbers.length - 1];` `}` `console.log(getMax(numbers)); // 49`
Les comparto mi respuesta: No duden en comentarla si tienen inquietudes. ```js function encontrar_maximo(arreglo){ let num_max=0; for (let i=0;i<arreglo.length;i++){ if (num_max<arreglo[i]){ num_max=arreglo[i] } } return num_max } numeros=[12,45,78,79,65,32,14,25,36,47,58,69,9,5,2,0,1254] console.log(encontrar_maximo(numeros)) ```
Mi respuesta ![](https://static.platzi.com/media/user_upload/image-9954907c-235b-4fd2-a8a7-386954280a43.jpg)
function encontrarMaximo(numeros) { let maxima = 0; for (let i = 0; i < numeros.length; i++) { if (numeros\[i] > maxima) { maxima = numeros\[i]; } } console.log("El número más grande es:", maxima); return maxima; } const numeros1 = \[1, 3, 2, 8, 5]; encontrarMaximo(numeros1);
![](https://static.platzi.com/media/user_upload/image-5472a0de-5915-4e55-a46c-78afad38cc61.jpg)![](https://static.platzi.com/media/user_upload/image-114dbe67-3d67-4133-b5c4-910b444d8c06.jpg)
Tu función para encontrar el número más grande en un array está muy bien. Sin embargo, considera iniciar la variable `maxima` con `-Infinity` para asegurar que funcione correctamente con arrays que contengan solo números negativos. Aquí tienes el código corregido: ```javascript function encontrarNumeroMasGrande(arr) { let maxima = -Infinity; for (let i = 0; i < arr.length; i++) { if (arr[i] > maxima) { maxima = arr[i]; } } return maxima; } const numeros = [3, 7, 2, 9, 5, 10, 1]; console.log("El número más grande es:", encontrarNumeroMasGrande(numeros)); ``` Usar `-Infinity` garantiza que cualquier número en el array lo reemplazará. ¡Sigue practicando!
let numeros= \[1,2,35,46,38,86,98,75,80,67,567,876,4565,567,686]; let max=numeros\[0]; for(let i=1; i < numeros.length; i++){ if(numeros\[i] > max) {max = numeros\[i]} } console.log("El número máximo es: " + max);
//Recibe un array de números let numeros=\[5,28,50,10,2]; //Crea una variable “máxima” que inicie en 0. let maxima=0; //crea una variable que lea el tamaño del array let tamano=numeros.legth; //Pregunta si el valor de la variable máxima es mayor que el valor del número en la posición actual del array. For(let i=0; i\<tamano;i++){ //Si la condición anterior es verdadera, asigna el valor de la posición actual del array a la variable máxima. If (maxima\<numero\[i]){ maxima=numero\[i]; } } //Imprime el número más grande del array. console.log (maxima);
Con ForEach const numbers = \[1,3,7,110,11,23,5,41]; let max = 0; numbers.forEach(num => {    if(num > max){        max = num;    }    }) console.log(`El número máximo es ${max}`);
function encontrarMaximo(array) { // Inicializa la variable 'maxima' con el valor más pequeño posible let maxima = Number.NEGATIVE\_INFINITY; // Recorre cada elemento del array for (let i = 0; i < array.length; i++) { // Si el elemento actual es mayor que 'maxima', actualiza 'maxima' if (array\[i] > maxima) { maxima = array\[i]; } } // Devuelve el número más grande encontrado return maxima; }
mi respuesta: let numbers = \[15,21,27,29,34];let maxNumber = 0; for (let i = 0; i < numbers.length; i++) {    if(maxNumber < numbers\[i] ){        maxNumber = numbers\[i];    }} console.log("El valor mas grande de max es: " + maxNumber);
```js let numeros = [2,4,5,1,100,6,10]; let max = 0; for (let i = 0; i < numeros.length; i++) { if(max < numeros[i] ){ max = numeros[i]; } } console.log("El valor mas grande de max es: " + max); ```
`function encontrarmaximo(arreglo) { // definimos la función` ` let maximo = arreglo[0]; // decimos que empieza en cero` ` for (let i = 1; i < arreglo.length; i++) { // creamos un bucle que recorra el arreglo` ` if (arreglo[i] > maximo) { // si el elemento del arreglo es mayor al máximo` ` maximo = arreglo[i]; ` ` }` ` }` ` return maximo; // retornamos el máximo` `}` `const numeros = [20, 30, 45, 605, 8784, 5, 4, 2, 1, 0, 458, 35445]; // creamos un arreglo con números` `const maximo = encontrarmaximo(numeros); // llamamos a la función` `console.log(maximo); // imprimimos el máximo`
Este ejemplo es perfecto. El objetivo del ejercicio es que accedamos la pagina, busquemos recursos, consultemos e investiguemos por medios externos, informacion adicional para formar en nosotros ser autodidactas. Excelente michas gracias!!! Estoy empezando desde cero y tuve que ir a la pagina de mozilla a leer!! Vuamos!!!
Hola a todos, espero que esten bien. Les comparto mi solución, es era AI así que decidí consultar también. ```js const numeros = [12, 45, 78, 23, 56, 89, 34, 67, 90, 21, 43, 76, 54, 32, 98, 65, 87, 29, 10, 99]; //Mi solución let max = 0 //btw hay un error aquí pq si el array solo tiene números negativos se mantendría en 0. La manera correcta sería iniciar la variable con "numeros[0]" Me dí cuenta gracias a AI por eso lo mantengo fiel a mi primera solución. numeros.forEach(item => { if (item > max) { max = item } else {} //esto de "else{}" no aporta pero como voy iniciando prefiero mantener la estructura. }); console.log(max) //Mejor solución posible (Según AI) const maximo = Math.max(...numeros); console.log(maximo); ```Espero ayude, un abrazo :)
```js // suma, resta, multiplicacion, division // Permite ver mejore el funcionamiento // Podes ver como itera para encontrarlo let numbers = [2,3,6,1,8,4] let length = numbers.length let maxNumber = 0 function Max(){ for (let i = 0; i < numbers.length; i++) { console.log(`Iteración ${i + 1}:`); console.log(`Número actual: ${numbers[i]}`); console.log(`Máximo actual: ${maxNumber}`); if(numbers[i] > maxNumber){ maxNumber = numbers[i] } } } Max() console.log(maxNumber) ```// suma, resta, multiplicacion, division let numbers = \[2,3,6,1,8,4]let length = numbers.lengthlet maxNumber = 0 function Max(){    for (let i = 0; i < numbers.length; i++) {        console.log(`Iteración ${i + 1}:`);        console.log(`Número actual: ${numbers\[i]}`);        console.log(`Máximo actual: ${maxNumber}`);    if(numbers\[i] > maxNumber){        maxNumber = numbers\[i]    }    }} Max()console.log(maxNumber)
```js let array = [2342,25,235,165,57,325,6,789,24,575,3444,63,2,76,1,3466,2,5]; let max = 0; let i = 0; do { if (array[i] > max) { max = array[i] } i++; } while (i < array.length); console.log(max); ```let array = \[2342,25,235,165,57,325,6,789,24,575,3444,63,2,76,1,3466,2,5];let max = 0;let i = 0;do { if (array\[i] > max) { max = array\[i] } i++;} while (i < array.length);console.log(max);
`let array = [2342,25,235,165,57,325,6,789,24,575,3444,63,2,76,1,3466,2,5];let max = 0;let i = 0;do { if (array[i] > max) { max = array[i] } i++;} while (i < array.length);console.log(max);`
Mi solución: ```js function valorMaximo(array){ let maximo = 0; for(let i = 0; i < array.length; i++){ if(array[i] > maximo){ maximo = array[i]; } } return maximo; }; ```function valorMaximo(array){ let maximo = 0; for(let i = 0; i < array.length; i++){ if(array\[i] > maximo){ maximo = array\[i]; } } return maximo; };
![](https://static.platzi.com/media/user_upload/image-bbddebb6-866b-4d8c-91c3-dda8655188ca.jpg) ![](https://static.platzi.com/media/user_upload/image-e7a8351b-976e-4f63-98c2-f92cecfe6e1d.jpg)
![](https://static.platzi.com/media/user_upload/image-f0856c21-f598-4a2d-8297-5d18fce9ca33.jpg)
![](https://static.platzi.com/media/user_upload/image-8a0f4c60-0cbb-49ba-9620-c590eb560b52.jpg)
![](https://static.platzi.com/media/user_upload/image-e5ce3830-a42e-471e-9c56-3e3ad163f22e.jpg)
![](https://static.platzi.com/media/user_upload/image-1d135dbc-19ee-4862-8554-778294a0f305.jpg)
![](https://static.platzi.com/media/user_upload/image-6440d43e-54ff-45ab-afe4-33c9a7f87872.jpg) ![](https://static.platzi.com/media/user_upload/image-afc74eb5-642c-486a-bc87-dddc7582e802.jpg)
`let num = [2,3,4,5,6,7,8,9];` `let max = 0;` `for (let i = 0; i < num.length; i++){` ` if(num [i] > max){` ` max = num[i];` ` }` `}` `console.log(max)`
let num = \[2,3,4,5,6,7,8,9]; let max = 0; for (let i = 0; i < num.length; i++){ if(num \[i] > max){ max = num\[i]; } } console.log(max)
Me quedó así: `//Find the biggest number in the array` `let arr = [8, 1, 40, 17, 4];` `let max = 0;` `for (let i = 0; i < arr.length; i++) {` ` if (arr[i] > max) {` ` max = arr[i];` ` }` `}` `console.log(max);`
function encontrarMayor(numeros) { let max = 0; // Inicializamos max en 0 for (let i = 0; i < numeros.length; i++) { // Recorremos el array if (numeros\[i] > max) { // Si el elemento actual es mayor que max max = numeros\[i]; // Actualizamos max } } return max; // Retornamos el número más grande } // Ejemplo de uso: const miArray = \[3, 7, 2, 9, 5]; const numeroMayor = encontrarMayor(miArray); console.log("El número más grande es:", numeroMayor);
`let numeros = [5, 15, 20, 8, 10, 3, 30, 11, 25, 2, 7];` `let maxima = 0;` `for (let i = 0; i < numeros.length; i++) {` ` if (numeros[i] > maxima) {` ` maxima = numeros[i];` ` }` `}` `console.log("El número máximo es:", maxima);`
Recién comencé practicamente a ver javascript y medio sé que es un array, pero en ningún momento explicaron el código para generar un array, y la verdad no me siento confiado en hacer apropiadamente este ejercicio, una lastima, pero seguimos que vamos.
El numero mas alto en esta lista es `function encuentraNumeroGrandeEnLista(){` ` ``let max = 0;` ` ``for(let i=0,i<numbers.length;i++)` `{` `if(max < numbers[i])` ` {max = numbers[i];}` `}` `console.log('El numero mas alto es:',max);` `}`
Estoy iniciando y realizando el ejercicio a mano en un cuaderno guiándome por el diagrama de flujo y siento que está mal realizado
Buscando el valor máximo dentro de los elementos de array.let miarray=\[4,5,9,80,445,6,200];     let maximo= 0;    // Recorre los valores de 1 a 1 del array para comparar.    for (let index = 0; index < miarray.length; index++) {        let element = miarray\[index];    //Se compara el elemento actual del array con el valor maximo, Si elemento es mayor que maximo se actualiza el valor maximo.        if (element>maximo) {             maximo= element;        }    }console.log(maximo); ```js let miarray=[4,5,9,80,445,6,200]; let maximo= 0; // Recorre los valores de uno a uno del array para comparar. for (let index = 0; index < miarray.length; index++) { let element = miarray[index]; //Se compara el elemento actual del array con el valor maximo, //si elemento es mayor que maximo se actualiza el valor maximo. if (element>maximo) { maximo= element; } } console.log(maximo); ```
const *nums* =** \[34,** 2,** 104]; let** max** =** 0; *for* (let** index** =** 0; index < *nums.*length; index++) {  const *element* =** nums\[index];  if (element > max) {    max = element;  }  } *console.log*('el mayor es: ' + max);