Java 查找整数是否为整数和之一的有效方法

这是一项学校作业，然而，要求程序“以最高性能实施”——这对我来说是模糊的，因为我不知道记忆是否会超过速度等等。但我想知道的是，是否有一种“棘手”的方法通过对输入数据进行一些智能操作来解决问题

这样，问题是：考虑你有两个数组，A和B，写一个函数，如果B中有这样的整数，则返回1，这等于A.

的任意两个后续元素之和。 下面是我的笔迹。请注意，我没有使用Hashmap，因为我认为加速所需的内存是一个缺点，足以承受O（n*m）速度而不是O（n）的最坏情况

publicstatic int-arrayContainsSum（int[]a，int[]b）
{
int offsetA=a.长度-1；
int offsetB=offsetA；
int index=b.length-1；
int结果=0；
int测试；
而（索引>=0）
{
如果（偏移量>0）a[offsetA]+=a[--offsetA]；
else if（offsetA==0）//这有溢出int的危险
a[offsetA--]=乘（a）；
测试=b[指数]；
如果（（偏移量<0&&tested！=0&&a[0]%tested！=0）||
偏移量b==0）
{
//测试这个元素没有意义，因为它没有
//除以和的乘积
偏移量b=a.长度-1；
索引--；
}
如果（测试==a[offsetB--]）
{
结果=1；
打破
}
}
返回结果；
}
专用静态整数乘法（整数[]输入）
{
int累加器=输入。长度>0？1:0；
for（int i：输入）
如果（i！=0）累加器*=i；
回流蓄能器；
}

有一些事情我不关心：整数溢出（可能是乘法的结果）。我假设

array.length

与读取局部变量一样快

但是，再一次，我的问题是“难道不可能通过分析来解决这个问题吗？”这意味着更高的效率

---

问题并没有提到数组是否只包含唯一的成员——这没有限制。我还认为可以通过排序

a

来优化（如果我检测到这种情况），这样当

b[x]

小于

a

中的最小元素或大于

a

中的最大元素时，就可以节省一些查找，但这同样会增加复杂性，可能不完全合理。

速度并不重要，除非你有超过100万个元素，并且需要超过1秒。顺便说一句，您不希望使数组的大小超过100万个元素

不幸运的是，高达7的Java版本甚至不包含基本的集合操作。不过，您可以在库中找到它们（该代码经过适当测试，并且尽可能高效）

假设您有两组20个元素，

a

和

b

，它们是从1到100和200之间随机选择的

a = RandomInteger[{100}, 20]
b = RandomInteger[{200}, 20]

在此之后，您希望找到后续元素的

a

和与

b

ap = Table[Total[{a[[i]], a[[i + 1]]}], {i, 1, Length[a] - 1}]
Intersection[ap, b]

例如：

{73,43,99,33,80,35,54,82,50,23,92,22,54,4,14,14,8,80,92,85}
{121,139,158,158,51,176,65,84,76,172,73,148,71,128,55,134,4,32,183,134}
{116,142,132,113,115,89,136,132,73,115,114,76,58,18,28,22,88,172,177}
{73,76,172}

---

速度并不重要，除非你有超过100万个元素，它需要超过1秒。顺便说一句，您不希望使数组的大小超过100万个元素

不幸运的是，高达7的Java版本甚至不包含基本的集合操作。不过，您可以在库中找到它们（该代码经过适当测试，并且尽可能高效）

假设您有两组20个元素，

a

和

b

，它们是从1到100和200之间随机选择的

a = RandomInteger[{100}, 20]
b = RandomInteger[{200}, 20]

在此之后，您希望找到后续元素的

a

和与

b

ap = Table[Total[{a[[i]], a[[i + 1]]}], {i, 1, Length[a] - 1}]
Intersection[ap, b]

例如：

{73,43,99,33,80,35,54,82,50,23,92,22,54,4,14,14,8,80,92,85}
{121,139,158,158,51,176,65,84,76,172,73,148,71,128,55,134,4,32,183,134}
{116,142,132,113,115,89,136,132,73,115,114,76,58,18,28,22,88,172,177}
{73,76,172}

publicstatic int-arrayContainsSum（int[]a，int[]b）{
最终集合总和=新HashSet（）；
对于（int i=0；i

公共静态int-arrayContainsSum（int[]a，int[]b）{
最终集合总和=新HashSet（）；
对于（int i=0；i

如有疑问，请使用暴力

当然，如果任务是编写性能解决方案，这可能还不够，但在优化解决方案之前，您需要一个解决方案

val a = List (3, 9, 7, 4, 16)    
val b = List (29, 12, 21, 16, 18, 14) 

for (i <- (0 to a.length - 2); 
  j = i+1;
  if b.exists (_ == a(i)+a(j))) yield (a(i), a(j), a(i)+a(j)) 

vala=List（3,9,7,4,16）
val b=列表（29、12、21、16、18、14）
对于（i当有疑问时，使用暴力

当然，如果任务是编写性能解决方案，这可能还不够，但在优化解决方案之前，您需要一个解决方案

val a = List (3, 9, 7, 4, 16)    
val b = List (29, 12, 21, 16, 18, 14) 

for (i <- (0 to a.length - 2); 
  j = i+1;
  if b.exists (_ == a(i)+a(j))) yield (a(i), a(j), a(i)+a(j)) 

vala=List（3,9,7,4,16）
val b=列表（29、12、21、16、18、14）
对于（我不知道你的问题是什么意思；在这种情况下，你所说的“分析”是什么意思？如果你想用O（1）内存做这件事，是的，排序数组然后进行二进制搜索会更好（a和b是数组的大小）：O（a*b）vs.O（a loga+b*loga）。如果a==b，那么它是O（a^2）vs.O（a loga）。最佳算法speedwise（如您所知）有O（a）额外内存，但运行时间为O（b）。我必须说，我不明白您为什么需要调用乘法（我还没有弄清楚您的代码在做什么，但这对我来说很突出…）@奥利：我一点也不了解算法，我会把它写成一个简单的for循环，一个
包含
调用。我只看了上面的问题描述（它也有一个bug，因为我们这里只引用数组b….）你说有一个数组
A
，但你没有说这是什么意思。我不知道你的问题是什么意思；在这种情况下，你所说的“分析”是什么意思？如果你想用O（1）内存来做这件事，是的，对数组排序，然后做b