public List <OperatorAsset> MoreEfficientAlgorithm()
{
// Build an OperatorID -> List<Assignments> dictionary
var opToAssignments = new Dictionary <int, List <Assignment> >();
foreach (Assignment assignment in _assignments)
{
if (!opToAssignments.ContainsKey(assignment.OperatorId))
{
opToAssignments.Add(assignment.OperatorId, new List <Assignment>());
}
opToAssignments[assignment.OperatorId].Add(assignment);
}
// Build the return list of operators
var retList = new List <OperatorAsset>();
foreach (Operator @operator in _operators)
{
var operatorAsset = new OperatorAsset(@operator);
if (opToAssignments.ContainsKey(@operator.OperatorId))
{
operatorAsset.Assignments = opToAssignments[@operator.OperatorId];
}
retList.Add(operatorAsset);
}
return(retList);
}
/// <summary>
/// Hiding the horrific run time with LINQ
/// </summary>
/// <returns></returns>
public List <OperatorAsset> IneffiecientLinqAlgorithm()
{
var retList = new List <OperatorAsset>();
foreach (Operator @operator in _operators)
{
var operatorAsset = new OperatorAsset(@operator);
var assignments = _assignments.Where(a => a.OperatorId == @operator.OperatorId);
operatorAsset.Assignments = assignments.ToList();
retList.Add(operatorAsset);
}
return(retList);
}
/// <summary>
/// Inputs:
/// 1. _operators (list of operators), call it n
/// 2. _assignments (list of assignments), call it m
/// Outputs:
/// Return back a list of OperatorAssets. Each OperatorAsset
/// contains an Operator and his assignments for the day.
/// </summary>
public List <OperatorAsset> InefficientAlgorithm()
{
var retList = new List <OperatorAsset>();
// What is the run time of this algorithm??
foreach (Operator @operator in _operators)
{
var operatorAsset = new OperatorAsset(@operator);
foreach (Assignment assignment in _assignments)
{
if (assignment.OperatorId == @operator.OperatorId)
{
operatorAsset.Assignments.Add(assignment);
}
}
retList.Add(operatorAsset);
}
return(retList);
}