সি শার্প
প্রায় সম্পূর্ণরূপে এলোমেলো এবং কাঁচা সমাবেশ সমাধান। যতদূর সি # এবং অন্য কোনও প্ল্যাটফর্ম যতটা যায়, এটি যথাসম্ভব নিম্ন স্তরের। ভাগ্যক্রমে, সি # আপনাকে আইএল-র রানটাইম চলাকালীন পদ্ধতিগুলি সংজ্ঞায়িত করতে দেয় (আইএল মধ্যবর্তী ভাষা, .NET এর বাইট কোড, সমাবেশের অনুরূপ)। এই কোডের একমাত্র সীমাবদ্ধতা হ'ল আমি কিছু অপকডগুলি বেছে নিয়েছি (শত শত এর মধ্যে) একটি স্বেচ্ছাসেবী বিতরণ যা নিখুঁত সমাধানের জন্য প্রয়োজনীয় হবে। যদি আমরা সমস্ত অপকডগুলিকে অনুমতি দিই তবে একটি কার্যনির্বাহী প্রোগ্রামের সম্ভাবনা কারও কাছেই কম নয়, সুতরাং এটি প্রয়োজনীয় (যেমন আপনি কল্পনা করতে পারেন, অনেকগুলি উপায় রয়েছে যা এলোমেলো সমাবেশের নির্দেশাবলী ক্র্যাশ করতে পারে, তবে ভাগ্যক্রমে, তারা পুরো প্রোগ্রামটি নামিয়ে না দেয়) ইন। নেট)। সম্ভাব্য ওপকোডগুলির পরিসীমা ব্যতীত, এটি সম্পূর্ণরূপে এলোমেলোভাবে কাটানো এবং কোনও ধরণের ইঙ্গিত ছাড়াই আইএল অপকোডগুলি ডাইস করা।
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Reflection.Emit;
using System.Diagnostics;
using System.Threading;
namespace codegolf
{
class Program
{
// decompile this into IL to find out the opcodes needed for the perfect algo
static int digitsumbest(int i)
{
var ret = 0;
while (i > 0)
{
ret += i % 10;
i /= 10;
}
return ret;
}
delegate int digitsumdelegate(int num);
static Thread bgthread;
// actually runs the generated code for one index
// it is invoked in a background thread, which we save so that it can be aborted in case of an infinite loop
static int run(digitsumdelegate del, int num)
{
bgthread = Thread.CurrentThread;
try
{
return del(num);
}
catch (ThreadAbortException)
{
bgthread = null;
throw;
}
}
// evaluates a generated code for some inputs and calculates an error level
// also supports a full run with logging
static long evaluate(digitsumdelegate del, TextWriter sw)
{
var error = 0L;
List<int> numbers;
if (sw == null) // quick evaluation
numbers = Enumerable.Range(1, 30).Concat(Enumerable.Range(1, 70).Select(x => 5000 + x * 31)).ToList();
else // full run
numbers = Enumerable.Range(1, 9999).ToList();
foreach (var num in numbers)
{
try
{
Func<digitsumdelegate, int, int> f = run;
bgthread = null;
var iar = f.BeginInvoke(del, num, null, null);
if (!iar.AsyncWaitHandle.WaitOne(10))
{
bgthread.Abort();
while (bgthread != null) ;
throw new Exception("timeout");
}
var result = f.EndInvoke(iar);
if (sw != null)
sw.WriteLine("{0};{1};{2};", num, digitsumbest(num), result);
var diff = result == 0 ? 15 : (result - digitsumbest(num));
if (diff > 50 || diff < -50)
diff = 50;
error += diff * diff;
}
catch (InvalidProgramException)
{
// invalid IL code, happens a lot, so let's make a shortcut
if (sw != null)
sw.WriteLine("invalid program");
return numbers.Count * (50 * 50) + 1;
}
catch (Exception ex)
{
if (sw != null)
sw.WriteLine("{0};{1};;{2}", num, digitsumbest(num), ex.Message);
error += 50 * 50;
}
}
return error;
}
// generates code from the given byte array
static digitsumdelegate emit(byte[] ops)
{
var dm = new DynamicMethod("w", typeof(int), new[] { typeof(int) });
var ilg = dm.GetILGenerator();
var loc = ilg.DeclareLocal(typeof(int));
// to support jumping anywhere, we will assign a label to every single opcode
var labels = Enumerable.Range(0, ops.Length).Select(x => ilg.DefineLabel()).ToArray();
for (var i = 0; i < ops.Length; i++)
{
ilg.MarkLabel(labels[i]);
// 3 types of jumps with 23 distribution each, 11 types of other opcodes with 17 distribution each = all 256 possibilities
// the opcodes were chosen based on the hand-coded working solution
var c = ops[i];
if (c < 23)
ilg.Emit(OpCodes.Br_S, labels[(i + 1 + c) % labels.Length]);
else if (c < 46)
ilg.Emit(OpCodes.Bgt_S, labels[(i + 1 + c - 23) % labels.Length]);
else if (c < 69)
ilg.Emit(OpCodes.Bge_S, labels[(i + 1 + c - 46) % labels.Length]);
else if (c < 86)
ilg.Emit(OpCodes.Ldc_I4, c - 70); // stack: +1
else if (c < 103)
ilg.Emit(OpCodes.Dup); // stack: +1
else if (c < 120)
ilg.Emit(OpCodes.Ldarg_0); // stack: +1
else if (c < 137)
ilg.Emit(OpCodes.Starg_S, 0); // stack: -1
else if (c < 154)
ilg.Emit(OpCodes.Ldloc, loc); // stack: +1
else if (c < 171)
ilg.Emit(OpCodes.Stloc, loc); // stack: -1
else if (c < 188)
ilg.Emit(OpCodes.Mul); // stack: -1
else if (c < 205)
ilg.Emit(OpCodes.Div); // stack: -1
else if (c < 222)
ilg.Emit(OpCodes.Rem); // stack: -1
else if (c < 239)
ilg.Emit(OpCodes.Add); // stack: -1
else
ilg.Emit(OpCodes.Sub); // stack: -1
}
ilg.Emit(OpCodes.Ret);
return (digitsumdelegate)dm.CreateDelegate(typeof(digitsumdelegate));
}
static void Main(string[] args)
{
System.Diagnostics.Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.Idle;
var rnd = new Random();
// the first list is just 10 small random ones
var best = new List<byte[]>();
for (var i = 0; i < 10; i++)
{
var initial = new byte[5];
for (var j = 0; j < initial.Length; j++)
initial[j] = (byte)rnd.Next(256);
best.Add(initial);
}
// load the best result from the previous run, if it exists
if (File.Exists("best.txt"))
best[0] = File.ReadAllLines("best.txt").Select(x => byte.Parse(x)).ToArray();
var stop = false;
// handle nice stopping with ctrl-c
Console.CancelKeyPress += (s, e) =>
{
stop = true;
e.Cancel = true;
};
while (!stop)
{
var candidates = new List<byte[]>();
// leave the 10 best arrays, plus generate 9 consecutive mutations for each of them = 100 candidates
for (var i = 0; i < 10; i++)
{
var s = best[i];
candidates.Add(s);
for (var j = 0; j < 9; j++)
{
// the optimal solution is about 20 opcodes, we keep the program length between 15 and 40
switch (rnd.Next(s.Length >= 40 ? 2 : 0, s.Length <= 15 ? 3 : 5))
{
case 0: // insert
case 1:
var c = new byte[s.Length + 1];
var idx = rnd.Next(0, s.Length);
Array.Copy(s, 0, c, 0, idx);
c[idx] = (byte)rnd.Next(256);
Array.Copy(s, idx, c, idx + 1, s.Length - idx);
candidates.Add(c);
s = c;
break;
case 2: // change
c = (byte[])s.Clone();
idx = rnd.Next(0, s.Length);
c[idx] = (byte)rnd.Next(256);
candidates.Add(c);
s = c;
break;
case 3: // remove
case 4: // remove
c = new byte[s.Length - 1];
idx = rnd.Next(0, s.Length);
Array.Copy(s, 0, c, 0, idx);
Array.Copy(s, idx + 1, c, idx, s.Length - idx - 1);
candidates.Add(c);
s = c;
break;
}
}
}
// score the candidates and select the best 10
var scores = Enumerable.Range(0, 100).ToDictionary(i => i, i => evaluate(emit(candidates[i]), null));
var bestidxes = scores.OrderBy(x => x.Value).Take(10).Select(x => x.Key).ToList();
Console.WriteLine("best score so far: {0}", scores[bestidxes[0]]);
best = bestidxes.Select(i => candidates[i]).ToList();
}
// output the code of the best solution
using (var sw = new StreamWriter("best.txt"))
{
foreach (var b in best[0])
sw.WriteLine(b);
}
// create a CSV file with the best solution
using (var sw = new StreamWriter("best.csv"))
{
sw.WriteLine("index;actual;generated;error");
evaluate(emit(best[0]), sw);
}
}
}
}
দুঃখিত, আমার এখনও পর্যন্ত কোনও ফলাফল নেই কারণ ১.৯.৯৯ (১.৯৯৯৯ এর পরিবর্তে) পরীক্ষা করাও বেশ ধীর এবং আমি খুব ক্লান্ত। আগামীকাল তোমার কাছে ফিরে আসব।
সম্পাদনা: আমি প্রোগ্রামটি শেষ করেছি এবং এটিকে অনেক টুইট করেছি। এখন, আপনি যদি CTRL-C টিপেন, এটি বর্তমান রান শেষ করবে এবং ফলাফলগুলিতে ফলাফলগুলি আউটপুট করবে। বর্তমানে, এটি কেবলমাত্র কার্যকর সমাধানগুলি হ'ল প্রোগ্রামগুলি যা সর্বদা একটি স্থির নম্বর দেয় return আমি ভাবতে শুরু করি যে আরও উন্নত ওয়ার্কিং প্রোগ্রামের সম্ভাবনাগুলি জ্যোতির্বিজ্ঞানের দিক থেকে খুব কম। যাইহোক আমি এটি কিছু সময়ের জন্য চলমান রাখব।
সম্পাদনা: আমি অ্যালগরিদম ট্যুইট করতে থাকি, এটি আমার মতো গিকের জন্য একটি নিখুঁত খেলনা। আমি একবার একটি উত্পন্ন প্রোগ্রাম দেখেছি যা আসলে কিছু এলোমেলো গণিত করেছিল এবং সবসময় একটি ধ্রুবক নম্বর ফেরত দেয় না। এটি একবারে কয়েক মিলিয়ন সিপিইউতে চালানো দারুণ হবে। এটি চালিয়ে যেতে হবে।
সম্পাদনা: এখানে কিছু সম্পূর্ণ র্যান্ডম গণিতের ফলাফল। এটি চারদিকে ঝাঁপিয়ে পড়ে এবং বাকি সূচকগুলির জন্য 17 এ থাকে। এটি শীঘ্রই কখনই সচেতন হবে না।
সম্পাদনা: এটি আরও জটিল হচ্ছে। অবশ্যই, আপনি যেমনটি প্রত্যাশা করবেন, এটি সঠিক অঙ্কের অ্যালগরিদমের মতো কিছুই দেখাচ্ছে না, তবে এটি চেষ্টা করছে। দেখুন, একটি কম্পিউটার উত্পন্ন সমাবেশ প্রোগ্রাম!
no librariesঅনুমতি দেওয়া কোন libc মানে?