সি, গড় 500+ 1500 1750 পয়েন্ট
এটি সংস্করণ 2 এর তুলনায় অপেক্ষাকৃত সামান্য উন্নতি (পূর্ববর্তী সংস্করণগুলির নোটগুলির জন্য নীচে দেখুন)। দুটি অংশ আছে। প্রথম: পুল থেকে এলোমেলোভাবে বোর্ডগুলি নির্বাচন করার পরিবর্তে, প্রোগ্রামটি পুলের প্রতিটি বোর্ডের উপরে পুনরায় পুনরুক্ত করার আগে পুলে প্রতিটি বোর্ডকে ঘুরে ফিরে ব্যবহার করে। (যেহেতু এই পুনরাবৃত্তিটি ঘটে যখন পুলটি সংশোধন করা হচ্ছে, তবুও এমন বোর্ডগুলি থাকবে যা পরপর দু'বার বা আরও খারাপভাবে নির্বাচিত হয় তবে এটি কোনও গুরুতর উদ্বেগ নয়)) দ্বিতীয় পরিবর্তনটি হ'ল পুলটি পরিবর্তন হওয়ার পরে প্রোগ্রামটি এখন ট্র্যাক করে cks , এবং যদি প্রোগ্রামটি পুলের বিষয়বস্তুগুলিকে উন্নত না করে খুব দীর্ঘ সময় ধরে চলে যায় তবে এটি নির্ধারণ করে যে অনুসন্ধানটি "স্থবির" হয়েছে, পুলটি খালি করে এবং একটি নতুন অনুসন্ধানের সাথে শুরু করে। দুই মিনিট শেষ না হওয়া পর্যন্ত এটি এটি চালিয়ে যায়।
আমি প্রাথমিকভাবে ভেবেছিলাম যে 1500-পয়েন্টের সীমা ছাড়িয়ে যাওয়ার জন্য আমি এক ধরণের হিউরিস্টিক অনুসন্ধান ব্যবহার করব। ৪৫২27-পয়েন্টের বোর্ড সম্পর্কে @ মেল্লামবকের মন্তব্য আমাকে ধরে নিয়েছিল যে উন্নতির জন্য প্রচুর জায়গা রয়েছে। তবে, আমরা তুলনামূলকভাবে একটি ছোট ওয়ার্ডলিস্ট ব্যবহার করছি। 4527-পয়েন্ট বোর্ডটি YAWL ব্যবহার করে স্কোর করছিল, যা সেখানে সর্বাধিক অন্তর্ভুক্ত ওয়ার্ডলিস্ট - এটি মার্কিন যুক্তরাষ্ট্রের স্ক্র্যাবল ওয়ার্ডলিস্টের চেয়েও বড়। এটি মাথায় রেখে, আমি আমার প্রোগ্রামটি যে বোর্ডগুলি খুঁজে পেয়েছি সেগুলি পুনরায় পরীক্ষা করে দেখেছি যে 1700 বা তার বেশি বোর্ডগুলির সীমাবদ্ধ সেট রয়েছে বলে মনে হয়েছে। সুতরাং উদাহরণস্বরূপ, আমার একাধিক রান ছিল যা 1726 স্কোর করে একটি বোর্ড আবিষ্কার করেছিল, তবে এটি সর্বদা একই বোর্ড ছিল যা পাওয়া গেছে (ঘূর্ণন এবং প্রতিফলন উপেক্ষা করে)।
অন্য পরীক্ষা হিসাবে, আমি YAWL অভিধান হিসাবে ব্যবহার করে আমার প্রোগ্রামটি চালিয়েছি এবং এটি প্রায় এক ডজন রানের পরে 4527-পয়েন্ট বোর্ড পেয়েছে। এটি দেওয়া, আমি অনুমান করছি যে আমার প্রোগ্রামটি ইতিমধ্যে অনুসন্ধানের জায়গার উপরের সীমাতে রয়েছে, এবং তাই আমি পুনর্লিখনের পরিকল্পনা করছিলাম খুব অল্প লাভের জন্য অতিরিক্ত জটিলতার পরিচয় দেবে।
আমার প্রোগ্রামটি english.0ওয়ার্ডলিস্ট ব্যবহার করে যে পাঁচটি সর্বোচ্চ স্কোরিং বোর্ড পেয়েছে তার তালিকা এখানে রয়েছে :
1735 : D C L P E I A E R N T R S E G S
1738 : B E L S R A D G T I N E S E R S
1747 : D C L P E I A E N T R D G S E R
1766 : M P L S S A I E N T R N D E S G
1772: G R E P T N A L E S I T D R E S
আমার বিশ্বাস যে ১72 53২ "গ্রেপ বোর্ড" (যেমন আমি এটি ডাকতে পেরেছি), ৫৩১ শব্দের সাথে এই ওয়ার্ডলিস্টটি দিয়ে সর্বোচ্চ স্কোরিং বোর্ডই সম্ভব। আমার প্রোগ্রামের দুই মিনিটের রানের 50% এরও বেশি এই বোর্ডের সাথে শেষ। আমি আরও ভাল কিছু না পেয়ে আমার প্রোগ্রামটি রাতারাতি চালিয়ে গিয়েছি। সুতরাং যদি উচ্চতর-স্কোরিং বোর্ড থাকে তবে এর সম্ভবত কিছু দিক থাকতে হবে যা প্রোগ্রামটির অনুসন্ধান কৌশলকে পরাস্ত করে। একটি বোর্ড যাতে লেআউটটিতে প্রতিটি ছোট ছোট পরিবর্তন মোট স্কোরের বিশাল পরিমাণ হ্রাস করে, উদাহরণস্বরূপ, আমার প্রোগ্রামটি কখনও আবিষ্কার করতে পারে না। আমার কুণ্ডলীটি হ'ল এই জাতীয় বোর্ডের অস্তিত্বের খুব কমই সম্ভাবনা।
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <time.h>
#define WORDLISTFILE "./english.0"
#define XSIZE 4
#define YSIZE 4
#define BOARDSIZE (XSIZE * YSIZE)
#define DIEFACES 6
#define WORDBUFSIZE 256
#define MAXPOOLSIZE 32
#define STALLPOINT 64
#define RUNTIME 120
/* Generate a random int from 0 to N-1.
*/
#define random(N) ((int)(((double)(N) * rand()) / (RAND_MAX + 1.0)))
static char const dice[BOARDSIZE][DIEFACES] = {
"aaeegn", "elrtty", "aoottw", "abbjoo",
"ehrtvw", "cimotu", "distty", "eiosst",
"delrvy", "achops", "himnqu", "eeinsu",
"eeghnw", "affkps", "hlnnrz", "deilrx"
};
/* The dictionary is represented in memory as a tree. The tree is
* represented by its arcs; the nodes are implicit. All of the arcs
* emanating from a single node are stored as a linked list in
* alphabetical order.
*/
typedef struct {
int letter:8; /* the letter this arc is labelled with */
int arc:24; /* the node this arc points to (i.e. its first arc) */
int next:24; /* the next sibling arc emanating from this node */
int final:1; /* true if this arc is the end of a valid word */
} treearc;
/* Each of the slots that make up the playing board is represented
* by the die it contains.
*/
typedef struct {
unsigned char die; /* which die is in this slot */
unsigned char face; /* which face of the die is showing */
} slot;
/* The following information defines a game.
*/
typedef struct {
slot board[BOARDSIZE]; /* the contents of the board */
int score; /* how many points the board is worth */
} game;
/* The wordlist is stored as a binary search tree.
*/
typedef struct {
int item: 24; /* the identifier of a word in the list */
int left: 16; /* the branch with smaller identifiers */
int right: 16; /* the branch with larger identifiers */
} listnode;
/* The dictionary.
*/
static treearc *dictionary;
static int heapalloc;
static int heapsize;
/* Every slot's immediate neighbors.
*/
static int neighbors[BOARDSIZE][9];
/* The wordlist, used while scoring a board.
*/
static listnode *wordlist;
static int listalloc;
static int listsize;
static int xcursor;
/* The game that is currently being examined.
*/
static game G;
/* The highest-scoring game seen so far.
*/
static game bestgame;
/* Variables to time the program and display stats.
*/
static time_t start;
static int boardcount;
static int allscores;
/* The pool contains the N highest-scoring games seen so far.
*/
static game pool[MAXPOOLSIZE];
static int poolsize;
static int cutoffscore;
static int stallcounter;
/* Some buffers shared by recursive functions.
*/
static char wordbuf[WORDBUFSIZE];
static char gridbuf[BOARDSIZE];
/*
* The dictionary is stored as a tree. It is created during
* initialization and remains unmodified afterwards. When moving
* through the tree, the program tracks the arc that points to the
* current node. (The first arc in the heap is a dummy that points to
* the root node, which otherwise would have no arc.)
*/
static void initdictionary(void)
{
heapalloc = 256;
dictionary = malloc(256 * sizeof *dictionary);
heapsize = 1;
dictionary->arc = 0;
dictionary->letter = 0;
dictionary->next = 0;
dictionary->final = 0;
}
static int addarc(int arc, char ch)
{
int prev, a;
prev = arc;
a = dictionary[arc].arc;
for (;;) {
if (dictionary[a].letter == ch)
return a;
if (!dictionary[a].letter || dictionary[a].letter > ch)
break;
prev = a;
a = dictionary[a].next;
}
if (heapsize >= heapalloc) {
heapalloc *= 2;
dictionary = realloc(dictionary, heapalloc * sizeof *dictionary);
}
a = heapsize++;
dictionary[a].letter = ch;
dictionary[a].final = 0;
dictionary[a].arc = 0;
if (prev == arc) {
dictionary[a].next = dictionary[prev].arc;
dictionary[prev].arc = a;
} else {
dictionary[a].next = dictionary[prev].next;
dictionary[prev].next = a;
}
return a;
}
static int validateword(char *word)
{
int i;
for (i = 0 ; word[i] != '\0' && word[i] != '\n' ; ++i)
if (word[i] < 'a' || word[i] > 'z')
return 0;
if (word[i] == '\n')
word[i] = '\0';
if (i < 3)
return 0;
for ( ; *word ; ++word, --i) {
if (*word == 'q') {
if (word[1] != 'u')
return 0;
memmove(word + 1, word + 2, --i);
}
}
return 1;
}
static void createdictionary(char const *filename)
{
FILE *fp;
int arc, i;
initdictionary();
fp = fopen(filename, "r");
while (fgets(wordbuf, sizeof wordbuf, fp)) {
if (!validateword(wordbuf))
continue;
arc = 0;
for (i = 0 ; wordbuf[i] ; ++i)
arc = addarc(arc, wordbuf[i]);
dictionary[arc].final = 1;
}
fclose(fp);
}
/*
* The wordlist is stored as a binary search tree. It is only added
* to, searched, and erased. Instead of storing the actual word, it
* only retains the word's final arc in the dictionary. Thus, the
* dictionary needs to be walked in order to print out the wordlist.
*/
static void initwordlist(void)
{
listalloc = 16;
wordlist = malloc(listalloc * sizeof *wordlist);
listsize = 0;
}
static int iswordinlist(int word)
{
int node, n;
n = 0;
for (;;) {
node = n;
if (wordlist[node].item == word)
return 1;
if (wordlist[node].item > word)
n = wordlist[node].left;
else
n = wordlist[node].right;
if (!n)
return 0;
}
}
static int insertword(int word)
{
int node, n;
if (!listsize) {
wordlist->item = word;
wordlist->left = 0;
wordlist->right = 0;
++listsize;
return 1;
}
n = 0;
for (;;) {
node = n;
if (wordlist[node].item == word)
return 0;
if (wordlist[node].item > word)
n = wordlist[node].left;
else
n = wordlist[node].right;
if (!n)
break;
}
if (listsize >= listalloc) {
listalloc *= 2;
wordlist = realloc(wordlist, listalloc * sizeof *wordlist);
}
n = listsize++;
wordlist[n].item = word;
wordlist[n].left = 0;
wordlist[n].right = 0;
if (wordlist[node].item > word)
wordlist[node].left = n;
else
wordlist[node].right = n;
return 1;
}
static void clearwordlist(void)
{
listsize = 0;
G.score = 0;
}
static void scoreword(char const *word)
{
int const scoring[] = { 0, 0, 0, 1, 1, 2, 3, 5 };
int n, u;
for (n = u = 0 ; word[n] ; ++n)
if (word[n] == 'q')
++u;
n += u;
G.score += n > 7 ? 11 : scoring[n];
}
static void addwordtolist(char const *word, int id)
{
if (insertword(id))
scoreword(word);
}
static void _printwords(int arc, int len)
{
int a;
while (arc) {
a = len + 1;
wordbuf[len] = dictionary[arc].letter;
if (wordbuf[len] == 'q')
wordbuf[a++] = 'u';
if (dictionary[arc].final) {
if (iswordinlist(arc)) {
wordbuf[a] = '\0';
if (xcursor == 4) {
printf("%s\n", wordbuf);
xcursor = 0;
} else {
printf("%-16s", wordbuf);
++xcursor;
}
}
}
_printwords(dictionary[arc].arc, a);
arc = dictionary[arc].next;
}
}
static void printwordlist(void)
{
xcursor = 0;
_printwords(1, 0);
if (xcursor)
putchar('\n');
}
/*
* The board is stored as an array of oriented dice. To score a game,
* the program looks at each slot on the board in turn, and tries to
* find a path along the dictionary tree that matches the letters on
* adjacent dice.
*/
static void initneighbors(void)
{
int i, j, n;
for (i = 0 ; i < BOARDSIZE ; ++i) {
n = 0;
for (j = 0 ; j < BOARDSIZE ; ++j)
if (i != j && abs(i / XSIZE - j / XSIZE) <= 1
&& abs(i % XSIZE - j % XSIZE) <= 1)
neighbors[i][n++] = j;
neighbors[i][n] = -1;
}
}
static void printboard(void)
{
int i;
for (i = 0 ; i < BOARDSIZE ; ++i) {
printf(" %c", toupper(dice[G.board[i].die][G.board[i].face]));
if (i % XSIZE == XSIZE - 1)
putchar('\n');
}
}
static void _findwords(int pos, int arc, int len)
{
int ch, i, p;
for (;;) {
ch = dictionary[arc].letter;
if (ch == gridbuf[pos])
break;
if (ch > gridbuf[pos] || !dictionary[arc].next)
return;
arc = dictionary[arc].next;
}
wordbuf[len++] = ch;
if (dictionary[arc].final) {
wordbuf[len] = '\0';
addwordtolist(wordbuf, arc);
}
gridbuf[pos] = '.';
for (i = 0 ; (p = neighbors[pos][i]) >= 0 ; ++i)
if (gridbuf[p] != '.')
_findwords(p, dictionary[arc].arc, len);
gridbuf[pos] = ch;
}
static void findwordsingrid(void)
{
int i;
clearwordlist();
for (i = 0 ; i < BOARDSIZE ; ++i)
gridbuf[i] = dice[G.board[i].die][G.board[i].face];
for (i = 0 ; i < BOARDSIZE ; ++i)
_findwords(i, 1, 0);
}
static void shuffleboard(void)
{
int die[BOARDSIZE];
int i, n;
for (i = 0 ; i < BOARDSIZE ; ++i)
die[i] = i;
for (i = BOARDSIZE ; i-- ; ) {
n = random(i);
G.board[i].die = die[n];
G.board[i].face = random(DIEFACES);
die[n] = die[i];
}
}
/*
* The pool contains the N highest-scoring games found so far. (This
* would typically be done using a priority queue, but it represents
* far too little of the runtime. Brute force is just as good and
* simpler.) Note that the pool will only ever contain one board with
* a particular score: This is a cheap way to discourage the pool from
* filling up with almost-identical high-scoring boards.
*/
static void addgametopool(void)
{
int i;
if (G.score < cutoffscore)
return;
for (i = 0 ; i < poolsize ; ++i) {
if (G.score == pool[i].score) {
pool[i] = G;
return;
}
if (G.score > pool[i].score)
break;
}
if (poolsize < MAXPOOLSIZE)
++poolsize;
if (i < poolsize) {
memmove(pool + i + 1, pool + i, (poolsize - i - 1) * sizeof *pool);
pool[i] = G;
}
cutoffscore = pool[poolsize - 1].score;
stallcounter = 0;
}
static void selectpoolmember(int n)
{
G = pool[n];
}
static void emptypool(void)
{
poolsize = 0;
cutoffscore = 0;
stallcounter = 0;
}
/*
* The program examines as many boards as it can in the given time,
* and retains the one with the highest score. If the program is out
* of time, then it reports the best-seen game and immediately exits.
*/
static void report(void)
{
findwordsingrid();
printboard();
printwordlist();
printf("score = %d\n", G.score);
fprintf(stderr, "// score: %d points (%d words)\n", G.score, listsize);
fprintf(stderr, "// %d boards examined\n", boardcount);
fprintf(stderr, "// avg score: %.1f\n", (double)allscores / boardcount);
fprintf(stderr, "// runtime: %ld s\n", time(0) - start);
}
static void scoreboard(void)
{
findwordsingrid();
++boardcount;
allscores += G.score;
addgametopool();
if (bestgame.score < G.score) {
bestgame = G;
fprintf(stderr, "// %ld s: board %d scoring %d\n",
time(0) - start, boardcount, G.score);
}
if (time(0) - start >= RUNTIME) {
G = bestgame;
report();
exit(0);
}
}
static void restartpool(void)
{
emptypool();
while (poolsize < MAXPOOLSIZE) {
shuffleboard();
scoreboard();
}
}
/*
* Making small modifications to a board.
*/
static void turndie(void)
{
int i, j;
i = random(BOARDSIZE);
j = random(DIEFACES - 1) + 1;
G.board[i].face = (G.board[i].face + j) % DIEFACES;
}
static void swapdice(void)
{
slot t;
int p, q;
p = random(BOARDSIZE);
q = random(BOARDSIZE - 1);
if (q >= p)
++q;
t = G.board[p];
G.board[p] = G.board[q];
G.board[q] = t;
}
/*
*
*/
int main(void)
{
int i;
start = time(0);
srand((unsigned int)start);
createdictionary(WORDLISTFILE);
initwordlist();
initneighbors();
restartpool();
for (;;) {
for (i = 0 ; i < poolsize ; ++i) {
selectpoolmember(i);
turndie();
scoreboard();
selectpoolmember(i);
swapdice();
scoreboard();
}
++stallcounter;
if (stallcounter >= STALLPOINT) {
fprintf(stderr, "// stalled; restarting search\n");
restartpool();
}
}
return 0;
}
সংস্করণ 2 এর জন্য নোট (9 জুন)
জাম্পিং-অফ পয়েন্ট হিসাবে আমার কোডের প্রাথমিক সংস্করণটি ব্যবহার করার একটি উপায় এখানে। এই সংস্করণে পরিবর্তনগুলি 100 টিরও কম লাইন নিয়ে গঠিত তবে গড় গেমের স্কোর তিনগুণ বেশি।
এই সংস্করণে, প্রোগ্রামটি এখন পর্যন্ত প্রোগ্রামটি তৈরি করেছে এমন এন-সর্বাধিক স্কোরিং বোর্ড সমন্বয়ে প্রার্থীদের একটি "পুল" বজায় রাখে। প্রতিবার নতুন বোর্ড তৈরি হওয়ার পরে এটি পুলে যুক্ত করা হয় এবং পুলের সর্বনিম্ন-স্কোরিং বোর্ড সরানো হয় (এটি খুব ভালভাবে সজ্জিত বোর্ডের হতে পারে, যদি এর স্কোরটি ইতিমধ্যে রয়েছে তার চেয়ে কম থাকে)। পুলটি প্রাথমিকভাবে এলোমেলোভাবে উত্পাদিত বোর্ডগুলিতে পূর্ণ হয়, এর পরে এটি প্রোগ্রামের পুরো রান চলাকালীন ধ্রুব আকার রাখে।
প্রোগ্রামটির মূল লুপটি পুল থেকে একটি এলোমেলো বোর্ড নির্বাচন করে এটি পরিবর্তন করে এই নতুন বোর্ডের স্কোরটি নির্ধারণ করে এবং পরে এটি পুলের মধ্যে রাখে (যদি এটি যথেষ্ট পরিমাণে স্কোর করে) of এই ফ্যাশনে প্রোগ্রামটি ক্রমাগত উচ্চ-স্কোরিং বোর্ডগুলিকে সংশোধন করে চলেছে। প্রধান ক্রিয়াকলাপ হ'ল ধাপে ধাপে বৃদ্ধি, ইনক্রিমেন্টাল উন্নতি করা, তবে পুলের আকারটি প্রোগ্রামটিকে বহু-পদক্ষেপের উন্নতিগুলি সন্ধান করতে দেয় যা বোর্ডের স্কোর আরও ভাল করার আগে সাময়িকভাবে আরও খারাপ করে দেয়।
সাধারণত এই প্রোগ্রামটি বরং একটি ভাল স্থানীয় সর্বাধিক দ্রুত সন্ধান করে, এর পরে সম্ভবত আরও ভাল সর্বাধিক সন্ধান করা খুব দূরের। এবং তাই আবার 10 সেকেন্ডের চেয়ে বেশি সময় ধরে প্রোগ্রামটি চালানোর সামান্য বিন্দু আছে। উদাহরণস্বরূপ প্রোগ্রামটি এই পরিস্থিতিটি সনাক্ত করতে এবং পরীক্ষার্থীদের নতুন পুলের সাথে একটি নতুন অনুসন্ধান শুরু করার মাধ্যমে এটি উন্নত হতে পারে। তবে এটি কেবলমাত্র প্রান্তিক বৃদ্ধি পাবে। একটি যথার্থ হিউরিস্টিক অনুসন্ধান কৌশল সম্ভবত অনুসন্ধানের আরও ভাল উপায় হবে।
(পার্শ্ব নোট: আমি দেখেছি যে এই সংস্করণটি প্রায় 5k বোর্ড / সেকেন্ড তৈরি করছে Since প্রথম সংস্করণটি সাধারণত 20k বোর্ড / সেকেন্ড করে বলে আমি প্রাথমিকভাবে উদ্বিগ্ন ছিলাম prof তবে, আমি আবিষ্কার করেছি যে অতিরিক্ত সময় শব্দের তালিকাটি পরিচালনা করতে ব্যয় হয়েছিল। অন্য কথায়, এটি সম্পূর্ণরূপে প্রোগ্রামে বোর্ড অনুসারে আরও অনেক শব্দ সন্ধান করার কারণে ঘটেছে of এর আলোকে, আমি ওয়ার্ডলিস্টটি পরিচালনা করতে কোড পরিবর্তন করার বিষয়টি বিবেচনা করেছি, কিন্তু এই প্রোগ্রামটি তার বরাদ্দ হওয়া 120 সেকেন্ডের মধ্যে কেবল 10 ব্যবহার করছে, যেমন একটি অপ্টিমাইজেশন খুব অকাল হতে পারে।)
সংস্করণ 1 এর জন্য নোট (2 জুন)
এটি একটি খুব, খুব সহজ সমাধান। এটি যা কিছু করে তা এলোমেলো বোর্ড উত্পন্ন করে এবং তারপরে 10 সেকেন্ড পরে এটি সর্বোচ্চ স্কোরের সাথে একটিকে আউটপুট করে। (আমি 10 সেকেন্ডে খেলাপি হয়েছি কারণ সমস্যা নির্দিষ্টকরণের দ্বারা অনুমোদিত অতিরিক্ত 110 সেকেন্ড সাধারণত অপেক্ষার উপযুক্ত বলে মনে করা চূড়ান্ত সমাধানটি উন্নত করে না)) সুতরাং এটি অত্যন্ত বোবা। তবে এটি আরও বুদ্ধিমান অনুসন্ধানের জন্য একটি ভাল সূচনা করার জন্য সমস্ত অবকাঠামো রয়েছে এবং যদি কেউ সময়সীমার আগে এটি ব্যবহার করতে চায় তবে আমি তাদের এটি করতে উত্সাহিত করি।
প্রোগ্রামটি গাছের কাঠামোয় অভিধান পড়ার মাধ্যমে শুরু হয়। (ফর্মটি যতটা হতে পারে ঠিক ততটা অনুকূল নয়, তবে এটি এই উদ্দেশ্যে যথেষ্ট ভাল।) অন্য কিছু প্রাথমিক সূচনা করার পরে এটি বোর্ড তৈরি এবং তাদের স্কোর করা শুরু করে। প্রোগ্রামটি আমার মেশিনে প্রতি সেকেন্ডে 20k বোর্ডগুলি পরীক্ষা করে এবং প্রায় 200k বোর্ডের পরে এলোমেলো অ্যাপ্রোচ শুকনো চলতে শুরু করে।
যেহেতু যে কোনও সময়ে কেবলমাত্র একটি বোর্ডের মূল্যায়ন করা হচ্ছে, তাই স্কোরিং ডেটা গ্লোবাল ভেরিয়েবলগুলিতে সংরক্ষণ করা হয়। এটি আমাকে পুনরাবৃত্ত ফাংশনগুলিতে যুক্তি হিসাবে পাস করতে হবে এমন ধ্রুবক ডেটার পরিমাণ হ্রাস করতে সহায়তা করে allows (আমি নিশ্চিত যে এটি কিছু লোককে আমবাত দেবে, এবং তাদের কাছে আমি ক্ষমা চেয়ে নিচ্ছি)) ওয়ার্ডলিস্টটি বাইনারি অনুসন্ধানের গাছ হিসাবে সংরক্ষণ করা হয়েছে। প্রাপ্ত প্রতিটি শব্দের শব্দ তালিকায় সন্ধান করতে হবে, যাতে সদৃশ শব্দের দ্বিগুণ হয় না। শব্দ তালিকাটি কেবল বিবর্তন প্রক্রিয়া চলাকালীন প্রয়োজন, তবে স্কোর সন্ধান করার পরে এটি বাতিল করা হয়। সুতরাং, প্রোগ্রাম শেষে, বাছাই করা বোর্ডটি আবারও স্কোর করতে হবে, যাতে ওয়ার্ডলিস্টটি মুদ্রিত হতে পারে।
মজাদার ঘটনা: এলোমেলোভাবে উত্পাদিত বোগল বোর্ডের গড় স্কোর english.0.7১..7 পয়েন্ট।
4527(1414মোট শব্দ), এখানে পাওয়া গেছে: iistante.edu/~chuongdo/boggle/index.html