Reto de colecciones

22/23

Lectura

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

Captura de Pantalla 2021-12-27 a la(s) 13.35.56.png

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 = {

{
鈥渘ombre鈥: 鈥淓l novillo alegre鈥,
鈥渢ipo鈥: 鈥淎rgentina鈥,
鈥渃alificaciones鈥: [4, 5, 2, 1, 2]
},

{
鈥渘ombre鈥: 鈥淏aires Grill鈥,
鈥渢ipo鈥: 鈥淎rgentina鈥,
鈥渃alificaciones鈥: [3, 1, 3, 5, 5, 2, 3]
},

{
鈥渘ombre鈥: 鈥淢ario Brothers鈥,
鈥渢ipo鈥: 鈥淚taliana鈥,
鈥渃alificaciones鈥: [4, 3, 2, 1, 1]
},

{
鈥渘ombre鈥: 鈥淢olto bene鈥,
鈥渢ipo鈥: 鈥淚taliana鈥,
鈥渃alificaciones鈥: [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 = {
鈥淚taliana鈥: 3.0,
鈥淎rgentina鈥: 2.5,
鈥淭odos鈥: 2.77
};

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

隆Comparte tu c贸digo!

Aportes 17

Preguntas 1

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesi贸n.

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

</*
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);
}
> 

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

}

Hola Darters!! Les comparto mi c贸digo:


C贸digo Fuente:

void main() {
Map<String, dynamic> r1 = {
鈥渘ombre鈥: 鈥淓l novillo alegre鈥,
鈥渢ipo鈥: 鈥淎rgentina鈥,
鈥渃alificaciones鈥: [4, 5, 2, 1, 2]
};

Map<String, dynamic> r2 = {
鈥渘ombre鈥: 鈥淏aires Grill鈥,
鈥渢ipo鈥: 鈥淎rgentina鈥,
鈥渃alificaciones鈥: [3, 1, 3, 5, 5, 2, 3],
};

Map<String, dynamic> r3 = {
鈥渘ombre鈥: 鈥淢ario Brothers鈥,
鈥渢ipo鈥: 鈥淚taliana鈥,
鈥渃alificaciones鈥: [4, 3, 2, 1, 1],
};

Map<String, dynamic> r4 = {
鈥渘ombre鈥: 鈥淢olto bene鈥,
鈥渢ipo鈥: 鈥淚taliana鈥,
鈥渃alificaciones鈥: [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庐.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 = {
鈥淚taliana鈥: avgIta,
鈥淎rgentina鈥: avgArg,
鈥淭odos鈥: avgTot.toStringAsPrecision(3)
};
print(rating);

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

Aqu铆 est谩 mi respuesta a este reto:

Les comparto mi desarrollo:

Est谩 fue 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]
    }
  };
  Map restaurante = {};
  List<int> scoresArgentina = [];
  List<int> scoresItaliana = [];
  int sumaArg = 0;
  int sumaIta = 0;
  //Obtenci贸n de los promedios por tipo.
  for (int i = 0; i < restaurantes.length; i++) {
    restaurante.addAll(restaurantes.elementAt(i));
    if (restaurante['tipo'] == 'Argentina') {
      scoresArgentina.addAll(restaurante['calificaciones']);
    } else {
      scoresItaliana.addAll(restaurante['calificaciones']);
    }
  }
  for(int i = 0; i < scoresArgentina.length; i++) {
    sumaArg += scoresArgentina[i];
  }
  for(int i = 0; i < scoresItaliana.length; i++) {
    sumaIta += scoresItaliana[i];
  }
  double promArgentina = sumaArg / scoresArgentina.length;
  double promItaliana = sumaIta / scoresItaliana.length;
  print('El promedio de argentina es: $promArgentina');
  print('El promedio de italiana es: $promItaliana');
  //Obtenci贸n de todo el promedio.
  List<int> scoresAll = [...scoresArgentina, ...scoresItaliana];
  int sum = 0;
  for(int i = 0; i < scoresAll.length; i++) {
    sum += scoresAll[i];
  }
  double promTotal = sum / scoresAll.length;
  print('El promedio total es: $promTotal');
  Map rating = {};
  rating.addAll({
    'Argentina' : promArgentina,
    'Italiana' : promItaliana,
    'Total' : promTotal
  });
  print('Rating = $rating');
}

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 tipos = {};
  Map rating = {};
  List total = [];
  double promedioTotal = 0;
  
  for(var restaurante in restaurantes){
      tipos.add(restaurante["tipo"]);
  }
  for(var tipo in tipos){
    List <int> calificaciones = [];
    int cantidadTotal = 0;
    double promedio = 0;
    print(tipo);
    for(var restaurante in restaurantes){
      if(restaurante["tipo"] == tipo) {
        calificaciones.addAll(restaurante["calificaciones"]);
      }
    }
    total.addAll(calificaciones);
    cantidadTotal = calificaciones.reduce((cantidad, valor) => cantidad + valor);
    promedio = cantidadTotal / calificaciones.length;
    print(promedio);
    rating.addAll({tipo: promedio}); 
  }
  
  promedioTotal = total.reduce((cantidad,valor) => cantidad + valor)/ total.length;
  rating.addAll({"Todos": promedioTotal});
  print(rating);
  
}
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]
    }
  };
  
  int sumArg = 0;
  int cantArg = 0;
  double avgArg = 0;
  int sumIt = 0;
  int cantIt= 0;
  double avgIt = 0;
  double avgAll = 0;
  
  Map<String,dynamic> rating = {
  };
  
  for(int i = 0; i < restaurantes.length; i++){
    Map<String,dynamic> restaurante = restaurantes.elementAt(i);
    
    if(restaurante["tipo"] == "Argentina"){
      
      List<int> calificaciones = restaurante["calificaciones"];
      
      cantArg += calificaciones.length;
      
      for(int i = 0; i<calificaciones.length;i++){
        sumArg += calificaciones[i];
      }  
    } else if(restaurante["tipo"] == "Italiana"){
      
      List<int> calificacionesIt = restaurante["calificaciones"];
      
      cantIt += calificacionesIt.length;
      
      for(int i = 0; i<calificacionesIt.length;i++){
        sumIt += calificacionesIt[i];
    }
      
  }
    else{
        print("No es de tipo argentino ni Italiano");
      }
}
  
  print(cantArg);
    print(cantIt);
  print(sumArg);
  print(sumIt);
  avgArg = sumArg/cantArg;
  avgIt = sumIt/cantIt;
  avgAll = (avgArg + avgIt) / 2;
    
    rating.addAll(
      {
        "Italiana":avgIt,
        "Argentina":avgArg,
        "Todos":avgAll
      }
    );
    
    print(rating); 
}
void main() {
  Set rests = {
    {
      "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]
    }
  };

  dynamic sArg = 0;
  dynamic lArgum = 0;
  dynamic avgArg = 0;

  dynamic sumaIt = 0;
  dynamic longItCal = 0;
  double avgIt = 0;

  double avgTotal = 0;

  Map<dynamic, dynamic> rating = {};

  for (int i = 0; i < rests.length; i++) {
    Map<String, dynamic> rest = rests.elementAt(i);
    if (rest["tipo"] == "Argentina") {
      List<int> calificaciones = rest["calificaciones"];
      lArgum += calificaciones.length;

      for (int i = 0; i < calificaciones.length; i++) {
        sArg += calificaciones[i];
      }
    } else if (rest["tipo"] == "Italiana") {
      List<int> calificacionesIt = rest["calificaciones"];
      longItCal += calificacionesIt.length;

      for (int i = 0; i < calificacionesIt.length; i++) {
        sumaIt += calificacionesIt[i];
      }
    }
  }
  avgArg = sArg / lArgum;
  avgIt = sumaIt / longItCal;
  avgTotal = avgArg + avgIt / 2;

  rating.addAll({"Italiana": avgIt, "Argentina": avgArg, "Todos": avgTotal});

  print(rating);
}

Mi solucion. Funciona agregando mas tipos de comida o mas calificaciones.

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, 5, 5]
    },

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

    {
    "nombre": "Molto bene",
    "tipo": "Italiana",
    "calificaciones": [4, 3, 1, 1, 5]
    }
  };
  
  Map rating = {};
  double promTodos = 0;
  
  void CompareRating(String typeOfFood, double prom){
    
    if(rating[typeOfFood] < prom){
        rating[typeOfFood] = prom;
    }
  }
  
  for(int i = 0; i < restaurantes.length; i++){
    
    var colecction = restaurantes.elementAt(i);
    
    List<int> calificaciones = colecction["calificaciones"];
    int sum = 0;
    
    for(int i = 0; i < calificaciones.length; i++){
      sum += calificaciones[i];
    }
    double prom = sum / calificaciones.length;
    
    //Reducimos los decimales a 1
    prom = double.parse((prom.toStringAsFixed(1)));
    
    if(rating.containsValue(colecction["tipo"])){
      CompareRating(colecction["tipo"], prom);
    }else{
      rating.addAll({colecction["tipo"]: prom});
    }
  }
  
  for (var r in rating.entries) {
    promTodos += r.value;
  }
  
  promTodos = double.parse((promTodos.toStringAsFixed(1)));
  rating.addAll({"Todos": promTodos});
   
  print(rating);

}

Soluci贸n que no considera los cambios de tipo de comida (no es robusta).

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]
    }
  };
  List tipo1 = [];
  List tipo2 = [];
  List todos = [];
  Map rating = {};

  for (int i = 0; i < restaurantes.length; i ++){
    if (restaurantes.elementAt(i)["tipo"] == "Argentina"){
      tipo1.addAll(restaurantes.elementAt(i)["calificaciones"]);
      todos.addAll(restaurantes.elementAt(i)["calificaciones"]);
      rating[restaurantes.elementAt(i)["tipo"]] = tipo1;
    }
    else if (restaurantes.elementAt(i)["tipo"] == "Italiana"){
      tipo2.addAll(restaurantes.elementAt(i)["calificaciones"]);
      todos.addAll(restaurantes.elementAt(i)["calificaciones"]);
      rating[restaurantes.elementAt(i)["tipo"]] = tipo2;
    }
  }
  rating.forEach((k,v) => print("$k:${v.reduce(( sum, star) => sum + star) /
                 v.length}"));
  print("Todos:${todos.reduce((sum,val) => sum + val) / todos.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]
    }
  };

  Map<String, num> rating = {};
  int contadorDeCalificaciones = 0;

  for (var restaurante in restaurantes) {
    String tipoDeRestaurante = restaurante["tipo"];
    List<int> calificaciones = restaurante["calificaciones"];
    contadorDeCalificaciones += calificaciones.length;
    String calificacionesKey = "numeroDeCalificaciones$tipoDeRestaurante";

    rating[calificacionesKey] =
        calificaciones.length + (rating[calificacionesKey] ?? 0);

    if (rating[tipoDeRestaurante] == null) {
      rating[tipoDeRestaurante] =
          calificaciones.reduce((int sum, int start) => sum + start);
    } else {
      rating[tipoDeRestaurante] =
          calificaciones.reduce((int sum, int start) => sum + start) +
              (rating[tipoDeRestaurante] ?? 0);
    }
  }

  rating.addAll({"Todos": 0.0});
  rating.forEach((key, value) {
    String calificacionesTag = 'numeroDeCalificaciones';
    if (key != "Todos" && !key.startsWith(calificacionesTag)) {
      rating[key] = value / (rating["$calificacionesTag$key"] ?? 0);
      rating["Todos"] = value + (rating["Todos"] ?? 0);
    }
  });
  rating.removeWhere((key, value) => key.startsWith('numeroDeCalificaciones'));

  rating["Todos"] = double.parse(
      (rating["Todos"]! / contadorDeCalificaciones).toStringAsFixed(2));

  print(rating);
}

print(restaurantes);

Map rating = {};

double sumaI = 0;
int cantidadI = 0;
double promedioI = 0;

double sumaA = 0;
int cantidadA = 0;
double promedioA = 0;

double promedioTodos = 0;

for (int i = 0; i < restaurantes.length; i++) {
Map restaurante = restaurantes.elementAt(i);
List<int> calificaciones = restaurante[鈥渃alificaciones鈥漖;

String tipo = restaurante["tipo"];

for(int j = 0; j < calificaciones.length; j++){
  if (tipo == "Italiana") {
    sumaI += calificaciones[j];
  } else {
    sumaA += calificaciones[j];
  }
}

if (tipo == "Italiana") {
  cantidadI += calificaciones.length;
} else {
  cantidadA += calificaciones.length;
}

print("$tipo = $calificaciones");

}

promedioI = sumaI / cantidadI;
promedioA = sumaA / cantidadA;
promedioTodos = (sumaI + sumaA) / (cantidadI + cantidadA);

rating.addAll({
鈥淚taliana鈥: promedioI,
鈥淎rgentina鈥: promedioA,
鈥淭odos鈥: promedioTodos
});

print(rating);

Mi c贸digo: Me di贸 pereza hacerlo mas corto 馃槂

<void main() {
  Map<String, dynamic> restaurante1 = {
    "nombre": "El novillo alegre",
    "tipo": "Argentina",
    "calificaciones": [4, 5, 2, 1, 2],
  };
  
  Map<String, dynamic> restaurante2 = {
    "nombre": "Baires Grill",
    "tipo": "Argentina",
    "calificaciones": [3, 1, 3, 5, 5, 2, 3],
  };
  
  Map<String, dynamic> restaurante3 = {
    "nombre": "Mario Brothers",
    "tipo": "Italiana",
    "calificaciones": [4, 3, 2, 1, 1],
  };
  
  Map<String, dynamic> restaurante4 = {
    "nombre": "Molto bene",
    "tipo": "Italiana",
    "calificaciones": [4, 3, 1, 1, 5],
  };
  
  int suma1 = 0;
  int suma2 = 0;
  int suma3 = 0;
  int suma4 = 0;
  
  int sumaTipoArgentina = 0;
  int sumaTipoItaliana = 0;
  
  List<int> estrellas1 = restaurante1["calificaciones"];
  for(int i = 0; i < estrellas1.length; i++) {
    suma1 += estrellas1[i];
  } if (restaurante1["tipo"] == "Argentina") {
    sumaTipoArgentina += suma1;
  } else {
    sumaTipoItaliana += suma1;
  }
  
  List<int> estrellas2 = restaurante2["calificaciones"];
  for(int i = 0; i < estrellas2.length; i++) {
      suma2 += estrellas2[i];
  } if (restaurante2["tipo"] == "Argentina") {
    sumaTipoArgentina += suma2;
  } else {
    sumaTipoItaliana += suma2;
  }
  
  List<int> estrellas3 = restaurante3["calificaciones"];
  for(int i = 0; i < estrellas3.length; i++) {
      suma3 += estrellas3[i];
  } if (restaurante3["tipo"] == "Argentina") {
    sumaTipoArgentina += suma3;
  } else {
    sumaTipoItaliana += suma3;
  }
  
  List<int> estrellas4 = restaurante4["calificaciones"];
  for(int i = 0; i < estrellas4.length; i++) {
      suma4 += estrellas4[i];
  } if (restaurante4["tipo"] == "Argentina") {
    sumaTipoArgentina += suma4;
  } else {
    sumaTipoItaliana += suma4;
  }
  
  List<int> tipoArgentina = [
    if (restaurante1["tipo"] == "Argentina") 
      ...estrellas1,
    if (restaurante2["tipo"] == "Argentina") 
      ...estrellas2,
    if (restaurante3["tipo"] == "Argentina") 
      ...estrellas3,
    if (restaurante4["tipo"] == "Argentina") 
      ...estrellas4,
  ];
  
  List<int> tipoItaliana = [
    if (restaurante1["tipo"] == "Italiana") 
      ...estrellas1,
    if (restaurante2["tipo"] == "Italiana") 
      ...estrellas2,
    if (restaurante3["tipo"] == "Italiana") 
      ...estrellas3,
    if (restaurante4["tipo"] == "Italiana") 
      ...estrellas4,
  ];
  
  int calificacionTotal = sumaTipoArgentina + sumaTipoItaliana;
  List<int> cantidadCalificaciones = [
    ...tipoArgentina,
    ...tipoItaliana
  ];
  
  double promedioArgentino = sumaTipoArgentina/tipoArgentina.length;
  print("El promedio de calificaci贸n para los restaurantes de tipo Argentino es: $promedioArgentino");
  
  double promedioItaliano = sumaTipoItaliana/tipoItaliana.length;
  print("El promedio de calificaci贸n para los restaurantes de tipo Argentino es: $promedioItaliano");
  
  double promedioTotal = calificacionTotal/cantidadCalificaciones.length;
  print("El promedio de calificaci贸n para todos los restaurantes es: $promedioTotal");
}
> 

void main() {

Set restaurantes = {
{
鈥渘ombre鈥:鈥淓l novillo alegre鈥,
鈥渢ipo鈥:鈥淎rgentina鈥,
鈥渃alificaciones鈥:[4,5,2,1,2]
},
{
鈥渘ombre鈥:鈥淢ario Brothers鈥,
鈥渢ipo鈥:鈥淚taliana鈥,
鈥渃alificaciones鈥:[4, 3, 2, 1, 1]
},
{
鈥渘ombre鈥:鈥淢olto bene鈥,
鈥渢ipo鈥:鈥淚taliana鈥,
鈥渃alificaciones鈥:[4, 3, 1, 1, 5]
}
};
print(restaurantes);

Map calculo = {};

for(Map restaurante in restaurantes){
if(!calculo.containsKey(restaurante[鈥渢ipo鈥漖)){
calculo.addAll({restaurante[鈥渢ipo鈥漖:
{
鈥渟uma鈥 : 0,
鈥渃antidad鈥 : 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[鈥渟uma鈥漖/aux[鈥渃antidad鈥漖)});
}

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

rating.addAll({鈥淭odos鈥:promedio});
print(rating);
}