public void DownloadTrainsProblemsTest()
{
HashSet <UInt64> arguments = new HashSet <UInt64>();
arguments.Add(UInt64.MaxValue);
arguments.Add(UInt64.MinValue);
for (long i = -1; i <= 100; ++i)
{
arguments.Add((ulong)i);
}
Random rnd = new Random(Environment.TickCount);
while (arguments.Count < 255)
{
arguments.Add((((ulong)rnd.Next()) << 32) + ((ulong)rnd.Next()));
}
ProblemsReader source = new ProblemsReader()
{
ProblemsFilename = @"..\..\..\..\problems.txt",
ProblemsResultsPath = @"..\..\..\..\problems-results\",
TrainProblemsPath = @"..\..\..\..\problems-samples\",
TrainProblemsResultsPath = @"..\..\..\..\problems-samples\"
};
ProblemsMiner miner = new ProblemsMiner(source);
//miner.DownloadTrainProblemsResults(true, arguments.ToArray());
miner.DownloadTrainProblemsResults(source.ReadProblems().Where(p => p.Size > 12).ToArray(), true, arguments.ToArray());
}
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");
}
}
}
public void BruteForceAllRealProblems(int size)
{
var ps = ProblemsReader.CreateDefault().ReadProblems().Where(p => p.Size == size).ToList();
Console.WriteLine("{0} problems of size {1}", ps.Count, size);
foreach (var problem in ps)
{
Console.Write("{0}: op:{1} ", problem.Id, string.Join(" ", problem.AllOperators));
var sw = Stopwatch.StartNew();
var count = new BinaryBruteForcer(problem.AllOperators).Enumerate(size).Count();
Console.WriteLine("count: {0} time: {1} ", count, sw.Elapsed);
}
}
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);
}
}
private static void Main(string[] args)
{
if (args.Length != 3)
{
PrintUsage();
return;
}
var source = new ProblemsReader()
{
ProblemsFilename = args[0],
TrainProblemsPath = args[1],
TrainProblemsResultsPath = args[1],
ProblemsResultsPath = args[2]
};
var problemsMiner = new ProblemsMiner(source);
problemsMiner.DownloadTrainProblemsSamples(Int32.MaxValue);
}
public void CuttingTest()
{
var keys = GenerateFirstSamples();
ProblemsReader reader = ProblemsReader.CreateDefault();
for (int i = 8; i < 14; ++i)
{
var problems =
reader.ReadProblems()
.Where(p => p.Size == i)
.SelectMany(
p => reader.ReadTrainProblems(p, true).Concat(reader.ReadTrainProblems(p, false)).Select(tp => Tuple.Create(p, tp)).Take(2))
.Take(10);
foreach (var problemPair in problems)
{
var tp = problemPair.Item2;
var programm = Expr.ParseFunction(tp.challenge).GetUnified().ToBinExp().ToArray();
var values = keys.ToDictionary(k => k, k => programm.Eval(k));
Func <byte[], bool> check = tree => values.All(kv => tree.Eval(kv.Key) == kv.Value);
var solutions = new BinaryBruteForcer(new Mask(values.Values), tp.operators).Enumerate(tp.size - 1);
int count = 0;
int cutted = 0;
foreach (var solution in solutions)
{
++count;
if (!check(solution))
{
++cutted;
}
}
Console.WriteLine(String.Format("{0}\t{1}\t{2}\t{3}", count, cutted, tp.size, tp));
}
}
}
public EvalTester(ProblemsReader source)
{
Source = source;
}
public void Test()
{
ProblemsReader source = new ProblemsReader()
{
ProblemsFilename = @"..\..\..\..\problems.txt",
ProblemsResultsPath = @"..\..\..\..\problems-results\",
TrainProblemsPath = @"..\..\..\..\problems-samples\",
TrainProblemsResultsPath = @"..\..\..\..\problems-samples\"
};
EvalTester tester = new EvalTester(source);
tester.Test(source.ReadProblems().ToArray());
Dictionary <string, statistic> statistics = new Dictionary <string, statistic>();
statistics["all"] = new statistic();
foreach (var testResult in tester.Tests)
{
foreach (var op in testResult.trainProblem.operators)
{
if (!statistics.ContainsKey(op))
{
statistics[op] = new statistic();
}
if (testResult.isSuccess > 0)
{
statistics[op].success++;
}
else if (testResult.isSuccess < 0)
{
statistics[op].fail++;
}
else
{
statistics[op].unknown++;
}
}
if (testResult.isSuccess > 0)
{
statistics["all"].success++;
}
else if (testResult.isSuccess < 0)
{
statistics["all"].fail++;
}
else
{
statistics["all"].unknown++;
}
}
foreach (var stat in statistics)
{
Console.WriteLine(String.Format("{0} sucess:{1} fail:{2} unknown: {3}", stat.Key, stat.Value.success, stat.Value.fail, stat.Value.unknown));
}
foreach (var testResult in tester.Tests)
{
Console.WriteLine(testResult);
}
}
public ProblemsMiner(ProblemsReader source)
{
this.Source = source;
}
