Viendo que podemos hacer todo lo que nos pide, Ana quiere saber la

ganancia promedio de los balances positivos. 

Definí las funciones:

 gananciaPositiva, que es la suma de las ganancias de los balances positivos

 promedioGananciasPositivas invocando gananciaPositiva y cantidadDeBalancesPositivos.

 ¡Dame una pista!

function promedio(listaDeNumeros) {
return sumatoria(listaDeNumeros) / longitud(listaDeNumeros);
}

function sumatoria(listaDeNumeros) {
let sumatoria = 0;
for (let numero of listaDeNumeros) {
sumatoria = sumatoria + numero;
}
return sumatoria;
}

Solución dada;

function gananciaPositiva (balancesDeUnPeriodo){

let sumatoria = 0;

for (let balance of balancesDeUnPeriodo){

if (balance.ganancia >0 ) {

sumatoria = sumatoria + balance.ganancia;

return sumatoria

}
function promedioGananciasPositivas (balancesDeUnPeriodo){

return gananciaPositiva(balancesDeUnPeriodo)/
cantidadDeBalancesPositivos(balancesDeUnPeriodo);

}
Por suerte existe una herramienta que va a simplificar nuestra tarea de ahora
en adelante: las variables. 

Las variables nos permiten nombrar y reutilizar valores. Similar a cómo los

procedimientos y funciones nos permiten dar nombres y reutilizar soluciones
a problemas más pequeños. Por ejemplo, si hacemos...

let primerMes = "enero"

...estamos asignándole el valor "enero" a la variable primerMes. En criollo,

estamos dándole ese valor a la variable. 

Cambiá los lugares donde aparece 3.14159265358979 por la variable pi en las funciones

que tenemos definidas.

let pi = 3.14159265358979;

function perimetroCirculo(radio){
return ( (2 * pi) * radio);
}
function areaCirculo(radio){
return (pi * radio * radio);
}

Entonces, ¿es necesario darle valor a nuestras variables antes de usarlas?

¡Sí!  Cuando declarás una variable tenés que darle un valor inicial, lo cual se
conoce como inicializar la variable.
¡Y sorpresa! Podemos declarar variables tanto directamente en el programa,
como dentro de una function:

function cuentaExtravagante(unNumero) {
let elDoble = unNumero * 2;
if (elDoble > 10) {
return elDoble;
} else {
return 0;
}
}
Las variables declaradas dentro de una function, conocidas como variables
locales, no presentan mayor misterio. Sin embargo, hay que tener un
particular cuidado: sólo se pueden utilizar desde dentro de la function en
cuestión. Si quiero referenciarla desde un programa:

let elCuadruple = elDoble * 4;

Kaboom, ¡se romperá! 

Sin embargo, las variables declaradas directamente en el programa, conocidas

como variables globales, pueden ser utilizadas desde cualquier function. Por
ejemplo:

let pesoMaximoEquipajeEnGramos = 5000;

function puedeLlevar(pesoEquipaje) {
return pesoEquipaje <= pesoMaximoEquipajeEnGramos;
}

Veamos si queda claro: definí una función ascensorSobrecargado, que toma una cantidad de
personas y retorna si entre todas superan la carga máxima de 300 kg.
Tené en cuenta que nuestra función va a utilizar dos variables globales:

 pesoPromedioPersonaEnKilogramos, la cual ya está declarada,

 cargaMaximaEnKilogramos que vas a tener que declarar.

let cargaMaximaEnKilogramos=300
2
function ascensorSobrecargado(personas){
3
 return pesoPromedioPersonaEnKilogramos * personas >=cargaMaximaEnKilogramos ;
4
}
Enviar

Vimos que una variable solo puede tener un valor, entonces cada vez
que le asignamos uno nuevo, perdemos el anterior. Entonces, dada la
función:

function cuentaExtravagante() {
let numero = 8;
numero *= 2;
numero += 4;
return numero;
}

Empecemos por algo sencillo, ¿te acordás del operador ! ? Se lo denomina

negación, not o complemento lógico y sirve para negar un valor booleano.

Si tengo el booleano representado por tieneHambre, el complemento será !

tieneHambre.

¿Y esto para qué sirve?  Por ejemplo, para modelar casos de alternancia como
prender y apagar una luz :

let lamparaPrendida = true;

function apretarInterruptor() {
lamparaPrendida = !lamparaPrendida;
}

let mochilaAbierta = true;

function usarCierre(){
mochilaAbierta = !mochilaAbierta ;
}
Ejercicio 4: La verdad detrás de la
conjunción
En la lógica booleana, se puede definir el comportamiento de un operador
con una tabla de verdad donde A y B son las expresiones o valores de verdad
a ser operados y el símbolo ^ representa la conjunción. Cada celda tiene una
V si representa verdadero o F si representa falso.

Por ejemplo, supongamos que una casa consume poca energía si se usa el
aire acondicionado a 24 grados y tiene al menos 5 lamparitas bajo consumo.
Podemos representar las expresiones de la siguiente forma:

 A: En la casa se usa el aire acondicionado a 24 grados

 B: La casa tiene al menos 5 lamparitas bajo consumo
 A ^ B: La casa consume poca energía

Como indicamos, la casa consume poca energía (A^B) cuando

tanto A como B son verdaderos. Esto se puede representar mediante la
siguiente tabla de verdad:

A B A^B
V V V
V F F
F V F
F F F
En el mundo de la lógica estas expresiones se llaman proposiciones. Pero…
¿qué cosas pueden ser una proposición?  Sólo hace falta que porten un valor
de verdad, es decir, cualquier expresión booleana puede ser una proposición.

Y si basta con que una de varias condiciones se cumpla para afirmar que una
expresión es verdadera? Podemos utilizar otro de los operadores que ya
conocés, ¡la disyunción lógica! 

Recordá que se lo representa con el símbolo || y también se lo conoce como el

operador or.
En el famoso juego T.E.G., un jugador puede ganar de dos formas:
cumpliendo su objetivo secreto o alcanzando el objetivo general de
conquistar 30 países.

function gano(cumplioObjetivoSecreto, cantidadDePaisesConquistados) {

return cumplioObjetivoSecreto || cantidadDePaisesConquistados >= 30;
}

Nuestra amiga Dory  necesitaba hacer algunos trámites en el banco, pero

cuando llegó notó que estaba cerrado. 

Para evitar que le ocurra nuevamente, vamos a definir una función que ayude
a la gente despistada como ella.

Sabemos que el banco está cerrado cuando:

 Es feriado, o
 Es fin de semana, o
 No estamos dentro del horario bancario.

La función dentroDeHorarioBancario ya la definimos por vos: recibe un

horario  (una hora en punto que puede ir desde las 0 hasta las 23) y nos dice
si está comprendido en la franja de atención del banco.

function esFinDeSemana (dia){

return dia === "sábado" || dia === "domingo"
}
function estaCerrado(feriado, dia, horario) {
return feriado || esFinDeSemana (dia)|| !dentroDeHorarioBancario
(horario) ;
}

Oli está diseñando una página web y se está centrando en el contraste de sus
componentes.  Para lograrlo, nos pidió que definamos la
función tieneContraste que recibe como argumentos el color de la letra y el
color del fondo de la página y retorna si la página tiene contraste.

Para empezar ya contamos con la función esTonoClaro que toma un color por

parámetro y retorna si es claro.

esTonoClaro('rojo')
false

esTonoClaro('blanco')
true

¡Ahora te toca a vos! Definí la función tieneContraste. Para que la página tenga contraste
tiene que tener el fondo claro y la letra no o bien tener la letra clara y el fondo no.

function tieneContraste(letra,fondo){
return (!esTonoClaro(letra) && esTonoClaro(fondo)) || (esTonoClaro(letra)
&& !esTonoClaro(fondo)) ;
}

Ahora cambiemos las proposiciones la letra tiene tono claro y el fondo tiene tono
claro por proposiciones genéricas A y B. Además, representemos la operación
que realiza tiene contraste con el símbolo ⊻. Lo que obtenemos es... ¡una nueva
tabla! 

A B A⊻B
V V F
V F V
F V V
F F F
Este comportamiento existe como un operador dentro de la lógica y se lo
denomina xor o disyunción lógica excluyente.

A diferencia del and, or y not, el xor no suele estar definido en los lenguajes.  Sin

embargo, ahora que sabés cómo funciona, si alguna vez lo necesitás podés
definirlo a mano. 

Veamos si se entiende: definí la función genérica xor, que tome dos booleanos y retorne
el valor de verdad correspondiente.
function xor(A,B){
return A!==B ;
}

Cuando una expresión matemática tiene varios operadores, sabemos que las
multiplicaciones y divisiones se efectuarán antes que las sumas y las restas:

5 * 3 + 8 / 4 - 3 = 14

Al igual que en matemática, cuando usamos operadores lógicos las

expresiones se evalúan en un orden determinado llamado precedencia.

¿Cuál es ese orden? ¡Hagamos la prueba!

Teniendo definida la siguiente función, según la cual las tarjetas de débito

ofrecen una única cuota, y las de crédito, seis:

function pagaConTarjeta(seCobraInteres, tarjeta, efectivoDisponible) {

return !seCobraInteres && cuotas(tarjeta) >= 3 || efectivoDisponible < 100;

Si prestaste atención a la función anterior, habrás notado que la operación

con mayor precedencia es la negación !, seguida de la conjunción && y por
último la disyunción ||. ¿Pero qué pasa si quiero alterar el orden en que se
resuelven? 

Al igual que en matemática, podemos usar paréntesis para agrupar las

operaciones que queremos que se realicen primero.

Delfi se puede concentrar cuando programa y toma infusiones, pero no

cualquier infusión. Tiene que ser mate  a exactamente 80ºC o té  que esté a
por lo menos 95ºC.

Definí la función sePuedeConcentrar que recibe una bebida, su temperatura y un booleano

que nos dice si Delfi está programando:
 sePuedeConcentrar('té', 100, true)
true

sePuedeConcentrar('mate', 70, true)

false

sePuedeConcentrar('té', 95, false)

false

¡Intentá resolverlo en una única función! Después vamos a ver cómo quedaría si
delegamos.

function sePuedeConcentrar(bebida,temp,prog){
return (bebida==="mate" && temp===80 && prog)||(bebida==="té"&&
temp>=95 && prog) ;
}
Cuando una expresión matemática tiene varios operadores, sabemos que las
multiplicaciones y divisiones se efectuarán antes que las sumas y las restas:

5 * 3 + 8 / 4 - 3 = 14

Al igual que en matemática, cuando usamos operadores lógicos las

expresiones se evalúan en un orden determinado llamado precedencia.

¿Cuál es ese orden? ¡Hagamos la prueba!

Teniendo definida la siguiente función, según la cual las tarjetas de débito

ofrecen una única cuota, y las de crédito, seis:

function pagaConTarjeta(seCobraInteres, tarjeta, efectivoDisponible) {

return !seCobraInteres && cuotas(tarjeta) >= 3 || efectivoDisponible < 100;
}

Probala en la consola con los valores:

  pagaConTarjeta(true, "crédito", 320)

  pagaConTarjeta(false, "crédito", 80)
  pagaConTarjeta(true, "débito", 215)
  pagaConTarjeta(true, "débito", 32)
Si prestaste atención a la función anterior, habrás notado que la operación
con mayor precedencia es la negación !, seguida de la conjunción && y por
último la disyunción ||. ¿Pero qué pasa si quiero alterar el orden en que se
resuelven? 

Al igual que en matemática, podemos usar paréntesis para agrupar las

operaciones que queremos que se realicen primero.

Delfi se puede concentrar cuando programa y toma infusiones, pero no

cualquier infusión. Tiene que ser mate  a exactamente 80ºC o té  que esté a
por lo menos 95ºC.

Definí la función sePuedeConcentrar que recibe una bebida, su temperatura y un booleano

que nos dice si Delfi está programando:

sePuedeConcentrar('té', 100, true)

true

sePuedeConcentrar('mate', 70, true)

false

sePuedeConcentrar('té', 95, false)

false

¡Intentá resolverlo en una única función! Después vamos a ver cómo quedaría si
delegamos.

function sePuedeConcentrar(bebida,temp,prog){
return (bebida==="mate" && temp===80 && prog)||(bebida==="té"&&
temp>=95 && prog) ;
}

En un parque de diversiones de la ciudad instalaron una nueva montaña

rusa  y nos pidieron ayuda para que le digamos a las personas si pueden
subirse o no antes de hacer la fila. Los requisitos para subir a la atracción son:

 Alcanzar la altura mínima de 1.5m (o 1.2m si está acompañada por una

persona adulta)
 No tener ninguna afección cardíaca
Definí la función de 3 parámetros puedeSubirse que recibe una altura de una persona en
metros, si está acompañada y si tiene alguna afección cardíaca. Ejemplo:

puedeSubirse(1.7, false, true)

false // no puede subirse
// porque aunque tiene mas de 1.5m,
// tiene una afección cardíaca

function puedeSubirse(altura,compa,afección){
return (altura===1.5 || altura===1.20 && compa) && (!afección) ;
}
Supongamos que queremos representar al conjunto de nuestras series
favoritas. ¿Cómo podríamos hacerlo?

let seriesFavoritasDeAna = ["Game of Thrones", "Breaking Bad", "House of Cards"];

let seriesFavoritasDeHector = ["En Terapia", "Recordando el Show de Alejandro Molina"]

Como ves, para representar a un conjunto de strings, colocamos todos esos

strings que nos interesan, entre corchetes ([ y ]) separados por comas. Fácil,
¿no?

Probá en la consola las siguientes consultas:

 seriesFavoritasDeAna
 seriesFavoritasDeHector
 ["hola","mundo!"]
 ["hola","hola"]

Lo que acabamos de ver es cómo modelar fácilmente conjuntos de cosas.

Mediante el uso de [], en JavaScript contamos con una manera simple de
agrupar esos elementos en listas.

¿Acaso hay una cantidad máxima de elementos? ¡No, no hay límite! Las listas
pueden tener cualquier cantidad de elementos.

Y no sólo eso, sino que además, el orden es importante. Por ejemplo, no es lo

mismo ["hola", "mundo"] que ["mundo", "hola"]: ambos tienen los mismos
elementos, pero en posiciones diferentes.

Probá en la consola las siguientes consultas:

 listasIguales(["hola", "mundo"], ["mundo", "hola"])

 listasIguales(["hola", "mundo"], ["hola", "mundo"])
  listasIguales(["hola", "mundo"], ["hola", "todo", "el", "mundo"])
 listasIguales(["hola"], ["hola", "mundo"])
 ["hola", "mundo"] === ["mundo", "hola"]
 personas
 ["mara", "julian"] === personas
 personas === personas

Pero, pero, ¿sólo podemos crear listas de strings? ¿Y si quiero, por ejemplo,
representar los números de la lotería que salieron la semana pasada? ¿O las
tiradas sucesivas de un dado? ¿O si salió cara o ceca en tiradas sucesivas de
una moneda?

let numerosDeLoteria = [2, 11, 17, 32, 36, 39];

let tiradasDelDado = [1, 6, 6, 2, 2, 4];
let salioCara = [false, false, true, false];

Como ves, también podemos representar conjuntos de números o booleanos,

de igual forma: escribiéndolos entre corchetes y separados por comas.
Podemos tener listas de números, de strings, de booleanos, etc. ¡Incluso
podríamos tener listas de listas!

Veamos si queda claro. Probá en la consola las siguientes consultas:

 numerosDeLoteria
 salioCara
 [[1, 2, 3], [4, 5, 6]]

 Genial, ¡parece que una lista puede contener cualquier tipo de

elemento! Podemos tener listas de booleanos, de números, de strings,
de listas...

 Y no sólo eso, sino que además pueden contener cualquier cantidad de

elementos: uno, dos, quince, cientos.

 ¿Podremos entonces tener listas vacías, es decir, que no tengan

elementos? ¡Por supuesto!

 let unaListaVacia = []
Por el momento ya sabemos qué cosas podemos representar con listas, y
cómo hacerlo. Pero, ¿qué podemos hacer con ellas?
Empecemos por lo fácil: saber cuántos elementos hay en la lista. Esto lo
podemos hacer utilizando la función longitud, de forma similar a lo que
hacíamos con los strings.

Realizá las siguientes consultas en la consola:

 longitud([])
 longitud(numerosDeLoteria)
 longitud([4, 3])

Las listas son muy útiles para contener múltiples elementos. ¡Pero hay más!
También podemos agregarle elementos en cualquier momento, utilizando la
función agregar, que recibe dos parámetros: la lista y el elemento. Por ejemplo:

let pertenencias = ["espada", "escudo", "antorcha"];

//longitud(pertenencias) devuelve 3;

agregar(pertenencias, "amuleto mágico");

//ahora longitud(pertenencias) devuelve 4

Como vemos, agregar suma un elemento a la lista, lo cual hace que su tamaño

aumente. ¿Pero en qué parte de la lista lo agrega? ¿Al principio? ¿Al final? ¿En
el medio?

Averigualo vos: inspeccioná en la consola qué elementos contiene pertenencias, agregale

una "ballesta" y volvé a inspeccionar pertenencias.
Además existe un procedimiento remover, que recibe la lista y un elemento por
parámetro. Investigá en la consola qué hace. 

Bueno, ya hablamos bastante; ¡es hora de la acción !

Definí el procedimiento trasladar, que tome dos listas y un elemento de la

primera. trasladar debe sacar el elemento de la primera lista y agregarlo en la segunda.
Ejemplo:

let unaLista = [1, 2, 3];

let otraLista = [4, 5];

trasladar(unaLista, otraLista, 2);

unaLista //debería ser [1, 3]

otraLista //debería ser [4, 5, 2]

function trasladar(unaLista,otraLista,numero){
remover(unaLista,numero) || agregar(otraLista,numero);
}

Otra cosa que queremos hacer con las listas es saber en qué posición se
encuentra un elemento. Para ello utilizamos la función posicion de la siguiente
manera:

posicion(["a", "la", "grande", "le", "puse", "cuca"], "grande"); //devuelve 2

let diasLaborales = ["lunes", "martes", "miercoles", "jueves", "viernes"]

posicion(diasLaborales, "lunes"); //devuelve 0

Como ves, lo curioso de esta función es que pareciera devolver siempre uno
menos de lo esperado. Por ejemplo, la palabra "grande" aparece tercera, no
segunda; y "lunes" es el primer día laboral, no el cero. ¿Es que los creadores de
JavaScript se equivocaron? 

¡No! Se trata de que en JavaScript, al igual que en muchos lenguajes, las

posiciones de las listas arrancan en 0: el primer elemento está en la posición
0, el segundo en la 1, el tercero en la 2, y así.

¿Y qué sucede si le pasás como argumento a posicion un elemento que no tiene?

¡Averigualo!
Probá lo siguiente:

posicion(diasLaborales, "osvaldo")

¡Ahora te toca a vos!

Definí la función contiene que nos diga si una lista contiene un cierto elemento.

contiene([1, 6, 7, 6], 7)
true
contiene([1, 6, 7, 6], 6)
true
contiene([], 7)
false
contiene([8, 5], 7)
false

function contiene(unaLista,elemento) {
return posicion(unaLista,elemento) !==-1
}
Si venís prestando atención a los ejemplos de consulta, habrás notado que las
listas también pueden tener elementos duplicados: [1, 2, 1], ["hola", "hola"], etc.

Por tanto, posicion en realidad devuelve la posición de la primera aparición del

elemento en la lista. Por ejemplo:

posicion(["qué", "es", "eso", "eso", "es", "queso"], "es")

1 //devuelve 1 porque si bien "es" también está en la posición 4, aparece primero en la posición 1.

Así como existe una función para averiguar en qué posición está un
elemento, también puede ocurrir que queramos saber lo contrario: qué
elemento está en una cierta posición. 

Para averiguarlo podemos usar el operador de indexación, escribiendo

después de la colección y entre corchetes [] la posición que queremos para
averiguar:

mesesDelAnio[0]
"enero"
["ese", "perro", "tiene", "la", "cola", "peluda"][1]
"perro"

¡Ojo! El número que le pases, formalmente llamado índice, debe ser menor a

la longitud de la lista, o cosas malas pueden suceder. 
Si le pedís un elemento en una posición igual o mayor al tamaño de la lista,
vas a obtener undefined. No parece algo terrible, pero el problema es que
con undefined no podés hacer nada realmente útil.

Así que la advertencia es: ¡no te pases de índice! 

Teniendo esto en cuenta, va un desafío: definí nuevamente la función medallaSegunPuesto,

pero esta vez usando como máximo un único if. Quizás las listas te pueden ser útiles
acá .
Te recordamos qué hace la función: tiene que devolver la medalla que le corresponde a
los primeros puestos de una competencia.

medallaSegunPuesto(1)
"oro"
medallaSegunPuesto(2)
"plata"
medallaSegunPuesto(3)
"bronce"
medallaSegunPuesto(4)
"nada"
medallaSegunPuesto(5)
"nada"

let medalla = ["oro", "plata", "bronce"];

function medallaSegunPuesto(lugar) {
if (lugar === 1 || lugar === 2 || lugar === 3){
return (medalla [lugar -1])
} else {
return ("nada");
}
}

Vamos a conocer una manera de recorrer los elementos de una lista con
un nuevo amigo: el for. 
Imaginémonos que tenemos una lista con los precios de los productos
que compramos en el supermercado y queremos restar cada uno de
ellos a plataEnBilletera . Usando for podemos hacerlo así:

for(let precio of [10, 100, 87 ]) {

plataEnBilletera = plataEnBilletera - precio
}

donde plataEnBilletera es una variable que se va modificando a medida

que recorremos los precios.

Si teníamos $500 en nuestra billetera, después del for nos van a quedar

$303 porque:

 Al principio plataEnBilletera era 500 y el primer precio de la lista es

10. Luego de hacer 500 - 10, plataEnBilletera es 490.
 A los 490 que quedaron en nuestra billetera, le restamos el
segundo precio de la lista: 100. Ahora plataEnBilletera es 390.
 El último precio a restar es 87, por lo que, al hacer 390 - 87, la
variable plataEnBilletera terminará siendo 303.

 Completá la función saludar que recibe una lista de personas e

imprime un saludo con "hola" para cada una de ellas.
 saludar(["Don Pepito", "Don Jose"])
 hola Don Pepito
 hola Don Jose

 saludar(["Elena", "Hector", "Tita"])
 hola Elena
 hola Hector
 hola Tita

function saludar(personas) {

for(let persona of personas) {

 imprimir ("hola " + persona)

}}

PRIMEROS REGISTROS

Una historiadora está recopilando información acerca de distintos

monumentos a lo largo y ancho del mundo . En principio solo quiso saber el
nombre, ubicación, y año de construcción de cada monumento. 

Para eso almacenó cada dato en una variable:

nombreEstatuaDeLaLibertad = "Estatua de la Libertad";

locacionEstatuaDeLaLibertad = "Nueva York";
anioDeConstruccionEstatuaDeLaLibertad = "1886";
nombreCristoRedentor = "Cristo Redentor";
locacionCristoRedentor = "Rio De Janeiro";
anioDeConstruccionCristoRedentor = "1931";

Ahí es cuando se dio cuenta que no era conveniente : si bien la información

entre las variables estaba relacionada, la estaba almacenando por separado.
Entonces pensó: ¿no existirá alguna forma de representar las distintas
características o propiedades de una misma cosa de forma agrupada?

Luego de investigar un poco, encontró una mejor manera para guardar la información
de los monumentos. Probá en la consola escribiendo:

estatuaDeLaLibertad
cristoRedentor
torreEiffel
tajMahal
coliseo

Los monumentos que probaste en el ejercicio anterior están representados

como registros, y cada una de sus características (nombre, locación, año de
construcción) son campos del registro. Por cierto, ¡podemos crear registros de
cualquier cosa, con los campos que querramos!

Por ejemplo, podríamos almacenar un libro de modo que cada campo del
registro fuese alguna característica: su título, su autor, su fecha de
publicación, y más. 

¡Es tu momento del monumento! Guardá en las

variables torreAzadi y monumentoNacionalALaBandera registros de esos monumentos,
oriundos de las ciudades de Teherán, Irán y Rosario, Argentina respectivamente. ¿Te animás a
investigar en qué año se terminaron de construir para completar ese campo? 

let torreAzadi={nombre: "Torre Azadi",locacion: "Teherán, Irán",

anioDeConstruccion:1971}

let monumentoNacionalALaBandera={nombre:"Monumento Nacional a la

Bandera", locacion: "Rosario, Argentina", anioDeConstruccion: 1957}

Cuando consultaste los registros existentes, se veía algo parecido a lo

siguiente:

tajMahal
{ nombre: "Taj Mahal", locacion: "Agra, India", anioDeConstruccion: 1653 }

Esa consulta era porque estábamos viendo al registro tajMahal completo,

incluyendo todos sus campos. ¡Pero también se puede consultar por un
campo particular! Mirá :

tajMahal.locacion
"Agra, India"
tajMahal.anioDeConstruccion
1653

Declaramos los planetas mercurio, marte y saturno como registros con la siguiente

información: nombre, temperaturaPromedio y si tieneAnillos. ¡Probalos en la consola!

Ahora que agregamos registros de planetas, ¡trabajemos un poco con ellos! 

Definí una función temperaturaDePlaneta que reciba como argumento un registro de

planeta y retorne un string que indique su nombre y su temperatura promedio. ¡Tiene
que funcionar para cualquier planeta!  Por ejemplo:

temperaturaDePlaneta(mercurio)
"Mercurio tiene una temperatura promedio de 67 grados"
temperaturaDePlaneta(saturno)
"Saturno tiene una temperatura promedio de -139 grados"
temperaturaDePlaneta(venus)
"Venus tiene una temperatura promedio de 462 grados"
function temperaturaDePlaneta(planeta){

return planeta.nombre + " tiene una temperatura promedio de " +

planeta.temperaturaPromedio+" " +"grados";

Por el momento estuvimos creando y consultando registros. ¿No sería

interesante poder... modificarlos? 

La sintaxis para modificar campos de registros es muy similar a lo que

hacemos para cambiar los valores de las variables. Por ejemplo, para cambiar
la temperatura de un planeta:

saturno.temperaturaPromedio = -140;

Ahora imaginá que tenemos un registro para representar un archivo, del que
sabemos su ruta (dónde está guardado) y su fecha de creación. Si queremos
cambiar su ruta podemos hacer...

leeme
{ ruta: "C:\leeme.txt", creacion: "23/09/2004" }

moverArchivo(leeme, "C:\documentos\leeme.txt")

Luego el registro leeme tendrá modificada su ruta:

leeme { ruta: "C:\documentos\leeme.txt", creacion: "23/09/2004" }

Es tu turno! Definí el procedimiento moverArchivo, que recibe un registro y una nueva

ruta y modifica el archivo con la nueva ruta.

function moverArchivo(registro,nuevaRuta) {

registro.ruta = nuevaRuta ;

En el ejercicio anterior modificamos la ruta del registro, pero no utilizamos su

fecha de creación. ¡Usémosla! Queremos saber si un archivo es del milenio
pasado, lo que ocurre cuando su año es anterior a 2000. 
Definí la función esDelMilenioPasado, que recibe un archivo y retorna un booleano.

esDelMilenioPasado({ ruta: "D:\fotonacimiento.jpg", creacion: "14/09/1989" })

true

function esDelMilenioPasado(archivo){

return anio(archivo.creacion)<2000

Unos ejercicios atrás te contamos la diferencia entre listas y registros. ¡Pero

eso no significa que no podamos usar ambas estructuras a la vez! 

Por ejemplo, una lista puede ser el campo de un registro. Mirá estos registros
de postres, de los cuales sabemos cuántos minutos de cocción requieren y
sus ingredientes:

let flanCasero = { ingredientes: ["huevos", "leche", "azúcar", "vainilla"], tiempoDeCoccion: 50 }

let cheesecake = { ingredientes: ["queso crema", "frambuesas"], tiempoDeCoccion: 80 }
let lemonPie = { ingredientes: ["jugo de limón", "almidón de maíz", "leche", "huevos"], tiempoDeCoccion: 65
}

Definí la función masDificilDeCocinar, que recibe dos registros de postres como

argumentos y retorna el que tiene más ingredientes de los dos.

masDificilDeCocinar(flanCasero, cheesecake)
{ ingredientes: ["huevos", "leche", "azúcar", "vainilla"], tiempoDeCoccion: 50 }

function masDificilDeCocinar(postre1, postre2){

if (longitud(postre1.ingredientes)>longitud(postre2.ingredientes)){return
postre1 } else {

return postre2;

}}

En el ejercicio anterior te mostramos que un registro puede tener una lista

entre sus campos. ¿Y al revés? ¿Podemos tener una lista de registros? 

¡Sí! Así como trabajamos con listas de números, booleanos, strings o más
listas, también podemos listar registros. Se puede hacer todo lo que hacías
antes, como por ejemplo remover, saber su longitud o preguntar por el elemento
de cierta posición utilizando los corchetes [].

Probá en la consola las listas postresFavoritos y monumentosDeAmerica. Hay un postre que no

mostramos antes, ¿te das cuenta cuál es solamente leyendo sus ingredientes? 
A veces no sólo queremos comer algo rico, sino que queremos comerlo lo
antes posible.  

Definí el procedimiento agregarAPostresRapidos, que toma una lista con postres rápidos y

un postre por parámetro. Si el tiempo de cocción es de una hora o menos, se agrega el
registro a la lista.

function agregarAPostresRapidos(lista,postre)

if (postre.tiempoDeCoccion<=60)

agregar(lista,postre);

¿Te acordás cuando vimos que una lista podía estar compuesta por otras
listas? ¡Con los registros aplica la misma idea!  Si tenemos alguna estructura
de datos compleja, puede ocurrir que no alcance con representarla
únicamente mediante strings, números, booleanos y listas, sino que
necesitemos otro registro dentro.

¡No se puede vivir a base de postres! Bueno, quizás sí, pero mantengamos
una alimentación saludable . Mediante un registro queremos modelar un
menú completo: consiste en un plato principal , los vegetales de la ensalada
que acompaña , y un postre  como lo veníamos trabajando, es decir, sigue
siendo un registro.

Por ejemplo, el siguiente es un menú con bife de lomo como plato principal,
una ensalada de papa, zanahoria y arvejas como acompañamiento y un
cheesecake de postre. Como el registro es un poco extenso, y para que sea
más legible, lo vamos a escribir de la siguiente forma:

let menuDelDia = {
platoPrincipal: "bife de lomo",
ensalada: ["papa", "zanahoria", "arvejas"],
postre: { ingredientes: ["queso crema", "frambuesas"], tiempoDeCoccion: 80 }
};

Para terminar, trabajemos una vez más con los menúes.

Definí un procedimiento endulzarMenu, que recibe un registro menú y le agrega azúcar a

los ingredientes de su postre. Si ya tiene azúcar, no importa... ¡le agrega más! 

function endulzarMenu (menu){

agregar(menu.postre.ingredientes, "azucar") ;

Ana, contadora de una conocida empresa , tiene registros para representar

los balances de cada mes y una lista para guardarlos. Por ejemplo, para el
último semestre del año pasado registró los siguientes:

//En julio ganó $50, en agosto perdió $12, etc

let balancesUltimoSemestre = [
{ mes: "julio", ganancia: 50 },
{ mes: "agosto", ganancia: -12 },
{ mes: "septiembre", ganancia: 1000 },
{ mes: "octubre", ganancia: 300 },
{ mes: "noviembre", ganancia: 200 },
{ mes: "diciembre", ganancia: 0 }
];

Y nos acaba de preguntar: "¿puedo saber la ganancia de todo un semestre?"

"Obvio, solo tenemos que sumar las ganancias de todos los balances", dijimos, y
escribimos el siguiente código:

function gananciaSemestre(balances) {
return balances[0].ganancia + balances[1].ganancia +
balances[2].ganancia + balances[3].ganancia +
balances[4].ganancia + balances[5].ganancia;
}
"Gracias ", nos dijo Ana, y se fue calcular las ganancias usando la función que
le pasamos. Pero un rato más tarde, volvió contándonos que también había
registrado los balances del primer trimestre de este año:

//En enero la empresa ganó $80, en febrero, $453, en marzo $1000

let balancesPrimerTrimestre = [
{ mes: "enero", ganancia: 80 },
{ mes: "febrero", ganancia: 453 },
{ mes: "marzo", ganancia: 1000 }
];

Y nos preguntó: "¿Podría usar esta función que me dieron para calcular las
ganancias del primer trimestre?". 

¿Tiene algún problema la función gananciaSemestre que escribimos anteriormente?

¿Funcionará con los balances trimestrales? ¿Y con los cuatrimestrestrales?
¡Probala en la consola!
La función gananciaSemestre anterior tiene dos problemas :

1. Es muy repetitiva y tediosa de escribir. ¡Tenemos que hacer muchas

sumas a mano!
2. No es genérica, como bien dice su nombre, sólo sirve para sumar las
ganancias de 6 balances:

 si la lista tiene más de seis balances, sólo suma los primeros;

 si tiene menos, no funciona (¿te acordás cuando te dijimos que si te
ibas de índice cosas malas podían ocurrir? )

Lo que nos gustaría es poder sumar las ganancias de todos los balances de
una lista, sin importar cuántos haya realmente; queremos una
función gananciaTotal, que pueda sumar balances de cualquier período de
meses: semestres, cuatrimestres, trimestres, etc. ¡Qué difícil!

¡Relajá! Ya tenemos nuestra versión; probala con las siguientes consultas:

gananciaTotal([
{ mes: "enero", ganancia: 2 },
{ mes: "febrero", ganancia: 3 }
])
gananciaTotal([
{ mes: "enero", ganancia: 2 },
{ mes: "febrero", ganancia: 3 },
{ mes: "marzo", ganancia: 1 },
{ mes: "abril", ganancia: 8 },
{ mes: "mayo", ganancia: 8 },
{ mes: "junio", ganancia: -1 }
 ])
gananciaTotal([])

Después seguinos para contarte cómo la hicimos. 

Ahora que sabemos la función que necesitamos (gananciaTotal), razonemos cómo
hacerla...

Vamos de a poquito : si la lista no tuviera elementos, ¿cuánto debería ser la

sumatoria? ¡0!

function gananciaTotal0(balancesDeUnPeriodo) {
let sumatoria = 0;
return sumatoria;
}

¿Y si tuviera exactamente 1 elemento? Sería... 0.... ¿más ese elemento?

¡Exacto! 

function gananciaTotal1(balancesDeUnPeriodo) {
let sumatoria = 0;
sumatoria = sumatoria + balancesDeUnPeriodo[0].ganancia;
return sumatoria;
}

¿Y si tuviera 2 elementos? 

function gananciaTotal2(balancesDeUnPeriodo) {
let sumatoria = 0;
sumatoria = sumatoria + balancesDeUnPeriodo[0].ganancia;
sumatoria = sumatoria + balancesDeUnPeriodo[1].ganancia;
return sumatoria;
}

¿Y si tuviera 3 elementos? 

function gananciaTotal3(balancesDeUnPeriodo) {
let sumatoria = 0;
sumatoria = sumatoria + balancesDeUnPeriodo[0].ganancia;
sumatoria = sumatoria + balancesDeUnPeriodo[1].ganancia;
sumatoria = sumatoria + balancesDeUnPeriodo[2].ganancia;
return sumatoria;

¿Empezás a ver un patrón? Tratá de escribir gananciaTotal4 que funcione para 4

elementos.
function gananciaTotal4(balancesDeUnPeriodo){

let sumatoria=0

sumatoria=sumatoria + balancesDeUnPeriodo[0].ganancia;

sumatoria=sumatoria + balancesDeUnPeriodo[1].ganancia;

sumatoria=sumatoria + balancesDeUnPeriodo[2].ganancia;

sumatoria=sumatoria + balancesDeUnPeriodo[3].ganancia;

return sumatoria;

Lo que tenemos que hacer, entonces, es repetir la operación de acumular

varias veces, una por cada elemento de la lista. ¡Digamos hola  (nuevamente)
al for...of!

function gananciaTotal(balancesDeUnPeriodo) {
let sumatoria = 0;
for (let balance of balancesDeUnPeriodo) {
sumatoria = sumatoria + balance.ganancia;
}
return sumatoria;
}

Como ves, el for...of nos permite visitar y hacer algo con cada elemento de una
lista; en este caso, estaremos visitando cada balance de balancesDeUnPeriodo.

¿Aún no te convenciste? Nuevamente, probá las siguientes expresiones en la consola:

gananciaTotal([])
gananciaTotal([
{ mes: "noviembre", ganancia: 5 }
])
gananciaTotal([
{ mes: "marzo", ganancia: 8 },
{ mes: "agosto", ganancia: 10 }
])
gananciaTotal([
{ mes: "enero", ganancia: 2 },
{ mes: "febrero", ganancia: 10 },
{ mes: "marzo", ganancia: -20 }
])
gananciaTotal([
 { mes: "enero", ganancia: 2 },
{ mes: "febrero", ganancia: 10 },
{ mes: "marzo", ganancia: -20 },
{ mes: "abril", ganancia: 0 },
{ mes: "mayo", ganancia: 10 }
])

Ana tiene nuevos requirimientos! Ahora nos pidió lo siguiente: "Quiero saber

cuántos balances fueron positivos, es decir, aquellos en los que la ganancia fue
mayor a cero".

Completá la función cantidadDeBalancesPositivos. Si prestás atención, notarás que tiene una

estructura similar al problema anterior. 
function cantidadDeBalancesPositivos(balancesDeUnPeriodo) {
let cantidad = 0;
for (let balance of balancesDeUnPeriodo) {
if (balance.ganancia>0){
cantidad=cantidad+1
}
}

return cantidad;
}
Pasemos al siguiente requerimiento de Ana. Ya podemos calcular una
sumatoria de ganancias y también crear contadores, ahora vamos a calcular
promedios. 

Ana quisiera saber dado un conjunto cualquiera de balances cuál es su gananciaPromedio.

gananciaPromedio([
{ mes: "marzo", ganancia: 8 },
{ mes: "agosto", ganancia: 10 }
])
9

function gananciaPromedio(balances){
return gananciaTotal(balances)/ longitud(balances)}
Viendo que podemos hacer todo lo que nos pide, Ana quiere saber la
ganancia promedio de los balances positivos. 

Definí las funciones:

 gananciaPositiva, que es la suma de las ganancias de los balances

positivos
 promedioGananciasPositivas invocando gananciaPositiva y cantidadD
eBalancesPositivos.

function gananciaPositiva (balancesDeUnPeriodo){

let sumatoria = 0;
for (let balance of balancesDeUnPeriodo){
if (balance.ganancia >0 ) {
sumatoria = sumatoria + balance.ganancia;
}
}
return sumatoria
}
Lamentablemente no se puede usar la función promedio con nuestra lista de
registros . Lo que necesitamos es una lista que tenga solo las ganancias de
cada balance. Para ello debemos transformar, o mapear, cada elemento de la
lista.

Completá la función ganancias que toma una lista de balances y devuelve una lista que
solo posea solo las ganancias de cada uno.

ganancias([
{ mes: "enero", ganancia: 40 },
{ mes: "febrero", ganancia: 12 },
{ mes: "marzo", ganancia: 8}
])
[40, 12, 8]
function ganancias(balancesDeUnPeriodo) {
let gananciasLista = [];
for (let balance of balancesDeUnPeriodo) {
agregar (gananciasLista,balance.ganancia)
}
return gananciasLista
}
Excelente!  Ahora ya sabemos cómo transformar cada elemento de una lista
para obtener una lista nueva . De esta manera podemos usar promedio con
nuestra lista de balances. Pero, ¿se puede utilizar la función promedio solo para
los balances positivos? 

Siguiente Ejercicio: A filtrar, a filtrar cada cosa en su lugar

Explicación del ejercicio:

Hola Paula, ¿Cómo estás? No te preocupes, te voy a hacer unos comentarios

para que solucionemos esto. Si bien pudiste resolverlo, como nos comentas,
me gustaría explicarte que es lo que debemos hacer y el por qué.
El ejercicio nos dice que: necesitamos una lista que tenga solo las ganancias de
cada balance. Para ello debemos transformar, o mapear, cada elemento de la
lista.
 Es decir, ganancias nos debe devolver una lista con la ganancia de cada
balance. Esta lista, para poder retornarla, debemos definirla. Para esto,
utilizamos let nombre = [ ], dónde los corchetes nos indican que
estamos asignando a esa variable, una lista, que en este caso está y
debe estar vacía. Por otro lado, me gustaría aclararte que si bien el
nombre está correcto, sabiendo los valores que se guardarán allí, lo
ideal es que no los repitamos si se encuentran en otro lado de la
función. Esta variable, podría llamarse gananciasLista, y se diferenciaría
del nombre de la función ganancias.
  Ahora bien, a esta lista vacía debemos añadirle como dijimos, la
ganancia de cada balance de esa lista de registros, que recibiremos
como argumento, bajo el parámetro balancesDeUnPeriodo. Acá es dónde
debemos mapear esta lista, y lo hacemos con for(let variable of lista). Este
ciclo, nos permitirá recorrer cada posición de esa lista.
o Iniciará la recorrida, posicionándose en el primer lugar que es 0,
y encontrará un registro.
o Luego, lo guardará en esa variable que declaramos con let , siendo
en tu caso balance y nos permitirá ejecutar las instrucciones que
tengamos dentro de las llaves.
o Una vez ejecutadas, continuará con la segunda posición y con el
otro registro que encuentre allí, y así sucesivamente, hasta
finalizar la lista.

Entonces, sabiendo esto, y pudiendo acceder a cada registro bajo la variable

balance, sabemos que tenemos que agregar a la lista, la ganancia de cada uno.
La función agregar(lista, elemento) nos permitirá hacerlo y en reemplazo de esa
lista, irá la vacía creada previamente y en reemplazo de ese elemento,
debemos colocar el registro como hablamos previamente... Pero, para para...
¿Cómo hacemos para añadir sólo la ganancia de ese registro? Recordá que
podemos acceder al campo de un registro mediante un punto, de esta
manera: registro.campo y observando en el ejemplo, este campo será ganancia.
Por último, nos resta que la función nos retorne esta lista, que ahora está
completa con las ganancias de cada registro.
¡Espero haber sido de ayuda y haberme explicado bien! Cualquier cosa, si
todavía hay dudas, te pido que vuelvas a escribir en esta consulta, con las
correcciones que hayas hecho. Saludos

Paula Candela M. hace alrededor de 1 mes

Hola María! fuiste re clara pero js me cuesta un montón! Modifiqué el
nombre de la nueva lista, tal como me indicaste para marcar la diferencia.
Pero no entiendo que mas debería cambiar.
function ganancias(balancesDeUnPeriodo) { let gananciasListas =[]; for (let
balance of balancesDeUnPeriodo)
{ agregar(balancesDeUnPeriodo,gananciasListas) } return gananciasListas; }
Aún con este código me sigue dando como resultado que mi solución no se
puede ejecutar.
function ganancias(balancesDeUnPeriodo) {
let gananciasListas =[];
for (let balance of balancesDeUnPeriodo)
{ agregar(balancesDeUnPeriodo,gananciasListas) }

return gananciasListas; }

Lara F.  MENTORÍA  hace alrededor de 1 mes

¡Buen día, Paula! Solo quedaría por modificar los argumentos de agregar, para
esto primero repasemos que necesitamos que a la lista gananciasListas (que por
el momento está vacía) se le agregue la ganancia de cada balance, y también
recorda que la función se define como agregar(lista, elemento), es decir que el
primer argumento debe ser una lista y el segundo un elemento que es el que
queremos agregar a esa lista. Entonces:

 Con agregar(balancesDeUnPeriodo,gananciasListas) lo que estamos

expresando es que a la lista balancesDeUnPeriodo se le agregue la
lista gananciasListas, pero no es esto lo que necesitamos 🤔 En este caso,
como dijimos, queremos que a la lista gananciasListas se le agregue la
ganancia de cada balance, por lo tanto el primer argumento
de agregar debe ser la lista gananciasListas en lugar de balancesDeUnPeriodo.
 Ahora, el segundo argumento que refiere al elemento que queremos
que se agregue, en este caso lo que necesitamos es la ganancia de cada
balance, por lo tanto acá pondremos en uso la variable balance, que
recordemos que representa a cada elemento de la
lista balancesDeUnPeriodo, por ejemplo:

//si tenemos la lista

balancesDeUnPeriodo =
[
{ mes: "enero", ganancia: 40 },
{ mes: "febrero", ganancia: 12 },
{ mes: "marzo", ganancia: 8}
]

// un balance, es decir un elemento de esa lista sería

{ mes: "enero", ganancia: 40 }

// el segundo balance es el segundo elemento:

{ mes: "febrero", ganancia: 12 }
// y el tercer balance es el tercer elemento:
{ mes: "marzo", ganancia: 8}

 Entonces teniendo balance nos permite recorrer cada uno de los

elementos de la lista, y en este caso lo que necesitamos es obtener la
ganancia de cada balance por lo tanto va a ser necesario que accedamos
al campo ganancia de cada uno de los elementos, fijate que cada
elemento tiene un campo mes y otro ganancia, y es a este último al que
necesitamos acceder. Para esto recorda que la forma de acceder a un
campo es registro.campo, en este caso el registro es el balance y el campo
se llama ganancia, entonces para obtener la ganancia del balance
hacemos: balance.ganancia, ¿me explico? Y este sería el segundo
argumento en la función agregar

Ejercicio 8: Soy el mapa, soy el mapa

Lamentablemente no se puede usar la función promedio con nuestra lista de

registros . Lo que necesitamos es una lista que tenga solo las ganancias de
cada balance. Para ello debemos transformar, o mapear, cada elemento de la
lista.

Completá la función ganancias que toma una lista de balances y devuelve una lista que
solo posea solo las ganancias de cada uno.

ganancias([
{ mes: "enero", ganancia: 40 },
{ mes: "febrero", ganancia: 12 },
{ mes: "marzo", ganancia: 8}
])
[40, 12, 8]

function ganancias(balancesDeUnPeriodo) {
let gananciasLista = [];
for (let balance of balancesDeUnPeriodo) {
agregar (gananciasLista,balance.ganancia)
}
 return gananciasLista
}

Ejercicio 9: A filtrar, a filtrar cada cosa en

su lugar
Con la programación se puede hacer cualquier cosa, o casi . Ya hicimos una
función para poder saber la cantidad de balances positivos
(cantidadDeBalancesPositivos), ahora vamos a ver cómo podemos hacer para saber
cuáles son esos balances. 

Completá la función balancesPositivos que toma los balances de un período y devuelve una

lista con aquellos cuya ganancia fue mayor a cero.
 ¡Dame una pista!
balances es una lista que contiene justamente eso, balances . Pero no todos,
tienen que cumplir una condición.

function balancesPositivos(balancesDeUnPeriodo)
{let balances= [];
for (let balance of balancesDeUnPeriodo)
if (balance.ganancia > 0)
agregar (balances, balance)

return balances;
}

Ejercicio 10: Un promedio más positivo

Ahora que tenemos la función ganancias y balancesPositivos podemos utilizar la
función promedio genérica para saber cuál es el promedio de ganancia de los
balances positivos.
Definí la función gananciasDeBalancesPositivos y luego usala junto a promedio para
definir promedioDeBalancesPositivos.
 ¡Dame una pista!
Para poder tener la lista que recibe por parámetro promedio vas a tener que
definir gananciasDeBalancesPositivos. Esta función primero filtra los balances
positivos y luego los mapea a ganancias. Recordá que función hace cada una
de estas cosas. 

En la Biblioteca vas a encontrar algunas de las funciones de ejercicios

anteriores para ayudarte a resolver este ejercicio. Tené en cuenta que van a
estar tal y como vos las definiste, por lo que si tienen errores, pueden
impactar en tu solución actual. 

function gananciasDeBalancesPositivos(balancesDeUnPeriodo){
return ganancias(balancesPositivos(balancesDeUnPeriodo))
}

function promedioDeBalancesPositivos(balancesDeUnPeriodo){
return promedio(gananciasDeBalancesPositivos(balancesDeUnPeriodo));
}

Ejercicio 11: Esto es lo máximo

Vamos a conocer una nueva función, maximo, que nos permite conocer cuál es
el mayor valor en una lista de números. Por ejemplo:

maximo([5, 8, 10, 42, 87, 776])

776

Usando esta nueva función, definí la función maximaGanancia que nos diga cuál es la

ganancia más alta entre los balances de un período de tiempo.

maximaGanancia([
{ mes: "enero", ganancia: 87 },
{ mes: "febrero", ganancia: 12 },
{ mes: "marzo", ganancia: 8}
 ])
87

 ¡Dame una pista!

Podés usar la función ganancias que hiciste antes . Tené en cuenta que va a
estar tal y como vos la definiste, por lo que si tiene errores, pueden impactar
en tu solución actual. 

function maximaGanancia(balancesDeUnPeriodo)
{return maximo(ganancias(balancesDeUnPeriodo)) ;
}

Ejercicio 12: Como mínimo

Suponemos que adivinaste el nombre. En caso que no, es minimo. 

Definí la función minimaGananciaPositiva que nos diga cuál es la ganancia más baja de

todos los balances positivos.

minimaGananciaPositiva([
{ mes: "enero", ganancia: -40 },
{ mes: "febrero", ganancia: 42 },
{ mes: "marzo", ganancia: 8},
{ mes: "abril", ganancia: -5}
])
8

 ¡Dame una pista!

Para poder hacer esta nueva función probablemente te sirva
tanto minimo como gananciasDeBalancesPositivos. 

minimo se utiliza como maximo:

minimo([5, 8, 10, 42, 87, 776])

5

En la Biblioteca vas a encontrar algunas de las funciones de ejercicios

anteriores para ayudarte a resolver este ejercicio. Tené en cuenta que van a
estar tal y como vos las definiste, por lo que si tienen errores, pueden
impactar en tu solución actual. 
function minimaGananciaPositiva(balancesDeUnPeriodo){
return minimo(gananciasDeBalancesPositivos(balancesDeUnPeriodo)) ;
}

Ejercicio 13: Los mejores meses del año

¡Vamos a terminar esta lección con todo! 

Para eso vamos a hacer las siguientes funciones:

 meses, la cual dada una lista con registros devuelve una lista de meses ;
 afortunados, que filtra aquellos registros que tuvieron una ganancia
mayor a $1000 ;
 mesesAfortunados, devuelve aquellos meses que fueron afortunados.

meses([
{ mes: "enero", ganancia: 870 },
{ mes: "febrero", ganancia: 1000 },
{ mes: "marzo", ganancia: 1020 },
{ mes: "abril", ganancia: 2300 },
{ mes: "mayo", ganancia: -10 }
])
["enero", "febrero", "marzo", "abril", "mayo"]

afortunados([
{ mes: "enero", ganancia: 870 },
{ mes: "febrero", ganancia: 1000 },
{ mes: "marzo", ganancia: 1020 },
{ mes: "abril", ganancia: 2300 },
{ mes: "mayo", ganancia: -10 }
])
[ { mes: "marzo", ganancia: 1020 }, { mes: "abril", ganancia: 2300 }]

mesesAfortunados([
{ mes: "enero", ganancia: 870 },
{ mes: "febrero", ganancia: 1000 },
{ mes: "marzo", ganancia: 1020 },
 { mes: "abril", ganancia: 2300 },
{ mes: "mayo", ganancia: -10 }
])
["marzo", "abril"]

Definí las funciones meses, afortunados, mesesAfortunados.

 ¡Dame una pista!
En la función meses es necesario mapear, en afortunados filtrar y
en mesesAfortunados tenés que usar las dos anteriores. 

function meses(balancesDeUnPeriodo) {

let meses = [];

for(let balance of balancesDeUnPeriodo) {

agregar(meses, balance.mes);

return meses;

function afortunados(balancesDeUnPeriodo){

let mesesAfortunados = [];

for(let balance of balancesDeUnPeriodo) {

if (balance.ganancia >1000){agregar(mesesAfortunados,balance)}

return mesesAfortunados;

function mesesAfortunados(balancesDeUnPeriodo){

return meses(afortunados(balancesDeUnPeriodo))
}