private static void FindCountTreesForMyProblems()
{
var smallTxt = "small.txt";
var smallIds =
File.Exists("small.txt") ? new HashSet <string>(File.ReadAllLines(smallTxt)
.Where(line => line.Trim().Length > 0)
.Select(line => line.Split('\t'))
.Select(p => p[0])) : new HashSet <string>();
MyProblem[] prob = ProblemsReader.ProblemsToSolve().Where(p => p.Size >= 14 && !smallIds.Contains(p.Id)).OrderBy(p => p.Size).ToArray();
int limit = 100000000;
foreach (MyProblem p in prob)
{
Console.Write("{2} {0}: {1} ", p.Id, string.Join(",", p.Operations).PadRight(40), p.Size);
int count = new SmartGenerator(p.Operations).Enumerate(p.Size - 1, p.Size - 1, false).Take(limit).Count();
if (count == limit)
{
Console.WriteLine(limit + "+");
}
else
{
Console.WriteLine(count);
File.AppendAllText(smallTxt, p.Id + "\t" + p.Size + "\r\n");
}
}
}
private static void FindCountTreesForTrainProblems(int startSize, int endSize)
{
ProblemsReader reader = ProblemsReader.CreateDefault();
string filename = @"..\..\..\..\problems-samples\sizetrees.txt";
var problems = reader.ReadProblems().Where(p => p.Size >= startSize && p.Size <= endSize);
var trainproblems = problems.SelectMany(p => reader.ReadTrainProblems(p, true).Concat(reader.ReadTrainProblems(p, false)));
foreach (var p in trainproblems)
{
var t0 = DateTime.Now;
int count = new SmartGenerator(p.operators).Enumerate(p.size - 1).Count();
var t1 = DateTime.Now;
var time = t1 - t0;
var str = String.Format("{0}\ttrees:{1}\ttime:{2}\tsize:{3}\t{4}\n", p.id, count, time, p.size, p.ToString());
Console.WriteLine(str);
File.AppendAllText(filename, str);
}
}
public static string PostSolution(string problemId, int size, string[] operations)
{
var gsc = new GameServerClient();
log.DebugFormat("Trying to solve problem {0}...", problemId);
var random = new Random();
List <ulong> inputs = Enumerable.Range(1, 256).Select(e => random.NextUInt64()).ToList();
List <ulong> outputs = gsc.Eval(problemId, inputs).ToList();
log.Debug("Eval result for samples received");
IEnumerable <byte[]> trees = new SmartGenerator(inputs, outputs, operations).Enumerate(size - 1, size - 1, false);
int tasksCount = 4;
IEnumerable <byte[][]> chunckedTrees = Chuncked(trees, 1 * 1024 * 1024);
IEnumerable <byte[][][]> chunckedTreesPerWorker = Chuncked(chunckedTrees, tasksCount);
var results = new byte[0][];
IEnumerator <byte[][][]> enumerator = chunckedTreesPerWorker.GetEnumerator();
enumerator.MoveNext();
var sw = Stopwatch.StartNew();
while (true)
{
if (sw.Elapsed.TotalSeconds > 400)
{
throw new InvalidOperationException(string.Format("TIME_LIMIT: {0} sec", sw.Elapsed.TotalSeconds));
}
byte[][][] treesPerWorkerChunk = enumerator.Current;
var tasks = new List <Task <byte[][]> >(tasksCount);
log.Debug("Starting creating tasks");
foreach (var treesChunk in treesPerWorkerChunk)
{
byte[][] treeToCheck = treesChunk;
Task <byte[][]> task = Task.Factory.StartNew(() => FilterTrees(treeToCheck, inputs, outputs));
tasks.Add(task);
}
log.Debug("Finished created tasks and starts new chunk");
enumerator.MoveNext();
log.Debug("Finished new chunk");
Task.WaitAll(tasks.ToArray <Task>());
List <byte[][]> tasksResults = Results(tasks);
log.DebugFormat("All tasks completed, {0} results", results.Length);
byte[] solution;
while ((solution = GetSolution(tasksResults)) != null)
{
log.Debug("First solution finded, asking the guess...");
var s = solution.SkipWhile(b => b == 16).ToArray();
string formula = String.Format("(lambda (x) {0})", s.ToSExpr().Item1);
WrongAnswer wrongAnswer = gsc.Guess(problemId, formula);
log.Debug("Guess answer received");
if (wrongAnswer == null)
{
log.DebugFormat("Problem solved!!!. Problem Id: {0}", problemId);
return(formula);
}
log.Debug(string.Format("WrongAnswer received: {0}", wrongAnswer));
inputs = inputs.Concat(new[] { wrongAnswer.Arg }).ToList();
outputs = outputs.Concat(new[] { wrongAnswer.CorrectValue }).ToList();
tasksResults =
tasksResults.Select(
r =>
FilterTrees(r, new List <ulong> {
wrongAnswer.Arg
}, new List <ulong> {
wrongAnswer.CorrectValue
}))
.ToList();
}
}
}
