public IActionResult OnPost(AnswerIn answerIn)
{
if (ModelState.IsValid)
{
try
{
var container = new ProblemContainer();
answerIn.IsCorrect = container.IsProblemSolved(answerIn.ProblemId, answerIn.Answer);
_databaseRepository.SaveAnswer(answerIn);
if (answerIn.IsCorrect)
{
return(RedirectToPage(@"Correct"));
}
else
{
return(RedirectToPage(@"Incorrect"));
}
}
catch (Exception ex)
{
ModelState.AddModelError("error", ex.Message);
}
}
return(Page());
}
public ProblemContainer CompleteProblem()
{
ProblemContainer pc = new ProblemContainer()
{
Number = 28,
Task = content,
Cases = new List <CaseContainer>()
};
pc.Cases.Add(new CaseContainer
{
Task = "Сумма чисел в диагоналях спирали 5 на 5, образованной таким же способом.",
Result = Calculate(5).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(Calculate5)
});
pc.Cases.Add(new CaseContainer
{
Task = "Сумма чисел в диагоналях спирали 1001 на 1001, образованной таким же способом.",
Result = Calculate(1001).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(Calculate1001)
});
return(pc);
}
public ProblemContainer CompleteProblem()
{
ProblemContainer pc = new ProblemContainer()
{
Number = 1,
Task = content,
Cases = new List <CaseContainer>()
};
pc.Cases.Add(new CaseContainer
{
Task = "Сумма всех натуральных чисел меньше 10, кратных 3 или 5.",
Result = Calculate(10).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(Calculate10)
});
pc.Cases.Add(new CaseContainer
{
Task = "Сумма всех натуральных чисел меньше 1000, кратных 3 или 5.",
Result = Calculate(1000).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(Calculate1000)
});
return(pc);
}
public ProblemContainer CompleteProblem()
{
ProblemContainer pc = new ProblemContainer()
{
Number = 10,
Task = content,
Cases = new List <CaseContainer>()
};
pc.Cases.Add(new CaseContainer
{
Task = "Сумма простых чисел меньше 10.",
Result = Calculate(10).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(Calculate10)
});
pc.Cases.Add(new CaseContainer
{
Task = "Сумма простых чисел меньше двух миллионов.",
Result = Calculate(2000000).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(Calculate2000000)
});
return(pc);
}
public ProblemContainer CompleteProblem()
{
ProblemContainer pc = new ProblemContainer()
{
Number = 2,
Task = content,
Cases = new List <CaseContainer>()
};
pc.Cases.Add(new CaseContainer
{
Task = "Сумма всех четных чисел ряда Фибоначи не превыщающих 10.",
Result = Calculate(10).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(Calculate10)
});
pc.Cases.Add(new CaseContainer
{
Task = "Сумма всех четных чисел ряда Фибоначи не превыщающих 4000000.",
Result = Calculate(4000000).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(Calculate4000000)
});
return(pc);
}
public ProblemContainer CompleteProblem()
{
ProblemContainer pc = new ProblemContainer()
{
Number = 25,
Task = content,
Cases = new List <CaseContainer>()
};
pc.Cases.Add(new CaseContainer
{
Task = "Какова порядковый номер первого члена последовательности Фибоначчи, содержащего 3 цифры.",
Result = Calculate(3).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(Calculate3)
});
pc.Cases.Add(new CaseContainer
{
Task = "Какова порядковый номер первого члена последовательности Фибоначчи, содержащего 1000 цифр.",
Result = Calculate(1000).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(Calculate1000)
});
return(pc);
}
public ProblemContainer CompleteProblem()
{
ProblemContainer pc = new ProblemContainer()
{
Number = 3,
Task = content,
Cases = new List <CaseContainer>()
};
pc.Cases.Add(new CaseContainer
{
Task = "Самый большой простой делитель числа 13195.",
Result = Calculate(13195).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(Calculate13195)
});
pc.Cases.Add(new CaseContainer
{
Task = "Самый большой простой делитель числа 600851475143.",
Result = Calculate(600851475143).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(Calculate600851475143)
});
return(pc);
}
public ProblemContainer CompleteProblem()
{
ProblemContainer pc = new ProblemContainer()
{
Number = 26,
Task = content,
Cases = new List <CaseContainer>()
};
pc.Cases.Add(new CaseContainer
{
Task = "Значение d < 11, для которого 1/d в десятичном виде содержит самую длинную повторяющуюся последовательность цифр.",
Result = Calculate(11).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(Calculate11)
});
pc.Cases.Add(new CaseContainer
{
Task = "Значение d < 1000, для которого 1/d в десятичном виде содержит самую длинную повторяющуюся последовательность цифр.",
Result = Calculate(1000).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(Calculate1000)
});
return(pc);
}
public ProblemContainer CompleteProblem()
{
ProblemContainer pc = new ProblemContainer()
{
Number = 6,
Task = content,
Cases = new List <CaseContainer>()
};
pc.Cases.Add(new CaseContainer
{
Task = "Найдите разность между суммой квадратов и квадратом суммы первых десяти натуральных чисел.",
Result = Calculate(10).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(Calculate10)
});
pc.Cases.Add(new CaseContainer
{
Task = "Найдите разность между суммой квадратов и квадратом суммы первых ста натуральных чисел.",
Result = Calculate(100).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(Calculate100)
});
return(pc);
}
public ProblemContainer CompleteProblem()
{
ProblemContainer pc = new ProblemContainer()
{
Number = 17,
Task = content,
Cases = new List <CaseContainer>()
};
pc.Cases.Add(new CaseContainer
{
Task = "Сколько букв понадобится для записи всех чисел от 1 до 5 включительно?",
Result = Calculate(5).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(Calculate5)
});
pc.Cases.Add(new CaseContainer
{
Task = "Сколько букв понадобится для записи всех чисел от 1 до 1000 включительно?",
Result = Calculate(1000).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(Calculate1000)
});
return(pc);
}
public ProblemContainer CompleteProblem()
{
ProblemContainer pc = new ProblemContainer()
{
Number = 14,
Task = content,
Cases = new List <CaseContainer>()
};
var calcA = CalculateWithCache(1000000);
pc.Cases.Add(new CaseContainer
{
Task = "Какой начальный элемент меньше 1000000 генерирует самую длинную последовательность по заданному правилу? Метод с использование кэша.",
Result = $"Элемент: {calcA.number}, длина: {calcA.length}",
BenchmarkResult = WatchstopBenchmark.Benchmark(CalculateWithCacheBench, 2, 3)
});
var calcB = CalculateWithoutCache(1000000);
pc.Cases.Add(new CaseContainer
{
Task = "Какой начальный элемент меньше 1000000 генерирует самую длинную последовательность по заданному правилу? Метод без использования кэша",
Result = $"Элемент: {calcB.number}, длина: {calcB.length}",
BenchmarkResult = WatchstopBenchmark.Benchmark(CalculateWithoutCacheBench, 2, 3)
});
return(pc);
}
public ProblemContainer CompleteProblem()
{
ProblemContainer pc = new ProblemContainer()
{
Number = 12,
Task = content,
Cases = new List <CaseContainer>()
};
pc.Cases.Add(new CaseContainer
{
Task = "Каково первое треугольное число, у которого более пяти делителей.",
Result = Calculate(5).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(Calculate5)
});
pc.Cases.Add(new CaseContainer
{
Task = "Каково первое треугольное число, у которого более пятисот делителей.",
Result = Calculate(500).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(Calculate500, 2, 3)
});
return(pc);
}
public ProblemContainer CompleteProblem()
{
ProblemContainer pc = new ProblemContainer()
{
Number = 29,
Task = content,
Cases = new List <CaseContainer>()
};
pc.Cases.Add(new CaseContainer
{
Task = "Сколько различных членов имеет последовательность a^b для 2 ≤ a ≤ 5 и 2 ≤ b ≤ 5?",
Result = Calculate(new Range(2, 5), new Range(2, 5)).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(Calculate2To5)
});
pc.Cases.Add(new CaseContainer
{
Task = "Сколько различных членов имеет последовательность a^b для 2 ≤ a ≤ 100 и 2 ≤ b ≤ 100?",
Result = Calculate(new Range(2, 100), new Range(2, 100)).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(Calculate2To100)
});
return(pc);
}
public ProblemContainer CompleteProblem()
{
ProblemContainer pc = new ProblemContainer()
{
Number = 5,
Task = content,
Cases = new List <CaseContainer>()
};
pc.Cases.Add(new CaseContainer
{
Task = "Самое маленькое число делится нацело на все числа от 1 до 10.",
Result = Calculate(10).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(Calculate10)
});
pc.Cases.Add(new CaseContainer
{
Task = "Самое маленькое число делится нацело на все числа от 1 до 20.",
Result = Calculate(20).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(Calculate20)
});
return(pc);
}
public ProblemContainer CompleteProblem()
{
ProblemContainer pc = new ProblemContainer()
{
Number = 7,
Task = content,
Cases = new List <CaseContainer>()
};
pc.Cases.Add(new CaseContainer
{
Task = "6-ое простое число.",
Result = Calculate(6).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(Calculate6)
});
pc.Cases.Add(new CaseContainer
{
Task = "10001-ое простое число.",
Result = Calculate(10001).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(Calculate10001)
});
return(pc);
}
private static void DisplayProblem(ProblemContainer problem)
{
if (problem == null)
{
return;
}
Console.WriteLine($"\t\t\t\tЭйлер №{problem.Number}:");
int startSybm = 0;
int lineWidthPref = 90;
int lineWidthActual = problem.Task.Length > startSybm + lineWidthPref ? lineWidthPref : problem.Task.Length - startSybm;
while (true)
{
Console.Write(problem.Task.Substring(startSybm, lineWidthActual));
if (ignoreInWordWrap.Contains(problem.Task[startSybm + lineWidthActual - 1]))
{
Console.WriteLine();
}
else
{
Console.WriteLine("-");
}
if (lineWidthActual != lineWidthPref)
{
break;
}
startSybm += lineWidthActual;
lineWidthActual = problem.Task.Length > startSybm + lineWidthPref ? lineWidthPref : problem.Task.Length - startSybm;
}
int counter = 1;
foreach (var problemCase in problem.Cases)
{
Console.WriteLine($"Случай №{counter}");
Console.WriteLine($"\t{problemCase.Task}");
Console.WriteLine($"\tРезультат: {problemCase.Result}");
if (problemCase.BenchmarkResult != null)
{
double avarageMsRounded = Math.Round(problemCase.BenchmarkResult.AvarageMs, 2);
if (avarageMsRounded > 0 || problemCase.BenchmarkResult.MedianMs > 0)
{
double avarageSecRounded = Math.Round(problemCase.BenchmarkResult.AvarageMs / 100.0, 2);
double medianSecRounded = Math.Round(problemCase.BenchmarkResult.MedianMs / 100.0, 2);
if (avarageSecRounded > 0 || medianSecRounded > 0)
{
Console.WriteLine($"\tСреднее сек: {avarageSecRounded}; Медианное сек: {Math.Round(medianSecRounded, 2)}");
}
Console.WriteLine($"\tСреднее мс: {avarageMsRounded}; Медианное мс: {problemCase.BenchmarkResult.MedianMs}");
}
Console.WriteLine($"\tСреднее тики: {Math.Round(problemCase.BenchmarkResult.AvarageTicks, 2)}; Медианное тики: {problemCase.BenchmarkResult.MedianTicks}");
}
counter++;
}
Console.Write("\n\n");
}
public ProblemContainer CompleteProblem()
{
ProblemContainer pc = new ProblemContainer()
{
Number = 24,
Task = content,
Cases = new List <CaseContainer>()
};
pc.Cases.Add(new CaseContainer
{
Task = "Какова миллионная словарная перестановка из цифр 0, 1, 2, 3, 4, 5, 6, 7, 8 и 9? Подсчет вплоть до миллионой.",
Result = CalculateBruteForce().ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(CalculateBruteForceBench)
});
pc.Cases.Add(new CaseContainer
{
Task = "Какова миллионная словарная перестановка из цифр 0, 1, 2, 3, 4, 5, 6, 7, 8 и 9? Вычисление миллионой с помощью факториалов.",
Result = CalculateFactorialMagic().ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(CalculateFactorialMagicBench)
});
return(pc);
}
public ProblemContainer CompleteProblem()
{
ProblemContainer pc = new ProblemContainer()
{
Number = 36,
Task = content,
Cases = new List <CaseContainer>()
};
pc.Cases.Add(new CaseContainer
{
Task = "Найдите сумму всех чисел меньше ста, являющихся палиндромами по основаниям 10 и 2.",
Result = Calculate(100).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(Calculate100)
});
pc.Cases.Add(new CaseContainer
{
Task = "Найдите сумму всех чисел меньше миллиона, являющихся палиндромами по основаниям 10 и 2.",
Result = Calculate(1000000).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(Calculate1000000)
});
return(pc);
}
public ProblemContainer CompleteProblem()
{
ProblemContainer pc = new ProblemContainer()
{
Number = 20,
Task = content,
Cases = new List <CaseContainer>()
};
pc.Cases.Add(new CaseContainer
{
Task = "Cумма цифр 10!",
Result = Calculate(10).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(Calculate10)
});
pc.Cases.Add(new CaseContainer
{
Task = "Cумма цифр 100!",
Result = Calculate(100).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(Calculate100)
});
return(pc);
}
public ProblemContainer CompleteProblem()
{
ProblemContainer pc = new ProblemContainer()
{
Number = 8,
Task = content,
Cases = new List <CaseContainer>()
};
pc.Cases.Add(new CaseContainer
{
Task = "Наибольшее произведение 4 последовательных цифр.",
Result = Calculate(4).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(Calculate4)
});
pc.Cases.Add(new CaseContainer
{
Task = "Наибольшее произведение 13 последовательных цифр.",
Result = Calculate(13).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(Calculate13)
});
return(pc);
}
public CreateProblemContainer(IRootCauseDb db, string initialProblemText, bool executeImmediately)
{
_Container = new ProblemContainer(initialProblemText);
_Db = db;
if (executeImmediately)
{
Execute();
}
}
public static void BakeSlectedProblems()
{
Transform[] transforms = Selection.transforms;
foreach (Transform transform in transforms)
{
ProblemContainer problemContainer = transform.GetComponent <ProblemContainer>();
if (problemContainer != null)
{
SerializationUtilits.SerializeProblem(problemContainer);
}
}
}
//private variables
public ProblemContainer CreateProblem(ProblemInfo problemInfo)
{
GameObject resultGameObject = ProblemContiner.Spawn(transform);
ProblemContainer result = resultGameObject.GetComponent <ProblemContainer>();
for (int i = 0; i < problemInfo.ProblemBlocks.Length; i++)
{
GameObject newBlock = CreateBlock(problemInfo.ProblemBlocks[i], resultGameObject.transform, i);
//Add the last as last
if (i == problemInfo.ProblemBlocks.Length - 1)
{
result.Last = newBlock.transform;
}
}
return(result);
}
public ProblemContainer CompleteProblem()
{
ProblemContainer pc = new ProblemContainer()
{
Number = 15,
Task = content,
Cases = new List <CaseContainer>()
};
pc.Cases.Add(new CaseContainer
{
Task = "Сколько существует таких маршрутов в сетке 2×2? Быстрый алгоритм",
Result = CalculateFast(2).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(CalculateFast2)
});
pc.Cases.Add(new CaseContainer
{
Task = "Сколько существует таких маршрутов в сетке 10×10? Быстрый алгоритм",
Result = CalculateFast(10).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(CalculateFast10)
});
pc.Cases.Add(new CaseContainer
{
Task = "Сколько существует таких маршрутов в сетке 20×20? Быстрый алгоритм",
Result = CalculateFast(20).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(CalculateFast20)
});
pc.Cases.Add(new CaseContainer
{
Task = "Сколько существует таких маршрутов в сетке 2×2? Медленный алгоритм",
Result = CalculateSlow(2).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(CalculateSlow2)
});
pc.Cases.Add(new CaseContainer
{
Task = "Сколько существует таких маршрутов в сетке 10×10? Медленный алгоритм",
Result = CalculateSlow(10).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(CalculateSlow10, 2, 3)
});
return(pc);
}
public void NewProblemContainer()
{
IRootCauseDb db = new NullDb();
var command = new CreateProblemContainer(db, "This is a problem");
command.Execute();
ProblemContainer container = command.Container;
Node problem = container.InitialProblem;
Assert.AreEqual("This is a problem", problem.Text);
Assert.AreEqual(0, container.CountUndoActions());
Assert.AreEqual(0, container.CountRedoActions());
IRootCauseCommand add = new AddNodeCommand(db, problem, "Cause 1");
container.AddAction(add);
Assert.AreEqual(true, add.Executed);
Assert.AreEqual(1, container.CountUndoActions());
Assert.AreEqual(0, container.CountRedoActions());
Assert.AreEqual(1, problem.CountChildNodes());
add = new AddNodeCommand(db, problem, "Cause 2", true);
container.AddAction(add);
Assert.AreEqual(true, add.Executed);
Assert.AreEqual(2, container.CountUndoActions());
Assert.AreEqual(0, container.CountRedoActions());
Assert.AreEqual(2, problem.CountChildNodes());
container.Undo();
Assert.AreEqual(1, container.CountUndoActions());
Assert.AreEqual(1, container.CountRedoActions());
Assert.AreEqual(1, problem.CountChildNodes());
container.Redo();
Assert.AreEqual(2, container.CountUndoActions());
Assert.AreEqual(0, container.CountRedoActions());
Assert.AreEqual(2, problem.CountChildNodes());
container.Undo();
add = new AddNodeCommand(db, problem, "Cause 3", true);
container.AddAction(add);
Assert.AreEqual(2, container.CountUndoActions());
Assert.AreEqual(0, container.CountRedoActions());
Assert.AreEqual(2, problem.CountChildNodes());
}
public ProblemContainer CompleteProblem()
{
ProblemContainer pc = new ProblemContainer()
{
Number = 23,
Task = content,
Cases = new List <CaseContainer>()
};
pc.Cases.Add(new CaseContainer
{
Task = "Cумму всех положительных чисел, которые не могут быть записаны как сумма двух избыточных чисел.",
Result = Calculate().ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(CalculateBench)
});
return(pc);
}
public ProblemContainer CompleteProblem()
{
ProblemContainer pc = new ProblemContainer()
{
Number = 50,
Task = content,
Cases = new List <CaseContainer>()
};
pc.Cases.Add(new CaseContainer
{
Task = "Какое 12-значное число образуется, если объединить три члена этой прогрессии?",
Result = Calculate(1000000).ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(CalculateBench)
});
return(pc);
}
public ProblemContainer CompleteProblem()
{
ProblemContainer pc = new ProblemContainer()
{
Number = 43,
Task = content,
Cases = new List <CaseContainer>()
};
pc.Cases.Add(new CaseContainer
{
Task = "Найдите сумму всех пан-цифровых чисел из цифр от 0 до 9, обладающих данным свойством.",
Result = Calculate().ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(CalculateBench, 3, 3)
});
return(pc);
}
public ProblemContainer CompleteProblem()
{
ProblemContainer pc = new ProblemContainer()
{
Number = 32,
Task = content,
Cases = new List <CaseContainer>()
};
pc.Cases.Add(new CaseContainer
{
Task = "Сумма всех пан-цифровых произведений, для которых равенство \"множимое × множитель = произведение\" можно записать цифрами от 1 до 9.",
Result = Calculate().ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(CalculateBench, 3, 3)
});
return(pc);
}
public ProblemContainer CompleteProblem()
{
ProblemContainer pc = new ProblemContainer()
{
Number = 55,
Task = content,
Cases = new List <CaseContainer>()
};
pc.Cases.Add(new CaseContainer
{
Task = "Сколько существует чисел Личрэла меньше десяти тысяч?",
Result = Calculate().ToString(),
BenchmarkResult = WatchstopBenchmark.Benchmark(CalculateBench)
});
return(pc);
}