Adding the Median algorithm Python Code

scripts/Median_algorithm/Median.md

@@ -0,0 +1,11 @@
+# Median Algorithm
+
+###### It brings the median value of an array
+
+## Run Script
+
+The script already has the array hardcoded.
+
+## Command to run the script
+
+python3 Median_Algorithm.py

scripts/Median_algorithm/Median_Algorithm.py

@@ -0,0 +1,135 @@
+import random
+def pick_pivot(l):
+ """
+ Pick a good pivot within l, a list of numbers
+ This algorithm runs in O(n) time.
+ """
+ assert len(l) > 0
+
+ # If there are < 5 items, just return the median
+ if len(l) < 5:
+ # In this case, we fall back on the first median function we wrote.
+ # Since we only run this on a list of 5 or fewer items, it doesn't
+ # depend on the length of the input and can be considered constant
+ # time.
+ return nlogn_median(l)
+
+ # First, we'll split `l` into groups of 5 items. O(n)
+ chunks = chunked(l, 5)
+
+ # For simplicity, we can drop any chunks that aren't full. O(n)
+ full_chunks = [chunk for chunk in chunks if len(chunk) == 5]
+
+
+ # Next, we sort each chunk. Each group is a fixed length, so each sort
+ # takes constant time. Since we have n/5 chunks, this operation
+ # is also O(n)
+ sorted_groups = [sorted(chunk) for chunk in full_chunks]
+
+ # The median of each chunk is at index 2
+ medians = [chunk[2] for chunk in sorted_groups]
+
+ # It's a bit circular, but I'm about to prove that finding
+ # the median of a list can be done in provably O(n).
+ # Finding the median of a list of length n/5 is a subproblem of size n/5
+ # and this recursive call will be accounted for in our analysis.
+ # We pass pick_pivot, our current function, as the pivot builder to
+ # quickselect. O(n)
+ median_of_medians = quickselect_median(medians, pick_pivot)
+ return median_of_medians
+
+
+def chunked(l, chunk_size):
+ """Split list `l` it to chunks of `chunk_size` elements."""
+ return [l[i:i + chunk_size] for i in range(0, len(l), chunk_size)]
+
+
+def nlogn_median(l):
+ l = sorted(l)
+ if len(l) % 2 == 1:
+ return l[int((len(l) / 2))]
+ else:
+ return 0.5 * (l[len(l) / 2 - 1] + l[len(l) / 2])
+
+
+def quickselect_median(l, pivot_fn=random.choice):
+ if len(l) % 2 == 1:
+ return quickselect(l, len(l) / 2, pivot_fn)
+ else:
+ return 0.5 * (quickselect(l, len(l) / 2 - 1, pivot_fn) +
+ quickselect(l, len(l) / 2, pivot_fn))
+
+
+def quickselect(l, k, pivot_fn):
+ """
+ Select the kth element in l (0 based)
+ :param l: List of numerics
+ :param k: Index
+ :param pivot_fn: Function to choose a pivot, defaults to random.choice
+ :return: The kth element of l
+ """
+ if len(l) == 1:
+ assert k == 0
+ return l[0]
+
+ pivot = pivot_fn(l)
+
+ lows = [el for el in l if el < pivot]
+ highs = [el for el in l if el > pivot]
+ pivots = [el for el in l if el == pivot]
+
+ if k < len(lows):
+ return quickselect(lows, k, pivot_fn)
+ elif k < len(lows) + len(pivots):
+ # We got lucky and guessed the median
+ return pivots[0]
+ else:
+ return quickselect(highs, k - len(lows) - len(pivots), pivot_fn)
+
+
+l = [9,1,0,2,3,4,6,8,7,10,5]
+
+print(pick_pivot(l))
+
+"""
+Considere a lista abaixo. Gostaríamos de encontrar a mediana.
+l = [9,1,0,2,3,4,6,8,7,10,5]
+len (l) == 11, então estamos procurando pelo 6º menor elemento
+Primeiro, devemos escolher um pivô. Selecionamos aleatoriamente o índice 3.
+O valor neste índice é 2.
+
+Particionamento com base no pivô:
+[1,0,2], [9,3,4,6,8,7,10,5]
+Queremos o 6º elemento. 6-len (esquerda) = 3, então queremos
+o terceiro menor elemento na matriz certa
+
+Agora estamos procurando o terceiro menor elemento na matriz abaixo:
+[9,3,4,6,8,7,10,5]
+Escolhemos um índice aleatoriamente para ser nosso pivô.
+Escolhemos o índice 3, o valor em que, l [3] = 6
+
+Particionamento com base no pivô:
+[3,4,5,6] [9,7,10]
+Queremos o terceiro menor elemento, então sabemos que é o
+3º menor elemento na matriz esquerda
+
+Agora estamos procurando o terceiro menor na matriz abaixo:
+[3,4,5,6]
+Escolhemos um índice aleatoriamente para ser nosso pivô.
+Escolhemos o índice 1, o valor em que, l [1] = 4
+Particionamento com base no pivô:
+[3,4] [5,6]
+Estamos procurando o item no índice 3, então sabemos que é
+o menor na matriz certa.
+
+Agora estamos procurando o menor elemento na matriz abaixo:
+[5,6]
+
+Neste ponto, podemos ter um caso base que escolhe a maior
+ou item menor com base no índice.
+Estamos procurando o menor item, que é 5.
+retorno 5
+
+Esse algoritmo roda em O(n)
+http://people.csail.mit.edu/rivest/pubs/BFPRT73.pdf
+"""

scripts/Median_algorithm/Median.md

@@ -0,0 +1,11 @@
+# Median Algorithm
+
+###### It brings the median value of an array
+
+## Run Script
+
+The script already has the array hardcoded.
+
+## Command to run the script
+
+python3 Median_Algorithm.py

scripts/Median_algorithm/Median_Algorithm.py

@@ -0,0 +1,135 @@
+import random
+def pick_pivot(l):
+ """
+ Pick a good pivot within l, a list of numbers
+ This algorithm runs in O(n) time.
+ """
+ assert len(l) > 0
+
+ # If there are < 5 items, just return the median
+ if len(l) < 5:
+ # In this case, we fall back on the first median function we wrote.
+ # Since we only run this on a list of 5 or fewer items, it doesn't
+ # depend on the length of the input and can be considered constant
+ # time.
+ return nlogn_median(l)
+
+ # First, we'll split `l` into groups of 5 items. O(n)
+ chunks = chunked(l, 5)
+
+ # For simplicity, we can drop any chunks that aren't full. O(n)
+ full_chunks = [chunk for chunk in chunks if len(chunk) == 5]
+
+
+ # Next, we sort each chunk. Each group is a fixed length, so each sort
+ # takes constant time. Since we have n/5 chunks, this operation
+ # is also O(n)
+ sorted_groups = [sorted(chunk) for chunk in full_chunks]
+
+ # The median of each chunk is at index 2
+ medians = [chunk[2] for chunk in sorted_groups]
+
+ # It's a bit circular, but I'm about to prove that finding
+ # the median of a list can be done in provably O(n).
+ # Finding the median of a list of length n/5 is a subproblem of size n/5
+ # and this recursive call will be accounted for in our analysis.
+ # We pass pick_pivot, our current function, as the pivot builder to
+ # quickselect. O(n)
+ median_of_medians = quickselect_median(medians, pick_pivot)
+ return median_of_medians
+
+
+def chunked(l, chunk_size):
+ """Split list `l` it to chunks of `chunk_size` elements."""
+ return [l[i:i + chunk_size] for i in range(0, len(l), chunk_size)]
+
+
+def nlogn_median(l):
+ l = sorted(l)
+ if len(l) % 2 == 1:
+ return l[int((len(l) / 2))]
+ else:
+ return 0.5 * (l[len(l) / 2 - 1] + l[len(l) / 2])
+
+
+def quickselect_median(l, pivot_fn=random.choice):
+ if len(l) % 2 == 1:
+ return quickselect(l, len(l) / 2, pivot_fn)
+ else:
+ return 0.5 * (quickselect(l, len(l) / 2 - 1, pivot_fn) +
+ quickselect(l, len(l) / 2, pivot_fn))
+
+
+def quickselect(l, k, pivot_fn):
+ """
+ Select the kth element in l (0 based)
+ :param l: List of numerics
+ :param k: Index
+ :param pivot_fn: Function to choose a pivot, defaults to random.choice
+ :return: The kth element of l
+ """
+ if len(l) == 1:
+ assert k == 0
+ return l[0]
+
+ pivot = pivot_fn(l)
+
+ lows = [el for el in l if el < pivot]
+ highs = [el for el in l if el > pivot]
+ pivots = [el for el in l if el == pivot]
+
+ if k < len(lows):
+ return quickselect(lows, k, pivot_fn)
+ elif k < len(lows) + len(pivots):
+ # We got lucky and guessed the median
+ return pivots[0]
+ else:
+ return quickselect(highs, k - len(lows) - len(pivots), pivot_fn)
+
+
+l = [9,1,0,2,3,4,6,8,7,10,5]
+
+print(pick_pivot(l))
+
+"""
+Considere a lista abaixo. Gostaríamos de encontrar a mediana.
+l = [9,1,0,2,3,4,6,8,7,10,5]
+len (l) == 11, então estamos procurando pelo 6º menor elemento
+Primeiro, devemos escolher um pivô. Selecionamos aleatoriamente o índice 3.
+O valor neste índice é 2.
+
+Particionamento com base no pivô:
+[1,0,2], [9,3,4,6,8,7,10,5]
+Queremos o 6º elemento. 6-len (esquerda) = 3, então queremos
+o terceiro menor elemento na matriz certa
+
+Agora estamos procurando o terceiro menor elemento na matriz abaixo:
+[9,3,4,6,8,7,10,5]
+Escolhemos um índice aleatoriamente para ser nosso pivô.
+Escolhemos o índice 3, o valor em que, l [3] = 6
+
+Particionamento com base no pivô:
+[3,4,5,6] [9,7,10]
+Queremos o terceiro menor elemento, então sabemos que é o
+3º menor elemento na matriz esquerda
+
+Agora estamos procurando o terceiro menor na matriz abaixo:
+[3,4,5,6]
+Escolhemos um índice aleatoriamente para ser nosso pivô.
+Escolhemos o índice 1, o valor em que, l [1] = 4
+Particionamento com base no pivô:
+[3,4] [5,6]
+Estamos procurando o item no índice 3, então sabemos que é
+o menor na matriz certa.
+
+Agora estamos procurando o menor elemento na matriz abaixo:
+[5,6]
+
+Neste ponto, podemos ter um caso base que escolhe a maior
+ou item menor com base no índice.
+Estamos procurando o menor item, que é 5.
+retorno 5
+
+Esse algoritmo roda em O(n)
+http://people.csail.mit.edu/rivest/pubs/BFPRT73.pdf
+"""

scripts/Median_algorithm/Median.md

@@ -0,0 +1,11 @@
+# Median Algorithm
+
+###### It brings the median value of an array
+
+## Run Script
+
+The script already has the array hardcoded.
+
+## Command to run the script
+
+python3 Median_Algorithm.py

scripts/Median_algorithm/Median_Algorithm.py

@@ -0,0 +1,135 @@
+import random
+def pick_pivot(l):
+ """
+ Pick a good pivot within l, a list of numbers
+ This algorithm runs in O(n) time.
+ """
+ assert len(l) > 0
+
+ # If there are < 5 items, just return the median
+ if len(l) < 5:
+ # In this case, we fall back on the first median function we wrote.
+ # Since we only run this on a list of 5 or fewer items, it doesn't
+ # depend on the length of the input and can be considered constant
+ # time.
+ return nlogn_median(l)
+
+ # First, we'll split `l` into groups of 5 items. O(n)
+ chunks = chunked(l, 5)
+
+ # For simplicity, we can drop any chunks that aren't full. O(n)
+ full_chunks = [chunk for chunk in chunks if len(chunk) == 5]
+
+
+ # Next, we sort each chunk. Each group is a fixed length, so each sort
+ # takes constant time. Since we have n/5 chunks, this operation
+ # is also O(n)
+ sorted_groups = [sorted(chunk) for chunk in full_chunks]
+
+ # The median of each chunk is at index 2
+ medians = [chunk[2] for chunk in sorted_groups]
+
+ # It's a bit circular, but I'm about to prove that finding
+ # the median of a list can be done in provably O(n).
+ # Finding the median of a list of length n/5 is a subproblem of size n/5
+ # and this recursive call will be accounted for in our analysis.
+ # We pass pick_pivot, our current function, as the pivot builder to
+ # quickselect. O(n)
+ median_of_medians = quickselect_median(medians, pick_pivot)
+ return median_of_medians
+
+
+def chunked(l, chunk_size):
+ """Split list `l` it to chunks of `chunk_size` elements."""
+ return [l[i:i + chunk_size] for i in range(0, len(l), chunk_size)]
+
+
+def nlogn_median(l):
+ l = sorted(l)
+ if len(l) % 2 == 1:
+ return l[int((len(l) / 2))]
+ else:
+ return 0.5 * (l[len(l) / 2 - 1] + l[len(l) / 2])
+
+
+def quickselect_median(l, pivot_fn=random.choice):
+ if len(l) % 2 == 1:
+ return quickselect(l, len(l) / 2, pivot_fn)
+ else:
+ return 0.5 * (quickselect(l, len(l) / 2 - 1, pivot_fn) +
+ quickselect(l, len(l) / 2, pivot_fn))
+
+
+def quickselect(l, k, pivot_fn):
+ """
+ Select the kth element in l (0 based)
+ :param l: List of numerics
+ :param k: Index
+ :param pivot_fn: Function to choose a pivot, defaults to random.choice
+ :return: The kth element of l
+ """
+ if len(l) == 1:
+ assert k == 0
+ return l[0]
+
+ pivot = pivot_fn(l)
+
+ lows = [el for el in l if el < pivot]
+ highs = [el for el in l if el > pivot]
+ pivots = [el for el in l if el == pivot]
+
+ if k < len(lows):
+ return quickselect(lows, k, pivot_fn)
+ elif k < len(lows) + len(pivots):
+ # We got lucky and guessed the median
+ return pivots[0]
+ else:
+ return quickselect(highs, k - len(lows) - len(pivots), pivot_fn)
+
+
+l = [9,1,0,2,3,4,6,8,7,10,5]
+
+print(pick_pivot(l))
+
+"""
+Considere a lista abaixo. Gostaríamos de encontrar a mediana.
+l = [9,1,0,2,3,4,6,8,7,10,5]
+len (l) == 11, então estamos procurando pelo 6º menor elemento
+Primeiro, devemos escolher um pivô. Selecionamos aleatoriamente o índice 3.
+O valor neste índice é 2.
+
+Particionamento com base no pivô:
+[1,0,2], [9,3,4,6,8,7,10,5]
+Queremos o 6º elemento. 6-len (esquerda) = 3, então queremos
+o terceiro menor elemento na matriz certa
+
+Agora estamos procurando o terceiro menor elemento na matriz abaixo:
+[9,3,4,6,8,7,10,5]
+Escolhemos um índice aleatoriamente para ser nosso pivô.
+Escolhemos o índice 3, o valor em que, l [3] = 6
+
+Particionamento com base no pivô:
+[3,4,5,6] [9,7,10]
+Queremos o terceiro menor elemento, então sabemos que é o
+3º menor elemento na matriz esquerda
+
+Agora estamos procurando o terceiro menor na matriz abaixo:
+[3,4,5,6]
+Escolhemos um índice aleatoriamente para ser nosso pivô.
+Escolhemos o índice 1, o valor em que, l [1] = 4
+Particionamento com base no pivô:
+[3,4] [5,6]
+Estamos procurando o item no índice 3, então sabemos que é
+o menor na matriz certa.
+
+Agora estamos procurando o menor elemento na matriz abaixo:
+[5,6]
+
+Neste ponto, podemos ter um caso base que escolhe a maior
+ou item menor com base no índice.
+Estamos procurando o menor item, que é 5.
+retorno 5
+
+Esse algoritmo roda em O(n)
+http://people.csail.mit.edu/rivest/pubs/BFPRT73.pdf
+"""

scripts/Median_algorithm/Median.md

@@ -0,0 +1,11 @@
+# Median Algorithm
+
+###### It brings the median value of an array
+
+## Run Script
+
+The script already has the array hardcoded.
+
+## Command to run the script
+
+python3 Median_Algorithm.py

scripts/Median_algorithm/Median_Algorithm.py

@@ -0,0 +1,135 @@
+import random
+def pick_pivot(l):
+ """
+ Pick a good pivot within l, a list of numbers
+ This algorithm runs in O(n) time.
+ """
+ assert len(l) > 0
+
+ # If there are < 5 items, just return the median
+ if len(l) < 5:
+ # In this case, we fall back on the first median function we wrote.
+ # Since we only run this on a list of 5 or fewer items, it doesn't
+ # depend on the length of the input and can be considered constant
+ # time.
+ return nlogn_median(l)
+
+ # First, we'll split `l` into groups of 5 items. O(n)
+ chunks = chunked(l, 5)
+
+ # For simplicity, we can drop any chunks that aren't full. O(n)
+ full_chunks = [chunk for chunk in chunks if len(chunk) == 5]
+
+
+ # Next, we sort each chunk. Each group is a fixed length, so each sort
+ # takes constant time. Since we have n/5 chunks, this operation
+ # is also O(n)
+ sorted_groups = [sorted(chunk) for chunk in full_chunks]
+
+ # The median of each chunk is at index 2
+ medians = [chunk[2] for chunk in sorted_groups]
+
+ # It's a bit circular, but I'm about to prove that finding
+ # the median of a list can be done in provably O(n).
+ # Finding the median of a list of length n/5 is a subproblem of size n/5
+ # and this recursive call will be accounted for in our analysis.
+ # We pass pick_pivot, our current function, as the pivot builder to
+ # quickselect. O(n)
+ median_of_medians = quickselect_median(medians, pick_pivot)
+ return median_of_medians
+
+
+def chunked(l, chunk_size):
+ """Split list `l` it to chunks of `chunk_size` elements."""
+ return [l[i:i + chunk_size] for i in range(0, len(l), chunk_size)]
+
+
+def nlogn_median(l):
+ l = sorted(l)
+ if len(l) % 2 == 1:
+ return l[int((len(l) / 2))]
+ else:
+ return 0.5 * (l[len(l) / 2 - 1] + l[len(l) / 2])
+
+
+def quickselect_median(l, pivot_fn=random.choice):
+ if len(l) % 2 == 1:
+ return quickselect(l, len(l) / 2, pivot_fn)
+ else:
+ return 0.5 * (quickselect(l, len(l) / 2 - 1, pivot_fn) +
+ quickselect(l, len(l) / 2, pivot_fn))
+
+
+def quickselect(l, k, pivot_fn):
+ """
+ Select the kth element in l (0 based)
+ :param l: List of numerics
+ :param k: Index
+ :param pivot_fn: Function to choose a pivot, defaults to random.choice
+ :return: The kth element of l
+ """
+ if len(l) == 1:
+ assert k == 0
+ return l[0]
+
+ pivot = pivot_fn(l)
+
+ lows = [el for el in l if el < pivot]
+ highs = [el for el in l if el > pivot]
+ pivots = [el for el in l if el == pivot]
+
+ if k < len(lows):
+ return quickselect(lows, k, pivot_fn)
+ elif k < len(lows) + len(pivots):
+ # We got lucky and guessed the median
+ return pivots[0]
+ else:
+ return quickselect(highs, k - len(lows) - len(pivots), pivot_fn)
+
+
+l = [9,1,0,2,3,4,6,8,7,10,5]
+
+print(pick_pivot(l))
+
+"""
+Considere a lista abaixo. Gostaríamos de encontrar a mediana.
+l = [9,1,0,2,3,4,6,8,7,10,5]
+len (l) == 11, então estamos procurando pelo 6º menor elemento
+Primeiro, devemos escolher um pivô. Selecionamos aleatoriamente o índice 3.
+O valor neste índice é 2.
+
+Particionamento com base no pivô:
+[1,0,2], [9,3,4,6,8,7,10,5]
+Queremos o 6º elemento. 6-len (esquerda) = 3, então queremos
+o terceiro menor elemento na matriz certa
+
+Agora estamos procurando o terceiro menor elemento na matriz abaixo:
+[9,3,4,6,8,7,10,5]
+Escolhemos um índice aleatoriamente para ser nosso pivô.
+Escolhemos o índice 3, o valor em que, l [3] = 6
+
+Particionamento com base no pivô:
+[3,4,5,6] [9,7,10]
+Queremos o terceiro menor elemento, então sabemos que é o
+3º menor elemento na matriz esquerda
+
+Agora estamos procurando o terceiro menor na matriz abaixo:
+[3,4,5,6]
+Escolhemos um índice aleatoriamente para ser nosso pivô.
+Escolhemos o índice 1, o valor em que, l [1] = 4
+Particionamento com base no pivô:
+[3,4] [5,6]
+Estamos procurando o item no índice 3, então sabemos que é
+o menor na matriz certa.
+
+Agora estamos procurando o menor elemento na matriz abaixo:
+[5,6]
+
+Neste ponto, podemos ter um caso base que escolhe a maior
+ou item menor com base no índice.
+Estamos procurando o menor item, que é 5.
+retorno 5
+
+Esse algoritmo roda em O(n)
+http://people.csail.mit.edu/rivest/pubs/BFPRT73.pdf
+"""

scripts/Median_algorithm/Median.md

@@ -0,0 +1,11 @@
+# Median Algorithm
+
+###### It brings the median value of an array
+
+## Run Script
+
+The script already has the array hardcoded.
+
+## Command to run the script
+
+python3 Median_Algorithm.py

scripts/Median_algorithm/Median_Algorithm.py

@@ -0,0 +1,135 @@
+import random
+def pick_pivot(l):
+ """
+ Pick a good pivot within l, a list of numbers
+ This algorithm runs in O(n) time.
+ """
+ assert len(l) > 0
+
+ # If there are < 5 items, just return the median
+ if len(l) < 5:
+ # In this case, we fall back on the first median function we wrote.
+ # Since we only run this on a list of 5 or fewer items, it doesn't
+ # depend on the length of the input and can be considered constant
+ # time.
+ return nlogn_median(l)
+
+ # First, we'll split `l` into groups of 5 items. O(n)
+ chunks = chunked(l, 5)
+
+ # For simplicity, we can drop any chunks that aren't full. O(n)
+ full_chunks = [chunk for chunk in chunks if len(chunk) == 5]
+
+
+ # Next, we sort each chunk. Each group is a fixed length, so each sort
+ # takes constant time. Since we have n/5 chunks, this operation
+ # is also O(n)
+ sorted_groups = [sorted(chunk) for chunk in full_chunks]
+
+ # The median of each chunk is at index 2
+ medians = [chunk[2] for chunk in sorted_groups]
+
+ # It's a bit circular, but I'm about to prove that finding
+ # the median of a list can be done in provably O(n).
+ # Finding the median of a list of length n/5 is a subproblem of size n/5
+ # and this recursive call will be accounted for in our analysis.
+ # We pass pick_pivot, our current function, as the pivot builder to
+ # quickselect. O(n)
+ median_of_medians = quickselect_median(medians, pick_pivot)
+ return median_of_medians
+
+
+def chunked(l, chunk_size):
+ """Split list `l` it to chunks of `chunk_size` elements."""
+ return [l[i:i + chunk_size] for i in range(0, len(l), chunk_size)]
+
+
+def nlogn_median(l):
+ l = sorted(l)
+ if len(l) % 2 == 1:
+ return l[int((len(l) / 2))]
+ else:
+ return 0.5 * (l[len(l) / 2 - 1] + l[len(l) / 2])
+
+
+def quickselect_median(l, pivot_fn=random.choice):
+ if len(l) % 2 == 1:
+ return quickselect(l, len(l) / 2, pivot_fn)
+ else:
+ return 0.5 * (quickselect(l, len(l) / 2 - 1, pivot_fn) +
+ quickselect(l, len(l) / 2, pivot_fn))
+
+
+def quickselect(l, k, pivot_fn):
+ """
+ Select the kth element in l (0 based)
+ :param l: List of numerics
+ :param k: Index
+ :param pivot_fn: Function to choose a pivot, defaults to random.choice
+ :return: The kth element of l
+ """
+ if len(l) == 1:
+ assert k == 0
+ return l[0]
+
+ pivot = pivot_fn(l)
+
+ lows = [el for el in l if el < pivot]
+ highs = [el for el in l if el > pivot]
+ pivots = [el for el in l if el == pivot]
+
+ if k < len(lows):
+ return quickselect(lows, k, pivot_fn)
+ elif k < len(lows) + len(pivots):
+ # We got lucky and guessed the median
+ return pivots[0]
+ else:
+ return quickselect(highs, k - len(lows) - len(pivots), pivot_fn)
+
+
+l = [9,1,0,2,3,4,6,8,7,10,5]
+
+print(pick_pivot(l))
+
+"""
+Considere a lista abaixo. Gostaríamos de encontrar a mediana.
+l = [9,1,0,2,3,4,6,8,7,10,5]
+len (l) == 11, então estamos procurando pelo 6º menor elemento
+Primeiro, devemos escolher um pivô. Selecionamos aleatoriamente o índice 3.
+O valor neste índice é 2.
+
+Particionamento com base no pivô:
+[1,0,2], [9,3,4,6,8,7,10,5]
+Queremos o 6º elemento. 6-len (esquerda) = 3, então queremos
+o terceiro menor elemento na matriz certa
+
+Agora estamos procurando o terceiro menor elemento na matriz abaixo:
+[9,3,4,6,8,7,10,5]
+Escolhemos um índice aleatoriamente para ser nosso pivô.
+Escolhemos o índice 3, o valor em que, l [3] = 6
+
+Particionamento com base no pivô:
+[3,4,5,6] [9,7,10]
+Queremos o terceiro menor elemento, então sabemos que é o
+3º menor elemento na matriz esquerda
+
+Agora estamos procurando o terceiro menor na matriz abaixo:
+[3,4,5,6]
+Escolhemos um índice aleatoriamente para ser nosso pivô.
+Escolhemos o índice 1, o valor em que, l [1] = 4
+Particionamento com base no pivô:
+[3,4] [5,6]
+Estamos procurando o item no índice 3, então sabemos que é
+o menor na matriz certa.
+
+Agora estamos procurando o menor elemento na matriz abaixo:
+[5,6]
+
+Neste ponto, podemos ter um caso base que escolhe a maior
+ou item menor com base no índice.
+Estamos procurando o menor item, que é 5.
+retorno 5
+
+Esse algoritmo roda em O(n)
+http://people.csail.mit.edu/rivest/pubs/BFPRT73.pdf
+"""

scripts/Median_algorithm/Median.md

@@ -0,0 +1,11 @@
+# Median Algorithm
+
+###### It brings the median value of an array
+
+## Run Script
+
+The script already has the array hardcoded.
+
+## Command to run the script
+
+python3 Median_Algorithm.py

scripts/Median_algorithm/Median_Algorithm.py

@@ -0,0 +1,135 @@
+import random
+def pick_pivot(l):
+ """
+ Pick a good pivot within l, a list of numbers
+ This algorithm runs in O(n) time.
+ """
+ assert len(l) > 0
+
+ # If there are < 5 items, just return the median
+ if len(l) < 5:
+ # In this case, we fall back on the first median function we wrote.
+ # Since we only run this on a list of 5 or fewer items, it doesn't
+ # depend on the length of the input and can be considered constant
+ # time.
+ return nlogn_median(l)
+
+ # First, we'll split `l` into groups of 5 items. O(n)
+ chunks = chunked(l, 5)
+
+ # For simplicity, we can drop any chunks that aren't full. O(n)
+ full_chunks = [chunk for chunk in chunks if len(chunk) == 5]
+
+
+ # Next, we sort each chunk. Each group is a fixed length, so each sort
+ # takes constant time. Since we have n/5 chunks, this operation
+ # is also O(n)
+ sorted_groups = [sorted(chunk) for chunk in full_chunks]
+
+ # The median of each chunk is at index 2
+ medians = [chunk[2] for chunk in sorted_groups]
+
+ # It's a bit circular, but I'm about to prove that finding
+ # the median of a list can be done in provably O(n).
+ # Finding the median of a list of length n/5 is a subproblem of size n/5
+ # and this recursive call will be accounted for in our analysis.
+ # We pass pick_pivot, our current function, as the pivot builder to
+ # quickselect. O(n)
+ median_of_medians = quickselect_median(medians, pick_pivot)
+ return median_of_medians
+
+
+def chunked(l, chunk_size):
+ """Split list `l` it to chunks of `chunk_size` elements."""
+ return [l[i:i + chunk_size] for i in range(0, len(l), chunk_size)]
+
+
+def nlogn_median(l):
+ l = sorted(l)
+ if len(l) % 2 == 1:
+ return l[int((len(l) / 2))]
+ else:
+ return 0.5 * (l[len(l) / 2 - 1] + l[len(l) / 2])
+
+
+def quickselect_median(l, pivot_fn=random.choice):
+ if len(l) % 2 == 1:
+ return quickselect(l, len(l) / 2, pivot_fn)
+ else:
+ return 0.5 * (quickselect(l, len(l) / 2 - 1, pivot_fn) +
+ quickselect(l, len(l) / 2, pivot_fn))
+
+
+def quickselect(l, k, pivot_fn):
+ """
+ Select the kth element in l (0 based)
+ :param l: List of numerics
+ :param k: Index
+ :param pivot_fn: Function to choose a pivot, defaults to random.choice
+ :return: The kth element of l
+ """
+ if len(l) == 1:
+ assert k == 0
+ return l[0]
+
+ pivot = pivot_fn(l)
+
+ lows = [el for el in l if el < pivot]
+ highs = [el for el in l if el > pivot]
+ pivots = [el for el in l if el == pivot]
+
+ if k < len(lows):
+ return quickselect(lows, k, pivot_fn)
+ elif k < len(lows) + len(pivots):
+ # We got lucky and guessed the median
+ return pivots[0]
+ else:
+ return quickselect(highs, k - len(lows) - len(pivots), pivot_fn)
+
+
+l = [9,1,0,2,3,4,6,8,7,10,5]
+
+print(pick_pivot(l))
+
+"""
+Considere a lista abaixo. Gostaríamos de encontrar a mediana.
+l = [9,1,0,2,3,4,6,8,7,10,5]
+len (l) == 11, então estamos procurando pelo 6º menor elemento
+Primeiro, devemos escolher um pivô. Selecionamos aleatoriamente o índice 3.
+O valor neste índice é 2.
+
+Particionamento com base no pivô:
+[1,0,2], [9,3,4,6,8,7,10,5]
+Queremos o 6º elemento. 6-len (esquerda) = 3, então queremos
+o terceiro menor elemento na matriz certa
+
+Agora estamos procurando o terceiro menor elemento na matriz abaixo:
+[9,3,4,6,8,7,10,5]
+Escolhemos um índice aleatoriamente para ser nosso pivô.
+Escolhemos o índice 3, o valor em que, l [3] = 6
+
+Particionamento com base no pivô:
+[3,4,5,6] [9,7,10]
+Queremos o terceiro menor elemento, então sabemos que é o
+3º menor elemento na matriz esquerda
+
+Agora estamos procurando o terceiro menor na matriz abaixo:
+[3,4,5,6]
+Escolhemos um índice aleatoriamente para ser nosso pivô.
+Escolhemos o índice 1, o valor em que, l [1] = 4
+Particionamento com base no pivô:
+[3,4] [5,6]
+Estamos procurando o item no índice 3, então sabemos que é
+o menor na matriz certa.
+
+Agora estamos procurando o menor elemento na matriz abaixo:
+[5,6]
+
+Neste ponto, podemos ter um caso base que escolhe a maior
+ou item menor com base no índice.
+Estamos procurando o menor item, que é 5.
+retorno 5
+
+Esse algoritmo roda em O(n)
+http://people.csail.mit.edu/rivest/pubs/BFPRT73.pdf
+"""

scripts/Median_algorithm/Median.md

@@ -0,0 +1,11 @@
+# Median Algorithm
+
+###### It brings the median value of an array
+
+## Run Script
+
+The script already has the array hardcoded.
+
+## Command to run the script
+
+python3 Median_Algorithm.py

scripts/Median_algorithm/Median_Algorithm.py

@@ -0,0 +1,135 @@
+import random
+def pick_pivot(l):
+ """
+ Pick a good pivot within l, a list of numbers
+ This algorithm runs in O(n) time.
+ """
+ assert len(l) > 0
+
+ # If there are < 5 items, just return the median
+ if len(l) < 5:
+ # In this case, we fall back on the first median function we wrote.
+ # Since we only run this on a list of 5 or fewer items, it doesn't
+ # depend on the length of the input and can be considered constant
+ # time.
+ return nlogn_median(l)
+
+ # First, we'll split `l` into groups of 5 items. O(n)
+ chunks = chunked(l, 5)
+
+ # For simplicity, we can drop any chunks that aren't full. O(n)
+ full_chunks = [chunk for chunk in chunks if len(chunk) == 5]
+
+
+ # Next, we sort each chunk. Each group is a fixed length, so each sort
+ # takes constant time. Since we have n/5 chunks, this operation
+ # is also O(n)
+ sorted_groups = [sorted(chunk) for chunk in full_chunks]
+
+ # The median of each chunk is at index 2
+ medians = [chunk[2] for chunk in sorted_groups]
+
+ # It's a bit circular, but I'm about to prove that finding
+ # the median of a list can be done in provably O(n).
+ # Finding the median of a list of length n/5 is a subproblem of size n/5
+ # and this recursive call will be accounted for in our analysis.
+ # We pass pick_pivot, our current function, as the pivot builder to
+ # quickselect. O(n)
+ median_of_medians = quickselect_median(medians, pick_pivot)
+ return median_of_medians
+
+
+def chunked(l, chunk_size):
+ """Split list `l` it to chunks of `chunk_size` elements."""
+ return [l[i:i + chunk_size] for i in range(0, len(l), chunk_size)]
+
+
+def nlogn_median(l):
+ l = sorted(l)
+ if len(l) % 2 == 1:
+ return l[int((len(l) / 2))]
+ else:
+ return 0.5 * (l[len(l) / 2 - 1] + l[len(l) / 2])
+
+
+def quickselect_median(l, pivot_fn=random.choice):
+ if len(l) % 2 == 1:
+ return quickselect(l, len(l) / 2, pivot_fn)
+ else:
+ return 0.5 * (quickselect(l, len(l) / 2 - 1, pivot_fn) +
+ quickselect(l, len(l) / 2, pivot_fn))
+
+
+def quickselect(l, k, pivot_fn):
+ """
+ Select the kth element in l (0 based)
+ :param l: List of numerics
+ :param k: Index
+ :param pivot_fn: Function to choose a pivot, defaults to random.choice
+ :return: The kth element of l
+ """
+ if len(l) == 1:
+ assert k == 0
+ return l[0]
+
+ pivot = pivot_fn(l)
+
+ lows = [el for el in l if el < pivot]
+ highs = [el for el in l if el > pivot]
+ pivots = [el for el in l if el == pivot]
+
+ if k < len(lows):
+ return quickselect(lows, k, pivot_fn)
+ elif k < len(lows) + len(pivots):
+ # We got lucky and guessed the median
+ return pivots[0]
+ else:
+ return quickselect(highs, k - len(lows) - len(pivots), pivot_fn)
+
+
+l = [9,1,0,2,3,4,6,8,7,10,5]
+
+print(pick_pivot(l))
+
+"""
+Considere a lista abaixo. Gostaríamos de encontrar a mediana.
+l = [9,1,0,2,3,4,6,8,7,10,5]
+len (l) == 11, então estamos procurando pelo 6º menor elemento
+Primeiro, devemos escolher um pivô. Selecionamos aleatoriamente o índice 3.
+O valor neste índice é 2.
+
+Particionamento com base no pivô:
+[1,0,2], [9,3,4,6,8,7,10,5]
+Queremos o 6º elemento. 6-len (esquerda) = 3, então queremos
+o terceiro menor elemento na matriz certa
+
+Agora estamos procurando o terceiro menor elemento na matriz abaixo:
+[9,3,4,6,8,7,10,5]
+Escolhemos um índice aleatoriamente para ser nosso pivô.
+Escolhemos o índice 3, o valor em que, l [3] = 6
+
+Particionamento com base no pivô:
+[3,4,5,6] [9,7,10]
+Queremos o terceiro menor elemento, então sabemos que é o
+3º menor elemento na matriz esquerda
+
+Agora estamos procurando o terceiro menor na matriz abaixo:
+[3,4,5,6]
+Escolhemos um índice aleatoriamente para ser nosso pivô.
+Escolhemos o índice 1, o valor em que, l [1] = 4
+Particionamento com base no pivô:
+[3,4] [5,6]
+Estamos procurando o item no índice 3, então sabemos que é
+o menor na matriz certa.
+
+Agora estamos procurando o menor elemento na matriz abaixo:
+[5,6]
+
+Neste ponto, podemos ter um caso base que escolhe a maior
+ou item menor com base no índice.
+Estamos procurando o menor item, que é 5.
+retorno 5
+
+Esse algoritmo roda em O(n)
+http://people.csail.mit.edu/rivest/pubs/BFPRT73.pdf
+"""

scripts/Median_algorithm/Median.md

@@ -0,0 +1,11 @@
+# Median Algorithm
+
+###### It brings the median value of an array
+
+## Run Script
+
+The script already has the array hardcoded.
+
+## Command to run the script
+
+python3 Median_Algorithm.py

scripts/Median_algorithm/Median_Algorithm.py

@@ -0,0 +1,135 @@
+import random
+def pick_pivot(l):
+ """
+ Pick a good pivot within l, a list of numbers
+ This algorithm runs in O(n) time.
+ """
+ assert len(l) > 0
+
+ # If there are < 5 items, just return the median
+ if len(l) < 5:
+ # In this case, we fall back on the first median function we wrote.
+ # Since we only run this on a list of 5 or fewer items, it doesn't
+ # depend on the length of the input and can be considered constant
+ # time.
+ return nlogn_median(l)
+
+ # First, we'll split `l` into groups of 5 items. O(n)
+ chunks = chunked(l, 5)
+
+ # For simplicity, we can drop any chunks that aren't full. O(n)
+ full_chunks = [chunk for chunk in chunks if len(chunk) == 5]
+
+
+ # Next, we sort each chunk. Each group is a fixed length, so each sort
+ # takes constant time. Since we have n/5 chunks, this operation
+ # is also O(n)
+ sorted_groups = [sorted(chunk) for chunk in full_chunks]
+
+ # The median of each chunk is at index 2
+ medians = [chunk[2] for chunk in sorted_groups]
+
+ # It's a bit circular, but I'm about to prove that finding
+ # the median of a list can be done in provably O(n).
+ # Finding the median of a list of length n/5 is a subproblem of size n/5
+ # and this recursive call will be accounted for in our analysis.
+ # We pass pick_pivot, our current function, as the pivot builder to
+ # quickselect. O(n)
+ median_of_medians = quickselect_median(medians, pick_pivot)
+ return median_of_medians
+
+
+def chunked(l, chunk_size):
+ """Split list `l` it to chunks of `chunk_size` elements."""
+ return [l[i:i + chunk_size] for i in range(0, len(l), chunk_size)]
+
+
+def nlogn_median(l):
+ l = sorted(l)
+ if len(l) % 2 == 1:
+ return l[int((len(l) / 2))]
+ else:
+ return 0.5 * (l[len(l) / 2 - 1] + l[len(l) / 2])
+
+
+def quickselect_median(l, pivot_fn=random.choice):
+ if len(l) % 2 == 1:
+ return quickselect(l, len(l) / 2, pivot_fn)
+ else:
+ return 0.5 * (quickselect(l, len(l) / 2 - 1, pivot_fn) +
+ quickselect(l, len(l) / 2, pivot_fn))
+
+
+def quickselect(l, k, pivot_fn):
+ """
+ Select the kth element in l (0 based)
+ :param l: List of numerics
+ :param k: Index
+ :param pivot_fn: Function to choose a pivot, defaults to random.choice
+ :return: The kth element of l
+ """
+ if len(l) == 1:
+ assert k == 0
+ return l[0]
+
+ pivot = pivot_fn(l)
+
+ lows = [el for el in l if el < pivot]
+ highs = [el for el in l if el > pivot]
+ pivots = [el for el in l if el == pivot]
+
+ if k < len(lows):
+ return quickselect(lows, k, pivot_fn)
+ elif k < len(lows) + len(pivots):
+ # We got lucky and guessed the median
+ return pivots[0]
+ else:
+ return quickselect(highs, k - len(lows) - len(pivots), pivot_fn)
+
+
+l = [9,1,0,2,3,4,6,8,7,10,5]
+
+print(pick_pivot(l))
+
+"""
+Considere a lista abaixo. Gostaríamos de encontrar a mediana.
+l = [9,1,0,2,3,4,6,8,7,10,5]
+len (l) == 11, então estamos procurando pelo 6º menor elemento
+Primeiro, devemos escolher um pivô. Selecionamos aleatoriamente o índice 3.
+O valor neste índice é 2.
+
+Particionamento com base no pivô:
+[1,0,2], [9,3,4,6,8,7,10,5]
+Queremos o 6º elemento. 6-len (esquerda) = 3, então queremos
+o terceiro menor elemento na matriz certa
+
+Agora estamos procurando o terceiro menor elemento na matriz abaixo:
+[9,3,4,6,8,7,10,5]
+Escolhemos um índice aleatoriamente para ser nosso pivô.
+Escolhemos o índice 3, o valor em que, l [3] = 6
+
+Particionamento com base no pivô:
+[3,4,5,6] [9,7,10]
+Queremos o terceiro menor elemento, então sabemos que é o
+3º menor elemento na matriz esquerda
+
+Agora estamos procurando o terceiro menor na matriz abaixo:
+[3,4,5,6]
+Escolhemos um índice aleatoriamente para ser nosso pivô.
+Escolhemos o índice 1, o valor em que, l [1] = 4
+Particionamento com base no pivô:
+[3,4] [5,6]
+Estamos procurando o item no índice 3, então sabemos que é
+o menor na matriz certa.
+
+Agora estamos procurando o menor elemento na matriz abaixo:
+[5,6]
+
+Neste ponto, podemos ter um caso base que escolhe a maior
+ou item menor com base no índice.
+Estamos procurando o menor item, que é 5.
+retorno 5
+
+Esse algoritmo roda em O(n)
+http://people.csail.mit.edu/rivest/pubs/BFPRT73.pdf
+"""