Question

首先，有点背景知识：

我正在研究the Codility lessons之一，即使这很容易解决，但从逻辑上来说，它在性能方面不太容易解决。

我已经能够将其归结为：

public func solution(_ A : inout [Int]) -> Int {
    let B = A   // Assigning it to a local speeds it up.
    return Array<Int>(Set(B)).sorted(by: {$0<$1}).reduce(0) { ($1 == $0 + 1) ? $1 : $0 } + 1
}

但是，这只是 WEE 位太慢。我猜主要的原因是reduce会通过数组的所有元素，即使答案可能是早期的。我可能无法加快速度。

但我想尝试一下。我正在关注的部分是：

.reduce(0) { ($1 == $0 + 1) ? $1 : $0 }

我想知道我是否可以提高效率。

我必须检查$ 1是否等于$ 0 + 1.我无法避免这种比较。

三元运算符实际上并不比if子句快，但它看起来更酷;）。

是否有一种更高性能的方法来比较两个正整数的等价性而不是基本的＆＃34; ==＆＃34;操作

顺便说一下：这不是一个＆＃34;为我做的功课＆＃34;题。它非常合法，而且这些Codility课程不会给你信任或任何东西。他们只是一个有趣的运动。我想知道怎么做，因为我确定我将来需要它。

Answer 1

在评论中使用@ TNguyen建议的解决方案，下面的代码得到100％的正确性和性能。

您只需要通过调用fo <- 'a' ~ b + c as.formula(gsub("\"a\"", "\"happy\"", deparse(fo))) #"happy" ~ b + c fo2 = func1(a, b) ~ func2("e", 10) + b * c + func3(d) as.formula(gsub("func2(\"e\", 10)", "func2(HAN, SOLO)", deparse(fo2), fixed = TRUE)) #func1(a, b) ~ func2(HAN, SOLO) + b * c + func3(d)生成正确的数组，其中包含[1..(N + 1)]范围内的每个整数。然后使用Array(1...A.count+1)对其元素求和，最后减去输入数组reduce(0,+)的元素之和。两个总和之间的差异给出了缺失的元素。

更快的解决方案是使用数学公式public func solution(_ A : inout [Int]) -> Int { return Array(1...A.count+1).reduce(0,+)-A.reduce(0,+) }作为第一笔和。

1+2+...+n=n(n-1)/2

Answer 2

使用其他概念在python中获得100％的分数：

def solution(A):
 Index=0;
 while (Index<len(A)):
  while((A[Index]-1) != Index and A[Index]<=len(A)):
   Tmp=A[Index]; #Permut
   A[Index]=A[Tmp-1];
   A[Tmp-1]=Tmp;
  Index+=1;
 Index=0;
 while Index<len(A):
  if((A[Index]-1) != Index) :
   return Index+1;
  else:
   Index+=1;
 return len(A)+1;  
pass

背后的想法是，对于给定的排列，每个元素A [Index] -1应该与Index匹配，除了缺少的元素。然后置换阵列的元素，直到在A [Index]> len（A）时实现或不实现对应。

找到给定排列中缺少的元素

2 个答案: