lec-05-arrays(1D)

December 20, 2024

0.1 Arrays
An array is a collection of elements of the same data type stored in contiguous memory
locations.
It can be thought of as a group of variables with the same name and data type that are accessed
using a common index. The index is used to identify the location of a specific element in the array.
Arrays are implemented as objects, which means that they have methods that can be used to access
and manipulate their elements.
Arrays have many advantages, including fast access times, easy implementation, and efficient mem-
ory usage. They are often used to store collections of data that are of the same type, such as a list
of numbers or a set of strings.
Arrays can be used in a variety of applications, including sorting algorithms, searching algorithms,
and data compression. They are also commonly used in graphical user interfaces (GUIs) to store
and display data.

0.1.1 Properties of Arrays

• Indexing: Access elements using indices (e.g., arr[0]).
• Contiguous Memory: All elements are stored in adjacent memory cells.
• Size: Fixed at the time of creation for static arrays.
• Efficient Access: Direct access using index (O(1) time complexity).
• Sequential Traversal: Common operations include looping through elements.

Types
• One-dimensional arrays
• Multidimensional Arrays
• Dynamic arrays

0.1.2 Functions of Arrays

• Basic Operations
– Traversing (e.g., for loop).
– Insertion (at specific indices).
– Deletion (by shifting elements).
– Searching (linear or binary).
– Sorting (e.g., bubble sort, quicksort).

1
 • Advanced Operations
– Slicing (in languages like Python).
– Resizing (dynamic arrays).

0.1.3 One-dimensional array

• All the data items constituting the group share the same name.
• Individual elements are accessed by specifying the index.
• Storage: Starting from a given memory location, the successive array elements are allocated
space in consecutive memory locations
• In the figure given below, 200 is the starting address
• The array index starts at zero. That is, the location of arr[0] is at 200
• Let k is the number of bytes allocated per array element
• Element arr[i] is allocated at the memory location having address x + i × k
Image source
[5]: #Experiment 1: Define one-dimensional array

class MyArray:
def __init__(self):
self.array = []

def insert(self, index, value):

if index < 0 or index > len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + [value] + self.array[index:]

def delete(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + self.array[index + 1:]

def get(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
return self.array[index]

def size(self):
count = 0
for _ in self.array:
count += 1
return count

def display(self):
for element in self.array:
print(element, end=" ")
print()

2
arr = MyArray()

arr.insert(0, 5)
print("After inserting 5 at the beginning:")
arr.display()

arr.insert(1, 10)
print("After inserting 10 at position 1:")
arr.display()

arr.insert(arr.size(), 20)
print("After inserting 20 at the end:")
arr.display()

arr.delete(0)
print("After deleting element from the beginning:")
arr.display()

arr.delete(0)
print("After deleting element at position 0:")
arr.display()

arr.delete(arr.size() - 1)
print("After deleting element from the end:")
arr.display()

print("Size of the array:", arr.size())

middle_index = arr.size() // 2
arr.insert(middle_index, 25)
print("After inserting 25 in the middle::")
arr.display()

After inserting 5 at the beginning:

5
After inserting 10 at position 1:
5 10
After inserting 20 at the end:
5 10 20
After deleting element from the beginning:
10 20
After deleting element at position 0:
20
After deleting element from the end:

3
 Size of the array: 0
After inserting 25 in the middle::
25

[13]: # Experiment 2: Basic Statistical Calculations

class MyArray:
def __init__(self):
self.array = []

def insert(self, index, value):

if index < 0 or index > len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + [value] + self.array[index:]

def delete(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + self.array[index + 1:]

def get(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
return self.array[index]

def size(self):
count = 0
for _ in self.array:
count += 1
return count

def display(self):
for element in self.array:
print(element, end=" ")
print()

def statistical_analysis(self):
mean = sum(self.array) / len(self.array)
variance = sum((x - mean) ** 2 for x in self.array) / len(self.array)
minimum = min(self.array)
maximum = max(self.array)

print("Mean:", mean)
print("Variance:", variance)
print("Minimum:", minimum)
print("Maximum:", maximum)

4
 arr = MyArray()
arr.insert(0, 10)
arr.insert(arr.size(), 15)
arr.insert(arr.size(), 20)
arr.insert(arr.size(), 25)
arr.insert(arr.size(), 30)
arr.insert(arr.size(), 35)
arr.insert(arr.size(), 40)
print("Array after inserting elements: ")
arr.display()
arr.statistical_analysis()

Array after inserting elements:

10 15 20 25 30 35 40
Mean: 25.0
Variance: 100.0
Minimum: 10
Maximum: 40

[16]: # Experiment 3: Array Element Filtering

class MyArray:
def __init__(self):
self.array = []

def insert(self, index, value):

if index < 0 or index > len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + [value] + self.array[index:]

def delete(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + self.array[index + 1:]

def clear(self):
self.array = []

def get(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
return self.array[index]

def size(self):
count = 0
for _ in self.array:

5
 count += 1
return count

def display(self):
for element in self.array:
print(element, end=" ")
print()

def statistical_analysis(self):
mean = sum(self.array) / len(self.array)
variance = sum((x - mean) ** 2 for x in self.array) / len(self.array)
minimum = min(self.array)
maximum = max(self.array)

print("Mean:", mean)
print("Variance:", variance)
print("Minimum:", minimum)
print("Maximum:", maximum)

def filtering(self):
even_numbers = [x for x in self.array if x % 2 == 0]
large_numbers = [x for x in self.array if x > 5]

print("Even Numbers:", even_numbers)

print("Large Numbers:", large_numbers)

arr = MyArray()
arr.clear()
arr.insert(0, 1)
arr.insert(arr.size(), 2)
arr.insert(arr.size(), 3)
arr.insert(arr.size(), 4)
arr.insert(arr.size(), 5)
arr.insert(arr.size(), 6)
arr.insert(arr.size(), 7)
arr.insert(arr.size(), 8)
arr.insert(arr.size(), 9)
arr.insert(arr.size(), 10)
print("Array after inserting elements: ")
arr.display()
arr.filtering()

Array after inserting elements:

1 2 3 4 5 6 7 8 9 10
Even Numbers: [2, 4, 6, 8, 10]
Large Numbers: [6, 7, 8, 9, 10]

6
[18]: # Experiment 4: Array Transformation

class MyArray:
def __init__(self):
self.array = []

def insert(self, index, value):

if index < 0 or index > len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + [value] + self.array[index:]

def delete(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + self.array[index + 1:]

def clear(self):
self.array = []

def get(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
return self.array[index]

def size(self):
count = 0
for _ in self.array:
count += 1
return count

def display(self):
for element in self.array:
print(element, end=" ")
print()

def statistical_analysis(self):
mean = sum(self.array) / len(self.array)
variance = sum((x - mean) ** 2 for x in self.array) / len(self.array)
minimum = min(self.array)
maximum = max(self.array)

print("Mean:", mean)
print("Variance:", variance)
print("Minimum:", minimum)
print("Maximum:", maximum)

def filtering(self):

7
 even_numbers = [x for x in self.array if x % 2 == 0]
large_numbers = [x for x in self.array if x > 5]

print("Even Numbers:", even_numbers)

print("Large Numbers:", large_numbers)

def transformation(self):
squared = [x**2 for x in self.array]
absolute = [abs(x) for x in self.array]

print("Squared Array:", squared)

print("Absolute Values:", absolute)

arr = MyArray()
arr.clear()
arr.insert(0, 1)
arr.insert(arr.size(), 2)
arr.insert(arr.size(), 3)
arr.insert(arr.size(), -4)
arr.insert(arr.size(), -5)
print("Array after inserting elements: ")
arr.display()
arr.transformation()

Array after inserting elements:

1 2 3 -4 -5
Squared Array: [1, 4, 9, 16, 25]
Absolute Values: [1, 2, 3, 4, 5]

[23]: # Experiment 5: Sorting in Arrays

class MyArray:
def __init__(self):
self.array = []

def insert(self, index, value):

if index < 0 or index > len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + [value] + self.array[index:]

def delete(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + self.array[index + 1:]

def clear(self):

8
 self.array = []

def get(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
return self.array[index]

def size(self):
count = 0
for _ in self.array:
count += 1
return count

def display(self):
for element in self.array:
print(element, end=" ")
print()

def statistical_analysis(self):
mean = sum(self.array) / len(self.array)
variance = sum((x - mean) ** 2 for x in self.array) / len(self.array)
minimum = min(self.array)
maximum = max(self.array)

print("Mean:", mean)
print("Variance:", variance)
print("Minimum:", minimum)
print("Maximum:", maximum)

def filtering(self):
even_numbers = [x for x in self.array if x % 2 == 0]
large_numbers = [x for x in self.array if x > 5]

print("Even Numbers:", even_numbers)

print("Large Numbers:", large_numbers)

def transformation(self):
squared = [x**2 for x in self.array]
absolute = [abs(x) for x in self.array]

print("Squared Array:", squared)

print("Absolute Values:", absolute)

def bubble_sort(self):
n = self.size()

for i in range(n):

9
 swapped = False

for j in range(0, n-i-1):

if self.array[j] > self.array[j+1]:
self.array[j], self.array[j+1] = self.array[j+1], self.
array[j]
,→

swapped = True

if not swapped:
break

return self.array

arr = MyArray()
arr.clear()
arr.insert(0, 5)
arr.insert(arr.size(), 2)
arr.insert(arr.size(), 9)
arr.insert(arr.size(), 1)
arr.insert(arr.size(), 7)
print("Array after inserting elements: ")
arr.display()
sorted_array = arr.bubble_sort()
print("Sorted array is:", sorted_array)

Array after inserting elements:

5 2 9 1 7
Sorted array is: [1, 2, 5, 7, 9]

[26]: # Experiment 6: Searching in Arrays

class MyArray:
def __init__(self):
self.array = []

def insert(self, index, value):

if index < 0 or index > len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + [value] + self.array[index:]

def delete(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + self.array[index + 1:]

def clear(self):
self.array = []

10
def get(self, index):
if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
return self.array[index]

def size(self):
count = 0
for _ in self.array:
count += 1
return count

def display(self):
for element in self.array:
print(element, end=" ")
print()

def statistical_analysis(self):
mean = sum(self.array) / len(self.array)
variance = sum((x - mean) ** 2 for x in self.array) / len(self.array)
minimum = min(self.array)
maximum = max(self.array)

print("Mean:", mean)
print("Variance:", variance)
print("Minimum:", minimum)
print("Maximum:", maximum)

def filtering(self):
even_numbers = [x for x in self.array if x % 2 == 0]
large_numbers = [x for x in self.array if x > 5]

print("Even Numbers:", even_numbers)

print("Large Numbers:", large_numbers)

def transformation(self):
squared = [x**2 for x in self.array]
absolute = [abs(x) for x in self.array]

print("Squared Array:", squared)

print("Absolute Values:", absolute)

def bubble_sort(self):
n = self.size()

for i in range(n):
swapped = False

11
 for j in range(0, n-i-1):
if self.array[j] > self.array[j+1]:
self.array[j], self.array[j+1] = self.array[j+1], self.
array[j]
,→

swapped = True

if not swapped:
break

return self.array

def linear_search(self, target):

for i, value in enumerate(self.array):
if value == target:
return i
return -1

def binary_search(self, target):

self.array = self.bubble_sort()

left, right = 0, len(self.array) - 1

while left <= right:

mid = (left + right) // 2
if self.array[mid] == target:
return mid
elif self.array[mid] < target:
left = mid + 1
else:
right = mid - 1

return -1

arr = MyArray()
arr.clear()
arr.insert(0, 10)
arr.insert(arr.size(), 80)
arr.insert(arr.size(), 30)
arr.insert(arr.size(), 70)
arr.insert(arr.size(), 50)
arr.insert(arr.size(), 60)
arr.insert(arr.size(), 90)
arr.insert(arr.size(), 40)
arr.insert(arr.size(), 20)
print("Array after inserting elements: ")
arr.display()

12
 target = 50
linear_result = arr.linear_search(target)
target = 20
binary_result = arr.binary_search(target)
print(f"Linear Search for {target}:", linear_result)
print(f"Binary Search for {target}:", binary_result)

Array after inserting elements:

10 80 30 70 50 60 90 40 20
Linear Search for 20: 4
Binary Search for 20: 1

[28]: # Experiment 7: Removing Duplicates

class MyArray:
def __init__(self):
self.array = []

def insert(self, index, value):

if index < 0 or index > len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + [value] + self.array[index:]

def delete(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + self.array[index + 1:]

def clear(self):
self.array = []

def get(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
return self.array[index]

def size(self):
count = 0
for _ in self.array:
count += 1
return count

def display(self):
for element in self.array:
print(element, end=" ")
print()

13
 def statistical_analysis(self):
mean = sum(self.array) / len(self.array)
variance = sum((x - mean) ** 2 for x in self.array) / len(self.array)
minimum = min(self.array)
maximum = max(self.array)

print("Mean:", mean)
print("Variance:", variance)
print("Minimum:", minimum)
print("Maximum:", maximum)

def filtering(self):
even_numbers = [x for x in self.array if x % 2 == 0]
large_numbers = [x for x in self.array if x > 5]

print("Even Numbers:", even_numbers)

print("Large Numbers:", large_numbers)

def transformation(self):
squared = [x**2 for x in self.array]
absolute = [abs(x) for x in self.array]

print("Squared Array:", squared)

print("Absolute Values:", absolute)

def bubble_sort(self):
n = self.size()

for i in range(n):
swapped = False

for j in range(0, n-i-1):

if self.array[j] > self.array[j+1]:
self.array[j], self.array[j+1] = self.array[j+1], self.
array[j]
,→

swapped = True

if not swapped:
break

return self.array

def linear_search(self, target):

for i, value in enumerate(self.array):
if value == target:
return i
return -1

14
 def binary_search(self, target):
self.array = self.bubble_sort()

left, right = 0, len(self.array) - 1

while left <= right:

mid = (left + right) // 2
if self.array[mid] == target:
return mid
elif self.array[mid] < target:
left = mid + 1
else:
right = mid - 1

return -1

def remove_duplicates(self):
unique_set = list(dict.fromkeys(self.array))
unique_comprehension = []
[unique_comprehension.append(x) for x in self.array if x not in␣
,→unique_comprehension]

print("Unique (Set Method):", unique_set)

print("Unique (Comprehension Method):", unique_comprehension)

arr = MyArray()
arr.clear()
arr.insert(0, 1)
arr.insert(arr.size(), 2)
arr.insert(arr.size(), 2)
arr.insert(arr.size(), 3)
arr.insert(arr.size(), 4)
arr.insert(arr.size(), 4)
arr.insert(arr.size(), 5)
arr.insert(arr.size(), 5)
arr.insert(arr.size(), 6)
print("Array after inserting elements: ")
arr.display()
arr.remove_duplicates()

Array after inserting elements:

1 2 2 3 4 4 5 5 6
Unique (Set Method): [1, 2, 3, 4, 5, 6]
Unique (Comprehension Method): [1, 2, 3, 4, 5, 6]

15
[29]: # Experiment 8: Cumulative Operations

class MyArray:
def __init__(self):
self.array = []

def insert(self, index, value):

if index < 0 or index > len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + [value] + self.array[index:]

def delete(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + self.array[index + 1:]

def clear(self):
self.array = []

def get(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
return self.array[index]

def size(self):
count = 0
for _ in self.array:
count += 1
return count

def display(self):
for element in self.array:
print(element, end=" ")
print()

def statistical_analysis(self):
mean = sum(self.array) / len(self.array)
variance = sum((x - mean) ** 2 for x in self.array) / len(self.array)
minimum = min(self.array)
maximum = max(self.array)

print("Mean:", mean)
print("Variance:", variance)
print("Minimum:", minimum)
print("Maximum:", maximum)

def filtering(self):

16
 even_numbers = [x for x in self.array if x % 2 == 0]
large_numbers = [x for x in self.array if x > 5]

print("Even Numbers:", even_numbers)

print("Large Numbers:", large_numbers)

def transformation(self):
squared = [x**2 for x in self.array]
absolute = [abs(x) for x in self.array]

print("Squared Array:", squared)

print("Absolute Values:", absolute)

def bubble_sort(self):
n = self.size()

for i in range(n):
swapped = False

for j in range(0, n-i-1):

if self.array[j] > self.array[j+1]:
self.array[j], self.array[j+1] = self.array[j+1], self.
array[j]
,→

swapped = True

if not swapped:
break

return self.array

def linear_search(self, target):

for i, value in enumerate(self.array):
if value == target:
return i
return -1

def binary_search(self, target):

self.array = self.bubble_sort()

left, right = 0, len(self.array) - 1

while left <= right:

mid = (left + right) // 2
if self.array[mid] == target:
return mid
elif self.array[mid] < target:
left = mid + 1

17
 else:
right = mid - 1

return -1

def remove_duplicates(self):
unique_set = list(dict.fromkeys(self.array))
unique_comprehension = []
[unique_comprehension.append(x) for x in self.array if x not in␣
,→unique_comprehension]

print("Unique (Set Method):", unique_set)

print("Unique (Comprehension Method):", unique_comprehension)

def cumulative_operations(self):
cumulative_sum = []
total = 0
for x in self.array:
total += x
cumulative_sum.append(total)

cumulative_product = []
product = 1
for x in self.array:
product *= x
cumulative_product.append(product)

print("Cumulative Sum:", cumulative_sum)

print("Cumulative Product:", cumulative_product)

arr = MyArray()
arr.clear()
arr.insert(0, 1)
arr.insert(arr.size(), 2)
arr.insert(arr.size(), 3)
arr.insert(arr.size(), 4)
arr.insert(arr.size(), 5)
print("Array after inserting elements: ")
arr.display()
arr.cumulative_operations()

Array after inserting elements:

1 2 3 4 5
Cumulative Sum: [1, 3, 6, 10, 15]
Cumulative Product: [1, 2, 6, 24, 120]

18
[42]: # Experiment 9: Rotation and Shifting

class MyArray:
def __init__(self):
self.array = []

def insert(self, index, value):

if index < 0 or index > len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + [value] + self.array[index:]

def delete(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + self.array[index + 1:]

def clear(self):
self.array = []

def get(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
return self.array[index]

def size(self):
count = 0
for _ in self.array:
count += 1
return count

def display(self):
for element in self.array:
print(element, end=" ")
print()

def statistical_analysis(self):
mean = sum(self.array) / len(self.array)
variance = sum((x - mean) ** 2 for x in self.array) / len(self.array)
minimum = min(self.array)
maximum = max(self.array)

print("Mean:", mean)
print("Variance:", variance)
print("Minimum:", minimum)
print("Maximum:", maximum)

def filtering(self):

19
 even_numbers = [x for x in self.array if x % 2 == 0]
large_numbers = [x for x in self.array if x > 5]

print("Even Numbers:", even_numbers)

print("Large Numbers:", large_numbers)

def transformation(self):
squared = [x**2 for x in self.array]
absolute = [abs(x) for x in self.array]

print("Squared Array:", squared)

print("Absolute Values:", absolute)

def bubble_sort(self):
n = self.size()

for i in range(n):
swapped = False

for j in range(0, n-i-1):

if self.array[j] > self.array[j+1]:
self.array[j], self.array[j+1] = self.array[j+1], self.
array[j]
,→

swapped = True

if not swapped:
break

return self.array

def linear_search(self, target):

for i, value in enumerate(self.array):
if value == target:
return i
return -1

def binary_search(self, target):

self.array = self.bubble_sort()

left, right = 0, len(self.array) - 1

while left <= right:

mid = (left + right) // 2
if self.array[mid] == target:
return mid
elif self.array[mid] < target:
left = mid + 1

20
 else:
right = mid - 1

return -1

def remove_duplicates(self):
unique_set = list(dict.fromkeys(self.array))
unique_comprehension = []
[unique_comprehension.append(x) for x in self.array if x not in␣
,→unique_comprehension]

print("Unique (Set Method):", unique_set)

print("Unique (Comprehension Method):", unique_comprehension)

def cumulative_operations(self):
cumulative_sum = []
total = 0
for x in self.array:
total += x
cumulative_sum.append(total)

cumulative_product = []
product = 1
for x in self.array:
product *= x
cumulative_product.append(product)

print("Cumulative Sum:", cumulative_sum)

print("Cumulative Product:", cumulative_product)

def array_rotation(self):
def left_rotate(arr, k):
k = k % len(arr)
return arr[k:] + arr[:k]

def right_rotate(arr, k):

k = k % len(arr)
return arr[-k:] + arr[:-k]

left_rotated = left_rotate(self.array, 2)
right_rotated = right_rotate(self.array, 2)

print("Left Rotated:", left_rotated)

print("Right Rotated:", right_rotated)

arr = MyArray()
arr.clear()

21
 arr.insert(0, 1)
arr.insert(1, 2)
arr.insert(2, 3)
arr.insert(3, 4)
arr.insert(4, 5)

print("Array after inserting elements:")

arr.display()

arr.array_rotation()

Array after inserting elements:

1 2 3 4 5
Left Rotated: [3, 4, 5, 1, 2]
Right Rotated: [4, 5, 1, 2, 3]

[43]: # Experiment 10: Frequency Count

class MyArray:
def __init__(self):
self.array = []

def insert(self, index, value):

if index < 0 or index > len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + [value] + self.array[index:]

def delete(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + self.array[index + 1:]

def clear(self):
self.array = []

def get(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
return self.array[index]

def size(self):
count = 0
for _ in self.array:
count += 1
return count

def display(self):

22
 for element in self.array:
print(element, end=" ")
print()

def statistical_analysis(self):
mean = sum(self.array) / len(self.array)
variance = sum((x - mean) ** 2 for x in self.array) / len(self.array)
minimum = min(self.array)
maximum = max(self.array)

print("Mean:", mean)
print("Variance:", variance)
print("Minimum:", minimum)
print("Maximum:", maximum)

def filtering(self):
even_numbers = [x for x in self.array if x % 2 == 0]
large_numbers = [x for x in self.array if x > 5]

print("Even Numbers:", even_numbers)

print("Large Numbers:", large_numbers)

def transformation(self):
squared = [x**2 for x in self.array]
absolute = [abs(x) for x in self.array]

print("Squared Array:", squared)

print("Absolute Values:", absolute)

def bubble_sort(self):
n = self.size()

for i in range(n):
swapped = False

for j in range(0, n-i-1):

if self.array[j] > self.array[j+1]:
self.array[j], self.array[j+1] = self.array[j+1], self.
array[j]
,→

swapped = True

if not swapped:
break

return self.array

def linear_search(self, target):

23
 for i, value in enumerate(self.array):
if value == target:
return i
return -1

def binary_search(self, target):

self.array = self.bubble_sort()

left, right = 0, len(self.array) - 1

while left <= right:

mid = (left + right) // 2
if self.array[mid] == target:
return mid
elif self.array[mid] < target:
left = mid + 1
else:
right = mid - 1

return -1

def remove_duplicates(self):
unique_set = list(dict.fromkeys(self.array))
unique_comprehension = []
[unique_comprehension.append(x) for x in self.array if x not in␣
,→unique_comprehension]

print("Unique (Set Method):", unique_set)

print("Unique (Comprehension Method):", unique_comprehension)

def cumulative_operations(self):
cumulative_sum = []
total = 0
for x in self.array:
total += x
cumulative_sum.append(total)

cumulative_product = []
product = 1
for x in self.array:
product *= x
cumulative_product.append(product)

print("Cumulative Sum:", cumulative_sum)

print("Cumulative Product:", cumulative_product)

def array_rotation(self):

24
 def left_rotate(arr, k):
k = k % len(arr)
return arr[k:] + arr[:k]

def right_rotate(arr, k):

k = k % len(arr)
return arr[-k:] + arr[:-k]

left_rotated = left_rotate(self.array, 2)
right_rotated = right_rotate(self.array, 2)

print("Left Rotated:", left_rotated)

print("Right Rotated:", right_rotated)

def frequency_count(self):
frequency = {x: self.array.count(x) for x in set(self.array)}
print("Frequency Count:", frequency)

arr = MyArray()
arr.clear()
arr.insert(0, 1)
arr.insert(1, 2)
arr.insert(2, 2)
arr.insert(3, 3)
arr.insert(4, 3)
arr.insert(5, 3)
arr.insert(6, 4)
arr.insert(7, 4)
arr.insert(8, 4)
arr.insert(9, 4)

print("Array after inserting elements:")

arr.display()

arr.frequency_count()

Array after inserting elements:

1 2 2 3 3 3 4 4 4 4
Frequency Count: {1: 1, 2: 2, 3: 3, 4: 4}

[47]: # Experiment 11: Finding Missing Number

class MyArray:
def __init__(self):
self.array = []

def insert(self, index, value):

25
 if index < 0 or index > len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + [value] + self.array[index:]

def delete(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + self.array[index + 1:]

def clear(self):
self.array = []

def get(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
return self.array[index]

def size(self):
count = 0
for _ in self.array:
count += 1
return count

def display(self):
for element in self.array:
print(element, end=" ")
print()

def statistical_analysis(self):
mean = sum(self.array) / len(self.array)
variance = sum((x - mean) ** 2 for x in self.array) / len(self.array)
minimum = min(self.array)
maximum = max(self.array)

print("Mean:", mean)
print("Variance:", variance)
print("Minimum:", minimum)
print("Maximum:", maximum)

def filtering(self):
even_numbers = [x for x in self.array if x % 2 == 0]
large_numbers = [x for x in self.array if x > 5]

print("Even Numbers:", even_numbers)

print("Large Numbers:", large_numbers)

def transformation(self):

26
 squared = [x**2 for x in self.array]
absolute = [abs(x) for x in self.array]

print("Squared Array:", squared)

print("Absolute Values:", absolute)

def bubble_sort(self):
n = self.size()

for i in range(n):
swapped = False

for j in range(0, n-i-1):

if self.array[j] > self.array[j+1]:
self.array[j], self.array[j+1] = self.array[j+1], self.
array[j]
,→

swapped = True

if not swapped:
break

return self.array

def linear_search(self, target):

for i, value in enumerate(self.array):
if value == target:
return i
return -1

def binary_search(self, target):

self.array = self.bubble_sort()

left, right = 0, len(self.array) - 1

while left <= right:

mid = (left + right) // 2
if self.array[mid] == target:
return mid
elif self.array[mid] < target:
left = mid + 1
else:
right = mid - 1

return -1

def remove_duplicates(self):
unique_set = list(dict.fromkeys(self.array))

27
 unique_comprehension = []
[unique_comprehension.append(x) for x in self.array if x not in␣
,→unique_comprehension]

print("Unique (Set Method):", unique_set)

print("Unique (Comprehension Method):", unique_comprehension)

def cumulative_operations(self):
cumulative_sum = []
total = 0
for x in self.array:
total += x
cumulative_sum.append(total)

cumulative_product = []
product = 1
for x in self.array:
product *= x
cumulative_product.append(product)

print("Cumulative Sum:", cumulative_sum)

print("Cumulative Product:", cumulative_product)

def array_rotation(self):
def left_rotate(arr, k):
k = k % len(arr)
return arr[k:] + arr[:k]

def right_rotate(arr, k):

k = k % len(arr)
return arr[-k:] + arr[:-k]

left_rotated = left_rotate(self.array, 2)
right_rotated = right_rotate(self.array, 2)

print("Left Rotated:", left_rotated)

print("Right Rotated:", right_rotated)

def frequency_count(self):
frequency = {x: self.array.count(x) for x in set(self.array)}
print("Frequency Count:", frequency)

def sum_of_elements(self):
total = 0
for num in self.array:
total += num
return total

28
 def missing_number(self):
expected_sum = sum(range(1, self.size() + 2))
actual_sum = self.sum_of_elements()
missing_number = expected_sum - actual_sum

print("Missing Number:", missing_number)

arr = MyArray()
arr.clear()
arr.insert(0, 1)
arr.insert(arr.size(), 2)
arr.insert(arr.size(), 4)
arr.insert(arr.size(), 5)
arr.insert(arr.size(), 6)
arr.insert(arr.size(), 7)
arr.insert(arr.size(), 8)
arr.insert(arr.size(), 9)
arr.insert(arr.size(), 10)
print("Array after inserting elements:")
arr.display()
arr.missing_number()

Array after inserting elements:

1 2 4 5 6 7 8 9 10
Missing Number: 3

[50]: # Experiment 12: Alternating Elements

class MyArray:
def __init__(self):
self.array = []

def insert(self, index, value):

if index < 0 or index > len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + [value] + self.array[index:]

def delete(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + self.array[index + 1:]

def clear(self):
self.array = []

def get(self, index):

29
 if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
return self.array[index]

def size(self):
count = 0
for _ in self.array:
count += 1
return count

def display(self):
for element in self.array:
print(element, end=" ")
print()

def statistical_analysis(self):
mean = sum(self.array) / len(self.array)
variance = sum((x - mean) ** 2 for x in self.array) / len(self.array)
minimum = min(self.array)
maximum = max(self.array)

print("Mean:", mean)
print("Variance:", variance)
print("Minimum:", minimum)
print("Maximum:", maximum)

def filtering(self):
even_numbers = [x for x in self.array if x % 2 == 0]
large_numbers = [x for x in self.array if x > 5]

print("Even Numbers:", even_numbers)

print("Large Numbers:", large_numbers)

def transformation(self):
squared = [x**2 for x in self.array]
absolute = [abs(x) for x in self.array]

print("Squared Array:", squared)

print("Absolute Values:", absolute)

def bubble_sort(self):
n = self.size()

for i in range(n):
swapped = False

for j in range(0, n-i-1):

30
 if self.array[j] > self.array[j+1]:
self.array[j], self.array[j+1] = self.array[j+1], self.
array[j]
,→

swapped = True

if not swapped:
break

return self.array

def linear_search(self, target):

for i, value in enumerate(self.array):
if value == target:
return i
return -1

def binary_search(self, target):

self.array = self.bubble_sort()

left, right = 0, len(self.array) - 1

while left <= right:

mid = (left + right) // 2
if self.array[mid] == target:
return mid
elif self.array[mid] < target:
left = mid + 1
else:
right = mid - 1

return -1

def remove_duplicates(self):
unique_set = list(dict.fromkeys(self.array))
unique_comprehension = []
[unique_comprehension.append(x) for x in self.array if x not in␣
,→unique_comprehension]

print("Unique (Set Method):", unique_set)

print("Unique (Comprehension Method):", unique_comprehension)

def cumulative_operations(self):
cumulative_sum = []
total = 0
for x in self.array:
total += x
cumulative_sum.append(total)

31
 cumulative_product = []
product = 1
for x in self.array:
product *= x
cumulative_product.append(product)

print("Cumulative Sum:", cumulative_sum)

print("Cumulative Product:", cumulative_product)

def array_rotation(self):
def left_rotate(arr, k):
k = k % len(arr)
return arr[k:] + arr[:k]

def right_rotate(arr, k):

k = k % len(arr)
return arr[-k:] + arr[:-k]

left_rotated = left_rotate(self.array, 2)
right_rotated = right_rotate(self.array, 2)

print("Left Rotated:", left_rotated)

print("Right Rotated:", right_rotated)

def frequency_count(self):
frequency = {x: self.array.count(x) for x in set(self.array)}
print("Frequency Count:", frequency)

def sum_of_elements(self):
total = 0
for num in self.array:
total += num
return total

def missing_number(self):
expected_sum = sum(range(1, self.size() + 2))
actual_sum = self.sum_of_elements()
missing_number = expected_sum - actual_sum

print("Missing Number:", missing_number)

def alternating_elements(self):
positive_elements = [x for x in self.array if x > 0]
negative_elements = [x for x in self.array if x < 0]

print("Positive Elements:", positive_elements)

32
 print("Negative Elements:", negative_elements)

arr = MyArray()
arr.clear()
alternating_positive = [x if x % 2 == 0 else -x for x in range(1, 11)]
for i in range(len(alternating_positive)):
arr.insert(arr.size(), alternating_positive[i])
print("Array after inserting elements:")
arr.display()
arr.alternating_elements()

Array after inserting elements:

-1 2 -3 4 -5 6 -7 8 -9 10
Positive Elements: [2, 4, 6, 8, 10]
Negative Elements: [-1, -3, -5, -7, -9]

[51]: # Experiment 13: Element Mapping

class MyArray:
def __init__(self):
self.array = []

def insert(self, index, value):

if index < 0 or index > len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + [value] + self.array[index:]

def delete(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + self.array[index + 1:]

def clear(self):
self.array = []

def get(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
return self.array[index]

def size(self):
count = 0
for _ in self.array:
count += 1
return count

33
 def display(self):
for element in self.array:
print(element, end=" ")
print()

def statistical_analysis(self):
mean = sum(self.array) / len(self.array)
variance = sum((x - mean) ** 2 for x in self.array) / len(self.array)
minimum = min(self.array)
maximum = max(self.array)

print("Mean:", mean)
print("Variance:", variance)
print("Minimum:", minimum)
print("Maximum:", maximum)

def filtering(self):
even_numbers = [x for x in self.array if x % 2 == 0]
large_numbers = [x for x in self.array if x > 5]

print("Even Numbers:", even_numbers)

print("Large Numbers:", large_numbers)

def transformation(self):
squared = [x**2 for x in self.array]
absolute = [abs(x) for x in self.array]

print("Squared Array:", squared)

print("Absolute Values:", absolute)

def bubble_sort(self):
n = self.size()

for i in range(n):
swapped = False

for j in range(0, n-i-1):

if self.array[j] > self.array[j+1]:
self.array[j], self.array[j+1] = self.array[j+1], self.
array[j]
,→

swapped = True

if not swapped:
break

return self.array

34
 def linear_search(self, target):
for i, value in enumerate(self.array):
if value == target:
return i
return -1

def binary_search(self, target):

self.array = self.bubble_sort()

left, right = 0, len(self.array) - 1

while left <= right:

mid = (left + right) // 2
if self.array[mid] == target:
return mid
elif self.array[mid] < target:
left = mid + 1
else:
right = mid - 1

return -1

def remove_duplicates(self):
unique_set = list(dict.fromkeys(self.array))
unique_comprehension = []
[unique_comprehension.append(x) for x in self.array if x not in␣
,→unique_comprehension]

print("Unique (Set Method):", unique_set)

print("Unique (Comprehension Method):", unique_comprehension)

def cumulative_operations(self):
cumulative_sum = []
total = 0
for x in self.array:
total += x
cumulative_sum.append(total)

cumulative_product = []
product = 1
for x in self.array:
product *= x
cumulative_product.append(product)

print("Cumulative Sum:", cumulative_sum)

print("Cumulative Product:", cumulative_product)

35
def array_rotation(self):
def left_rotate(arr, k):
k = k % len(arr)
return arr[k:] + arr[:k]

def right_rotate(arr, k):

k = k % len(arr)
return arr[-k:] + arr[:-k]

left_rotated = left_rotate(self.array, 2)
right_rotated = right_rotate(self.array, 2)

print("Left Rotated:", left_rotated)

print("Right Rotated:", right_rotated)

def frequency_count(self):
frequency = {x: self.array.count(x) for x in set(self.array)}
print("Frequency Count:", frequency)

def sum_of_elements(self):
total = 0
for num in self.array:
total += num
return total

def missing_number(self):
expected_sum = sum(range(1, self.size() + 2))
actual_sum = self.sum_of_elements()
missing_number = expected_sum - actual_sum

print("Missing Number:", missing_number)

def alternating_elements(self):
positive_elements = [x for x in self.array if x > 0]
negative_elements = [x for x in self.array if x < 0]

print("Positive Elements:", positive_elements)

print("Negative Elements:", negative_elements)

def element_mapping(self):
def square(x): return x ** 2
def cube(x): return x ** 3

squared_map = list(map(square, self.array))

cubed_map = list(map(cube, self.array))

print("Squared Map:", squared_map)

36
 print("Cubed Map:", cubed_map)

arr = MyArray()
arr.clear()
arr.insert(0, 1)
arr.insert(arr.size(), 2)
arr.insert(arr.size(), 3)
arr.insert(arr.size(), 4)
arr.insert(arr.size(), 5)
print("Array after inserting elements:")
arr.display()
arr.element_mapping()

Array after inserting elements:

1 2 3 4 5
Squared Map: [1, 4, 9, 16, 25]
Cubed Map: [1, 8, 27, 64, 125]

[57]: # Experiment 14: Running Window Operations

class MyArray:
def __init__(self):
self.array = []

def insert(self, index, value):

if index < 0 or index > len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + [value] + self.array[index:]

def delete(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + self.array[index + 1:]

def clear(self):
self.array = []

def get(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
return self.array[index]

def size(self):
count = 0
for _ in self.array:
count += 1

37
 return count

def display(self):
for element in self.array:
print(element, end=" ")
print()

def statistical_analysis(self):
mean = sum(self.array) / len(self.array)
variance = sum((x - mean) ** 2 for x in self.array) / len(self.array)
minimum = min(self.array)
maximum = max(self.array)

print("Mean:", mean)
print("Variance:", variance)
print("Minimum:", minimum)
print("Maximum:", maximum)

def filtering(self):
even_numbers = [x for x in self.array if x % 2 == 0]
large_numbers = [x for x in self.array if x > 5]

print("Even Numbers:", even_numbers)

print("Large Numbers:", large_numbers)

def transformation(self):
squared = [x**2 for x in self.array]
absolute = [abs(x) for x in self.array]

print("Squared Array:", squared)

print("Absolute Values:", absolute)

def bubble_sort(self):
n = self.size()

for i in range(n):
swapped = False

for j in range(0, n-i-1):

if self.array[j] > self.array[j+1]:
self.array[j], self.array[j+1] = self.array[j+1], self.
array[j]
,→

swapped = True

if not swapped:
break

38
 return self.array

def linear_search(self, target):

for i, value in enumerate(self.array):
if value == target:
return i
return -1

def binary_search(self, target):

self.array = self.bubble_sort()

left, right = 0, len(self.array) - 1

while left <= right:

mid = (left + right) // 2
if self.array[mid] == target:
return mid
elif self.array[mid] < target:
left = mid + 1
else:
right = mid - 1

return -1

def remove_duplicates(self):
unique_set = list(dict.fromkeys(self.array))
unique_comprehension = []
[unique_comprehension.append(x) for x in self.array if x not in␣
,→unique_comprehension]

print("Unique (Set Method):", unique_set)

print("Unique (Comprehension Method):", unique_comprehension)

def cumulative_operations(self):
cumulative_sum = []
total = 0
for x in self.array:
total += x
cumulative_sum.append(total)

cumulative_product = []
product = 1
for x in self.array:
product *= x
cumulative_product.append(product)

print("Cumulative Sum:", cumulative_sum)

39
 print("Cumulative Product:", cumulative_product)

def array_rotation(self):
def left_rotate(arr, k):
k = k % len(arr)
return arr[k:] + arr[:k]

def right_rotate(arr, k):

k = k % len(arr)
return arr[-k:] + arr[:-k]

left_rotated = left_rotate(self.array, 2)
right_rotated = right_rotate(self.array, 2)

print("Left Rotated:", left_rotated)

print("Right Rotated:", right_rotated)

def frequency_count(self):
frequency = {x: self.array.count(x) for x in set(self.array)}
print("Frequency Count:", frequency)

def sum_of_elements(self):
total = 0
for num in self.array:
total += num
return total

def missing_number(self):
expected_sum = sum(range(1, self.size() + 2))
actual_sum = self.sum_of_elements()
missing_number = expected_sum - actual_sum

print("Missing Number:", missing_number)

def alternating_elements(self):
positive_elements = [x for x in self.array if x > 0]
negative_elements = [x for x in self.array if x < 0]

print("Positive Elements:", positive_elements)

print("Negative Elements:", negative_elements)

def element_mapping(self):
def square(x): return x ** 2
def cube(x): return x ** 3

squared_map = list(map(square, self.array))

cubed_map = list(map(cube, self.array))

40
 print("Squared Map:", squared_map)
print("Cubed Map:", cubed_map)

def window_operations(self):
window_size = 3
moving_average = []
for i in range(self.size() - window_size + 1):
window = self.array[i:i+window_size]
moving_average.append(sum(window) / window_size)

print("Moving Average (Window Size 3):", moving_average)

arr = MyArray()
arr.clear()
arr.insert(0, 1)
arr.insert(arr.size(), 2)
arr.insert(arr.size(), 3)
arr.insert(arr.size(), 4)
arr.insert(arr.size(), 5)
arr.insert(arr.size(), 6)
arr.insert(arr.size(), 7)
arr.insert(arr.size(), 8)
arr.insert(arr.size(), 9)
arr.insert(arr.size(), 10)
print("Array after inserting elements:")
arr.display()
arr.window_operations()

Array after inserting elements:

1 2 3 4 5 6 7 8 9 10
Moving Average (Window Size 3): [2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]

[58]: # Experiment 15: Random Sampling

class MyArray:
def __init__(self):
self.array = []

def insert(self, index, value):

if index < 0 or index > len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + [value] + self.array[index:]

def delete(self, index):

41
 if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + self.array[index + 1:]

def clear(self):
self.array = []

def get(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
return self.array[index]

def size(self):
count = 0
for _ in self.array:
count += 1
return count

def display(self):
for element in self.array:
print(element, end=" ")
print()

def statistical_analysis(self):
mean = sum(self.array) / len(self.array)
variance = sum((x - mean) ** 2 for x in self.array) / len(self.array)
minimum = min(self.array)
maximum = max(self.array)

print("Mean:", mean)
print("Variance:", variance)
print("Minimum:", minimum)
print("Maximum:", maximum)

def filtering(self):
even_numbers = [x for x in self.array if x % 2 == 0]
large_numbers = [x for x in self.array if x > 5]

print("Even Numbers:", even_numbers)

print("Large Numbers:", large_numbers)

def transformation(self):
squared = [x**2 for x in self.array]
absolute = [abs(x) for x in self.array]

print("Squared Array:", squared)

print("Absolute Values:", absolute)

42
 def bubble_sort(self):
n = self.size()

for i in range(n):
swapped = False

for j in range(0, n-i-1):

if self.array[j] > self.array[j+1]:
self.array[j], self.array[j+1] = self.array[j+1], self.
array[j]
,→

swapped = True

if not swapped:
break

return self.array

def linear_search(self, target):

for i, value in enumerate(self.array):
if value == target:
return i
return -1

def binary_search(self, target):

self.array = self.bubble_sort()

left, right = 0, len(self.array) - 1

while left <= right:

mid = (left + right) // 2
if self.array[mid] == target:
return mid
elif self.array[mid] < target:
left = mid + 1
else:
right = mid - 1

return -1

def remove_duplicates(self):
unique_set = list(dict.fromkeys(self.array))
unique_comprehension = []
[unique_comprehension.append(x) for x in self.array if x not in␣
,→unique_comprehension]

print("Unique (Set Method):", unique_set)

43
 print("Unique (Comprehension Method):", unique_comprehension)

def cumulative_operations(self):
cumulative_sum = []
total = 0
for x in self.array:
total += x
cumulative_sum.append(total)

cumulative_product = []
product = 1
for x in self.array:
product *= x
cumulative_product.append(product)

print("Cumulative Sum:", cumulative_sum)

print("Cumulative Product:", cumulative_product)

def array_rotation(self):
def left_rotate(arr, k):
k = k % len(arr)
return arr[k:] + arr[:k]

def right_rotate(arr, k):

k = k % len(arr)
return arr[-k:] + arr[:-k]

left_rotated = left_rotate(self.array, 2)
right_rotated = right_rotate(self.array, 2)

print("Left Rotated:", left_rotated)

print("Right Rotated:", right_rotated)

def frequency_count(self):
frequency = {x: self.array.count(x) for x in set(self.array)}
print("Frequency Count:", frequency)

def sum_of_elements(self):
total = 0
for num in self.array:
total += num
return total

def missing_number(self):
expected_sum = sum(range(1, self.size() + 2))
actual_sum = self.sum_of_elements()
missing_number = expected_sum - actual_sum

44
 print("Missing Number:", missing_number)

def alternating_elements(self):
positive_elements = [x for x in self.array if x > 0]
negative_elements = [x for x in self.array if x < 0]

print("Positive Elements:", positive_elements)

print("Negative Elements:", negative_elements)

def element_mapping(self):
def square(x): return x ** 2
def cube(x): return x ** 3

squared_map = list(map(square, self.array))

cubed_map = list(map(cube, self.array))

print("Squared Map:", squared_map)

print("Cubed Map:", cubed_map)

def window_operations(self):
window_size = 3
moving_average = []
for i in range(self.size() - window_size + 1):
window = self.array[i:i+window_size]
moving_average.append(sum(window) / window_size)

print("Moving Average (Window Size 3):", moving_average)

def random_sampling(self):
import random

sample_size = 5
random_sample = random.sample(self.array, sample_size)

shuffled_data = self.array.copy()
random.shuffle(shuffled_data)

print(f"Random Sample of {sample_size}:", random_sample)

print("Shuffled Array:", shuffled_data)

arr = MyArray()
arr.clear()
data = list(range(1, 21))
for d in data:

45
 arr.insert(arr.size(), d)
print("Array after inserting elements:")
arr.display()
arr.random_sampling()

Array after inserting elements:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
Random Sample of 5: [10, 3, 20, 12, 6]
Shuffled Array: [8, 18, 15, 13, 12, 4, 11, 6, 14, 1, 19, 9, 10, 17, 5, 2, 3, 20,
16, 7]

[64]: # Experiment 16: Prefix and Suffix Matching

class MyArray:
def __init__(self):
self.array = []

def insert(self, index, value):

if index < 0 or index > len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + [value] + self.array[index:]

def delete(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + self.array[index + 1:]

def clear(self):
self.array = []

def get(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
return self.array[index]

def size(self):
count = 0
for _ in self.array:
count += 1
return count

def display(self):
for element in self.array:
print(element, end=" ")
print()

def statistical_analysis(self):

46
 mean = sum(self.array) / len(self.array)
variance = sum((x - mean) ** 2 for x in self.array) / len(self.array)
minimum = min(self.array)
maximum = max(self.array)

print("Mean:", mean)
print("Variance:", variance)
print("Minimum:", minimum)
print("Maximum:", maximum)

def filtering(self):
even_numbers = [x for x in self.array if x % 2 == 0]
large_numbers = [x for x in self.array if x > 5]

print("Even Numbers:", even_numbers)

print("Large Numbers:", large_numbers)

def transformation(self):
squared = [x**2 for x in self.array]
absolute = [abs(x) for x in self.array]

print("Squared Array:", squared)

print("Absolute Values:", absolute)

def bubble_sort(self):
n = self.size()

for i in range(n):
swapped = False

for j in range(0, n-i-1):

if self.array[j] > self.array[j+1]:
self.array[j], self.array[j+1] = self.array[j+1], self.
array[j]
,→

swapped = True

if not swapped:
break

return self.array

def linear_search(self, target):

for i, value in enumerate(self.array):
if value == target:
return i
return -1

47
 def binary_search(self, target):
self.array = self.bubble_sort()

left, right = 0, len(self.array) - 1

while left <= right:

mid = (left + right) // 2
if self.array[mid] == target:
return mid
elif self.array[mid] < target:
left = mid + 1
else:
right = mid - 1

return -1

def remove_duplicates(self):
unique_set = list(dict.fromkeys(self.array))
unique_comprehension = []
[unique_comprehension.append(x) for x in self.array if x not in␣
,→unique_comprehension]

print("Unique (Set Method):", unique_set)

print("Unique (Comprehension Method):", unique_comprehension)

def cumulative_operations(self):
cumulative_sum = []
total = 0
for x in self.array:
total += x
cumulative_sum.append(total)

cumulative_product = []
product = 1
for x in self.array:
product *= x
cumulative_product.append(product)

print("Cumulative Sum:", cumulative_sum)

print("Cumulative Product:", cumulative_product)

def array_rotation(self):
def left_rotate(arr, k):
k = k % len(arr)
return arr[k:] + arr[:k]

def right_rotate(arr, k):

48
 k = k % len(arr)
return arr[-k:] + arr[:-k]

left_rotated = left_rotate(self.array, 2)
right_rotated = right_rotate(self.array, 2)

print("Left Rotated:", left_rotated)

print("Right Rotated:", right_rotated)

def frequency_count(self):
frequency = {x: self.array.count(x) for x in set(self.array)}
print("Frequency Count:", frequency)

def sum_of_elements(self):
total = 0
for num in self.array:
total += num
return total

def missing_number(self):
expected_sum = sum(range(1, self.size() + 2))
actual_sum = self.sum_of_elements()
missing_number = expected_sum - actual_sum

print("Missing Number:", missing_number)

def alternating_elements(self):
positive_elements = [x for x in self.array if x > 0]
negative_elements = [x for x in self.array if x < 0]

print("Positive Elements:", positive_elements)

print("Negative Elements:", negative_elements)

def element_mapping(self):
def square(x): return x ** 2
def cube(x): return x ** 3

squared_map = list(map(square, self.array))

cubed_map = list(map(cube, self.array))

print("Squared Map:", squared_map)

print("Cubed Map:", cubed_map)

def window_operations(self):
window_size = 3
moving_average = []

49
 for i in range(self.size() - window_size + 1):
window = self.array[i:i+window_size]
moving_average.append(sum(window) / window_size)

print("Moving Average (Window Size 3):", moving_average)

def random_sampling(self):
import random

sample_size = 5
random_sample = random.sample(self.array, sample_size)

shuffled_data = self.array.copy()
random.shuffle(shuffled_data)

print(f"Random Sample of {sample_size}:", random_sample)

print("Shuffled Array:", shuffled_data)

def prefix_suffix(self):
def find_prefix_matches(prefix):
return [x for x in self.array if x.startswith(prefix)]

def find_suffix_matches(suffix):
return [x for x in self.array if x.endswith(suffix)]

print("Prefix 'app' matches:", find_prefix_matches('app'))

print("Suffix 'and' matches:", find_suffix_matches('and'))

arr = MyArray()
arr.clear()
words = ['apple', 'application', 'banana', 'append', 'cat']
for w in words:
arr.insert(arr.size(), w)
print("Array after inserting elements:")
arr.display()
arr.prefix_suffix()

Array after inserting elements:

apple application banana append cat
Prefix 'app' matches: ['apple', 'application', 'append']
Suffix 'and' matches: []

[67]: # Experiment 17: Grouped Element Operations

class MyArray:
def __init__(self):
self.array = []

50
def insert(self, index, value):
if index < 0 or index > len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + [value] + self.array[index:]

def delete(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + self.array[index + 1:]

def clear(self):
self.array = []

def get(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
return self.array[index]

def size(self):
count = 0
for _ in self.array:
count += 1
return count

def display(self):
for element in self.array:
print(element, end=" ")
print()

def statistical_analysis(self):
mean = sum(self.array) / len(self.array)
variance = sum((x - mean) ** 2 for x in self.array) / len(self.array)
minimum = min(self.array)
maximum = max(self.array)

print("Mean:", mean)
print("Variance:", variance)
print("Minimum:", minimum)
print("Maximum:", maximum)

def filtering(self):
even_numbers = [x for x in self.array if x % 2 == 0]
large_numbers = [x for x in self.array if x > 5]

print("Even Numbers:", even_numbers)

print("Large Numbers:", large_numbers)

51
 def transformation(self):
squared = [x**2 for x in self.array]
absolute = [abs(x) for x in self.array]

print("Squared Array:", squared)

print("Absolute Values:", absolute)

def bubble_sort(self):
n = self.size()

for i in range(n):
swapped = False

for j in range(0, n-i-1):

if self.array[j] > self.array[j+1]:
self.array[j], self.array[j+1] = self.array[j+1], self.
array[j]
,→

swapped = True

if not swapped:
break

return self.array

def linear_search(self, target):

for i, value in enumerate(self.array):
if value == target:
return i
return -1

def binary_search(self, target):

self.array = self.bubble_sort()

left, right = 0, len(self.array) - 1

while left <= right:

mid = (left + right) // 2
if self.array[mid] == target:
return mid
elif self.array[mid] < target:
left = mid + 1
else:
right = mid - 1

return -1

52
 def remove_duplicates(self):
unique_set = list(dict.fromkeys(self.array))
unique_comprehension = []
[unique_comprehension.append(x) for x in self.array if x not in␣
,→unique_comprehension]

print("Unique (Set Method):", unique_set)

print("Unique (Comprehension Method):", unique_comprehension)

def cumulative_operations(self):
cumulative_sum = []
total = 0
for x in self.array:
total += x
cumulative_sum.append(total)

cumulative_product = []
product = 1
for x in self.array:
product *= x
cumulative_product.append(product)

print("Cumulative Sum:", cumulative_sum)

print("Cumulative Product:", cumulative_product)

def array_rotation(self):
def left_rotate(arr, k):
k = k % len(arr)
return arr[k:] + arr[:k]

def right_rotate(arr, k):

k = k % len(arr)
return arr[-k:] + arr[:-k]

left_rotated = left_rotate(self.array, 2)
right_rotated = right_rotate(self.array, 2)

print("Left Rotated:", left_rotated)

print("Right Rotated:", right_rotated)

def frequency_count(self):
frequency = {x: self.array.count(x) for x in set(self.array)}
print("Frequency Count:", frequency)

def sum_of_elements(self):
total = 0
for num in self.array:

53
 total += num
return total

def missing_number(self):
expected_sum = sum(range(1, self.size() + 2))
actual_sum = self.sum_of_elements()
missing_number = expected_sum - actual_sum

print("Missing Number:", missing_number)

def alternating_elements(self):
positive_elements = [x for x in self.array if x > 0]
negative_elements = [x for x in self.array if x < 0]

print("Positive Elements:", positive_elements)

print("Negative Elements:", negative_elements)

def element_mapping(self):
def square(x): return x ** 2
def cube(x): return x ** 3

squared_map = list(map(square, self.array))

cubed_map = list(map(cube, self.array))

print("Squared Map:", squared_map)

print("Cubed Map:", cubed_map)

def window_operations(self):
window_size = 3
moving_average = []
for i in range(self.size() - window_size + 1):
window = self.array[i:i+window_size]
moving_average.append(sum(window) / window_size)

print("Moving Average (Window Size 3):", moving_average)

def random_sampling(self):
import random

sample_size = 5
random_sample = random.sample(self.array, sample_size)

shuffled_data = self.array.copy()
random.shuffle(shuffled_data)

print(f"Random Sample of {sample_size}:", random_sample)

54
 print("Shuffled Array:", shuffled_data)

def prefix_suffix(self):
def find_prefix_matches(prefix):
return [x for x in self.array if x.startswith(prefix)]

def find_suffix_matches(suffix):
return [x for x in self.array if x.endswith(suffix)]

print("Prefix 'app' matches:", find_prefix_matches('app'))

print("Suffix 'and' matches:", find_suffix_matches('and'))

def group_operations(self):
def group_parity(data):
return {
'even': [x for x in data if x % 2 == 0],
'odd': [x for x in data if x % 2 != 0]
}

grouped = group_parity(self.array)
grouped_stats = {
key: {
'sum': sum(value),
'avg': sum(value) / len(value) if value else 0,
'count': len(value)
} for key, value in grouped.items()
}

print("Grouped by Parity:", grouped)

print("Group Statistics:", grouped_stats)

arr = MyArray()
arr.clear()
data = list(range(1, 11))
for d in data:
arr.insert(arr.size(), d)
print("Array after inserting elements:")
arr.display()
arr.group_operations()

Array after inserting elements:

1 2 3 4 5 6 7 8 9 10
Grouped by Parity: {'even': [2, 4, 6, 8, 10], 'odd': [1, 3, 5, 7, 9]}
Group Statistics: {'even': {'sum': 30, 'avg': 6.0, 'count': 5}, 'odd': {'sum':
25, 'avg': 5.0, 'count': 5}}

55
[68]: # Experiment 18: Complex Transformation

class MyArray:
def __init__(self):
self.array = []

def insert(self, index, value):

if index < 0 or index > len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + [value] + self.array[index:]

def delete(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
self.array = self.array[:index] + self.array[index + 1:]

def clear(self):
self.array = []

def get(self, index):

if index < 0 or index >= len(self.array):
raise IndexError("Index out of bounds")
return self.array[index]

def size(self):
count = 0
for _ in self.array:
count += 1
return count

def display(self):
for element in self.array:
print(element, end=" ")
print()

def statistical_analysis(self):
mean = sum(self.array) / len(self.array)
variance = sum((x - mean) ** 2 for x in self.array) / len(self.array)
minimum = min(self.array)
maximum = max(self.array)

print("Mean:", mean)
print("Variance:", variance)
print("Minimum:", minimum)
print("Maximum:", maximum)

def filtering(self):

56
 even_numbers = [x for x in self.array if x % 2 == 0]
large_numbers = [x for x in self.array if x > 5]

print("Even Numbers:", even_numbers)

print("Large Numbers:", large_numbers)

def transformation(self):
squared = [x**2 for x in self.array]
absolute = [abs(x) for x in self.array]

print("Squared Array:", squared)

print("Absolute Values:", absolute)

def bubble_sort(self):
n = self.size()

for i in range(n):
swapped = False

for j in range(0, n-i-1):

if self.array[j] > self.array[j+1]:
self.array[j], self.array[j+1] = self.array[j+1], self.
array[j]
,→

swapped = True

if not swapped:
break

return self.array

def linear_search(self, target):

for i, value in enumerate(self.array):
if value == target:
return i
return -1

def binary_search(self, target):

self.array = self.bubble_sort()

left, right = 0, len(self.array) - 1

while left <= right:

mid = (left + right) // 2
if self.array[mid] == target:
return mid
elif self.array[mid] < target:
left = mid + 1

57
 else:
right = mid - 1

return -1

def remove_duplicates(self):
unique_set = list(dict.fromkeys(self.array))
unique_comprehension = []
[unique_comprehension.append(x) for x in self.array if x not in␣
,→unique_comprehension]

print("Unique (Set Method):", unique_set)

print("Unique (Comprehension Method):", unique_comprehension)

def cumulative_operations(self):
cumulative_sum = []
total = 0
for x in self.array:
total += x
cumulative_sum.append(total)

cumulative_product = []
product = 1
for x in self.array:
product *= x
cumulative_product.append(product)

print("Cumulative Sum:", cumulative_sum)

print("Cumulative Product:", cumulative_product)

def array_rotation(self):
def left_rotate(arr, k):
k = k % len(arr)
return arr[k:] + arr[:k]

def right_rotate(arr, k):

k = k % len(arr)
return arr[-k:] + arr[:-k]

left_rotated = left_rotate(self.array, 2)
right_rotated = right_rotate(self.array, 2)

print("Left Rotated:", left_rotated)

print("Right Rotated:", right_rotated)

def frequency_count(self):
frequency = {x: self.array.count(x) for x in set(self.array)}

58
 print("Frequency Count:", frequency)

def sum_of_elements(self):
total = 0
for num in self.array:
total += num
return total

def missing_number(self):
expected_sum = sum(range(1, self.size() + 2))
actual_sum = self.sum_of_elements()
missing_number = expected_sum - actual_sum

print("Missing Number:", missing_number)

def alternating_elements(self):
positive_elements = [x for x in self.array if x > 0]
negative_elements = [x for x in self.array if x < 0]

print("Positive Elements:", positive_elements)

print("Negative Elements:", negative_elements)

def element_mapping(self):
def square(x): return x ** 2
def cube(x): return x ** 3

squared_map = list(map(square, self.array))

cubed_map = list(map(cube, self.array))

print("Squared Map:", squared_map)

print("Cubed Map:", cubed_map)

def window_operations(self):
window_size = 3
moving_average = []
for i in range(self.size() - window_size + 1):
window = self.array[i:i+window_size]
moving_average.append(sum(window) / window_size)

print("Moving Average (Window Size 3):", moving_average)

def random_sampling(self):
import random

sample_size = 5
random_sample = random.sample(self.array, sample_size)

59
 shuffled_data = self.array.copy()
random.shuffle(shuffled_data)

print(f"Random Sample of {sample_size}:", random_sample)

print("Shuffled Array:", shuffled_data)

def prefix_suffix(self):
def find_prefix_matches(prefix):
return [x for x in self.array if x.startswith(prefix)]

def find_suffix_matches(suffix):
return [x for x in self.array if x.endswith(suffix)]

print("Prefix 'app' matches:", find_prefix_matches('app'))

print("Suffix 'and' matches:", find_suffix_matches('and'))

def group_operations(self):
def group_parity(data):
return {
'even': [x for x in data if x % 2 == 0],
'odd': [x for x in data if x % 2 != 0]
}

grouped = group_parity(self.array)
grouped_stats = {
key: {
'sum': sum(value),
'avg': sum(value) / len(value) if value else 0,
'count': len(value)
} for key, value in grouped.items()
}

print("Grouped by Parity:", grouped)

print("Group Statistics:", grouped_stats)

def complex_transformation(self):
def transform_array(data):
unique = list(dict.fromkeys(data))
squared = [x**2 if x > 0 else x for x in unique]
sorted_arr = sorted(squared)
final = [x for x in sorted_arr if x % 3 == 0]
return final

transformed = transform_array(self.array)
print("Transformed Array:", transformed)

60
arr = MyArray()
arr.clear()
data = [1, 2, 2, 3, -4, 5, 6, 6, 7, 8, 9]
for d in data:
arr.insert(arr.size(), d)
print("Array after inserting elements:")
arr.display()
arr.group_operations()

Array after inserting elements:

1 2 2 3 -4 5 6 6 7 8 9
Grouped by Parity: {'even': [2, 2, -4, 6, 6, 8], 'odd': [1, 3, 5, 7, 9]}
Group Statistics: {'even': {'sum': 20, 'avg': 3.3333333333333335, 'count': 6},
'odd': {'sum': 25, 'avg': 5.0, 'count': 5}}

61