public override async Task <Result> Resolve(ProblemStatement input)
{
var stopWatch = Stopwatch.StartNew();
var smallestPizza = input.PizzaTypes.Select(type => type.Slices).Min();
var maxSlices = input.MaximumNumberOfSlices;
var pizzas = input.PizzaTypes;
var currentSlices = 0;
var orderedPizzas = new List <int>();
while (currentSlices < maxSlices)
{
PizzaType pizzaToUse = null;
var possiblePizzas = pizzas.Where(pizza => pizza.Slices <= maxSlices - currentSlices).ToList();
pizzaToUse = possiblePizzas.LastOrDefault();
//if (possiblePizzas.Count >= 2)
//{
// pizzaToUse = possiblePizzas[possiblePizzas.Count - 2];
//} else if (possiblePizzas.Count == 1)
//{
// pizzaToUse = possiblePizzas.First();
//}
if (pizzaToUse is null)
{
break;
}
pizzas.Remove(pizzaToUse);
orderedPizzas.Add(pizzaToUse.Type);
currentSlices += pizzaToUse.Slices;
}
var result = await Task.FromResult(new Result(orderedPizzas));
_logger.LogInformation("Resolved by MDW in {0}s", (float)stopWatch.ElapsedMilliseconds / 1000);
_logger.LogInformation("Rest is {0} slices when smallest item in set is {1}", maxSlices - currentSlices, smallestPizza);
return(result);
}
protected void contentsParams_Deactivate(object sender, EventArgs e)
{
ProblemStatement ps = new ProblemStatement();
ps.Author = authorTB.Text;
ps.InputFormat = inputFormatTB.Text;
ps.OutputFormat = outputFormatTB.Text;
ps.InputSample = inputSampleTB.Text;
ps.OutputSample = outputSampleTB.Text;
ps.Text = textTB.Text;
problem.Statement = ps;
problem.Name = nameTB.Text;
problem.Store();
}
public void LockedTest2()
{
var problemStatement = new ProblemStatement
{
chores = new List <ChoreCore>
{
createChore("c1", 1, 2, 3, 3, "u2"),
createChore("c2", 2, 2, 3, 3),
createChore("c3", 1, 1, 1, 3),
createChore("c4", 2, 3, 3, 2),
createChore("c7", 2, 1, 2, 3)
},
users = new List <UserCore>
{
new UserCore
{
userId = "u1",
shareOfChoresPercent = 0.2
},
new UserCore
{
userId = "u2",
shareOfChoresPercent = 0.3
},
new UserCore
{
userId = "u3",
shareOfChoresPercent = 0.4
},
new UserCore
{
userId = "u4",
shareOfChoresPercent = 0.1
},
}
};
var assService = new AssignmentService();
var result1 = assService.Solve(problemStatement);
Assert.Equal(1, result1.Item1.TotalDiff);
}
public void Test()
{
var problemStatement = new ProblemStatement
{
chores = new List <ChoreCore>
{
createChore("c1", 1, 2, 3),
createChore("c2", 2, 2, 3),
createChore("c3", 1, 1, 1),
createChore("c4", 3, 2, 2),
createChore("c5", 1, 2, 1),
createChore("c6", 1, 2, 2),
createChore("c7", 2, 1, 2)
},
users = new List <UserCore>
{
new UserCore
{
userId = "u1",
shareOfChoresPercent = 0.33333
},
new UserCore
{
userId = "u2",
shareOfChoresPercent = 0.111111
},
new UserCore
{
userId = "u3",
shareOfChoresPercent = 0.666666
},
}
};
var assService = new AssignmentService();
var result1 = assService.GetBuckets(problemStatement.users, problemStatement.chores);
Assert.Equal(3, result1.Count());
}
public Problem(IServiceProvider serviceProvider, ApplicationDbContext dbContext, Model.Problem model) : base(serviceProvider, dbContext, model)
{
this.statement = MessagePackSerializer.Deserialize <ProblemStatement>(model._Statement);
this.submissionProvider = ServiceProvider.GetRequiredService <ProblemSubmissionProvider>();
}
public ActionResult <Solution> Post([FromBody] ProblemStatement problem)
{
var(solution, _) = _assignmentService.Solve(problem);
return(new OkObjectResult(solution));
}
public (Solution, MetaData) Solve(ProblemStatement problemStatement, bool print = false)
{
//clean data - users might not have effort ratings - add locked chores to user - and shares might be missing
foreach (var chore in problemStatement.chores)
{
foreach (var user in problemStatement.users)
{
var effortRating = chore.effortRatings.FirstOrDefault(e => e.userId == user.userId);
if (effortRating == null)
{
chore.effortRatings.Add(new EffortRating
{
userId = user.userId,
effort = chore.effortRatings.Min(e => e.effort)
});
}
if (!problemStatement.CustomShareOfChores)
{
user.shareOfChoresPercent = 1.0 / (double)problemStatement.users.Count();
}
user.lockedChores = problemStatement.chores.Where(c => c.lockedToUserId == user.userId).ToArray();
var exactActualEffort = problemStatement.chores.Sum(c => c.effort) * user.shareOfChoresPercent;
var percentAfterMyLockedChores = (1 - (user.lockedChores.Sum(c => c.effort) / exactActualEffort)) * user.shareOfChoresPercent;
user.percentAfterMyLockedChores = percentAfterMyLockedChores > 0 ? percentAfterMyLockedChores : 0;
}
}
//Adjust problem after locked chores
var usersToSolve = problemStatement.users.Where(u => u.percentAfterMyLockedChores > 0);
var usersFullOfChores = problemStatement.users.Where(u => u.percentAfterMyLockedChores == 0);
var choresToSolve = problemStatement.chores.Select(c => c);
var sumOfSharePercentAfterLocked = problemStatement.users.Sum(u => u.percentAfterMyLockedChores);
var adjustRatio = 1 / sumOfSharePercentAfterLocked;
foreach (var user in usersToSolve)
{
user.shareOfChoresPercent = user.percentAfterMyLockedChores * adjustRatio;
}
foreach (var chore in choresToSolve)
{
chore.effortRatings = chore.effortRatings.Where(e => !usersFullOfChores.Any(u => u.userId == e.userId)).ToList();
}
choresToSolve = choresToSolve.Where(c => string.IsNullOrEmpty(c.lockedToUserId));
var solutions = new List <Solution>();
if (choresToSolve.Count() != 0)
{
var bucketsPermutations = GetBuckets(usersToSolve, choresToSolve);
foreach (var buckets in bucketsPermutations)
{
Debug.WriteLine($"Solving for permutation {buckets.Select(kvp => kvp.Value).ToArray()}:");
var(solution, metadata) = SolveForBuckets(choresToSolve.ToArray(), usersToSolve.ToArray(), buckets, print);
if (solution.IsPerfect)
{
return(solution, metadata);
}
solutions.Add(solution);
}
}
else
{
//All chores locked, just add a empty solution
solutions.Add(new Solution
{
choreToUserMap = new List <KeyValuePair <string, string> >()
});
}
var bestSolution = solutions.OrderBy(s => s.TotalDiff).ThenBy(s => s.MaximumDiff).First();
foreach (var user in problemStatement.users)
{
foreach (var chore in user.lockedChores)
{
bestSolution.choreToUserMap.Add(new KeyValuePair <string, string>(user.userId, chore.choreId));
}
}
return(bestSolution, null);
}
