1
00:00:00,150 --> 00:00:04,110
所以还有另一个度量算法的组成部分, 那就是空间复杂度 

2
00:00:04,110 --> 00:00:07,080
那么什么是空间复杂性呢？

3
00:00:08,610 --> 00:00:10,590
这两种算法 

4
00:00:11,740 --> 00:00:13,990
看看你能不能告诉我们, 好的.

5
00:00:14,110 --> 00:00:16,170
那么它真的明白发生了什么吗？

6
00:00:16,180 --> 00:00:17,800
它真的能理解吗？

7
00:00:17,980 --> 00:00:25,260
不太多, 但它确实能够生成在给定上下文中有意义的可能的单词序列

8
00:00:25,270 --> 00:00:29,980
所以筛子的空间复杂度是x 

9
00:00:30,640 --> 00:00:36,940
这样做的原因是我们实际上继续为每个数字创建一个完整的数组 

10
00:00:36,940 --> 00:00:37,360
对吧？

11
00:00:37,360 --> 00:00:40,090
这就是为什么X是这样的 

12
00:00:40,700 --> 00:00:40,830
是的 

13
00:00:40,990 --> 00:00:47,020
所以我们创建了一个布尔数组, 试除法的空间复杂度是1, 因为我们实际上没有存储,

14
00:00:47,020 --> 00:00:52,900
我们实际上没有创建任何辅助结构来帮助我们

15
00:00:52,900 --> 00:00:53,110
对吧？

16
00:00:53,110 --> 00:00:57,570
我们创建的唯一空间就是存储输出本身 

17
00:00:57,580 --> 00:01:01,500
所以这是一种我们在这里进行的权衡 

18
00:01:01,510 --> 00:01:09,250
筛子确实有一些空间, 但它运行得更快, 而试验除法没有额外的空间,

19
00:01:09,610 --> 00:01:20,380
尽管当我们得到更高, 更大的输出或输入时, 它的运行时间确实差得多

20
00:01:20,800 --> 00:01:25,630
所以是的, 这是非常有趣的, 它能够为我们提供所有这些,

21
00:01:25,630 --> 00:01:30,250
甚至可以告诉我们它们在空间和时间方面的表现

22
00:01:30,970 --> 00:01:40,600
所以如果我们去一个很受欢迎的网站, 叫做Leap Code, 我们可以试着看看我们是否能解决其中的一个问题

23
00:01:40,600 --> 00:01:44,170
所以我们把它带到 

24
00:01:45,000 --> 00:01:47,190
在这里, 我们可以看到 

25
00:01:47,190 --> 00:01:48,700
我来放大一下 

26
00:01:48,720 --> 00:01:50,610
所以这恰好是每天的问题 

27
00:01:50,610 --> 00:01:56,520
Lead Code是一个非常受欢迎的网站, 软件工程师们经常使用它来准备面试 

28
00:01:56,520 --> 00:02:03,450
基本上, 他们会问你这种不是真正的脑筋急转弯, 但有时他们是脑筋急转弯,

29
00:02:03,450 --> 00:02:08,910
但他们基本上只是问你, 基本上是要求你实现一个解决方案,

30
00:02:08,910 --> 00:02:12,180
在你的代码或你选择的语言

31
00:02:12,180 --> 00:02:12,740
对吧？

32
00:02:12,750 --> 00:02:16,230
所以这个问题叫做单元素 

33
00:02:16,230 --> 00:02:19,020
在一个有序数组中, 你得到了一个有序数组 

34
00:02:19,020 --> 00:02:22,710
所以基本上是一个元素序列, 它只由整数组成 

35
00:02:22,710 --> 00:02:29,310
所以整数和每个元素都只出现两次, 除了一个元素只出现一次

36
00:02:29,310 --> 00:02:34,110
我们想要返回一个只出现一次的元素, 我们的解决方案必须在o的log

37
00:02:34,110 --> 00:02:36,390
n时间和o的空间中运行

38
00:02:36,390 --> 00:02:42,480
所以这听起来像是一个二分搜索问题, 因为它是排序的 

39
00:02:42,480 --> 00:02:47,070
如果你对它很熟悉的话, 这就可以解释log n的运行时间 

40
00:02:47,070 --> 00:02:54,150
所以基本上, 它看起来像是检查它是否小于或正确的中途, 并有点探测

41
00:02:54,150 --> 00:02:54,630
好吧 

42
00:02:54,630 --> 00:03:03,510
所以如果我们继续, 让我们看看它是否能阅读, 你能解决这个问题吗？

43
00:03:04,140 --> 00:03:06,270
在以下链接中规定 

44
00:03:08,090 --> 00:03:09,820
这里有一个解决问题的办法 

45
00:03:09,830 --> 00:03:11,900
单个元素是从代码中排序的数组 

46
00:03:11,900 --> 00:03:17,780
所以现在它实际上进入了我发送的那个链接, 它正在读出问题和例子,

47
00:03:17,780 --> 00:03:21,590
希望它能给我们一个正确的解决方案

48
00:03:21,590 --> 00:03:26,900
这很酷的原因是因为代码实际上有一个更大的 

49
00:03:26,900 --> 00:03:34,490
因此, 我们将能够针对一组测试来测试我们的解决方案, 这些测试将验证其作为解决方案的鲁棒性,

50
00:03:34,490 --> 00:03:42,560
并查看它是否也满足此运行时需求, 即它必须及时运行O日志

51
00:03:42,560 --> 00:03:47,000
所以在计算机科学中, 你可以编写所有类型的代码来解决同一个问题 

52
00:03:47,000 --> 00:03:51,920
但正如我们之前看到的, 在生成一定数量的所有素数的情况下,

53
00:03:51,920 --> 00:03:57,860
通常情况下, 在时空权衡方面, 一种算法可能比另一种算法更好

54
00:03:58,730 --> 00:04:04,520
所以如果我们继续看这里, 再一次, 代码片段被不正确的语言注释了

55
00:04:04,850 --> 00:04:10,430
这不是一个SQL脚本的任何延伸, 甚至不是语法 

56
00:04:10,430 --> 00:04:14,510
但是如果我们继续复制代码, 我们可以把它带到这里 

57
00:04:15,440 --> 00:04:20,420
不过, 我需要注意的一点是, 它实际上删除了解决方案的类声明, 而这正是我们实际需要的

58
00:04:20,420 --> 00:04:22,790
它也去掉了一些我们确实需要的东西 

59
00:04:22,790 --> 00:04:29,510
所以如果我们继续快速地修补它, 然后运行它, 让我们看看它是否真的通过了测试用例,

60
00:04:29,810 --> 00:04:33,140
Python是否对缩进敏感

61
00:04:33,140 --> 00:04:35,330
所以我们继续缩进它 

62
00:04:36,440 --> 00:04:40,180
果然, 它接受了, 这是相当可怕的 

63
00:04:40,190 --> 00:04:48,020
现在, 我要警告的一件事是, 这里可能有一些解决方案, 它可以很容易地直接从

64
00:04:48,620 --> 00:04:51,080
然而, 这被锁定在付费墙后面 

65
00:04:51,080 --> 00:04:51,650
我相信 

66
00:04:51,650 --> 00:04:52,460
所以是的

67
00:04:52,460 --> 00:04:56,120
它肯定没有看那里, 所以我们可以看到, 这是接受 

68
00:04:56,120 --> 00:05:01,340
这只是两个非常小的测试用例, 所以让我们继续提交, 这将运行许多,

69
00:05:01,340 --> 00:05:03,380
许多更多的测试

70
00:05:03,380 --> 00:05:06,140
所以如果它真的通过了这个, 我们就知道它真的很好 

71
00:05:06,260 --> 00:05:07,730
这很酷对吧

72
00:05:07,730 --> 00:05:08,810
它真的有用 

73
00:05:09,170 --> 00:05:12,440
所以是的, 它甚至给了我们一个解释这里发生了什么 

74
00:05:13,190 --> 00:05:16,220
它给出了时间复杂度, 也给出了空间复杂度 

75
00:05:16,220 --> 00:05:21,590
我几乎有点怀疑它这样做的原因是不是因为我在前面的问题中问到了这个问题,

76
00:05:21,590 --> 00:05:22,970
这真的很酷

77
00:05:23,690 --> 00:05:25,850
所以, 是的, 我们可以看到, 这实际上只是工作 

78
00:05:25,850 --> 00:05:28,430
但是如果我们想让它在Java中呢？

79
00:05:29,120 --> 00:05:32,480
你能给我Java代码吗？

80
00:05:33,960 --> 00:05:34,660
相反 

81
00:05:34,740 --> 00:05:34,970
好吧 

82
00:05:34,980 --> 00:05:41,010
所以这是一件非常酷的事情, 对于聊天应用程序来说 

83
00:05:41,010 --> 00:05:47,490
GPT是你可以用一种语言写代码, 也许你想用另一种语言写, 因为可移植性的原因,

84
00:05:47,490 --> 00:05:50,880
或者你想要的任何原因

85
00:05:50,880 --> 00:05:58,470
如果你让Shakib用不同的语言为那个问题规格生成相同的代码, 它可能能做到

86
00:05:58,470 --> 00:06:00,390
让我们来验证一下它是否正确 

87
00:06:00,390 --> 00:06:06,810
再一次, 它错误地注释了类型或者代码块, 但是只要你熟悉编码语言,

88
00:06:06,810 --> 00:06:10,590
事实上, 让我们来做个实验

89
00:06:10,590 --> 00:06:15,540
我的意思是, 它引用了Java代码, 但如果你真的不知道, 你可以尝试复制这些代码,

90
00:06:15,540 --> 00:06:19,440
然后问它这是用什么语言写的？

91
00:06:19,440 --> 00:06:22,590
它可能应该说Java, 因为我的意思是, 这就是它看起来的样子, 对吧？

92
00:06:22,590 --> 00:06:31,050
但事不宜迟, 让我们直接将其复制到Java中, Java代码笔在这里, 让我们提交它,

93
00:06:31,110 --> 00:06:33,300
看看它是否有效

94
00:06:33,300 --> 00:06:37,320
果然, 这又是一个正确的解决方案 

95
00:06:37,320 --> 00:06:38,490
所以这很酷, 对吧？

96
00:06:38,640 --> 00:06:43,380
您可以在这里或多或少使用相同的算法在两种语言之间进行翻译 

97
00:06:43,380 --> 00:06:51,990
但是, 是的, 这真的显示了聊天和算法的力量, 期待在下一个关于调试的视频中见到你