Pgm 1:

Solve the Tic Tac Toe problem using the Depth First Search technique.

grid = []
line = []
for i in range(3):
for j in range(3):
line.append(" ")
grid.append(line)
line = []

# grid printing
def print_grid():
for i in range(3):
print("|", end="")
for j in range(3):
print(grid[i][j], "|", end="")
print("")

# player turn
def player_turn(turn_player1):
if turn_player1 == True:
turn_player1 = False
print(f"It's {player2}'s turn")
else:
turn_player1 = True
print(f"It's {player1}'s turn")
return turn_player1

# choosing cell
def write_cell(cell):
cell -= 1
i = int(cell / 3)
j = cell % 3
if turn_player1 == True:
grid[i][j] = player1_symbol
else:
grid[i][j] = player2_symbol
return grid

# checking cell
def free_cell(cell):
cell -= 1
i = int(cell / 3)
j = cell % 3
if grid[i][j] == player1_symbol or grid[i][j] == player2_symbol:
print("This cell is not free")
return False
return True

# game opening
print("Welcome to the Tic-Tac-Toe !")
print("")
print_grid()
print("")
player1 = input("Please enter name of player 1 : ")
player1_symbol = input("Please enter the symbol of player 1 : ")
player2 = input("Please enter name of player 2 : ")
player2_symbol = input("Please enter the symbol of player 2 : ")
game = True
full_grid = False
turn_player1 = False
winner = ""

# win check
def win_check(grid, player1_symbol, player2_symbol):
full_grid = True
player1_symbol_count = 0
player2_symbol_count = 0
# checking rows
for i in range(3):
for j in range(3):
if grid[i][j] == player1_symbol:
player1_symbol_count += 1
player2_symbol_count = 0
if player1_symbol_count == 3:
game = False
winner = player1
return game, winner
if grid[i][j] == player2_symbol:
player2_symbol_count += 1
player1_symbol_count = 0
if player2_symbol_count == 3:
game = False
winner = player2
return game, winner
if grid[i][j] == " ":
full_grid = False

player1_symbol_count = 0
player2_symbol_count = 0
# checking columns
player1_symbol_count = 0
player2_symbol_count = 0
for i in range(3):
for j in range(3):
for k in range(3):
if i + k <= 2:
if grid[i + k][j] == player1_symbol:
player1_symbol_count += 1
player2_symbol_count = 0
if player1_symbol_count == 3:
game = False
winner = player1
return game, winner
if grid[i + k][j] == player2_symbol:
player2_symbol_count += 1
player1_symbol_count = 0
if player2_symbol_count == 3:
game = False
winner = player2
return game, winner
 if grid[i][j] == " ":
full_grid = False

player1_symbol_count = 0
player2_symbol_count = 0
# checking diagonals
player1_symbol_count = 0
player2_symbol_count = 0
for i in range(3):
for j in range(3):
for k in range(3):
if j + k <= 2 and i + k <= 2:
if grid[i + k][j + k] == player1_symbol:
player1_symbol_count += 1
player2_symbol_count = 0
if player1_symbol_count == 3:
game = False
winner = player1
return game, winner
if grid[i + k][j + k] == player2_symbol:
player2_symbol_count += 1
player1_symbol_count = 0
if player2_symbol_count == 3:
game = False
winner = player2
return game, winner
if grid[i][j] == " ":
full_grid = False

player1_symbol_count = 0
player2_symbol_count = 0

player1_symbol_count = 0
player2_symbol_count = 0
for i in range(3):
for j in range(3):
for k in range(3):
if j - k >= 0 and i + k <= 2:
if grid[i + k][j - k] == player1_symbol:
player1_symbol_count += 1
player2_symbol_count = 0
if player1_symbol_count == 3:
game = False
winner = player1
return game, winner
if grid[i + k][j - k] == player2_symbol:
player2_symbol_count += 1
player1_symbol_count = 0
if player2_symbol_count == 3:
game = False
winner = player2
return game, winner
if grid[i][j] == " ":
full_grid = False

player1_symbol_count = 0
player2_symbol_count = 0

# full grid or not

 if full_grid == True:
game = False
winner = ""
return game, winner
else:
game = True
winner = ""
return game, winner

# game
while game == True:
turn_player1 = player_turn(turn_player1)
free_box = False
while free_box == False:
cell = int(input("Please enter a number for your case (1 to 9 from left to
right and from top to bottom) : "))
free_box = free_cell(cell)
grid = write_cell(cell)
print_grid()
game, winner = win_check(grid, player1_symbol, player2_symbol)

# end of game
if winner == player1:
print(f"Winner is {player1} !")
elif winner == player2:
print(f"Winner is {player2} !")
else:
print(f"Grid is full : equality for {player1} and {player2} !")

Program 2:
Show that the 8 - puzzle states are divided into two disjoint sets, such that any
state is reachable from any other state in the same set, while no state is
reachable from any state in the other set.

def count_inversions(state):
"""Count the number of inversions in the given state."""
inversions = 0
flat_state = [tile for tile in state if tile != 0] # Exclude the empty space
(0)

for i in range(len(flat_state)):
for j in range(i + 1, len(flat_state)):
if flat_state[i] > flat_state[j]:
inversions += 1

return inversions

def classify_states(states):
"""Classify states into two sets based on the parity of inversions."""
set_even = []
set_odd = []

for state in states:

inversions = count_inversions(state)
if inversions % 2 == 0:
set_even.append(state)
 else:
set_odd.append(state)

return set_even, set_odd

# Example states (0 represents the empty space)

states = [
[1, 2, 3, 4, 5, 6, 7, 8, 0], # Solved state (0 inversions)
[1, 2, 3, 4, 5, 6, 0, 7, 8], # 1 inversion
[1, 2, 3, 4, 0, 5, 6, 7, 8], # 1 inversion
[1, 2, 3, 0, 4, 5, 6, 7, 8], # 2 inversions
[1, 2, 0, 3, 4, 5, 6, 7, 8], # 2 inversions
[0, 1, 2, 3, 4, 5, 6, 7, 8], # 0 inversions
[1, 0, 2, 3, 4, 5, 6, 7, 8], # 1 inversion
[1, 2, 3, 5, 4, 6, 7, 8, 0], # 3 inversions
]

set_even, set_odd = classify_states(states)

print("States with even inversions:")

for state in set_even:
print(state)

print("\nStates with odd inversions:")

for state in set_odd:
print(state)

Link: https://www.blackbox.ai/chat/0gHrN4a

Program 3:
To Represent and evaluate different scenarios using predicate logic and knowledge
rules.

class Predicate:
def __init__(self, name, *args):
self.name = name
self.args = args

def __repr__(self):
return f"{self.name}({', '.join(map(str, self.args))})"

class KnowledgeBase:
def __init__(self):
self.facts = set()
self.rules = []

def add_fact(self, fact):

self.facts.add(fact)

def add_rule(self, rule):

self.rules.append(rule)

def evaluate(self, query):

# Check if the query is a fact
if query in self.facts:
return True
 # Evaluate rules
for rule in self.rules:
if rule['condition'](self):
self.facts.add(rule['conclusion'])
if query == rule['conclusion']:
return True

return False

# Example predicates
is_mammal = Predicate('is_mammal', 'dog')
is_mammal2 = Predicate('is_mammal', 'cat')
is_bird = Predicate('is_bird', 'sparrow')

# Create a knowledge base

kb = KnowledgeBase()

# Add facts
kb.add_fact(is_mammal)
kb.add_fact(is_mammal2)

# Define rules
def rule1(kb):
return Predicate('is_mammal', 'dog') in kb.facts

def rule2(kb):
return Predicate('is_bird', 'sparrow') in kb.facts

# Add rules with conditions and conclusions

kb.add_rule({'condition': rule1, 'conclusion': Predicate('has_fur', 'dog')})
kb.add_rule({'condition': rule2, 'conclusion': Predicate('can_fly', 'sparrow')})

# Evaluate scenarios
query1 = Predicate('has_fur', 'dog')
query2 = Predicate('can_fly', 'sparrow')

print(f"Does the dog have fur? {kb.evaluate(query1)}") # Should return True

print(f"Can the sparrow fly? {kb.evaluate(query2)}") # Should return True

Link: https://www.blackbox.ai/chat/eW4CVNQ

or

class KnowledgeBase:
def __init__(self):
self.facts = {}
self.rules = []

def add_fact(self, predicate, value):

if predicate not in self.facts:
self.facts[predicate] = set()
self.facts[predicate].add(value)

def add_rule(self, rule):

self.rules.append(rule)

def evaluate(self, predicate, value):

if predicate in self.facts and value in self.facts[predicate]:
return True
 for rule in self.rules:
if rule['condition'](self, value):
return rule['conclusion'](self, value)
return False

# Define some predicates

def is_mammal(kb, animal):
return animal in kb.facts.get('mammals', set())

def is_bird(kb, animal):

return animal in kb.facts.get('birds', set())

# Define a rule
def can_fly(kb, animal):
if is_bird(kb, animal):
return True
return False

# Create a knowledge base

kb = KnowledgeBase()

# Add facts
kb.add_fact('mammals', 'dog')
kb.add_fact('mammals', 'cat')
kb.add_fact('birds', 'sparrow')
kb.add_fact('birds', 'eagle')

# Add rules
kb.add_rule({'condition': is_bird, 'conclusion': can_fly})

# Evaluate scenarios
animals_to_check = ['dog', 'sparrow', 'cat', 'eagle']

for animal in animals_to_check:

if kb.evaluate('mammals', animal):
print(f"{animal} is a mammal.")
elif kb.evaluate('birds', animal):
print(f"{animal} is a bird and can fly: {can_fly(kb, animal)}.")
else:
print(f"{animal} is neither a mammal nor a bird.")

Program 4: write a python code to apply the find - S and candidate elimination
algorithms to a concept learning task and compare their inductive biases and
outputs

Candidate elimination Program.

import copy
G = [['?', '?', '?', '?', '?', '?'], ['?', '?', '?', '?', '?', '?'], ['?', '?',
'?', '?', '?', '?'],
['?', '?', '?', '?', '?', '?'], ['?', '?', '?', '?', '?', '?'], ['?', '?',
'?', '?', '?', '?']]
S = ['Null', 'Null', 'Null', 'Null', 'Null', 'Null']
def is_consistent(hypothesis, example):
for i in range(len(hypothesis)):
if hypothesis[i] != '?' and hypothesis[i] != example[i]:
return False
return True
def update_hypotheses_positive(G, S, example):
 for i in range(len(G)):
if is_consistent(G[i], example):
continue
else:
for j in range(len(G[i])):
if G[i][j] == '?':
G[i][j] = example[j]
else:
G[i][j] = '?'
for j in range(len(S)):
if S[j] == 'Null':
S[j] = example[j]
elif S[j] != example[j]:
S[j] = '?'
def update_hypotheses_negative(G, S, example):
new_G = copy.deepcopy(G)
for i in range(len(G)):
if not is_consistent(G[i], example):
new_G.remove(G[i])
return new_G
instance1 = ['sunny', 'warm', 'normal', 'strong', 'warm', 'same']
instance2 = ['sunny', 'warm', 'high', 'strong', 'warm', 'same']
instance3 = ['rainy', 'cold', 'high', 'strong', 'warm', 'change']
instance4 = ['sunny', 'warm', 'high', 'strong', 'cool', 'change']
update_hypotheses_positive(G, S, instance1)
print("After instance 1:")
print("G =", G)
print("S =", S)
update_hypotheses_positive(G, S, instance2)
print("\nAfter instance 2:")
print("G =", G)
print("S =", S)
G = update_hypotheses_negative(G, S, instance3)
print("\nAfter instance 3:")
print("G =", G)
print("S =", S)
update_hypotheses_positive(G, S, instance4)
print("\nAfter instance 4:")
print("G =", G)
print("S =", S)

Link: https://www.javatpoint.com/candidate-elimination-algorithm-in-python

Find S Algorithm

import pandas as pd
import numpy as np

# Read the Excel file

data = pd.read_excel('F:/sample.xlsx')

print(data, "\n")

# Convert the DataFrame to a NumPy array

d = np.array(data)[:, :-1]
print("The attributes are: ", d)

target = np.array(data)[:, -1]

print("The target is: ", target)
def train(c, t):
specific_hypothesis = None # Initialize specific_hypothesis

# Find the first positive example

for i, val in enumerate(t):
if val == "Yes":
specific_hypothesis = c[i].copy()
break

# If no positive example was found, handle the case

if specific_hypothesis is None:
print("No positive examples found.")
return None # or return a default value

# Generalize the hypothesis based on positive examples

for i, val in enumerate(c):
if t[i] == "Yes":
for x in range(len(specific_hypothesis)):
if val[x] != specific_hypothesis[x]:
specific_hypothesis[x] = '?'

return specific_hypothesis

# Print the final hypothesis

final_hypothesis = train(d, target)
if final_hypothesis is not None:
print("The final hypothesis is:", final_hypothesis)

https://www.blackbox.ai/chat/JUXjead

Program 5:

import pandas as pd

# Create a simple dataset

data = {
'Outlook': ['Sunny', 'Sunny', 'Overcast', 'Rain', 'Rain', 'Rain', 'Overcast',
'Sunny', 'Sunny', 'Rain', 'Sunny', 'Overcast', 'Overcast', 'Rain'],
'Temperature': ['Hot', 'Hot', 'Hot', 'Mild', 'Cool', 'Cool', 'Mild', 'Mild',
'Hot', 'Mild', 'Cool', 'Mild', 'Cool', 'Cool'],
'Humidity': ['High', 'High', 'High', 'High', 'Normal', 'Normal', 'Normal',
'High', 'Normal', 'Normal', 'Normal', 'High', 'Normal', 'High'],
'Windy': [False, True, False, False, False, True, True, False, False, False,
True, True, False, True],
'Play': ['No', 'No', 'Yes', 'Yes', 'Yes', 'No', 'Yes', 'No', 'Yes', 'Yes',
'Yes', 'Yes', 'Yes', 'No']
}

df = pd.DataFrame(data)

from sklearn.preprocessing import LabelEncoder

# Initialize label encoders

le = LabelEncoder()

# Encode categorical features

df['Outlook'] = le.fit_transform(df['Outlook'])
df['Temperature'] = le.fit_transform(df['Temperature'])
df['Humidity'] = le.fit_transform(df['Humidity'])
df['Windy'] = le.fit_transform(df['Windy'])
df['Play'] = le.fit_transform(df['Play'])

# Separate features and target variable

X = df.drop('Play', axis=1)
y = df['Play']

from sklearn.tree import DecisionTreeClassifier

from sklearn.model_selection import train_test_split
from sklearn import tree
import matplotlib.pyplot as plt

# Split the dataset into training and testing sets

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,
random_state=42)

# Create the decision tree classifier

clf = DecisionTreeClassifier(criterion='entropy', random_state=42)

# Fit the model

clf.fit(X_train, y_train)

# Evaluate the model

accuracy = clf.score(X_test, y_test)
print(f'Accuracy: {accuracy:.2f}')

# Visualize the decision tree

plt.figure(figsize=(12,8))
tree.plot_tree(clf, filled=True, feature_names=X.columns, class_names=['No',
'Yes'])
plt.show()

https://www.blackbox.ai/chat/1GKx7r8

Program 6:
https://www.blackbox.ai/chat/OQJAQqg

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification, make_moons, make_circles
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Create datasets
datasets = {
"Linear": make_classification(n_samples=100, n_features=2, n_informative=2,
n_redundant=0, random_state=42),
"Moons": make_moons(n_samples=100, noise=0.1, random_state=42),
"Circles": make_circles(n_samples=100, noise=0.1, factor=0.5, random_state=42)
}

# Function to evaluate decision tree performance

def evaluate_decision_tree(X, y, max_depths):
train_accuracies = []
test_accuracies = []
 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3,
random_state=42)

for depth in max_depths:

clf = DecisionTreeClassifier(max_depth=depth, criterion='entropy',
random_state=42)
clf.fit(X_train, y_train)

train_pred = clf.predict(X_train)
test_pred = clf.predict(X_test)

train_accuracies.append(accuracy_score(y_train, train_pred))
test_accuracies.append(accuracy_score(y_test, test_pred))

return train_accuracies, test_accuracies

# Define maximum depths to evaluate

max_depths = range(1, 11)

# Store results
results = {}

for name, (X, y) in datasets.items():

train_acc, test_acc = evaluate_decision_tree(X, y, max_depths)
results[name] = (train_acc, test_acc)

# Plotting the results

plt.figure(figsize=(15, 10))

for name, (train_acc, test_acc) in results.items():

plt.plot(max_depths, train_acc, label=f'{name} - Train', marker='o')
plt.plot(max_depths, test_acc, label=f'{name} - Test', marker='x')

plt.title('Decision Tree Performance with Varying Depths')

plt.xlabel('Max Depth')
plt.ylabel('Accuracy')
plt.xticks(max_depths)
plt.ylim(0, 1)
plt.legend()
plt.grid()
plt.show()

Program 7:

https://www.blackbox.ai/chat/zI39t6T

Program 8:
https://www.blackbox.ai/chat/qWVwR5W

Program 9:

import pandas as pd

housing = pd.read_csv("F:\\python\\housing.csv")

print(housing.head())

https://www.blackbox.ai/chat/Rp09DKf
Program 10:

https://www.geeksforgeeks.org/evaluation-metrics-for-classification-model-in-
python/