1
00:00:00,000 --> 00:00:02,830
>> COLUNA 1: Vamos escrever um programa que
solicita ao usuário um resultado positivo

2
00:00:02,830 --> 00:00:05,950
inteiro, n, e, em seguida, imprime
a soma de todos os números

3
00:00:05,950 --> 00:00:07,980
entre 1 e n.

4
00:00:07,980 --> 00:00:10,580
Bem, aqui temos principal, que eu tenho
já escrita antecipadamente.

5
00:00:10,580 --> 00:00:13,520
E observe aqui no topo da
principal, eu declaro um int n.

6
00:00:13,520 --> 00:00:16,079
>> Eu, então, dentro de um While
loop, primeiro imprima

7
00:00:16,079 --> 00:00:17,530
inteiro positivo, por favor.

8
00:00:17,530 --> 00:00:21,070
Então eu proceder para obter um número inteiro de
ao usuário obter a biblioteca CS50

9
00:00:21,070 --> 00:00:22,070
int função.

10
00:00:22,070 --> 00:00:26,410
E então, em minha condição enquanto aqui, eu
certificar-se de que n é maior do que ou

11
00:00:26,410 --> 00:00:30,480
igual a 1 antes de eu realmente proceder
para fazer algo com esse valor.

12
00:00:30,480 --> 00:00:31,520
>> O que eu faço agora?

13
00:00:31,520 --> 00:00:34,690
Bem, eu chamo uma função que eu vou
chamar sigma, representante do

14
00:00:34,690 --> 00:00:37,700
sigma capital que você pode ter
lembrou das aulas de matemática que

15
00:00:37,700 --> 00:00:40,860
indica que você deseja somar algo
a partir de um valor para outro.

16
00:00:40,860 --> 00:00:44,540
E o que quer que função retorna como
seu valor de retorno, eu estou indo para armazenar

17
00:00:44,540 --> 00:00:46,500
em uma variável chamada resposta.

18
00:00:46,500 --> 00:00:50,280
>> Finalmente, em minha última linha principal, eu sou
vai imprimir o que resposta é.

19
00:00:50,280 --> 00:00:52,840
Claro, nós ainda não implementado
esta sigma função.

20
00:00:52,840 --> 00:00:54,590
Então, como é que vamos fazer isso?

21
00:00:54,590 --> 00:00:58,040
>> Bem, no fundo do meu arquivo, eu sou
vai proceder para declarar uma função

22
00:00:58,040 --> 00:00:59,450
que retorna um int.

23
00:00:59,450 --> 00:01:01,630
E eu vou chamar
que a função sigma.

24
00:01:01,630 --> 00:01:06,340
E eu estou indo para especificar que como entrada
essa função também aceita um int.

25
00:01:06,340 --> 00:01:09,800
E eu vou chamá-lo apenas, para ser
distinta, m em vez de n.

26
00:01:09,800 --> 00:01:12,120
Mas poderíamos ter chamado a
mais alguma coisa que gostaria.

27
00:01:12,120 --> 00:01:14,930
>> Dentro do corpo desta função eu sou
vai continuar a utilizar um familiar

28
00:01:14,930 --> 00:01:16,420
construção, a saber, um circuito.

29
00:01:16,420 --> 00:01:19,010
Mas eu também vou fazer um pouco de sanidade
verificação para certificar-se de que o

30
00:01:19,010 --> 00:01:22,340
usuário não fornecer-me com um número
que eu não estou esperando.

31
00:01:22,340 --> 00:01:28,010
Em particular, eu vou fazer, se m é
menos do que 1 e, tanto arbitrariamente,

32
00:01:28,010 --> 00:01:31,280
Estou simplesmente vai retornar 0 se
o número não é um positivo

33
00:01:31,280 --> 00:01:32,800
inteiro como eu esperava.

34
00:01:32,800 --> 00:01:36,920
>> Então eu vou para declarar uma variável
chamado soma e inicialize-o a 0.

35
00:01:36,920 --> 00:01:40,810
Isto irá, em última instância armazenar a soma de
todos os números entre 1 e m.

36
00:01:40,810 --> 00:01:43,550
E então eu vou usar um familiar
construção de loop para a frente.

37
00:01:43,550 --> 00:01:50,272
Para int i obtém 1, i é inferior a
ou igual a m, i, mais além.

38
00:01:50,272 --> 00:01:54,010
E então, dentro do corpo da presente
loop, eu estou indo simplesmente para fazer soma

39
00:01:54,010 --> 00:01:56,350
é igual a soma mais eu.

40
00:01:56,350 --> 00:02:01,900
Ou, mais simplesmente, soma mais é igual a i,
que atinge o mesmo resultado.

41
00:02:01,900 --> 00:02:04,810
>> E então, finalmente, eu preciso voltar
a soma que eu computados.

42
00:02:04,810 --> 00:02:07,640
Então eu adicionar em suma retorno.

43
00:02:07,640 --> 00:02:08,560
>> Agora eu não estou pronto ainda.

44
00:02:08,560 --> 00:02:11,360
Eu preciso ensinar C que este
função realmente existe.

45
00:02:11,360 --> 00:02:14,400
E assim, em cima de meu arquivo eu vou declarar
o que temos chamado de função

46
00:02:14,400 --> 00:02:18,270
protótipo, idêntica à assinatura
que eu usei na definição da função

47
00:02:18,270 --> 00:02:19,250
um momento atrás.

48
00:02:19,250 --> 00:02:22,450
>> Especificamente, logo acima principal,
Eu estou indo para o tipo int

49
00:02:22,450 --> 00:02:26,080
sigma, int m, ponto e vírgula.

50
00:02:26,080 --> 00:02:29,240
Não implementar a função
novamente, basta declará-lo.

51
00:02:29,240 --> 00:02:32,800
Se agora eu salvar, compilar e executar este
programa, vamos ver o que eu recebo.

52
00:02:32,800 --> 00:02:37,460
Faça sigma 0 dot cortar sigma 0.

53
00:02:37,460 --> 00:02:41,050
E agora vamos fornecer um número inteiro positivo
como 2, que deve dar-me

54
00:02:41,050 --> 00:02:45,920
três, porque os valores entre
1 e 2 são mais 2 1 é igual a 3.

55
00:02:45,920 --> 00:02:47,300
E, de fato, isso é o que eu recebo.

56
00:02:47,300 --> 00:02:49,940
>> Vamos executá-lo novamente, desta
tempo com, digamos, 3.

57
00:02:49,940 --> 00:02:53,470
Então eu deveria ter 1 mais 2 mais
3 deveria me dar 6.

58
00:02:53,470 --> 00:02:54,740
E, de fato, eu entendo 6.

59
00:02:54,740 --> 00:02:57,380
>> E vamos tentar um último valor, digamos, 50 anos.

60
00:02:57,380 --> 00:03:01,160
E 1275 é a nossa resposta.

61
00:03:01,160 --> 00:03:02,253