Scribd
Upload
31 views4 pages

Assessment AI

1. The document discusses implementing basic search strategies for three problems: 8 puzzle, 8 queens, and crypt arithmetic. 2. For the 8 queens problem, the logic is to place 8 queens on an 8x8 chessboard so that no two queens attack each other by being in the same row, column, or diagonal. Pseudocode is provided. 3. For the 8 puzzle problem, the goal is to arrange N tiles (N+1 with one empty tile) in the correct order, where N is 8. Pseudocode uses a priority queue and node class to search the state space from an initial to goal configuration.

Uploaded by

KIRUTHIKA V UCS20443
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
31 views4 pages

Assessment AI

1. The document discusses implementing basic search strategies for three problems: 8 puzzle, 8 queens, and crypt arithmetic. 2. For the 8 queens problem, the logic is to place 8 queens on an 8x8 chessboard so that no two queens attack each other by being in the same row, column, or diagonal. Pseudocode is provided. 3. For the 8 puzzle problem, the goal is to arrange N tiles (N+1 with one empty tile) in the correct order, where N is 8. Pseudocode uses a priority queue and node class to search the state space from an initial to goal configuration.

Uploaded by

KIRUTHIKA V UCS20443
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 4

25/08/2022

EX.NO:01

IMPLEMENT BASIC SEARCH STRATEGIES - 8 PUZZLE, 8 QUEENS, CRYPT ARITHMETIC

AIM:
To implement basic search strategies in 8 puzzle, 8 queens and crypt arithmetic
problems respectively.

1.1 8 QUEENS LOGIC:


8 - Queens problem is to place 8 - queens in such a manner on an 8 x 8 chessboard
that no queens attack each other by being in the same row, column or diagonal.

CODE:
print ("Enter the number of queens")
N = int(input())
board = [[0]*N for _ in range(N)]
def attack(i, j):
for k in range(0,N):
if board[i][k]==1 or board[k][j]==1:
return True
for k in range(0,N):
for l in range(0,N):
if (k+l==i+j) or (k-l==i-j):
if board[k][l]==1:
return True
return False
def N_queens(n):
if n==0:
return True
for i in range(0,N):
for j in range(0,N):
if (not(attack(i,j))) and (board[i][j]!=1):
board[i][j] = 1
if N_queens(n-1)==True:
return True
board[i][j] = 0
return False
N_queens(N)
for i in board:
print (i)

OUTPUT:
1.2 8 PUZZLE:
N-puzzle that consists of N tiles (N+1 titles with an empty tile) where N can be 8, 15, 24
and so on. In our example N = 8. (that is square root of (8+1) = 3 rows and 3 columns).
So, basically in these types of problems we are given an initial state or initial
configuration(Start state) and a Goal state or Goal Configuration.

CODE:
import copy
from heapq import heappush, heappop
n=3
row = [ 1, 0, -1, 0 ]
col = [ 0, -1, 0, 1 ]
class priorityQueue:
def __init__(self):
self.heap = []
def push(self, k):
heappush(self.heap, k)
def pop(self):
return heappop(self.heap)
def empty(self):
if not self.heap:
return True
else:
return False
class node:
def __init__(self, parent, mat, empty_tile_pos, cost, level):
self.parent = parent
self.mat = mat
self.empty_tile_pos = empty_tile_pos
self.cost = cost
self.level = level
def __lt__(self, nxt):
return self.cost < nxt.cost
def calculateCost(mat, final) -> int:
count = 0
for i in range(n):
for j in range(n):
if ((mat[i][j]) and
(mat[i][j] != final[i][j])):
count += 1
return count
def newNode(mat, empty_tile_pos, new_empty_tile_pos, level, parent, final) -> node:
new_mat = copy.deepcopy(mat)
x1 = empty_tile_pos[0]
y1 = empty_tile_pos[1]
x2 = new_empty_tile_pos[0]
y2 = new_empty_tile_pos[1]
new_mat[x1][y1], new_mat[x2][y2] = new_mat[x2][y2], new_mat[x1][y1]
cost = calculateCost(new_mat, final)
new_node = node(parent, new_mat, new_empty_tile_pos, cost, level)
return new_node
def printMatrix(mat):
for i in range(n):
for j in range(n):
print("%d " % (mat[i][j]), end = " ")
print()
def isSafe(x, y):
return x >= 0 and x < n and y >= 0 and y < n
def printPath(root):
if root == None:
return
printPath(root.parent)
printMatrix(root.mat)
print()
def solve(initial, empty_tile_pos, final):
pq = priorityQueue()
cost = calculateCost(initial, final)
root = node(None, initial, empty_tile_pos, cost, 0)
pq.push(root)
while not pq.empty():
minimum = pq.pop()
if minimum.cost == 0:
printPath(minimum)
return
for i in range(4):
new_tile_pos = [ minimum.empty_tile_pos[0] + row[i],
minimum.empty_tile_pos[1] + col[i], ]
if isSafe(new_tile_pos[0], new_tile_pos[1]):
child = newNode(minimum.mat, minimum.empty_tile_pos,
new_tile_pos, minimum.level + 1, minimum, final,)
pq.push(child)
initial = [ [ 1, 2, 3 ], [ 5, 6, 0 ], [ 7, 8, 4 ] ]
final = [ [ 1, 2, 3 ], [ 5, 8, 6 ], [ 0, 7, 4 ] ]
empty_tile_pos = [ 1, 2 ]

OUTPUT:

You might also like

pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy