Reto de colecciones

Clase 22 de 23 • Curso de Dart desde Cero

Google Maps es una herramienta de Google que permite localizar diferentes tipos de comercios, entre ellos restaurantes.

La información es almacenada en bases de datos no relaciones y puede ser extraído en la siguiente estructura mediante el lenguaje de programación Dart.

Set restaurantes = {

{ "nombre": "El novillo alegre", "tipo": "Argentina", "calificaciones": [4, 5, 2, 1, 2] },

{ "nombre": "Baires Grill", "tipo": "Argentina", "calificaciones": [3, 1, 3, 5, 5, 2, 3] },

{ "nombre": "Mario Brothers", "tipo": "Italiana", "calificaciones": [4, 3, 2, 1, 1] },

{ "nombre": "Molto bene", "tipo": "Italiana", "calificaciones": [4, 3, 1, 1, 5] }

};

Un conjunto de restaurantes que no se puede repetir, que contiene varios mapas con nombre, tipo y una lista con calificaciones.

Google requiere que un programador realice un código en Dart para obtener un resumen de la calificación de los diferentes tipos de restaurantes de una zona. Realizando un promedio de las calificaciones por tipo, el resultado debe ser el siguiente.

Map rating = { "Italiana": 3.0, "Argentina": 2.5, "Todos": 2.77 };

Los tipos de comida pueden variar, al igual que las cantidades de la lista de calificación.

¡Comparte tu código!

Ivan Ezequiel Mazzalay

student•

Les dejo mi solución:

void main() {
  Set restaurantes = {
    {
      "nombre": "El novillo alegre",
      "tipo": "Argentina",
      "calificaciones": [4, 5, 2, 1, 2]
    },
    {
      "nombre": "Baires Grill",
      "tipo": "Argentina",
      "calificaciones": [3, 1, 3, 5, 5, 2, 3]
    },
    {
      "nombre": "Mario Brothers",
      "tipo": "Italiana",
      "calificaciones": [4, 3, 2, 1, 1]
    },
    {
      "nombre": "Molto bene",
      "tipo": "Italiana",
      "calificaciones": [4, 3, 1, 1, 5]
    }
  };
  
  //Declaro las variables necesarias para calcular los promedios según sera restaurante Argentino o Italiano
  int sumaArg = 0;
  int longArgCal = 0;
  double avgArg = 0;
  
  int sumaIt = 0;
  int longItCal = 0;
  double avgIt = 0;
  
  double avgTotal = 0;
  
  Map <String, dynamic> rating = {};
  
  //Ejecuto un ciclo for para obtener los datos de cada Restaurant de forma individual.
  //Luego se analiza el tipo de restaurant y se separan los cálculos según cada tipo
  //Se suman los valores de la lista de calificaciones y se suman las longitudes de las listas según tipo de restaurant
  for(int i = 0; i < restaurantes.length; i++){
    
    Map <String, dynamic> restaurante = restaurantes.elementAt(i);
    if (restaurante["tipo"] == "Argentina") {
      
      List <int> calificaciones = restaurante["calificaciones"];
      longArgCal += calificaciones.length;
      
      for (int i = 0; i < calificaciones.length; i++){
        sumaArg += calificaciones[i];
      }
      
    } else if (restaurante["tipo"] == "Italiana") {
      
      List <int> calificacionesIt = restaurante["calificaciones"];
      longItCal += calificacionesIt.length;
      
      for (int i = 0; i < calificacionesIt.length; i++){
        sumaIt += calificacionesIt[i];
      }
      
    }
  }  
  
  
  //Se calculan los promedios de cada Resto y el total
  avgArg = sumaArg / longArgCal;
  avgIt = sumaIt / longItCal;
  avgTotal = avgArg + avgIt / 2;
  
  //Se cargan los datos al Conjunto rating para imprimir en pantalla los resultados
  rating.addAll({
    "Italiana": avgIt, 
    "Argentina": avgArg, 
    "Todos": avgTotal
    });
  
  print(rating);
  
}

Mario de la Torre

student•

Gracias por compartir tu solución. Me sirvió de aprendizaje. Me gustaría hacerte una corrección, y es en: avgTotal = avgArg + avgIt / 2; Para que el resultado sea correcto haría falta añadirle paréntesis quedándose de esta manera: avgTotal = (avgArg + avgIt) / 2;

Nicolás Barceló

student•

import 'package:collection/collection.dart';

void main() {
  Set restaurantes = {
    {
      "nombre": "El novillo alegre",
      "tipo": "Argentina",
      "calificaciones": [4, 5, 2, 1, 2]
    },
    {
      "nombre": "Baires Grill",
      "tipo": "Argentina",
      "calificaciones": [3, 1, 3, 5, 5, 2, 3]
    },
    {
      "nombre": "Mario Brothers",
      "tipo": "Italiana",
      "calificaciones": [4, 3, 2, 1, 1]
    },
    {
      "nombre": "Molto bene",
      "tipo": "Italiana",
      "calificaciones": [4, 3, 1, 1, 5]
    }
  };
  
  Map rating = {};
  
  
  for (Map restaurante in restaurantes) {
    if (rating[restaurante["tipo"]] == null) {
      rating[restaurante["tipo"]] = restaurante["calificaciones"];
    } else {
      rating[restaurante["tipo"]].addAll(restaurante["calificaciones"]);
    }        
    
  }
  
  print(rating);
  
  int valuesSum = 0;
  int valuesLength = 0;
  
  for (var e in rating.entries) {
    List<int> values = e.value;
    rating[e.key] = values.sum / values.length;
    valuesSum += values.sum;
    valuesLength += values.length;
  }
  
  rating["Total"] = valuesSum / valuesLength;
  
  print(rating);
  
}

Carlos Andres Osorio Diaz

student•

Hola Darters!! Les comparto mi código:

!Resultado Reto Colecciones:

Código Fuente:

void main() { Map<String, dynamic> r1 = { "nombre": "El novillo alegre", "tipo": "Argentina", "calificaciones": [4, 5, 2, 1, 2] };

Map<String, dynamic> r2 = { "nombre": "Baires Grill", "tipo": "Argentina", "calificaciones": [3, 1, 3, 5, 5, 2, 3], };

Map<String, dynamic> r3 = { "nombre": "Mario Brothers", "tipo": "Italiana", "calificaciones": [4, 3, 2, 1, 1], };

Map<String, dynamic> r4 = { "nombre": "Molto bene", "tipo": "Italiana", "calificaciones": [4, 3, 1, 1, 5] }; // print(r1);print(r2);print(r3);print(r4); Set restaurantes = {r1, r2, r3, r4}; // print("---------------\nRestaurantes:\n ->$restaurantes \n---------------");

int sumaArg = 0; int sumaIta = 0; List<int> calificaARGs = []; List<int> calificaITAs = [];

// Evaluación de Todos los Restaurantes for (int r = 0; r < restaurantes.length; r++) { print("r: $r, element: " + restaurantes.elementAt(r).toString());

if (restaurantes.elementAt(r)["tipo"] == "Argentina") {
  calificaARGs.addAll(restaurantes.elementAt(r)["calificaciones"]);
}
if (restaurantes.elementAt(r)["tipo"] == "Italiana") {
  calificaITAs.addAll(restaurantes.elementAt(r)["calificaciones"]);
}

}

// Calculos para Argentinos for (int a = 0; a < calificaARGs.length; a++) { sumaArg += calificaARGs[a]; } // Calculos para Italianos for (int i = 0; i < calificaITAs.length; i++) { sumaIta += calificaITAs[i]; }

// Calculo de Promedios double avgArg = sumaArg / calificaARGs.length; double avgIta = sumaIta / calificaITAs.length; double avgTot = (sumaArg + sumaIta) / (calificaARGs.length + calificaITAs.length);

Map<String, dynamic> rating = { "Italiana": avgIta, "Argentina": avgArg, "Todos": avgTot.toStringAsPrecision(3) }; print(rating);

print("\nRest Argentinos: $calificaARGs Longitud : " + calificaARGs.length.toString()); print("Rests Italianos: $calificaITAs Longitud : " + calificaITAs.length.toString()); print("(sumaArg + sumaIta): ($sumaArg + $sumaIta) / (cantArg + cantIta): (" + calificaARGs.length.toString() + "+" + calificaITAs.length.toString() + ")"); print("\navgARG: $avgArg"); print("avgITA: $avgIta"); print("avgTOTAL: " + avgTot.toStringAsPrecision(3)); }

Melvin Salas

teacher•

Me gusta mucho como pones comentarios en el código :D

leandro lion

student•

Hola, como estan? no me queda claro como armar el set! me pueden ayudar?

Gracias

Melvin Salas

teacher•

Para este curso no debes armar ningún set, solo ingresar a https://dartpad.dev

Vidale C.

student•

Mi solución al reto, no es la más optima pero it works! Así mismo, me toco investigar como hacer funciones para lograr hacerlo

int suma(List numbers) {
  dynamic tmp = 0;
  for (int i = 0; i<numbers.length; i++){
    tmp += numbers[i];
  }
  return tmp;
}

void main() {
  Set restaurantes = {
    {
      "name": "El novillo",
      "type": "Argentina",
      "reviews": [4, 5, 2, 1, 1]
    },
    {
      "name": "Baires Grill",
      "type": "Argentina",
      "reviews": [3, 1, 3, 5, 5, 2, 3]
    },
    {
      "name": "M. Brothers",
      "type": "Italiana",
      "reviews": [4, 3, 2, 1, 1]
    },
    {
      "name": "M. bene",
      "type": "Italiana",
      "reviews": [4, 3, 1, 1, 5]
    }
  };

  
  Map ratings = {"Italiana": 0, "Argentina": 0, "Todos": 0};
  dynamic len_arg = 0; dynamic len_ital = 0; //Auxiliar para obtener el promedio
  dynamic total = 0;
  for(int i = 0; i < restaurantes.length; i++) {
    //print(restaurantes.elementAt(i)["type"]);
    if (restaurantes.elementAt(i)["type"] == "Argentina"){
      ratings["Argentina"] += suma(restaurantes.elementAt(i)["reviews"]);
      len_arg += restaurantes.elementAt(i)["reviews"].length;
      total += suma(restaurantes.elementAt(i)["reviews"]);
    }
    else if (restaurantes.elementAt(i)["type"] == "Italiana"){
      ratings["Italiana"] += suma(restaurantes.elementAt(i)["reviews"]);
      len_ital += restaurantes.elementAt(i)["reviews"].length;
      total += suma(restaurantes.elementAt(i)["reviews"]);
    }
  }
  ratings["Argentina"] = ratings["Argentina"]/len_arg;
  ratings["Italiana"] = ratings["Italiana"]/len_ital;
  ratings["Todos"] = total/(len_arg+len_ital);
  
  print(ratings);

}

Melvin Salas

teacher•

En este caso las funciones no son necesarias, eso lo veremos en el próximo curso ;)

Creo que usando ciclos puedes hacer una solución un poco más óptima, espero tu siguiente versión para verla en conjunto :D

Juan Carlos Mezquita Gutierrez

student•

</*
obtener un resumen de la calificación de los diferentes tipos de 
restaurantes de una zona. Realizando un promedio de las calificaciones 
por tipo.
 */
import 'package:collection/collection.dart';

void main() {
  //Coleccion con los restauramnte y a sus calificaciones
  Set _restaurantes = {
    {
      "nombre": "El novillo alegre",
      "tipo": "Argentina",
      "calificaciones": [4, 5, 2, 1, 2]
    },
    {
      "nombre": "Baires Grill",
      "tipo": "Argentina",
      "calificaciones": [3, 1, 3, 5, 5, 2, 3]
    },
    {
      "nombre": "Mario. Brothers",
      "tipo": "Italiana",
      "calificaciones": [4, 3, 2, 1, 1]
    },
    {
      "nombre": "Molto. bene",
      "tipo": "Italiana",
      "calificaciones": [4, 3, 1, 1, 5]
    }
  };

//en esta variable guardare los diferentes tipos
  Map<String, double> _calificacionPorTipo = {};

  //Este lista tendra las calificaciones por tipos
  List<int> _calificcaciones = [];

  //almcenara el propedio de calificacion para
  double _calificacionPromedio;

  //en esta variable alamcenare el total de calificacion, no me gusta mucho usar variables para esto, pero de esta forma evitare tener que hacerle un query a la lista nuevamente.
  double _totalCalificaciones = 0;
  int _totalCant = 0;

//query a la lista, que me devuelve solos los tipos nos repetidos,
//luego recorro el resultado y ejecuto un nuevo query a la lista principal filtrando por el tipo y seleccionando solo las calificaciones
  List _listaTipo = _restaurantes.map((v) => v["tipo"]).toSet().toList();

  for (var e in _listaTipo) {
    _calificcaciones.clear();
    _restaurantes
        .where((w) => w["tipo"] == e)
        .toList()
        .map((m) => m["calificaciones"])
        .toList()
        .forEach((i) {
      _calificcaciones.addAll(i);
    });

    //Calculo el propedio de la calificacion segun su tipo
    _calificacionPromedio = double.parse(
        (_calificcaciones.sum / _calificcaciones.length).toStringAsFixed(2));

    //acumulacion de las sumas de las calificaciones
    _totalCalificaciones += _calificcaciones.sum;
    _totalCant += _calificcaciones.length;

    //agrego a la lista definitica los resultado segun el tipo
    _calificacionPorTipo.addAll({e: _calificacionPromedio});
  }

  //como todos no es un tipo de la lista lo agrego harcode
  _calificacionPorTipo.addAll({
    "Todos":
        double.parse((_totalCalificaciones / _totalCant).toStringAsFixed(2))
  });

  print(_calificacionPorTipo);
}
>

Alberto Aleman Rocha

student•

Haciendo este ejercicio no pude notar la diferencia entre la colección tipo Set y la colección tipo Map:(

Melvin Salas

teacher•

Los Sets son registros únicos que no se pueden repetir, es como una lista con la diferencia de que si agregar un elemento que ya existe, no se duplicará:

  var nombres = {"Alberto", "Ana"};
  print(nombres); // {Alberto, Ana}
  nombres.add('José');
  print(nombres); // {Alberto, Ana, José}
  nombres.add('José');
  print(nombres); // {Alberto, Ana, José}

Por otro lado, el map es como una lista, pero con un índice (también se le puede llamar diccionario) permite que los elementos se puedan duplicar solo si el índice no se repite (como funciona el diccionario en la vida real)

void main() { 
  var dicc = {
    'platzi':'plataforma en línea',
    'google':'web de busquedas'
  }; 
  print(dicc);  // Platzi, Google
  dicc.addAll({
    'bing': 'otro buscador'
  });
  print(dicc);  // Platzi, Google, Bing
}

Los Maps son utiles para hacer búsqueda por ese índice o llave

Christian Manuel Campos Navarro

student•

Bastante básico el curso aunque útil. A este ritmo tendrían que sacar otros 5 cursos más por lo menos.

Hector David Ramos Ortiz

student•

Hola, adjunto mi solucion

<void main() 
// variable para almacenar los tipos de restaurante con sus respectivas calificaciones.
{
  Set restaurantes = {
    {
      "nombre": "El novillo alegre",
      "tipo": "Argentina",
      "calificaciones": [4, 3, 1, 1, 5]
    },
    {
      "nombre": "Baires Grill",
      "tipo": "Argentina",
      "calificaciones": [4, 3, 2, 1, 1]
    },
    {
      "nombre": "Mario Brothers",
      "tipo": "Italiana",
      "calificaciones": [4, 5, 2, 1, 2]
    },
    {
      "nombre": "Molto bene",
      "tipo": "Italiana",
      "calificaciones": [3, 1, 3, 5, 5, 2, 3]
    }
  };
 // variables para almacenar totales segun tipo y promedio de todos 
  int sumaArg = 0;
  int sumaIta = 0;
  int suma = 0;
  int totalArg = 0;
  int totalIta = 0;
  int total = 0;
  double promedioIta = 0;
  double promedioArg = 0;
  double promedioTotal = 0;
 //calculo suma de cada tipo y promedio 
  for(int i = 0; i<restaurantes.length; i ++){
    if (restaurantes.elementAt(i)['tipo'] == 'Italiana'){
      List<int> calificacionesItal = restaurantes.elementAt(i)['calificaciones'];
      for (int i = 0; i<calificacionesItal.length; i++){
        sumaIta += calificacionesItal[i];
        totalIta += 1;
      } 
    }else{
      List<int> calificacionesArg = restaurantes.elementAt(i)['calificaciones'];
      for (int a = 0; a<calificacionesArg.length; a++){
        sumaArg += calificacionesArg[a];
        totalArg += 1;
      }
    }
  }
  promedioArg = sumaArg / totalArg;
  promedioIta = sumaIta / totalIta;
// se hace la suma de todos los tipos para adquirir el total 
  total = totalIta + totalArg;
  suma = sumaIta + sumaArg;
  promedioTotal = suma / total;
  
  Map <String, double> rating = {
    'Italiana': promedioIta,
    'Argentina': promedioArg,
    'Todos': promedioTotal
  };
  print(rating);
  
}>

JOHN FREDY ARISTIZABAL ESCOBAR

student•

Mi ejercicio:

void main() {
  //Definimos el Set de Restaurantes
  Set restaurantes = {
    {
      "nombre": "El novillo alegre",
      "tipo": "Argentina",
      "calificaciones": [4,5,2,1,2]
      },
    {
      "nombre": "Baires Girls",
      "tipo": "Argentina",
      "calificaciones": [4,4,4,1,3,5]
      },
    {
      "nombre": "Mario Brothers",
      "tipo": "Italiana",
      "calificaciones": [5,5,4,5,3,5]
      },
    {
      "nombre": "Molto Bene",
      "tipo": "Italiana",
      "calificaciones": [5,4,4,3,3,2]
      },
    {
      "nombre": "Andres Carne de Res",
      "tipo": "Colombiana",
      "calificaciones": [5,5,4,3,5,5]
      },
    {
      "nombre": "SAPiens",
      "tipo": "Alemana",
      "calificaciones": [2,5,4,3,5,5]
      },
    {
      "nombre": "Los tacos",
      "tipo": "Mexicana",
      "calificaciones": [5,1,4,3,3,5]
      },
  };
  
  Map<String, dynamic> rating = {
    
  };
  
  //Variable para acumular todos los puntajes de todos los restaurantes
  double puntajeTotal = 0;
  //Variable para calcular el promedio de todos los restaurantes
  double promedioTodos = 0;
  String tipo = "";
  
  
  //Recorremos cada uno de los elementos del Set
  for (int r = 0; r < restaurantes.length; r++){
    //Se crea lista con el puntaje de cada restaurante
    List<int> puntajes = (restaurantes.elementAt(r)["calificaciones"]);
    
    //Variable para almacenar la suma del puntaje x restaurante
    int sumaPuntajeRes = 0;
    //Variable para calcular el promedio x restaurante
    double promRes = 0;
    
    for (int i=0; i < puntajes.length; i++) {
      sumaPuntajeRes += puntajes[i];
    }
    promRes = (sumaPuntajeRes / puntajes.length);
    
    tipo = (restaurantes.elementAt(r)["tipo"]);
    
    if (rating.containsKey(tipo)){
      //Si el restaurante ya esta en el mapa se debe acumular
      // y promediar el puntaje
      double puntajeAcumulado = rating[tipo] + promRes;
      rating.update(tipo, (value) => puntajeAcumulado/2);
    } else {
      //Si el restaurante no esta en el mapa se agrega,
      rating.addAll({tipo:promRes});
    }
  }
  
  //Recorro el Map y acumulo los puntajes
  rating.forEach((key, value){
    puntajeTotal += value;
  });
  
  //Calcular el promedio total
  
  promedioTodos = puntajeTotal / rating.length;
  //Almaceno la llave de Todos en el mapa
  rating.addAll({"Todos":promedioTodos});
  
  //Imprimo el Map final recorriendo uno a uno
  rating.forEach((key, value){
    print("Restaurante tipo: $key con un puntaje: $value");
  });
  
}

Marcos Ramirez

student•

void main() {

Set restaurantes = { { "nombre":"El novillo alegre", "tipo":"Argentina", "calificaciones":[4,5,2,1,2] }, { "nombre":"Mario Brothers", "tipo":"Italiana", "calificaciones":[4, 3, 2, 1, 1] }, { "nombre":"Molto bene", "tipo":"Italiana", "calificaciones":[4, 3, 1, 1, 5] } }; print(restaurantes);

Map calculo = {};

for(Map restaurante in restaurantes){ if(!calculo.containsKey(restaurante["tipo"])){ calculo.addAll({restaurante["tipo"]: { "suma" : 0, "cantidad" : 0 }}); }

List calificacion = restaurante["calificaciones"];
int suma = 0;
for(int i=0; i<calificacion.length; i++){
   int calif = calificacion[i];
   suma = suma + calif;
}

Map valores = calculo[restaurante["tipo"]];
valores["suma"] = valores["suma"] + suma;
valores["cantidad"] = valores["cantidad"] + calificacion.length;

} print (calculo);

Map rating = {}; for(String v in calculo.keys){ Map aux = calculo[v]; rating.addAll({v:(aux["suma"]/aux["cantidad"])}); }

double sum = 0; for(String todo in rating.keys){ sum = sum + rating[todo]; } double promedio = sum / rating.keys.length;

rating.addAll({"Todos":promedio}); print(rating); }

Andres Villanueva Tabares

student•

¿Alguien se dio cuenta de que la respuesta que se pide en el ejercicio es imposible de resolver con los datos suministrados?, ya que al hacer el cálculo Argentina da 3.00 e italiana da 2.50, lo que significa que la respuesta que se espera del ejercicio a la fecha está mal.

Muy bonito y todo el proceso para llegar a esa conclusión, pero al final lo que importa es que la pregunta está bien hecha porque uno puede pensar que está haciendo las cosas mal hasta que ve las respuestas de los comentarios y uno se da cuenta de que todos concluyen el mismo error.

Melvin Salas

teacher•

Hola, claro, como indicas hubo un error en la redacción de las respuestas, gracias por la aclaración.

Anghelo Alexander Pintado Valverde

student•

Mi aporte:

void main() {
  Set restaurantes = {
    {
      "nombre": "El novillo alegre",
      "tipo": "Argentina",
      "calificaciones": [4, 5, 2, 1, 2]
    },
    {
      "nombre": "Baires Grill",
      "tipo": "Argentina",
      "calificaciones": [3, 1, 3, 5, 5, 2, 3]
    },
    {
      "nombre": "Mario Brothers",
      "tipo": "Italiana",
      "calificaciones": [4, 3, 2, 1, 1]
    },
    {
      "nombre": "Molto bene",
      "tipo": "Italiana",
      "calificaciones": [4, 3, 1, 1, 5]
    }
  };
  
  // Declaramos e inicializamos el mapa que nos permitirá almacenar las calificaciones por tipo
  Map<String, List<int>> calificacionesPorTipo = {};

  //Iteramos en el Set de restaurantes
  for (Map rest in restaurantes) {
    String tipo = rest["tipo"];

    //Si variable tipo no se encuentra en el mapa acumuladoTipo se ingresa y se asigna una lista vacia
    if (!calificacionesPorTipo.containsKey(tipo)) {
      calificacionesPorTipo[tipo] = [];
    }

    //Ya sea que se encuentre o no en el mapa se añaden la lista de calificaciones que le corresponde a su tipo("Argentina, Italiana...")
    calificacionesPorTipo[tipo]!.addAll(rest["calificaciones"]);
    // Con ! le estamos diciendo al compilador: "Confía en mí, esto no será null"
  }

  //Con ayuda del bucle for incializamos las claves del mapa rating
  Map rating = {
    for (String tipo in calificacionesPorTipo.keys)
      tipo:
          //Accedemos al mapa a traves del tipo, con el metodo reduce() se realiza una suma acumulativa y esta se divide entre el tamaño de la lista
          calificacionesPorTipo[tipo]!
                  .reduce((sum, calificacion) => sum + calificacion) /
              calificacionesPorTipo[tipo]!.length
  };

  //Con el metodo expand() unimos todas las lista en una sola, para poder sacar el promedio
  double promedioTotal = calificacionesPorTipo.values
          .expand((calificaciones) => calificaciones)
          .reduce((sum, calificacion) => sum + calificacion) /
      calificacionesPorTipo.values
          .expand((calificaciones) => calificaciones)
          .length;

  //Se agrega la clave Todos con su repectivo valor que seria el promedio total
  rating["Todos"] = (promedioTotal).toStringAsFixed(2);

  print(rating);
}

```void main() {

&#x20; Set restaurantes = {

&#x20;   {

&#x20;     "nombre": "El novillo alegre",

&#x20;     "tipo": "Argentina",

&#x20;     "calificaciones": \[4, 5, 2, 1, 2]

&#x20;   },

&#x20;   {

&#x20;     "nombre": "Baires Grill",

&#x20;     "tipo": "Argentina",

&#x20;     "calificaciones": \[3, 1, 3, 5, 5, 2, 3]

&#x20;   },

&#x20;   {

&#x20;     "nombre": "Mario Brothers",

&#x20;     "tipo": "Italiana",

&#x20;     "calificaciones": \[4, 3, 2, 1, 1]

&#x20;   },

&#x20;   {

&#x20;     "nombre": "Molto bene",

&#x20;     "tipo": "Italiana",

&#x20;     "calificaciones": \[4, 3, 1, 1, 5]

&#x20;   }

&#x20; };

&#x20;&#x20;

&#x20; // Declaramos e inicializamos el mapa que nos permitirá almacenar las calificaciones por tipo

&#x20; Map\<String, List\<int>> calificacionesPorTipo = {};



&#x20; //Iteramos en el Set de restaurantes

&#x20; for (Map rest in restaurantes) {

&#x20;   String tipo = rest\["tipo"];



&#x20;   //Si variable tipo no se encuentra en el mapa acumuladoTipo se ingresa y se asigna una lista vacia

&#x20;   if (!calificacionesPorTipo.containsKey(tipo)) {

&#x20;     calificacionesPorTipo\[tipo] = \[];

&#x20;   }



&#x20;   //Ya sea que se encuentre o no en el mapa se añaden la lista de calificaciones que le corresponde a su tipo("Argentina, Italiana...")

&#x20;   calificacionesPorTipo\[tipo]!.addAll(rest\["calificaciones"]);

&#x20;   // Con ! le estamos diciendo al compilador: "Confía en mí, esto no será null"

&#x20; }



&#x20; //Con ayuda del bucle for incializamos las claves del mapa rating

&#x20; Map rating = {

&#x20;   for (String tipo in calificacionesPorTipo.keys)

&#x20;     tipo:

&#x20;         //Accedemos al mapa a traves del tipo, con el metodo reduce() se realiza una suma acumulativa y esta se divide entre el tamaño de la lista

&#x20;         calificacionesPorTipo\[tipo]!

&#x20;                 .reduce((sum, calificacion) => sum + calificacion) /

&#x20;             calificacionesPorTipo\[tipo]!.length

&#x20; };



&#x20; //Con el metodo expand() unimos todas las lista en una sola, para poder sacar el promedio

&#x20; double promedioTotal = calificacionesPorTipo.values

&#x20;         .expand((calificaciones) => calificaciones)

&#x20;         .reduce((sum, calificacion) => sum + calificacion) /

&#x20;     calificacionesPorTipo.values

&#x20;         .expand((calificaciones) => calificaciones)

&#x20;         .length;



&#x20; //Se agrega la clave Todos con su repectivo valor que seria el promedio total

&#x20; rating\["Todos"] = (promedioTotal).toStringAsFixed(2);



&#x20; print(rating);

}

Luigi Espinosa

student•

void main() {
  List<Map<String, dynamic>> restaurants = [
    {
      "nombre": "El novillo alegre",
      "tipo": "Argentina",
      "calificaciones": [4, 5, 2, 1, 2]
    },
    {
      "nombre": "Baires Grill",
      "tipo": "Argentina",
      "calificaciones": [3, 1, 3, 5, 5, 2, 3]
    },
    {
      "nombre": "Mario Brothers",
      "tipo": "Italiana",
      "calificaciones": [4, 3, 2, 1, 1]
    },
    {
      "nombre": "Molto bene",
      "tipo": "Italiana",
      "calificaciones": [4, 3, 1, 1, 5]
    }
  ];
  
  // Step 1: Collect ratings by country
  Map<String, List<int>> countryRatings = {};
  
  for (var restaurant in restaurants) {
    String country = restaurant["tipo"];
    List<int> ratings = List<int>.from(restaurant["calificaciones"]);
    
    if (countryRatings.containsKey(country)) {
      countryRatings[country]?.addAll(ratings);
    } else {
      countryRatings[country] = ratings;
    }
  }

  // Step 2: Calculate average rating for each country
  Map<String, double> averageRatings = {};
  int totalSum = 0;
  int totalCount = 0;

  countryRatings.forEach((country, ratings) {
    double average = ratings.reduce((a, b) => a + b) / ratings.length;
    averageRatings[country] = average;

    totalSum += ratings.reduce((a, b) => a + b);
    totalCount += ratings.length;
  });
  
  // Step 3: Calculate the total average rating
  double totalAverage = totalSum / totalCount;
  averageRatings["Total"] = double.parse(totalAverage.toStringAsFixed(2));

  // Print the result
  print(averageRatings);
}
```void main() {

&#x20; List\<Map\<String, dynamic>> restaurants = \[

&#x20;   {

&#x20;     "nombre": "El novillo alegre",

&#x20;     "tipo": "Argentina",

&#x20;     "calificaciones": \[4, 5, 2, 1, 2]

&#x20;   },

&#x20;   {

&#x20;     "nombre": "Baires Grill",

&#x20;     "tipo": "Argentina",

&#x20;     "calificaciones": \[3, 1, 3, 5, 5, 2, 3]

&#x20;   },

&#x20;   {

&#x20;     "nombre": "Mario Brothers",

&#x20;     "tipo": "Italiana",

&#x20;     "calificaciones": \[4, 3, 2, 1, 1]

&#x20;   },

&#x20;   {

&#x20;     "nombre": "Molto bene",

&#x20;     "tipo": "Italiana",

&#x20;     "calificaciones": \[4, 3, 1, 1, 5]

&#x20;   }

&#x20; ];

&#x20;&#x20;

&#x20; // Step 1: Collect ratings by country

&#x20; Map\<String, List\<int>> countryRatings = {};

&#x20;&#x20;

&#x20; for (var restaurant in restaurants) {

&#x20;   String country = restaurant\["tipo"];

&#x20;   List\<int> ratings = List\<int>.from(restaurant\["calificaciones"]);

&#x20;  &#x20;

&#x20;   if (countryRatings.containsKey(country)) {

&#x20;     countryRatings\[country]?.addAll(ratings);

&#x20;   } else {

&#x20;     countryRatings\[country] = ratings;

&#x20;   }

&#x20; }



&#x20; // Step 2: Calculate average rating for each country

&#x20; Map\<String, double> averageRatings = {};

&#x20; int totalSum = 0;

&#x20; int totalCount = 0;



&#x20; countryRatings.forEach((country, ratings) {

&#x20;   double average = ratings.reduce((a, b) => a + b) / ratings.length;

&#x20;   averageRatings\[country] = average;



&#x20;   totalSum += ratings.reduce((a, b) => a + b);

&#x20;   totalCount += ratings.length;

&#x20; });

&#x20;&#x20;

&#x20; // Step 3: Calculate the total average rating

&#x20; double totalAverage = totalSum / totalCount;

&#x20; averageRatings\["Total"] = double.parse(totalAverage.toStringAsFixed(2));



&#x20; // Print the result

&#x20; print(averageRatings);

}

Cristian Caled Flores Vasquez

student•

Hice mi mayor esfuerzo jejeje

void main() {
  Set restaurantes = {
    {
      "nombre": "El novillo alegre",
      "tipo": "Italiana",
      "calificaciones": [4, 5, 2, 1, 2]
    },
    {
      "nombre": "Baires Grill",
      "tipo": "Italiana",
      "calificaciones": [3, 1, 3, 5, 5, 2, 3]
    },
    {
      "nombre": "Mario Brothers",
      "tipo": "Argentina",
      "calificaciones": [4, 3, 2, 1, 1]
    },
    {
      "nombre": "Molto bene",
      "tipo": "Argentina",
      "calificaciones": [4, 3, 1, 1, 5]
    }
  };

  Map ratings = {};
  List paises = [];

  for (int i = 0; i < restaurantes.length; i++) {
    if (i == 0) {
      ratings[restaurantes.elementAt(i)['tipo']] = (restaurantes.elementAt(i)['calificaciones']);
      paises.add(restaurantes.elementAt(i)['tipo']);
    } else {
      for (int x = 0; x < ratings.length; x++) {
        if (ratings.containsKey(restaurantes.elementAt(i)['tipo'])) {
          ratings[restaurantes.elementAt(i)['tipo']] += (restaurantes.elementAt(i)['calificaciones']);
        } else {
          paises.add(restaurantes.elementAt(i)['tipo']);
          ratings[restaurantes.elementAt(i)['tipo']] = (restaurantes.elementAt(i)['calificaciones']);
        }
      }
    }
  }
  
  for(int z=0; z < paises.length; z++){
    ratings[paises[z]] = (ratings[paises[z]].reduce((int v, int e) => v + e)/ratings[paises[z]].length);
  }

  print(ratings);
}

Breiner Julián Rodríguez

student•

void main() {

Set<Map<String, dynamic>> restaurantes = {

{

"nombre": "El novillo alegre",

"tipo": "Argentina",

"calificaciones": [4, 5, 2, 1, 2],

{

"nombre": "Baires Grill",

"tipo": "Argentina",

"calificaciones": [3, 1, 3, 5, 5, 2, 3],

{

"nombre": "Mario Brothers",

"tipo": "Italiana",

"calificaciones": [4, 3, 2, 1, 1],

{

"nombre": "Molto bene",

"tipo": "Italiana",

"calificaciones": [4, 3, 1, 1, 5],

};

Map<String, dynamic> rating = {};

restaurantes.forEach((restaurante) {

String tipo = restaurante["tipo"];

List<int> calificaciones = restaurante["calificaciones"];

// Calcula el promedio de calificaciones por tipo

double promedio = calificaciones.isNotEmpty

? calificaciones.reduce((a, b) => a + b) / calificaciones.length

: 0;

rating.update(tipo, (value) => (value + promedio) / 2, ifAbsent: () => promedio);

});

// Calcula el promedio general

double promedioGeneral = rating.values.isNotEmpty

? rating.values.reduce((a, b) => a + b) / rating.length

: 0;

rating["Todos"] = promedioGeneral;

print(rating);

}

David Fernando Sandoval Gomez

student•

Hola, les dejo la imagen del resultado

y el código

void main() {
  // Definimos el conjunto de restaurantes
  Set restaurantes = {
    {
      "nombre": "El novillo alegre",
      "tipo": "Argentina",
      "calificaciones": [4, 5, 2, 1, 2]
    },
    {
      "nombre": "Baires Grill",
      "tipo": "Argentina",
      "calificaciones": [3, 1, 3, 5, 5, 2, 3]
    },
    {
      "nombre": "Mario Brothers",
      "tipo": "Italiana",
      "calificaciones": [4, 3, 2, 1, 1]
    },
    {
      "nombre": "Molto bene",
      "tipo": "Italiana",
      "calificaciones": [4, 3, 1, 1, 5]
    }
  };

  //Definimos conjunto de rating y en cada llave ejecutamos la funcion enviandole los parametros definidos
  Map rating = {
    "Argentina": calcularPromedioDeCalificaciones(restaurantes, "Argentina"),
    "Italiana": calcularPromedioDeCalificaciones(restaurantes, "Italiana"),
    "Todos": ((calcularPromedioDeCalificaciones(restaurantes, "Argentina") +
            calcularPromedioDeCalificaciones(restaurantes, "Italiana")) /
        2)
  };

  // Imprimimos el promedio de las calificaciones obtenidas
  print(rating);
}

//Creamos funcion para calcular el promedio de las calificaciones por tipo
double calcularPromedioDeCalificaciones(restaurantes, String tipo) {
  // Inicializamos la variable para almacenar la suma de las calificaciones
  int sumaCalificaciones = 0;

  // Inicializamos la variable para almacenar la cantidad de calificaciones
  num cantidadDeCalificaciones = 0;

  // Inicializamos la variable para almacenar el promedio de calificaciones
  double promedioDeCalificaciones;

  // Recorremos el conjunto de restaurantes
  for (Map<String, dynamic> restaurante in restaurantes) {
    // Validamos si el tipo del restaurante coincide con el tipo recibido
    if (restaurante["tipo"] == tipo) {
      // Recorremos la lista de calificaciones del tipo
      for (int calificacion in restaurante["calificaciones"]) {
        // Sumamos la calificación a la variable
        sumaCalificaciones += calificacion;
      }
      // Sumamos la longitud de la lista de calificaciones
      cantidadDeCalificaciones += restaurante["calificaciones"].length;
    }
  }

  //Calculamos el promedio de las calificaciones
  promedioDeCalificaciones = sumaCalificaciones / cantidadDeCalificaciones;

  // Devolvemos el promedio de las calificaciones
  return promedioDeCalificaciones;
}
```Saludos.

Cristian Roca

student•

Joel Verastegui

student•

Le agregué un promedio por restaurante y luego por país. Para el código usé dos métodos que no se mencionaron en el curso:

"Reduce" para la suma de los valores de la colección "Calificaciones".
"Where" para filtrar la colección por país.

void main() {
  Set restaurantes = {
    {
      "nombre": "El novillo alegre",
      "tipo": "Argentina",
      "calificaciones": [4, 5, 2, 1, 2]
    },
    {
      "nombre": "Baires Grill",
      "tipo": "Argentina",
      "calificaciones": [3, 1, 3, 5, 5, 2, 3]
    },
    {
      "nombre": "Mario Brothers",
      "tipo": "Italiana",
      "calificaciones": [4, 3, 2, 1, 1]
    },
    {
      "nombre": "Molto bene",
      "tipo": "Italiana",
      "calificaciones": [4, 3, 1, 1, 5]
    }
  };
  
  Set<String> tipos = {};
  
  for(var restaurante in restaurantes) {
    tipos.add(restaurante["tipo"]);
    
    print("////////////////////");
    for(String key in restaurante.keys) {
      if(key == "calificaciones") {
        print("$key: ${restaurante[key].reduce((int a, int b) => a + b) / restaurante[key].length}");
      } else {
        print("$key: ${restaurante[key]}");
      }
    }
    print("////////////////////\n");
  }
    
  double totalAvg = 0;
  print("====================");
  
  for(String tipo in tipos) {
    double avg = 0;
    int count = 0;
    for(var restaurante in restaurantes.where((x) => x["tipo"] == tipo)) {
      avg += restaurante["calificaciones"].reduce((int a, int b) => a + b) / restaurante["calificaciones"].length;
      count++;
    }
    totalAvg += avg / count;
    print("$tipo: ${avg / count}");
  }
  print("Todos: ${totalAvg / tipos.length}");
  print("====================");
}

Victor Sosa

student•

void main() {
  Set restaurantes = {
    {
      "nombre": "El novillo alegre",
      "tipo": "Argentina",
      "calificaciones": [4, 5, 2, 1, 2]
    },
    {
      "nombre": "Baires Grill",
      "tipo": "Argentina",
      "calificaciones": [3, 1, 3, 5, 5, 2, 3]
    },
    {
      "nombre": "Mario Brothers",
      "tipo": "Italiana",
      "calificaciones": [4, 3, 2, 1, 1]
    },
    {
      "nombre": "Molto bene",
      "tipo": "Italiana",
      "calificaciones": [4, 3, 1, 1, 5]
    }
  };
  
  //Declaro las variables necesarias para calcular los promedios según sera restaurante Argentino o Italiano
  int sumaArg = 0;
  int longArgCal = 0;
  double avgArg = 0;
  
  int sumaIt = 0;
  int longItCal = 0;
  double avgIt = 0;
  
  double avgTotal = 0;
  
  Map <String, dynamic> rating = {};
  
  //Ejecuto un ciclo for para obtener los datos de cada Restaurant de forma individual.
  //Luego se analiza el tipo de restaurant y se separan los cálculos según cada tipo
  //Se suman los valores de la lista de calificaciones y se suman las longitudes de las listas según tipo de restaurant
  for(int i = 0; i < restaurantes.length; i++){
    
    Map <String, dynamic> restaurante = restaurantes.elementAt(i);
    if (restaurante["tipo"] == "Argentina") {
      
      List <int> calificaciones = restaurante["calificaciones"];
      longArgCal += calificaciones.length;
      
      for (int i = 0; i < calificaciones.length; i++){
        sumaArg += calificaciones[i];
      }
      
    } else if (restaurante["tipo"] == "Italiana") {
      
      List <int> calificacionesIt = restaurante["calificaciones"];
      longItCal += calificacionesIt.length;
      
      for (int i = 0; i < calificacionesIt.length; i++){
        sumaIt += calificacionesIt[i];
      }
      
    }
  }  
  
  
  //Se calculan los promedios de cada Resto y el total
  avgArg = sumaArg / longArgCal;
  avgIt = sumaIt / longItCal;
  avgTotal = avgArg + avgIt / 2;
  
  //Se cargan los datos al Conjunto rating para imprimir en pantalla los resultados
  rating.addAll({
    "Italiana": avgIt, 
    "Argentina": avgArg, 
    "Todos": avgTotal
    });
  
  print(rating);
  
}

import 'package:collection/collection.dart';

void main() {
  Set restaurantes = {
    {
      "nombre": "El novillo alegre",
      "tipo": "Argentina",
      "calificaciones": [4, 5, 2, 1, 2]
    },
    {
      "nombre": "Baires Grill",
      "tipo": "Argentina",
      "calificaciones": [3, 1, 3, 5, 5, 2, 3]
    },
    {
      "nombre": "Mario Brothers",
      "tipo": "Italiana",
      "calificaciones": [4, 3, 2, 1, 1]
    },
    {
      "nombre": "Molto bene",
      "tipo": "Italiana",
      "calificaciones": [4, 3, 1, 1, 5]
    }
  };
  
  Map rating = {};
  
  
  for (Map restaurante in restaurantes) {
    if (rating[restaurante["tipo"]] == null) {
      rating[restaurante["tipo"]] = restaurante["calificaciones"];
    } else {
      rating[restaurante["tipo"]].addAll(restaurante["calificaciones"]);
    }        
    
  }
  
  print(rating);
  
  int valuesSum = 0;
  int valuesLength = 0;
  
  for (var e in rating.entries) {
    List<int> values = e.value;
    rating[e.key] = values.sum / values.length;
    valuesSum += values.sum;
    valuesLength += values.length;
  }
  
  rating["Total"] = valuesSum / valuesLength;
  
  print(rating);
  
}

if (restaurantes.elementAt(r)["tipo"] == "Argentina") {
  calificaARGs.addAll(restaurantes.elementAt(r)["calificaciones"]);
}
if (restaurantes.elementAt(r)["tipo"] == "Italiana") {
  calificaITAs.addAll(restaurantes.elementAt(r)["calificaciones"]);
}

int suma(List numbers) {
  dynamic tmp = 0;
  for (int i = 0; i<numbers.length; i++){
    tmp += numbers[i];
  }
  return tmp;
}

void main() {
  Set restaurantes = {
    {
      "name": "El novillo",
      "type": "Argentina",
      "reviews": [4, 5, 2, 1, 1]
    },
    {
      "name": "Baires Grill",
      "type": "Argentina",
      "reviews": [3, 1, 3, 5, 5, 2, 3]
    },
    {
      "name": "M. Brothers",
      "type": "Italiana",
      "reviews": [4, 3, 2, 1, 1]
    },
    {
      "name": "M. bene",
      "type": "Italiana",
      "reviews": [4, 3, 1, 1, 5]
    }
  };

  
  Map ratings = {"Italiana": 0, "Argentina": 0, "Todos": 0};
  dynamic len_arg = 0; dynamic len_ital = 0; //Auxiliar para obtener el promedio
  dynamic total = 0;
  for(int i = 0; i < restaurantes.length; i++) {
    //print(restaurantes.elementAt(i)["type"]);
    if (restaurantes.elementAt(i)["type"] == "Argentina"){
      ratings["Argentina"] += suma(restaurantes.elementAt(i)["reviews"]);
      len_arg += restaurantes.elementAt(i)["reviews"].length;
      total += suma(restaurantes.elementAt(i)["reviews"]);
    }
    else if (restaurantes.elementAt(i)["type"] == "Italiana"){
      ratings["Italiana"] += suma(restaurantes.elementAt(i)["reviews"]);
      len_ital += restaurantes.elementAt(i)["reviews"].length;
      total += suma(restaurantes.elementAt(i)["reviews"]);
    }
  }
  ratings["Argentina"] = ratings["Argentina"]/len_arg;
  ratings["Italiana"] = ratings["Italiana"]/len_ital;
  ratings["Todos"] = total/(len_arg+len_ital);
  
  print(ratings);

}

</*
obtener un resumen de la calificación de los diferentes tipos de 
restaurantes de una zona. Realizando un promedio de las calificaciones 
por tipo.
 */
import 'package:collection/collection.dart';

void main() {
  //Coleccion con los restauramnte y a sus calificaciones
  Set _restaurantes = {
    {
      "nombre": "El novillo alegre",
      "tipo": "Argentina",
      "calificaciones": [4, 5, 2, 1, 2]
    },
    {
      "nombre": "Baires Grill",
      "tipo": "Argentina",
      "calificaciones": [3, 1, 3, 5, 5, 2, 3]
    },
    {
      "nombre": "Mario. Brothers",
      "tipo": "Italiana",
      "calificaciones": [4, 3, 2, 1, 1]
    },
    {
      "nombre": "Molto. bene",
      "tipo": "Italiana",
      "calificaciones": [4, 3, 1, 1, 5]
    }
  };

//en esta variable guardare los diferentes tipos
  Map<String, double> _calificacionPorTipo = {};

  //Este lista tendra las calificaciones por tipos
  List<int> _calificcaciones = [];

  //almcenara el propedio de calificacion para
  double _calificacionPromedio;

  //en esta variable alamcenare el total de calificacion, no me gusta mucho usar variables para esto, pero de esta forma evitare tener que hacerle un query a la lista nuevamente.
  double _totalCalificaciones = 0;
  int _totalCant = 0;

//query a la lista, que me devuelve solos los tipos nos repetidos,
//luego recorro el resultado y ejecuto un nuevo query a la lista principal filtrando por el tipo y seleccionando solo las calificaciones
  List _listaTipo = _restaurantes.map((v) => v["tipo"]).toSet().toList();

  for (var e in _listaTipo) {
    _calificcaciones.clear();
    _restaurantes
        .where((w) => w["tipo"] == e)
        .toList()
        .map((m) => m["calificaciones"])
        .toList()
        .forEach((i) {
      _calificcaciones.addAll(i);
    });

    //Calculo el propedio de la calificacion segun su tipo
    _calificacionPromedio = double.parse(
        (_calificcaciones.sum / _calificcaciones.length).toStringAsFixed(2));

    //acumulacion de las sumas de las calificaciones
    _totalCalificaciones += _calificcaciones.sum;
    _totalCant += _calificcaciones.length;

    //agrego a la lista definitica los resultado segun el tipo
    _calificacionPorTipo.addAll({e: _calificacionPromedio});
  }

  //como todos no es un tipo de la lista lo agrego harcode
  _calificacionPorTipo.addAll({
    "Todos":
        double.parse((_totalCalificaciones / _totalCant).toStringAsFixed(2))
  });

  print(_calificacionPorTipo);
}
> 

  var nombres = {"Alberto", "Ana"};
  print(nombres); // {Alberto, Ana}
  nombres.add('José');
  print(nombres); // {Alberto, Ana, José}
  nombres.add('José');
  print(nombres); // {Alberto, Ana, José}

void main() { 
  var dicc = {
    'platzi':'plataforma en línea',
    'google':'web de busquedas'
  }; 
  print(dicc);  // Platzi, Google
  dicc.addAll({
    'bing': 'otro buscador'
  });
  print(dicc);  // Platzi, Google, Bing
} 

<void main() 
// variable para almacenar los tipos de restaurante con sus respectivas calificaciones.
{
  Set restaurantes = {
    {
      "nombre": "El novillo alegre",
      "tipo": "Argentina",
      "calificaciones": [4, 3, 1, 1, 5]
    },
    {
      "nombre": "Baires Grill",
      "tipo": "Argentina",
      "calificaciones": [4, 3, 2, 1, 1]
    },
    {
      "nombre": "Mario Brothers",
      "tipo": "Italiana",
      "calificaciones": [4, 5, 2, 1, 2]
    },
    {
      "nombre": "Molto bene",
      "tipo": "Italiana",
      "calificaciones": [3, 1, 3, 5, 5, 2, 3]
    }
  };
 // variables para almacenar totales segun tipo y promedio de todos 
  int sumaArg = 0;
  int sumaIta = 0;
  int suma = 0;
  int totalArg = 0;
  int totalIta = 0;
  int total = 0;
  double promedioIta = 0;
  double promedioArg = 0;
  double promedioTotal = 0;
 //calculo suma de cada tipo y promedio 
  for(int i = 0; i<restaurantes.length; i ++){
    if (restaurantes.elementAt(i)['tipo'] == 'Italiana'){
      List<int> calificacionesItal = restaurantes.elementAt(i)['calificaciones'];
      for (int i = 0; i<calificacionesItal.length; i++){
        sumaIta += calificacionesItal[i];
        totalIta += 1;
      } 
    }else{
      List<int> calificacionesArg = restaurantes.elementAt(i)['calificaciones'];
      for (int a = 0; a<calificacionesArg.length; a++){
        sumaArg += calificacionesArg[a];
        totalArg += 1;
      }
    }
  }
  promedioArg = sumaArg / totalArg;
  promedioIta = sumaIta / totalIta;
// se hace la suma de todos los tipos para adquirir el total 
  total = totalIta + totalArg;
  suma = sumaIta + sumaArg;
  promedioTotal = suma / total;
  
  Map <String, double> rating = {
    'Italiana': promedioIta,
    'Argentina': promedioArg,
    'Todos': promedioTotal
  };
  print(rating);
  
}> 

void main() {
  //Definimos el Set de Restaurantes
  Set restaurantes = {
    {
      "nombre": "El novillo alegre",
      "tipo": "Argentina",
      "calificaciones": [4,5,2,1,2]
      },
    {
      "nombre": "Baires Girls",
      "tipo": "Argentina",
      "calificaciones": [4,4,4,1,3,5]
      },
    {
      "nombre": "Mario Brothers",
      "tipo": "Italiana",
      "calificaciones": [5,5,4,5,3,5]
      },
    {
      "nombre": "Molto Bene",
      "tipo": "Italiana",
      "calificaciones": [5,4,4,3,3,2]
      },
    {
      "nombre": "Andres Carne de Res",
      "tipo": "Colombiana",
      "calificaciones": [5,5,4,3,5,5]
      },
    {
      "nombre": "SAPiens",
      "tipo": "Alemana",
      "calificaciones": [2,5,4,3,5,5]
      },
    {
      "nombre": "Los tacos",
      "tipo": "Mexicana",
      "calificaciones": [5,1,4,3,3,5]
      },
  };
  
  Map<String, dynamic> rating = {
    
  };
  
  //Variable para acumular todos los puntajes de todos los restaurantes
  double puntajeTotal = 0;
  //Variable para calcular el promedio de todos los restaurantes
  double promedioTodos = 0;
  String tipo = "";
  
  
  //Recorremos cada uno de los elementos del Set
  for (int r = 0; r < restaurantes.length; r++){
    //Se crea lista con el puntaje de cada restaurante
    List<int> puntajes = (restaurantes.elementAt(r)["calificaciones"]);
    
    //Variable para almacenar la suma del puntaje x restaurante
    int sumaPuntajeRes = 0;
    //Variable para calcular el promedio x restaurante
    double promRes = 0;
    
    for (int i=0; i < puntajes.length; i++) {
      sumaPuntajeRes += puntajes[i];
    }
    promRes = (sumaPuntajeRes / puntajes.length);
    
    tipo = (restaurantes.elementAt(r)["tipo"]);
    
    if (rating.containsKey(tipo)){
      //Si el restaurante ya esta en el mapa se debe acumular
      // y promediar el puntaje
      double puntajeAcumulado = rating[tipo] + promRes;
      rating.update(tipo, (value) => puntajeAcumulado/2);
    } else {
      //Si el restaurante no esta en el mapa se agrega,
      rating.addAll({tipo:promRes});
    }
  }
  
  //Recorro el Map y acumulo los puntajes
  rating.forEach((key, value){
    puntajeTotal += value;
  });
  
  //Calcular el promedio total
  
  promedioTodos = puntajeTotal / rating.length;
  //Almaceno la llave de Todos en el mapa
  rating.addAll({"Todos":promedioTodos});
  
  //Imprimo el Map final recorriendo uno a uno
  rating.forEach((key, value){
    print("Restaurante tipo: $key con un puntaje: $value");
  });
  
}

List calificacion = restaurante["calificaciones"];
int suma = 0;
for(int i=0; i<calificacion.length; i++){
   int calif = calificacion[i];
   suma = suma + calif;
}

Map valores = calculo[restaurante["tipo"]];
valores["suma"] = valores["suma"] + suma;
valores["cantidad"] = valores["cantidad"] + calificacion.length;

void main() {
  Set restaurantes = {
    {
      "nombre": "El novillo alegre",
      "tipo": "Argentina",
      "calificaciones": [4, 5, 2, 1, 2]
    },
    {
      "nombre": "Baires Grill",
      "tipo": "Argentina",
      "calificaciones": [3, 1, 3, 5, 5, 2, 3]
    },
    {
      "nombre": "Mario Brothers",
      "tipo": "Italiana",
      "calificaciones": [4, 3, 2, 1, 1]
    },
    {
      "nombre": "Molto bene",
      "tipo": "Italiana",
      "calificaciones": [4, 3, 1, 1, 5]
    }
  };
  
  // Declaramos e inicializamos el mapa que nos permitirá almacenar las calificaciones por tipo
  Map<String, List<int>> calificacionesPorTipo = {};

  //Iteramos en el Set de restaurantes
  for (Map rest in restaurantes) {
    String tipo = rest["tipo"];

    //Si variable tipo no se encuentra en el mapa acumuladoTipo se ingresa y se asigna una lista vacia
    if (!calificacionesPorTipo.containsKey(tipo)) {
      calificacionesPorTipo[tipo] = [];
    }

    //Ya sea que se encuentre o no en el mapa se añaden la lista de calificaciones que le corresponde a su tipo("Argentina, Italiana...")
    calificacionesPorTipo[tipo]!.addAll(rest["calificaciones"]);
    // Con ! le estamos diciendo al compilador: "Confía en mí, esto no será null"
  }

  //Con ayuda del bucle for incializamos las claves del mapa rating
  Map rating = {
    for (String tipo in calificacionesPorTipo.keys)
      tipo:
          //Accedemos al mapa a traves del tipo, con el metodo reduce() se realiza una suma acumulativa y esta se divide entre el tamaño de la lista
          calificacionesPorTipo[tipo]!
                  .reduce((sum, calificacion) => sum + calificacion) /
              calificacionesPorTipo[tipo]!.length
  };

  //Con el metodo expand() unimos todas las lista en una sola, para poder sacar el promedio
  double promedioTotal = calificacionesPorTipo.values
          .expand((calificaciones) => calificaciones)
          .reduce((sum, calificacion) => sum + calificacion) /
      calificacionesPorTipo.values
          .expand((calificaciones) => calificaciones)
          .length;

  //Se agrega la clave Todos con su repectivo valor que seria el promedio total
  rating["Todos"] = (promedioTotal).toStringAsFixed(2);

  print(rating);
}

```void main() {

&#x20; Set restaurantes = {

&#x20;   {

&#x20;     "nombre": "El novillo alegre",

&#x20;     "tipo": "Argentina",

&#x20;     "calificaciones": \[4, 5, 2, 1, 2]

&#x20;   },

&#x20;   {

&#x20;     "nombre": "Baires Grill",

&#x20;     "tipo": "Argentina",

&#x20;     "calificaciones": \[3, 1, 3, 5, 5, 2, 3]

&#x20;   },

&#x20;   {

&#x20;     "nombre": "Mario Brothers",

&#x20;     "tipo": "Italiana",

&#x20;     "calificaciones": \[4, 3, 2, 1, 1]

&#x20;   },

&#x20;   {

&#x20;     "nombre": "Molto bene",

&#x20;     "tipo": "Italiana",

&#x20;     "calificaciones": \[4, 3, 1, 1, 5]

&#x20;   }

&#x20; };

&#x20;&#x20;

&#x20; // Declaramos e inicializamos el mapa que nos permitirá almacenar las calificaciones por tipo

&#x20; Map\<String, List\<int>> calificacionesPorTipo = {};

&#x20; //Iteramos en el Set de restaurantes

&#x20; for (Map rest in restaurantes) {

&#x20;   String tipo = rest\["tipo"];

&#x20;   //Si variable tipo no se encuentra en el mapa acumuladoTipo se ingresa y se asigna una lista vacia

&#x20;   if (!calificacionesPorTipo.containsKey(tipo)) {

&#x20;     calificacionesPorTipo\[tipo] = \[];

&#x20;   }

&#x20;   //Ya sea que se encuentre o no en el mapa se añaden la lista de calificaciones que le corresponde a su tipo("Argentina, Italiana...")

&#x20;   calificacionesPorTipo\[tipo]!.addAll(rest\["calificaciones"]);

&#x20;   // Con ! le estamos diciendo al compilador: "Confía en mí, esto no será null"

&#x20; }

&#x20; //Con ayuda del bucle for incializamos las claves del mapa rating

&#x20; Map rating = {

&#x20;   for (String tipo in calificacionesPorTipo.keys)

&#x20;     tipo:

&#x20;         //Accedemos al mapa a traves del tipo, con el metodo reduce() se realiza una suma acumulativa y esta se divide entre el tamaño de la lista

&#x20;         calificacionesPorTipo\[tipo]!

&#x20;                 .reduce((sum, calificacion) => sum + calificacion) /

&#x20;             calificacionesPorTipo\[tipo]!.length

&#x20; };

&#x20; //Con el metodo expand() unimos todas las lista en una sola, para poder sacar el promedio

&#x20; double promedioTotal = calificacionesPorTipo.values

&#x20;         .expand((calificaciones) => calificaciones)

&#x20;         .reduce((sum, calificacion) => sum + calificacion) /

&#x20;     calificacionesPorTipo.values

&#x20;         .expand((calificaciones) => calificaciones)

&#x20;         .length;

&#x20; //Se agrega la clave Todos con su repectivo valor que seria el promedio total

&#x20; rating\["Todos"] = (promedioTotal).toStringAsFixed(2);

&#x20; print(rating);

}

void main() {
  List<Map<String, dynamic>> restaurants = [
    {
      "nombre": "El novillo alegre",
      "tipo": "Argentina",
      "calificaciones": [4, 5, 2, 1, 2]
    },
    {
      "nombre": "Baires Grill",
      "tipo": "Argentina",
      "calificaciones": [3, 1, 3, 5, 5, 2, 3]
    },
    {
      "nombre": "Mario Brothers",
      "tipo": "Italiana",
      "calificaciones": [4, 3, 2, 1, 1]
    },
    {
      "nombre": "Molto bene",
      "tipo": "Italiana",
      "calificaciones": [4, 3, 1, 1, 5]
    }
  ];
  
  // Step 1: Collect ratings by country
  Map<String, List<int>> countryRatings = {};
  
  for (var restaurant in restaurants) {
    String country = restaurant["tipo"];
    List<int> ratings = List<int>.from(restaurant["calificaciones"]);
    
    if (countryRatings.containsKey(country)) {
      countryRatings[country]?.addAll(ratings);
    } else {
      countryRatings[country] = ratings;
    }
  }

  // Step 2: Calculate average rating for each country
  Map<String, double> averageRatings = {};
  int totalSum = 0;
  int totalCount = 0;

  countryRatings.forEach((country, ratings) {
    double average = ratings.reduce((a, b) => a + b) / ratings.length;
    averageRatings[country] = average;

    totalSum += ratings.reduce((a, b) => a + b);
    totalCount += ratings.length;
  });
  
  // Step 3: Calculate the total average rating
  double totalAverage = totalSum / totalCount;
  averageRatings["Total"] = double.parse(totalAverage.toStringAsFixed(2));

  // Print the result
  print(averageRatings);
}
```void main() {

&#x20; List\<Map\<String, dynamic>> restaurants = \[

&#x20;   {

&#x20;     "nombre": "El novillo alegre",

&#x20;     "tipo": "Argentina",

&#x20;     "calificaciones": \[4, 5, 2, 1, 2]

&#x20;   },

&#x20;   {

&#x20;     "nombre": "Baires Grill",

&#x20;     "tipo": "Argentina",

&#x20;     "calificaciones": \[3, 1, 3, 5, 5, 2, 3]

&#x20;   },

&#x20;   {

&#x20;     "nombre": "Mario Brothers",

&#x20;     "tipo": "Italiana",

&#x20;     "calificaciones": \[4, 3, 2, 1, 1]

&#x20;   },

&#x20;   {

&#x20;     "nombre": "Molto bene",

&#x20;     "tipo": "Italiana",

&#x20;     "calificaciones": \[4, 3, 1, 1, 5]

&#x20;   }

&#x20; ];

&#x20;&#x20;

&#x20; // Step 1: Collect ratings by country

&#x20; Map\<String, List\<int>> countryRatings = {};

&#x20;&#x20;

&#x20; for (var restaurant in restaurants) {

&#x20;   String country = restaurant\["tipo"];

&#x20;   List\<int> ratings = List\<int>.from(restaurant\["calificaciones"]);

&#x20;  &#x20;

&#x20;   if (countryRatings.containsKey(country)) {

&#x20;     countryRatings\[country]?.addAll(ratings);

&#x20;   } else {

&#x20;     countryRatings\[country] = ratings;

&#x20;   }

&#x20; }



&#x20; // Step 2: Calculate average rating for each country

&#x20; Map\<String, double> averageRatings = {};

&#x20; int totalSum = 0;

&#x20; int totalCount = 0;



&#x20; countryRatings.forEach((country, ratings) {

&#x20;   double average = ratings.reduce((a, b) => a + b) / ratings.length;

&#x20;   averageRatings\[country] = average;



&#x20;   totalSum += ratings.reduce((a, b) => a + b);

&#x20;   totalCount += ratings.length;

&#x20; });

&#x20;&#x20;

&#x20; // Step 3: Calculate the total average rating

&#x20; double totalAverage = totalSum / totalCount;

&#x20; averageRatings\["Total"] = double.parse(totalAverage.toStringAsFixed(2));



&#x20; // Print the result

&#x20; print(averageRatings);

}

void main() {
  Set restaurantes = {
    {
      "nombre": "El novillo alegre",
      "tipo": "Italiana",
      "calificaciones": [4, 5, 2, 1, 2]
    },
    {
      "nombre": "Baires Grill",
      "tipo": "Italiana",
      "calificaciones": [3, 1, 3, 5, 5, 2, 3]
    },
    {
      "nombre": "Mario Brothers",
      "tipo": "Argentina",
      "calificaciones": [4, 3, 2, 1, 1]
    },
    {
      "nombre": "Molto bene",
      "tipo": "Argentina",
      "calificaciones": [4, 3, 1, 1, 5]
    }
  };

  Map ratings = {};
  List paises = [];

  for (int i = 0; i < restaurantes.length; i++) {
    if (i == 0) {
      ratings[restaurantes.elementAt(i)['tipo']] = (restaurantes.elementAt(i)['calificaciones']);
      paises.add(restaurantes.elementAt(i)['tipo']);
    } else {
      for (int x = 0; x < ratings.length; x++) {
        if (ratings.containsKey(restaurantes.elementAt(i)['tipo'])) {
          ratings[restaurantes.elementAt(i)['tipo']] += (restaurantes.elementAt(i)['calificaciones']);
        } else {
          paises.add(restaurantes.elementAt(i)['tipo']);
          ratings[restaurantes.elementAt(i)['tipo']] = (restaurantes.elementAt(i)['calificaciones']);
        }
      }
    }
  }
  
  for(int z=0; z < paises.length; z++){
    ratings[paises[z]] = (ratings[paises[z]].reduce((int v, int e) => v + e)/ratings[paises[z]].length);
  }

  print(ratings);
}

void main() {
  // Definimos el conjunto de restaurantes
  Set restaurantes = {
    {
      "nombre": "El novillo alegre",
      "tipo": "Argentina",
      "calificaciones": [4, 5, 2, 1, 2]
    },
    {
      "nombre": "Baires Grill",
      "tipo": "Argentina",
      "calificaciones": [3, 1, 3, 5, 5, 2, 3]
    },
    {
      "nombre": "Mario Brothers",
      "tipo": "Italiana",
      "calificaciones": [4, 3, 2, 1, 1]
    },
    {
      "nombre": "Molto bene",
      "tipo": "Italiana",
      "calificaciones": [4, 3, 1, 1, 5]
    }
  };

  //Definimos conjunto de rating y en cada llave ejecutamos la funcion enviandole los parametros definidos
  Map rating = {
    "Argentina": calcularPromedioDeCalificaciones(restaurantes, "Argentina"),
    "Italiana": calcularPromedioDeCalificaciones(restaurantes, "Italiana"),
    "Todos": ((calcularPromedioDeCalificaciones(restaurantes, "Argentina") +
            calcularPromedioDeCalificaciones(restaurantes, "Italiana")) /
        2)
  };

  // Imprimimos el promedio de las calificaciones obtenidas
  print(rating);
}

//Creamos funcion para calcular el promedio de las calificaciones por tipo
double calcularPromedioDeCalificaciones(restaurantes, String tipo) {
  // Inicializamos la variable para almacenar la suma de las calificaciones
  int sumaCalificaciones = 0;

  // Inicializamos la variable para almacenar la cantidad de calificaciones
  num cantidadDeCalificaciones = 0;

  // Inicializamos la variable para almacenar el promedio de calificaciones
  double promedioDeCalificaciones;

  // Recorremos el conjunto de restaurantes
  for (Map<String, dynamic> restaurante in restaurantes) {
    // Validamos si el tipo del restaurante coincide con el tipo recibido
    if (restaurante["tipo"] == tipo) {
      // Recorremos la lista de calificaciones del tipo
      for (int calificacion in restaurante["calificaciones"]) {
        // Sumamos la calificación a la variable
        sumaCalificaciones += calificacion;
      }
      // Sumamos la longitud de la lista de calificaciones
      cantidadDeCalificaciones += restaurante["calificaciones"].length;
    }
  }

  //Calculamos el promedio de las calificaciones
  promedioDeCalificaciones = sumaCalificaciones / cantidadDeCalificaciones;

  // Devolvemos el promedio de las calificaciones
  return promedioDeCalificaciones;
}
```Saludos.

void main() {
  Set restaurantes = {
    {
      "nombre": "El novillo alegre",
      "tipo": "Argentina",
      "calificaciones": [4, 5, 2, 1, 2]
    },
    {
      "nombre": "Baires Grill",
      "tipo": "Argentina",
      "calificaciones": [3, 1, 3, 5, 5, 2, 3]
    },
    {
      "nombre": "Mario Brothers",
      "tipo": "Italiana",
      "calificaciones": [4, 3, 2, 1, 1]
    },
    {
      "nombre": "Molto bene",
      "tipo": "Italiana",
      "calificaciones": [4, 3, 1, 1, 5]
    }
  };
  
  Set<String> tipos = {};
  
  for(var restaurante in restaurantes) {
    tipos.add(restaurante["tipo"]);
    
    print("////////////////////");
    for(String key in restaurante.keys) {
      if(key == "calificaciones") {
        print("$key: ${restaurante[key].reduce((int a, int b) => a + b) / restaurante[key].length}");
      } else {
        print("$key: ${restaurante[key]}");
      }
    }
    print("////////////////////\n");
  }
    
  double totalAvg = 0;
  print("====================");
  
  for(String tipo in tipos) {
    double avg = 0;
    int count = 0;
    for(var restaurante in restaurantes.where((x) => x["tipo"] == tipo)) {
      avg += restaurante["calificaciones"].reduce((int a, int b) => a + b) / restaurante["calificaciones"].length;
      count++;
    }
    totalAvg += avg / count;
    print("$tipo: ${avg / count}");
  }
  print("Todos: ${totalAvg / tipos.length}");
  print("====================");
}

Reto de colecciones

Introducción

Bienvenida al curso

Introducción de Dart

Introducción a DartPad

Las bases de programación

Variables

Tipos de datos básicos

Tipos de datos avanzados

Manipulación de variables

String con Dart

Conversión de tipos

Ejercicio sobre las bases de programación

Flujo de datos

Operaciones

Condicionales

Ciclos

Enumeraciones

¡Construye una calculadora!

Colecciones

Introducción a las colecciones

Colección de tipo Lista

Colección de tipo Sets

Colección de tipo Mapa

Colección de colecciones

Flujos dentro de colecciones

Reto de colecciones

Conclusión

Sigue aprendiendo Dart