Algorithm Python编码一次复杂度

所以这是另一个可能是众所周知的Codibility平台的方法，关于青蛙过河的任务。很抱歉，如果这个问题被问得不好，这是我在这里的第一篇帖子

目标是找到青蛙能跳到河对岸的最早时间。 例如，给定X=5和数组A，则：

函数应该返回6

示例测试：（5、[1,3,1,4,2,3,5,4]）

完整任务内容：

这是我的第一个明显的方法：

def solution(X, A):
    lista = list(range(1, X + 1))
    if X < 1 or len(A) < 1:
        return -1
    found = -1
    for element in lista:
        if element in A:
            if A.index(element) > found:
                found = A.index(element)
        else: return -1
    return found

X = 5
A = [1,2,4,5,3]
solution(X,A)

def溶液（X，A）：
lista=列表（范围（1，X+1））
如果X<1或len（A）<1：
返回-1
发现=-1
对于lista中的元素：
如果A中的元素为：
如果A.index（element）>找到：
找到=A.索引（元素）
其他：返回-1
返回发现
X=5
A=[1,2,4,5,3]
解决方案（X，A）

此解决方案100%正确，在性能测试中获得0%

所以我认为行数少+列表理解会得到更好的分数：

def solution(X, A):
    if X < 1 or len(A) < 1:
        return -1
    try:
        found = max([ A.index(element) for element in range(1, X + 1) ])
    except ValueError:
        return -1
    return  found

X = 5
A = [1,2,4,5,3]
solution(X,A)

def溶液（X，A）：
如果X<1或len（A）<1：
返回-1
尝试：
找到=最大值（[A.范围（1，X+1）内元素的索引（元素）]）
除值错误外：
返回-1
返回发现
X=5
A=[1,2,4,5,3]
解决方案（X，A）

这一款也可以工作，性能为0%，但无论如何它都更快

我还找到了deanalvero（）的解决方案：

def溶液（X，A）：
#用Python 2.6编写代码
青蛙，叶子=0，[假]*（X）
对于分钟，叶在枚举（A）：
如果leaf嵌套循环的数量不能直接告诉您任何关于时间复杂性的信息。设n为输入数组的长度。while循环的内部平均需要O（1）时间，尽管其最坏情况的时间复杂度是O（n）。快速解决方案使用一个布尔数组leaves，其中，如果存在leaf，则在每个索引处都有值true，否则为false。在整个算法过程中，while循环内部的异常次数不超过n次。外部for循环也仅执行n次。这意味着算法的时间复杂度为O（n）
 嵌套循环的数量并不能直接告诉您有关时间复杂性的任何信息。设n为输入数组的长度。while循环的内部平均需要O（1）时间，尽管其最坏情况的时间复杂度是O（n）。快速解决方案使用一个布尔数组leaves，其中，如果存在leaf，则在每个索引处都有值true，否则为false。在整个算法过程中，while循环内部的异常次数不超过n次。外部for循环也仅执行n次。这意味着算法的时间复杂度为O（n）
 关键是两个初始解都是二次的。它们涉及对父元素的每个进行O（n）内部扫描（导致O（n**2））

快速解决方案最初似乎面临着相同的命运，因为它显然包含一个循环中的一个循环。但是内部while循环不会对每个“叶”进行完全扫描。看看“frog”在哪里初始化，你会注意到while循环有效地拾取了它在每个叶子上停止的位置。
关键是两个初始解都是二次的。它们涉及对父元素的每个进行O（n）内部扫描（导致O（n**2））

快速解决方案最初似乎面临着相同的命运，因为它显然包含一个循环中的一个循环。但是内部while循环不会对每个“叶”进行完全扫描。看看“frog”在哪里被初始化，您会注意到while循环有效地拾取了它在每个叶子上停止的位置。
答案已经告诉了，但我将添加一个可选的解决方案，我认为这可能有助于您理解：

def save_frog(x, arr):
    # creating the steps the frog should make
    steps = set([i for i in range(1, x + 1)])

    # creating the steps the frog already did
    froggy_steps = set()

    for index, leaf in enumerate(arr):
        froggy_steps.add(leaf)
        if froggy_steps == steps:
            return index
    return -1

答案已经给出，但我将添加一个可选的解决方案，我认为这可能有助于您理解：

def save_frog(x, arr):
    # creating the steps the frog should make
    steps = set([i for i in range(1, x + 1)])

    # creating the steps the frog already did
    froggy_steps = set()

    for index, leaf in enumerate(arr):
        froggy_steps.add(leaf)
        if froggy_steps == steps:
            return index
    return -1

以下是我如何解决此问题并获得0性能：

def solution(X, A):
    # write your code in Python 3.6
    if X not in A: return -1 
    else: return [i for i in range(len(A)) if(A[i]==X)][0]

我只用了两行就得到了这个表演
 以下是我如何解决此问题并获得0性能：

def solution(X, A):
    # write your code in Python 3.6
    if X not in A: return -1 
    else: return [i for i in range(len(A)) if(A[i]==X)][0]

我只用了两行就得到了这个表演
 这里有一个解决方案，您可以获得100%的正确性和性能

def solution(X, A):
    i = 0
    dict_temp = {}
    while i < len(A):
        dict_temp[A[i]] = i
        if len(dict_temp) == X:
            return i
        i += 1
    return -1

def溶液（X，A）：
i=0
dict_temp={}
而我
这是一个解决方案，您可以在正确性和性能方面获得100%的回报

def solution(X, A):
    i = 0
    dict_temp = {}
    while i < len(A):
        dict_temp[A[i]] = i
        if len(dict_temp) == X:
            return i
        i += 1
    return -1

def溶液（X，A）：
i=0
dict_temp={}
而我
这是我的100%解决方案，它考虑了数值级数的总和

def solution(X, A):
covered = [False] * (X+1)
n = len(A)
Sx = ((1+X)*X)/2 # sum of the numeric progression
for i in range(n):
    if(not covered[A[i]]):
        Sx -= A[i]
    covered[A[i]] = True
    if (Sx==0):
        return i
return -1

这是我的100%解，它考虑了数值级数的和

def solution(X, A):
covered = [False] * (X+1)
n = len(A)
Sx = ((1+X)*X)/2 # sum of the numeric progression
for i in range(n):
    if(not covered[A[i]]):
        Sx -= A[i]
    covered[A[i]] = True
    if (Sx==0):
        return i
return -1

自动假定一个循环较多的算法总是较慢，这是一个常见的错误。此外，您甚至没有计算
索引中的隐式循环（这是
O（n）
，因为
A
是一个无序数组）。自动假设循环越多的算法总是越慢，这是一个常见的错误。此外，您甚至没有计算
索引中的隐式循环（这是
O（n）
，因为
A
是无序数组）。在这种情况下，您还可以测试
len（froggy_步数）==x，而不是比较两个集合，如果这两个集合的大小相当大，这应该是一个轻微的改进。解决方案似乎是错误的，但通过了所有测试用例。设置的
froggy_步数
应仅为