public TaskProgress(BackpackTask backpackTask)
{
_backpackTask = backpackTask;
BackpackTaskId = backpackTask.Id;
_totalAmountOfWork = (int)Math.Round(Math.Pow(2, backpackTask.BackpackItems.Count) - 1);
_currentProgress = backpackTask.CombinationSets.Count;
}
private static void GenerateCombinationRecursive(BackpackTask backpackTask, List <Item> set, List <CombinationSet> result, TaskProgress service, CancellationToken token)
{
for (int i = 0; i < set.Count; i++)
{
if (token.IsCancellationRequested)
{
return;
}
List <Item> temp = new List <Item>(set.Where((s, index) => index != i));
if (temp.Count > 0 && !result.Where(l => l.ItemCombinations.Count == temp.Count).Any(l =>
{
List <Item> items = l.ItemCombinations.Select(argItemCombination => argItemCombination.Item).ToList();
return(items.SequenceEqual(temp));
}))
{
CombinationSet combinationSet = new CombinationSet {
ItemCombinations = temp.Select(item => new ItemCombination {
Item = item
}).ToList()
};
result.Add(combinationSet);
CalculateCombinationSet(backpackTask, combinationSet, service, token);
GenerateCombinationRecursive(backpackTask, temp, result, service, token);
}
}
}
static void Main(string[] args)
{
while (true)
{
Console.Clear();
Console.WriteLine(
"---------Меню---------\n" +
"1. Задача о рюкзаке\n" +
"2. RSA\n" +
"3. RSA .NET\n" +
"----------------------\n" +
"0. Выход"
);
Console.Write("> ");
string act = Console.ReadLine();
switch (act)
{
case "1": BackpackTask.backpackTask(); break;
case "2": RsaTask.myRSA(); break;
case "3": RsaDotNetTask.dotnetRSA(); break;
case "0": Environment.Exit(0); break;
default: Console.WriteLine("Неизвестная команда!"); break;
}
}
}
public async Task <string> NewBackpackTask(List <ItemDto> itemDtos, string taskName,
int backpackWeightLimit)
{
BackpackTask backpackTask = new BackpackTask
{
Name = taskName,
BackpackItems = Mapper.Map <List <ItemDto>, List <Item> >(itemDtos),
WeightLimit = backpackWeightLimit,
StartTime = DateTime.Now
};
var unitOfWork = UnitOfWork.UnitOfWorkFactory();
unitOfWork.BackpackTaskRepository.Add(backpackTask);
await unitOfWork.CompleteAsync();
return(backpackTask.Id);
}
public async Task ContinueBackpackTask_PassValidBackpackTask_ShouldComplete()
{
// arrange
List <ItemCombination> itemCombinations = new List <ItemCombination>();
itemCombinations.Add(new ItemCombination {
Item = _items[0]
});
itemCombinations.Add(new ItemCombination {
Item = _items[1]
});
BackpackTask backpackTask = new BackpackTask();
backpackTask.Id = "id";
backpackTask.Name = "ContinueTask";
backpackTask.WeightLimit = 8;
backpackTask.BackpackItems = _items;
backpackTask.CombinationSets = new List <CombinationSet>
{
new CombinationSet()
{
Id = "AlreadyExist1",
ItemCombinations = itemCombinations
},
};
BackpackTaskService service = new BackpackTaskService();
_unitOfWork.BackpackTaskRepository.Add(Arg.Do <BackpackTask>(bc => backpackTask = bc));
// act
_unitOfWork.BackpackTaskRepository.Get(Arg.Any <string>()).Returns(backpackTask);
await service.StartBackpackTask("id", CancellationToken.None);
// assert
// assert
Assert.AreEqual(31, backpackTask.CombinationSets.Count);
Assert.AreEqual(46500, backpackTask.BestItemSetPrice);
Assert.AreEqual(8, backpackTask.BestItemSetWeight);
Assert.AreEqual(3, backpackTask.BestItemSet.Count);
}
public async Task CreateNewBackpackTask_PassValidArgs_ShouldReturnBackpackTask()
{
// arrange
var taskName = "TaskName";
var weightLimit = 8;
BackpackTaskService service = new BackpackTaskService();
BackpackTask backpackTask = null;
_unitOfWork.BackpackTaskRepository.Add(Arg.Do <BackpackTask>(bc => backpackTask = bc));
// act
string id = await service.NewBackpackTask(_itemDtos, taskName, weightLimit);
// assert
Assert.NotNull(id);
Assert.NotNull(backpackTask);
Assert.AreEqual(taskName, backpackTask.Name);
Assert.AreEqual(weightLimit, backpackTask.WeightLimit);
Assert.AreEqual(_itemDtos.Count, backpackTask.BackpackItems.Count);
}
private static void CalculateCombinationSet(BackpackTask backpackTask, CombinationSet set,
TaskProgress service, CancellationToken token)
{
if (token.IsCancellationRequested)
{
return;
}
// iterate over all item combinations
// calculate total weight and price of current item set
var totalWeight = 0;
var totalPrice = 0;
foreach (var itemCombination in set.ItemCombinations)
{
totalWeight += itemCombination.Item.Weight;
totalPrice += itemCombination.Item.Price;
}
// check if we ok with totalWeight and current price of item set is greater that current best item set price
if (totalWeight <= backpackTask.WeightLimit &&
totalPrice > backpackTask.BestItemSetPrice)
{
// update current solution
backpackTask.BestItemSetPrice = totalPrice;
backpackTask.BestItemSetWeight = totalWeight;
List <Item> items = new List <Item>();
foreach (var itemCombo in set.ItemCombinations)
{
items.Add(itemCombo.Item);
}
backpackTask.BestItemSet = new List <BestItemSet>();
foreach (var item in items)
{
backpackTask.BestItemSet.Add(new BestItemSet()
{
Item = item
});
}
}
service.UpdateProgress();
}
public async Task StartBackpackTask(string id, CancellationToken token)
{
var unitOfWork = UnitOfWork.UnitOfWorkFactory();
BackpackTask backpackTask = unitOfWork.BackpackTaskRepository.Get(id);
TaskProgress taskProgress = new TaskProgress(backpackTask);
CalculationService.StartCalculation(backpackTask, taskProgress, token);
if (token.IsCancellationRequested)
{
await unitOfWork.CompleteAsync();
return;
}
backpackTask.EndTime = DateTime.Now;
backpackTask.Complete = true;
unitOfWork.CombinationSetRepository.RemoveRange(backpackTask.CombinationSets);
await unitOfWork.CompleteAsync();
}
public static void StartCalculation(BackpackTask backpackTask, TaskProgress service, CancellationToken token)
{
List <Item> set = backpackTask.BackpackItems;
List <CombinationSet> result = backpackTask.CombinationSets;
if (set.Count > 0 && !result.Where(l => l.ItemCombinations.Count == set.Count).Any(l =>
{
List <Item> items = l.ItemCombinations.Select(argItemCombination => argItemCombination.Item).ToList();
return(items.SequenceEqual(set));
}))
{
CombinationSet combinationSet = new CombinationSet {
ItemCombinations = set.Select(item => new ItemCombination {
Item = item
}).ToList()
};
result.Add(combinationSet);
CalculateCombinationSet(backpackTask, combinationSet, service, token);
}
GenerateCombinationRecursive(backpackTask, set, result, service, token);
}
public async Task StartBackpackTask_PassValidBackpackTask_ShouldCalculateCorrect()
{
// arrange
var taskName = "TaskName";
var weightLimit = 8;
BackpackTaskService service = new BackpackTaskService();
BackpackTask backpackTask = null;
_unitOfWork.BackpackTaskRepository.Add(Arg.Do <BackpackTask>(bc => backpackTask = bc));
string backpackTaskId = await service.NewBackpackTask(_itemDtos, taskName, weightLimit);
// act
_unitOfWork.BackpackTaskRepository.Get(Arg.Any <string>()).Returns(backpackTask);
await service.StartBackpackTask(backpackTaskId, CancellationToken.None);
// assert
// assert
Assert.AreEqual(31, backpackTask.CombinationSets.Count);
// Assert.AreEqual(46500, backpackTask.BestItemSetPrice);
Assert.AreEqual(weightLimit, backpackTask.BestItemSetWeight);
Assert.AreEqual(3, backpackTask.BestItemSet.Count);
Assert.IsTrue(backpackTask.Complete);
}
public void Remove(BackpackTask backpackTask)
{
_context.BackpackTasks.Remove(backpackTask);
}
public void Add(BackpackTask backpackTask)
{
_context.BackpackTasks.Add(backpackTask);
}
public string OloloPost([FromBody] BackpackTask someName)
{
return("OK");
}
