exercícios da aula 5

README.org

@@ -24,3 +24,4 @@ qualquer distribuição.
 - 14.03.2025 [[./aulas/02-dados-e-instrucoes/README.org][Aula 2: Dados e instruções]] ([[https://youtu.be/2KsvRJjshQ0][vídeo]]) ([[./exercicios/02/README.org][exercícios]])
 - 17.03.2025 [[./aulas/03-tipos-de-dados/README.org][Aula 3: Tipos de dados]] ([[https://youtu.be/iMiRzZCU7hE][vídeo]]) ([[./exercicios/03/README.org][exercícios]])
 - 19.03.2025 [[./aulas/04-variaveis/README.org][Aula 4: Variaveis e ponteiros]] ([[https://youtu.be/i7RKtMgSSrM][vídeo]]) ([[./exercicios/04/README.org][exercícios]])
+- 21.03.2025 [[./aulas/05-controle/README.org][Aula 5: Estruturas de controle de fluxo]] ([[https://youtu.be/9dvDL7FbYKY][vídeo]]) ([[./exercicios/05/README.org][exercícios]])

aulas/05-controle/README.org

@@ -0,0 +1,559 @@
+#+title: Curso Básico da Linguagem C
+#+subtitle: Aula 5: Estruturas de controle de fluxo
+#+author: Blau Araujo
+#+startup: show2levels
+#+options: toc:3
+
+* Estruturas de controle de fluxo
+
+[[https://www.youtube.com/watch?v=9dvDL7FbYKY][Vídeo desta aula]]
+
+Construtos da linguagem que alteram a ordem normal da execução do programa que,
+em princípio, seria linha a linha de cima para baixo.
+
+#+begin_quote
+*Construtos*: são os elementos fundamentais da sintaxe e da semântica de uma
+linguagem.
+#+end_quote
+
+** Controle de fluxo
+
+A alteração do fluxo normal de execução pode ser produzida por estruturas e 
+alguns construtos da linguagem C.
+
+*Estruturas de repetição*
+
+- Loop =for=
+- Loop =while=
+- Loop =do..while=
+
+*Estruturas de decisão*
+
+- Estrutura =if..else if..else=
+- Estrutura =switch..case=
+
+*Construtos de desvio incondicional*
+
+- =return=: Finaliza a execução de uma função e retorna um valor.
+- =break=: Interrompe a execução de um =switch= ou de um /loop/.
+- =continue=: Salta para a próxima iteração de um /loop/.
+- =goto <rótulo>=: Salta para um rótulo definido como =rótulo:=.
+
+#+begin_quote
+O =goto= torna o código confuso e difícil de entender e manter, levando a um
+estilo conhecido como /"código espaguete"/, o que deve ser evitado a todo custo,
+pois isso vai contra os conceitos que definem um código como /estruturado/!
+#+end_quote
+
+** O loop 'for'
+
+O /loop/ =for= uma estrutura de repetição com sintaxe compacta que combina a
+inicialização de uma variável, a condição de continuidade das repetições
+e a atualização do valor associado à variável em uma /expressão tripla/,
+possibilitando a repetição controlada de um bloco de código um número
+definido de vezes.
+
+Com o /loop/ =for=, as repetições são controladas pela /iterações/ com o valor
+associado a uma variável.
+
+#+begin_quote
+*Iterar*: da álgebra, o termo significa valer-se do resultado de uma equação,
+obtido através de cálculos sucessivos.
+#+end_quote
+
+*** Sintaxe
+
+#+begin_example
+for (INICIALIZAÇÃO; CONDIÇÂO; ALTERAÇÃO) {
+    BLOCO DE INSTRUÇÕES...
+}
+#+end_example
+
+Quando houver apenas uma instrução...
+
+#+begin_example
+for (INICIALIZAÇÂO; CONDIÇÃO; ALTERAÇÃO) INSTRUÇÃO;
+
+for (INICIALIZAÇÂO; CONDIÇÃO; ALTERAÇÃO)
+    INSTRUÇÃO;
+#+end_example
+
+Loop =for= infinito...
+
+#+begin_example
+for (;;) {
+    BLOCO DE INSTRUÇÕES...
+}
+#+end_example
+
+#+begin_quote
+Um loop infinito pressupõe a definição de uma condição de parada
+no =BLOCO DE INSTRUÇÕES= e o uso de um construto de desvio incondicional,
+geralmente, o =break=.
+#+end_quote
+
+*** Exemplo do vídeo
+
+#+begin_src c
+#include <stdio.h>
+
+int main(void) {
+
+    for (int i = 0; i < 10; i++) {
+        printf("%d - %d\n", i, i * 10);
+    }
+    
+    return 0;
+}
+#+end_src
+
+*Notas*
+
+- A declaração de uma variável =i=, na primeira expressão, faz com que ela
+  seja visível apenas no bloco de instruções.
+- Ao término das repetições, a variável deixa de existir.
+- A variável =i= também poderia ser declarada fora da estrutura =for=.
+- O operação de pós incremento =<var>++=, na terceira expressão, avalia =var=
+  e soma 1 ao seu valor.
+- A variável =i= poderia ser manipulada de qualquer outra forma na terceira
+  expressão. 
+
+*Compilando e executando...*
+
+#+begin_example
+:~$ gcc exemplo.c
+:~$ ./a.out
+0 - 0
+1 - 10
+2 - 20
+3 - 30
+4 - 40
+5 - 50
+6 - 60
+7 - 70
+8 - 80
+9 - 90
+#+end_example
+
+** Loop 'while'
+
+O /loop/ =while= repete a execução de um bloco de instruções /enquanto/ a sua
+expressão de controle continuar avaliando como verdadeira ou qualquer
+valor diferente de =0=. Como a continuidade dos ciclos é condicionada
+à verdade da expressão de controle, o /loop/ =while= pode ser classificado
+como um /loop condicional/.
+
+*** Sintaxe
+
+#+begin_example
+while (CONDIÇÃO) {
+    BLOCO DE INSTRUÇÕES...
+}
+#+end_example
+
+Quando houver apenas uma instrução...
+
+#+begin_example
+while (CONDIÇÃO) INSTRUÇÃO;
+
+while (CONDIÇÃO)
+    INSTRUÇÃO;
+#+end_example
+
+/Loop/ =while= infinito...
+
+#+begin_example
+while (1) {
+    BLOCO DE INSTRUÇÕES...
+}
+#+end_example
+
+*IMPORTANTE!*
+
+Todas as estruturas de repetição podem ser usadas sem a definição de um
+bloco de instruções ou apenas uma instrução, mas isso só faz sentido em
+loops onde é possível avaliar condições através de uma expressão, como
+é o caso dos /loops/ =while= e =do..while=.
+
+Por exemplo, este /loop/ é muito utilizado para limpar o conteúdo do buffer
+de entrada após a digitação de uma entrada do usuário:
+
+#+begin_src c
+int c;
+while ((c = getchar()) != '\n' && c != EOF);
+#+end_src
+
+Aqui, o objetivo é apenas ler os bytes restante no buffer de entrada,
+o que pode ser feito na própria expressão de controle do =while=.
+
+*** Exemplo do vídeo
+
+#+begin_src c
+#include <stdio.h>
+
+int main(void) {
+    
+    int i = 0;
+    while (i < 10) {
+        printf("%d", i);
+        i += 2;
+    }
+      
+    return 0;
+}
+#+end_src
+
+*Nota*
+
+Este exemplo reproduz com o /loop/ =while= o mesmo comportamento de um
+/loop/ =for=, mas sem tornar a variável =i= local ao bloco de instruções:
+
+- =int i = 0;= - Inicialização da variável que será iterada.
+- =i < 10= - Condição de continuidade.
+- ~i += 2;~ - Alteração da variável =i=.
+
+*Compilando e executando...*
+
+#+begin_example
+:~$ gcc exemplo.c
+:~$ ./a.out
+0
+2
+4
+6
+8
+#+end_example
+
+** Loop 'do..while'
+
+Enquanto o /loop/ =while= avalia sua expressão de controle antes de executar
+o bloco de instruções, o /loop/ =do..while= tem que executar o bloco de instruções
+pelo menos uma vez antes de avaliar a expressão de controle: fora isso,
+os funcionamentos são idênticos.
+
+*** Sintaxe
+
+#+begin_example
+do {
+    BLOCO DE INSTRUÇÕES...
+} while (CONDIÇÃO);
+#+end_example
+
+Quando houver apenas uma instrução...
+
+#+begin_example
+do INSTRUÇÃO;
+while (CONDIÇÃO);
+
+do
+    INSTRUÇÃO;
+while (CONDIÇÃO);
+#+end_example
+
+/Loop/ =do..while= infinito...
+
+#+begin_example
+do {
+    BLOCO DE INSTRUÇÕES...
+} while (1);
+#+end_example
+
+*** Exemplo do vídeo
+
+#+begin_src c
+#include <stdio.h>
+
+int main(void) {
+    
+    int i = 10;
+    do
+        printf("%d", i);
+        i--;
+    while (i > 0);
+      
+    return 0;
+}
+#+end_src
+
+*Notas*
+
+- Ainda estamos reproduzindo o comportamento do =for=.
+- A operação de pós decremento =<var>--= avalia =var= antes de subtrair 1
+  de seu valor.
+
+*Compilando e executando...*
+
+#+begin_example
+:~$ gcc exemplo.c
+:~$ ./a.out
+10
+9
+8
+7
+6
+5
+4
+3
+2
+1
+#+end_example
+
+** Estrutura de decisão 'if..else if..else'
+
+A estrutura =if..else if..else= (ou simplesmente =if=) possibilita a execução
+de um bloco de instruções caso a avaliação de um expressão resulte em
+verdadeira ou em um valor diferente de =0=.
+
+*** Sintaxe
+
+#+begin_example
+if (CONDIÇÃO_1) {
+    BLOCO EXECUTADO SE CONDIÇÃO_1 FOR VERDADEIRA...
+} else if (CONDIÇÃO_2) {
+    BLOCO EXECUTADO SE CONDIÇÃO_2 FOR VERDADEIRA...
+} else if (CONDIÇÃO_N) {
+    BLOCO EXECUTADO SE CONDIÇÃO_N FOR VERDADEIRA...
+} else {
+    BLOCO EXECUTADO SE NENHUMA DAS CONDIÇÔES FOR VERDADEIRA...
+}
+#+end_example
+
+Quando houver apenas uma instrução nos blocos de instruções...
+
+#+begin_example
+if (CONDIÇÃO_1)
+    INSTRUÇÃO SE CONDIÇÃO_1 FOR VERDADEIRA...
+else if (CONDIÇÃO_2)
+    INSTRUÇÃO SE CONDIÇÃO_2 FOR VERDADEIRA...
+else if (CONDIÇÃO_N)
+    INSTRUÇÃO SE CONDIÇÃO_N FOR VERDADEIRA...
+else
+    INSTRUÇÃO SE NENHUMA DAS CONDIÇÔES FOR VERDADEIRA...
+#+end_example
+
+*Notas*
+
+- Apenas o bloco =if= é obrigatório.
+- É possível escrever quantos blocos =else if= forem necessários.
+- Só podemos escrever um bloco =else=, se necessário.
+- A estrutura =if= termina assim que um dos seus blocos é executado. 
+- Eu prefiro me referir aos blocos de instruções como /consequências/.
+
+*** Exemplo do vídeo
+
+#+begin_src c
+#include <stdio.h>
+
+int main(void) {
+
+    for (int i = 0; i <= 20; i++) {
+        if (i % 2 == 0) {
+            printf("%d é par\n", i);
+        } else if (i % 15 == 0) {
+            printf("%d é ímpar e divisível por 3 e 5\n", i);
+        } else {
+            printf("%d é ímpar\n", i);
+        }
+    }
+    return 0;
+}
+#+end_src
+
+*Compilando e executando...*
+
+#+begin_example
+:~$ gcc exemplo.c
+:~$ ./a.out
+0 é par
+1 é ímpar
+2 é par
+3 é ímpar
+4 é par
+5 é ímpar
+6 é par
+7 é ímpar
+8 é par
+9 é ímpar
+10 é par
+11 é ímpar
+12 é par
+13 é ímpar
+14 é par
+15 é ímpar e divisível por 3 e 5
+16 é par
+17 é ímpar
+18 é par
+19 é ímpar
+20 é par
+#+end_example
+
+*** Dica: 'else if' abreviado
+
+A escrita do bloco =else if= pode ser um pouco verbosa demais para quem
+escreve muitos scripts em Bash, que usa =elif=. Não existe uma abreviação
+nativa em C, mas nós podemos implementá-la com uma macro:
+
+#+begin_src c
+#define elif else if
+#+end_src
+
+Por exemplo:
+
+#+begin_src c
+#include <stdio.h>
+
+#define elif else if
+
+int main(void) {
+
+    for (int i = 1; i <= 15; i++) {
+        if (!(i % 15)) {
+            puts("FizzBuzz");
+        } elif (!(i % 3)) {
+            puts("Fizz");
+        } elif (!(i % 5)) {
+            puts("Buzz");
+        } else {
+            printf("%d\n", i);
+        }
+    }
+}
+#+end_src
+
+*Compilando e executando...*
+
+#+begin_example
+:~$ gcc -Wall fizzbuzz.c
+:~$ ./a.out
+1
+2
+Fizz
+4
+Buzz
+Fizz
+7
+8
+Fizz
+Buzz
+11
+Fizz
+13
+14
+FizzBuzz
+#+end_example
+
+** Estrutura 'switch..case'
+
+A estrutura =switch..case= possibilita selecionar a execução de um ou mais
+blocos de instruções diferentes com base na correspondência entre o valor de
+uma expressão e os valores especificados nas cláusulas =case=.
+
+#+begin_quote
+*Cláusulas*: seções de uma estrutura sintática que definem condições ou
+comportamentos específicos dentro da totalidade do comando de que
+fazem parte.
+#+end_quote
+
+*** Sintaxe
+
+#+begin_example
+switch (CONTROLE) {
+    case CONST_1:
+        BLOCO DE INSTRUÇÕES...
+        [break;]
+    case CONST_2:
+        BLOCO DE INSTRUÇÕES...
+        [break;]
+    case CONST_N:
+        BLOCO DE INSTRUÇÕES...
+        [break;]
+    default:
+        BLOCO DE INSTRUÇÕES...
+}
+#+end_example
+
+*Notas*
+
+- A expressão =CONTROLE= deve avaliar um tipo compatível com =int=.
+- Os valores nas cláusulas =case= devem ser /expressões constantes/ ou
+  expressões ou valores que possam ser resolvidos em tempo de
+  compilação.
+- Sejam quais forem os valores nas cláusulas =case=, eles devem ser
+  do mesmo tipo da expressão =CONTROLE=.
+
+*** Exemplo do vídeo
+
+#+begin_src c
+#include <stdio.h>
+
+
+int main(void) {
+
+    int flag;
+    
+    for (int i = 1; i <= 20; i++) {
+        flag = 0;
+        flag += (i % 2) ? 0 : 1;
+        flag += (i % 3) ? 0 : 2;
+
+        switch (flag) {
+            case 1:
+                printf("%d é divisível por 2\n", i);
+                break;
+            case 2:
+                printf("%d é divisível por 3\n", i);
+                break;
+            case 3:
+                printf("%d é divisível por 2 e 3\n", i);
+                break;
+            default:
+                printf("%d\n", i);
+        }
+    }
+    
+    return 0;
+}
+#+end_src
+
+*Compilando e executando...*
+
+#+begin_example
+:~$ gcc exemplo.c
+:~$ ./a.out
+1
+2 é divisível por 2
+3 é divisível por 3
+4 é divisível por 2
+5
+6 é divisível por 2 e 3
+7
+8 é divisível por 2
+9 é divisível por 3
+10 é divisível por 2
+11
+12 é divisível por 2 e 3
+13
+14 é divisível por 2
+15 é divisível por 3
+16 é divisível por 2
+17
+18 é divisível por 2 e 3
+19
+20 é divisível por 2
+#+end_example
+
+*** Bônus: expressão condicional (ternária)
+
+A linguagem C implementa a avaliação condicional de expressões na forma
+de uma /expressão ternária/ (uma expressão com 3 termos):
+
+#+begin_example
+CONDIÇÃO ? EXPRESSÃO_SE_VERDADEIRO : EXPRESSÃO_SE_FALSO
+#+end_example
+
+Aqui, se a expressão =CONDIÇÃO= avaliar verdadeiro ou um valor diferente de
+=0=, o valor de toda a expressão ternária será o valor avaliado no seu segundo
+termo (depois de =?=); se avaliar falso ou igual a =0=, a expressão ternária
+terá o valor avaliado no seu terceiro termo (depois de =:=).
+
+

exercicios/05/README.org

@@ -0,0 +1,91 @@
+#+title: Curso Básico da Linguagem C
+#+subtitle: Exercícios
+#+author: Blau Araujo
+#+startup: show2levels
+#+options: toc:3
+
+* Exercícios da aula 4: Variáveis e ponteiros
+
+- [[../aulas/05-controle/README.org][Anotações da aula]]
+- [[https://youtu.be/9dvDL7FbYKY][Vídeo]]
+
+
+** 1. Desafio: caracteres alfanuméricos ASCII
+
+Crie um programa que produza a seguinte saída:
+
+#+begin_example
+======================================================
+DEC OCT HEXA CHR | DEC OCT HEXA CHR | DEC OCT HEXA CHR
+-----------------+------------------+-----------------
+ 48  60 0x30  0  |  65 101 0x41  A  |  97 141 0x61  a
+ 49  61 0x31  1  |  66 102 0x42  B  |  98 142 0x62  b
+ 50  62 0x32  2  |  67 103 0x43  C  |  99 143 0x63  c
+ 51  63 0x33  3  |  68 104 0x44  D  | 100 144 0x64  d
+ 52  64 0x34  4  |  69 105 0x45  E  | 101 145 0x65  e
+ 53  65 0x35  5  |  70 106 0x46  F  | 102 146 0x66  f
+ 54  66 0x36  6  |  71 107 0x47  G  | 103 147 0x67  g
+ 55  67 0x37  7  |  72 110 0x48  H  | 104 150 0x68  h
+ 56  70 0x38  8  |  73 111 0x49  I  | 105 151 0x69  i
+ 57  71 0x39  9  |  74 112 0x4a  J  | 106 152 0x6a  j
+                 |  75 113 0x4b  K  | 107 153 0x6b  k
+                 |  76 114 0x4c  L  | 108 154 0x6c  l
+                 |  77 115 0x4d  M  | 109 155 0x6d  m
+                 |  78 116 0x4e  N  | 110 156 0x6e  n
+                 |  79 117 0x4f  O  | 111 157 0x6f  o
+                 |  80 120 0x50  P  | 112 160 0x70  p
+                 |  81 121 0x51  Q  | 113 161 0x71  q
+                 |  82 122 0x52  R  | 114 162 0x72  r
+                 |  83 123 0x53  S  | 115 163 0x73  s
+                 |  84 124 0x54  T  | 116 164 0x74  t
+                 |  85 125 0x55  U  | 117 165 0x75  u
+                 |  86 126 0x56  V  | 118 166 0x76  v
+                 |  87 127 0x57  W  | 119 167 0x77  w
+                 |  88 130 0x58  X  | 120 170 0x78  x
+                 |  89 131 0x59  Y  | 121 171 0x79  y
+                 |  90 132 0x5a  Z  | 122 172 0x7a  z
+======================================================
+#+end_example
+
+** 2. Desafio: dias da semana
+
+Pesquise e crie um programa que receba um número inteiro entre 1 e 7 como
+argumento e imprima o nome do dia correspondente da semana.
+
+*Requisitos:*
+
+- Utilize uma estrutura =switch= para resolver o problema.
+- Se o número não estiver no intervalo de 1 a 7, o programa deve imprimir
+  =Número inválido=.
+- Se não houver argumentos, a mensagem deve ser =Número incorreto de argumentos=.
+- Em ambos os casos anteriores, o programa deve terminar com erro.
+- Se o argumento recebido for =-h=, o programa deve exibir uma mensagem de uso
+  e terminar com sucesso.
+
+*Dicas:*
+
+Para receber argumentos, os parâmetros da função =main= devem ser (nesta ordem):
+
+- =int argc= - Número de argumentos recebidos.
+- =char **argv= - Vetor de palavras (/strings/) recebidas como argumentos.
+
+Cada palavra no vetor =argv= pode ser acessada com =argv[N]=, onde =N=
+é o índice do argumento acessado.
+
+O primeiro argumento (=argv[0]=) sempre será a invocação do programa.
+
+Todo argumento é recebido como uma string, inclusive os numéricos.
+
+** 3. Desafio: conversão de base 10 para 16 e vice-versa
+
+Crie um programa que receba um inteiro como argumento e imprima...
+
+- Se o número começar com =0x=, o número convertido da base 16 para a base 10.
+- Se começar com um inteiro diferente de =0=, o número convertido da base 10 para 16.
+- Se começar com =0= ou tiver letras inválidas para um número em hexa, uma mensagem de erro.
+
+  
+
+
+
+