## Prompt

II want you to act as an instructor in a school, teaching[request and context]

## Sample query

I want you to act as an instructor in a school, teaching algorithms to beginners. You will provide code examples using python programming language. First, start briefly explaining what an algorithm is, and continue giving simple examples, including bubble sort and quick sort. Later, wait for my prompt for additional questions. As soon as you explain and give the code samples, I want you to include corresponding visualizations as an ascii art whenever possible.

## Sample response

An algorithm is a step-by-step procedure for calculations, data processing, and automated reasoning tasks. It's like a recipe that precisely defines a set of instructions to be executed in a certain order to perform a task or solve a problem.

**Bubble Sort Example in Python:**

```
def bubbleSort(arr):
n = len(arr)
for i in range(n-1):
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] = arr[j+1], arr[j]
arr = [64, 34, 25, 12, 22, 11, 90]
bubbleSort(arr)
print("Sorted array is:", arr)
```

**Quick Sort Example in Python:**

```
def partition(arr, low, high):
i = (low-1)
pivot = arr[high]
for j in range(low, high):
if arr[j] < pivot:
i = i+1
arr[i], arr[j] = arr[j], arr[i]
arr[i+1], arr[high] = arr[high], arr[i+1]
return (i+1)
def quickSort(arr, low, high):
if len(arr) == 1:
return arr
if low < high:
pi = partition(arr, low, high)
quickSort(arr, low, pi-1)
quickSort(arr, pi+1, high)
arr = [10, 7, 8, 9, 1, 5]
n = len(arr)
quickSort(arr, 0, n-1)
print("Sorted array is:", arr)
```

**Visualization:**

Bubble Sort Visualization:

```
[64, 34, 25, 12, 22, 11, 90]
[34, 25, 12, 22, 11, 64, 90] - After 1st pass
[25, 12, 22, 11, 34, 64, 90] - After 2nd pass
...
```

Quick Sort Visualization:

```
[10, 7, 8, 9, 1, 5]
[1, 7, 8, 9, 10, 5] - After partitioning around pivot 10
[1, 5, 7, 8, 9, 10] - After recursive sorting
```

Note: The ASCII art provided here aims to give a basic understanding of how elements are swapped during the sorting process. In bubble sort, elements are swapped to bubble up the largest unsorted element to its correct position in each pass, whereas, in quick sort, elements are partitioned around a pivot, and the process is applied recursively to the sub-arrays.