AI Assignment-3

Name: Mohammad Danish

System ID: 2021302678

Class: B.Tech(IT) 6th Sem

Submitted To: Dr. Yogesh Singh Rathore

Q1. Solve these:-
a) SEND + MORE = MONEY
b) CROSS + ROADS = DANGER
c) DONALD + GERALD = ROBERT

Ans1. Solution:-

a) Here's how we can approach this problem:

Assign unique digits to each letter (S, E, N, D, M, O, R, Y).

Ensure that the sum of the digits in the units place (D + E)
equals the digit in the units place of the sum (Y).
Carry over any extra digits to the next column.
Iterate until all digits are assigned and the equation holds true.
Let's solve it step by step:

Start by assigning values to the letters. Since we want the value

of MONEY, M cannot be 0. Also, since SEND + MORE =
MONEY, it's clear that S and M must be 1, as the sum of two
four-digit numbers cannot exceed 19998.

S=1
M=1
Now, let's consider the units place: D + E = Y. Since D and E
cannot be 0, the only possibility for D + E = Y is 10. This means:

Y = 0 (Carry 1 over to the next column)

Now, consider the tens place: N + R + O = E + 10. Since E is
either 0 or 1, O must be 8 or 9.

O = 9 (to maximize the value of N + R)

N + R + 1 = 10 + E
Now, let's consider the hundreds place: E + N + M = 10N + D.
Since M and N are both 1, E must be 8 (to maximize the value
of N + R).

E = 8 (Carry 1 over to the next column)

1 + N + 1 = 10 + D
N + 2 = 10 + D
Finally, consider the thousands place: S + M + O = N. Since S
and M are both 1, and O is 9, the only possibility for N is 0.

N = 0 (Carry 1 over to the next column)

S+1+9=0
Now, we have the following values:

S=1
E=8
N=0
D=7
M=1
O=9
R=6
Y=0

b) To solve the cryptarithmetic puzzle

CROSS + ROADS = DANGER
CROSS+ROADS=DANGER, we need to assign distinct digits
to each letter (C, R, O, S, A, D, N, G, E) so that the equation
holds true. Here's the step-by-step solution:

Identify Constraints:
Since "CROSS" and "ROADS" both have 5 letters, the result
"DANGER" must have 6 letters.
The sum of two 5-digit numbers can produce a 6-digit result that
starts with either 1 or 2 (the maximum sum of two 5-digit
numbers being 199998).
Trial and Error Method:

We'll start by guessing values for some of the letters and

gradually refine our guesses based on the constraints and the
partial results.
Let's begin:
Since "DANGER" starts with 'D', 'C' must be 1 or 2. However,
'C' cannot be 2 because "ROADS" already has 'O' as 2, so 'C'
must be 1.
With 'C' being 1, 'R' (in "ROADS") must be 0 (as it's in the tens
place), and 'A' (in "DANGER") must be 9 (since 'C' cannot be 0,
and 'A' + 'C' = 'D' must be greater than 10).
Now, since 'R' (in "ROADS") is 0, 'O' must be 9 (since it's in the
ones place).
With 'O' being 9, 'S' (in "CROSS") must be 8 (as 'O' is already
used and 'S' + 'O' = 'N' must be less than 10).
'N' (in "DANGER") must be 0 (as 'R' is 0 and 'N' + 'S' must be
greater than 10).
Now, we can deduce that 'G' (in "DANGER") must be 7 (since
it's not used yet).
Finally, we're left with 'E'. It must be 2 (as it's not used yet, and
'E' + 'R' = 'G' = 7).
Let's verify the solution:

CROSS = 18988
CROSS= 18988
ROADS = 01909
ROADS= 01909
DANGER = 198797
DANGER=198797
So,
CROSS + ROADS = 18988 + 01909 = 198797
CROSS+ROADS=18988+01909=198797, which satisfies the
equation.

c) We need to find unique digits to replace each letter (D, O, N,

A, L, G, E, R, B, and T) such that the equation holds true. We'll
approach this problem systematically through trial and error,
ensuring that each digit is used only once and that the leading
digits (D, G, and R) are non-zero.
Let's start by trying different combinations:

We'll begin by checking if the sum of the two largest numbers (9

+ 9) could result in a single-digit number. Since it can't, we can
conclude that neither D nor G can be 9.
We'll now attempt to find suitable values for R, T, E, and B.
Since the sum of the two largest numbers (18 + 18) could result
in a number between 20 and 25, we can conclude that neither R
nor T can be 9 or 8. Therefore, R and T must be 7 and 6,
respectively.
Now, considering the carry from the addition of E and L, E must
be less than 7 (the maximum carry value) but cannot be 9, 7, or
6. Therefore, E must be 5.
With E as 5, we need to find values for L, O, N, A, and B, with
a carry of 1 from the addition of D and G. We know that the
maximum possible value for B is 4. So, L + L must be greater
than 9 to produce a carry. This suggests that L is either 6, 7, or 8.
Trying 6, we see that it's not possible to find a valid assignment
for the remaining digits.
Therefore, we try L as 7. With L as 7, the possible values for A
and B are 1 and 4, respectively. With the available digits, we
can easily assign O = 0, N = 2, and D = 3.

So, the solution to the equation:-

DONALD+GERALD=ROBERT is
735174 + 621745 = 1355919
735174+621745=1355919.

Q2. Explain the concept of Best First Search give example.

Ans2. Best-First Search (BFS) is a graph traversal algorithm that

explores a graph by selecting the most promising node based on
a heuristic evaluation function. Unlike Breadth-First Search
(BFS) or Depth-First Search (DFS), which explore vertices in a
predetermined order, BFS dynamically selects nodes to expand
based on an estimate of their potential to lead to the goal state.
The heuristic evaluation function guides the search towards
nodes that appear to be closer to the goal, potentially leading to
more efficient search in terms of time and space.

Here's how Best-First Search works:

Initialization: Start with an initial state (or node) and initialize a

priority queue to store nodes awaiting expansion. Assign a
heuristic value to each node representing its estimated distance
or cost to the goal.

Expansion: While the priority queue is not empty, select the

node with the highest priority (lowest heuristic value) from the
queue. Expand the selected node by generating its successors (or
neighbors) and computing heuristic values for each successor.

Goal Test: If the selected node is a goal state, the search

terminates, and the solution is found. Otherwise, continue
expanding nodes until a goal state is reached or the search space
is exhausted.

Priority Queue Update: After expanding a node, add its

successors to the priority queue. The priority queue is
maintained in such a way that nodes with lower heuristic values
are given higher priority for expansion.

Repeat: Repeat steps 2-4 until a solution is found or the search

space is fully explored.

The effectiveness of Best-First Search heavily depends on the

quality of the heuristic evaluation function. A good heuristic
function should provide accurate estimates of the remaining cost
to reach the goal state from any given node. Common heuristics
used in Best-First Search include Manhattan distance, Euclidean
distance, and Hamming distance, depending on the problem
domain.

Here's an example to illustrate Best-First Search:

Consider a navigation system tasked with finding the shortest
route from a start location to a destination on a road network.
Each node in the graph represents a location, and edges
represent road segments between locations. The heuristic
evaluation function could be the straight-line distance
(Euclidean distance) between each node and the destination.

Start Node: Current location

Goal Node: Destination location
Heuristic Function: Euclidean distance between nodes and the
destination

The Best-First Search algorithm would prioritize expanding

nodes that are closer to the destination, allowing the navigation
system to efficiently find the shortest route from the start to the
destination. The search continues until the destination node is
reached, providing the optimal route based on the heuristic
guidance.

Q3. Explain the concept of hill climbing.

Ans3. Hill climbing is a local search algorithm used in

optimization problems to find the best solution in a given search
space. It belongs to the category of greedy algorithms because it
makes decisions based solely on the current state without
considering future consequences. The basic idea behind hill
climbing is to iteratively move towards the direction of
increasing value (ascending a "hill") until a local maximum (or
minimum) is reached.

Here's how the hill climbing algorithm works:

Initialization: Start with an initial solution or state.

Evaluation: Evaluate the current solution to determine its
quality. This could involve calculating a cost function, objective
function, or any other measure of performance.

Neighbor Generation: Generate neighboring solutions by

making small modifications to the current solution. These
modifications typically involve making small changes or
"moves" from the current solution to explore nearby solutions in
the search space.

Selection: Select the best neighboring solution among the

generated neighbors based on its evaluation function. If the
neighboring solution improves upon the current solution, move
to that solution and repeat the process. Otherwise, terminate the
algorithm.

Termination: Repeat steps 3 and 4 until a termination condition

is met. This could be reaching a maximum number of iterations,
achieving a satisfactory solution quality, or reaching a
predefined threshold of improvement.

Hill climbing is effective for finding local optima in

optimization problems but may not always find the global
optimum due to its greedy nature. The algorithm can get stuck in
local optima or plateau regions, especially in problems with
rugged or deceptive landscapes where the gradient information
is unreliable. To mitigate this issue, variants of hill climbing
algorithms, such as simulated annealing and genetic algorithms,
introduce mechanisms for escaping local optima and exploring a
more extensive search space.

Q4. What are the challenges face during hill climbing?

Ans4. Hill climbing is a simple and intuitive optimization

algorithm, but it also faces several challenges that can impact its
effectiveness in finding optimal solutions. Some of the main
challenges faced during hill climbing include:
Local Optima: Hill climbing tends to get trapped in local
optima, where the current solution is better than its neighbors
but not necessarily the best possible solution in the entire search
space. Once it reaches a local optimum, the algorithm cannot
escape it without backtracking, which is not part of the hill
climbing approach.

Plateaus and Ridges: Plateaus and ridges are regions of the

search space where the objective function remains constant or
changes very slowly. Hill climbing may struggle to navigate
through these regions efficiently, as small changes in the current
solution may not result in improvements. This can slow down
the convergence of the algorithm or lead to premature
termination without reaching a satisfactory solution.

Flat Regions: Similar to plateaus and ridges, flat regions are

areas of the search space where the objective function is
relatively constant, making it challenging for hill climbing to
distinguish between neighboring solutions. In such cases, the
algorithm may oscillate or wander aimlessly without making
significant progress towards the optimal solution.

Initial Solution Dependency: Hill climbing's performance is

highly dependent on the choice of the initial solution. If the
initial solution is far from the global optimum or located in a
region with poor local optima, the algorithm may struggle to
find a satisfactory solution within a reasonable time frame.

Gradient Misleadingness: Hill climbing relies on gradient

information to guide its search, assuming that small changes in
the solution space lead to improvements in the objective
function. However, in some cases, the gradient information may
be misleading, leading the algorithm to make suboptimal
decisions or get stuck in regions of the search space that do not
lead to improvements.
Convergence to Suboptimal Solutions: Even if hill climbing
reaches a local optimum, there is no guarantee that the solution
is globally optimal. The algorithm may converge to suboptimal
solutions due to its greedy nature, especially in problems with
complex and deceptive objective functions.

Q5. Explain the concept of A* algorithm and compare it with

AO* algorithm.

Ans5. The A* algorithm is a widely used search algorithm in

artificial intelligence for finding the shortest path or optimal
solution to a problem. It combines elements of both uniform
cost search (Dijkstra's algorithm) and heuristic search, utilizing
a heuristic function to guide the search towards the most
promising nodes while ensuring completeness and optimality
under certain conditions.

Here's an overview of the A* algorithm:

Initialization: Initialize two sets: an open list containing nodes

to be evaluated and a closed list containing nodes that have
already been evaluated. Start with the initial node and add it to
the open list.

Evaluation: While the open list is not empty, select the node
with the lowest combined cost (the sum of the actual cost from
the start node to the current node and the estimated cost from the
current node to the goal node) and remove it from the open list.
If the selected node is the goal node, terminate the search and
return the optimal path. Otherwise, expand the selected node by
generating its neighboring nodes and adding them to the open
list.

Heuristic Function: A* uses a heuristic function to estimate the

cost from each node to the goal node. This heuristic function
provides a "guess" or estimate of the remaining cost, guiding the
search towards nodes that are likely to lead to the optimal
solution.

Optimality: A* is both complete (guaranteed to find a solution

if one exists) and optimal (guaranteed to find the optimal
solution with respect to the provided heuristic function) under
certain conditions, such as having an admissible heuristic (never
overestimates the true cost) and a finite search space.

The AO* algorithm, short for Adaptive A*, is an extension of

the A* algorithm that dynamically adjusts the heuristic function
during the search to improve efficiency and accuracy. It
addresses some of the limitations of traditional A* by
continuously refining the heuristic estimates based on the
information gathered during the search.

Here are the key differences between A* and AO*:

Heuristic Adaptation: A* uses a fixed heuristic function

throughout the search, while AO* adapts the heuristic function
dynamically based on the information gathered during the
search process. This adaptation allows AO* to refine the
heuristic estimates over time, potentially leading to more
accurate estimates and faster convergence to the optimal
solution.

Efficiency: AO* can be more efficient than A* in certain

scenarios, especially when the initial heuristic estimates are
inaccurate or when the search space is large and complex. By
continuously updating the heuristic estimates, AO* can avoid
getting stuck in local optima and explore a broader search space
more effectively.

Implementation Complexity: AO* is generally more complex

to implement than A* due to the additional overhead of heuristic
adaptation and bookkeeping. Implementing AO* requires
carefully designing and updating the heuristic function to ensure
correctness and efficiency.

Convergence: Both A* and AO* are guaranteed to converge to

the optimal solution under certain conditions, but AO* may
converge faster in practice due to its adaptive nature. However,
the convergence rate of AO* depends on the quality of the
initial heuristic estimates and the dynamics of the search space.