private static void rowToTree(ScoreNode node, DataGridViewRow row, DataGridView grid)
{
int index = grid.Rows.IndexOf(row);
for (int i = 1; i < row.Cells.Count - 2; i++)
{
try
{
if (Double.Parse(row.Cells[i].Value.ToString()) > valuesThreshold.ElementAt(i))
{
node.setScore1(node.getScore1() + 1);
node = node.getRight();
}
else
{
node.setScore0(node.getScore0() + 1);
node = node.getLeft();
}
}
catch
{
node.setScore0(node.getScore0() + 1);
node = node.getLeft();
}
}
}
//todo implement bonus: likely this is something like a momentum factor
protected DecisionContextPair ScoreAllDecisions() {
float cutoff = 0f;
scoreQueue.Clear();
if(decisions.Count == 0) return default(DecisionContextPair);
for (int i = 0; i < decisions.Count; i++) {
Decision decision = decisions[i];
List<Context> contexts = decisions[i].contextCollector.Collect(decisions[i].action, entity);
for (int j = 0; j < contexts.Count; j++) {
Context context = contexts[j];
float bonus = 0; //context.GetBonusFactor(lastContext); //I likely cant do bonus like this
//if (bonus < cutoff) {
// continue;
//}
float score = decision.evaluator.Score(context, bonus, cutoff);
ScoreNode node = new ScoreNode(new DecisionContextPair(decision, context));
scoreQueue.Enqueue(node, 1 - score); //queue uses a min heap so 1 - score is correct
if (score > cutoff) {
cutoff = score;
}
}
}
switch (decisionSelectionProfile) {
case DecisionSelection.AlwaysBest:
return scoreQueue.First.item;
default:
return scoreQueue.First.item;
}
}
public ScoreNode InsertAfter(int n)
{
var node = new ScoreNode(n);
Next.Previous = node;
node.Next = Next;
Next = node;
node.Previous = this;
return(node);
}
private static void allocTree(ScoreNode root, int levelsNumber, int currentLevel)
{
if (levelsNumber > currentLevel)
{
root.setLeft(new ScoreNode(generatedNodes++));
root.setRight(new ScoreNode(generatedNodes++));
allocTree(root.getLeft(), levelsNumber, currentLevel + 1);
allocTree(root.getRight(), levelsNumber, currentLevel + 1);
}
}
public static void createTree(ScoreNode root, DataGridView dataGridView1)
{
valuesThreshold = new List <double>();
calculateThreshold(valuesThreshold, dataGridView1);
dataGridView1.DataSource = null;
generatedNodes = 1;
allocTree(root, dataGridView1.Columns.Count - 2, 0);
foreach (DataGridViewRow row in dataGridView1.Rows)
{
rowToTree(root, row, dataGridView1);
}
}
protected override string GetAnswer(string input)
{
var n = int.Parse(input);
var elf1 = new ScoreNode(3);
var elf2 = new ScoreNode(7);
elf1.Next = elf1.Previous = elf2;
elf2.Next = elf2.Previous = elf1;
var lastNode = elf2;
var scoreCount = 2;
while (scoreCount < n + 10)
{
var scoreSum = elf1.Score + elf2.Score;
if (scoreSum >= 10)
{
lastNode = lastNode.InsertAfter(scoreSum / 10 % 10);
scoreCount++;
}
lastNode = lastNode.InsertAfter(scoreSum % 10);
scoreCount++;
elf1 = elf1.Increment(1 + elf1.Score);
elf2 = elf2.Increment(1 + elf2.Score);
}
var node = lastNode;
if (scoreCount > n + 10)
{
node = node.Previous;
}
node = node.Decrement(9);
var answer = "";
for (var i = 0; i < 10; i++)
{
answer += node.Score;
node = node.Next;
}
return(answer);
}
private bool CheckForMatch(ScoreNode lastNode, int[] searchScores)
{
var node = lastNode.Decrement(searchScores.Length - 1);
for (var i = 0; i < searchScores.Length; i++)
{
if (node.Score != searchScores[i])
{
return(false);
}
else
{
node = node.Next;
}
}
return(true);
}
//todo implement bonus: likely this is something like a momentum factor
protected DecisionContextPair ScoreAllDecisions()
{
float cutoff = 0f;
scoreQueue.Clear();
if (decisions.Count == 0)
{
return(default(DecisionContextPair));
}
for (int i = 0; i < decisions.Count; i++)
{
Decision decision = decisions[i];
List <Context> contexts = decisions[i].contextCollector.Collect(decisions[i].action, entity);
for (int j = 0; j < contexts.Count; j++)
{
Context context = contexts[j];
float bonus = 0; //context.GetBonusFactor(lastContext); //I likely cant do bonus like this
//if (bonus < cutoff) {
// continue;
//}
float score = decision.evaluator.Score(context, bonus, cutoff);
ScoreNode node = new ScoreNode(new DecisionContextPair(decision, context));
scoreQueue.Enqueue(node, 1 - score); //queue uses a min heap so 1 - score is correct
if (score > cutoff)
{
cutoff = score;
}
}
}
switch (decisionSelectionProfile)
{
case DecisionSelection.AlwaysBest:
return(scoreQueue.First.item);
default:
return(scoreQueue.First.item);
}
}
protected override int GetAnswer(string input)
{
var searchScores = input.ToCharArray().Select(c => int.Parse(c.ToString())).ToArray();
var elf1 = new ScoreNode(3);
var elf2 = new ScoreNode(7);
elf1.Next = elf1.Previous = elf2;
elf2.Next = elf2.Previous = elf1;
var lastNode = elf2;
var scoreCount = 2;
while (true)
{
var scoreSum = elf1.Score + elf2.Score;
if (scoreSum >= 10)
{
scoreCount++;
lastNode = lastNode.InsertAfter(scoreSum / 10 % 10);
if (CheckForMatch(lastNode, searchScores))
{
break;
}
}
scoreCount++;
lastNode = lastNode.InsertAfter(scoreSum % 10);
if (CheckForMatch(lastNode, searchScores))
{
break;
}
elf1 = elf1.Increment(1 + elf1.Score);
elf2 = elf2.Increment(1 + elf2.Score);
}
return(scoreCount - input.Length);
}
public void SetScore(RoundUserStatisticsUpdatedEvent e, UserNode user, [JoinByUser] ScoreNode score)
{
score.scoreTableScoreIndicator.Score = user.roundUserStatistics.ScoreWithoutBonuses;
}
public void SetScore(NodeAddedEvent e, ScoreNode score, [Context, JoinByUser] UserNode user)
{
score.scoreTableScoreIndicator.Score = user.roundUserStatistics.ScoreWithoutBonuses;
}
