def heuristic(letters):
"""
Input: 2D tuple or 2D list of letters
Output: sum of frequencies plus number of meaningful words
"""
score = 0
for i in range(0, 3):
# accumulate by rows
score += ai_io.get_frequency(letters[i][0], letters[i][1])
score += ai_io.get_frequency(letters[i][1], letters[i][2])
if ai_io.has_meaning(letters[i][0], letters[i][1], letters[i][2]):
# row i has meaning
score += 1
# accumulate by cols
score += ai_io.get_frequency(letters[0][i], letters[1][i])
score += ai_io.get_frequency(letters[1][i], letters[2][i])
if ai_io.has_meaning(letters[0][i], letters[1][i], letters[2][i]):
# column i has meaning
score += 1
#accumulate by diagonals
score += ai_io.get_frequency(letters[0][0], letters[1][1])
score += ai_io.get_frequency(letters[1][1], letters[2][2])
if ai_io.has_meaning(letters[0][0], letters[1][1], letters[2][2]):
# diagonal left - right has meaning
score += 1
score += ai_io.get_frequency(letters[0][2], letters[1][1])
score += ai_io.get_frequency(letters[1][1], letters[2][0])
if ai_io.has_meaning(letters[0][2], letters[1][1], letters[2][0]):
# diagonal right - left has meaning
score += 1
return score
def heuristic(letters):
"""
Input: 2D tuple or 2D list of letters
Output: sum of frequencies plus number of meaningful words
"""
score = 0
for i in range(0,3):
# accumulate by rows
score += ai_io.get_frequency(letters[i][0], letters[i][1])
score += ai_io.get_frequency(letters[i][1], letters[i][2])
if ai_io.has_meaning(letters[i][0], letters[i][1], letters[i][2]):
# row i has meaning
score += 1
# accumulate by cols
score += ai_io.get_frequency(letters[0][i], letters[1][i])
score += ai_io.get_frequency(letters[1][i], letters[2][i])
if ai_io.has_meaning(letters[0][i], letters[1][i], letters[2][i]):
# column i has meaning
score += 1
#accumulate by diagonals
score += ai_io.get_frequency(letters[0][0], letters[1][1])
score += ai_io.get_frequency(letters[1][1], letters[2][2])
if ai_io.has_meaning(letters[0][0], letters[1][1], letters[2][2]):
# diagonal left - right has meaning
score += 1
score += ai_io.get_frequency(letters[0][2], letters[1][1])
score += ai_io.get_frequency(letters[1][1], letters[2][0])
if ai_io.has_meaning(letters[0][2], letters[1][1], letters[2][0]):
# diagonal right - left has meaning
score += 1
return score
def check_all(letters):
"""
Input: 1D tuple or 1D list of letters
Output: True of all words have meanings, False otherwise
"""
flag = True
letters_cp = to_two_d(letters)
for i in range(0,3):
# check row i and col i
if (not ai_io.has_meaning(letters_cp[i][0], letters_cp[i][1], letters_cp[i][2]) or
not ai_io.has_meaning(letters_cp[0][i], letters_cp[1][i], letters_cp[2][i])):
flag = False
break
# check diagons
if (not ai_io.has_meaning(letters_cp[0][0], letters_cp[1][1], letters_cp[2][2]) or
not ai_io.has_meaning(letters_cp[0][2], letters_cp[1][1], letters_cp[2][0])):
flag = False
return flag
def heuristic(self, state, index):
"""
Input:
'state': the current state that need to evaluate heuristic value
'index': the index of input in 'self.inputs'
Output:
The heuristic value of state
"""
score = 0
if len(state) == 3:
# check the first row
if not ai_io.has_meaning(state[0], state[1], state[2]):
# the first row has no meaning
return 0
elif len(state) == 6:
# check the second row
if not ai_io.has_meaning(state[3], state[4], state[5]):
# the second row has no meaning
return 0
elif len(state) == 7:
# check the first column and the right-left diagonal
if (not ai_io.has_meaning(state[0], state[3], state[6])
or not ai_io.has_meaning(state[2], state[4], state[6])):
# first column and the right-left diagonal have no meanings
return 0
elif len(state) == 8:
# check the second column
if not ai_io.has_meaning(state[1], state[4], state[7]):
# the second column has no meaning
return 0
elif len(state) == 9:
# check the third column, the third row and the left-right diagonal
if (not ai_io.has_meaning(state[2], state[5], state[8])
or not ai_io.has_meaning(state[0], state[4], state[8])
or not ai_io.has_meaning(state[6], state[7], state[8])):
# the third column, the third row and the left-right diagonal have no meanings
return 0
# START: Accumulate the frequency of each pair of letters in 'state'
for i in range(1, len(state)):
for j in AlgorithmPart2.PREVIOUS[i]:
try:
# state[i] is the current letter
# state[j] is one of the letters that precedes state[i]
freq = self.freq_dicts[index][state[j] + state[i]]
except Exception:
continue
else:
score += freq
# END
return score
def heuristic(self, state, index):
"""
Input:
'state': the current state that need to evaluate heuristic value
'index': the index of input in 'self.inputs'
Output:
The heuristic value of state
"""
score = 0
if len(state) == 3:
# check the first row
if not ai_io.has_meaning(state[0], state[1], state[2]):
# the first row has no meaning
return 0
elif len(state) == 6:
# check the second row
if not ai_io.has_meaning(state[3], state[4], state[5]):
# the second row has no meaning
return 0
elif len(state) == 7:
# check the first column and the right-left diagonal
if (not ai_io.has_meaning(state[0], state[3], state[6])
or not ai_io.has_meaning(state[2], state[4], state[6])):
# first column and the right-left diagonal have no meanings
return 0
elif len(state) == 8:
# check the second column
if not ai_io.has_meaning(state[1], state[4], state[7]):
# the second column has no meaning
return 0
elif len(state) == 9:
# check the third column, the third row and the left-right diagonal
if (not ai_io.has_meaning(state[2], state[5], state[8])
or not ai_io.has_meaning(state[0], state[4], state[8])
or not ai_io.has_meaning(state[6], state[7], state[8])):
# the third column, the third row and the left-right diagonal have no meanings
return 0
# START: Accumulate the frequency of each pair of letters in 'state'
for i in range(1, len(state)):
for j in AlgorithmPart2.PREVIOUS[i]:
try:
# state[i] is the current letter
# state[j] is one of the letters that precedes state[i]
freq = self.freq_dicts[index][state[j] + state[i]]
except Exception:
continue
else:
score += freq
# END
return score
def check_all(letters):
"""
Input: 1D tuple or 1D list of letters
Output: True of all words have meanings, False otherwise
"""
flag = True
letters_cp = to_two_d(letters)
for i in range(0, 3):
# check row i and col i
if (not ai_io.has_meaning(letters_cp[i][0], letters_cp[i][1],
letters_cp[i][2])
or not ai_io.has_meaning(letters_cp[0][i], letters_cp[1][i],
letters_cp[2][i])):
flag = False
break
# check diagons
if (not ai_io.has_meaning(letters_cp[0][0], letters_cp[1][1],
letters_cp[2][2])
or not ai_io.has_meaning(letters_cp[0][2], letters_cp[1][1],
letters_cp[2][0])):
flag = False
return flag
def heuristic(self, state, index):
score = 0
# START: Find a list of remaining letters (letters that are not in 'state')
letters_left = self.inputs[index][:]
for letter in state:
letters_left.remove(letter)
# END
len_state = len(state)
if len_state == 2:
for letter in letters_left:
if ai_io.has_meaning(state[0], state[1], letter):
score += 0.001
elif len_state == 3:
# check the first row
if not ai_io.has_meaning(state[0], state[1], state[2]):
return 0
else:
score += 0.001
# for letter in letters_left:
# now_score = score
# for j in AlgorithmPart3.PREVIOUS[len_state]:
# try:
# score += self.freq_dicts[index][state[j] + letter] / 10
# except Exception:
# score = now_score # reset score
# break
# if score == 0.001:
# there is no letter in letters_left that can go in the next position
# return 0
elif len_state == 4:
score += 0.001
# for letter in letters_left:
# now_score = score
# for j in AlgorithmPart3.PREVIOUS[len_state]:
# try:
# score += self.freq_dicts[index][state[j] + letter] / 10
# except Exception:
# score = now_score # reset score
# break
# if score == 0.001:
# there is no letter in letters_left that can go in the next position
# return 0
elif len_state == 5:
for letter in letters_left:
if ai_io.has_meaning(state[3], state[4], letter):
score += 0.001
elif len_state == 6:
# check the second row
if not ai_io.has_meaning(state[3], state[4], state[5]):
return 0
else:
for letter in letters_left:
if ai_io.has_meaning(state[0], state[3], letter):
score += 0.002
elif len_state == 7:
# check the first column and the right-left diagonal
if (not ai_io.has_meaning(state[0], state[3], state[6])
or not ai_io.has_meaning(state[2], state[4], state[6])):
return 0
else:
for letter in letters_left:
if ai_io.has_meaning(state[1], state[4], letter):
score += 0.004
elif len_state == 8:
# check the second column
if not ai_io.has_meaning(state[1], state[4], state[7]):
return 0
else:
for letter in letters_left:
if (ai_io.has_meaning(state[2], state[5], letter)
and ai_io.has_meaning(state[0], state[4], letter)
and ai_io.has_meaning(state[6], state[7], letter)):
score += 10
elif len(state) == 9:
# check the third column, the third row and the left-right diagonal
if (not ai_io.has_meaning(state[2], state[5], state[8])
or not ai_io.has_meaning(state[0], state[4], state[8])
or not ai_io.has_meaning(state[6], state[7], state[8])):
return 0
else:
score += 10
return score
def heuristic(self, state, index):
"""
Input:
'state': the current state that need to evaluate heuristic value
'index': the index of input in 'self.inputs'
Output:
The heuristic value of state
"""
score = 0
# START: Find a list of remaining letters (letters that are not in 'state')
letters_left = self.inputs[index][:]
for letter in state:
letters_left.remove(letter)
# END
len_state = len(state)
weight = 1.0/30.0 # the value is chosen from experience
if len_state == 2:
# START: add score for each letter left which makes the first row has meaning
for letter in letters_left:
if ai_io.has_meaning(state[0], state[1], letter):
score += 0.001
# END
elif len_state == 3 or len_state == 4:
# check the first row
if len_state == 3 and not ai_io.has_meaning(state[0], state[1], state[2]):
# the first row has no meaning
return 0
else:
score += 0.002 # score of the first row
for letter in letters_left:
now_score = score # the score before add 'letter' to 'state'
for j in AlgorithmPart3.PREVIOUS[len_state]:
try:
score += self.freq_dicts[index][state[j] + letter] * weight
except Exception:
# this 'letter' does not have a frequency with one of the previous letters
score = now_score # reset score
break
elif len_state == 5:
# START: add score for each letter left which makes the second row has meaning
for letter in letters_left:
if ai_io.has_meaning(state[3], state[4], letter):
now_score = score # the score before add 'letter' to 'state'
score += 0.001
for j in AlgorithmPart3.PREVIOUS[len_state]:
try:
score += self.freq_dicts[index][state[j] + letter] * weight
except Exception:
score = now_score # reset score
break
# END
elif len_state == 6:
# check the second row
if not ai_io.has_meaning(state[3], state[4], state[5]):
# the second row has no meaning
return 0
else:
# START: add score for each letter left which makes
# the first column and the right-left diagonal has meaning
for letter in letters_left:
if (ai_io.has_meaning(state[0], state[3], letter)
and ai_io.has_meaning(state[2], state[4], letter)):
score += 0.002
# END
elif len_state == 7:
# check the first column and the right-left diagonal
if (not ai_io.has_meaning(state[0], state[3], state[6])
or not ai_io.has_meaning(state[2], state[4], state[6])):
# first column and the right-left diagonal have no meanings
return 0
else:
# START: add score for each letter left which makes the second column has meaning
for letter in letters_left:
if ai_io.has_meaning(state[1], state[4], letter):
score += 0.004
# END
return score
elif len_state == 8:
# check the second column
if not ai_io.has_meaning(state[1], state[4], state[7]):
# the second column has no meaning
return 0
else:
# START: add score for 1 letter left which makes
# the third column, the third row and the left-right diagonal has meaning
if (ai_io.has_meaning(state[2], state[5], letters_left[0])
and ai_io.has_meaning(state[0], state[4], letters_left[0])
and ai_io.has_meaning(state[6], state[7], letters_left[0])):
# this is the result
return 10
else:
return 0
# END
if score == 0:
# there is no future for this state
return 0
# START: Accumulate the frequency of each pair of letters in 'state'
for i in range(1, len_state):
for j in AlgorithmPart3.PREVIOUS[i]:
try:
# state[i] is the current letter
# state[j] is one of the letters that precedes state[i]
freq = self.freq_dicts[index][state[j] + state[i]] * weight
except Exception:
return 0
else:
score += freq
# END
return score
def heuristic(self, state, index):
"""
Input:
'state': the current state that need to evaluate heuristic value
'index': the index of input in 'self.inputs'
Output:
The heuristic value of state
"""
score = 0
# START: Find a list of remaining letters (letters that are not in 'state')
letters_left = self.inputs[index][:]
for letter in state:
letters_left.remove(letter)
# END
len_state = len(state)
weight = 1.0/30.0
if len_state == 2:
# START: add score for each letter left which makes the first row has meaning
for letter in letters_left:
if ai_io.has_meaning(state[0], state[1], letter):
score += 0.001
# END
elif len_state == 3 or len_state == 4:
# check the first row
if len_state == 3 and not ai_io.has_meaning(state[0], state[1], state[2]):
# the first row has no meaning
return 0
else:
score += 0.002 # score of the first row
for letter in letters_left:
now_score = score # the score before add 'letter' to 'state'
for j in AlgorithmPart3.PREVIOUS[len_state]:
try:
score += self.freq_dicts[index][state[j] + letter] * weight
except Exception:
# this 'letter' does not have a frequency with one of the previous letters
score = now_score # reset score
break
elif len_state == 5:
# START: add score for each letter left which makes the second row has meaning
for letter in letters_left:
if ai_io.has_meaning(state[3], state[4], letter):
now_score = score # the score before add 'letter' to 'state'
score += 0.001
for j in AlgorithmPart3.PREVIOUS[len_state]:
try:
score += self.freq_dicts[index][state[j] + letter] * weight
except Exception:
score = now_score # reset score
break
# END
elif len_state == 6:
# check the second row
if not ai_io.has_meaning(state[3], state[4], state[5]):
# the second row has no meaning
return 0
else:
# START: add score for each letter left which makes
# the first column and the right-left diagonal has meaning
for letter in letters_left:
if (ai_io.has_meaning(state[0], state[3], letter)
and ai_io.has_meaning(state[2], state[4], letter)):
score += 0.002
# END
elif len_state == 7:
# check the first column and the right-left diagonal
if (not ai_io.has_meaning(state[0], state[3], state[6])
or not ai_io.has_meaning(state[2], state[4], state[6])):
# first column and the right-left diagonal have no meanings
return 0
else:
# START: add score for each letter left which makes the second column has meaning
for letter in letters_left:
if ai_io.has_meaning(state[1], state[4], letter):
score += 0.004
# END
return score
elif len_state == 8:
# check the second column
if not ai_io.has_meaning(state[1], state[4], state[7]):
# the second column has no meaning
return 0
else:
# START: add score for 1 letter left which makes
# the third column, the third row and the left-right diagonal has meaning
if (ai_io.has_meaning(state[2], state[5], letters_left[0])
and ai_io.has_meaning(state[0], state[4], letters_left[0])
and ai_io.has_meaning(state[6], state[7], letters_left[0])):
# this is the result
return 10
else:
return 0
# END
if score == 0:
# there is no future for this state
return 0
# START: Accumulate the frequency of each pair of letters in 'state'
for i in range(1, len_state):
for j in AlgorithmPart3.PREVIOUS[i]:
try:
# state[i] is the current letter
# state[j] is one of the letters that precedes state[i]
freq = self.freq_dicts[index][state[j] + state[i]] * weight
except Exception:
return 0
else:
score += freq
# END
return score