2048 گیم (جاوا کوڈ) کو حل کرنے کے لیے مصنوعی ذہانت کا استعمال

• اپریل 7، 2014
• Vasilis Vryniotis
• . 6 تبصرے

اب تک آپ میں سے اکثر نے سنا/چلایا ہوگا۔ 2048 کھیل بذریعہ Gabriele Cirulli یہ ایک سادہ لیکن انتہائی لت لگانے والا بورڈ گیم ہے جس میں 2048 نمبر تک پہنچنے کے لیے آپ کو سیلز کی تعداد کو یکجا کرنے کی ضرورت ہوتی ہے۔ جیسا کہ توقع کی جاتی ہے کہ گیم کی مشکل بڑھ جاتی ہے کیونکہ زیادہ سیلز اعلی اقدار سے بھرے ہوتے ہیں۔ ذاتی طور پر اگرچہ میں نے گیم کھیلنے میں کافی وقت صرف کیا، لیکن میں کبھی بھی 2048 تک نہیں پہنچ سکا۔ لہذا قدرتی بات یہ ہے کہ 2048 گیم کو مات دینے کے لیے JAVA میں AI سولور تیار کرنے کی کوشش کی جائے۔ 🙂

اس آرٹیکل میں میں گیم 2048 کے آرٹیفیشل انٹیلی جنس سولور کی تعمیر کے لیے اپنے نقطہ نظر پر مختصراً بات کروں گا، میں ان ہیورسٹکس کی وضاحت کروں گا جو میں نے استعمال کی ہیں اور میں مکمل کوڈ فراہم کروں گا جو JAVA میں لکھا ہوا ہے۔ کوڈ GPL v3 لائسنس کے تحت اوپن سورس ہے اور آپ اسے یہاں سے ڈاؤن لوڈ کر سکتے ہیں۔ Github کے.

JAVA میں 2048 گیم تیار کرنا

اصل گیم جاوا اسکرپٹ میں لکھی گئی ہے، اس لیے مجھے اسے شروع سے جاوا میں دوبارہ لکھنا پڑا۔ گیم کا بنیادی خیال یہ ہے کہ آپ کے پاس انٹیجر ویلیوز کے ساتھ 4×4 گرڈ ہے، یہ سبھی 2 کی طاقتیں ہیں۔ زیرو ویلیو سیلز کو خالی سمجھا جاتا ہے۔ گیم کے دوران ہر موڑ پر آپ اقدار کو اوپر، نیچے، دائیں یا بائیں 4 سمتوں کی طرف لے جا سکتے ہیں۔ جب آپ حرکت کرتے ہیں تو گرڈ کی تمام قدریں اس سمت کی طرف بڑھ جاتی ہیں اور وہ یا تو گرڈ کی سرحدوں تک پہنچنے پر یا غیر صفر ویلیو کے ساتھ کسی دوسرے سیل تک پہنچنے پر رک جاتی ہیں۔ اگر اس پچھلے سیل کی قدر ایک جیسی ہے تو، دونوں سیلز کو دوہری قدر کے ساتھ ایک سیل میں ضم کر دیا جاتا ہے۔ ہر حرکت کے اختتام پر خالی سیلوں میں سے ایک میں بورڈ میں ایک بے ترتیب قدر کا اضافہ کیا جاتا ہے اور اس کی قدر یا تو 2 امکان کے ساتھ 0.9 یا 4 امکان کے ساتھ 0.1 ہوتی ہے۔ گیم اس وقت ختم ہوتی ہے جب کھلاڑی 2048 (جیت) کی قیمت والا سیل بنانے کا انتظام کرتا ہے یا جب بنانے کے لیے کوئی دوسری حرکت نہیں ہوتی (ہارنا)۔

گیم کے اصل نفاذ میں، موو مرج الگورتھم تھوڑا پیچیدہ ہے کیونکہ یہ تمام سمتوں کو مدنظر رکھتا ہے۔ الگورتھم کی ایک اچھی سادگی کو انجام دیا جاسکتا ہے اگر ہم اس سمت کو درست کریں جس کی طرف ہم ٹکڑوں کو جوڑ سکتے ہیں اور حرکت کو انجام دینے کے لئے اس کے مطابق بورڈ کو گھما سکتے ہیں۔ موریتس وین ڈیر شی حال ہی میں اس کے بارے میں ایک مضمون لکھا ہے جس کے بارے میں مجھے یقین ہے کہ یہ دیکھنے کے قابل ہے۔

تمام کلاسز جاواڈاک تبصروں کے ساتھ دستاویزی ہیں۔ ذیل میں ہم نفاذ کے فن تعمیر کی اعلیٰ سطحی وضاحت فراہم کرتے ہیں:

1. بورڈ کلاس

بورڈ کلاس میں گیم کا مرکزی کوڈ ہوتا ہے، جو ٹکڑوں کو منتقل کرنے، اسکور کا حساب لگانے، گیم ختم ہونے کی توثیق وغیرہ کے لیے ذمہ دار ہوتا ہے۔

2. ایکشن اسٹیٹس اور ڈائریکشن اینوم

ایکشن سٹیٹس اور ڈائریکشن 2 ضروری اینم ہیں جو حرکت کے نتائج اور اس کے مطابق اس کی سمت کو محفوظ کرتے ہیں۔

3. کنسول گیم کلاس

ConsoleGame مرکزی کلاس ہے جو ہمیں گیم کھیلنے اور AI سولور کی درستگی کو جانچنے کی اجازت دیتی ہے۔

4. AIsolver کلاس

AIsolver مصنوعی ذہانت کے ماڈیول کی پرائمری کلاس ہے جو کسی خاص بورڈ کے پیش نظر اگلے بہترین اقدام کا جائزہ لینے کے لیے ذمہ دار ہے۔

مصنوعی ذہانت کی تکنیکیں: منی میکس بمقابلہ الفا بیٹا کٹائی

اس گیم کو خود بخود حل کرنے کے لیے کئی طریقے شائع کیے گئے ہیں۔ سب سے زیادہ قابل ذکر کی طرف سے تیار ایک ہے میٹ اوورلان. اس مسئلے کو حل کرنے کے لیے میں نے دو مختلف طریقے آزمائے، Minimax الگورتھم کا استعمال کرتے ہوئے اور Alpha-beta pruning کا استعمال۔

Minimax الگورتھم

۔ ہنگری ایک تکراری الگورتھم ہے جس کا استعمال دو کھلاڑیوں کے زیرو سم گیمز کو حل کرنے کے لیے کیا جا سکتا ہے۔ کھیل کی ہر حالت میں ہم ایک قدر منسلک کرتے ہیں۔ Minimax الگورتھم ممکنہ گیم سٹیٹس کی جگہ کے ذریعے تلاش کرتا ہے جس میں ایک درخت پیدا ہوتا ہے جسے اس وقت تک پھیلایا جاتا ہے جب تک کہ یہ کسی خاص پہلے سے طے شدہ گہرائی تک نہ پہنچ جائے۔ ایک بار جب وہ پتی کی حالتوں تک پہنچ جاتے ہیں، تو ان کی اقدار کا استعمال انٹرمیڈیٹ نوڈس کے تخمینے کے لیے کیا جاتا ہے۔

اس الگورتھم کا دلچسپ خیال یہ ہے کہ ہر سطح دو کھلاڑیوں میں سے ایک کی باری کی نمائندگی کرتا ہے۔ جیتنے کے لیے ہر کھلاڑی کو اس اقدام کا انتخاب کرنا چاہیے جو حریف کی زیادہ سے زیادہ ادائیگی کو کم سے کم کرے۔ یہاں minimax الگورتھم کی ایک اچھی ویڈیو پریزنٹیشن ہے:

[سرایت مواد]

ذیل میں آپ Minimax الگورتھم کا pseudocode دیکھ سکتے ہیں:

تقریب minimax (نوڈ، گہرائی، زیادہ سے زیادہ پلیئر)
    if گہرائی = 0 or نوڈ ایک ٹرمینل نوڈ ہے۔
        واپسی نوڈ کی heuristic قدر
    if maximizingPlayer bestValue := -∞
        ہر ایک کے لئے نوڈ ویل کا بچہ := minimax(بچہ، گہرائی - 1، FALSE)) bestValue := max(bestValue, val)؛
        واپسی بہترین قیمت
    اور
        بہترین قدر := + ∞
        ہر ایک کے لئے نوڈ ویل کا بچہ := minimax(بچہ، گہرائی - 1، TRUE)) bestValue := min(bestValue, val)؛
        واپسی بہترین قیمت
(* زیادہ سے زیادہ کھلاڑی کے لیے ابتدائی کال *)
minimax (اصل، گہرائی، سچ)

الفا بیٹا کی کٹائی

۔ الفا بیٹا کٹائی الگورتھم minimax کی توسیع ہے، جو نوڈس کی تعداد کو بہت زیادہ گھٹا دیتی ہے (کاٹتی ہے) جس کا ہمیں اندازہ/توسیع کرنا چاہیے۔ اس کو حاصل کرنے کے لیے، الگورتھم دو قدروں کا اندازہ لگاتا ہے الفا اور بیٹا۔ اگر کسی دیے گئے نوڈ میں بیٹا الفا سے کم ہے تو باقی ذیلی درختوں کی کٹائی کی جا سکتی ہے۔ یہاں حروف تہجی الگورتھم کی ایک اچھی ویڈیو پیش کش ہے:

[سرایت مواد]

ذیل میں آپ Alpha-beta pruning Algorithm کا pseudocode دیکھ سکتے ہیں:

تقریب حروف تہجی (نوڈ، گہرائی، α، β، زیادہ سے زیادہ پلیئر)
    if گہرائی = 0 or نوڈ ایک ٹرمینل نوڈ ہے۔
        واپسی نوڈ کی heuristic قدر
    if زیادہ سے زیادہ پلیئر
        ہر ایک کے لئے نوڈ کا بچہ α := زیادہ سے زیادہ (α، حروف تہجی (بچہ، گہرائی - 1، α، β، FALSE))
            if β ≤ α
                توڑ (* β کٹ آف *)
        واپسی α
    اور
        ہر ایک کے لئے نوڈ کا بچہ β := منٹ(β، حروف تہجی (بچہ، گہرائی - 1، α، β، TRUE))
            if β ≤ α
                توڑ (* α کٹ آف *)
        واپسی β
(*ابتدائی کال*)
حروف تہجی (اصل، گہرائی، -∞، +∞، TRUE)

گیم 2048 کو حل کرنے کے لیے AI کا استعمال کیسے کیا جاتا ہے؟

مندرجہ بالا الگورتھم استعمال کرنے کے لیے ہمیں پہلے دو کھلاڑیوں کی شناخت کرنی ہوگی۔ پہلا کھلاڑی وہ ہوتا ہے جو گیم کھیلتا ہے۔ دوسرا کھلاڑی وہ کمپیوٹر ہے جو بورڈ کے خلیوں میں تصادفی طور پر اقدار داخل کرتا ہے۔ ظاہر ہے کہ پہلا کھلاڑی اپنے اسکور کو زیادہ سے زیادہ کرنے اور 2048 کے انضمام کو حاصل کرنے کی کوشش کرتا ہے۔ دوسری طرف اصل گیم میں کمپیوٹر خاص طور پر صارف کو اس کے لیے بدترین ممکنہ اقدام کا انتخاب کرکے بلاک کرنے کے لیے پروگرام نہیں کیا گیا ہے بلکہ تصادفی طور پر خالی خلیوں پر قدریں داخل کرتا ہے۔

تو ہم AI تکنیک کیوں استعمال کرتے ہیں جو صفر کے حساب سے گیمز کو حل کرتی ہیں اور جو خاص طور پر یہ فرض کرتی ہیں کہ دونوں کھلاڑی اپنے لیے بہترین ممکنہ اقدام کا انتخاب کرتے ہیں؟ جواب سادہ ہے؛ اس حقیقت کے باوجود کہ یہ صرف پہلا کھلاڑی ہے جو اپنے اسکور کو زیادہ سے زیادہ کرنے کی کوشش کرتا ہے، کمپیوٹر کے انتخاب ترقی کو روک سکتے ہیں اور صارف کو گیم مکمل کرنے سے روک سکتے ہیں۔ کمپیوٹر کے رویے کو آرتھولوجیکل نان رینڈم پلیئر کے طور پر ماڈلنگ کرتے ہوئے ہم اس بات کو یقینی بناتے ہیں کہ ہمارا انتخاب کمپیوٹر کے کھیل سے آزادانہ طور پر ٹھوس ہوگا۔

دوسرا اہم حصہ کھیل کی ریاستوں کو اقدار تفویض کرنا ہے۔ یہ مسئلہ نسبتاً آسان ہے کیونکہ گیم ہی ہمیں اسکور دیتی ہے۔ بدقسمتی سے اپنے طور پر اسکور کو زیادہ سے زیادہ کرنے کی کوشش کرنا اچھا طریقہ نہیں ہے۔ اس کی ایک وجہ یہ ہے کہ کھیل جیتنے کے لیے ویلیوز کی پوزیشن اور خالی ویلیو سیلز کی تعداد بہت اہم ہے۔ مثال کے طور پر اگر ہم بڑی قدروں کو دور دراز کے خلیوں میں بکھیر دیتے ہیں، تو ہمارے لیے ان کو یکجا کرنا واقعی مشکل ہوگا۔ مزید برآں اگر ہمارے پاس کوئی خالی سیل دستیاب نہیں ہے تو ہمیں کسی بھی وقت گیم کھونے کا خطرہ ہے۔

مندرجہ بالا تمام وجوہات کی بناء پر، کئی heuristics تجویز کیا گیا ہے جیسے کہ مونوٹیسٹی، ہمواری اور بورڈ کی مفت ٹائلیں۔ مرکزی خیال یہ نہیں ہے کہ ہر گیم سٹیٹ کا جائزہ لینے کے لیے اکیلے اسکور کا استعمال کیا جائے بلکہ اس کے بجائے ایک جامع اسکور بنایا جائے جس میں مذکورہ اسکورز شامل ہوں۔

آخر میں ہمیں نوٹ کرنا چاہیے کہ اگرچہ میں نے Minimax الگورتھم کا نفاذ تیار کیا ہے، ممکنہ ریاستوں کی بڑی تعداد الگورتھم کو بہت سست بناتی ہے اور اس لیے کٹائی ضروری ہے۔ JAVA کے نفاذ کے نتیجے میں میں Alpha-beta pruning algorithm کی توسیع کا استعمال کرتا ہوں۔ مزید برآں دیگر نفاذات کے برعکس، میں صوابدیدی اصولوں کا استعمال کرتے ہوئے کمپیوٹر کے انتخاب کو جارحانہ انداز میں نہیں کاٹتا بلکہ اس کے بجائے میں کھلاڑی کے بہترین ممکنہ اقدام کو تلاش کرنے کے لیے ان سب کو مدنظر رکھتا ہوں۔

ایک ہورسٹک سکور فنکشن تیار کرنا

کھیل کو شکست دینے کے لیے، میں نے کئی مختلف ہورسٹک فنکشنز آزمائے۔ میں نے جو سب سے زیادہ مفید پایا وہ درج ذیل ہے:

private static int heuristicScore(int actualScore, int numberOfEmptyCells, int clusteringScore) {
     int score = (int) (actualScore+Math.log(actualScore)*numberOfEmptyCells -clusteringScore);
     return Math.max(score, Math.min(actualScore, 1));
}

مندرجہ بالا فنکشن بورڈ کے اصل سکور، خالی سیلز/ٹائلز کی تعداد اور کلسٹرنگ سکور نامی ایک میٹرک کو یکجا کرتا ہے جس پر ہم بعد میں بات کریں گے۔ آئیے ہر ایک جزو کو مزید تفصیل سے دیکھتے ہیں:

1. اصل اسکور: واضح وجوہات کی بناء پر، جب ہم کسی بورڈ کی قیمت کا حساب لگاتے ہیں تو ہمیں اس کے سکور کو مدنظر رکھنا پڑتا ہے۔ زیادہ اسکور والے بورڈز کو عام طور پر کم اسکور والے بورڈز کے مقابلے میں ترجیح دی جاتی ہے۔
2. خالی سیلوں کی تعداد: جیسا کہ ہم نے پہلے ذکر کیا، چند خالی سیل رکھنا اس بات کو یقینی بنانے کے لیے اہم ہے کہ ہم اگلی چالوں میں گیم نہیں ہاریں گے۔ زیادہ خالی خلیات والی بورڈ ریاستوں کو عام طور پر دوسروں کے مقابلے میں کم کے ساتھ ترجیح دی جاتی ہے۔ ایک سوال اٹھتا ہے کہ ہم ان خالی خلیوں کی قدر کیسے کریں گے؟ اپنے حل میں میں ان کا وزن اصل اسکور کے لوگارتھم سے کرتا ہوں۔ اس کا درج ذیل اثر ہوتا ہے: اسکور جتنا کم ہوگا، بہت سے خالی خلیات کا ہونا اتنا ہی کم اہم ہوگا (اس کی وجہ یہ ہے کہ کھیل کے آغاز میں خلیات کو یکجا کرنا کافی آسان ہے)۔ جتنا زیادہ اسکور ہوگا، اتنا ہی ضروری ہے کہ اس بات کو یقینی بنایا جائے کہ ہمارے پاس ہمارے گیم میں سیلز خالی ہوں (اس کی وجہ یہ ہے کہ گیم کے اختتام پر خالی سیلز کی کمی کی وجہ سے ہارنے کا زیادہ امکان ہوتا ہے۔
3. کلسٹرنگ سکور: ہم کلسٹرنگ سکور کا استعمال کرتے ہیں جس سے اندازہ ہوتا ہے کہ ہمارے بورڈ کی قدریں کتنی بکھری ہوئی ہیں۔ جب ایک جیسی اقدار والے خلیے قریب ہوتے ہیں تو ان کو جوڑنا آسان ہوتا ہے یعنی گیم ہارنا مشکل ہوتا ہے۔ اس معاملے میں کلسٹرنگ سکور کی قدر کم ہے۔ اگر بورڈ کی قدریں بکھری ہوئی ہیں، تو اس اسکور کو بہت بڑی قدر ملتی ہے۔ اس اسکور کو پچھلے دو اسکور سے گھٹا دیا جاتا ہے اور یہ ایک جرمانے کی طرح کام کرتا ہے جو اس بات کو یقینی بناتا ہے کہ کلسٹرڈ بورڈز کو ترجیح دی جائے گی۔

فنکشن کی آخری لائن میں ہم اس بات کو یقینی بناتے ہیں کہ اسکور غیر منفی ہے۔ اسکور سختی سے مثبت ہونا چاہیے اگر بورڈ کا سکور مثبت ہو اور صفر صرف اس صورت میں جب بورڈ کا سکور صفر ہو۔ زیادہ سے زیادہ اور کم سے کم فنکشنز بنائے گئے ہیں تاکہ ہم یہ اثر حاصل کریں۔

آخر میں ہمیں نوٹ کرنا چاہیے کہ جب کھلاڑی ٹرمینل گیم سٹیٹ پر پہنچ جاتا ہے اور مزید حرکت کی اجازت نہیں ہوتی ہے، تو ہم ریاست کی قدر کا اندازہ لگانے کے لیے اوپر کے سکور کا استعمال نہیں کرتے ہیں۔ اگر گیم جیت جاتی ہے تو ہم سب سے زیادہ ممکنہ عددی قدر تفویض کرتے ہیں، جب کہ اگر گیم ہار جاتی ہے تو ہم سب سے کم غیر منفی قدر تفویض کرتے ہیں (پچھلے پیراگراف کی طرح اسی طرح کی منطق کے ساتھ 0 یا 1)۔

کلسٹرنگ سکور کے بارے میں مزید

جیسا کہ ہم نے پہلے کہا کہ کلسٹرنگ سکور پیمائش کرتا ہے کہ بورڈ کی قدریں کتنی بکھری ہوئی ہیں اور جرمانے کی طرح کام کرتی ہیں۔ میں نے اس اسکور کو اس طرح بنایا ہے تاکہ اس میں ان صارفین کی تجاویز/قواعد شامل ہوں جنہوں نے گیم میں "مہارت حاصل کی"۔ پہلا تجویز کردہ قاعدہ یہ ہے کہ آپ ایک جیسی قدروں والے خلیوں کو قریب رکھنے کی کوشش کریں تاکہ ان کو آسانی سے جوڑ دیا جائے۔ دوسرا اصول یہ ہے کہ اعلیٰ قدر والے خلیے ایک دوسرے کے قریب ہونے چاہئیں اور بورڈ کے وسط میں نہیں بلکہ اطراف یا کونوں پر ظاہر ہونے چاہئیں۔

آئیے دیکھتے ہیں کہ کلسٹرنگ سکور کا اندازہ کیسے لگایا جاتا ہے۔ بورڈ کے ہر سیل کے لیے ہم اس کے پڑوسیوں (خالی خلیوں کو چھوڑ کر) سے مطلق فرق کے مجموعے کا تخمینہ لگاتے ہیں اور ہم اوسط فرق لیتے ہیں۔ ہم اوسط لینے کی وجہ دو پڑوسی خلیوں کے اثر کو ایک سے زیادہ بار گننے سے گریز کرنا ہے۔ کلسٹرنگ سکور ان تمام اوسطوں کا مجموعہ ہے۔

کلسٹرنگ سکور میں درج ذیل خصوصیات ہیں:

1. اس کی قدر زیادہ ہوتی ہے جب بورڈ کی قدریں بکھری ہوئی ہوتی ہیں اور کم قیمت ہوتی ہے جب ایک جیسی اقدار والے سیل ایک دوسرے کے قریب ہوتے ہیں۔
2. یہ دو پڑوسی خلیوں کے اثر سے زیادہ نہیں ہے۔
3. حاشیے یا کونوں میں موجود خلیات میں پڑوسی کم ہوتے ہیں اور اس طرح اسکور کم ہوتے ہیں۔ نتیجے کے طور پر جب اعلی اقدار کو مارجن یا کونوں کے قریب رکھا جاتا ہے تو ان کے اسکور چھوٹے ہوتے ہیں اور اس طرح جرمانہ بھی کم ہوتا ہے۔

الگورتھم کی درستگی

جیسا کہ توقع کی جاتی ہے کہ الگورتھم کی درستگی (یعنی جیتنے والے گیمز کا فیصد) کافی حد تک اس تلاش کی گہرائی پر منحصر ہے جسے ہم استعمال کرتے ہیں۔ تلاش کی گہرائی جتنی زیادہ ہوگی، درستگی اتنی ہی زیادہ ہوگی اور اسے چلانے میں اتنا ہی زیادہ وقت درکار ہوگا۔ میرے ٹیسٹوں میں، گہرائی 3 والی تلاش 0.05 سیکنڈ سے کم رہتی ہے لیکن جیتنے کا 20% موقع دیتی ہے، 5 کی گہرائی تقریباً 1 سیکنڈ تک رہتی ہے لیکن جیتنے کا 40% موقع دیتی ہے اور آخر میں 7 کی گہرائی 27-28 سیکنڈ تک رہتی ہے اور جیتنے کا تقریباً 70-80% موقع فراہم کرتا ہے۔

مستقبل کی توسیع

آپ میں سے جو لوگ کوڈ کو بہتر بنانے میں دلچسپی رکھتے ہیں ان کے لیے یہاں چند چیزیں ہیں جن پر آپ غور کر سکتے ہیں:

1. رفتار کو بہتر بنائیں: الگورتھم کی رفتار کو بہتر بنانے سے آپ کو زیادہ گہرائی کا استعمال کرنے اور اس طرح بہتر درستگی حاصل کرنے کی اجازت ملے گی۔
2. گرافکس بنائیں: اس کی ایک اچھی وجہ ہے کہ Gabriele Cirulli کا نفاذ اتنا مشہور کیوں ہوا۔ یہ اچھی لگ رہی ہے! میں نے GUI تیار کرنے کی زحمت نہیں کی لیکن میں نتائج کو کنسول پر پرنٹ کرتا ہوں جس کی وجہ سے گیم کی پیروی کرنا اور کھیلنا مشکل ہو جاتا ہے۔ ایک اچھا GUI بنانا ضروری ہے۔
3. ٹیون ہیورسٹکس: جیسا کہ میں نے پہلے ذکر کیا ہے، بہت سے صارفین نے مختلف heuristics کا مشورہ دیا ہے۔ کوئی بھی اسکور کا حساب لگانے کے طریقے، وزن اور بورڈ کی خصوصیات کو مدنظر رکھ کر تجربہ کر سکتا ہے۔ کلسٹر سکور کی پیمائش کرنے کا میرا نقطہ نظر دیگر تجاویز جیسے کہ Monotonicity اور Smoothness کو یکجا کرے گا، لیکن ابھی بھی بہتری کی گنجائش ہے۔
4. گہرائی ٹیوننگ: کوئی بھی گیم کی حالت کے لحاظ سے تلاش کی گہرائی کو ٹیون/ایڈجسٹ کرنے کی کوشش کر سکتا ہے۔ اس کے علاوہ آپ استعمال کر سکتے ہیں تکراری گہرا گہرائی-پہلی تلاش الگورتھم جو الفا بیٹا کی کٹائی الگورتھم کو بہتر بنانے کے لیے جانا جاتا ہے۔

سے JAVA کوڈ ڈاؤن لوڈ کرنا نہ بھولیں۔ Github کے اور تجربہ. مجھے امید ہے کہ آپ نے اس پوسٹ کا لطف اٹھایا! اگر آپ نے ایسا کیا ہے تو براہ کرم مضمون کو فیس بک اور ٹویٹر پر شیئر کرنے کے لیے تھوڑا وقت نکالیں۔ 🙂