## Run a random algorithm mutiple times and average over the results

randomized algorithms
randomized algorithms that produce solutions guaranteed to be exact are named after the city of
application of randomized algorithm
randomized selection algorithm time complexity
randomized algorithms pdf
randomized algorithms tutorialspoint
types of randomized algorithms
las vegas algorithm

I have the following random selection script:

```import random

length_of_list = 200
my_list = list(range(length_of_list))
num_selections = 10

numbers = random.sample(my_list, num_selections)
```

It looks at a list of predetermined size and randomly selects 10 numbers. Is there a way to run this section 500 times and then get the top 10 numbers which were selected the most? I was thinking that I could feed the numbers into a dictionary and then get the top 10 numbers from there. So far, I've done the following:

```for run in range(0, 500):
numbers = random.sample(my_list, num_selections)
for number in numbers:
current_number = my_dict.get(number)
key_number = number
my_dict.update(number = number+1)

print(my_dict)
```

Here I want the code to take the current number assigned to that key and then add 1, but I cannot manage to make it work. It seems like the key for the dictionary update has to be that specific key, cannot insert a variable.. Also, I think having this nested loop might not be so efficient as I have to run this 500 times 1500 times 23... so I am concerned about performance. If anyone has an idea of what I should try, it would be great! Thanks

SOLUTION:

```import random
from collections import defaultdict
from collections import OrderedDict

length_of_list = 50
my_list = list(range(length_of_list))
num_selections = 10

my_dict = dict.fromkeys(my_list)

di = defaultdict(int)
for run in range(0, 500):
numbers = random.sample(my_list, num_selections)
for number in numbers:
di[number] += 1

def get_top_numbers(data, n, order=False):
"""Gets the top n numbers from the dictionary"""
top = sorted(data.items(), key=lambda x: x, reverse=True)[:n]
if order:
return OrderedDict(top)
return dict(top)

print(get_top_numbers(di, n=10))
```

Checkout defaultdict of collections module, So basically, you create a `defaultdict` with default value `0` and then iterate over your `numbers` list and update the value of the number to `+=1`

```from collections import defaultdict
di = defaultdict(int)
for run in range(0, 500):
numbers = random.sample(my_list, num_selections)
for number in numbers:
di[number] += 1

print(di)

```

Randomized algorithm, Problem classes having (possibly nonterminating) algorithms with polynomial time average case running time whose output is always correct are said to be in ZPP� The algorithm typically uses uniformly random bits as an auxiliary input to guide its behavior, in the hope of achieving good performance in the "average case" over all possible choices of random bits. Formally, the algorithm's performance will be a random variable determined by the random bits; thus either the running time, or the output (or

`my_dict.update(number = number+1)` in this line you are assigning a new value to a variable inside the parentheses of a function call. Unless you're giving the function a kwarg called `number` with value `number+1` this in the following error: `TypeError: 'number' is an invalid keyword argument for this function`

Also `dict.update` doesn't accept an integer but another dictionary. You should read the documentation about this function: https://www.tutorialspoint.com/python3/dictionary_update.htm Here it say's `dict.update(dict2)` takes a dictionary which it will integrate into `dict`. See example below:

```dict = {'Name': 'Zara', 'Age': 17}
dict2 = {'Gender': 'female' }

dict.update(dict2)
print ("updated dict : ", dict)
```

Gives as result: `updated dict : {'Gender': 'female', 'Age': 17, 'Name': 'Zara'}`

So far for the errors in your code, I see a good answer is already given so I won't repeat him.

RandomizedAlgorithms, A randomized algorithm flips coins during its execution to determine what to do next This average is computed over all the possible outcomes of the coin flips See ExpectedValue for more information about computing expectations. Because the running time may depend on the random bits, it is now a RandomVariable� By applying the time series prediction algorithm suggested by the RF method for a given house, we obtain 1.909 MSE averaged over all houses, where this average MSE value is 1.828 if we were to use an oracle (the case where we know all the best prediction algorithms for each house ahead of time).

You can use for this task `collections.Counter` which provides addition method. So you will use two counters one which is sum of all and second which contains count of samples.

```counter = collections.Counter()
for run in range(500):
samples = random.sample(my_list, num_samples)
sample_counter = collections.Counter(samples)
counter = counter + sample_counter
```

Run the Clustering Algorithm, The centroid of a cluster is the mean of all the points in the cluster. The algorithm randomly chooses a centroid for each cluster. In our from Stanford, try running k-means multiple times and see if you get different results. This can be achieved by using the same value to seed the random number generator each time you run your program. reproducible results, 1st time and every time. do not change over time. It

[PDF] Chapter 9 Randomized Algorithms, Algorithms that run in a fixed amount of time, but may or may not average across all random choices it makes, the algorithm has O(n) work. repeat it many time) and the outcome is probabilistic (each experiment might lead to a different. And the running time will be an expected running time that will hold for any input array. Now, for the sorting problem we know that quick sort that's n log in time on average, where the average is over the coin flips done by the code.

How Many Random Seeds Should I Use? Statistical Power Analysis in, A solution to this problem is to use more random seeds, to average X and running this algorithm in an environment results in a realization x. Repeating the procedure N times, you obtain a statistical sample x=(x^1, .., x^N). Running Karger's algorithm O(n2 log n) times produces a minimum cut with high probability. Claim: Using adjacency matrices, it's possible to run Karger's algorithm once in time O(n2). Theorem: Running Karger's algorithm O(n2 log n) times gives a minimum cut with high probability and takes time O(n4 log n).

Efficiency of random swap clustering, Random swap algorithm aims at solving clustering by a sequence of prototype swaps The main results are that the expected time complexity has (1) linear We use the centroid index (CI) as our primary measure of success . on average, and the number of iterations is multiplied roughly by a factor of� The general way to parallelize any operation is to take a particular function that should be run multiple times and make it run parallelly in different processors. To do this, you initialize a Pool with n number of processors and pass the function you want to parallelize to one of Pools parallization methods.