Programando en JavaScript

¡No te rindas!

Aquí ya empezamos a tocar código puro y duro (y de hecho fue una introducción un poco… hardcore… jaja) mi mejor consejo para ti son estos:
.

1. Razona: trata de entender qué hace cada línea, si no puedes apoyate de un diagrama de flujo, pero trata de entender bien qué sucede.
2. Debuguea: Recuerda que usar las instrucciones para imprimir en pantalla te pueden ayudar ver cómo los programas se comportan en cierto punto.
3. Busca la documentación: Recuerda siempre buscar documentación, léela y mira cómo funciona cada cosa que usas

.
Por ejemplo, en este caso, ¿por qué me imprimer 8? No lo sé, pero puedo usar debugging:

function secondLargestNumber(numbers) {
  console.log(numbers);
  numbers.sort();
  console.log(numbers);
  numbers.reverse();
  console.log(numbers);
  return numbers[1];
}

Aquí puedes ver cómo use debugging para ver qué valores contenía mi elemento numbers después de cada acción.
.
Después de esto me doy cuenta de que contiene estos valores, el primer par de corchetes es a como mis valores llegan, el segundo par es después del método sort y el tercer par es después del método reverse:
.

.
Uhmm interesante, ¿por qué el método sort me está ordenando los valores de esa manera? 🤔 ¡No tiene ningún sentido! ¡Vamos a buscar la documentación! (hay varias páginas donde puedes documentarte, yo te dejo esta, aunque en archivos de la clase hay otra):
.
https://www.w3schools.com/jsref/jsref_sort.asp
.
Leyendo veo el método sort() ordena todo como si fueran strings, y en un string, “4” es mayor que “20”, ¿Por qué? porque estamos comparando strings, no números. De hecho un string podría decirse que compara el primer caracter, por lo que 4 es mayor que 2.
.
Ahora, si miro más abajo veo que ellos ya me proponen un algoritmo donde puedo ordenar los números directamente de forma descendiente, ya ni si quiera necesito el método reverse! Así que puedo usarlo, este algoritmo tiene su explicación, pero por ahora quédate con que te va a ordenar los números de mayor a menor:

function secondLargestNumber(numbers) {

    numbers.sort( function(a, b){
        return b-a
    } );

    return numbers[1];
  
}

let nums = [8, 4, 6, 10, 9, 11, 20];
console.log(secondLargestNumber(nums))

¡Y listo!, mi programa ya funciona, problema solucionado!
.
Así es como tienen que empezsar a pensar para resolver problemas, y el debugging y la documentación serán sus mejores herramientas, ¡no se rindan!

Al inicio no entendí muy bien así que decidí hacerlo en papel para comprenderlo mejor.

como vemos en la imagen de arriba numbs es el array y la i es el espacio que ocupa cada número como lo dijeron en clases anteriores en los arrays la primera posición es el 0.
Como vemos en esta línea for (let i=0; i < numbers.length; i++), nos indica que el número de iteraciones que tendremos será 6 porque numbers.length es la cantidad de elementos que tenemos en nuestro array que es 6 y después de cada iteración se le sumara uno a i para la siguiente iteración hasta llegar a i = 5.

Como podemos ver en la imagen de arriba no se cumple ninguna de las condiciones, así que first y second se mantienen igual; el único que se modificaría seria i al que se le sumaría 1.

En la imagen de arriba se ve la segunda iteración donde i = 1 y numbers[1]=4, se ve que si cumple la segunda condición y second toma el valor de 4 y este se mantendrá para la siguiente iteración como lo veremos en la siguiente imagen.

como podemos ver en la imagen de la cuarta iteración se cumple la primera condición y second toma el valor de 8 y firts el valor de 10; la segunda condición no se cumple. Para la quinta iteración i = 4.

en la sexta iteración firts = 11 y second = 10 y nos retornaria el valor de second que es 10. Ya no se podria hacer una séptima iteración porque no cumpliría con la condición del for que i < 6, ya que para la séptima iteración el valor de i sería 6.

Yo hice antes de este curso el de Programación Básica que da Freddy que de hecho es gratis y explica muy bien Javascript, luego de ese puedes seguir con los cursos definitivos y es el curso si quieres ser desarrollador web Fronted como yo 😃 Te lo recomiendo mucho, en esta clase la verdad si no hubiera hecho ese curso hubiera quedado un poco asustada con el lenguaje

Al principio no entendi
.
.
.
.
.
.
.
.
.
.
.
.
.
.
al final después de revisar todo paso por paso y con los conocimientos técnicos de los cursos anteriores.

tampoco entendí nada

Me quede… … … Pero si yo aún no sé programar en js… Bueno de momento lo voy viendo. Toca verlo más adelante y ahí ya tendrá más sentido esto de seguro.

Creo que entre a a la clase equivocada. apenas me estoy familiarizando con lo conceptos básico y salen con este ejemplo.

¡hasta aquí llegue!
esta señora se salta por completo la curva de aprendizaje. vamos en la parte 36 sin tan siquiera usar, o tan siquiera explicar Node.js y pega un salto olímpico a escribir código. no critico lo de escribir código, pero debió introducir esto bastante atrás. parece que le toco pisar el acelerador a mitad de curso.

lo único bueno era encontrar en este curso cursos alternativos de fundamentos así al menos enterarme de algo, por que los demás instructores no trabajan asi, hacen cosas como poner ejemplos concretos de lo que esta explicando no solo información teórica. porque en todo lo que duro la parte de diagrama de flujo el único ejemplo practico fue el de Pokémon, y fue un video de Freddy.

si no es por la comunidad, ya hace mucho dejo tirado esto. ¡¿como es posible que usuarios expliquen mejor que la que se supone esta dictando el curso?!

me salto este curso, voy a seguir con el curso de Freddy de programación básica y los que le siguen.

No me gusto esta parte, en mi caso estoy desde cero en la programación, no explicaron bien como descargar, como escribir, indicaron todo como si personas como yo supiéramos, pienso que la idea de estos cursos es explicar un poco mas a detalle

🐱‍💻 Interesante como podemos optimizar el código cuando conocemos las funciones que tiene el lenguaje de programación.

function secondLargestNumber(numbers){
  numbers.sort();
  numbers.reverse();
  return numbers[1];
}

let nums = [8, 4, 6, 10, 9, 11, 20];
console.log(secondLargestNumber(nums));

No entendí nada… 😦

Me costó entender como corría este código
Al visualizar los resultados de cada iteración del ciclo for con el console.log(), se puede comprender mejor el código ñ.ñ

<function secondLargesNumber(numbers)
{
  let first = numbers[0];
  let second = 0;
  for (let i = 0; i < numbers.length; i++)
  {
    if(numbers[i] > first)
    {
      second = first;
      first = numbers[i];
    }
    if(numbers[i] > second && numbers[i] < first)
    {
      second = numbers[i];
    }
    console.log(numbers[i], first, second, );
  }
  return second;
}
let nums = [8, 4, 6, 10, 9, 11];
console.log(secondLargesNumber(nums));>

El resultado de cada iteración que ocurre en el ciclo es el siguiente:
.
Al iniciar numbers[ 0 ] es: 8, first es: 8 y second es: 0
Luego:
numbers[ 1 ] es: 4, first es: 8 y second es: 4
numbers[ 2 ] es: 6, first es: 8 y second es: 6
numbers[ 3 ] es: 10, first es: 10 y second es: 8
numbers[ 4 ] es: 9 first es: 10 y second es: 9
numbers[ 5 ] es: 11, first es: 11 y second es: 10
.
finalmente return nos retorna second = 10
.
Recuerden que el ciclo ocurre hasta que se cumpla la condición i < numbers.length y numbers.length es igual a 6 porque es la cantidad de números que contiene nuestro arrays nums = [8, 4, 6, 10, 9, 11]. 😄

✅La solución a la preguta final: Si hacemos nums.sort() el orden va a quedar: [10, 11, 20, 4, 6, 8, 9] porque sort ordena en forma alfabética. Va primero el 10 que el 2 o el 4 porque empieza por 1. Si hacemos el reverse, el segundo número será 8

Para los que apenas comienzan en la programación esta clase es demasiado abrumadora. Deberían poner ejemplos más prácticos y sencillos. Veo que la lógica la explicaron en documentaciones pasadas pero eso amerita un video porque para alguien que apenas empieza eso podría ser muy complicado, también veo que muchos se desesperan y se rinden porque la programación es muy difícil, eso se podría solucionar con ejemplos más prácticos y sencillos.

🔴 Es inconcebible el cambio, se deberia hacer un acercamiento mas sencillo y facil para familiarizarse con al lenguage JS,
.
Se paso de la utilizacion de algunos algoritmos en diagramas de flujo a escribir una extensa linea entera de codigo.

Comparto el ejercicio explicado paso a paso:

1. Explicación del algoritmo

1. Si no entendiste la primera lámina, te invito a ver el desarrollo de un ejercicio:

Me veo motivado a ser crítico en mi comentario y en mi opinión con respecto al curso. Es un curso de Pensamiento Lógico y no tiene ninguna lógica cómo está formulado y explicado, ya que saltas de un tema a otro y de repente te escupe un montón de conceptos los cuales nunca has escuchado antes, y finaliza dándote como tarea un reto más elevado a dichos conceptos como si ya fueras experto, lo cuál para alguien que se está iniciando no hace sentido y en vez de aprender es no tener comprensión sobre el funcionamiento del cerebro del ser humano, ya que requiere de un proceso para asimilar lo aprendido antes de su misma comprensión de los nuevos conceptos y todo esto requiere de un proceso que considero debería de ser tenue y calmado. De otra manera es frustrante y no hace sentido hacer un curso con esta dinámica tan poco comprensible. Este curso está bien si lo repites 3 o 4 vezes, lo cuál considero que un curso no debe de hacerse con este fin. Mejor más cantidad de vídeos explicando, con más calma y detenimiento en lo que se explica, que rapidez y todo el contenido apretujado para que quepa en un solo vídeo. De todas formas estoy contento con los conocimientos que se aportan.

No olvides tener en cuenta los diferentes casos de uso de tu función:

• El array puede tener una longitud variable
• Los números pueden repetirse dentro de un array [1, 2, 2, 3, 4, 3]
• No siempre lo más obvio es la respuesta, debes probar tu lógica en diferentes escenarios

El método sort() ordena los elementos de un array localmente y devuelve el mismo array ordenado. El modo de ordenación por defecto responde a la posición del valor del string de acuerdo a su valor Unicode (Es decir ordena alfabéticamente). Ej.

[8, 4, 6, 10, 9, 11, 20] => [10, 11, 20, 4, 6, 8, 9]

La solución a la función seria:

function secondLargestNumber(numbers) {
    numbers.sort(function (a, b) {
        return a - b;
    });
    numbers.reverse();
    return numbers[1];
}

Alguien me puede explicar porque la function tiene como argumento “numbers” pero luego el array a recorrer se llama nums?? No debería llamarse igual?? y de no ser así a que hace referencia numbers?? no entiendo esa lógica. gracias

al principio no entendí nada … al final tampoco xD

Para escribir con JS les recomiendo usar directamente la consola

Pasos

• Dar click derecho en cualquier parte de nuestro navegador
• Dar click en inspeccionar
• Damos click en la seccion que dice console
• Podemos escribir codigo con respuesta inmediata esto gracias a V8 el motor de JS que funcion en tiempo real
  Just in time compiler!!

para ser un curso basico el ejemplo es muy dificil de entender, me hubiera gustado que e vez de dejar lecturas hubiera explicado con en video los conceptos que esta usando ya que solo hemos tocado lo basico de algoritmos pero pasar asi de HARD a un Lenguaje asusta a la mayoria, nisiquiera hemos tenido ejemplos del uso de FOR, WHILE, DO WHILE, creo que si desarrolla mas ejemplos estaria mejor

Realmente viendo solo los video es muy difícil que aprendas, yo hago lo siguiente:

en cada video cada vez que escucho un concepto o una palabra que no conozco lo googleo y veo videos en YouTube sobre el tema para poder comprender mejor y seguir avanzando.

Estuve en un Bootcamp y decidí no continuar por que es demasiado acelerado, me di cuenta de que para mi es mejor ir con calma y avanzar a paso lento pero firme, sin embargo se que hay personas que pueden ir tranquilamente a esos ritmos acelerados seguramente es por que tienen excelentes bases.

Por lo tanto tomate las cosas con calma si hay algo que no entiendes investígalo profundiza y después sigue avanzando.

Al principio pensaras que vas muy lento pero poco a poco con el tiempo vas a ver que tu ritmo de aprendizaje se ira acelerando y esto se da gracias a las buenas bases que construiste en un principio.

Antes de correr para, y aprende caminar!

function secondLargesNumber(numbers) {
	let first = numbers[0]
	let second = 0;
	for(let i=0; i < unmbers.length; i++) {
		if (numbers[i] > first) {
			second = first;
			first = numers[i]
		}
		if (numbers [i] > second && numbers[i] < first) {
			second = numbers[i];
		}
	]
	return second
}

let nums = [8, 4, 6, 10, 9, 11, 20]
console.log(secondLargestNumber(nums))

ESTO NO ES UNA EXPLICACIÓN DESDE CERO. MUY BUENO PARA EL QUE YA SABE PROGRAMACIÓN Y VIO HTML Y CSS Y JAVASCRIPT.
Necesito aprender para poder dejar mi trabajo actual, esto me hace perder tiempo!!! estoy a pasitos de volver a youtube.

Dios… no se si reir o llorar jajaja

El método “sort” tiene una forma particular de organizar los elementos dentro de un arreglo en esta pagina explican a detalle:
https://www.freecodecamp.org/espanol/news/ordenar-arreglos-en-javascript-como-usar-el-metodo-sort/

El algoritmo funcionando quedaría así:

al principio vi el video y me confundio todo, pero tuve que ver mas videos y entender el lenguaje javascript, y al final pude lograrlo entender 😄 VAMOS TU TAMBIEN PUEDES!! (me demore 1 dia en entenderlo)

no comprendo: 1. Porq se inicia en 0, es porque la posición inicial es cero [0] , la misma duda para second =0 2. Se considera el < y > pero también se puede dar el caso que sea = . 3. En el if cuál sería el else el segundo if? porque no se usa el else … si alguien sabe porfa… porq mconfundo … gracias :<

Valla que interesante nose olviden que esto es un acercamiento y si quieres profundizar en los lenguajes tienes que tomar sus cursos respectivamente no se frusten SI NO lo entienden ahora cuando profundizen en los lenjuages lo entenderan.

function secondLargestNumber(numbers){
  numbers.sort((a, b) => a + b);
  numbers.reverse();
  return numbers[1];
}

let nums = [8, 4, 6, 10, 9, 11, 20];
console.log(secondLargestNumber(nums));

En mi modesto entender, el curso está mal enfocado para aquellas personas que son nuevos en la programación.

Yo lo que hice fue primero ver la clase y hacer el código al mismo tiempo, al final ver el video otra vez, analizar más detenida mente y poner comentarios en cada línea.

function SecontLargestNumber(numbers){ //Se declara la funcion.
    let first = numbers[0] //Se declara la variable que contendrá el número más grande una vez corra el código, esta va a iniciar con la primera posición del arreglo y en caso de encontrar un número más grande va a ir cambiando de valor.
    let second = 0; //Se declara la variable que contendrá el segundo número más grande, y solo cambiara de valor una vez este número se encuentre.
    for (let i=0; i < numbers.length; i++){ //Se usa un ciclo "for" para ir por cada uno de los valores del areglo y luego realizar las evaluaciones necesarias, donde i=0 indica la posición en la que va a empezar a evaluar el arreglo, i<numbers.length le dice al ciclo que únicamente realizara comparación con los números dentro del arreglo, i++ indica cada cambio de iteración haciendo la función de un contador y asi evitar que haga un cliclo infinito.
        if (numbers[i] > first){ // Aqui pregunta si el valor que se está evaluando actualmente en arreglo es más grande que el valor actual de first, como ejemplo podemos poner la primera iteración en la que va a preguntar si la posición 1 del arreglo es más grande que 0, ya que ese fue el valor declarado inicialmente en first.
           second = first; // Si se cumple la condición anterior vamos a decirle a la variable second que tome el valor de first, porque al cumplirse esta condición first sería el segundo número más grande y numbers[i] sería el valor más grande.
           first = numbers [i] // Se le indica a first que será igual al número más grande, que en este caso seria el valor de la posición que se esta analizando en el arreglo como numbres[i].
        }
        if (numbers[i] > second && numbers[i] < first){ // Aquí se hace una doble comparación para asegurar que los valores son correctos, pregunta que si el valor del arreglo que se está evaluando es mayor que el que se encuentra en la variable second, pero menor al que se encuentra en la variable first.
            second = numbers[i]; // En caso de que la condición se cumpla la condición anterior, se indica que second tomara el valor que se evaluaba en numbers[i].
        }
    }
    return second //Aqui le indicas al código que es lo que debe retornar, que debe ser el valor de la variable que andábamos buscando.
}
let nums = [8, 4, 6, 10, 9, 14, 16, 1] //Fuera de la lógica podemos declaró el arreglo que evaluara la funcion "SecontLargestNumber"
console.log(SecontLargestNumber(nums)) // en esta línea le decimos que corra toda la lógica con el areglo del renglon aterior e imprima el resultado.

personalmente no me gusto nada este curso, me parece desordenado y muy poco natural, la forma de explicar que tiene la profesora se me hace pauteada al punto de que estoy aprendiendo mas con los comentarios de los compañeros

Hola, estoy aprendidendo a programar desde 0 y cuando digo 0 es porque es 0, y este curso básico de algoritmos de pensamiento lógico la verdad me ha parecido de lo mas mal estructurado que hay, puede que esta profesora tenga muchos conocimientos en el área de la programación pero si no sabe enseñar o por lo menos darse a entender no tiene nada que hacer acá dictando este curso, se supone que esto es básico y la señora no sabe eso. Este curso debe replantearse

La verdad me parece pésimo, que se arranque con lógica y código puro, sin hacer un acercamiento verdadero al lenguaje. Es como que le quiera explicar funciones avanzadas de excel a una persona que por primera vez abre el programa y no le de ni una mínima introducción de lo que es el programa, y con qué tipo de fórmulas nos vamos a encontrar. Malísima profesora, ya no me venía gustando su enfoque pero con esto ya menos, y perdí un monton de tiempo.

No explican bien como entrar al Replit y cual lenguaje es, terrible así confunden al que no sabe mucho de esto.

Me temo que la profesora no entiende el sentido pedagógico del asunto, dice curso básico de algoritmos y pensamiento lógico y manda una cadena de código con conceptos y palabras que no ah explicado, Así como seguirle el paso? (Hay que ir de menos a mas). por favor validar este curso desactualizado y es poco factible la verdad.

Para las personas que estan comenzando en Javascript les recomiendo este curso :
https://platzi.com/clases/basico-javascript/

El profesor explica muy bien los conceptos basicos del lenguaje y de la programacion en general

Una hora me ha tomado tratar de entender tanto la anterior clase como esta. Casi la logro, pero hay cosas que debo cuadrar todavía.
Me funcionó leer línea por línea y buscarle la lógica.

En JavaScript, podemos ordenar los elementos de un arreglo fácilmente con el método incorporado sort().

Sin embargo, los tipos de datos (cadena, número, etc.) pueden diferir de un arreglo a otro. Esto significa que usar únicamente el método sort() no siempre es la solución adecuada.

En este post, aprenderás como ordenar un arreglo en JavaScript usando el método sort() con cadenas y números.

Arreglo de Cadenas
Comencemos con cadenas:

const equipos = [‘Real Madrid’, ‘Manchester Utd’, ‘Bayern Munich’, ‘Juventus’];
Cuando usamos el método sort(), los elementos se ordenarán en orden ascendente (de la A a la Z) por defecto:

equipos.sort();

// [‘Bayern Munich’, ‘Juventus’, ‘Manchester Utd’, ‘Real Madrid’]
Si prefieres ordenar el arreglo en orden descendente, debes usar el método reverse() en su lugar:

equipos.reverse();

// [‘Real Madrid’, ‘Manchester Utd’, ‘Juventus’, ‘Bayern Munich’]
Arreglo de Números
Lamentablemente, ordenar números no es tan simple. Si aplicamos el método sort() directamente a un arreglo de números, veremos un resultado inesperado:

const numeros = [3, 23, 12];

numeros.sort(); // --> 12, 23, 3
Por qué el método sort() no funciona con números
En realidad está funcionando, pero este problema ocurre porque JavaScript ordena los números alfabéticamente. Déjame explicarte esto en detalle.

Pensemos en A=1, B=2 y C=3.

const miArreglo = [‘C’, ‘BC’, ‘AB’];

miArreglo.sort(); // [AB, BC, C]
Por ejemplo, si tenemos tres cadenas como C (3), BC (23) y AB (12), JavaScript las ordenará como AB, BC y C en orden ascendente, lo que es alfabéticamente correcto.

Sin embargo, JavaScript ordenará los números (alfabéticamente nuevamente) como 12, 23 y 3, lo cual es incorrecto.

Solución: la función de comparación
Afortunadamente, podemos complementar el método sort() con una función de comparación básica que haga el truco:

function(a, b) {return a - b}
El método sort() puede ordenar valores negativos, cero y positivos en el orden correcto. Cuando compara dos valores, los envía a nuestra función de comparación y luego ordena los valores de acuerdo al resultado devuelto.

Si el resultado es negativo, a se ordena antes que b.
Si el resultado es positivo, b se ordena antes de a.
Si el resultado es 0, nada cambia.
Todo lo que necesitamos es usar la función de comparación dentro del método sort():

const numeros = [3, 23, 12];

numeros.sort(function(a, b){return a - b}); // --> 3, 12, 23
Si queremos ordenar los números en orden descendente, esta vez necesitamos restar el segundo parámetro (b) del primero (a):

const numeros = [3, 23, 12];

numeros.sort(function(a, b){return b - a}); // --> 23, 12, 3
En conclusión
Como podemos ver, ordenar los elementos de un arreglo puede hacerse fácilmente en JavaScript con el método sort(), si sabemos usarlo correctamente. Espero que mi post pueda servirte de ayuda para entenderlo y usarlo de la mejor forma.

Paso a paso del ejercicio

1. Para crear una funcion en JavaScript lo primero es reservar con la palabra reservada la cual le daremos un nombre:

function secondLargestNumber  

Esta funcion lo que hace es encontrar el segundo valor mas alto del array que estemos buscando, para eso necesitamos recibir un parametro array dado que sería: (numbers)

function secondLargestNumber(numbers)

ahora para definir cuales son esos bloque de codigo debemos abrir { } y será aquí dentro donde pondremos toda la logica de nuestro algoritmo

1. Lo siguiente sería definir una variable que será el numero donde vamos a iniciar, la cual llamaremos first y diremos que será la posición 0 de nuestro array numbers, por lo tanto aqui ya vamos a partir desde la primera pocisión.

function secondLargestNumber(numbers) {
    let first = numbers[0]
}

1. Lo siguiente que realizariamos es la variable en la cual vamos a almacenar el segundo valor que será sobre el que vamos a empezar a trabajar y esté lo vamos a iniciar en 0

function secondLargestNumber(numbers) {
    let first = numbers[0]
    let second = 0;
}

1. Lo siguiente sería plantear la logica de la busqueda, de nuestro array para poder encontrar cual será el segundo numero mas grande, para esto vamos a utilizar un ciclo for que nos permitirá ir por cada posición de nuestro array y realizar las evaluaciones que necesitemos, recuerda que la sintaxis de for empieza definiendo una variable inicial que será la que itere y la vamos a inicializar en 0
   Luego la vamos a mover por la cantidad de posiciones que tenga nuestro array, para esto vamos a decir que mientras i sea menor a numbers en su longitud
   la palabra para traer la longitud de un array es la palabra reservada length que nos define el tamaño total de nuestro array luego incrementariamos a i++ para que haga todas las iteraciones necesarias

function secondLargestNumber(numbers) {
    let first = numbers[0]
    let second = 0;
    for (let i=0; 1 < numbers.length; i++) {
 }
}

1. Nuevamente abrimos los corchetes {} para indicar que dentro se realizara la logica de codigo, ahora vamos a preguntar si nuestro numero actual por cada una de las iteraciones que vamos a realizar es mayor a nuestro primer numero del array, como aun no tenemos conocimiento de ello, vamos a utilizar una condición if voy a colocarme en la posición actual de mi array de numbers y entre corchetes le vooy a indicar que [i] es la que me indica la posicion en la que estoy actualmente, luego le preguntaria si i es mayor a nuestro primer valor.

function secondLargestNumber(numbers) {
    let first = numbers[0]
    let second = 0;
     for (let i=0; 1 < numbers.length; i++) {
       if  (numbers[i] > first) 
 }
}

1. luego abririamos nuevamente corchetes que nos indicaría que vamos a realizar una nueva logica que se ejecutara si numbers en su posicion i, es mayor al numero que definimos como el primero, nuevamente en caso de que entremos aquí vamos a definir que nuestra variable second sera igual a first, recuerda que esto es solo si cumple con la condición que hemos cumplido en el first, luego le vamos a indicar que first tomara un nuevo valor que será numbers en la posicion actual que está dada por i

function secondLargestNumber(numbers) {
    let first = numbers[0]
    let second = 0;
     for (let i=0; 1 < numbers.length; i++) {
       if  (numbers[i] > first) {
         second = first;
         first= numbers[i]
   }
 }
}

1. si nuestra condición no se cumple debemos realizar una segunda condión donde vamos a evaluar otros casos, como será si en la posición actual donde estamos que es dada por numbers en la posición i es mayor al valor que tenemos definido como second && que ademas nuestra posición actual que es numbers en su posición i sera menor a first. Si esta condición se cumple se ejecutaría lo que vamos a definir dentro de nuestros corchetes y sera que el segundo valor de nuestra variable sera la posición actual en la que estamos.

function secondLargestNumber(numbers) {
    let first = numbers[0]
    let second = 0;
     for (let i=0; 1 < numbers.length; i++) {
       if  (numbers[i] > first) {
         second = first;
         first= numbers[i]
   }
   if (numbers[i] > second && numbers[i] < first) {
     second = numbers[i];
  }
 }
}

1. De esta manera tendremos dos casos de evaluación sobre los cuales vamos a retornar el resultado que hayamos obtenido atravez de un return second que sera el que nos indique el segundo valor, para hacer el llamado de esta función y ver si de verdad nos va a funcionar vamos a definir nuestro array de numeros, que le vamos a llamar nums y como ya no estamos dentro de nuestra función podemos darle el nombre que querramos, colocamos nums porque estamos trabajando con numeros, y
   luego colocaremos numeros al azar y luego vamos a hacer llamado a nuestra función secondLargestNumber luego dentro de parentesis vamos a pasar el argumento que sería nums que seria el valor que le corresponde a numbers que fue el parametro que definimos, así que decimos que nums será los valores que vamos a enviar.
   Para poner en funcionamiento nuestro aplicacion debemos colocar una herramienta muy simple de JavaScript que es llamada console.log que no solo muestra los datos en cosola, si no que te ayuda a debuggear tu aplicación en caso de tener un problema.

function secondLargestNumber(numbers) {
    let first = numbers[0]
    let second = 0;
     for (let i=0; 1 < numbers.length; i++) {
       if  (numbers[i] > first) {
         second = first;
         first= numbers[i]
   }
   if (numbers[i] > second && numbers[i] < first) {
     second = numbers[i];
  }
 }
  return second
}
 let nums = [8,4,6,10,9,11]
console.log(secondLargesNumber(nums))

Hola, Aquí dejo un aporte:

Solución usando Sort

function getNumber(numbers) {
    orderedNumbers = numbers.sort(function(a,b) {
        return a-b
    }); 
    console.log('arreglo ordenado: '+ orderedNumbers);
    revNumbers = orderedNumbers.reverse();
    console.log('arreglo invertido: '+revNumbers);
    for(let i = 0; i <= revNumbers.length; i++) {
        if(revNumbers[i] !== revNumbers[i+1]) {
            secLarNum = revNumbers[i+1];
            return 'el segundo número más grande es: ' + secLarNum;
        };
    }
    
}

Notas:

1. La función sort() ordena los elemetos del array como si fueran cadenas de caracteres y no valores numéricos, es necesario incluir una función de comparación para que ordene numéricamente.

2. Para solucionar el problema que se generaría en caso de tener números repetidos en los elementos del arreglo, se compara cada elemento del arreglo con el siguiente y solo si es diferente se ha encontrado el segundo número más grande.

Ejemplo:

No me quedó claro. 😦

Para la segunda forma, que dicen que no se puede, si agregamos los métodos reduce y sort podemos encontrar el segundo valor más grande dentro de un array, de esta manera:

let lista = [3, 4, 4, 1, 4, 2, 1, 1];

let lista_reducida = lista.reduce((a, e) => {
    if (!a.find(d => d == e))
    {
        a.push(e)
    }
    return a;
}, []);

console.log(lista_reducida);

lista_reducida.sort((a, b) => b - a);
console.log(lista_reducida);

console.log("El segundo valor más grande dentro de un array: " + lista_reducida[1])

Les recomiendo hacer el curso de programación básica de Fredy, esta profesora no está explicando como analizar el problema para resolverlos.

Lo primero QUE YO HICE (un análisis personal) fue definir un array cualquier, por ejemplo [3, 4, 1, 6, 2]. Luego escribí las variables que yo creía que podía necesitar, en este caso el dato que busco es el segundo número más alto, así que esa sería una, pero si hablamos de un segundo número más alto, también debe haber un primero, por lo que también agregue ese como otra variable de interés, entonces mis variables son:

# first, second

Luego escribí en un papel como sería una iteración en el array definido, y cuáles serian los valores correctos para cada variable en cada iteración.

	3 => first = 3, second = 0    # Iteracion 1
	4 => first = 4, second = 3    # Iteracion 2
	1 => first = 4, second = 3    # Iteracion 3
	6 => first = 6, second = 4    # Iteracion 4
	2 => first = 6, second = 4    # Iteracion 5

Al escribir esto en un papel, sentí que mi mente explotaba, lo primero que pude ver en el papel fue que siempre que first cambiara, second iba a tomar el valor de first, lo otro que note es first siempre iba a cambiar si el valor actual era mayor que él.

Luego lo lleve todo al código y funciono como la ceda. Cada quien tiene una forma de razonar y pensar distinta, solo tiene que buscar la tuya, no te rindas ❤️

Aquí mi implementación:

/**
 * This function find the second largest number
 * in a list of numbers (array) like [3, 4, 1, 6, 2]
 * 
 * @param int numbers
 * @return int
 */
 function findSecondLargestNumber(numbers) {
    let firstBigger  = numbers[0];
    let secondBigger = 0;
  
    for(let i=0; i < numbers.length; i++ ) {
      const number = numbers[i];
      
      if (number > firstBigger) {
        secondBigger = firstBigger; 
        firstBigger  = numbers[i];
      }  
    }
  
    console.log(`First Bigest Number is: ${firstBigger}`);
    console.log(`Second Bigest Number is: ${secondBigger}`);
  }

El problema al utilizar la función .sort es que ordena de menor a mayor según el primer dígito, es decir si el array es [11, 2, 6, 8, 33] lo va a ordenar de esta forma: [11, 2, 33, 6, 8], empezando con los primeros números 1 (11), 2(2), 3(33) y así sucesivamente.

Comparto el ejercicio explicado paso a paso, al inicio no entendía pero de esta manera se me hizo fácil entender la lógica de porqué el presente algoritmo nos da el segundo mayor valor:

1. Explicación algoritmo:
   

   

2. Desarrollo de un ejemplo:

Ahora si codigo puro y duro (lo puse en menor velocidad para entender mejor)

god!
Yo tengo un nivel de javascript muy basico, y lo que la profesora explica en este video lo entiendo, pero me imagino no saber las bases y la verdad me daria mucho susto. Este curso en vez de orientar al aprendiz lo que hace es aterrarlo y desorientarlo. Ya llegué hasta aqui lo que me obliga en lo personal a terminalo, pero me ha parecido un curso muy flojo y hardcore para las personas que estamos iniciando incluso ya sabiendo bases del lenguaje.

Hola, tal vez el código que hice es muy extenso, pero funciona para buscar el segundo número más grande en valor, así existan números repetidos.

var numeros=[1920,43,2000,9,1236,2000,1967,4,7,1235,93,1400];
var posicion=0;
var tamaño=numeros.length;
var posicionMayor=[];
var numeroMayor=numeros[posicion];
numeroGrande();
function numeroGrande()
{
  posicion+=1;
  if(posicion<tamaño)
  {
    if(numeroMayor>numeros[posicion])
    {
    }
    else
    {
        numeroMayor=numeros[posicion];
    }
    numeroGrande();
  }
  else
  {
      buscar();
  }
}

function buscar()
{
  for(var a=0;a<tamaño;a++)
  {
    if(numeroMayor==numeros[a])
    {
      posicionMayor.push(a);
    }
  }
  segundoMasGrande();
}

function segundoMasGrande()
{
  var b=0;
  numeroMayor=numeros[b];
  var tamaño2=posicionMayor.length;
  var inicio;
  for(b=1;b<tamaño;b++)
  {
    inicio=0;
    for(c=0;c<tamaño2;c++)
    {
        if(b==posicionMayor[c])
        {
          inicio=1;
        }
    }
if(inicio==1)
{

}
else
{
  if(numeroMayor>numeros[b])
  {
  }
  else
  {
    numeroMayor=numeros[b];
  }
}
  }
    alert(numeroMayor);
}

Se que estoy utilizando algunas cosas mas avanzadas pero quería dar mi aporte de otra forma de poderlo hacer.

function secondLargestNumber(numbers){
  let first = numbers[0], second = 0;

  for (let num of numbers){

    if(num > first){
      second = first
      first = num
    }
    if(num > second && num < first){
      second = num
    }
  }
  return second
}
let numeros = [1,2,3,4,5,6,7,8,9,10]
console.log(secondLargestNumber(numeros))

Les propongo otro código…

function segundo(n)
{
    let res = n.sort((a, b) =>{
        return b - a;
    });
    return res[1];
}
console.log(segundo([8, 7, 15, 10, 2, 9]));

El error esta en la manera como lo “ordena” la extensión sort() ya que su comparación la hace convirtiendo en string lo pasado como argumento, y ahí procede a la comparación, lo que daría como resultado:
numbers.sort():
[10, 11, 20, 4, 6, 8, 9]

Luego al aplicar el reverse quedaría: [9, 8, 6, 4, 20, 11, 10]
y por eso al retornar el elemento de la posición [1] es que retornamos el 8.

🤖
Razona: trata de entender qué hace cada línea, si no puedes apoyáte de un diagrama de flujo, tratemos de entender bien qué sucede.
Debuguea: Recuerda que usar las instrucciones para imprimir en pantalla te pueden ayudar ver cómo los programas se comportan en cierto punto.
Busca la documentación: Recuerda siempre buscar documentación, léela y mira cómo funciona cada cosa que usas
.
Por ejemplo, en este caso, ¿por qué me imprimer 8? No lo sé, pero puedo usar debugging:
function secondLargestNumber(numbers) {
console.log(numbers);
numbers.sort();
console.log(numbers);
numbers.reverse();
console.log(numbers);
return numbers[1];
}
Aquí puedes ver cómo use debugging para ver qué valores contenía mi elemento numbers después de cada acción.
.
Después de esto me doy cuenta de que contiene estos valores, el primer par de corchetes es a como mis valores llegan, el segundo par es después del método sort y el tercer par es después del método reverse:
.
debug.png
.
¿por qué el método sort me está ordenando los valores de esa manera? ¡No tiene ningún sentido! ¡Vamos a buscar la documentación! (hay varias páginas donde puedes documentarte, yo te dejo esta, aunque en archivos de la clase hay otra):
.
https://www.w3schools.com/jsref/jsref_sort.asp
.
Leyendo veo el método sort() ordena todo como si fueran strings, y en un string, “4” es mayor que “20”, ¿Por qué? porque estamos comparando strings, no números. De hecho un string podría decirse que compara el primer caracter, por lo que 4 es mayor que 2.
.
Ahora, si miro más abajo veo que ellos ya me proponen un algoritmo donde puedo ordenar los números directamente de forma descendiente, ya ni si quiera necesito el método reverse! Así que puedo usarlo, este algoritmo tiene su explicación, pero por ahora quédate con que te va a ordenar los números de mayor a menor:
function secondLargestNumber(numbers) {

numbers.sort( function(a, b){
    return b-a
} );

return numbers[1];

}

let nums = [8, 4, 6, 10, 9, 11, 20];
console.log(secondLargestNumber(nums))
¡Y listo!, mi programa ya funciona, problema solucionado!
.
Así es como tienen que empezsar a pensar para resolver problemas, y el debugging y la documentación serán sus mejores herramientas.

Hola, me costo mucho enteneder la logica que uso para resolver el problema. Mas que el codigo en si. Por lo que con un papel dibuje que iba haciendo el codigo paso por paso hasta que comprendi el por que de esta logica.

Ahora bien, viendo q con sort solo ordena alfabeticamente y la solucion a esto eso usar:

numeros.reverse(function(a,b){
     return b-a
   })

Use esa herramienta y luego una logica mas sencilla (creo)

use el for para ir uno por uno por el array y encontrar el numero siguiente que sea menor a la primera posición, una vez que lo encuentra cierra la busqueda haciendo que i= al largo del array. De esta forma solucionamos el problema de que el primero sea igual al segundo y el resultado sea erroneo.

la logica quedo asi

function elSegundo(numeros){
   numeros.reverse(function(a,b){
     return b-a
   })
  let elMayor = numeros[0]
  let larespuesta = numeros[1]
  for (let i=0; i < numeros.length; i++){
    if (numeros[i] < elMayor){
      larespuesta = numeros[i]
      i= numeros.length
    }
  }
 return larespuesta
}
let numeritos = [8,4,6,10,9,1,8,9,9,9,9,10,10,10]
console.log(elSegundo(numeritos))

function secondLargestNumber(numbers){
numbers.reverse(); //Este para que los invierta, quedando 11 en la posición 1. Recordando que las posiciones inician en cero
return numbers[1];
}
let nums = [8,4,6,10,9,11,20]
console.log(secondLargestNumber(nums));

No sé si está bien pero funciona jaja

Mi resultado en Repl es el siguiente:
https://arrayexc.tom4sfelipebelt.repl.co/

Añadí CSS y usé un código para generar números aleatorios en el arreglo, además de usar clasificación ascendente en el array. Sin embargo, ordenar no es eficiente para este proyecto, por lo que usé el algoritmo de la profe

Dejo esto por aqui 😃 Espero les sirva.

Los conceptos los saque de la documentacion oficial de MDN.

function secondLargestNumber(numbers) {
console.log(numbers);
numbers.sort(function(a,b){return a-b});
console.log(numbers);
numbers.reverse();
console.log(numbers);
return numbers[1];
}
let nums=[8,9,6,7,11,14,3,20,42,49]
console.log(secondLargestNumber(nums))

dejo los log para que muestre todo el proceso

¡Esta es mi solución antes de empezar la clase, su opinión es valorada!!

var numbers = [4, 9, 6, 7, 3, 2, 9];
numbers = numbers.sort();

var first = numbers[numbers.length - 1];
var second = 0;

for (var actual = 0; actual <= numbers.length; actual++) {
    if (numbers[actual] < first) {
        second = numbers[actual]
    }
}

console.log(numbers);
console.log(first);
console.log(second);

Explicación del Código hecho por la profe Ana 😃
https://i.imgur.com/Lz6ZQX1.png

El método sort () ordena los elementos de una matriz en y la devuelve ordenada. El orden de clasificación predeterminado es ascendente, que se basa en convertir los elementos en cadenas y luego comparar sus secuencias de valores de unidades de código UTF-16. por esto al hacer numbers.sort() numbers =[10,11,20,4,6,8,9] y luego cuando hacemos numbers reverse queda ordenada como numbers = [9,8,6,4,20,11,10], parea solucionar el orden de sortse utiliza la funcion compare

<code> 
let nums = [8, 4, 6, 10, 9, 11,20];
console.log(secondLargestNumber(nums));

function secondLargestNumber(numbers){
  numbers.sort(function(a, b) {
  return a - b;});  
  numbers.reverse();
  return numbers[1];
}

de esta manera se obtiene el resultado esperado que es 11 .

Ya la respuesta ya lo indico otro compañero entre los comentarios. Sin embargo, tuve que investigar como poder implementar el sort. En realidad interesante esta funcion, animo a otros a investigarlo ya que hay otras maneras para implementarlo

El error es que si se repite el número mayor, será el segundo mayor. La forma en que lo resolví (mi punto de vista):

let number = [1, 3, 6, 2, 3, 6, 8, 8];

function secondLargestnumber(number){

        number.sort();
        number.reverse();
        for (let i = 0; i < number.length; i++) {
            if(number[i] != number[i+1])
            {
                return number[i+1];
            }
        }
       
}

console.log(secondLargestnumber(number));

function secondLargesNumeber(numbers){

let second =0;
let first = numbers[0]

for( let i=0; i<numbers.length;i++){
if (numbers[i] > first ) {
second = first;
first = numbers[i];
}
if (numbers[i] > second && numbers[i] < first ) {
second = numbers;
}
return second;
}
}
let nums = [8,4,6,10,11,20];
console.log(secondLargesNumeber(nums));

Resolví el ejercicio de la segunda forma volviéndolo funcional
Gracias al uso de If y de la recursividad.

var arr = [1,7,7,7,7,7,7,7,7];
var arrOrd = arr.sort();
function segundoMayor(n) {
    if ((n - 1) === 0) {
        console.log("Todos los numeros son iguales");   
    } else {
            if (arrOrd[n - 1] == arrOrd[n - 2]) {
                segundoMayor(n - 1);
            } else {
                console.log(arrOrd[n - 2]);
            }
        }
}
segundoMayor(arrOrd.length);

Para los que no quieren copiar el código a mano

function secondLargestNumber(numbers){
	let first=numbers[0];
	let second=0;

	for (let i=0; i < numbers.length; i++){
		if (numbers[i] > first){
			second=first;
			first=numbers[i]
		}
		if (numbers[i] > second && numbers[i] < first){
			second=numbers[i];
		}
	}
	return second;
}

let numbs=[8,4,6,10,9,11]
console.log(secondLargestNumber(numbs))__

De pronto hay personas que se siente perdidos con esta, yo lo estaría si no fuera por el curso básico gratis de Freddy.

De pronto unas pequeñas ayudas para poder entender mejor el código.

• Los for reciben tres datos (inicio de variable, condición para salirse del for, incremento de la variable): Para este caso, se inicia la variable i igual a 0, se acaba apenas se recorra todos los valores de nums, y se incrementa de uno con el i++, es decir

i++ =  i + 1

• Cuando se tiene valores dentro de unos corchetes [ ], significa que son arrays que es una colección de valores, la ubicación en los arrays empiezan en 0, por eso la variable i del for se comienza en 0.

• Recuerda que el doble && es el condicional and.

• Es buena practica aunque no necesario, colocar el punto y coma al final de líneas de código de JavaScript con el fin de acostumbrarse a una escritura mas parecida a otros lenguajes de programación como C, ejemplo:

let first = numbers[0];

Espero que sea de gran ayuda 😃

Me encantó la libertad de poder resolver el problema primero desde la lógica y luego volcarlo a un lenguaje de programación concreto. Creo que debería haber hecho este curso antes de intentar aprender un lenguaje porque me abrió la cabeza. Como dice la canción: “Such a little thing makes such a big difference”.

Intenté buscarle la vuelta para encontrar una solución distinta y practicar, y me salió esto:

https://replit.com/@GabiMin1/Second-Largest-Number#script.js

function secondLargest(numbers) {
  numbers.sort(function(a, b){return b - a});
  let second = numbers[1]
  for (i = 0; i < numbers.length; i++) {
    if (second < numbers[i]){
      break
    }
    else {
    second = numbers[i+2]
    }
  }
  return second
}
let nums = [1,6,9,9,9,8,8,6,3,5,2,4,7];
console.log(secondLargest(nums))

cositas.sort();

Este método ordena las cositas del arreglo dependiendo del orden que tengan en UNICODE (Universal character encoding), es por ello que de un arreglo como el siguiente y por ende el resultado esperado no concuerde:

const cositas = [0,16,100, 20, 20, 21, 40, 30, 11, 1];
cositas.sort()
//Resultado
//0,1,100,11,16,20,20,21,30,40
cositas.reverse()
//Resultado
//40,30,21,20,20,16,11,100,1,0

Evidentemente cositas[1]=30 y lo esperado es que sea 40.

cuando se usa el metodo sort() en números, JavaScript interpreta dichos numeros como cadenas de caracteres, esto es, como si fueran letras.
es por eso que en el ejemplo, cuando se utiliza numbers.sort();
el array quedaría de esta forma:
[ 10, 11, 20, 4, 6, 8, 9]

El resultado para el uso de la funcion es:
let nums = [2, 4, 7, 3, 9, 5, 15, 18, 20, 22]
nums.sort(function(a, b){return a-b});
nums.reverse()
console.log(nums[1])

El código no funciona porque si hacemos sort() al arreglo

const numbers = [8, 4, 6, 10, 9, 11, 20];
numbers.sort();
// El resultado sería este nuevo arreglo
const numbers = [10, 11, 20, 4, 6, 8, 9];

Porque JavaScript hace el ordenamiento conforme la tabla ASCII que es por los valores unicode de los números. y ahí 10 es menor que 4. Pueden revisarla.
Para que lo ordene tiene que pasarle una función
De menor a mayor

numbers.sort((a,b) => a - b)

Ordenar de mayor a menor

numbers.sort((a, b) => b - a);

Esto nos daría este código

const numbers = [8,4,6,10,9,11,20];
numbers.sort((a, b) => b - a);
numbers.reverse

Pero aunque utilicemos sort() y reverse(), tenemos el problema de si tenemos el número mayor duplicado por ejemplo dos 20.

const numbers = [8,4,6,10,20,9,11,20];

numbers.sort((a, b) => b - a);

let first = numbers[0];
let second = 0;

numbers.forEach((numbers, index) => {
  if (numbers < first && second < numbers) {
    second = numbers;
  }
});
console.log(`El primer valor es ${first} y el segundo valor es ${second}`);

numbers.forEach() es un método de JavaScript y ejecuta la función indicada una vez por cada elemento del array.

Mas resumido.

let numeros = [
  1,
  2,
  15,
  4,
  34,
  69,
  5,
];

numeros.sort((a, b) => b - a);

console.log(numeros[1]);

Veo que muchos no entienden los conceptos que menciona la profesora . Creo que se debe en parte al cambio en la ruta de desarrollo web pues antes este curso estaba más adelante . Si están perdidos, busquen el curso de programación básica de Fredy, esta antes que este y la verdad sirve mucho.

Hay que tener en cuenta los conceptos de cada método de un arreglo, que son varios y cada uno tiene su forma de trabajar.
Por ejemplo el metodo .sort() es mas aplicable en cadenas de texto ya que si se lo hacen para números estos no dan el resultado deseado.
Quizás muchos esperamos que se definan todos los conceptos que son nuevos para algunos en el curso, pero también es necesario el autoaprendizaje e investigación.

El metodo sort tiene un criterio por defecto, que es el alfabetico, es decir el 1 va primero que el 2, pero segun eso tambien 1000 va primero que el 2.

lo que se tiene que hacer es escribir el criterio (una funcion de ordenamiento) y pasarla como argumento al metodo sort

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort

Solución al problema:
sort hace que el 8 sea mayor que el 11 por ejemplo, ya que lo interpreta como 8 < 1, con el reverse hace que sea de forma descendente, entonces el numero mayor en el ultimo ejercicio planteado vendría ser 9 seguido del 8, es por eso que sale 8.

Vengo de tener algo de experiencia en python y la verdad no mucha trabajando en mi pensamiento de algoritmos. Me pareció retador el ejemplo! y me tardé un rato en entenderle, pero me ayudó a aprender varias cosas sobre JS de golpe.

Para tratar de ver si había entendido el algoritmo intenté ir en reversa, dibujar el diagrama de flujo y luego implementarlo en Python. Me ayudó a entenderlo mejor. Les comparto el resultado (:

def second_largest (num_list):
	
	nums = num_list
	# Initialize first and second values
	first = nums[0]
	second = 0
	
	# Iterating through every 'i' element of nums
	for i in nums:
		# if current i is greater than first
		if i > first:
			# then it means the current first should be second
			second = first
			# and the current i should be first
			first = i
		
		# if current i is not greater than first 
		# but greater than second
		if i < first and i > second:
			# then it means that the first remains first
			# and that current i should become the new second
			second = i
	
	# As in the first cycle i = first, no changes are made
	# to second up until the second cycle
	return second
	
	
if __name__ == '__main__':
	test_nums = [8, 4, 6, 10, 9, 11]
	print(second_largest(test_nums))

Hola, solo quería comentar que si bien podrían haber formas más sencillas, se siente bien esforzar la mente para comprender nuevas lógicas. Es cómo llevar el cerebro al gym. Intenten entender la lógica y la satisfacción al lograrlo será exquisita.

Pd: Después de unos buenos minutos logré entenderla

Así es como lo resolví

Leyendo un poco de la documentación y con la ayuda del todo poderoso stackoverflow pude resolver el ejercicio.

function sortArray(nums){
    nums.sort(function(a, b){return a - b});
    nums.reverse();

    return nums;
}

let numbers = [8, 4, 5, 10, 3, 11];
sortArr = sortArray(numbers);

console.log(numbers);
console.log(sortArr);
console.log("The second largest number is: " + sortArr[1]);

[ 11, 10, 8, 5, 4, 3 ]
[ 11, 10, 8, 5, 4, 3 ]
The second largest number is: 10
$

Sin embargo este código no resuelve el problema de si el número más grande se repite más de una vez, por ejemplo en el array numbers 11 es el número más grande, por lo que si se repite, este código no funciona. Ej:

function sortArray(nums){
    nums.sort(function(a, b){return a - b});
    nums.reverse();

    return nums;
}

let numbers = [8, 4, 5, 10, 11, 11]; //Cambie el 3 por otro 11
sortArr = sortArray(numbers);

console.log(numbers);
console.log(sortArr);
console.log("The second largest number is: " + sortArr[1]);

Resultado

[ 11, 11, 10, 8, 5, 4 ]
[ 11, 11, 10, 8, 5, 4 ]
The second largest number is: 11
$

Como podemos ver el resultado es incorrecto considerando que 10 sería el segundo número más grande en el array numbers. En todo caso esta fue mi solución. Si alguien encontró como resolver este problema utilizando las funciones sort y reverse y unas que otras condiciones, déjame tu solución en los comentarios.

La explicación de por qúe usando las funciones de javascript sale el 8 es la siguiente:
Al hacer el numbers.sort() Javascript lo que hace es ordenarlas alfabéticamente, no numericamente. En este caso, la array ordenada quedaría [10, 11, 20, 4, 6, 8 ,9]
Y luego al darle vuelta con numbers.reverse() la array termina como [9, 8, 6, 4, 20, 11, 10].
Finalmente, seleccionando la segunda posición nos arroja el 8.

Se implementa en Rust:

fn main() {
    let mut numbers: [i32; 6] = [8, 4, 6, 10, 9, 11] ;
    // Metodo 1:
    println!("second_larges_number({:?}) = {}", numbers, second_larges_number(numbers)) ;
    // Metodo 2:
    numbers.sort_by(|a, b| b.cmp(a)) ;
    println!("Ordered descending = {:?} ==> Second (numbers[1]) = {}", numbers, numbers[1]) ;
}

fn second_larges_number(numbers: [i32; 6]) -> i32 {
    let mut first = numbers[0] ;
    let mut second = 0 ;
    for n in numbers {
        if n > first {
            second = first ;
            first = n ;
        }
        if n > second && n < first {
            second = n ;
        }
    }
    return second ;
} 

Personalmente, gracias a este curso he comprendido conceptos básicos de la lógica, el problema está en que al momento de llevar a la práctica este tipo de ejercicios, no sé cómo resolverlos. Aunque yo sé que todo es cuestión de tiempo para que me vaya familiarizando y así poder resolver esto pan comido 😄 Por el momento, seguiré.

function seccondLargesNumber(numbers)
{
	console.log(numbers.sort()); //poder ver el orden del array por consola y la forma en la que los ordena
	console.log(numbers.reverse()); //poder ver el orden del array por consola y la forma en la que los ordena
	return numbers[4]
}
let nums = [8,4,6,10,9,11,20]
console.log(seccondLargesNumber(nums)); // mostrar por consola el número más grande

Pueden probar el código dirigiéndose a una nueva pestaña " Ctrl + t ", después para abrir la consola " Ctrl + Shift + j ", y entonces copian y pegan el código.

Hice este diagrama con el animo de comprender bien el ejercicio
lo comparto por si alguien le sirve
como dato curioso parece ejecutar una iteración de mas, pienso que
podría corregirse utilizando un comparador mayor o igual en el FOR

function secondLargestnumber(numbers) [
let first = numbers[0]
let second = 0;
for (let i=0; i < numbers. leng; i++) [
if (numbers[i] > first) [
second = first;
first = numbers[i]
]
if (numbers[i]) > second && numbers[i] < first) [
second = numbers [i];
]
return second
]
let nums = [8,4,6,10,9,11]
console.log(secondLargestnumber(nums))

Siento que esto es muy avanzado para mi que estoy empezando. No entiendo y me frustra. 😭

Busque un poco y parece que la razón del error es porque al utilizar la instrucción .sort() sin especificar como se comparan los elementos que en nuestro caso son los numeros, lo que hara .sort() es convertir los números a una cadena(string) y comparara su orden según su valor en el UNICODE

Array original : [8, 4, 6, 10, 9, 11, 20]
Array.sort() : [10, 11, 20, 4, 6, 8, 9]
Array.reverse() : [9, 8, 6, 4, 20, 11, 10]

¿Ven como el 8 quedo en la segunda posición? y por eso cuando la profesora pone el return numbers[1] el resultado es el 8. FUA ESPERO HABER AYUDADO!!!

Lo intente de otra forma

let numeros = [3, 10, 19, 12, 8, 11, 20];
let primero = 0; 
let segundo = 0;

for (i of numeros)
{
    if (i > primero)
    {
        segundo = primero;
        primero = i;

    }
    else if (i > segundo)
    {
        segundo = i;
        primero = primero;
    }
    else
    {
        segundo = segundo;
        primero = primero;
        
    }
    
    
}

document.write("el numero mayor es " + primero + "<br />");
document.write("el segundo mayor es " + segundo);

Vengo de hacer el curso basico de pyton

si estas leyendo esto y te esta costando, no te preocupes, lee y anota todo y trata de hacer los ejercicios, hay muchos cursos y yo se que estas ansioso/a de pasarte a nuevo curso, pero trata de entender bien los conceptos de este curso

La razón por la que no da con sort es porque este los ordena de manera ascendente pero tomando encuentra con el numero que inician, esto quiere decir que si tiene 12 y 4 en lugar de ordenarlos 4, 12 los ordenará 12, 4.

Aun no se bien como usar java y decidi hacerlo en raptor, coloque los numeros en desorden y al final me dio el segundo numero mayor, aunque creo que de este modo (raptor) es mas dificil

Me siento mal por no haberlo realizado aun teniendo experiencia con js, tuve que venir a ver como se hacia 😦

Lo solucione de esta forma:

function secondLargesNumber(numbers){
	numbers.sort((a,b) => b -a)
	return numbers[1]
	}
let nums = [8, 4, 6, 10, 9, 11]
secondLargesNumbers(nums)

Lo de como utilizar .sort lo leí en la documentación oficial en MDN, leer documentación oficial va ser siempre una necesidad en este camino de la programación, aunque los videos es una manera dinamica de aprender.