import random

from simpleai.search.models import SearchProblem

from simpleai.search import breadth$\_$first, depth$\_$first, uniform$\_$cost$,$ limited$\_$depth$\_$first, iterative$\_$limited$\_$depth$\_$first, astar, greedy

class NQueens$($SearchProblem$)$:

def $\_\_$init$\_\_($self$,$ N$,$ initial$\_$state$=$None$)$:

self.N $=$ N

if initial$\_$state is None:

self.$\_$set$\_$state$()$

else:

self.state $=$ tuple$($map$($int$,$ initial$\_$state$))$

super$().\_\_$init$\_\_($tuple$($self$.$state$))$ # Initial state is a tuple of queen positions

def actions$($self$,$ state$)$:

return $[($i$,$ j$)$ for i in range$(1,$ self.N $+1)$ for j in range$(1,$ self.N $+1)]$

def result$($self$,$ state, action$)$:

i$,$ j $=$ action

new$\_$state $=$ list$($state$)$

new$\_$state$[$i $-1]=$ j

return tuple$($new$\_$state$)$

def is$\_$goal$($self$,$ state$)$:

return self.$\_$count$\_$attacking$\_$pairs$($state$)==0$

def heuristic$($self$,$ state$)$:

return self.$\_$count$\_$attacking$\_$pairs$($state$)$

def generate$\_$random$\_$state$($self$)$:

random$\_$state $=""$

for $\_$ in range$($self$.$N$)$:

str$\_$val $=$ random.randint$(1,$ self.N$)$

random$\_$state $+=$ str$($str$\_$val$)$

return random$\_$state

def $\_$set$\_$state$($self$)$:

state$\_$answer $=$ input$("$Enter $1$ for Manual Entrance, $0$ for Random State:"$)$

if state$\_$answer $=="0"$:

self.state $=$ self.generate$\_$random$\_$state$()$

elif state$\_$answer $=="1"$:

state$\_$temp $=$ input$("$enter state: $")$

if self.$\_$is$\_$valid$($state$\_$temp$)$:

self.state $=$ state$\_$temp

else:

self.state $=$ "wrong state"

else:

self.state $=$ "wrong entry"

def $\_$count$\_$attacking$\_$pairs$($self$,$ state$)$:

if self.$\_$is$\_$valid$($self$.$state$)$:

attacking$\_$pairs $=0$

for index, state$\_$indexed in enumerate$($state$)$:

for index$1,$ state$\_$indexed$1$ in enumerate$($state$)$:

if index $<$ index$1$:

coordinate $=[$index $+1,$ int$($state$\_$indexed$)]$

coordinate$\_1=[$index$1+1,$ int$($state$\_$indexed$1)]$

if $($abs$($coordinate$[0]-$ coordinate$\_1[0])==$ abs$($coordinate$[1]-$ coordinate$\_1[1]))$ or $\backslash$

$($coordinate$[0]==$ coordinate$\_1[0])$ or $($coordinate$[1]==$ coordinate$\_1[1])$:

attacking$\_$pairs $+=1$

return attacking$\_$pairs

return "Error"

def $\_$is$\_$valid$($self$,$ state$)$:

if len$($state$)!=$ self.N:

print$("$The length of the state string is not equal to N$.")$

return False

for i in range$($len$($state$))$:

try:

if not $1<=$ int$($state$[$i$])<=$ self.N:

print$("$State string includes numbers greater than N or less than $1.")$

return False

except ValueError:

return False

return True

def solve$\_$with$\_$algorithm$($self$,$ algorithm$)$:

result$=$None

algorithm $=$ None

if algorithm$\_$name $==\text{'}$bfs$\text{'}$:

algorithm $=$ breadth$\_$first

elif algorithm$\_$name $==$ 'ucs':

algorithm $=$ uniform$\_$cost

elif algorithm$\_$name $==\text{'}$dfs$\text{'}$:

algorithm $=$ depth$\_$first

elif algorithm$\_$name $==\text{'}$dls$\text{'}$:

limit $=$ int$($input$("$Enter depth limit for DLS: $"))$

algorithm $=$ limited$\_$depth$\_$first

result $=$ limited$\_$depth$\_$first$($self$,$ depth$\_$limit$=$limit$)$

elif algorithm$\_$name $==$ 'ids':

algorithm $=$ iterative$\_$limited$\_$depth$\_$first

elif algorithm$\_$name $==$ 'greedy':

algorithm $=$ greedy

elif algorithm$\_$name $==$ 'astar':

algorithm $=$ astar

if algorithm:

problem $=$ NQueens$($self$.$N$,$ self.state$)$

if result is None:

result $=$ algorithm$($problem$,$ graph$\_$search$=$graph$\_$search$)$

print$($f$"$

Algorithm: $\{$algorithm$\_$name$\}")$

print$($f$"$Resulting State: $\{$result$.$state$\}")$

print$($f$"$Resulting Path: $\{$result$.$path$()\}")$

print$($f$"$Cost: $\{$result$.$cost$\}")$

if hasattr$($result$,$ 'nodes'$)$:

print$($f$"$Viewer Statistics: Max Fringe Size: $\{$result$.$nodes$[\text{'}$max$\_$fringe$\_$size'$]\},$ Visited Nodes: $\{$result$.$nodes$[\text{'}$visited$\_$nodes'$]\}")$

else:

print$("$Viewer statistics not available for this algorithm."$)$

else:

print$("$Invalid algorithm name. Please enter a valid algorithm."$)$

if $\_\_$name$\_\_=="\_\_$main$\_\_"$:

N $=$ int$($input$("$Enter the size of the chessboard $($N$)$: $"))$

algorithm$\_$name $=$ input$("$Enter the algorithm name $($BFS$,$ UCS, DFS$,$ DLS$,$ IDS, Greedy, A$*)$: $").$lower$()$

graph$\_$search $=$ input$("$Use graph search? $($yes or no$)$: $").$lower$()==$ 'yes'

queens$\_$problem $=$ NQueens$($N$)$

queens$\_$problem.solve$\_$with$\_$algorithm$($algorithm$\_$name$).$please add this code block value, mutate and crossover functions and adjust this according to the simpleai library. Add genetic search, hill climbing search and random restarts hill climbing search.