Reto 9: traduce un algoritmo a JavaScript

Creo que este tipo de ejercicios son excelentes.
pero dependiendo el contexto… hay quienes van iniciando desde cero y nisiquiera saben el significado de “Array” o como ir sumando un valor.
Yo personalmente considero que estaría mucho mejor primero explicar y despues ir a la práctica.

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.

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

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 😃

buenas tardes yo estoy desde cero y estoy perdido gracias

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.

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.

yo no entiendo en que cabeza cabe que una persona que recién esta iniciando en la programación y que lo único que ha visto en su vida son los 3 cursos anteriores a este va a resolver esto jajajaja, no tienen ni idea de la sintaxis de java script (Ni siquiera creo que sepan lo que significa sintaxis), de verdad que el que diseño esto esta loco

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.

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> 

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

.

• 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)

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].

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

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

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

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.

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)

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.

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.

var numbers = [1,4,9,2,5,54,12]
var nummax = 0

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

function encontrarMax(array, max){
  for(let i=0; i <= array.length; i++){
    if(array[i] > max) {
      max = array[i]
    }
  }
  console.log("El número mayor es: " + max)
}
let numeros=[1,2,3,4,5,6,7,8,9]
let max= 0

encontrarMax(numeros, max)

Este es mi aporte al reto, saludos

si no tuviera un poco de base no creo poder hacer este ejercicio
const arrayDenumeros=[2,5,9,7];
let suma=0
for(let i=0;i<arrayDenumeros.length;i++){
suma+=arrayDenumeros[i]
}
console.log(suma);

// Paso 1: Definir el array de números

const numeros = [12, 5, 27, 8, 19, 3, 42, 25];

// Paso 2: Inicializar la variable 'maximo' con el primer número del array

let maximo = numeros[0];  

// Paso 3: Recorrer el array para encontrar el número más grande

for (let i = 1; i < numeros.length; i++) {

    // Paso 4: Comparar y actualizar el máximo
    if (numeros[i] > maximo) {
        maximo = numeros[i];
    }
}

// Paso 5: Imprimir el número más grande encontrado

console.log("El número más grande es: " + maximo);

let recorrido = [110, 220, 1, 60, 8, 52, 3];
function numeroMayor(){
  let maximo = 0;
  for(let i = 0; i < recorrido.length; i++){
    if(recorrido[i] > maximo){
      maximo = recorrido[i];
    }
  }
  
  return maximo;
}

let result = numeroMayor();

console.log(result);

No entendí mucho, pero esto dijo chatGPT:
function encontrarNumeroMasGrande(arrayDeNumeros) {
// Comenzamos con la variable ‘maxima’ en 0
let maxima = 0;

// Recorremos el array valor por valor
for (let i = 0; i < arrayDeNumeros.length; i++) {
// Comparamos si el valor de ‘maxima’ es menor que el valor actual del array
if (maxima < arrayDeNumeros[i]) {
// Si es cierto, asignamos el valor actual del array a 'maxima’
maxima = arrayDeNumeros[i];
}
}

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

// Ejemplo de uso
const numeros = [10, 5, 7, 23, 15, 8, 32];
encontrarNumeroMasGrande(numeros);

Utilicé la ayuda de chatgpt porque obviamente por mis conocimientos casi nulos sobre programacion no podria escribir de manera correcta asi que hice una pregunta y tratando de entender todos los pasos.

// Paso 1: Definir una matriz (array) de números
var numeros = [12, 5, 67, 8, 100, 42, 3, 72];

// Paso 2: Inicializar una variable llamada "maxima" con un valor inicial
var maxima = 0;

// Paso 3: Recorre la matriz utilizando un bucle "for"
for (var i = 0; i < numeros.length; i++) {
    // Paso 4: Compara el valor actual de "maxima" con el valor en la posición actual de la matriz
    // Paso 5: Pregunta si "maxima" es menor que el valor actual de la matriz
    if (maxima < numeros[i]) {
        // Paso 6: Si la condición es verdadera, actualiza "maxima" con el nuevo valor
        maxima = numeros[i];
    }
}

// Paso 8: Después de recorrer la matriz, "maxima" contendrá el número más grande
// Paso 8: Imprime el número más grande
console.log("El número más grande en la lista es: " + maxima);

Al final hice esta pregunta
Que signifia var i?

ChatGPT
En JavaScript, la declaración var se utiliza para declarar una variable. En el contexto del código de ejemplo que te proporcioné, var i se refiere a una variable llamada “i” que se utiliza como contador en un bucle for.

Explicando más detalladamente:

var: Es una palabra clave que se utiliza para declarar una variable en JavaScript. Antes de la introducción de let y const, var era la forma principal de declarar variables en JavaScript. Sin embargo, let y const son más modernos y ofrecen un mejor alcance de bloque, lo que hace que var sea menos utilizado en la programación moderna.

i: Es el nombre de la variable que estamos declarando. En este contexto, “i” generalmente se usa como una convención para representar un índice o contador en un bucle. Puedes usar cualquier otro nombre de variable que desees, como “contador” o “índice,” pero “i” es comúnmente utilizado por su brevedad y porque es ampliamente reconocido como un índice en bucles.

En el bucle for que proporcioné como ejemplo, var i se utiliza como el contador que aumenta en cada iteración para rastrear la posición actual en la matriz durante el recorrido. La variable “i” generalmente se inicializa en 0 y se incrementa en cada iteración del bucle hasta que alcanza el valor que determina el final del bucle (en este caso, i < numeros.length para recorrer todos los elementos de la matriz “numeros”).

alert("   ----- Este programa da el num maximo de tu array -----   "); 

alert(" "); //Salto de linea. 
alert("          -----  Debes ingresar 10 valores -----            ");

let array = []; 
let max = 0;  //Creamos el arreglo donde van los valores y la variable maxima. 

alert(" "); //Salto de linea. 
for(var i = 0; i <10; i++){
   array[i] = parseInt(prompt("Dame el valor: ")); 
} //Llenamos los valores. 

alert(" "); //Salto de linea. 
for(var i = 0; i <10; i++){
  if(array[i] > max){
    max = array[i];  //Con un if y recorriento el arreglo verificamos cual es el valor mayo 
  }
}

//Lo imprmimos. 
alert("El numero maximo que pusiste en tu arreglo es: " + max );
alert(" "); //Salto de Linea. 

var array=[4,10,1]
var max=0
for (var i=0;i<3;i++){
if(array[i]>max){
max = array[i]
}else
console.log(“probando ando”,max)
}

// Write, Edit and Run your Javascript code using JS Online Compiler

console.log(“Welcome to Programiz!”);
let array =[3,6,64,7,325,4525,655];
let max = 0;
for (let i = 0; i <array.length; i++){
console.log("El valor de array que se a comprobar: " + array[i])
if (max < array[i]){
console.log ("valor de max: "+ max)
max<numeros[i]
console.log(“nuevo valor de max1” + max)
}
}
console.log(“Este es el valor final de max” + max)

Yo tampoco entendi pero le pregunte a chatGPT y me ayudo a entender bastante

Entiendo el desafío que se te ha planteado: encontrar el número más grande en un array usando JavaScript. El algoritmo que has proporcionado es un buen punto de partida. A continuación, te daré una explicación paso a paso del algoritmo:

Recibe un array de números (de cualquier cantidad):

Esto significa que tu función debe tomar como entrada un array que contiene una lista de números. Por ejemplo:
javascript
Copy code
const numeros = [10, 5, 8, 20, 3];
Crea una variable "máxima" que inicie en 0:

Inicializas una variable llamada "máxima" con un valor de 0. Esta variable se utilizará para realizar un seguimiento del número más grande encontrado hasta el momento.
javascript
Copy code
let maxima = 0;
Recorre el array valor por valor:

Utiliza un bucle (por ejemplo, un bucle for o forEach) para recorrer cada elemento del array.
javascript
Copy code
for (let i = 0; i < numeros.length; i++) {
  // Accede al número en la posición actual del array.
  const numeroActual = numeros[i];
  // Continúa con los siguientes pasos...
}
Pregunta si el valor de la variable "máxima" es mayor que el valor del número en la posición actual del array:

En este paso, comparas el valor almacenado en la variable "máxima" con el valor del número en la posición actual del array.
javascript
Copy code
if (maxima < numeroActual) {
  // Si el número en la posición actual es mayor que el valor almacenado en "máxima", continúa con el siguiente paso.
}
Si la condición anterior es verdadera, asigna el valor de la posición actual del array a la variable "máxima":

Si el número en la posición actual del array es mayor que el valor almacenado en "máxima", actualizas el valor de "máxima" con el número actual.
javascript
Copy code
if (maxima < numeroActual) {
  maxima = numeroActual;
}
Al final del bucle, tendrás el número más grande en la variable "máxima".

Imprime el número más grande del array:

Después de completar el bucle, puedes imprimir el número más grande que encontraste, que está almacenado en la variable "máxima".
javascript
Copy code
console.log("El número más grande es: " + maxima);
Este algoritmo debería encontrar el número más grande en el array proporcionado y mostrarlo en la consola. Puedes llamar a esta función con diferentes arrays de números para probar su funcionamiento.

Esta fue mi solucion a este ejercicio

let array = [40, 36, 115, 120, 15358, 22, 60];
var max = 0;

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

let array=[5,3,3,8,5,6]
let maximo=0

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

Aquí está mi código. Saludos.

let listaNumeros = [2,3,0,7,5,4];
let valorMaximo = 0;

function buscarMaximo(lista,max) {
  for(i=0; i<lista.length; i++) {
    if(max < lista[i]) {
      max = lista[i];
    }
   }
console.log(max);
}

buscarMaximo(listaNumeros,valorMaximo);

Yo lo hice de esta manera

Mi aporte: determinar el numero mayor en un array, usando estructuras de control for, while, do while.

numeros=[30,4,5,25,7,8,9]
maxima_for=0
maxima_while=0
maxima_do_while=0
//-------------------------------
for(i=0;i<numeros.length;i++){
  if (numeros[i]>maxima_for){
    maxima_for=numeros[i]
  }
}
console.log("Mayor ciclo for:")
console.log(maxima_for)
console.log()
//-------------------------------
i=0
while(i<numeros.length){
  if (numeros[i]>maxima_while){
    maxima_while=numeros[i]  
  }
  i++
}
console.log("Mayor ciclo While:")
console.log(maxima_while)
console.log()
//--------------------------------
i=0
do{  
  if (numeros[i]>maxima_do_while){
    maxima_do_while=numeros[i]  
  }
  i++ 
}while(i<numeros.length)
console.log("Mayor ciclo Do While:")
console.log(maxima_do_while)
console.log()

const miNumero = [1,5,67,3];
var max = 0;

for (let i = 0; i < miNumero.length; i++) {
  if (miNumero[i] > max) {
  max = miNumero[i];
}
}
console.log("El numero mayor es: ", max);

así me quedo

let numeros = [5,8,9,10,11,11.5];

let length = numeros.length;

let numeromayor = 0;

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

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

En lo personal he intentado por mucho tiempo estudiar esta carrera pero no he tenido suerte, por eso me he apoyado con los comentarios que encontré acá y ha sido muy útil, hay cosas que me falta comprender, como por ejemplo ¿por qué es necesario dejar la variable del ciclo al lado del nombre de otra variable?.. pero son cosas que se aprenderán a medida que vamos avanzando… les comparto lo que hice conforme al aporte de un compañero que lo explicó super!!

let array = [10,20,6,567,9,4,13];
let max = 0;
for (let i=0; i < array.lenght; i++) {
if array[i] > max {
max = array[i];
}
}
console.log(max);

aqui esta mi codigo, creo que funciona bien

<//crearemos un arreglo el cual el tamaño sera ingresado por el usuario, el tambien ingresara despues los numeros de ese arreglo. y al final imprimiremos el arreglo y cual es el numero mayor

// Pedir al usuario que ingrese el tamaño del arreglo
const tamano = parseInt(prompt("Ingresa el tamaño del arreglo:"));

// Crear un arreglo vacío
const arregloNumeros = [];

// Pedir al usuario que ingrese los valores para el arreglo
for (let i = 0; i < tamano; i++) {
  const valor = parseInt(prompt(`Ingresa el valor para la posición ${i}:`));
  arregloNumeros.push(valor);
}

var numeroMayor=0;
for(let i=0;i<tamano;i++){
  if(numeroMayor<arregloNumeros[i]){
    numeroMayor=arregloNumeros[i];
  }
  
}


// Mostrar el arreglo resultante
console.log("Arreglo final:", arregloNumeros);
console.log("El numero mayor del arreglo es: "+numeroMayor)> 

Este mi código realizado en Replit, primero creo 10 numero aleatorios y después ejecuto la lógica para hallar el numero mayor.

// Algoritmo Platzi //
function numeroMayor() {

    // Se crean 10 numero aleatorios y se almacenan en el array //
    const array = []
    for (i = 0; i < 10; i++) {
        const numero = Math.floor(Math.random() * 100) + 1
        array.push(numero)
    }
    console.log("La serio de numeros aleatoria es:", array)

    max = 0
    i = 0

    // Se procede a contar y a identificar el numero mayor de la serie de numeros //

    for (i; i < array.length; i++) {
        if (array[i] > max) {
            max = array[i]
        }
    }
    console.log("\nEl numero mayor de la serie de numeros es:", max)
};
numeroMayor()

Mi solución al reto

numeros = [5, 35, 20, 3, 4]
max = 0

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

MayorNumero()

siguiendo algunos ejemplos, moviendo quitando y volviendo a leer el diagrama y que es lo que requiero salio…

let array = [1,4,2,89,12,5,43,98];
let max = 0;

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

Mi Aporte, el primer array ya tiene los datos y en el segundo defini en el ciclo for el tamaño del array y el usuario le mete los datos al segundo array

let array=[19,56,43,95,23,15];
let array2=[];
let maxima=0;
let max=0;
let num;
for(var i=0; i<array.length; i++){
  if(array[i] > maxima){
    maxima = array[i];
  }
  
}
for(var j=0;j<10;j++){
  num = parseInt(prompt("Ingrese un numero "));
  array2[j]=num;
}
for(var k=0;k<10;k++){
  if(array2[k] > max){
    max=array2[k];
  }
}

console.log(array);
console.log("El numero mayor en el arreglo es:",maxima);
console.log(array2);
console.log("El numero mayor en el arreglo es:",max);

<code> 
numbers = [84, 92, 10, 48, 37, 26]
max_num = 0

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

console.log("The greatest number is " + max_num)

Esta es mi solución, y le agregué para saber el índice en el que se encuentra el número más grande.

numeros = [5, 10, 7]
numMax = 0
i = 0

while (i < numeros.length) {
  if (numeros[i] > numMax) {
    numMax = numeros[i]
    indexMax = i
  }
  i++
}

console.log('El número más grande está en el indice: %d, y es el número: %d', indexMax, numMax)

Esta es mi solución

//Declaramos las variables
let arrayNumber = [1,2,3,101,4,5,70,89]
let max =0;
//inicializamos el for
for(let i=0;i<arrayNumber.length;i++){
  //realizamos la comparación del numero actual con el máximo, si es mayor grabamos el numero numero máximo
  if(arrayNumber[i]>max){
    max = arrayNumber[i]
  }
}
console.log("El número más grande es: "+max)

function encontrarMaximo(array) {
  // Iniciamos la variable máxima en 0
  let maxima = 0;

  // Recorremos el array valor por valor
  for (let i = 0; i < array.length; i++) {
    // Pregunta si el valor de la variable máxima es menor que el valor del número en la posición actual del array.
    // Si es verdadero, asigna el valor de la posición actual del array a la variable máxima.
    if (maxima < array[i]) {
      maxima = array[i];
    }
  }

  // Imprimimos el número más grande del array
  console.log("El número más grande del array es: " + maxima);
}

// Ejemplo de uso
const numeros = [5, 9, 2, 11, 3, 8];
encontrarMaximo(numeros);

//Encontrar el número más grande de una lista
function encontrar(){
numeros = [3, 5, 8, 200, 10, 3, 123];
max = 0;
i = 0;

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

encontrar();

let numeros = [5,6,4,8,9,41,54,10,24,36,56]

function encontrarValorMaximo(array) {
let maxima = 0
for (let i = 0; i < array.length; i++) {
if (maxima < array[i]) {
maxima = array[i]
}
}
return maxima
}
console.log(encontrarValorMaximo(numeros));

<code> 
let miArray=[6,300, 45, 20];
let max=0;
let i=0;


for (i=0; i<4; i++){
   if (max < miArray[i]) {
    max=miArray[i]
  }
  
}
console.log(max)

//Encontrar el mayor número

let numeros = [0,1,2,3,11,5,69,7,8,9]

function maximo(a) {
  let mayor = 0;
  for(i = 1; i < 10; i++){
    if(a[i] > mayor) {
      mayor = a[i];
    }
  }
  console.log(mayor);
}

maximo(numeros);

function reto1(){

  let numerosAleatorios = [];
  let cantidadDeNumeros = 5;

    for (let i=0; i < cantidadDeNumeros; i++){
      let nAleatorios = Math.floor(Math.random() * 100);
      numerosAleatorios.push(nAleatorios);
    }
  
  let maximo = Math.max(...numerosAleatorios);

  console.log("El array es : ", numerosAleatorios);
  console.log("El numero maximo es : ", maximo);
  
}

reto1()

function determinarMayorNumeroLista(number){

let mayor = 0;

for(var i = 0; i < number.length;i++){

if( mayor < number[i] ){
mayor = number[i];

}

}
console.log('Numero mayor : ', mayor);
}

Esta es mi traducción del algoritmo a codigo

let Array = [2,0,3,4,6,1,7,2,9];
let max = 0

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

console.log(max);

https://imgur.com/a/Nt9D5RC

Muy a los golpes el aprendizaje