Math.round(4.

5) // redondea
funcionMisteriosa(1, 2, 3)

function cuantoSaleAproximadamente(precio, impuestos) {

return Math.round(precio * impuestos);
}

Math.max(4,7)
Math.min(4,7)

function extraer(saldo, monto) {

return Math.max(saldo- monto, 0);
}

function estaEntre(num1,num2,num3){
return num1>num2 && num1<num3;
}
function estaFueraDeRango(num1,num2,num3){
return num1<num2 || num1>num3;
}

function estaAfinado (numero){

return numero===440;
}

function estaCerca (numero){

return numero<=443 && numero>=437 && numero!==440;
}

function escribirCartelito(nombre, apellido, titulo){

return nombre + " " + apellido + " " +titulo ;
}

function escribirCartelito(titulo, nombre, apellido, booleano){

if (booleano){
return titulo + " " +apellido;
}
else
{
return titulo + " " + nombre + " " +apellido;
}
}

function escribirCartelitoOptimo (titulo, nombre, apellido){

return escribirCartelito(titulo, nombre, apellido, longitud(nombre +
apellido)>15) ;
}

function decisionConMoneda(moneda, pizzas, empanadas){

if(moneda==="cara"){
return pizzas;
}else{
return empanadas;
 }
}

function valorEnvido(nroCarta){
if(nroCarta>=1 && nroCarta<=7){
return nroCarta;
}else{
if(nroCarta>=10 && nroCarta<=12){
return nroCarta===0;

}
}
}

function puntosDeEnvidoTotales(nroCarta, palo, nroCarta2,palo2){

if (palo===palo2){
return valorEnvido(nroCarta)+ valorEnvido(nroCarta2)+20;
}else{
return Math.max(valorEnvido(nroCarta),valorEnvido(nroCarta2))

}
}

function valorCantoTruco(canto){
if (canto==="truco"){
return 2;
}else{
if(canto==="retruco"){
return 3;
}else{
if(canto==="vale cuatro"){
return 4;
}
}
}
}

function funcionEgocentrica() {
imprimir("soy una función que imprime por pantalla");
imprimir("y estoy por devolver el valor 5");
return 5;
}

function versosMartinFierro(){
imprimir("Aquí me pongo a cantar")
imprimir("Al compás de la vigüela;")
imprimir("Que el hombre que lo desvela")
imprimir("Una pena extraordinaria")
return 0;
}

function versosMartinFierro() {
imprimir("Aquí me pongo a cantar");
imprimir("Al compás de la vigüela;");
 imprimir("Que el hombre que lo desvela");
imprimir("Una pena extraordinaria");
}

//afuera de la funcion//
imprimir("Tirando dados");
imprimir("La primera tirada dio " + tirarDado());
imprimir("La segunda tirada dio " + tirarDado());
imprimir("La tercera tirada dio " + tirarDado());

function elefantesEquilibristas(nro){
return nro + " elefantes se balanceaban";
}

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

//...estamos asignándole el valor "enero" a la variable primerMes.

En criollo, estamos dándole ese valor a la variable.
let pi = 3.14159265358979;

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

let cargaMaximaEnKilogramos = 300;

function ascensorSobrecargado(cantpersonas){
return cantpersonas*pesoPromedioPersonaEnKilogramos>cargaMaximaEnKilogramos;

function aumentarFortuna (){

pesosEnMiBilletera=pesosEnMiBilletera*2;

x += y; //equivalente a x = x + y;
x *= y; //equivalente a x = x * y;
x -= y; //equivalente a x = x - y;
x++; //equivalente a x = x + 1;
//inicialmente la variable numero vale 8
al hacer numero *= 2 la variable pasa a tener su valor multiplicado por 2,
es decir, 16;
al hacer numero += 4 le sumamos 4 a 16 y lo guardamos en número, por ende
la función cuentaExtravagante retorna 20

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

let mochilaAbierta = true;

function usarCierre(){
mochilaAbierta = !mochilaAbierta;
}

function esMayorDeEdad(edad){
return edad>=18;
}
function esMenorDeEdad(edad){
return !esMayorDeEdad(edad);
}

function esPeripatetico(profesión , nacionalidad, cantkmpordia){

return profesión === "filósofo" && nacionalidad === "griego" && cantkmpordia>2;
}

function estaCerrado(esFeriado, dia, horario) {

return esFeriado || esFinDeSemana(dia) || !dentroDeHorarioBancario(horario); }

function esFinDeSemana (dia)

{
return dia==="sabado" || dia==="domingo";
}

function tieneContraste (colorLetra, colorFondo){

return esTonoClaro(colorLetra) && !esTonoClaro(colorFondo) || !
esTonoClaro(colorLetra) && esTonoClaro(colorFondo);
}

function xor (a, b){

return a===!b || !a===b;

}

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

//mi version no se porque no funciona ej 11 sin precedentes

function sePuedeConcentrar(bebida,temperatura, estaProgramando){
return (((bebida==="te" && temperatura>=95) || (bebida ==="mate" &&
temperatura===80)) && estaProgramando) ;
}

otra version
function sePuedeConcentrar(bebida,temperatura, estáProgramando){
return (((bebida==="té" && temperatura>=95) || (bebida ==="mate" &&
temperatura===80)) && estáProgramando) ;
}

¿Y si delegamos? Podríamos separar la lógica de la siguiente manera:

function sePuedeConcentrar(infusion, temperatura, estaProgramando) {

return infusionATemperaturaCorrecta(infusion, temperatura) && estaProgramando;
}

function puedeSubirse (altura, acompañada, afeccionC){

return (altura>=1.5 && !acompañada&& !afeccionC)||
(altura >= 1.2 && acompañada && !afeccionC);
}

Como ves, para representar a un conjunto de strings, colocamos todos esos strings
que nos interesan, entre corchetes ([ y ]) separados por comas.

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

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

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

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

let tiradasDelDado = [1, 6, 6, 2, 2, 4];
let salioCara = [false, false, true, false];
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 = []

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

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

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.

pertenencias
=> ["espada","escudo","antorcha"]
> agregar(pertenencias, "ballesta")
=> undefined
> pertenencias
=> ["espada","escudo","antorcha","ballesta"]
> remover(pertenencias, "ballesta")
=> undefined
> pertenencias
=> ["espada","escudo","antorcha"]
>

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]

¿Tenés dudas sobre cómo quitar y agregar elementos? Repasemos agregar y remover:

agregar(lista, elemento): agrega elemento al final de lista.

remover(lista, elemento): saca elemento de lista.

function trasladar (lista1, lista2, elementoL1){

remover(lista1, elementoL1);
agregar (lista2, elementoL1);
}

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

function contiene(lista, n){

return ((posicion(lista , n) >=0) )
}

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"

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

function medallaSegunPuesto(puesto){
if (puesto>=1 && puesto<=3)
{
return medalla[puesto-1]; //es la posicion de las medallas ( 0 ,1 , 2, ...)
}
else
{
return "nada";
}
}

OOOOOO

function medallaSegunPuesto(puesto){
if (puesto>=1 && puesto<=3){
return ["oro", "plata", "bronce"][puesto-1];//loque esta al lado es la posicion

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

function saludar(personas) {
for(let persona of personas) {
imprimir ("hola" + " " + persona)
}
}

registros///////
nombreEstatuaDeLaLibertad = "Estatua de la Libertad";
locacionEstatuaDeLaLibertad = "Nueva York";
anioDeConstruccionEstatuaDeLaLibertad = "1886";
nombreCristoRedentor = "Cristo Redentor";
locacionCristoRedentor = "Rio De Janeiro";
anioDeConstruccionCristoRedentor = "1931";

en consola::
estatuaDeLaLibertad
cristoRedentor
torreEiffel
tajMahal
coliseo

estatuaDeLaLibertad
=> {nombre:"Estatua de la Libertad",locacion:"Nueva York, Estados Unidos de
América",anioDeConstruccion:1886}
> cristoRedentor
=> {nombre:"Cristo Redentor",locacion:"Rio de Janeiro,
Brasil",anioDeConstruccion:1931}

/*let nombre = "torreAzadi"

let locacion = "Teheran de Iran"
let letaniodeconstruccion = "1971"*/

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

anioDeConstruccion: 1971}

/*let nombre ="monumentoNacionalALaBandera"

let locacion = "Rosario, Argentina"
let aniodeconstruccion= "1957"*/

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

function temperaturaDePlaneta (planeta){

return planeta.nombre +" "+"tiene una temperatura promedio de" + " " +
planeta.temperaturaPromedio + " " + "grados";

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, Nruta){

registro.ruta = Nruta
}

Un registro, nos permite agrupar las características y/o propiedades de un objeto

o cosa.
Por ejemplo:
let auto ={marca: "Toyota”, modelo: "Yaris"}

El registro se llama auto; marca y modelo, son sus campos (que representan su
característica.
Como sería un registro que represente un pais?
let pais={idioma: “castellano”, nombre: “Argentina”, superficie: 2700000}

Y si queremos hacer referencia a los campos de un registro, escribimos:

pais.idioma = castellano
auto.modelo = Yaris

Y si queremos cambiar el valor de un campo de un registro:

let pais.superficie = 3000000

Por último, también podemos definir una lista de registros, donde cada elemento de
la lista es un registro.

Por ejemplo:
let listaAutos = [{marca: "Toyota”, modelo: "Yaris"},
{marca:”Ford”,modelo:”Focus”}]
Esta lista tiene dos elementos, cada uno formado por un registro.

function esDelMilenioPasado(archivo){
return anio(archivo.creacion) <2000
}

Quizá te pueda servir la función anio:

> anio("04/11/1993")
1993

La idea de la función esDelMilenioPasado es que reciba un archivo y devuelva un

booleano.
Es decir que la idea es que la declaración de la función tendría que tener la
siguiente forma:

function esDelMilenioPasado(archivo)
{
//acá va el código
}
Ahora veamos de qué se trata un archivo.
El archivo es en realidad un registro que representa un archivo. Tiene dos campos:
ruta (que contiene un string con la ubicación del archivo) y creacion (que contiene
un string con la fecha de alta del archivo).

Un ejemplo de un registro archivo es:

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

Supongamos que ese registro se encuentra referenciado por la variable archivo. Y si
escribís, archivo.creacion vas a obtener "14/09/1989".

Ahora bien, por otro lado tenemos una función anio que recibe un string
representando una fecha y devuelve la parte correspondiente al año.
Es decir, que si hacés: anio("14/09/1989") te devuelve 1989.
Es decir, que de acuerdo al ejemplo anterior, si pusieras anio(archivo.creacion) te
devolvería 1989

Que tendríamos que hacer entonces, en este ejercicio?

Tendríamos que comparar con 2000 el anio de archivo.creacion y en base al
resultado de esa comparación responder si el archivo es del milenio anterior o no.

Tendríamos que tener algo así:

function esDelMilenioPasado(archivo)
{
return //anio de archivo.creacion es menor a 2000//
}
Lo que está a la derecha del return lo puse entre // para indicar que es
pseudocódigo. Vos tendrías que escribir esa condición en lenguaje javascript.
/////

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: ["frambuesas", "queso crema"], 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 }
¡Dame una pista!
¡Recordá que podés usar la función longitud! Y si los dos postres tienen la misma
cantidad de ingredientes, podés devolver cualquiera de los dos

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?

Consola
Biblioteca
> postresFavoritos
=> [{ingredientes:["galletitas","dulce de leche","crema"],tiempoDeCoccion:20},
{ingredientes:["huevos","leche","azúcar","vainilla"],tiempoDeCoccion:50},
{ingredientes:["queso crema","frambuesas"],tiempoDeCoccion:80},{ingredientes:["jugo
de limón","almidón de maíz","leche","huevos"],tiempoDeCoccion:65}]
> monumentosDeAmerica
=> [{nombre:"Monumento Nacional a la Bandera",locacion:"Rosario,
Argentina",anioDeConstruccion:1957},{nombre:"Estatua de la
Libertad",locacion:"Nueva York, Estados Unidos de
América",anioDeConstruccion:1886},{nombre:"Cristo Redentor",locacion:"Rio de
Janeiro, Brasil",anioDeConstruccion:1931}]

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

¡Recordá que tiempoDeCoccion está expresado en minutos! Por lo tanto, si queremos

que se cocine en una hora o menos, tenés que fijarte que ese tiempoDeCoccion sea
menor a 60 minutos.

Además, como agregarAPostresRapidos es un procedimiento, no t iene que retornar

nada. Sólo tenés que agregar (¿te acordás de este procedimiento?) el postre a la
lista si es rápido.

function agregarAPostresRapidos(postresrapidos, postres){

if (postres.tiempoDeCoccion <= 60){
agregar(postresrapidos, postres)
}
}

/////

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 }
};
Averiguá qué devuelve el campo ingredientes del campo postre del registro
menuInfantil. ¡Está un registro adentro del otro! La sintaxis es la siguiente:

menuInfantil.postre.ingredientes

menuInfantil.postre.ingredientes
=> ["galletitas","dulce de leche","crema"]
>

//////

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!

Recordá que cada menú tiene un postre y que cada postre tiene ingredientes

function endulzarMenu (menu){

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

77777

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 }
];

La función gananciaSemestre anterior tiene dos problemas :

Es muy repetitiva y tediosa de escribir. ¡Tenemos que hacer muchas sumas a mano!
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([])

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.

////

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.

Lo importante en este ejercicio es pensar cuál es el valor inicial de cantidad

y cuándo incrementa ese valor.

function cantidadDeBalancesPositivos(balancesDeUnPeriodo) {
let cantidad = 0;
for (let balance of balancesDeUnPeriodo) {
if(balance.ganancia >0)
cantidad = cantidad + 1
 }
return cantidad;
}

cantidad es lo que en programación se conoce como contador, una variable que

se incrementa cada vez que hacemos algo dentro de un for...of o solo aquellas
veces que se cumpla una condición (como en este caso ).

////

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 (balancesDeUnPeriodo){

return gananciaTotal(balancesDeUnPeriodo)/longitud(balancesDeUnPeriodo)
}

En primer lugar, tené en cuenta que la función gananciaPromedio recibe por

parámetro los balances de un período (que no son más que una lista de registros
donde cada registro se corresponde con un balance). Entonces, lo más apropiado
sería que renombres el parámetro de tu función como, por ejemplo,
balancesDeUnPeriodo

Bien, dicha función tiene que retornar la ganancia promedio de los balances.

¿Cómo se calcula ese promedio?

Bueno, tenes que dividir las ganancias totales sobre la cantidad de balances.

¿Cómo podes obtener las ganancias totales?

Utilizando la función gananciaTotal que recibe por parámetro los balances
de un período y retorna las ganancias totales.

¿Cómo podes obtener la cantidad de balances de un período?

Bueno, recordá que balancesDeUnPeriodo es una lista, con lo cual podes
utilizarlongitud(balancesDeUnPeriodo) que va a retornar la cantidad de balances.

Por último, tu función gananciaPromedio tiene que retornar la división de

los retornos de gananciaTotal(balancesDeUnPeriodo) y longitud(balancesDeUnPeriodo)

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!
gananciaPositiva es muy similar a cantidadDeBalancesPositivos, solo que ahora
necesitas una sumatoria en vez de un contador.

En la Biblioteca vas a encontrar cantidadDeBalancesPositivos para ayudarte a

resolver este ejercicio. 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 gananciaPositiva (balances){

let sumatoria=0;
for (let balance of balances)
if (balance.ganancia > 0){
sumatoria =sumatoria + balance.ganancia;
}
return sumatoria;
}
function promedioGananciasPositivas(balances){
return gananciaPositiva (balances)/cantidadDeBalancesPositivos(balances)}

Como podés ver todos los promedios se basan en el mismo principio . Sumar una
cantidad determinada elementos y dividir el resultado por esa cantidad. Si
quisiéramos realizar una función promedio genérica sería algo así:

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

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

Te acordás de las listas? Bueno, en estos ejercicios estás trabajando con listas
más complejas porque son registros, es decir, cada elemento de la lista tiene 2
partes, una parte es el mes y la otra parte es la ganancia. Hagamos un repasito de
cómo se trabaja una lista. Las palabras clave son lista que es la variable que
contiene varios elementos. Elemento que es cada una de las palabras agrupadas en la
lista. Indice que es la posición de cada elemento dentro de la lista. Veamos un
ejemplo:

Podemos pensar una lista de compras:

let listaDeCompras = ["mate", "cafe", "harina", "palmitos", "yerba", "mermelada"]

Cada elemento de la lista tiene una posición dentro de la lista, comenzando desde
cero. A saber:
0. "mate",
1. "cafe",
2. "harina",
3. "palmitos",
4. "yerba",
5. "mermelada"

Si quisiera acceder al elemento "palmitos", sabiendo que su índice en la lista

listaDeCompras es 3, lo hago de la siguiente manera:

listaDeCompras[3]
que es equivalente a "palmitos".

Si quisiera acceder al elemento "cafe":

listaDeCompras[1]
que es equivalente a "cafe".

y así...

Ahora bien, tratádose de registros, ahora las listas en lugar de tener un elemento
simple por índice, tiene un elemento con 2 cualidades:
Imaginate que al producto se le agrega la marca, entonces quedaría así:

let listaDeCompras = [
{nombre: "mate" , marca: "marolio"},
{nombre: "cafe", marca: "marolio"}
{nombre:"harina", marca: "marolio"},
{nombre: "palmitos", marca: "marolio"},
{nombre: "yerba", marca: "marolio"},
{nombre:"mermelada", marca: "marolio"}
]
Entonces si querés averiguar la marca del 3er elemento del registro, sería de la
siguiente manera:

listaDeCompras[2].marca
//te devuelve "marolio"

y así con cada uno

Ahora bien, el recorrido for lo que hace es evitar tener que usar el índice
[numero], sino que recorre elemento por elemento, y a cada elemento vos le
pones un nombre, en el caso de este ejercicio vos lo llamaste balances, en el
caso de este ejemplo que te di de compras quizas seria apropiado productos.
Por cada elemento, el recorrido se encarga de hacer una operación. Entonces,
dentro del recorrido, tenés que operar sobre balances, no sobre
BalancesDeUnPeriodo,
porque en mi ejemplo, sería como operar sobre listaDeCompras en lugar de sobre
productos.
Después, cuando agregas los elementos que cumplen, tenés que agregar balances,
no el registro balancesDeUnPeriodo, y lo tenés que agregar a la lista ganancias,
no a la lista nuevaLista porque no está definida. Revisá esas cuestiones y volvé
a intentar.

//////

ganancias tiene que ser una lista que va a almacenar solo las ganancias
de los balances es decir que tenés que inicializarla de esta manera

let ganancias = [];

Por otro lado, para asignarle los valores de las ganancias la función agregar se
encarga de ello. Por ejemplo tenemos la lista
fruta=["manzana","banana"], para agregarle el elemento "durazno" hay que hacer

agregar(fruta, "durazno")
fruta=agregar("durazno", fruta) No es correcto

Por último, revisa que cada balance de la lista balancesDeUnPeriodo es

representado por balance en el bucle

for (let balance of balancesDeUnPeriodo)

o sea que por ejemplo balancesDeUnPeriodo es [{ mes: "enero", ganancia: 40 },
{ mes: "febrero", ganancia: 12 }, { mes: "marzo", ganancia: 8} y balance puede
ser { mes: "enero", ganancia: 40 } en el primer ciclo, en el segundo
{ mes: "febrero", ganancia: 12 } y así sucesivamente

para acceder a las ganancias de cada balance se usa la notación por punto:
balance.ganancia, entonces cada elemento que tenes que agregarle a la lista
ganancias es balance.ganancia, por lo que tenés que usar la función así:
agregar(ganancias,balance.ganancia

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 ganancias = [];
for (let balance of balancesDeUnPeriodo) {
agregar(ganancias,balance.ganancia)
}
return ganancias;
}

Por último, revisa que cada balance de la lista balancesDeUnPeriodo es

representado por balance
en el bucle

for (let balance of balancesDeUnPeriodo)

o sea que por ejemplo balancesDeUnPeriodo es
[{ mes: "enero", ganancia: 40 }, { mes: "febrero", ganancia: 12 },
{ mes: "marzo", ganancia: 8} y balance puede ser { mes: "enero", ganancia: 40 }
en el primer ciclo, en el segundo { mes: "febrero", ganancia: 12 }
y así sucesivamente

para acceder a las ganancias de cada balance se usa la notación por punto:
balance.ganancia, entonces cada elemento que tenes que agregarle a la lista
ganancias es
balance.ganancia, por lo que tenés que usar la función así:
agregar(ganancias,balance.ganancia

//////

Un detalle sobre lo que realizamos dentro del for:

for(let balance of balancesDeUnPeriodo)
Definimos la variable balance para recorrer cada elemento de balancesDeUnPeriodo.
Recordemos que
balancesDeUnPeriodo tiene esta forma:
[{ mes: "marzo", ganancia: 8 }, { mes: "agosto", ganancia: 10 }]
Por lo que si hacemos ---> balancesDeUnPeriodo.ganancia no estamos accediendo a la
ganancia del elemento,
sino que estamos aplicando .ganancia
a la lista de todos los balances.
Definimos en el for ---> let balance para representar a cada elemento del
registro.
En cada iteracion del for, balance va a tomar como valor cada elemento de la lista
que contiene los balances.
En la primera iteracion, balance toma como valor ---> { mes: "marzo", ganancia:
8 }.
En la segunda ---> { mes: "agosto", ganancia: 10 }... esto sucederá hasta que
termine de recorrer todos los
elementos.
.
Luego, en esta parte --> if(balancesDeUnPeriodo.ganancia > 0)vamos a utilizar
balance. Usamos ganancia para
acceder al campo ganancia de balance.
En esta parte ---> agregar(balance, balancesDeUnPeriodo.ganancias) queremos guardar
en la lista balances
aquel balance que es positivo. No guardaremos solamente su ganancia sino el
balance completo.
Pero, balancesDeUnPeriodo no es el balance, sino la lista de balances. Usaremos
balance

balances es una lista vacia que definimos en esta linea ---> let balances = [];
Esta es la lista que queremos retornar al final de nuestro ejercicio
.
El objetivo del ejercicio es retornar una lista de aquellos balances que son
positivos
.
balancesDeUnPeriodo es una lista de registros
Los registros los vimos en la leccion 6.Registros ---> 2. Programación
Imperativa/6. Registros/3. Accediendo al campo
.
Podemos tener una lista de cualquier valor, por ejemplo lista de numeros --->
[1,2,3,4]
Lista de strings ---> ["hola", "manzana", "pera"]
Lista de registros ---> [ { mes: "enero", ganancia: 40 }, { mes: "febrero",
ganancia: 12 }, { mes: "marzo", ganancia: 8} ]
Cada registro es lo que tenemos entre llaves ---> { mes: "marzo", ganancia: 8}
.
Ahora bien, en los ejercicios de esta Leccion, estamos trabajando con balances. Un
balance equivale a un registro: { mes: "marzo", ganancia: 8}. El balance lo compone
su mes y su ganancia.
.
Los balances de un periodo equivale a la lista de registros (lista de balances) ---
> [ { mes: "enero", ganancia: 40 }, { mes: "febrero", ganancia: 12 }, { mes:
"marzo", ganancia: 8} ]
.
Lo que hacemos cuando definimos el for es recorrer todos los elementos de nuestra
lista de registros --> for (let balance of balancesDeUnPeriodo)
En el ejercicio 2. Programación Imperativa/7. Recorridos/4. Nos visita un viejo
amigo vemos que utilizamos el for para poder "visitar" cada elemento de nuestra
lista de registros. De esta manera por cada elemento podemos realizar una accion.
En let balance definimos como vamos a llamar a cada elemento de esta lista de
registros.
En este caso se llama balance.
.
Recordemos el objetivo del ejercicio. Si la ganancia del balance es positiva, vamos
a guardar el balance en la lista que definimos al principio. ¿Como sabemos si la
ganancia es positiva? Accedemos al campo del balance y preguntamos si es mayor a
0. Esto lo hacemos en un if. En tu solucion:
if(balancesDeUnPeriodo.ganancia > 0)
Recordemos que balancesDeUnPeriodo tiene esta forma ---> [ { mes: "enero",
ganancia: 40 }, { mes: "febrero", ganancia: 12 }, { mes: "marzo", ganancia: 8} ]
.
Estamos haciendo ---> [ { mes: "enero", ganancia: 40 }, { mes: "febrero",
ganancia: 12 }, { mes: "marzo", ganancia: 8} ] . ganancia
.
No podemos acceder a la ganancia de la lista de balances. Tenemos que tomar de a un
elemento. Para ello usamos balance
Podemos acceder al campo ganancia de balance. Recordemos que balance tiene esta
forma ---> { mes: "marzo", ganancia: 8}
.
Ahora bien, si la ganancia del balance es positiva. Queremos guardar este balance
en nuestra lista.
La lista se llama balances
La funcion que utilizamos para agregar un elemento a la lista es agregar --->
https://seprogramar.inti.gob.ar/inti/chapters/2-programacion-imperativa/
appendix#agregarunalista-unelemento
El primer parametro que recibe la funcion agregar es una lista. En nuestro caso
esta lista es balances. El segundo parametro es el elemento que queremos agregar a
la lista, en nuestro caso es el balance. En tu solucion:
agregar(balance, balancesDeUnPeriodo.ganancia)
.
Agregas balancesDeUnPeriodo.ganancia a balance (tiene que ser balances para
referirse a la lista).
.
Recordemos que la forma que tiene balancesDeUnPeriodo es ---> [ { mes: "enero",
ganancia: 40 }, { mes: "febrero", ganancia: 12 }, { mes: "marzo", ganancia: 8} ]
No queremos guardar esta lista entera. Queremos quedarnos solamente con aquellos
balances cuya ganancia es positiva.
Sabemos cual balance es positivo por el if. Luego, vamos a agregar a nuestra lista
el balance
.
Para encarar estos ejercicios es bueno identificar cada elemento que nos pide usar
el ejercicio. Sabemos que siempre vamos a partir con una lista de registros que
tendrá esta forma ---> [ { mes: "enero", ganancia: 40 }, { mes: "febrero",
ganancia: 12 }, { mes: "marzo", ganancia: 8} ]
A partir de esta lista, vamos a querer extraer informacion de ella.

/////

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

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

if (balancesDeUnPeriodo.ganancias>0) { <--- tenemos que preguntar si la ganancia

de un balance es positivo
agregar (balances,balancesDeUnPeriodo.ganancias); <--- vamos a guardar ese
balance en nuestra lista balances
}
.
Un detalle sobre lo que realizamos dentro del for:
for(let balance of balancesDeUnPeriodo)
Definimos la variable balance para recorrer cada elemento de balancesDeUnPeriodo.
Recordemos que balancesDeUnPeriodo tiene esta forma:
[{ mes: "marzo", ganancia: 8 }, { mes: "agosto", ganancia: 10 }]
Por lo que si hacemos ---> balancesDeUnPeriodo.ganancia no estamos accediendo a la
ganancia del elemento, sino que estamos aplicando .ganancia
a la lista de todos los balances.
Definimos en el for ---> let balance para representar a cada elemento.
En cada iteracion del for, balance va a tomar como valor cada elemento de la lista
que contiene los balances. En la primera iteracion, balance toma como valor --->
{ mes: "marzo", ganancia: 8 }. En la segunda ---> { mes: "agosto", ganancia:
10 }... esto sucederá hasta que termine de recorrer todos los elementos.
.
Luego, vamos a utilizar balance.
Para acceder a la ganancia, usamos ---> ganancia, sin la s
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í.

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

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

function temperaturaDePlaneta (planeta){

return planeta.nombre +" "+"tiene una temperatura promedio de" + " " +
planeta.temperaturaPromedio + " " + "grados";
 }

function moverArchivo (registro, Nruta){

registro.ruta = Nruta
}

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: ["frambuesas", "queso crema"], 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
}
}

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(postresrapidos, postres){

if (postres.tiempoDeCoccion <= 60){
agregar(postresrapidos, postres)
}
}

Además, como agregarAPostresRapidos es un procedimiento, no t iene que retornar

nada. Sólo tenés que agregar (¿te acordás de este procedimiento?) el postre a la
lista si es rápido.

¿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 }
};
Averiguá qué devuelve el campo ingredientes del campo postre del registro
menuInfantil. ¡Está un registro adentro del otro! La sintaxis es la siguiente:

menuInfantil.postre.ingredientes

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

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.

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

Como podés ver todos los promedios se basan en el mismo principio . Sumar una
cantidad determinada elementos y dividir el resultado por esa cantidad. Si
quisiéramos realizar una función promedio genérica sería algo así:

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

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

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 ganancias = [];
for (let balance of balancesDeUnPeriodo) {
agregar(ganancias,balance.ganancia)
 }
return ganancias;
}

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.

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

Muy bien! Ahora ya sabemos cómo filtrar una lista. En criollo, aprendimos a obtener
los elementos de una lista que cumplen una condición determinada. En este caso
obtuvimos una nueva lista con los balances que presentaban una ganancia positiva

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){
 let ganancias=[];
for
(let balance of balancesPositivos(balancesDeUnPeriodo)){
agregar(ganancias,balance.ganancia );
}
return ganancias;
}
function promedioDeBalancesPositivos(balancesDeUnPeriodo){
return promedio(gananciasDeBalancesPositivos(balancesDeUnPeriodo));
}

mi function : xdddd
function gananciasDeBalancesPositivos (balancesDeUnPeriodo){
let ganancias = []
for (let balance of balancesPositivos(balancesDeUnPeriodo)){
agregar(ganancias, balance.ganancia)
}
return ganancias;
}
function promedioDeBalancesPositivos (balancesDeUnPeriodo){
return promedio(gananciasDeBalancesPositivos(balancesDeUnPeriodo))

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

function maximaGanancia (balanceDeUnPeriodo){

return maximo(ganancias(balanceDeUnPeriodo)) ;
}

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

function minimaGananciaPositiva (balancesDeUnPeriodo){

return minimo(gananciasDeBalancesPositivos (balancesDeUnPeriodo))
}

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

function meses(mes){
let meses = []
for (let estemes of mes){
agregar(meses, estemes.mes)
 }
return meses;
}

function afortunados(mes){
let ganancias = []
for (let mesAfortunado of mes ){
if(mesAfortunado.ganancia > 1000){
agregar(ganancias, mesAfortunado)
}
}
return ganancias;
}

function mesesAfortunados(mes){
let mesesAfortunados = [];
for (let mesConSuerte of meses(afortunados(mes))){
agregar(mesesAfortunados, mesConSuerte)
}
return mesesAfortunados;
}

////OTRA VERSION

function meses(regMeses){
let meses=[];
for(let estemes of regMeses){
agregar(meses,estemes.mes);
}
return meses;
}
function afortunados(regMeses){
let afortunados=[];
for (let mesrico of regMeses){
if (mesrico.ganancia>1000){
agregar(afortunados,mesrico);
}
}
return afortunados;
}
function mesesAfortunados(regMeses){
let mesesAfortunados=[];
for (let supermes of meses(afortunados(regMeses))){
agregar(mesesAfortunados,supermes);
}
return mesesAfortunados;
}
function ganancias(balancesDeUnPeriodo) {
let ganancias = [];
for (let balance of balancesDeUnPeriodo) {
agregar(ganancias,balance.ganancia)
}
return ganancias;
}

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

function gananciasDeBalancesPositivos (balancesDeUnPeriodo){

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

function minimo(numeros) /* ... */

// Retorna el menor valor dentro de una lista de números:
//
// > minimo([5, 7, 8, 9, 3])
// => 3

function agregar(unaLista, unElemento) /* ... */

// Inserta unElemento al final de unaLista.
// Este es un procedimiento que no retorna nada pero modifica a unaLista:
//
// > let cancionesFavoritas = ["La colina de la vida", "Zamba por vos"]
// > agregar(cancionesFavoritas, "Seminare")
// > cancionesFavoritas
// ["La colina de la vida", "Zamba por vos", "Seminare"]
function cuantoCuesta(pulgada, memoria){
return pulgada*60 + memoria*200 + 1000;

function meConviene(pulgadas, memoria){

return cuantoCuesta(pulgadas, memoria) < 6000 && pulgadas>=32 && memoria>=8;
}function perimetroTriangulo(lado1,lado2,lado3){
return lado1+lado2+lado3;
}
function areaTriangulo(base, altura){
return (base*altura)/2;
}

function perimetroCuadrado(lado){
return lado*4;
}
function areaCuadrado (lado){
return lado*lado;
}

function longitud(unString) /* ... */

// Retorna cuan largo es un string
//
// Por ejemplo:
//
// > longitud("hola")
// 4

function convertirEnMayuscula(unString) /* ... */

// Convierte una palabra en mayúsculas
//
// Por ejemplo:
//
// > convertirEnMayuscula("hola")
// "HOLA"

function comienzaCon(unString, otroString) /* ... */

// Retorna un booleano que nos dice si unString empieza con otroString
//
// Por ejemplo:
//
// > comienzaCon("hola todo el mundo", "hola todo")
// true

function gritar(grito){
return "¡" + convertirEnMayuscula(grito) + "!";
}

function signo(num){
if (num>0){
return 1;
}else
if(num===0){
return 0;
}
 else{
return -1;
}

function esNumeroDeLaSuerte(num){
return num>0 && num<100 && num!==15;
}

function medallaSegunPuesto(medalla){
if (medalla===1){
return "oro";
}else
if (medalla===2){
return "plata";
}else
if(medalla===3){
return "bronce";
}
else
return "nada";
}

function longitud(unString) /* ... */

// Retorna cuan largo es un string
//
// Por ejemplo:
//
// > longitud("hola")
// 4

function convertirEnMayuscula(unString) /* ... */

// Convierte una palabra en mayúsculas
//
// Por ejemplo:
//
// > convertirEnMayuscula("hola")
// "HOLA"

function comienzaCon(unString, otroString) /* ... */

// Retorna un booleano que nos dice si unString empieza con otroString
//
// Por ejemplo:
//
// > comienzaCon("hola todo el mundo", "hola todo")
// true

/**/

/**/

function imprimir(unString) /* ... */

// Imprime por pantalla unString
//
// Por ejemplo:
//
// > imprimir("¡estoy imprimiendo!")
// ¡estoy imprimiendo!

function tirarDado() /* ... */

// Retorna un número al azar entre 1 y 6
//
// Por ejemplo:
//
// > tirarDado()
// 5
// > tirarDado()
// 1
// > tirarDado()
// 2

/**/

function listasIguales(unArray, otroArray) /* ... */

// Retorna un booleano que nos dice si dos listas son iguales
//
// Por ejemplo:
//
// > listasIguales([1, 2, 3], [1, 2, 3])
// true
// > listasIguales([1, 2, 3], [4, 5, 3])
// false

function longitud(unStringOLista) /* ... */

// Retorna el largo de un string o una lista
//
// Por ejemplo:
//
// > longitud("hola")
// 4
// > longitud([5, 6, 3])
// 3

function agregar(unaLista, unElemento) /* ... */

// Inserta unElemento al final de unaLista.
// Este es un procedimiento que no retorna nada pero modifica a unaLista:
//
// > let cancionesFavoritas = ["La colina de la vida", "Zamba por vos"]
// > agregar(cancionesFavoritas, "Seminare")
// > cancionesFavoritas
// ["La colina de la vida", "Zamba por vos", "Seminare"]

function remover(unaLista, unElemento) /* ... */

// Quita unElemento de unaLista. En caso de que no esté, no hace nada.
// Este es un procedimiento que no retorna nada pero modifica a unaLista:
//
// > let listaDeCompras = ["leche", "pan", "arroz", "aceite", "yerba"]
// > remover(listaDeCompras, "pan")
// > listaDeCompras
// ["leche", "arroz", "aceite", "yerba"]

function posicion(unaLista, unElemento) /* ... */

// Retorna la posición en que se encuentra unElemento en unaLista.
// Si el elemento no está en la lista, retorna -1
//
// > let premios = ["dani", "agus", "juli", "fran"]
// > posicion(premios, "dani")
// 0
// > posicion(premios, "juli")
// 2
// > posicion(premios, "feli")
// -1

function convertirEnMayuscula(unString) /* ... */

// Convierte una palabra en mayúsculas
//
// Por ejemplo:
//
// > convertirEnMayuscula("hola")
// "HOLA"

function comienzaCon(unString, otroString) /* ... */

// Retorna un booleano que nos dice si unString empieza con otroString
//
// Por ejemplo:
//
// > comienzaCon("hola todo el mundo", "hola todo")
// true

/**/

/**/

function imprimir(unString) /* ... */

// Imprime por pantalla unString
//
// Por ejemplo:
//
// > imprimir("¡estoy imprimiendo!")
// ¡estoy imprimiendo!

function tirarDado() /* ... */

// Retorna un número al azar entre 1 y 6
//
// Por ejemplo:
//
// > tirarDado()
// 5
// > tirarDado()
// 1
// > tirarDado()
// 2

/**/
function listasIguales(unArray, otroArray) /* ... */
// Retorna un booleano que nos dice si dos listas son iguales
//
// Por ejemplo:
//
// > listasIguales([1, 2, 3], [1, 2, 3])
// true
// > listasIguales([1, 2, 3], [4, 5, 3])
// false

function longitud(unStringOLista) /* ... */

// Retorna el largo de un string o una lista
//
// Por ejemplo:
//
// > longitud("hola")
// 4
// > longitud([5, 6, 3])
// 3

function agregar(unaLista, unElemento) /* ... */

// Inserta unElemento al final de unaLista.
// Este es un procedimiento que no retorna nada pero modifica a unaLista:
//
// > let cancionesFavoritas = ["La colina de la vida", "Zamba por vos"]
// > agregar(cancionesFavoritas, "Seminare")
// > cancionesFavoritas
// ["La colina de la vida", "Zamba por vos", "Seminare"]

function remover(unaLista, unElemento) /* ... */

// Quita unElemento de unaLista. En caso de que no esté, no hace nada.
// Este es un procedimiento que no retorna nada pero modifica a unaLista:
//
// > let listaDeCompras = ["leche", "pan", "arroz", "aceite", "yerba"]
// > remover(listaDeCompras, "pan")
// > listaDeCompras
// ["leche", "arroz", "aceite", "yerba"]

function posicion(unaLista, unElemento) /* ... */

// Retorna la posición en que se encuentra unElemento en unaLista.
// Si el elemento no está en la lista, retorna -1
//
// > let premios = ["dani", "agus", "juli", "fran"]
// > posicion(premios, "dani")
// 0
// > posicion(premios, "juli")
// 2
// > posicion(premios, "feli")
// -1