AI QUIZ (2020CS625).txt

TASK1-----------------------------
                        
def ASTAR(startingnode, goalnode):   
        set1 = set(startingnode) 
        set2 = set()
        SND = {} 
        parents = {}
        SND[startingnode] = 0
        parents[startingnode] = startingnode
        while len(set1) > 0:
            n = None
            for v in set1:
                
                if n == None or SND[v] + heuristicfunction(v) < SND[n] + heuristicfunction(n):
                    n = v             
            if n == goalnode or Graph [n] == None:
                pass
            else:
                for (m,cost) in childern(n):
                    if m not in set1 and m not in set2:
                        set1.add(m)
                        parents[m] = n
                        SND[m] = SND[n] + cost
                    else:
                        if SND[m] > SND[n] + cost:
                            SND[m] = SND[n] + cost
                            parents[m] = n
                            if m in set2:
                                set2.remove(m)
                                set1.add(m)
                                
                                
            if n == goalnode:
                path = []
                while parents[n] != n:
                    path.append(n)
                    n = parents[n]
                path.append(startingnode)
                path.reverse()
                print('Final Path:',path)
                return path
            set1.remove(n)
            set2.add(n)
 
        
def childern(v):
    if v in Graph :
        return Graph [v]
    else:
        return None
def heuristicfunction(n):
    Heuristic_values={
    'A':10.4,
    'B':6.7,
    'C':4.0,
    'S':11.0,
    'D':8.9,
    'E':6.9,
    'F':3.0,
    'G':0,
            
}  
    return Heuristic_values[n]
Graph = {
    'S': [('A', 3), ('D', 4)],
    'A': [('D', 5),('B', 4)],
    'D': [('E', 2)],
    'B': [('E', 5),('C',4)],
    'E': [('F',4)],
    'F':[('G',3)],
}
     

    
ASTAR('S', 'G')
                



TASK2--------------
class Node:
    def __init__(self,data,level,fval):
        
        self.data = data
        self.level = level
        self.fval = fval
        print(self.data)
    def generate_child(self):
        
        x,y = self.find(self.data,'_')
       
        val_list = [[x,y-1],[x,y+1],[x-1,y],[x+1,y]]
        children = []
        for i in val_list:
            child = self.shuffle(self.data,x,y,i[0],i[1])
            if child is not None:
                child_node = Node(child,self.level+1,0)
                children.append(child_node)
        return children
        
    def shuffle(self,puz,x1,y1,x2,y2):
        
        if x2 >= 0 and x2 < len(self.data) and y2 >= 0 and y2 < len(self.data):
            temp_puz = []
            temp_puz = self.copy(puz)
            temp = temp_puz[x2][y2]
            temp_puz[x2][y2] = temp_puz[x1][y1]
            temp_puz[x1][y1] = temp
            return temp_puz
        else:
            return None
            

    def copy(self,root):
        temp = []
        for i in root:
            t = []
            for j in i:
                t.append(j)
            temp.append(t)
        return temp    
            
    def find(self,puz,x):
        for i in range(0,len(self.data)):
            for j in range(0,len(self.data)):
                if puz[i][j] == x:
                    return i,j


class Puzzle:
    def __init__(self,size):
        self.n = size
        self.open = []
        self.closed = []

    def accept(self):
        puz = []
        for i in range(0,self.n):
            temp = input().split(" ")
            puz.append(temp)
        return puz
    def f(self,start,goal):
        
        return self.h(start.data,goal)+start.level
    def h(self,start,goal):
       
        temp = 0
        for i in range(0,self.n):
            for j in range(0,self.n):
                if start[i][j] != goal[i][j] and start[i][j] != '_':
                    temp += 1
        return temp
        

    def process(self):
        
        print("Enter the start state matrix \n")
        start = self.accept()
        print("Enter the goal state matrix \n")        
        goal = self.accept()
puz=puzzle()
puz.process()