Basic program using python
1)Program to print multiplication table for given no.
Solution-

Program published on https://beginnersbook.com

Python Program to Print Multiplication Table of a Number

num = int(input("Enter the number: "))

print("Multiplication Table of", num)
for i in range(1, 11):
print(num,"X",i,"=",num * i)

Output:
Enter the number: 6
Multiplication Table of 6
6 X 1 = 6
6 X 2 = 12
6 X 3 = 18
6 X 4 = 24
6 X 5 = 30
6 X 6 = 36
6 X 7 = 42
6 X 8 = 48
6 X 9 = 54
6 X 10 = 60

2. )Program to check whether the given no is prime or not
   Solution-

Python program to check if the input number is prime or not

num = 407

take input from the user

num = int(input("Enter a number: "))

prime numbers are greater than 1

if num > 1:

check for factors

for i in range(2,num):
if (num % i) == 0:
print(num,"is not a prime number")
print(i,"times",num//i,"is",num)
break
else:
print(num,"is a prime number")

if input number is less than

or equal to 1, it is not prime

else:
print(num,"is not a prime number")
Output
407 is not a prime number
11 times 37 is 407

3)Program to find factorial of the given no
Solution-

Python program to find the factorial of a number provided by the user.

change the value for a different result

num = 7

uncomment to take input from the user

#num = int(input("Enter a number: "))
factorial = 1

check if the number is negative, positive or zero

if num < 0:
print("Sorry, factorial does not exist for negative numbers")
elif num == 0:
print("The factorial of 0 is 1")
else:
for i in range(1,num + 1):
factorial = factorial*i
print("The factorial of",num,"is",factorial)
Output
The factorial of 7 is 5040

4)Program to Illusrate different set operations
Solution-

Program to perform different set operations like in mathematics

define three sets

E = {0, 2, 4, 6, 8};
N = {1, 2, 3, 4, 5};

set union

print("Union of E and N is",E | N)

set intersection

print("Intersection of E and N is",E & N)

set difference

print("Difference of E and N is",E - N)

set symmetric difference

print("Symmetric difference of E and N is",E ^ N)
Output
Union of E and N is {0, 1, 2, 3, 4, 5, 6, 8}
Intersection of E and N is {2, 4}
Difference of E and N is {8, 0, 6}
Symmetric difference of E and N is {0, 1, 3, 5, 6, 8}

5)Program to implement Depth first Search Traversal
Solution-

Python3 program to print DFS traversal

from a given given graph

from collections import defaultdict

This class represents a directed graph using

adjacency list representation

class Graph:

Driver code

Create a graph given

in the above diagram

g = Graph()
g.addEdge(0, 1)
g.addEdge(0, 2)
g.addEdge(1, 2)
g.addEdge(2, 0)
g.addEdge(2, 3)
g.addEdge(3, 3)

print("Following is DFS from (starting from vertex 2)")
g.DFS(2)

Output:
Following is Depth First Traversal (starting from vertex 2)
2 0 1 3

6)Program to Implement Breadth first search Transversal
Solution-

Python3 Program to print BFS traversal

from a given source vertex. BFS(int s)

traverses vertices reachable from s.

from collections import defaultdict

This class represents a directed graph

using adjacency list representation

class Graph:

Driver code

Create a graph given in

the above diagram

g = Graph()
g.addEdge(0, 1)
g.addEdge(0, 2)
g.addEdge(1, 2)
g.addEdge(2, 0)
g.addEdge(2, 3)
g.addEdge(3, 3)

print ("Following is Breadth First Traversal"
" (starting from vertex 2)")
g.BFS(2)

Output:
Following is Breadth First Traversal (starting from vertex 2)
2 0 3 1

7)Program to Implement water jug Problem
Solution-

This function is used to initialize the

dictionary elements with a default value.

from collections import defaultdict

jug1 and jug2 contain the value

for max capacity in respective jugs

and aim is the amount of water to be measured.

jug1, jug2, aim = 4, 3, 2

Initialize dictionary with

default value as false.

visited = defaultdict(lambda: False)

Recursive function which prints the

intermediate steps to reach the final

solution and return boolean value

(True if solution is possible, otherwise False).

amt1 and amt2 are the amount of water present

in both jugs at a certain point of time.

def waterJugSolver(amt1, amt2):

print("Steps: ")

Call the function and pass the

initial amount of water present in both jugs.

waterJugSolver(0, 0)

Output:
Steps:
0 0
4 0
4 3
0 3
3 0
3 3
4 2
0 2

8)Program to Implement K nearest Neigbor algorithm
Solution-
import unicodecsv
import random
import operator
import math

#getdata() function definition
def getdata(filename):
with open(filename,'rb') as f:
reader = unicodecsv.reader(f)
return list(reader)

#random train test data split function definition
def shuffle(i_data):
random.shuffle(i_data)
train_data = i_data[:int(0.730)]
test_data = i_data[int(0.730):]
return train_data, test_data

def euclideanDist(x, xi):
d = 0.0
for i in range(len(x)-1):
d += pow((float(x[i])-float(xi[i])),2) #euclidean distance
d = math.sqrt(d)
return d

#KNN prediction and model training
def knn_predict(test_data, train_data, k_value):
for i in test_data:
eu_Distance =[]
knn = []
good = 0

#Accuracy calculation function
def accuracy(test_data):
correct = 0
for i in test_data:
if i[5] == i[6]:
correct += 1
accuracy = float(correct)/len(test_data) *100 #accuracy
return accuracy

dataset = getdata('i_data_sample_30.csv') #getdata function call with csv file as parameter
train_dataset, test_dataset = shuffle(dataset) #train test data split
K = 5 # Assumed K value
knn_predict(test_dataset, train_dataset, K)
print test_dataset
print "Accuracy : ",accuracy(test_dataset)

9)Program to Implement regression algorithm
Solution-
import numpy as np
import matplotlib.pyplot as plt

def estimate_coef(x, y):
# number of observations/points
n = np.size(x)

def plot_regression_line(x, y, b):
# plotting the actual points as scatter plot
plt.scatter(x, y, color = "m",
marker = "o", s = 30)

def main():
# observations
x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
y = np.array([1, 3, 2, 5, 7, 8, 8, 9, 10, 12])

if name == "main":
main()

Output :
Estimated coefficients:
b_0 = -0.0586206896552
b_1 = 1.45747126437

10)Program to Implement Random forest algorithm
Solution-

Random Forest Algorithm on Sonar Dataset

from random import seed
from random import randrange
from csv import reader
from math import sqrt

Load a CSV file

def load_csv(filename):
dataset = list()
with open(filename, 'r') as file:
csv_reader = reader(file)
for row in csv_reader:
if not row:
continue
dataset.append(row)
return dataset

Convert string column to float

def str_column_to_float(dataset, column):
for row in dataset:
row[column] = float(row[column].strip())

Convert string column to integer

def str_column_to_int(dataset, column):
class_values = [row[column] for row in dataset]
unique = set(class_values)
lookup = dict()
for i, value in enumerate(unique):
lookup[value] = i
for row in dataset:
row[column] = lookup[row[column]]
return lookup

Split a dataset into k folds

def cross_validation_split(dataset, n_folds):
dataset_split = list()
dataset_copy = list(dataset)
fold_size = int(len(dataset) / n_folds)
for i in range(n_folds):
fold = list()
while len(fold) < fold_size:
index = randrange(len(dataset_copy))
fold.append(dataset_copy.pop(index))
dataset_split.append(fold)
return dataset_split

Calculate accuracy percentage

def accuracy_metric(actual, predicted):
correct = 0
for i in range(len(actual)):
if actual[i] == predicted[i]:
correct += 1
return correct / float(len(actual)) * 100.0

Evaluate an algorithm using a cross validation split

def evaluate_algorithm(dataset, algorithm, n_folds, *args):
folds = cross_validation_split(dataset, n_folds)
scores = list()
for fold in folds:
train_set = list(folds)
train_set.remove(fold)
train_set = sum(train_set, [])
test_set = list()
for row in fold:
row_copy = list(row)
test_set.append(row_copy)
row_copy[-1] = None
predicted = algorithm(train_set, test_set, *args)
actual = [row[-1] for row in fold]
accuracy = accuracy_metric(actual, predicted)
scores.append(accuracy)
return scores

Split a dataset based on an attribute and an attribute value

def test_split(index, value, dataset):
left, right = list(), list()
for row in dataset:
if row[index] < value:
left.append(row)
else:
right.append(row)
return left, right

Calculate the Gini index for a split dataset

def gini_index(groups, classes):
# count all samples at split point
n_instances = float(sum([len(group) for group in groups]))
# sum weighted Gini index for each group
gini = 0.0
for group in groups:
size = float(len(group))
# avoid divide by zero
if size == 0:
continue
score = 0.0
# score the group based on the score for each class
for class_val in classes:
p = [row[-1] for row in group].count(class_val) / size
score += p * p
# weight the group score by its relative size
gini += (1.0 - score) * (size / n_instances)
return gini

Select the best split point for a dataset

def get_split(dataset, n_features):
class_values = list(set(row[-1] for row in dataset))
b_index, b_value, b_score, b_groups = 999, 999, 999, None
features = list()
while len(features) < n_features:
index = randrange(len(dataset[0])-1)
if index not in features:
features.append(index)
for index in features:
for row in dataset:
groups = test_split(index, row[index], dataset)
gini = gini_index(groups, class_values)
if gini < b_score:
b_index, b_value, b_score, b_groups = index, row[index], gini, groups
return {'index':b_index, 'value':b_value, 'groups':b_groups}

Create a terminal node value

def to_terminal(group):
outcomes = [row[-1] for row in group]
return max(set(outcomes), key=outcomes.count)

Create child splits for a node or make terminal

def split(node, max_depth, min_size, n_features, depth):
left, right = node['groups']
del(node['groups'])
# check for a no split
if not left or not right:
node['left'] = node['right'] = to_terminal(left + right)
return
# check for max depth
if depth >= max_depth:
node['left'], node['right'] = to_terminal(left), to_terminal(right)
return
# process left child
if len(left) <= min_size:
node['left'] = to_terminal(left)
else:
node['left'] = get_split(left, n_features)
split(node['left'], max_depth, min_size, n_features, depth+1)
# process right child
if len(right) <= min_size:
node['right'] = to_terminal(right)
else:
node['right'] = get_split(right, n_features)
split(node['right'], max_depth, min_size, n_features, depth+1)

Build a decision tree

def build_tree(train, max_depth, min_size, n_features):
root = get_split(train, n_features)
split(root, max_depth, min_size, n_features, 1)
return root

Make a prediction with a decision tree

def predict(node, row):
if row[node['index']] < node['value']:
if isinstance(node['left'], dict):
return predict(node['left'], row)
else:
return node['left']
else:
if isinstance(node['right'], dict):
return predict(node['right'], row)
else:
return node['right']

Create a random subsample from the dataset with replacement

def subsample(dataset, ratio):
sample = list()
n_sample = round(len(dataset) * ratio)
while len(sample) < n_sample:
index = randrange(len(dataset))
sample.append(dataset[index])
return sample

Make a prediction with a list of bagged trees

def bagging_predict(trees, row):
predictions = [predict(tree, row) for tree in trees]
return max(set(predictions), key=predictions.count)

Random Forest Algorithm

def random_forest(train, test, max_depth, min_size, sample_size, n_trees, n_features):
trees = list()
for i in range(n_trees):
sample = subsample(train, sample_size)
tree = build_tree(sample, max_depth, min_size, n_features)
trees.append(tree)
predictions = [bagging_predict(trees, row) for row in test]
return(predictions)

Test the random forest algorithm

seed(2)

load and prepare data

filename = 'sonar.all-data.csv'
dataset = load_csv(filename)

convert string attributes to integers

for i in range(0, len(dataset[0])-1):
str_column_to_float(dataset, i)

convert class column to integers

str_column_to_int(dataset, len(dataset[0])-1)

evaluate algorithm

n_folds = 5
max_depth = 10
min_size = 1
sample_size = 1.0
n_features = int(sqrt(len(dataset[0])-1))
for n_trees in [1, 5, 10]:
scores = evaluate_algorithm(dataset, random_forest, n_folds, max_depth, min_size, sample_size, n_trees, n_features)
print('Trees: %d' % n_trees)
print('Scores: %s' % scores)
print('Mean Accuracy: %.3f%%' % (sum(scores)/float(len(scores))))