1
00:00:00,120 --> 00:00:04,680
在这个视频中, 我们将探索如何使用聊天, GPT和算法 

2
00:00:05,310 --> 00:00:09,840
让我们从一个简单的素数例子开始 

3
00:00:09,840 --> 00:00:17,340
所以GPT你能给我写一个Python脚本斜杠算法吗？

4
00:00:17,990 --> 00:00:24,620
生成直到给定数x为止的所有素数 

5
00:00:24,890 --> 00:00:32,780
所以希望它能为Python中的一个函数创建某种定义, 该函数接受X作为参数 

6
00:00:33,110 --> 00:00:34,700
果然, 这就是它的作用 

7
00:00:34,700 --> 00:00:37,100
它将此标记为Python脚本 

8
00:00:38,240 --> 00:00:43,550
这是一个叫做生成素数的函数, 它接受一个X作为参数, 看看这个.

9
00:00:43,550 --> 00:00:46,220
它甚至记录了它正在编写的代码 

10
00:00:46,700 --> 00:00:51,590
所以这是一个使用Eratosthenes筛子的算法 

11
00:00:51,590 --> 00:00:55,670
我不知道我说的对不对, Eratosthenes用算法生成了所有的素数直到给定的数X,

12
00:00:55,670 --> 00:01:02,570
所以我们可以通过运行它来测试它的正确性.

13
00:01:03,770 --> 00:01:08,300
也许我们不能够完全地进行事实检查, 因为正如一位著名的计算机科学家曾经说过的那样,

14
00:01:08,300 --> 00:01:20,960
像测试用例或检查某些输入和某些输出只能显示错误的存在, 但不能证明错误的不存在或不存在

15
00:01:21,080 --> 00:01:27,740
所以我不知道这是否完全稳健, 但我们可以尝试用一些数字来检查它, 看看它是否有效

16
00:01:27,740 --> 00:01:28,160
好吧 

17
00:01:28,160 --> 00:01:29,800
这就是Python代码 

18
00:01:29,810 --> 00:01:31,370
让我们来看看VS代码 

19
00:01:31,370 --> 00:01:37,910
在我的终端里, 我的系统里安装了Python 

20
00:01:37,910 --> 00:01:41,150
让我们运行python 

21
00:01:41,720 --> 00:01:44,840
我现在在Python终端里 

22
00:01:45,380 --> 00:01:47,000
让我放大一点 

23
00:01:47,270 --> 00:01:53,750
所以这是一个Python终端, 只要在命令行上运行Python, 因为我已经安装了它,

24
00:01:53,750 --> 00:01:58,250
我可以继续输入这些代码

25
00:01:58,730 --> 00:02:00,680
如果你输入这个 

26
00:02:02,110 --> 00:02:02,980
把这个贴进去 

27
00:02:04,420 --> 00:02:07,240
实际上我们会看到一个意外的缩进 

28
00:02:07,240 --> 00:02:11,930
所以让我们实际上继续并为此创建一个文件, 只是为了使事情更容易 

29
00:02:11,950 --> 00:02:15,100
我们把它叫做质数点π 

30
00:02:16,030 --> 00:02:19,690
如果我复制这段代码, 这就是函数声明 

31
00:02:19,690 --> 00:02:25,620
就像他们在这里说的, 这里有一个函数的示例用法, 可以生成直到20的所有素数

32
00:02:25,630 --> 00:02:31,270
所以它肯定会包含一个函数调用来生成素数20, 然后打印输出

33
00:02:31,510 --> 00:02:35,110
果然, 这很有道理, 对吧？

34
00:02:35,110 --> 00:02:37,120
这些是到20为止的质数 

35
00:02:37,990 --> 00:02:44,170
所以如果你真的继续运行它, 如果我退出我的终端, 然后用π·素数运行这个文件,

36
00:02:44,170 --> 00:02:47,550
我们可以看到这实际上是输出, 对吗？

37
00:02:48,160 --> 00:02:49,390
我们可以尝试更大的数字 

38
00:02:49,390 --> 00:02:54,520
让我们疯狂地投入一百万, 希望这不会花太长时间 

39
00:02:54,520 --> 00:02:57,310
但是, 是的, 这是一个很大的输出在那里 

40
00:02:57,310 --> 00:03:03,980
我想我的电脑在这方面是相当快的, 所以是的, 这是很多 

41
00:03:04,030 --> 00:03:05,080
好多数字啊 

42
00:03:05,080 --> 00:03:10,300
我不知道, 如果这些是质数, 我想这个算法是正确的,

43
00:03:10,300 --> 00:03:16,690
经过测试的, 这是一件好事, 如果你要求它提供一个完善的算法,

44
00:03:16,690 --> 00:03:23,500
这将是一个非常好的记录和证明, 这将是已经存在的代码

45
00:03:23,500 --> 00:03:31,090
所以这是它可能不会出错的东西, 因为有一个很好的可靠的解释来解释这个东西是如何工作的,

46
00:03:31,090 --> 00:03:35,710
实际上还有其他算法用于生成素数

47
00:03:35,710 --> 00:03:40,060
所以有趣的是, Chalkbeat碰巧给了你一个非常知名和高效的 

48
00:03:40,060 --> 00:03:41,890
你能用算法吗？

49
00:03:43,100 --> 00:03:48,380
除了埃拉托斯特尼的种子, 如果我拼写正确的话 

50
00:03:48,410 --> 00:03:49,310
希望我做到了 

51
00:03:49,490 --> 00:03:55,490
当然, 这里有一个尝试除法算法的实现, 可以在Python中生成直到给定数字X为止的所有素数

52
00:03:55,490 --> 00:03:59,540
所以这将是一个完全不同的函数定义, 但它可能会给我们相同的输出,

53
00:03:59,540 --> 00:04:03,350
在生成所有素数方面, 直到一个给定的数字

54
00:04:03,350 --> 00:04:06,110
但是, 是的, 让我们让我们继续下去, 并给一个尝试 

55
00:04:06,110 --> 00:04:07,400
好吧, 既然我们在这里 

56
00:04:07,550 --> 00:04:12,050
所以在这里我们已经得到了C的定义, 角鲨烯的定义 

57
00:04:13,760 --> 00:04:18,230
让我们给这个函数加上前缀, 调用一个筛子, 这样我们就不会调用它了 

58
00:04:18,860 --> 00:04:22,340
这里我们要调用新的生成素函数 

59
00:04:22,340 --> 00:04:24,830
如果我们称之为20, 它应该给我们同样的输出 

60
00:04:24,830 --> 00:04:27,350
二三五七十一十三十七十九

61
00:04:27,350 --> 00:04:29,390
所以如果我继续运行它, 就足够了 

62
00:04:29,390 --> 00:04:31,610
是的, 这正是它给我们的 

63
00:04:32,000 --> 00:04:38,300
如果你不熟悉计算机科学, 也不熟悉写代码的研究,

64
00:04:38,300 --> 00:04:46,910
那么关于算法的一个有趣的事情是, 首先, 这些算法是可以被测量的

65
00:04:47,060 --> 00:04:50,540
所以这两件事是空间和时间复杂度 

66
00:04:50,540 --> 00:04:55,610
我们来问一下, 这其实是一个脚注, 注意试除算法在生成素数时,

67
00:04:55,610 --> 00:05:00,350
效率不如C, 特别是对于大的X值

68
00:05:00,350 --> 00:05:02,300
让我们来试试看

69
00:05:02,300 --> 00:05:08,480
因为之前我们在这个函数的C版本上运行了一百万次 

70
00:05:08,570 --> 00:05:11,990
让我们试着用generate primes来运行它 

71
00:05:12,230 --> 00:05:16,250
你可以看到这花了更长的时间才出来, 对吧？

72
00:05:16,250 --> 00:05:19,360
所以它肯定给了我们同样的答案 

73
00:05:19,370 --> 00:05:23,410
然而, 你可以看到我的电脑确实停了一两秒钟 

74
00:05:23,420 --> 00:05:31,250
所以让我们来问GPT为什么会这样, 你可能会问为什么会慢一点

75
00:05:31,250 --> 00:05:39,230
这可能是个幼稚的问题, 但如果你熟悉算法背后的理论, 你可以问它空间是什么？

76
00:05:39,230 --> 00:05:42,770
这两种算法的时间复杂度是多少？

77
00:05:44,490 --> 00:05:48,780
让我们看看你能不能告诉我们, Eratosthenes的Steve算法的时间复杂度,

78
00:05:48,780 --> 00:05:51,030
来生成所有的素数, 直到一个给定的数

79
00:05:51,240 --> 00:05:58,080
X是X的大O乘以X的对数的对数定律和最坏的情况 

80
00:05:58,080 --> 00:06:03,780
所以如果你不明白这意味着什么, 大O符号是一种描述算法运行时复杂度的方法,

81
00:06:03,780 --> 00:06:09,120
这里有很多需要理解的地方

82
00:06:09,120 --> 00:06:17,040
但是我们在这里看到, 试除法算法的复杂度是O的X的1次方  最坏的情况下是5, 这是相当糟糕的,

83
00:06:17,040 --> 00:06:18,960
对吧？

84
00:06:18,960 --> 00:06:21,750
所以如果你考虑这两个图 

85
00:06:21,750 --> 00:06:30,540
所以如果你看一个图, 函数是输入大小和算法完成所需时间的函数,

86
00:06:30,540 --> 00:06:36,330
那么这个图的增长速度会比这个图慢得多,

87
00:06:36,330 --> 00:06:37,770
对吧？

88
00:06:37,770 --> 00:06:39,120
所以这个会爆炸 

89
00:06:39,120 --> 00:06:44,670
所以当你的X增加时, 算法完成所需的时间会急剧增加, 因为它就像指数一样,

90
00:06:44,670 --> 00:06:46,770
对吧？

91
00:06:46,770 --> 00:06:48,270
它是某种力量的象征 

92
00:06:48,600 --> 00:06:53,280
所以, 是的, 我们可以看到为什么这是一样的, 为什么一个比另一个花更长的时间？

93
00:06:53,280 --> 00:06:58,410
如果你想了解更多, 我们可以继续聊天, 继续提问

94
00:06:58,410 --> 00:06:58,820
对吧？

95
00:06:58,830 --> 00:07:04,800
如果你对学习充满好奇, 并且知道该问什么, 这些东西就会非常有效