# 1. Introduction

Quick sort is an efficient sorting algorithm that works by selecting a 'pivot' element from the array and partitioning the other elements into two sub-arrays, according to whether they are less than or greater than the pivot. The sub-arrays are then sorted recursively.

# 2. Implementation Steps

1. Choose a 'pivot' element from the array and partition the remaining elements into two sub-arrays, according to whether they are less than or greater than the pivot.

2. Recursively apply the above step to the sub-arrays.

3. The base case of the recursion is an array of size zero or one, which are considered to be sorted.

# 3. Implementation in Ruby Programming

``````def quick_sort(arr)
return arr if arr.length <= 1
# Choosing the pivot
pivot = arr.delete_at(rand(arr.length))
# Partitioning the array
left, right = arr.partition { |x| x < pivot }
# Recursive call
quick_sort(left) + [pivot] + quick_sort(right)
end
# Client code
array = [34, 2, 10, 19, 7, 50, 32]
puts "Original array: #{array}"
sorted_array = quick_sort(array)
puts "Sorted array: #{sorted_array}"
``````

### Output:

```Original array: [34, 2, 10, 19, 7, 50, 32]
Sorted array: [2, 7, 10, 19, 32, 34, 50]
```

### Explanation:

1. The primary operation in the quick sort algorithm is the partitioning of the array. A random element called the pivot is selected from the array.

2. The array is then partitioned into two sets - one with elements less than the pivot and the other with elements greater than the pivot.

3. These two sets are then sorted recursively using the same process.

4. The sorted set with elements less than the pivot, the pivot, and the sorted set with elements greater than the pivot are concatenated to give the final sorted array.

5. This process continues until the base case is reached, which is an array of size zero or one.