entityMap|blocks|key|8cood|text|所以我实际上实现了它，但出于教育的目的，我不会在稍后发布它(我会在几个小时内更新它)，因为我假设这是为了一个课程或其他一些你应该自己弄明白的设置。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|er4vs|假设你正在尝试达到一个不同的目标|e7uno|并且您正在计算任意元素|94mge|..。只有两个值允许|6o259|在集合中有补语：|1f87l|和|9ldq5|..。|fg9pc|如果|8f8ut|或者|1tdpg|在之前的任何元素中，你都会知道这个集合有一对补码。否则，你会想要记录下这样一个事实|90uf4|已经被看到了。因此，如果|eeqs3|后来被发现，|ffbq9|将被查询为|8vq7n|会被考虑。|13adc|换句话说，我提出了一种方法，在这种方法中，您可以递归地遍历列表，并且|bpafs|(基本大小写)位于列表末尾|csph2|有一个当前元素|97qlb|这样的话|2avus|2gumb|已经被看到了|d6kiu|记录当前元素已被看到，并转到下一个元素|dbc75|理想情况下，这应该在最坏的情况下具有O(n)时间复杂度和O(n)空间复杂度(假设使用按引用传递或类似的有效实现，以及分期的常量时间集查询)。它也可以使用基本数组实现，但我不会说这更好(在python中)。|8ks6s|我将在几个小时后发布我的解决方案。祝你好运！|8s64n|编辑1：|eo1qn|希望你有足够的时间让它工作。我描述的方法可以按如下方式完成：|6r3bn|def+hasDiffRecur(L,+t,+i,+C):
++++"""
++++Recursive+version+to+see+if+list+has+difference
++++:param+L:+List+to+be+considered
++++:param+t:+Target+difference
++++:param+i:+Current+index+to+consider
++++:param+C:+Cache+set
++++"""
++++#+We've+reached+the+end.+Give+up
++++if+i+>=+len(L):+
++++++++return+False
++++
++++print(f"+>+L[{i}]+=+{L[i]:2};+is+{L[i]-t:3}+or+{L[i]%2Bt:2}+in+{C}")
++++
++++#+Has+the+complement+been+cached?
++++if+L[i]+-+t+in+C:+
++++++++print(f"!+Difference+between+{L[i]}+and+{L[i]-t}+is+{t}")
++++++++return+True
++++
++++if+L[i]+%2B+t+in+C:+
++++++++print(f"!+Difference+between+{L[i]}+and+{L[i]%2Bt}+is+{t}")
++++++++return+True
++++
++++#+Complement+not+seen+yet.+Cache+element+and+go+to+next+element
++++C.add(L[i])
++++return+hasDiffRecur(L,+t,+i%2B1,+C)

###################################################################

def+hasDiff(L,+t):
++++"""
++++Initialized+call+for+hasDiffRecur.+Also+prints+intro+message.+
++++See+hasDiffRecur+for+param+info
++++"""
++++print(f"\nIs+a+difference+of+{t}+present+in+{L}?")
++++return+hasDiffRecur(L,+t,+0,+set())

###################################################################

hasDiff([5,+4,+8,+-3,+6],+9)
hasDiff([-1,+5,+4],+3)
hasDiff([-1,+5,+4,+-1,+7],+0)+#+If+concerned+about+set+non-duplicity|code-block|syntax|javascript|ejb7b|输出：|89hpe|Is+a+difference+of+9+present+in+[5,+4,+8,+-3,+6]?
+>+L[0]+=++5;+is++-4+or+14+in+set()
+>+L[1]+=++4;+is++-5+or+13+in+{5}
+>+L[2]+=++8;+is++-1+or+17+in+{4,+5}
+>+L[3]+=+-3;+is+-12+or++6+in+{8,+4,+5}
+>+L[4]+=++6;+is++-3+or+15+in+{8,+-3,+4,+5}
!+Difference+between+6+and+-3+is+9

Is+a+difference+of+3+present+in+[-1,+5,+4]?
+>+L[0]+=+-1;+is++-4+or++2+in+set()
+>+L[1]+=++5;+is+++2+or++8+in+{-1}
+>+L[2]+=++4;+is+++1+or++7+in+{5,+-1}

Is+a+difference+of+0+present+in+[-1,+5,+4,+-1,+7]?
+>+L[0]+=+-1;+is++-1+or+-1+in+set()
+>+L[1]+=++5;+is+++5+or++5+in+{-1}
+>+L[2]+=++4;+is+++4+or++4+in+{5,+-1}
+>+L[3]+=+-1;+is++-1+or+-1+in+{4,+5,+-1}
!+Difference+between+-1+and+-1+is+0|v3t7|编辑2：|a691u|这是一个非常聪明和有效的解决方案。我确实意识到它的意图可能是根本不允许任何遍历(即不存在查询集合)。如果是这种情况，则可以使用预先分配为等于该列表的值的范围的大小的固定大小的列表来完成上述方法。|cr5vr|如果预先分配到列表范围大小的概念仍然迭代太多，我可以想到递归实现的穷举方法。对于这一点，可能有一种更有效的方法，但您可以将问题归结为一个类似于双循环的问题(O(n%5E2)时间复杂度)。这是一个微不足道的算法，我认为你可以在没有文档的情况下理解它，所以我把它放在这里是为了更完整：|1pe8d|def+hasDiffRecur(L,+t,+i+=+0,+j+=+1):
++++if+i+>=+len(L):+return+False
++++if+j+>=+len(L):+return+hasDiffRecur(L,+t,+i%2B1,+i%2B2)
++++if+abs(L[i]+-+L[j])+==+t:+return+True
++++return+hasDiffRecur(L,+t,+i,+j%2B1)

###################################################################

print(hasDiffRecur([5,+4,+8,+-3,+6],+9))++#+True
print(hasDiffRecur([-1,+5,+4],+3))++++++++#+False
print(hasDiffRecur([-1,+5,+4,+-1,+7],+0))+#+True^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|24|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|25|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|26|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|27|9|@]|A|@]|B|$]]|$2|I|4|J|6|7|8|28|9|@]|A|@]|B|$]]|$2|K|4|L|6|7|8|29|9|@]|A|@]|B|$]]|$2|M|4|N|6|7|8|2A|9|@]|A|@]|B|$]]|$2|O|4|P|6|7|8|2B|9|@]|A|@]|B|$]]|$2|Q|4|R|6|7|8|2C|9|@]|A|@]|B|$]]|$2|S|4|T|6|7|8|2D|9|@]|A|@]|B|$]]|$2|U|4|V|6|7|8|2E|9|@]|A|@]|B|$]]|$2|W|4|X|6|7|8|2F|9|@]|A|@]|B|$]]|$2|Y|4|Z|6|7|8|2G|9|@]|A|@]|B|$]]|$2|10|4|11|6|7|8|2H|9|@]|A|@]|B|$]]|$2|12|4|13|6|7|8|2I|9|@]|A|@]|B|$]]|$2|14|4|15|6|7|8|2J|9|@]|A|@]|B|$]]|$2|16|4|17|6|7|8|2K|9|@]|A|@]|B|$]]|$2|18|4|19|6|7|8|2L|9|@]|A|@]|B|$]]|$2|1A|4|R|6|7|8|2M|9|@]|A|@]|B|$]]|$2|1B|4|1C|6|7|8|2N|9|@]|A|@]|B|$]]|$2|1D|4|1E|6|7|8|2O|9|@]|A|@]|B|$]]|$2|1F|4|1G|6|7|8|2P|9|@]|A|@]|B|$]]|$2|1H|4|1I|6|7|8|2Q|9|@]|A|@]|B|$]]|$2|1J|4|1K|6|7|8|2R|9|@]|A|@]|B|$]]|$2|1L|4|1M|6|7|8|2S|9|@]|A|@]|B|$]]|$2|1N|4|1O|6|1P|8|2T|9|@]|A|@]|B|$1Q|1R]]|$2|1S|4|1T|6|7|8|2U|9|@]|A|@]|B|$]]|$2|1U|4|1V|6|1P|8|2V|9|@]|A|@]|B|$1Q|1R]]|$2|1W|4|1X|6|7|8|2W|9|@]|A|@]|B|$]]|$2|1Y|4|1Z|6|7|8|2X|9|@]|A|@]|B|$]]|$2|20|4|21|6|7|8|2Y|9|@]|A|@]|B|$]]|$2|22|4|23|6|1P|8|2Z|9|@]|A|@]|B|$1Q|1R]]]]

So I actually implemented it, but for educational purposes I'm not gonna post it until a bit later (I'll update it in a few hours) as I assume this is for a class or some other setting where you should figure it out on your own.
Assume you are trying to hit a difference target <code>t = 5</code> and you are evaluating an arbitrary element <code>8</code>. There are only two values that would allow <code>8</code> to have a complement in the set: <code>8 + 5 = 13</code> and <code>8 - 5 = 3</code>.
If <code>3</code> or <code>13</code> had been in any previous elements, you would know that the set has a pair of complements. Otherwise, you'd want to record the fact that <code>8</code> had been seen. Thereby, if <code>3</code> was found later, <code>8</code> would be queried as <code>3 + 5 = 8</code> would be considered.
In other words, I am proposing a method where you recursively traverse the list and either
<ul>
<li>(base case) Are at the end of the list</li>
<li>Have a current element <code>a</code> such that <code>a + t</code> or <code>a - t</code> has been seen</li>
<li>Record that the current element has been seen and go to the next element</li>
</ul>
Ideally, this should have O(n) time complexity and O(n) space complexity in the worst case (assuming efficient implementation with pass-by-reference or similar, and also amortized constant-time set query). It can also be implemented using a basic array, but I'm not going to say that's better (in python).
I'll post my solution in a few hours. Good luck!
<hr />
EDIT 1: Hopefully, you had enough time to get it to work. The method I described can be done as follows:
<pre><code>def hasDiffRecur(L, t, i, C):
 &quot;&quot;&quot;
 Recursive version to see if list has difference
 :param L: List to be considered
 :param t: Target difference
 :param i: Current index to consider
 :param C: Cache set
 &quot;&quot;&quot;
 # We've reached the end. Give up
 if i &gt;= len(L): 
 return False
 
 print(f&quot; &gt; L[{i}] = {L[i]:2}; is {L[i]-t:3} or {L[i]+t:2} in {C}&quot;)
 
 # Has the complement been cached?
 if L[i] - t in C: 
 print(f&quot;! Difference between {L[i]} and {L[i]-t} is {t}&quot;)
 return True
 
 if L[i] + t in C: 
 print(f&quot;! Difference between {L[i]} and {L[i]+t} is {t}&quot;)
 return True
 
 # Complement not seen yet. Cache element and go to next element
 C.add(L[i])
 return hasDiffRecur(L, t, i+1, C)

###################################################################

def hasDiff(L, t):
 &quot;&quot;&quot;
 Initialized call for hasDiffRecur. Also prints intro message. 
 See hasDiffRecur for param info
 &quot;&quot;&quot;
 print(f&quot;\nIs a difference of {t} present in {L}?&quot;)
 return hasDiffRecur(L, t, 0, set())

###################################################################

hasDiff([5, 4, 8, -3, 6], 9)
hasDiff([-1, 5, 4], 3)
hasDiff([-1, 5, 4, -1, 7], 0) # If concerned about set non-duplicity 
</code></pre>
OUTPUT:
<pre><code>Is a difference of 9 present in [5, 4, 8, -3, 6]?
 &gt; L[0] = 5; is -4 or 14 in set()
 &gt; L[1] = 4; is -5 or 13 in {5}
 &gt; L[2] = 8; is -1 or 17 in {4, 5}
 &gt; L[3] = -3; is -12 or 6 in {8, 4, 5}
 &gt; L[4] = 6; is -3 or 15 in {8, -3, 4, 5}
! Difference between 6 and -3 is 9

Is a difference of 3 present in [-1, 5, 4]?
 &gt; L[0] = -1; is -4 or 2 in set()
 &gt; L[1] = 5; is 2 or 8 in {-1}
 &gt; L[2] = 4; is 1 or 7 in {5, -1}

Is a difference of 0 present in [-1, 5, 4, -1, 7]?
 &gt; L[0] = -1; is -1 or -1 in set()
 &gt; L[1] = 5; is 5 or 5 in {-1}
 &gt; L[2] = 4; is 4 or 4 in {5, -1}
 &gt; L[3] = -1; is -1 or -1 in {4, 5, -1}
! Difference between -1 and -1 is 0
</code></pre>
<hr />
EDIT 2:
This is a pretty clever and efficient solution. I do realize that maybe it is the intention to not allow any traversal at all (i.e. no existance querying for set). If that is the case, the above approach can be done with a constant-size list that is pre-allocated to size equal to the range of the values of the list.
If the notion of pre-allocating to the size of the range of the list is still too much iteration, I can think of the exhaustive approach implemented recursively. There is likely a more efficient approach for this, but you could boil the problem down to a double-for-loop-like problem (O(n^2) time complexity). This is a trivial algorithm and I think you can understand it without documentation, so I'll just throw it in there to be complete:
<pre><code>def hasDiffRecur(L, t, i = 0, j = 1):
 if i &gt;= len(L): return False
 if j &gt;= len(L): return hasDiffRecur(L, t, i+1, i+2)
 if abs(L[i] - L[j]) == t: return True
 return hasDiffRecur(L, t, i, j+1)

###################################################################

print(hasDiffRecur([5, 4, 8, -3, 6], 9)) # True
print(hasDiffRecur([-1, 5, 4], 3)) # False
print(hasDiffRecur([-1, 5, 4, -1, 7], 0)) # True
</code></pre>

entityMap|blocks|key|e1gle|text|选择|type|unstyled|depth|inlineStyleRanges|entityRanges|data|bha6h|我将从一个接受列表的泛型函数开始，|31f2f|，以及多个可供选择的元素，|c4pg2|-|4f57l|def+choose(t,+n):
++if+n+==+0:
++++return+[[]]
++elif+not+t:
++++return+[]
++else:
++++return+append+\
++++++(+map+\
++++++++++(+choose(rest(t),+n+-+1)
++++++++++,+lambda+c:+append([first(t)],+c)
++++++++++)
++++++,+choose(rest(t),+n)
++++++)|code-block|syntax|javascript|aa5s4|print(choose(["a",+"b",+"c",+"d"],+2))|egv89|[['a',+'b'],+['a',+'c'],+['a',+'d'],+['b',+'c'],+['b',+'d'],+['c',+'d']]|2hvjb|帮助者|8k1p2|您的问题有相当多的限制，而Python是一种多范式语言，因此我们将使用一些帮助程序使其具有可读性|4l796|def+first(t):
++return+t[0]

def+rest(t):
++return+t[1:]

def+append(t0,+t1):
++return+t0+%2B+t1|5ptsd|我不知道如果|ekel4|算作进口，但我们会定义我们自己的以防万一-|4qi64|def+map(t,+f):
++if+not+t:
++++return+[]
++else:
++++return+append+\
++++++(+[f(first(t))]
++++++,+map(rest(t),+f)
++++++)|9b5mm|解算|csgdb|很好，现在我们已经完成了实现|2vv1t|，让我们看看如何将其应用于我们的问题|adfeg|print(choose([5,+4,+8,+-3,+6],+2))|a9jna|[[5,+4],+[5,+8],+[5,+-3],+[5,+6],+[4,+8],+[4,+-3],+[4,+6],+[8,+-3],+[8,+6],+[-3,+6]]|1lki8|如你所见，我们已经找到了2个元素的所有组合。我们只需要|f3o08|通过这些和|2nr4t|如果减去一对就能达到我们的目标，|bnnfd|bskbs|def+solve(t,+q):
++def+check(p):
++++(x,+y)+=+p
++++return+x+-+y+==+q+or+y+-+x+==+q
++def+loop(c):
++++if+not+c:
++++++return+False
++++else:
++++++return+check(first(c))+or+loop(rest(c))++++
++return+loop(choose(t,+2))|edmk8|print(solve([5,+4,+8,+-3,+6],+9))
print(solve([-1,+5,+4],+3))|6q373|True
False|64hm9|允许|6ai4u|2cto3|这是一个很好的练习来构建你的递归技巧。禁止|5brnr|是需要克服的最具挑战性的限制。这是如果我们可以用它的话它会是什么样子-|86ll2|def+choose(t,+n):
++if+n+==+0:
++++yield+[]
++elif+not+t:
++++return
++else:
++++for+c+in+choose(t[1:],+n+-+1):
++++++yield+[t[0]]+%2B+c
++++yield+from+choose(t[1:],+n)

def+solve(t,+q):
++for+(x,y)+in+choose(t,+2):
++++if+x+-+y+==+q+or+y+-+x+==+q:
++++++return+True
++return+False|cgapj|print(solve([5,+4,+8,+-3,+6],+9))
print(solve([-1,+5,+4],+3))|2ahp1|8d8tc|这个变体还有一个额外的优点，一旦找到解决方案，它就会停止计算组合。第一个变量必须计算|5rp2i|全部|ea650|首先组合，然后开始遍历它们。|bdr8a|允许其他内置|cj7b7|Python|f8emu|内置函数|810v1|包括|f0krr|和|fq82h|并为我们提供另一种方法来绕过|eea9k|限制，但我不确定这些是否被允许-|9sr4c|def+choose(t,+n):
++if+n+==+0:
++++yield+[]
++elif+not+t:
++++return
++else:
++++yield+from+map+\
++++++(+lambda+c:+[t[0]]+%2B+c
++++++,+choose(t[1:],+n+-+1)
++++++)
++++yield+from+choose(t[1:],+n)

def+solve(t,+q):
++def+check(p):
++++(x,y)+=+p
++++return+x+-+y+==+q+or+y+-+x+==+q
++return+any(map(check,+choose(t,+2)))|f6uh0|print(solve([5,+4,+8,+-3,+6],+9))
print(solve([-1,+5,+4],+3))|b2h7r^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|2R|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|2S|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|2T|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|2U|9|@]|A|@]|B|$]]|$2|I|4|J|6|K|8|2V|9|@]|A|@]|B|$L|M]]|$2|N|4|O|6|K|8|2W|9|@]|A|@]|B|$L|M]]|$2|P|4|Q|6|K|8|2X|9|@]|A|@]|B|$L|M]]|$2|R|4|S|6|7|8|2Y|9|@]|A|@]|B|$]]|$2|T|4|U|6|7|8|2Z|9|@]|A|@]|B|$]]|$2|V|4|W|6|K|8|30|9|@]|A|@]|B|$L|M]]|$2|X|4|Y|6|7|8|31|9|@]|A|@]|B|$]]|$2|Z|4|10|6|7|8|32|9|@]|A|@]|B|$]]|$2|11|4|12|6|K|8|33|9|@]|A|@]|B|$L|M]]|$2|13|4|14|6|7|8|34|9|@]|A|@]|B|$]]|$2|15|4|16|6|7|8|35|9|@]|A|@]|B|$]]|$2|17|4|18|6|7|8|36|9|@]|A|@]|B|$]]|$2|19|4|1A|6|K|8|37|9|@]|A|@]|B|$L|M]]|$2|1B|4|1C|6|K|8|38|9|@]|A|@]|B|$L|M]]|$2|1D|4|1E|6|7|8|39|9|@]|A|@]|B|$]]|$2|1F|4|1G|6|7|8|3A|9|@]|A|@]|B|$]]|$2|1H|4|1I|6|7|8|3B|9|@]|A|@]|B|$]]|$2|1J|4|H|6|7|8|3C|9|@]|A|@]|B|$]]|$2|1K|4|1L|6|K|8|3D|9|@]|A|@]|B|$L|M]]|$2|1M|4|1N|6|K|8|3E|9|@]|A|@]|B|$L|M]]|$2|1O|4|1P|6|K|8|3F|9|@]|A|@]|B|$L|M]]|$2|1Q|4|1R|6|7|8|3G|9|@]|A|@]|B|$]]|$2|1S|4|-4|6|7|8|3H|9|@]|A|@]|B|$]]|$2|1T|4|1U|6|7|8|3I|9|@]|A|@]|B|$]]|$2|1V|4|1W|6|7|8|3J|9|@]|A|@]|B|$]]|$2|1X|4|1Y|6|K|8|3K|9|@]|A|@]|B|$L|M]]|$2|1Z|4|20|6|K|8|3L|9|@]|A|@]|B|$L|M]]|$2|21|4|1P|6|K|8|3M|9|@]|A|@]|B|$L|M]]|$2|22|4|23|6|7|8|3N|9|@]|A|@]|B|$]]|$2|24|4|25|6|7|8|3O|9|@]|A|@]|B|$]]|$2|26|4|27|6|7|8|3P|9|@]|A|@]|B|$]]|$2|28|4|29|6|7|8|3Q|9|@]|A|@]|B|$]]|$2|2A|4|2B|6|7|8|3R|9|@]|A|@]|B|$]]|$2|2C|4|2D|6|7|8|3S|9|@]|A|@]|B|$]]|$2|2E|4|2F|6|7|8|3T|9|@]|A|@]|B|$]]|$2|2G|4|2H|6|7|8|3U|9|@]|A|@]|B|$]]|$2|2I|4|2J|6|7|8|3V|9|@]|A|@]|B|$]]|$2|2K|4|2L|6|7|8|3W|9|@]|A|@]|B|$]]|$2|2M|4|2N|6|K|8|3X|9|@]|A|@]|B|$L|M]]|$2|2O|4|2P|6|K|8|3Y|9|@]|A|@]|B|$L|M]]|$2|2Q|4|1P|6|K|8|3Z|9|@]|A|@]|B|$L|M]]]]

choose
I'll start with a generic function that takes a list, <code>t</code>, and a number of elements to choose, <code>n</code> -
<pre class="lang-py prettyprint-override"><code>def choose(t, n):
 if n == 0:
 return [[]]
 elif not t:
 return []
 else:
 return append \
 ( map \
 ( choose(rest(t), n - 1)
 , lambda c: append([first(t)], c)
 )
 , choose(rest(t), n)
 )
</code></pre>
<pre class="lang-py prettyprint-override"><code>print(choose([&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;], 2))
</code></pre>
<pre class="lang-py prettyprint-override"><code>[['a', 'b'], ['a', 'c'], ['a', 'd'], ['b', 'c'], ['b', 'd'], ['c', 'd']]
</code></pre>
helpers
Your question imposes quite a few restrictions and Python is a multi-paradigm language and so we're going to use a number of helpers to make things readable
<pre class="lang-py prettyprint-override"><code>def first(t):
 return t[0]

def rest(t):
 return t[1:]

def append(t0, t1):
 return t0 + t1
</code></pre>
I don't know if <code>map</code> counts as an import, but we will define our own just in case -
<pre class="lang-py prettyprint-override"><code>def map(t, f):
 if not t:
 return []
 else:
 return append \
 ( [f(first(t))]
 , map(rest(t), f)
 )
</code></pre>
solve
Great, now that we've finished implementing <code>choose</code>, let's see how we can apply it to our problem
<pre class="lang-py prettyprint-override"><code>print(choose([5, 4, 8, -3, 6], 2))
</code></pre>
<pre class="lang-py prettyprint-override"><code>[[5, 4], [5, 8], [5, -3], [5, 6], [4, 8], [4, -3], [4, 6], [8, -3], [8, 6], [-3, 6]]
</code></pre>
As you can see, we've found all combinations of 2 elements. We just need to <code>loop</code> through these and <code>check</code> if a pair can be subtracted to reach our target, <code>q</code> -
<pre class="lang-py prettyprint-override"><code>def solve(t, q):
 def check(p):
 (x, y) = p
 return x - y == q or y - x == q
 def loop(c):
 if not c:
 return False
 else:
 return check(first(c)) or loop(rest(c)) 
 return loop(choose(t, 2))
</code></pre>
<pre class="lang-py prettyprint-override"><code>print(solve([5, 4, 8, -3, 6], 9))
print(solve([-1, 5, 4], 3))
</code></pre>
<pre class="lang-py prettyprint-override"><code>True
False
</code></pre>
allowing <code>for</code>
This is a great exercise to build your recursion skills. Disallowing <code>for</code> is the most challenging restriction to overcome. Here's what it could look like if we could use it -
<pre class="lang-py prettyprint-override"><code>def choose(t, n):
 if n == 0:
 yield []
 elif not t:
 return
 else:
 for c in choose(t[1:], n - 1):
 yield [t[0]] + c
 yield from choose(t[1:], n)

def solve(t, q):
 for (x,y) in choose(t, 2):
 if x - y == q or y - x == q:
 return True
 return False
</code></pre>
<pre class="lang-py prettyprint-override"><code>print(solve([5, 4, 8, -3, 6], 9))
print(solve([-1, 5, 4], 3))
</code></pre>
<pre class="lang-py prettyprint-override"><code>True
False
</code></pre>
This variant has an added advantage that it will stop computing combinations as soon as a solution is found. The first variant must compute all combinations first and then begin iterating through them.
allowing other built-ins
Python <a href="https://docs.python.org/3/library/functions.html" rel="nofollow noreferrer">built-in functions</a> include <code>map</code> and <code>any</code> and offer us another way to get around the <code>for</code> restriction, but I'm unsure if those are allowed -
<pre class="lang-py prettyprint-override"><code>def choose(t, n):
 if n == 0:
 yield []
 elif not t:
 return
 else:
 yield from map \
 ( lambda c: [t[0]] + c
 , choose(t[1:], n - 1)
 )
 yield from choose(t[1:], n)

def solve(t, q):
 def check(p):
 (x,y) = p
 return x - y == q or y - x == q
 return any(map(check, choose(t, 2)))
</code></pre>
<pre class="lang-py prettyprint-override"><code>print(solve([5, 4, 8, -3, 6], 9))
print(solve([-1, 5, 4], 3))
</code></pre>
<pre class="lang-py prettyprint-override"><code>True
False
</code></pre>

entityMap|blocks|key|eba87|text|问题：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5ml7m|给定一个int数组|delt4|和int|eqsim|5uk02|中每个元素之间的差异是否|4r6sr|等于|4f0o6|使用递归|5j90o|不要使用|cjifv|3mdcr|和|fc5ae|cgf23|示例：|cclq9|>>>+aList+=+[5,+4,+8,+-3,+6]
>>>+target+=+9
return+True

>>>+aList+=+[-1,+5,+4]
>>>+target+=+3
return+False|code-block|syntax|javascript|291ik|比较差异：|9kmga|5++4++8++-3+6
-------------------------
5++%7C++X
4++%7C++1++X
8++%7C++3++4++X
-3+%7C++6++7++11+X
6++%7C++1++2++2++9++X

where+X+means+that+there's+no+difference+(same+number)
since+we+find+9+there,+so+it+should+return+True+(target+is+9)|7tucj|传统的for循环|3be5p|要解决递归问题，首先尝试用传统的|1da4u|循环：|bs83a|def+compareAll(lst,+tgt):
++for+x+in+lst:+#+let's+call+this+x+loop
++++for+y+in+lst:+#+let's+call+this+y+loop
++++++if+abs(x-y)+==+tgt:
++++++++return+True
++return+False
print(+compareAll([5,4,8,-3,6],9)+)
print(+compareAll([-1,5,4],3)+)|ccm03|这将返回|4fk0a|然后|7bvi9|递归|lkic|现在我们可以尝试使用递归循环。因为我们已经得到了|3jfoi|循环，我们可以这样转换它：|c7ttm|def+compareAll(lst,+tgt,+x=0,+y=0):
++if(len(lst)-1+==+x+and+len(lst)+==+y):
++++return+False
++if(len(lst)+==+x+or+len(lst)+==+y):
++++return+compareAll(lst,+tgt,+x%2B1,+0)
++if(abs(lst[x]+-+lst[y])==tgt):
++++return+True
++return+compareAll(lst,+tgt,+x,+y%2B1)
print(+compareAll([5,4,8,-3,6],9)+)
print(+compareAll([-1,5,4],3)+)|bpq9h|如何转换|5u31s|循环到下面：|8u77a|python的|66fie|循环实际上是|bbhsh|大多数其他语言中的循环|6nr4c|所以，纯|3gvdu|python中的循环将如下所示：|11rd6|def+compareAll(lst,+tgt):
++x+=+0
++while+x+<+len(lst):+#+let's+call+this+x+loop
++++y+=+0
++++while+y+<+len(lst):+#+let's+call+this+y+loop
++++++if+abs(lst[x]-lst[y])+==+tgt:
++++++++return+True
++++++y+=+y%2B1
++++x+=+x%2B1
++return+False
print(+compareAll([5,4,8,-3,6],9)+)
print(+compareAll([-1,5,4],3)+)|26t70|注意的停止条件|bu80d|：当所有数组元素都已循环时|c165a|所以我们在这里添加停止条件：|3q8um|f3v2|c2bfj|fi9sg|这会停止当前|6ohir|并继续使用|865bc|然后，我们添加循环的实际内容：|at387|最后，我们必须继续循环：|1fh7g|将for循环转换为递归循环的关键是确定循环应该何时结束，以及何时应该继续。^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|2N|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|2O|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|2P|9|@]|A|@]|B|$]]|$2|G|4|-4|6|7|8|2Q|9|@]|A|@]|B|$]]|$2|H|4|I|6|7|8|2R|9|@]|A|@]|B|$]]|$2|J|4|K|6|7|8|2S|9|@]|A|@]|B|$]]|$2|L|4|M|6|7|8|2T|9|@]|A|@]|B|$]]|$2|N|4|O|6|7|8|2U|9|@]|A|@]|B|$]]|$2|P|4|O|6|7|8|2V|9|@]|A|@]|B|$]]|$2|Q|4|R|6|7|8|2W|9|@]|A|@]|B|$]]|$2|S|4|O|6|7|8|2X|9|@]|A|@]|B|$]]|$2|T|4|U|6|7|8|2Y|9|@]|A|@]|B|$]]|$2|V|4|W|6|X|8|2Z|9|@]|A|@]|B|$Y|Z]]|$2|10|4|11|6|7|8|30|9|@]|A|@]|B|$]]|$2|12|4|13|6|X|8|31|9|@]|A|@]|B|$Y|Z]]|$2|14|4|15|6|7|8|32|9|@]|A|@]|B|$]]|$2|16|4|17|6|7|8|33|9|@]|A|@]|B|$]]|$2|18|4|19|6|7|8|34|9|@]|A|@]|B|$]]|$2|1A|4|1B|6|X|8|35|9|@]|A|@]|B|$Y|Z]]|$2|1C|4|1D|6|7|8|36|9|@]|A|@]|B|$]]|$2|1E|4|1F|6|7|8|37|9|@]|A|@]|B|$]]|$2|1G|4|1H|6|7|8|38|9|@]|A|@]|B|$]]|$2|1I|4|1J|6|7|8|39|9|@]|A|@]|B|$]]|$2|1K|4|1L|6|7|8|3A|9|@]|A|@]|B|$]]|$2|1M|4|1N|6|X|8|3B|9|@]|A|@]|B|$Y|Z]]|$2|1O|4|1P|6|7|8|3C|9|@]|A|@]|B|$]]|$2|1Q|4|1R|6|7|8|3D|9|@]|A|@]|B|$]]|$2|1S|4|1T|6|7|8|3E|9|@]|A|@]|B|$]]|$2|1U|4|1V|6|7|8|3F|9|@]|A|@]|B|$]]|$2|1W|4|1X|6|7|8|3G|9|@]|A|@]|B|$]]|$2|1Y|4|1Z|6|7|8|3H|9|@]|A|@]|B|$]]|$2|20|4|21|6|7|8|3I|9|@]|A|@]|B|$]]|$2|22|4|23|6|X|8|3J|9|@]|A|@]|B|$Y|Z]]|$2|24|4|25|6|7|8|3K|9|@]|A|@]|B|$]]|$2|26|4|27|6|7|8|3L|9|@]|A|@]|B|$]]|$2|28|4|29|6|7|8|3M|9|@]|A|@]|B|$]]|$2|2A|4|25|6|7|8|3N|9|@]|A|@]|B|$]]|$2|2B|4|27|6|7|8|3O|9|@]|A|@]|B|$]]|$2|2C|4|29|6|7|8|3P|9|@]|A|@]|B|$]]|$2|2D|4|2E|6|7|8|3Q|9|@]|A|@]|B|$]]|$2|2F|4|2G|6|7|8|3R|9|@]|A|@]|B|$]]|$2|2H|4|2I|6|7|8|3S|9|@]|A|@]|B|$]]|$2|2J|4|2K|6|7|8|3T|9|@]|A|@]|B|$]]|$2|2L|4|2M|6|7|8|3U|9|@]|A|@]|B|$]]]]

<h1>Problem:</h1>
<ul>
<li>given an array of int <code>aList</code> and int <code>target</code>,</li>
<li>check if the difference between each element in <code>aList</code> equals to <code>target</code></li>
<li>use recursion</li>
<li>do not use <code>.sort()</code></li>
<li>do not use <code>while</code> and <code>for</code></li>
<li>do not use <code>import</code></li>
</ul>
<h3>Example:</h3>
<pre><code>&gt;&gt;&gt; aList = [5, 4, 8, -3, 6]
&gt;&gt;&gt; target = 9
return True

&gt;&gt;&gt; aList = [-1, 5, 4]
&gt;&gt;&gt; target = 3
return False
</code></pre>
<h3>Comparing the differences:</h3>
<pre><code> 5 4 8 -3 6
-------------------------
5 | X
4 | 1 X
8 | 3 4 X
-3 | 6 7 11 X
6 | 1 2 2 9 X

where X means that there's no difference (same number)
since we find 9 there, so it should return True (target is 9)
</code></pre>
<h1>Traditional for loops</h1>
To solve recursion problem, first try to solve it with traditional <code>for</code> loops:
<pre><code>def compareAll(lst, tgt):
 for x in lst: # let's call this x loop
 for y in lst: # let's call this y loop
 if abs(x-y) == tgt:
 return True
 return False
print( compareAll([5,4,8,-3,6],9) )
print( compareAll([-1,5,4],3) )
</code></pre>
This returns <code>True</code> then <code>False</code>
<h1>Recursion</h1>
Now we can try using recursion loop. Since we already got the <code>for</code> loop, we can convert it like this:
<pre><code>def compareAll(lst, tgt, x=0, y=0):
 if(len(lst)-1 == x and len(lst) == y):
 return False
 if(len(lst) == x or len(lst) == y):
 return compareAll(lst, tgt, x+1, 0)
 if(abs(lst[x] - lst[y])==tgt):
 return True
 return compareAll(lst, tgt, x, y+1)
print( compareAll([5,4,8,-3,6],9) )
print( compareAll([-1,5,4],3) )
</code></pre>
<h3>How I convert <code>for</code> loop into this:</h3>
<ul>
<li>python's <code>for</code> loop is actually <code>foreach</code> loop in most other languages</li>
<li>so, pure <code>for</code> loop in python will be like:</li>
</ul>
<pre><code>def compareAll(lst, tgt):
 x = 0
 while x &lt; len(lst): # let's call this x loop
 y = 0
 while y &lt; len(lst): # let's call this y loop
 if abs(lst[x]-lst[y]) == tgt:
 return True
 y = y+1
 x = x+1
 return False
print( compareAll([5,4,8,-3,6],9) )
print( compareAll([-1,5,4],3) )
</code></pre>
<ul>
<li>notice the stopping condition of <code>x loop</code>: when all the array element have been looped
<ul>
<li>so we add stopping condition here: <code>if(len(lst)-1 == x and len(lst) == y): return False</code></li>
</ul>
</li>
<li>notice the stopping condition of <code>y loop</code>: when all the array element have been looped
<ul>
<li>so we add stopping condition here: <code>if(len(lst) == x or len(lst) == y): return compareAll(lst, tgt, x+1, 0)</code></li>
<li>this stops the current <code>y loop</code> and continue with the <code>x loop</code></li>
</ul>
</li>
<li>then, we add the actual content of the loop: <code>if(abs(lst[x] - lst[y])==tgt): return True</code></li>
<li>last, we have to continue the loop: <code>return compareAll(lst, tgt, x, y+1)</code></li>
</ul>
The key to convert for loop into recursive loop is just to identify when the loop should end, and when the loop should continue.

entityMap|blocks|key|c8cgv|text|这应该是可行的，而且非常简洁：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|7iluq|def+q(target,+aList,+memo=set()):
++++if+len(aList)+==+0:
++++++++return+False
++++num+=+aList.pop()
++++memo.add(num)++++
++++if+target+%2B+num+in+memo:
++++++++return+True
++++return+q(target,+aList,+memo)


q(target=9,+aList=[5,+4,+8,+-3,+6])+#+True++++
q(target=3,+aList=[-1,5,4])+#+False|code-block|syntax|javascript|2egqj|对我来说，关键的洞察力是一个目标|b5klq|和一个给定的数字|93knp|，不同之处|au5ud|是已知的。无论添加了多少项，Dict/set/hashmap都能快速检测成员身份。所以..。只是|cts9v|遍历值列表，并将它们放入hashmap中以便稍后进行比较。^0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|R|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|S|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|T|9|@]|A|@]|B|$]]|$2|J|4|K|6|7|8|U|9|@]|A|@]|B|$]]|$2|L|4|M|6|7|8|V|9|@]|A|@]|B|$]]|$2|N|4|O|6|7|8|W|9|@]|A|@]|B|$]]|$2|P|4|Q|6|7|8|X|9|@]|A|@]|B|$]]]]

This should work and is quite concise:
<pre><code>def q(target, aList, memo=set()):
 if len(aList) == 0:
 return False
 num = aList.pop()
 memo.add(num) 
 if target + num in memo:
 return True
 return q(target, aList, memo)


q(target=9, aList=[5, 4, 8, -3, 6]) # True 
q(target=3, aList=[-1,5,4]) # False
</code></pre>
The key insight for me is that a target <code>t</code> and a given number <code>n</code>, the difference <code>d</code> is known. Dict/set/hashmaps are fast at detecting membership, regardless of how many items are added. So... just <code>pop</code> through the list of values and chuck them into a hashmap for later comparison.

entityMap|blocks|key|46c3b|text|这个问题可以通过检查列表中的每一对可能的数字来解决。如果允许使用Python的标准库，那么解决方案非常简单。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5nj0g|from+itertools+import+product

def+check(xs,+target):
++++return+any(map(lambda+x:+x[0]-x[1]+==+target,+product(xs,+xs)))|code-block|syntax|javascript|11l97|分解|r6nr|给出了xs与自身的叉积。|8diu2|如果iterable的任何元素为true，则返回true|fdjd2|惰性(将函数应用于iterable的每个元素)|eo0f|带参数的匿名函数|20rel|并返回表达式的结果|9csp2|中的return语句|aufpm|使用惰性结构，因此它只做所需的工作，并且节省空间。^0|0|0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|X|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|Y|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|Z|9|@]|A|@]|B|$]]|$2|J|4|K|6|7|8|10|9|@]|A|@]|B|$]]|$2|L|4|M|6|7|8|11|9|@]|A|@]|B|$]]|$2|N|4|O|6|7|8|12|9|@]|A|@]|B|$]]|$2|P|4|Q|6|7|8|13|9|@]|A|@]|B|$]]|$2|R|4|S|6|7|8|14|9|@]|A|@]|B|$]]|$2|T|4|U|6|7|8|15|9|@]|A|@]|B|$]]|$2|V|4|W|6|7|8|16|9|@]|A|@]|B|$]]]]

The problem can be solved by checking every possible pair of numbers in the list for a solution. If you are allowed to use Python's standard library, then the solution is pretty straight forward.
<pre><code>from itertools import product

def check(xs, target):
 return any(map(lambda x: x[0]-x[1] == target, product(xs, xs)))

</code></pre>
<h3>Breakdown</h3>
<ul>
<li><code>product(xs, xs)</code> gives the cross product of xs with itself</li>
<li><code>any(iterable)</code> returns true if any element of iterable is truthy</li>
<li><code>map(function, iterable)</code> lazily (applies function to every element of iterable)</li>
<li><code>lambda arg_tuple: expression</code> annonymous function with arguments <code>arg_tuple</code> and returns the result of expression</li>
</ul>
The return statement in <code>check</code> uses lazy structures so it only does as much work as
is needed, and is space efficient.

entityMap|blocks|key|21kqf|text|假设这只是一个递归练习，它可能不会排除“蛮力”方法。您可以使用递归将每个值与其余值配对，直到找到匹配的差异。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|171pb|例如：|au4as|def+hasDiff(L,diff,base=None):
++++if+not+L:+return+False++++#+empty+list:+no+match
++++if+base+is+None:++++++++++#+search+with+&+without+first+as+base++++++
++++++++return+hasDiff(L[1:],diff,L[0])+or+hasDiff(L[1:],diff)
++++return+abs(base-L[0])+==+diff+or+hasDiff(L[1:],diff,base)+#+match+or+recurse
++++
print(hasDiff([5,+4,+8,+-3,+6],9))+#+True
print(hasDiff([-1,+5,+4],3))+++++++#+False|code-block|syntax|javascript|b50kr|当函数使用基值递归时，它只检查列表的其余部分中的第一项，并递归其他值。当函数在没有基值的情况下递归时，它会尝试寻找不涉及第一项的新对(即在列表的其余部分)^0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|L|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|M|9|@]|A|@]|B|$]]|$2|E|4|F|6|G|8|N|9|@]|A|@]|B|$H|I]]|$2|J|4|K|6|7|8|O|9|@]|A|@]|B|$]]]]

Assuming that this is just an exercise in recursion, it probably doesn't preclude a &quot;brute force&quot; approach. You can use the recursion to pair up every value with the remaining ones until you find a matching difference.
For example:
<pre><code>def hasDiff(L,diff,base=None):
 if not L: return False # empty list: no match
 if base is None: # search with &amp; without first as base 
 return hasDiff(L[1:],diff,L[0]) or hasDiff(L[1:],diff)
 return abs(base-L[0]) == diff or hasDiff(L[1:],diff,base) # match or recurse
 
print(hasDiff([5, 4, 8, -3, 6],9)) # True
print(hasDiff([-1, 5, 4],3)) # False
</code></pre>
When the function recurses with a base value, it merely checks the first item in the remainder of the list and recurses for the other values. When the function recurses without a base value, it tries to find new pairs that don't involve the first item (i.e. in the remainder of the list)

Given a list of unsorted integers and a target integer, find out if any pair's difference in the list is equal to the target integer with recursion.
<pre><code>&gt;&gt;&gt; aList = [5, 4, 8, -3, 6]
&gt;&gt;&gt; target = 9
return True

&gt;&gt;&gt; aList = [-1, 5, 4]
&gt;&gt;&gt; target = 3
return False
</code></pre>
<ul>
<li>For and while loops are not allowed.</li>
<li>No imports allowed.</li>
<li>.sort() is not allowed.</li>
</ul>
I tried this and it didn't work.
<pre><code>def calculate(aList, target):

 if len(aList) == 0 and diff != 0:
 return False

 startIndex = 0
 endIndex = len(aList) - 1

 return resursive_sum(aList, target, startIndex, endIndex)

def resursive_sum(aList, targ, start, end):

 print(f'Start: {start}')
 print(f'End: {end}')

 if start == end:
 return False
 elif aList[end] - aList[start] == targ:
 return True
 elif aList[end] - aList[start] &lt; targ:
 return resursive_sum(values, targ, start, end - 1)
 return resursive_sum(aList, targ, start + 1, end)
</code></pre>
I'm unsure of how this problem could be solved if we aren't able to use loops to sort the list. Even if we could use recursion to sort the list, how should the recursion look so that it can scan every pair's difference?

Find the target difference in a pair with recursion

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

 给定一个未排序的整数列表和一个目标整数，找出列表中任何一对的差值是否与目标整数的递归相等。 >>> aList = [5, 4, 8, -3, 6]>>> target = 9return True>>> aList = [-1, 5, 4]>>> target = 3return False 不允许使用For和wh...

问使用递归查找成对的目标差异
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用递归查找成对的目标差异EN