It's O(n), since it must check every element. If you want better performance for max, you can use the heapq module. However, you have to negate each value, since heapq provides a min heap. Inserting an element into a heap is O(log n).
It's O(n), since it must check every element. If you want better performance for max, you can use the heapq module. However, you have to negate each value, since heapq provides a min heap. Inserting an element into a heap is O(log n).
Of course it is O(n) unless you are using a different datastructure supporting the max of a value collection due to some implementation invariant.
That depends what exactly you mean by "constant sized". The time to find the minimum of a list with 917,340 elements is 
with a very large constant factor. The time to find the minimum of various lists of different constant sizes is 
and likely 
where 
is the size of each list. Finding the minimum of a list of 917,340 elements takes much longer than finding the minimum of a list of 3 elements.
I found this quote from the Wikipedia article on time complexity helpful:
The time complexity is generally expressed as a function of the size of the input.
So if the size of the input doesn't vary, for example if every list is of 256 integers, the time complexity will also not vary and the time complexity is therefore O(1). This would be true of any algorithm, such as sorting, searching, etc.
How to Compute Max Value with Linear Time Complexity When 'k' Is Not Fixed?
What is the time complexity of the Python code below?
Problem description and code provided.
def max_independent_set(nums): #function
dp=[0 for i in range(len(nums))] #create a dp table to find the max sum at index i
How to Compute Max Value with Linear Time Complexity When 'k' Is Not Fixed?
Time-complexity of this algo?
Body: Hello! I'm stuck on a problem and could really use some fresh perspectives. I'm trying to figure out a linear time solution (`Theta(n)`) for a problem that's a bit tricky due to its varying parameters.
Here's the Challenge: Picture a line of creatures, each with its own strength and a unique ability. We have two lists: `x` for their strengths and `k` for the number of creatures in front of each (including itself) they can turn to for help.
Example to Illustrate: Let's say `x = [5, 10, 7, 2, 20]` and `k = [1, 2, 1, 3, 2]`. We need to find the maximum strength each creature can muster. For the fourth creature, it looks at the 3 creatures (`k[3] = 3`) - itself and the two creatures before it, considers the strengths `[10, 7, 2]`, and realizes it can leverage a maximum strength of `10`.
Our goal is to output a list where each element is this maximum accessible strength for each creature.
Where I'm Stuck: Here's my Python attempt so far:
def calculate_ output(x, k):
output = []
for i in range(len(x)):
start_index = max(0, i - k[i])
end_index = i + 1
output.append(max(x[start_index:end_index]))
return outputThis isn't efficient. The nested iterations due to `max` make it O(n^2). For each creature, we slice and dice through the list based on `k`, which isn't ideal.
Looking for Advice: I'm hitting a wall here. Maybe there's a way to do this with a sliding window, but the variable range in `k` throws a wrench in the works. Any thoughts on data structures or algorithms to make this linear?
Thanks in advance! Looking forward to your insights.
Body: Hello! I'm stuck on a problem and could really use some fresh perspectives. I'm trying to figure out a linear time solution (`Theta(n)`) for a problem that's a bit tricky due to its varying parameters.
Here's the Challenge: Picture a line of creatures, each with its own strength and a unique ability. We have two lists: `x` for their strengths and `k` for the number of creatures in front of each (including itself) they can turn to for help.
Example to Illustrate: Let's say `x = [5, 10, 7, 2, 20]` and `k = [1, 2, 1, 3, 2]`. We need to find the maximum strength each creature can muster. For the fourth creature, it looks at the 3 creatures (`k[3] = 3`) - itself and the two creatures before it, considers the strengths `[10, 7, 2]`, and realizes it can leverage a maximum strength of `10`.
Our goal is to output a list where each element is this maximum accessible strength for each creature.
Where I'm Stuck: Here's my Python attempt so far:
def calculate_ output(x, k):
output = []
for i in range(len(x)):
start_index = max(0, i - k[i])
end_index = i + 1
output.append(max(x[start_index:end_index]))
return outputThis isn't efficient. The nested iterations due to `max` make it O(n^2). For each creature, we slice and dice through the list based on `k`, which isn't ideal.
Looking for Advice: I'm hitting a wall here. Maybe there's a way to do this with a sliding window, but the variable range in `k` throws a wrench in the works. Any thoughts on data structures or algorithms to make this linear?
Thanks in advance! Looking forward to your insights.
I was taking a Hackerrank test for employment screening and some of the test cases kept coming back with a timeout error, meaning that the code is running too slow. However, it runs perfectly fine in Pycharm.
I think this is no more than O(n), or maybe O(3N), but what am I not understanding here?
Follow up, what can I do to make this run faster? I wasn't sure if the max() and count() functions were terribly inefficient, so I implemented my own on the spot that I knew were definitely O(n) and still got the error on some test cases. I also tried storing the list slice as a variable once per iteration so it wouldn't have to re-slice the array.
def frequencyOfMaxValue(price, query):
answers = []
for q in query:
maximum = max(price[q-1:])
c = price[q-1:].count(maximum)
answers.append(c)
return answers
Edit:
Here's the problem.
price is an int array as is query. Each element in the query array specifies a starting index(indexes start at 1, rather than 0 which is odd but anyway) of the price array in which to search for count of the maximum element. The count of occurrences of the maximum element of the subarray is added to the return array, answers.
It seems my issue was iterating through the subarray of price once to find the max, then a second time to count the occurrences of the max.