Initial upload

2021-08-17 16:46:49 -03:00 · 2021-08-17 16:46:49 -03:00 · a2aef5fe9b
commit a2aef5fe9b
98 changed files with 3404 additions and 0 deletions
--- a/Cronograma.md
+++ b/Cronograma.md
@ -0,0 +1,267 @@
+# Cronograma: Introdução à Ciência da Computação em C
+
+## Capítulo 1: Como funciona um computador
+
+### Resumo
+
+- [x] Descrever as principais partes de um computador
+
+  - [x] Unidade Central de Processamento (microprocessadores)
+
+  - [x] Memória
+
+  - [x] Dispositivos de Entrada e Saída
+
+- [x] Diferenciar software e hardware
+
+- [x] Definir o que é um compilador
+
+- [x] Descrever o que é um algoritmo e dar exemplos práticos
+
+## Capítulo 2: Um primeiro programa em C
+
+### Resumo
+
+- [x] Descrever o ambiente em que os seus programas serão desenvolvidos.
+
+- [x] Escrever um programa em C que recebe dados do teclado e imprime dados na tela, usando as funções `scanf` e `printf`.
+
+- [x] Compilar um programa em C usando o `gcc`.
+
+- [x] Executar o programa após a compilação.
+
+## Capítulo 3: Fundamentos
+
+### Resumo
+
+- [x] Descrever e utilizar variáveis.
+
+- [x] Descrever a precedência dos operadores e como isso afeta o resultado das expressões aritméticas.
+
+- [x] Utilizar expressões aritméticas e relacionais, e prever seus resultados para entradas conhecidas.
+
+- [x] Utilizar comandos de leitura, impressão e atribuição.
+
+## Capítulo 4: Comandos de repetição: *while*
+
+### Resumo
+
+- [x] Utilizar comandos de repetição na resolução de problemas computacionais.
+
+- [x] Definir condições iniciais e de parada para o comando `while`.
+
+- [x] Simular o processamento do comando `while`.
+
+## Capítulo 5: Comandos de seleção simples e composta
+
+### Resumo
+
+- [x] Utilizar o comando `if`.
+
+- [x] Utilizar o comando `if-else`
+
+- [x] Identificar situações onde é necessário utilizar o comando `if-else` e situações onde é suficiente utilizar o comando `if`.
+
+- [x] Simular o processamento dos comandos `if` e `if-else` em um programa.
+
+## Capítulo 6: Sobre a divisão e resto de números inteiros
+
+### Resumo
+
+- [x] Calcular o resultado de expressões aritméticas que contenham os operadores de divisão e resto com números inteiros.
+
+- [x] Utilizar os operadores de divisão e resto de números inteiros em seus programas.
+
+## Capítulo 7: Mais detalhes sobre a linguagem C
+
+### Resumo
+
+- [x] Identificar blocos, situações que necessitam a utilização de chaves em seu programa, e situações onde as chaves podem ser omitidas.
+
+- [x] Simular e utilizar abreviaturas do comando de atribuição (como += e -=).
+
+- [x] Simular e utilizar atribuições múltiplas e no instante da declaração.
+
+- [x] Definir constantes e utilizá-las em seus programas.
+
+## Capítulo 8: Operadores lógicos
+
+### Resumo
+
+- [x] Calcular o valor de expressões aritméticas, relacionais e lógicas.
+
+- [x] Utilizar operadores lógicos para a construção de condições complexas em seus programas.
+
+## Capítulo 9: Dicas de programação
+
+### Resumo
+
+- [x] Definir o conceito de padrão em computação
+
+- [x] Utilizar os padrões computacionais: padrão sequência númerica lida, padrão sequência numérica gerada, padrão sequência numérica selecionada e padrão sequência numérica alternadamente selecionada.
+
+## Capítulo 10: Comando de repetição: *for*
+
+### Resumo
+
+- [x] Descrever a sintaxe do comando`for`.
+
+- [x] Simular o funcionamento do comando `for`.
+
+- [x] Utilizar o comando `for` em programas.
+
+## Capítulo 11: Repetições encaixadas
+
+### Resumo
+
+- [x] Simular programas com repetições encaixadas.
+
+- [x] Utilizar repetições encaixadas em seus programas.
+
+## Capítulo 12: Indicador de passagem
+
+### Resumo
+
+- [x] Descrever o funcionamento de indicadores de passagem.
+
+- [x] Identificar situações onde indicadores de passagem podem ser utilizados.
+
+- [x] Utilizar indicadores de passagem em seus programas.
+
+## Capítulo 13: Números reais do tipo *float*
+
+### Resumo
+
+- [x] Declarar, ler e imprimir variáveis do tipo float.
+
+- [x] Calcular o valor de expressões aritméticas envolvendo reais.
+
+- [x] Utilizar variáveis reais em programas.
+
+## Capítulo 14: Fórmula de recorrência e séries (Somas Infinitas)
+
+### Resumo
+
+- [x] Descrever o que são fórmulas de recorrência.
+
+- [x] Descrever o que são erro absoluto e relativo.
+
+- [x] Escrever programas em C a partir de fórmulas de recorrência.
+
+## Capítulo 15: Introdução às funções
+
+### Resumos
+
+- [x] Justificar as vantagens do uso de funções em programas.
+
+- [x] Identificar em seus programas oportunidades para criação e uso de funções.
+
+- [x] Definir os parâmetros que a função precisa receber (parâmetros de entrada) e o que a função precisa devolver (o tipo do valor devolvido pela função).
+
+## Capítulo 16: Definição e uso de funções em programas
+
+### Resumo
+
+- [x] Escrever o protótipo de uma função.
+
+- [x] Escrever o corpo de uma função.
+
+- [x] Utilizar funções em seus programas.
+
+- [x] Simular a execução de programas com funções.
+
+## Capítulo 17: Funções e ponteiros
+
+### Resumo
+
+- [x] Descrever como a informação é armazenada na memória do computador, e a diferença entre conteúdo e endereço de uma posição de memória.
+
+- [x] Definir o que é um ponteiro (ou apontador), e para que ele é utilizado.
+
+- [x] Declarar ponteiros.
+
+- [x] Utilizar ponteiros como parâmetros de funcões e em programas.
+
+## Capítulo 18: Vetores
+
+### Resumo
+
+- [x] Descrever o que são vetores na linguagem C.
+
+- [x] Declarar vetores.
+
+- [x] Como acessar elementos de um vetor e percorrer um vetor.
+
+- [x] Utilizar vetores para resolver problemas computacionais.
+
+## Capítulo 19: Vetores, ponteiros e funções
+
+### Resumo
+
+- [x] Descrever como os vetores são armazenados na memória.
+
+- [x] Descrever a relação entre vetores e ponteiros.
+
+- [x] Utilizar vetores como parâmetros de funções.
+
+## Capítulo 20: Caracteres: *char*
+
+### Resumo
+
+- [x] Declarar, ler e imprimir variáveis do tipo `char`.
+
+- [x] Descrever como caracteres são representados no computador e porque eles podem ser utilizados em expressões.
+
+- [x] Utilizar variáveis do tipo `char` em programas.
+
+## Capítulo 21: *Strings*
+
+### Resumo
+
+- [x] Descrever o que são `strings`.
+
+- [x] Descrever a distinção entre `strings` e vetores de caracteres.
+
+- [x] Ler e imprimir `strings`.
+
+- [x] Usar recursos da `string.h`[^1].
+
+- [x] Utilizar `strings` em seus programas.
+
+[^1]: Utilizou-se da biblioteca `wchar.h`, adequada a realizar operações com `wchar_t`. Estas variáveis do tipo `char` com consumo de memória adicional para armazenarem uma amplitude de caracteres acentuados presentes no idioma português.
+
+## Capítulo 22: Matrizes
+
+### Resumo
+
+- [ ] Descrever o que são matrizes em C.
+
+- [ ] Declarar matrizes.
+
+- [ ] Como acessar elementos de uma matriz e percorrer uma matriz.
+
+- [ ] Utilizar matrizes para resolver problemas computacionais.
+
+
+
+## Capítulo 23: Matrizes, Ponteiros e Funções
+
+### Resumo
+
+- [ ] Descrever como matrizes são armazenadas na memória.
+
+- [ ] Descrever a relação entre matrizes e ponteiros.
+
+- [ ] Utilizar matrizes como parâmetros de funções.
+
+
+
+## Capítulo 24: Algoritmos de busca
+
+### Resumo
+
+- [ ] Definir o problema de busca de um elemento em um vetor.
+
+- [ ] Descrever o que é busca sequencial.
+
+- [ ] Descrever a vantagem de usar sentinela em busca sequencial.
--- a/Exercícios/04/fatorial.c
+++ b/Exercícios/04/fatorial.c
@ -0,0 +1,29 @@
+# include <stdio.h>
+
+int main () {
+	int n, i, fatorial;
+	n = -1;
+	
+	printf ("este programa calcula o valor do fatorial n!, para qualquer valor de n positivo.\n");
+	while (n < 0) {
+		printf ("Digite um valor para n: ");
+		scanf ("%d", &n);
+		if (n < 0) {
+			printf ("O valor %d não é igual ou maior que 0.\n", n);
+		}
+	}
+	fatorial = n;
+	i = n;
+
+	if (fatorial == 0) {
+		fatorial = 1;
+	}
+
+	while (i > 2) {
+		i = i - 1;
+		fatorial = fatorial * i;
+	}
+
+	printf ("%d! = %d\n", n, fatorial);
+	return 0;
+}
--- a/Exercícios/04/potenciacao.c
+++ b/Exercícios/04/potenciacao.c
@ -0,0 +1,36 @@
+# include <stdio.h>
+
+int main() {
+	int n, k, seq, resultado;
+	k = -1;
+	seq = 1;
+
+	printf ("Este programa calcula o valor de um número inteiro n elevado à potência doutro número inteiro k.\nDigite um valor para n: ");
+	scanf ("%d", &n);
+	resultado = n;
+
+	while (k < 0) {
+		printf ("Digite um valor positivo para k: ");
+		scanf ("%d", &k);
+		if (k < 0) {
+			printf ("O valor %d não é maior ou igual à 0.\n", k);
+		}
+	}
+
+	if (k == 0) {
+		if (n >= 0){
+			resultado = 1;
+		}
+		else {
+			resultado = -1;
+		}
+		
+	}
+
+	while (seq < k) {
+		resultado = resultado * n;
+		seq = seq + 1;
+	}
+	printf ("%d^%d = %d\n", n, k, resultado);
+	return 0;
+}
--- a/Exercícios/06/base10_to_base2.c
+++ b/Exercícios/06/base10_to_base2.c
@ -0,0 +1,32 @@
+# include <stdio.h>
+
+int main () {
+	int num, result, pot, i, j;
+	num = -1;
+	result = 0;
+
+	printf("Este programa converte um número em base decimal no seu equivalente binário.\n");
+	while (num < 0)  {
+		printf ("Digite um número natural e positivo: ");
+		scanf("%d", &num);
+		if (num <= 0)
+			printf ("Número inválido\n");
+	}
+
+	i = num;
+	while (i != 0) {
+		j = 1;
+		pot = 1;
+		if (i > 1){
+			while (j * 2 <= i) {
+				j = j * 2;
+				pot = pot * 10;
+			}
+		}
+		i = i - j;
+		result = result + pot;
+	}
+
+	printf ("O número %d pode ser representado pelo binário %d.\n", num, result);
+	return 0;
+}
--- a/Exercícios/06/base2_to_base10.c
+++ b/Exercícios/06/base2_to_base10.c
@ -0,0 +1,37 @@
+# include <stdio.h>
+
+int main () {
+	int num, i, j, pot, result, test;
+	pot = 1;
+	test = 1;
+	result = 0;	
+
+	printf ("Este programa converte um número natural em base binária em seu equivalente em base decimal.\n");
+
+	/* Solicite um número e teste se este é válido */
+	while (test == 1) {
+		test = 0;
+		printf ("Digite um número natural binário: ");
+		scanf ("%d", &num);
+		i = num;
+		while (i != 0 && test == 0) {
+			if (i % 10 != 0 && i % 10 != 1)
+				test = 1;
+			else
+				i = i / 10;
+		}
+		if (test == 1)
+			printf ("Número inválido.\n");
+	}
+	
+
+	/* Converta o número */
+	j = num;
+	while (j != 0) {
+		result = result + j % 10 * pot; 
+		j = j / 10;
+		pot = pot * 2;		
+	}
+	printf ("O número binário %d é representado em base decimal por %d.\n", num, result);
+	return 0;
+}
--- a/Exercícios/06/congruentes.c
+++ b/Exercícios/06/congruentes.c
@ -0,0 +1,30 @@
+# include <stdio.h>
+
+int main () {
+	int n, j, m, i, count;
+	n = 0;
+	j = 0;
+	m = 0;
+	count = 0;
+	i = 1;
+
+	printf ("Este programa imprime n números, em ordem crescente, que produzem o mesmo resto de um número j dividido pelo módulo m, quando divididos por este mesmo módulo. ");
+
+	while (n == 0 || j == 0 || m == 0) {
+		printf ("Dê um valor inteiro, positivo, e não nulo, para n, j e m: ");
+		scanf ("%d %d %d", &n, &j, &m);
+		if (n == 0 || j == 0 || m == 0)
+			printf ("Valor inválido.\n");
+	}
+
+	while (count < n) {
+		if (i % m == j % m && i != j) {
+			printf("%d ", i);
+			count = count + 1;
+		}
+		i = i + 1;
+	}
+
+	printf ("\n");
+	return 0;
+}
--- a/Exercícios/06/digitos.c
+++ b/Exercícios/06/digitos.c
@ -0,0 +1,37 @@
+# include <stdio.h>
+
+int main () {
+
+	int num, dig, cont, i;
+	num = 0;
+	dig = -1;
+	cont = 0;
+	
+	printf ("Este programa contabiliza as ocorrências de um digito qualquer em um número positivo e não nulo.\n");
+
+	while (num <= 0) {
+		printf ("Digite um número: ");
+		scanf ("%d", &num);
+		if (num <= 0)
+			printf ("Número inválido\n");
+		else
+			i = num;
+		
+	}
+
+	while (dig < 0 || dig > 9) {
+		printf ("Dê um dígito a ser contabilizado: ");
+		scanf ("%d", &dig);
+		if (dig < 0 || dig > 9)
+			printf ("Número inválido\n");
+	}
+
+	while (i != 0) {
+		if (i % 10 == dig)
+			cont = cont + 1;
+		i = i / 10;
+	}
+
+	printf("Número de vezes em que o dígito %d aparece no número %d: %d\n", dig, num, cont);
+	return 0;	
+}
--- a/Exercícios/06/mdc.c
+++ b/Exercícios/06/mdc.c
@ -0,0 +1,32 @@
+# include <stdio.h>
+
+int main () {
+	int mdc, min, i, j, k;
+	i = 0;
+	j = 0;
+	k = 1;
+
+	printf ("Este programa calcula o maior divisor comum (mdc) entre dois números positivos, inteiros e não nulos.");
+
+	while (i == 0 || j == 0) {
+		printf ("Digite dois números ineiros, separados por um espaço: ");
+		scanf ("%d %d", &i, &j);
+		if (i == 0 || j == 0)
+			printf ("Número inválido.\n");
+	}
+
+	if (i <= j)
+		min = i;
+	else
+		min = j;
+
+	mdc = k;
+	while (k < min) {
+		k = k + 1;
+		if (i % k == 0 && j % k == 0)
+			mdc = k;
+	}
+
+	printf ("O maior divisor comum entre %d e %d é %d.\n", i, j, mdc);	
+	return 0;
+}
--- a/Exercícios/06/multiplos_comuns.c
+++ b/Exercícios/06/multiplos_comuns.c
@ -0,0 +1,32 @@
+# include <stdio.h>
+
+int main () {
+	int n, i, j, k, cont;
+	n = 0;
+	i = 0;
+	j = 0;
+	cont = 0;
+
+	printf ("Este programa imprime um número de múltiplos comuns, em ordem crescente, entre dois números inteiros, positivos e não nulos. ");
+
+	while (n <= 0 || i <= 0 || j <= 0) {
+		printf ("Digite, separados por espaços, dois números seguidos da quantidade de múltiplos comuns entre eles que se deseja calcular: ");
+		scanf("%d %d %d", &i, &j, &n);
+		if (n <= 0 || i <= 0 || j <= 0)
+			printf ("Foi encontrado um valor inválido.\n");
+	}
+
+	if (i >= j)
+		k = i;
+	else
+		k = j;
+	while (cont < n) {
+		if (k % i == 0 && k % j == 0){
+			printf ("%d ", k);
+			cont = cont + 1;
+		}
+		k = k + 1;
+	}
+	printf ("\n");
+	return 0;
+}
--- a/Exercícios/06/palindromo.c
+++ b/Exercícios/06/palindromo.c
@ -0,0 +1,39 @@
+# include <stdio.h>
+
+int main () {
+	int num, i, j, k, cont;
+	num = 0;
+
+	printf ("Este é um programa que verifica se um número inteiro maior que 10 é palíndrome.\n");
+
+	while (num <= 10) {
+		printf ("Digite um número: ");
+		scanf ("%d", &num);
+		if (num <= 10)
+			printf ("Número inválido\n");
+	}
+
+	i = num;
+	while (i != 0) {
+		cont = 1;
+		j = i % 10;
+		if (j == 0) {
+			printf ("%d não é palindrome.\n", num);
+			return 0;
+		}
+		k = i;
+		while (k > 9) {
+			k = k / 10;
+			cont = cont * 10;
+		}
+		if (j != k) {
+			printf ("%d não é palindrome.\n", num);
+			return 0;
+		}
+
+		i = i % cont / 10;	
+	}
+
+	printf ("%d é palindrome.\n", num);
+	return 0;
+}
--- a/Exercícios/06/raiz_e_soma.c
+++ b/Exercícios/06/raiz_e_soma.c
@ -0,0 +1,22 @@
+# include <stdio.h>
+
+int main () {
+	int i, j, k, raiz;
+	i = 1000;
+
+	printf("Este programa imprime todos os milhares cuja raiz quadrada seja a soma das duas dezenas formadas pelos seus dois primeiros e dois últimos algarismos.\n");
+
+	while (i < 10000) {
+		raiz = 10;
+		while (raiz * raiz != i && raiz < 100)
+			raiz = raiz + 1;
+		if (raiz != 100) {
+			j = i / 100;
+			k = i % 100;
+			if (k + j == raiz)
+				printf("Raiz de %d: %d = %d + %d\n", i, raiz, j, k);
+		}
+		i = i + 1;
+	}
+	return 0;
+}
--- a/Exercícios/06/soma_digitos.c
+++ b/Exercícios/06/soma_digitos.c
@ -0,0 +1,26 @@
+# include <stdio.h>
+
+int main () {
+	int num, i, cont;
+	num = 0;
+	cont = 0;
+
+	printf("Este programa calcula a soma dos dígitos de um número positivo e não nulo.\n");
+
+	while (num <= 0) {
+		printf ("Digite um número: ");
+		scanf ("%d", &num);
+		if (num <= 0)
+			printf ("Número inválido\n");
+		else
+			i = num;
+	}
+
+	while (i != 0) {
+		cont = cont + i % 10;
+		i = i / 10;
+	}
+
+	printf("A soma dos dígitos de %d é %d.\n", num, cont);
+	return 0;
+}
--- a/Exercícios/06/soma_pares.c
+++ b/Exercícios/06/soma_pares.c
@ -0,0 +1,26 @@
+# include <stdio.h>
+
+int main () {
+	int num, i, result;
+	num = 0;
+	result = 0;
+
+	printf ("Este programa calcula a soma dos dígitos pares de um número positivo e não nulo");
+
+	while (num <= 0) {
+		printf ("Digite um número: ");
+		scanf ("%d", &num);
+		if (num <= 0)
+			printf ("Número inválido.\n");
+	}
+
+	i = num;
+	while (i != 0) {
+		if ( i % 2 == 0)
+			result = result + i % 10;
+		i = i / 10;
+	}
+
+	printf ("A soma dos dígitos pares em %d é %d.\n", num, result);
+	return 0;
+}
--- a/Exercícios/07/numero_perfeito.c
+++ b/Exercícios/07/numero_perfeito.c
@ -0,0 +1,20 @@
+# include <stdio.h>
+
+int main () {
+	int num, soma, n;
+	num = 1;
+	soma = 0;
+	n = 120;
+
+	while (num < n) {
+		if (n % num == 0)
+			soma = soma + num;
+		num = num + 1;
+	}
+
+	if (soma == n)
+		printf ("Número perfeito\n");
+	else
+		printf ("Número imperfeito: soma igual à %d\n", soma);
+	return 0;
+}
--- a/Exercícios/08/multiplos.c
+++ b/Exercícios/08/multiplos.c
@ -0,0 +1,25 @@
+# include <stdio.h>
+
+int main () {
+	int n = 0, i = 0, j = 0, k = 1, cont = 0;
+
+	printf ("Este programa imprime os n primeiros números, em ordem crescente, que são múltiplos de dois números positivos e não nulos quaisquer. ");
+
+	while (n <= 0 || i <= 0 || j <= 0) {
+		printf ("Dê um valor para n, e mais dois números, separados por espaços: ");
+		scanf ("%d %d %d", &n, &i, &j);
+		if (n <= 0 || i <= 0 || j <= 0)
+			printf("Valor inválido detectado.\n");
+	}
+
+	while (cont < n) {
+		if (k % i == 0 || k % j == 0) {
+			printf ("%d ", k);
+			cont++;
+		}
+		k++;	
+	}
+	
+	printf ("\n");
+	return 0;
+}
--- a/Exercícios/09/fibonacci.c
+++ b/Exercícios/09/fibonacci.c
@ -0,0 +1,25 @@
+# include <stdio.h>
+
+int main () {
+	int n = 0, i = 0, f1 = 1, f2 = 1, f3;
+	printf ("Este programa calcula os valores até o enésimo número na sequência Fibonacci.\n");
+
+	while (n <= 3) {
+		printf ("Digite um valor inteiro para n maior ou igual à 3: ");
+		scanf ("%d", &n);
+		if (n <= 3)
+			printf ("Valor inválido.\n");
+	}
+
+	printf("%d %d", f1, f2);
+	while (i <= n){
+		f3 = f2 + f1;
+		printf(" %d", f3);
+		f1 = f2;
+		f2 = f3;
+		i++;
+	}
+	
+	printf("\n");
+	return 0;
+}
--- a/Exercícios/09/impares.c
+++ b/Exercícios/09/impares.c
@ -0,0 +1,24 @@
+# include <stdio.h>
+
+int main () {
+	int n = 0, i = 1, cont = 0;
+	printf ("Este programa imprime, em ordem crescente, todos os números ímpares até a enésima unidade.\n");
+
+	while (n <= 0) {
+		printf ("Digite um valor para n: ");
+		scanf ("%d", &n);
+		if (n <= 0)
+			printf ("Valor inválido.\n");
+	}
+
+	while (cont < n) {
+		if (i % 2 != 0) {
+			printf("%d ", i);
+			cont++;
+		}
+		i ++;
+	}
+
+	printf("\n");
+	return 0;
+}
--- a/Exercícios/09/num_perfeito.c
+++ b/Exercícios/09/num_perfeito.c
@ -0,0 +1,31 @@
+# include <stdio.h>
+
+int main () {
+	int n = 0, i = 1, cont = 0, j, soma;
+	printf ("Este programa imprime, em ordem crescente, todos os números perfeitos até a enésima unidade.\n");
+
+	while (n <= 0) {
+		printf ("Digite um valor para n: ");
+		scanf ("%d", &n);
+		if (n <= 0)
+			printf ("Valor inválido.\n");
+	}
+
+	while (cont < n) {
+		j = 1;
+		soma = 0;
+		while (j < i) {
+			if (i % j == 0)
+				soma += j;
+			j++;
+		}
+		if (soma == i) {
+			printf ("%d ", i);
+			cont++;
+		}
+		i++;
+	}
+
+	printf("\n");
+	return 0;
+}
--- a/Exercícios/09/soma_divisores.c
+++ b/Exercícios/09/soma_divisores.c
@ -0,0 +1,28 @@
+# include <stdio.h>
+
+int main () {
+	int i = 1, n = 0, soma = 0;
+	printf ("Este programa calcula a soma dos divisores de um número qualquer, postitivo e não nulo.\n");
+
+	while (n <= 0) {
+		printf ("Digite um número: ");
+		scanf ("%d", &n);
+		if (n <= 0)
+			printf ("Número inválido.\n") ;
+		
+	}
+
+	while (i <= n) {
+		if (n % i == 0) {
+			if (i > 1)
+				printf(" + ");
+			printf ("%d", i);
+			soma += i;
+		}
+		i++;
+	}
+
+	printf(" = %d\n", soma);
+	
+	return 0;
+}
--- a/Exercícios/09/soma_e_quantidade_1.c
+++ b/Exercícios/09/soma_e_quantidade_1.c
@ -0,0 +1,29 @@
+# include <stdio.h>
+
+int main () {
+	int n = 0, i = 1, soma_pares = 0, quant_impares = 0;
+	printf ("Este programa determina, para uma sequência de n números positivos consecutivos, inteiros, iniciada em 1, a soma dos números pares e a quantidade de números ímpares.\n");
+
+	while (n <= 0) {
+		printf ("Digite um valor para n: ");
+		scanf ("%d", &n);
+		if (n <= 0)
+			printf ("Valor inválido.\n");
+	}
+
+	printf ("Soma dos números pares: ");
+	while (i <= n) {
+		if (i % 2 == 0) {
+			if (i != 2)
+				printf (" + ");
+			printf ("%d", i);
+			soma_pares += i;
+		}
+		else
+			quant_impares++;
+		i++;		
+	}
+
+	printf (" = %d\nQuantidade de número ímpares: %d\n", soma_pares, quant_impares);
+	return 0;
+}
--- a/Exercícios/09/soma_e_quantidade_2.c
+++ b/Exercícios/09/soma_e_quantidade_2.c
@ -0,0 +1,34 @@
+# include <stdio.h>
+
+# define true 1
+# define false 0
+
+int main () {
+	int n = 0, i = 1, quant_divs_pares = 0, soma_divs = 0, test_soma = false;
+	printf ("Este programa determina, no âmbito dos números naturais e não nulos, a soma dos divisores e a quantidade de divisores pares de um número n.\n");
+
+	while (n <= 0) {
+		printf ("Digite um valor para n: ");
+		scanf ("%d", &n);
+		if (n <= 0)
+			printf ("Valor inválido.\n");
+	}
+
+	printf ("Soma dos divisores de n: ");
+	while (i <= n) {
+		if (n % i == 0) {
+			if (test_soma == true)
+				printf(" + ");
+			else
+				test_soma = true;
+			printf("%d", i);
+			soma_divs += i;
+			if (i % 2 == 0)
+				quant_divs_pares++;
+		}
+		i++;		
+	}
+
+	printf (" = %d\nQuantidade de divisores pares: %d\n", soma_divs, quant_divs_pares);
+	return 0;
+}
--- a/Exercícios/09/somacao.c
+++ b/Exercícios/09/somacao.c
@ -0,0 +1,20 @@
+# include <stdio.h>
+
+int main () {
+	int n = -1, i = 0, soma = 0;
+	printf ("Este programa calcula, para um número inteiro e positivo n, a soma dos n primeiros números naturais.\n");
+
+	while (n < 0) {
+		printf ("Digite um valor para n: ");
+		scanf ("%d", &n);
+		if (n < 0)
+			printf ("Valor inválido");
+	}
+
+	while (i <= n){
+		soma += i;
+		i++;
+	}
+	printf ("A soma de todos os valores desde 0 até %d é %d\n", n, soma);
+	return 0;
+}
--- a/Exercícios/10/fatorial.c
+++ b/Exercícios/10/fatorial.c
@ -0,0 +1,30 @@
+# include <stdio.h>
+
+int main () {
+	int n = -1, i, fatorial;
+	printf ("Este programa calcula do valor fatorial n!.\n");
+
+	while (n < 0) {
+		printf ("Digite um valor positivo e inteiro para n: ");
+		scanf ("%d", &n);
+		if (n < 0)
+			printf ("Valor inválido.\n");
+	}
+
+	printf ("%d! = ", n);
+	if (n < 2)
+		fatorial = 1;
+	else
+		fatorial = n;
+
+	printf ("%d", fatorial);
+	for (i = fatorial - 1; i > 0; i--) {
+			printf(" * %d", i);
+			fatorial *= i;
+			if (i == 1)
+				printf (" = %d", fatorial);
+	}
+
+	printf ("\n");
+	return 0;
+}
--- a/Exercícios/10/primo.c
+++ b/Exercícios/10/primo.c
@ -0,0 +1,33 @@
+# include <stdio.h>
+
+int main () {
+	int num = 0, i, j, count = 0;
+	printf ("Este programa testa se um dado número inteiro e não nulo é primo.\n");
+
+	while (num == 0) {
+		printf ("Dê um número inteiro: ");
+		scanf ("%d", &num);
+		if (num == 0)
+			printf ("Valor inválido.\n");		
+	}
+
+	if (num < 0)
+		j = -num;
+	else
+		j = num;
+
+	printf ("São os divisores positivos de %d: 1", num);
+	for (i = 2; i <= j; i++) {
+		if (j % i != 0)
+			continue;
+		printf (", %d", i);
+		count++;
+	}
+
+	if (count == 1)
+		printf(". Logo, %d é um número primo.\n", num);
+	else
+		printf(". Logo, %d não é um número primo.\n", num);
+		
+	return 0;
+}
--- a/Exercícios/10/triangular.c
+++ b/Exercícios/10/triangular.c
@ -0,0 +1,24 @@
+# include <stdio.h>
+
+int main () {
+	int n = 0, i, j, count = 0;
+	printf ("Este programa imprime os n primeiros números triangulares, em ordem crescente.\n");
+
+	while (n <= 0) {
+		printf ("Dê um valor inteiro, positivo e não nulo à n: ");
+		scanf ("%d", &n);
+		if (n <= 0)
+			printf ("Valor inválido.\n");
+	}
+
+	for (i = 4; count < n; i++) {
+		for (j = 3; j < i; j++) {
+			if ((j - 2) * (j - 1) * j != i)
+				continue;
+			printf ("%d * %d * %d = %d\n", j - 2, j - 1, j, i);
+			count ++;
+		}
+	}
+		
+	return 0;
+}
--- a/Exercícios/11/segundo_grau.c
+++ b/Exercícios/11/segundo_grau.c
@ -0,0 +1,40 @@
+# include <stdio.h>
+
+int main () {
+	int m = -1, n = -1, i, j, x, y, x_2, y_2, max;
+	printf ("Dados dois naturais n > 0 e m > 0, este programa determina entre todos os pares de números inteiros (x,y) tais que 0 ≤ x ≤ n e 0 ≤ y ≤ m, o par para o qual o valor da expressão -x² + yx + y seja máximo.\n");
+
+	while (n < 0 || m < 0) {
+		printf ("Dê valores inteiros, e positivos à n e m, separados por espaço: ");
+		scanf ("%d %d", &n, &m);
+		if (n < 0 || m < 0)
+			printf ("Valor inválido detectado.\n");
+	}
+
+	max = n * m - n * n + m;
+	x = n;
+	y = m;
+	for (i = 0; i <= n; i++) {
+		for (j = 0; j <= m; j++) {
+			if (i * j - i * i + j <= max || (i == n && j == m))
+				continue;
+			max = i * j - i * i + j;
+			x = i;
+			y = j;
+		}
+	}
+
+	for (i = 0; i <= n; i++) {
+		for (j = 0; j <= m; j++) {
+			if (i * j - i * i + j < max || (i == x && j == y))
+				continue;
+			x_2 = i;
+			y_2 = j;
+		}
+	}
+
+	printf ("O valor de -x² + yx + y é máximo quando x = %d e y = %d: -(%d)² + %d + %d = %d\n", x, y, x, y * x, y, max);
+	if (x_2 != x || y_2 != y)
+		printf ("Também, quando x = %d e y = %d: -(%d)² + %d + %d = %d\n", x_2, y_2, x_2, y_2 * x_2, y_2, max);
+	return 0;
+}
--- a/Exercícios/12/digitos_adjacentes.c
+++ b/Exercícios/12/digitos_adjacentes.c
@ -0,0 +1,27 @@
+# include <stdio.h>
+# define true 1
+# define false 0
+
+int main () {
+	int adjacente = false, n, i;
+
+	printf ("Este programa verifica se uma dado número possui dígitos adjacentes iguais.\nDigite um número: ");
+	scanf ("%d", &n);
+
+	i = n % 10;
+	n /= 10;
+	while (n != 0) {
+		if (n % 10 == i) {
+			adjacente = true;
+			break;
+		}
+		i = n % 10;
+		n /= 10;
+	}
+
+	if (adjacente == true)
+		printf ("O número possui dígitos adjacentes iguais\n");
+	else
+		printf ("O número não possui dígitos adjacentes iguais\n");
+	return 0;
+}
--- a/Exercícios/13/harmonico.c
+++ b/Exercícios/13/harmonico.c
@ -0,0 +1,27 @@
+# include <stdio.h>
+
+int main () {
+	int n = 0;
+	float k, result = 0;
+
+	printf ("Este programa calcula o harmônico para um número natural n.\n");
+	while (n <= 0) {
+		printf ("Dê um valor para n: ");
+		scanf ("%d", &n);
+		if (n <= 0)
+			printf ("Valor inválido.\n");
+	}
+
+	printf ("O harmônico de %d é igual à: ", n);
+	for (k = 1; k <= n; k++) {
+		printf ("(1 / %d)", (int) k);
+		result += 1 / k;
+		if (k < n)
+			printf (" + ");
+		else
+			printf (" = ");
+	}
+
+	printf ("%f\n", result);
+	return 0;		
+}
--- a/Exercícios/13/somacao.c
+++ b/Exercícios/13/somacao.c
@ -0,0 +1,27 @@
+# include <stdio.h>
+
+int main () {
+	int n = 0, k;
+	float result = 0;
+
+	printf ("Este programa calcula o valor da somação S_n, onde S_n = (1 / n) + [2 / (n - 1)] + [3 / (n - 2)] + ... + n / 1, para um número inteiro e não nulo n.\n");
+	while (n <= 0) {
+		printf ("Dê um valor para n: ");
+		scanf ("%d", &n);
+		if (n <= 0)
+			printf ("Valor inválido.\n");
+	}
+	printf ("S_n = ");
+
+	for (k = 1; k <= n; k++) {
+		printf ("[%d / %d]", k, n - k + 1);
+		result += k / (n - k + 1);
+		if (k < n)
+			printf (" + ");
+		else
+			printf (" = ");
+	}
+
+	printf ("%f\n", result);
+	return 0;		
+}
--- a/Exercícios/14/cos.c
+++ b/Exercícios/14/cos.c
@ -0,0 +1,35 @@
+#include <stdio.h>
+
+int main () {
+	float soma, t, x = -1, eps = 0, t_ant;
+	int k;
+	soma = t_ant = t = k = 1;
+	
+	printf ("Este programa apresenta uma aproximação do cosseno de x, para um número real x ≥ 0, com uma precisão eps, de valor 0 < eps < 1.\n");
+
+	while (x < 0) {
+		printf ("Digite um valor para x: ");
+		scanf ("%f", &x);
+		if (x < 0)
+			printf ("Valor inválido \n");
+	}
+
+	while (eps >= 1 || eps <= 0) {
+		printf ("Digite um valor para eps: ");
+		scanf ("%f", &eps);
+		if (eps >= 1 || eps <= 0)
+			printf ("Valor inválido \n");
+	}
+
+	while (t_ant >= eps) {
+		t = - t * x * x / ((2 * k) * ( 2 * k - 1));
+		soma += t;
+		k++;
+		t_ant = t;
+		if (t_ant < 0)
+			t_ant = -t_ant;
+	}
+
+	printf ("cos(%f) = %f\n", x, soma);
+	return 0;
+}
--- a/Exercícios/14/sen.c
+++ b/Exercícios/14/sen.c
@ -0,0 +1,35 @@
+#include <stdio.h>
+
+int main () {
+	float soma, t, x = -1, eps = 0, t_ant;
+	int k;
+	soma = t_ant = t = k = 1;
+	
+	printf ("Este programa apresenta uma aproximação do seno de x, para um número real x ≥ 0, com uma precisão eps, de valor 0 < eps < 1.\n");
+
+	while (x < 0) {
+		printf ("Digite um valor para x: ");
+		scanf ("%f", &x);
+		if (x < 0)
+			printf ("Valor inválido \n");
+	}
+
+	while (eps >= 1 || eps <= 0) {
+		printf ("Digite um valor para eps: ");
+		scanf ("%f", &eps);
+		if (eps >= 1 || eps <= 0)
+			printf ("Valor inválido \n");
+	}
+
+	while (t_ant >= eps) {
+		t = - t * x * x / ((2 * k) * ( 2 * k + 1));
+		soma += t;
+		k++;
+		t_ant = t;
+		if (t_ant < 0)
+			t_ant = -t_ant;
+	}
+
+	printf ("sen(%f) = %f\n", x, soma);
+	return 0;
+}
--- a/Exercícios/14/serie.c
+++ b/Exercícios/14/serie.c
@ -0,0 +1,35 @@
+#include <stdio.h>
+
+int main () {
+	float soma, t, x = -1, eps = 0, t_ant;
+	int k;
+	soma = t_ant = t = k = 1;
+	
+	printf ("Este programa apresenta uma aproximação da série e^x = 1 + x + x^2 / 2! + x^3 / 3! + ... + x^k / k! + ..., para um número real x ≥ 0, com uma precisão eps, de valor 0 < eps < 1.\n");
+
+	while (x < 0) {
+		printf ("Digite um valor para x: ");
+		scanf ("%f", &x);
+		if (x < 0)
+			printf ("Valor inválido \n");
+	}
+
+	while (eps >= 1 || eps <= 0) {
+		printf ("Digite um valor para eps: ");
+		scanf ("%f", &eps);
+		if (eps >= 1 || eps <= 0)
+			printf ("Valor inválido \n");
+	}
+
+	while (t_ant >= eps) {
+		t = t * x / k;
+		soma += t;
+		k++;
+		t_ant = t;
+		if (t_ant < 0)
+			t_ant = -t_ant;
+	}
+
+	printf ("exp(%f) = %f\n", x, soma);
+	return 0;
+}
--- a/Exercícios/15/combinacao.c
+++ b/Exercícios/15/combinacao.c
@ -0,0 +1,31 @@
+# include <stdio.h>
+
+int main () {
+	int m, n, i;
+	float result = 1;
+	m = n = 0;
+	printf ("Este programa calcula o número de possibilidades de combinação de m elementos distintos em um subconjunto com n elementos de tamanho. Isto é, C(m,n) = m! / [n! (m - n)!], onde m e n são números inteiros e positivos, e m ≥ n.\n");
+
+	while (m <= n || m < 0 || n < 0) {
+		printf ("Digite valores para m e n, respectivamente, separados por espaço: ");
+		scanf ("%d %d", &m, &n);
+		if (m <= n || m < 0 || n < 0)
+			printf ("Valor inválido detectado.\n");
+	}
+
+	if (m - n > n) {
+		for (i = m; i > m - n; i--)
+			result *= i;
+		for (i = n; i > 1; i--)
+			result /=i;
+	}
+	else {
+		for (i = m; i > n; i--)
+			result *= i;
+		for (i = m - n; i > 1; i--)
+			result /=i;
+	}
+
+	printf ("C(%d,%d) = %d! / (%d! %d!) = %f\n", m, n, m, n, m - n, result);
+	return 0;
+}
--- a/Exercícios/15/expressao_real.c
+++ b/Exercícios/15/expressao_real.c
@ -0,0 +1,55 @@
+# include <stdio.h>
+
+int main () {
+	int a, b, i, pot;
+	float x, y, x_y, x_2 = 1, y_2 = 1, x_y_2 = 1;
+
+	printf ("Este programa calcula o valor da expressão x^a + y^b + (x - y)^(a + b). Onde x e y são números reais e a e b são números inteiros.\n");
+	printf ("Descreva, separados por um espaço, valores para x, y, a e b respectivamente: ");
+	scanf ("%f %f %d %d", &x, &y, &a, &b);
+
+	/* Calcular o valor de x^a */
+
+	if (a < 0)
+		pot = -a;
+	else
+		pot = a;
+
+	for (i = 1; i <= pot; i++)
+		x_2 *= x;
+
+	if (a < 0)
+		x_2 = 1 / x_2;
+
+	/* Calcular o valor de y^b */
+
+	if (b < 0)
+		pot = -b;
+	else
+		pot = b;
+
+	for (i = 1; i <= pot; i++)
+		y_2 *= y;
+
+	if (b < 0)
+		y_2 = 1 / y_2;
+
+	/* Calcular o valor de (x - y)^(a + b) */
+	
+	x_y = x - y;
+	pot = a + b;
+	
+	if (pot < 0)
+		pot = -pot;
+
+	for (i = 1; i <= pot; i++)
+		x_y_2 *= x_y;
+
+	if (a + b < 0)
+		x_y_2 = 1/ x_y_2;
+
+	/* Apresentar resultado */
+		
+	printf ("%f^%d + %f^%d + %f^%d = %f\n", x, a, y, b, x_y, a + b, x_2 + y_2 + x_y_2);
+	return 0;
+}
--- a/Exercícios/15/expressao_real_func.c
+++ b/Exercícios/15/expressao_real_func.c
@ -0,0 +1,31 @@
+# include <stdio.h>
+
+float potencia (float base, int expoente) {
+	int i, pot;
+	float result = 1;
+
+	if (expoente < 0)
+		pot = -expoente;
+	else
+		pot = expoente;
+
+	for (i = 1; i <= pot; i++)
+		result *= base;
+
+	if (expoente < 0)
+		result = 1 / result;
+
+	return result; 
+}
+
+int main () {
+	int a, b;
+	float x, y;
+
+	printf ("Este programa calcula o valor da expressão x^a + y^b + (x - y)^(a + b). Onde x e y são números reais e a e b são números inteiros.\n");
+	printf ("Descreva, separados por um espaço, valores para x, y, a e b respectivamente: ");
+	scanf ("%f %f %d %d", &x, &y, &a, &b);
+		
+	printf ("%f^%d + %f^%d + %f^%d = %f\n", x, a, y, b, x - y, a + b, potencia (x,a) + potencia (y,b) + potencia (x - y,a + b));
+	return 0;
+}
--- a/Exercícios/15/potencia_real.c
+++ b/Exercícios/15/potencia_real.c
@ -0,0 +1,25 @@
+# include <stdio.h>
+
+int main () {
+	int k, i, pot;
+	float x, result = 1;
+
+	printf ("Este programa calcula o valor do número real x quando elevado à potência do número inteiro k.\n");
+	printf ("Descreva, separados por um espaço, valores para x e k, respectivamente: ");
+	scanf ("%f %d", &x, &k);
+
+	if (k < 0)
+		pot = -k;
+	else
+		pot = k;
+
+	for (i = 1; i <= pot; i++)
+		result *= x;
+
+	if (k < 0)
+		result = 1 / result;
+
+	printf ("%f^%d = %f\n", x, k, result);
+	
+	return 0;
+}
--- a/Exercícios/16/coeficientes.c
+++ b/Exercícios/16/coeficientes.c
@ -0,0 +1,30 @@
+# include <stdio.h>
+
+int fatorial (int n) {
+	int i, result = 1;
+	for (i = n; i > 1; i--)
+		result *= i;
+	return result;	
+}
+
+int comb (int m, int n) {
+	return fatorial (m) / (fatorial (n) * fatorial (m - n));
+}
+
+int main () {
+	int n = -1, p;
+	printf ("Este programa imprime os coeficientes da expansão (a + b)^n, para um valor inteiro n >= 0.\n");
+
+	while (n < 0) {
+		printf ("Digite um valor para n: ");
+		scanf ("%d", &n);
+		if (n < 0)
+			printf ("Valor inválido.\n");
+	}
+
+	for (p = 0; p <= n; p++)
+		printf("%d ", comb (n,p));
+		
+	printf ("\n");
+	return 0;
+}
--- a/Exercícios/16/dist.c
+++ b/Exercícios/16/dist.c
@ -0,0 +1,15 @@
+# include <stdio.h>
+# include <math.h>
+
+int main () {
+	double x_a, x_b, y_a, y_b;
+
+	printf ("Este programa calcula a distância entre dois pontos cartesianos a e b, definidos por suas coordenadas reais x e y.\n");
+	printf ("Dê as coordenadas x e y do ponto a, separadas por espaço: ");
+	scanf ("%lf %lf", &x_a, &y_a);
+	printf ("Dê as coordenadas x e y do ponto a, separadas por espaço: ");
+	scanf ("%lf %lf", &x_b, &y_b);
+
+	printf ("sqrt[(%f - %f)^2 + (%f - %f)^2] = %f\n", x_b, x_a, y_a, y_b, sqrt(pow(x_b - x_a,2) + pow(y_b - y_a,2)));
+	return 0;
+}
--- a/Exercícios/16/permutacao.c
+++ b/Exercícios/16/permutacao.c
@ -0,0 +1,48 @@
+# include <stdio.h>
+# define true 1
+# define false 0
+
+int has_0 (int number) {
+	if (number == 0)
+		return true;
+	while (number != 0) {
+		if (number % 10 == 0)
+			return true;
+		number /= 10;
+	}
+	return false;	
+}
+
+int digit_count (int digit, int number) {
+	int count = 0;
+
+	while (number != 0) {
+		if (number % 10 == digit)
+			count ++;
+		number /= 10;
+	}
+	return count;
+}
+
+int main () {
+	int a, b, i;
+	a = b = 0;
+
+	printf("Este programa confirma ou nega se dois números a e b, que não possuem o dígito 0, são permutáveis entre si.\n");
+	while (has_0 (a) == true || has_0 (b) == true) {
+		printf ("Digite, separados por um espaço, dois números a e b: ");
+		scanf ("%d %d", &a, &b);
+		if (has_0 (a) == true || has_0 (b) == true)
+			printf ("Valor inválido detectado.\n");
+	}
+
+	for (i = 0; i <= 9; i++) {
+		if (digit_count (i,a) == digit_count (i,b))
+			continue;
+		printf ("%d não é uma permutação de %d.\n", a, b);
+		return 0;
+	}
+
+	printf ("%d é uma permutação de %d.\n", a, b);
+	return 0;
+}
--- a/Exercícios/16/soma_primos.c
+++ b/Exercícios/16/soma_primos.c
@ -0,0 +1,43 @@
+# include <stdio.h>
+# define true 1
+# define false 0
+
+int is_prime (int num) {
+	int i, cont = 0;
+	if (num == 0)
+		return false;
+	for (i = 1; i <= num; i++)
+		if (num % i == 0)
+			cont++;
+	if (cont == 2)
+		return true;
+	return false;
+}
+
+int main () {
+	int i, j, n = 0, found = false;
+	printf ("Este programa calcula se um dado número n, positivo e não nulo, pode ser representado pela soma de dois números primos.\n");
+
+	while (n <= 0) {
+		printf ("Dê um valor para n: ");
+		scanf ("%d", &n);
+		if (n <= 0)
+			printf ("Valor inválido.\n");
+	}
+
+	for (i = 2; i < n; i++) {
+		if (is_prime(i) == false)
+			continue;
+		for (j = 2; j < n; j++){
+			if (is_prime(j) == false || i + j != n)
+				continue;
+			printf ("%d + %d = %d\n", i, j, n);
+			found = true;
+		}
+			
+	}
+	
+	if (found == false)
+		printf ("Não é possível obter %d à partir da soma de números primos.\n", n);
+	return 0;
+}
--- a/Exercícios/17/mmc.c
+++ b/Exercícios/17/mmc.c
@ -0,0 +1,43 @@
+# include <stdio.h>
+
+int mdc (int a, int b) {
+	int i, limite;
+	if (a > b)
+		limite = a;
+	else
+		limite = b;
+	for (i = 1; i <= limite; i++) {
+		if (a % i == 0 || a % i == 0)
+			return i;
+	}
+	return 0;
+}
+
+int main () {
+	int m = -1, n = -1, mmc;
+	printf ("Este programa calcula o mínimo múltiplo comum (mmc) entre dois números inteiros e positivos m e n.\n");
+	while (m < 0 || n < 0) {
+		printf ("Digite valores para m e n, respectivamente, divididos por espaço: ");
+		scanf ("%d %d", &m, &n);
+		if (m < 0 || n < 0)
+			printf ("Valor inválido detectado.\n");
+	}
+
+	if (mdc(m,n) == 0) {
+		if (m == 0 && n == 0)
+			printf ("mmc = 0\n");
+		else
+			printf ("Não há mmc entre %d e %d\n", m, n);
+		return 0;
+	}
+
+	if (m > n)
+		mmc = m;
+	else
+		mmc = n;
+	while (mmc % m != 0 || mmc % n != 0)
+		mmc++;
+
+	printf ("mmc = %d\n", mmc);
+	return 0;	
+}
--- a/Exercícios/17/palindromo.c
+++ b/Exercícios/17/palindromo.c
@ -0,0 +1,36 @@
+# include <stdio.h>
+# define true 1
+# define false 0
+
+void palindromo (int * number, int * first, int * last) {
+	int pot = 10;
+	* first = 0;
+	* last = * number % 10;
+	while (* number != 0) {
+		* first = * number % 10;
+		* number /= 10;
+		pot *= 10;
+	}
+	* number = * number % pot / 10;
+}
+
+int main () {
+	int n, n_2, f, l, is_palindromo = true;
+	printf ("Este programa verifica se um número inteiro n é palíndromo.\n");
+	printf ("Dê um valor para n: ");
+	scanf ("%d", &n);
+	n_2 = n;
+	while (n_2 != 0) {
+		palindromo (&n_2, &f, &l);
+		if (f == l)
+			continue;
+		is_palindromo = false;
+		break;
+	}
+
+	if (is_palindromo == true)
+		printf ("O número %d é palíndromo.\n", n);
+	else
+		printf ("O número %d não é palíndromo.\n", n);
+	return 0;	
+}
--- a/Exercícios/17/polar.c
+++ b/Exercícios/17/polar.c
@ -0,0 +1,41 @@
+# include <stdio.h>
+# include <math.h>
+# define pi 3.14159265358979323846
+
+void polar (float x, float y, float * raio, float * angulo) {
+	* raio = sqrt(pow(x, 2) + pow(y, 2));
+
+	if (x == 0 && y != 0) {
+		if (y > 0)
+			* angulo = pi / 2;
+		else
+			* angulo = 3 * pi / 2;
+	}
+
+	else if (y == 0 && x != 0) {
+		if (x > 0)
+			* angulo = 0;
+		else
+			* angulo = pi;
+	}
+
+	else {
+		* angulo = atan (y/x);
+		if (x < 0 && y > 0)
+			* angulo  = pi - * angulo;
+		else if (x < 0 && y < 0)
+			* angulo += pi;
+		else if (x > 0 && y < 0)
+			* angulo = 2 * pi - * angulo;
+	}
+}
+
+int main () {
+	float x, y, r, s;
+	printf ("Este programa converte a coordenada cartesiana (x, y) em coordenada polar (r, s).\n");
+	printf ("Digite valores para x e y, respectivamente, separados por um espaço: ");
+	scanf ("%f %f", &x, &y);
+	polar (x, y, &r, &s);
+	printf ("O valor (%f, %f), em coordenada cartesiana, equivalem à (%f, %f), em coordenada polar.\n", x, y, r, s);
+	return 0;
+}
--- a/Exercícios/17/raizes.c
+++ b/Exercícios/17/raizes.c
@ -0,0 +1,24 @@
+# include <stdio.h>
+# include <math.h>
+
+int main () {
+	float a, b, c, delta, r_1, r_2;
+
+	printf ("Este programa encontra as raízes reais de uma equação do segundo grau ax^2 + bx + c = 0, para quaisquer valores de a, b e c.\n");
+	printf ("Dê valores para a, b e c, respectivamente, separados por espaços: ");
+	scanf ("%f %f %f", &a, &b, &c);
+
+	delta = pow(b,2) - 4 * a * c;
+
+	if (delta < 0)
+		printf ("%fx^2 + (%f)x + (%f) = 0 não possui raízes reais.\n", a, b, c);
+	else {
+		r_1 = (- b + sqrt(delta)) / (2 * a);
+		r_2 = (- b - sqrt(delta)) / (2 * a);
+		if (r_1 == r_2)
+			printf ("%fx^2 + (%f)x + (%f) = 0 possui uma única raiz real: %f\n", a, b, c, r_1);
+		else
+			printf ("%fx^2 + (%f)x + (%f) = 0 possui duas raizes reais: %f e %f\n", a, b, c, r_1, r_2);
+	}
+	return 0;
+}
--- a/Exercícios/17/soma_bin.c
+++ b/Exercícios/17/soma_bin.c
@ -0,0 +1,67 @@
+# include <stdio.h>
+# include <math.h>
+# define true 1
+# define false 0
+
+int is_bin (int bin) {
+	if (bin < 0)
+		bin = -bin;
+	while (bin != 0) {
+		if (bin % 10 > 1)
+			return false;
+		bin /= 10;
+	}
+	return true;
+}
+
+int base2_to_base10 (int bin) {
+	int i = fabs((float)bin), pot = 1, result = 0;
+	while (i != 0) {
+		result = result + i % 10 * pot; 
+		i = i / 10;
+		pot = pot * 2;		
+	}
+	if (bin < 0)
+		return -result;
+	return result;
+}
+
+int base10_to_base2 (int num) {
+	int i = fabs((float)num), j, pot, result = 0;
+	while (i != 0) {
+		j = 1;
+		pot = 1;
+		if (i > 1){
+			while (j * 2 <= i) {
+				j *= 2;
+				pot *= 10;
+			}
+		}
+		i -= j;
+		result += pot;
+	}
+	if (num < 0)
+		return -result;
+	return result;
+}
+
+int main () {
+	int bin_1 = 0, bin_2 = 0, test = false;
+
+	printf ("Este programa calcula a soma entre dois números binários, sejam estes positivos ou negativos (indicados pelo sinal de menos).\n");
+	
+	while (test == false) {
+		printf ("Digite dois números binários separados por espaço: ");
+		scanf ("%d %d", &bin_1, &bin_2);
+		if (is_bin(bin_1) == false)
+			printf ("O número %d não é binário.\n", bin_1);
+		if (is_bin(bin_2) == false)
+				printf ("O número %d não é binário.\n", bin_2);
+		if (is_bin(bin_1) == true && is_bin(bin_2) == true)
+				test = true;
+	}
+
+	printf ("(%d) + (%d) = %d\n", bin_1, bin_2, base10_to_base2(base2_to_base10(bin_1) + base2_to_base10(bin_2)));
+	printf ("Ou, em decimais: (%d) + (%d) = %d\n", base2_to_base10(bin_1), base2_to_base10(bin_2), base2_to_base10(bin_1) + base2_to_base10(bin_2));
+	return 0;
+}
--- a/Exercícios/18/media.c
+++ b/Exercícios/18/media.c
@ -0,0 +1,23 @@
+# include <stdio.h>
+
+int main () {
+	int i, alunos = 0;
+	float notas[3], media, media_geral = 0;
+
+	printf ("Este programa calcula a média ponderada das notas de cada aluno em três provas de peso 1, 2 e 3, respectivamente, e a média aritmética das notas da turma.\n");
+	while (alunos <= 0) {
+		printf ("Digite o número de alunos: ");
+		scanf ("%d", &alunos);
+	}
+
+	for (i = 1; i <= alunos; i++) {
+		printf("Digite as notas do aluno %d nas sucessivas provas, separadas por espaço: ", i);
+		scanf("%f %f %f", &notas[0], &notas[1], &notas[2]);
+		media = (notas[0] + 2 * notas[1] + 3 * notas[2]) / 6;
+		printf ("Média ponderada: %f\n", media);
+		media_geral += media / alunos;
+	}
+
+	printf("Média aritmética da turma: %f\n", media_geral);
+	return 0;	
+}
--- a/Exercícios/18/sequencia.c
+++ b/Exercícios/18/sequencia.c
@ -0,0 +1,27 @@
+# include <stdio.h>
+
+int main () {
+	int i, j, k, inicial, final;
+	float soma, soma_max = 0, v[12];
+
+	printf ("Este programa calcula, para uma sequência de 12 números inteiros, o segmento mais longo de soma máxima.\n");
+	printf ("Digite 12 números, positivos ou negativos, separados uns dos outros por um espaço: ");
+	scanf ("%f %f %f %f %f %f %f %f %f %f %f %f", &v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7], &v[8], &v[9], &v[10], &v[11]);
+
+	 for (i = 0; i < 12; i++) {
+	 	k = 12;
+	 	while (k > i) {
+	 		soma = 0;
+	 		for (j = i; j < k; j++)
+	 			soma += v[j];
+	 		if (soma > soma_max) {
+	 			soma_max = soma;
+	 			inicial = i + 1;
+	 			final = j;
+	 		}
+	 		k--;
+	 	}
+	 }
+	 printf ("O segmento mais longo e de soma máxima é aquele iniciado no %d° número e terminado no %d°, totalizando %f.\n", inicial, final, soma_max);
+	 return 0;
+}
--- a/Exercícios/18/sequencia_2.c
+++ b/Exercícios/18/sequencia_2.c
@ -0,0 +1,34 @@
+# include <stdio.h>
+# include <math.h>
+
+int main () {
+	int i, j, k, l, sequence, selection[4], v[8];
+
+	printf ("Este programa identifica a presença de sequências iguais dentro de uma sequência maior, de 8 números inteiros.\n");
+	printf ("Digite oito números inteiros, separados entre si por espaços: ");
+	scanf ("%d %d %d %d %d %d %d %d", &v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7]);
+
+	for (i = 0; i < 7; i++) {
+		k = 0;
+		for (j = i + 1; j < 8; j++) {
+			if (v[i] != v[j])
+				continue;
+			while (j < 8) {
+				if (v[i] == v[j]) {
+					selection[k] = v[i];
+					i++;
+					j++;
+					k++;
+				}
+				else {
+					sequence = 0;
+					for (l = 0; l < k; l++)
+						sequence += selection[l] * pow(10, k - l - 1);
+					printf ("A sequência \"%d\" se repete à partir dos índices %d e %d\n", sequence, i - k, j - k);
+					break;
+				}
+			}
+		}
+	}	
+	return 0;
+}
--- a/Exercícios/18/sequencia_3.c
+++ b/Exercícios/18/sequencia_3.c
@ -0,0 +1,33 @@
+# include <stdio.h>
+# define true 1
+# define false 0
+
+int main () {
+	int i, j, k, found, inicial[10], final[10];
+	printf ("Este programa reproduz uma sequềncia original de 10 números inteiros excluindo desta números repetidos.\n");
+	printf ("Digite 10 números separados entre si por espaços: ");
+	scanf ("%d %d %d %d %d %d %d %d %d %d", &inicial[0], &inicial[1], &inicial[2], &inicial[3], &inicial[4], &inicial[5], &inicial[6], &inicial[7], &inicial[8], &inicial[9]);
+
+	final[0] = inicial[0];
+	k = 1;
+	for (i = 1; i < 10; i++) {
+		found = false;
+		for (j = 0; j < k; j++) {
+			if (inicial[i] != final[j])
+				continue;
+			found = true;
+			break;
+		}
+		if (found == true)
+			continue;
+		final[k] = inicial[i];
+		k++;
+	}
+
+	printf ("A sequência passada excluidas as repetições: ");
+	for (i = 0; i < k; i++) {
+		printf("%d ", final[i]);
+	}
+	printf ("\n");
+	return 0;
+}
--- a/Exercícios/18/soma_polinômios.c
+++ b/Exercícios/18/soma_polinômios.c
@ -0,0 +1,9 @@
+# include <math.h>
+
+float soma_poli (float v[], float x, int n) {
+	int i;
+	float result = 0;
+	for (i = 0; i < n; i++)
+		result += v[i] * pow(x, i);
+	return result;
+}
--- a/Exercícios/20/caps.c
+++ b/Exercícios/20/caps.c
@ -0,0 +1,13 @@
+#include <stdio.h>
+
+int main() {
+    char i;
+    printf ("Este programa lê um caractere minúsculo e apresenta sua versão maiúscula.\n");
+    printf("Digite um caractere minúsculo e pressione ENTER: ");
+    if (!(scanf(" %c", &i)) || i < 'a' || i > 'z') {
+        printf("Caractere inválido\n");
+        return 1;
+    }
+    printf("→ %c\n", i - ('a' - 'A'));
+    return 0;
+}
--- a/Exercícios/20/comprimento.c
+++ b/Exercícios/20/comprimento.c
@ -0,0 +1,74 @@
+#include <stdio.h>
+#include <locale.h>
+#include <wchar.h>
+
+/* Largura da maior palavra no idioma português, "Pneumoultramicroscopicossilicovulcanoconiótico" */
+#define MAX 46 
+
+int main() {
+
+	setlocale(LC_CTYPE, "pt_BR.UTF-8");
+	wchar_t caractere, palavra[MAX], maiores_palavras[MAX][MAX];
+	int i, maior_comprimento, palavras;
+	i = maior_comprimento = palavras = 0;
+	
+	wprintf (L"Este programa lê uma sequência de texto escrita em português, terminada por uma quebra de linha, e relata a palavra mais longa nesta.\n");
+	wprintf(L"Escreva algo e então pressione ENTER: ");
+	
+	while ((caractere = getwchar()) != WEOF) {
+
+		/* Ler o input caractere por caractere e copiá-lo à string "palavra", até deparar-se com um caractere que não seja uma letra */
+		if ((caractere >= 'A' && caractere <= 'Z')
+        || (caractere >= 'a' && caractere <= 'z')
+        || (caractere >= L'À' && caractere <= L'Ä')
+        || (caractere >= L'à' && caractere <= L'ä')
+        || (caractere >= L'È' && caractere <= L'Ë')
+        || (caractere >= L'è' && caractere <= L'ë')
+        || (caractere >= L'Ì' && caractere <= L'Ï')
+        || (caractere >= L'ì' && caractere <= L'ï')
+        || (caractere >= L'Ò' && caractere <= L'Ö')
+        || (caractere >= L'ò' && caractere <= L'ö')
+        || (caractere >= L'Ù' && caractere <= L'Ü')
+        || (caractere >= L'ù' && caractere <= L'ü')
+        || (caractere == L'ç') || (caractere == L'Ç')
+        ) {
+			palavra[i] = caractere;
+			i++;
+			continue;
+		}
+
+		/* Término da leitura de uma palavra, avaliá-la um função do seu comprimento */
+		if (i >= maior_comprimento && i > 0) {
+
+			/* Se a palavra é a maior até então, armazene seu comprimento e reinicie a contagem de palavras mais longas */
+			if (i > maior_comprimento) {
+				maior_comprimento = i;
+				palavras = 1;
+			}
+
+			/* Se ela for tão longa quanto outra, apenas a adicione a contagem */
+			else
+				palavras++;
+
+			/* Armazene a palavra */
+			palavra[i] = '\0';
+			wcscpy(maiores_palavras[palavras - 1], palavra);
+		}
+		i = 0;
+
+		/* Terminar a leitura ao alcançar a quebra de linha */
+		if (caractere == '\n')
+			break;
+	}
+
+	if (palavras == 0)
+		return 1;
+	if (palavras == 1)
+		wprintf(L"Maior palavra (%d caracteres): %ls\n", maior_comprimento, maiores_palavras[0]);
+	else {
+		wprintf(L"Maiores palavras (%d caracteres):\n", maior_comprimento);
+		for (; i < palavras; i++)
+			wprintf(L"%ls\n", maiores_palavras[i]);
+	}
+	return 0;
+}
--- a/Exercícios/20/mai_min.c
+++ b/Exercícios/20/mai_min.c
@ -0,0 +1,39 @@
+#include <stdio.h>
+#include <locale.h>
+#include <wchar.h>
+
+int main() {
+
+	setlocale(LC_CTYPE, "pt_BR.UTF-8");
+	wchar_t caractere;
+	int maiúsculos, minúsculos;
+	maiúsculos = minúsculos = 0;
+
+	printf("Este programa lê um parágrafo de texto e calcula o número de caracteres maiúsculos e minúsculos neste. Escreva algo e pressione ENTER:\n");
+
+	while ((caractere = getwchar()) != WEOF) {
+		if ((caractere >= 'a' && caractere <= 'z')
+		|| (caractere >= L'à' && caractere <= L'ä')
+		|| (caractere >= L'è' && caractere <= L'ë')
+		|| (caractere >= L'ì' && caractere <= L'ï')
+		|| (caractere >= L'ò' && caractere <= L'ö')
+		|| (caractere >= L'ù' && caractere <= L'ü')
+		|| (caractere == L'ç'))
+			minúsculos++;
+		else if ((caractere >= 'A' && caractere <= 'Z')
+		|| (caractere >= L'À' && caractere <= L'Ä')
+		|| (caractere >= L'È' && caractere <= L'Ë')
+		|| (caractere >= L'Ì' && caractere <= L'Ï')
+		|| (caractere >= L'Ò' && caractere <= L'Ö')
+		|| (caractere >= L'Ù' && caractere <= L'Ü')
+		|| (caractere == L'Ç'))
+			maiúsculos++;
+		else if (caractere == '\n')
+			break;
+	}
+	
+	if (minúsculos == 0 && maiúsculos == 0)
+		return 1;
+	printf("\nMaiúsculos: %d\nMinúsculos: %d\n", maiúsculos, minúsculos);
+	return 0;
+}
--- a/Exercícios/20/tabela_ASCII.c
+++ b/Exercícios/20/tabela_ASCII.c
@ -0,0 +1,16 @@
+#include <stdio.h>
+#include <locale.h>
+#include <wchar.h>
+
+int main() {
+
+	setlocale(LC_ALL, "pt_BR.UTF-8");
+    wchar_t c;
+    wprintf (L"Tabela ASCII (pt_BR.UTC-8)\n");
+    for (c = 32; c < 256; c++){
+    	if (c == 128)
+    		wprintf(L"Tabela ASCII extendida\n");
+        wprintf(L"%03d | %lc\n", c, c);
+    }
+    return 0;
+}
--- a/Exercícios/20/vogais.c
+++ b/Exercícios/20/vogais.c
@ -0,0 +1,47 @@
+#include <stdio.h>
+#include <locale.h>
+#include <wchar.h>
+
+int main() {
+
+	setlocale(LC_CTYPE, "pt_BR.UTF-8");
+    int vowel_count, character_count, i, j, accent;
+    wchar_t character, vowel[] = {'a', 'e', 'i', 'o', 'u', L'à', L'è', L'ì', L'ò', L'ù', L'ä', L'ë', L'ï', L'ö', L'ü'};
+    vowel_count = character_count = 0;
+
+    printf ("Este programa lê uma sequência de texto escrita em português, terminada por uma quebra de linha, e relata a frequência relativa de vogais pelo total de caracteres desta.\n");
+    printf("Escreva algo e então pressione ENTER: ");
+
+    while ((character = getwchar()) != WEOF && character != '\n') {
+        if (!((character >= 'A' && character <= 'Z')
+        || (character >= 'a' && character <= 'z')
+        || (character >= L'À' && character <= L'Ä')
+        || (character >= L'à' && character <= L'ä')
+        || (character >= L'È' && character <= L'Ë')
+        || (character >= L'è' && character <= L'ë')
+        || (character >= L'Ì' && character <= L'Ï')
+        || (character >= L'ì' && character <= L'ï')
+        || (character >= L'Ò' && character <= L'Ö')
+        || (character >= L'ò' && character <= L'ö')
+        || (character >= L'Ù' && character <= L'Ü')
+        || (character >= L'ù' && character <= L'ü')
+        || (character == L'ç') || (character == L'Ç')
+        ))
+            continue;
+        character_count++;
+
+        for (i = 0; i < 10; i++){
+            accent = (i < 5) ? i : i + 5;
+            for (j = 0; j <= vowel[accent] - vowel[i]; j++) {
+                if (character == vowel[i] + j
+                || character == vowel[i] + j - ('a' - 'A')) {
+                    vowel_count++;
+                    break;
+                }
+            }
+        }
+    }        
+
+    printf("Frequência de vogais = %d / %d\n", vowel_count, character_count);
+    return 0;
+}
--- a/Exercícios/20/word_count.c
+++ b/Exercícios/20/word_count.c
@ -0,0 +1,47 @@
+#include <stdio.h>
+#include <locale.h>
+#include <wchar.h>
+
+# define TRUE 1
+# define FALSE 0
+
+int main() {
+
+	setlocale(LC_CTYPE, "pt_BR.UTF-8");
+	wchar_t caractere;
+	int letras, palavra, palavras;
+	letras = palavra = palavras = 0;
+
+	printf("Este programa lê um paragrafo de texto e contabiliza o número de letras e palavras neste. Escreva algo e então pressione ENTER:\n");
+
+	while ((caractere = getwchar()) != WEOF) {
+		if (caractere != ' ' && caractere != '\n') {
+			palavra = TRUE;
+			if ((caractere >= 'A' && caractere <= 'Z')
+	        || (caractere >= 'a' && caractere <= 'z')
+	        || (caractere >= L'À' && caractere <= L'Ä')
+	        || (caractere >= L'à' && caractere <= L'ä')
+	        || (caractere >= L'È' && caractere <= L'Ë')
+	        || (caractere >= L'è' && caractere <= L'ë')
+	        || (caractere >= L'Ì' && caractere <= L'Ï')
+	        || (caractere >= L'ì' && caractere <= L'ï')
+	        || (caractere >= L'Ò' && caractere <= L'Ö')
+	        || (caractere >= L'ò' && caractere <= L'ö')
+	        || (caractere >= L'Ù' && caractere <= L'Ü')
+	        || (caractere >= L'ù' && caractere <= L'ü')
+	        || (caractere == L'ç') || (caractere == L'Ç'))
+	        	letras++;
+		}
+		else if (palavra == TRUE) {
+			palavras++;
+			palavra = FALSE;
+		}
+		if (caractere == '\n')
+			break;
+	}
+
+	if (letras == 0 && palavras == 0)
+		return 1;
+	printf("\nLetras: %d\nPalavras: %d\n", letras, palavras);
+	return 0;
+}
--- a/Exercícios/21/all_caps.c
+++ b/Exercícios/21/all_caps.c
@ -0,0 +1,35 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <locale.h>
+#include <wchar.h>
+
+int main () {
+
+    int i, size = 1;
+    wchar_t character, * output;
+    output = (wchar_t *) malloc (sizeof(wchar_t));
+
+
+    setlocale(LC_CTYPE, "pt_BR.UTF-8");
+    wprintf(L"Este programa lê um dado texto e devolve ele próprio em caixa-alta. Escreva algo:\n");
+
+    for (i = 0; (character = getwchar()) != WEOF && character != '\n'; i++) {
+        if (i + 1 == size) {
+            size *= 2;
+            output = (wchar_t *) realloc (output, size * sizeof(wchar_t));
+        }
+        if ((character >= 'a' && character <= 'z')
+        || (character >= L'à' && character <= L'ä')
+        || (character >= L'è' && character <= L'ë')
+        || (character >= L'ì' && character <= L'ï')
+        || (character >= L'ò' && character <= L'ö')
+        || (character >= L'ù' && character <= L'ü')
+        || (character == L'ç'))
+            character -= 'a' - 'A';
+
+        output[i] = character;
+    }
+    output[i] = '\0';
+    wprintf (L"%ls\n", output);
+    return 0;
+}
--- a/Exercícios/21/find_str.c
+++ b/Exercícios/21/find_str.c
@ -0,0 +1,46 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <locale.h>
+#include <wchar.h>
+
+int main () {
+
+    int i, j, found = 0, size;
+    wchar_t character, ** strings;
+    strings = (wchar_t **) malloc (2 * sizeof(wchar_t *));
+
+    setlocale(LC_CTYPE, "pt_BR.UTF-8");
+    wprintf(L"Este programa contabiliza o número de ocorrências de um termo em um texto, com distinção entre letras maiúsculas e minúsculas.\n");
+
+    /* Leitura dos parâmetros */
+    for (i = 0; i < 2; i++) {
+        size = 1;
+        strings[i] = (wchar_t *) malloc (sizeof(wchar_t));
+
+        if (i == 0)
+            wprintf(L"Digite um termo a ser contabilizado: ");
+        else
+            wprintf(L"Digite um texto no qual buscá-lo: ");
+
+        for (j = 0; (character = getwchar()) != WEOF && character != '\n'; j++) {
+            if (j + 1 == size) {
+                size *= 2;
+                strings[i] = (wchar_t *) realloc (strings[i], size * sizeof(wchar_t));
+            }
+            strings[i][j] = character;
+        }
+        strings[i][j] = '\0';
+    }
+
+    /* Comparação dos parâmetros */
+    size = wcslen(strings[0]);
+    for (i = 0; strings[1][i] != '\0'; i++)
+        for (j = 0; strings[0][j] != '\0'
+        && strings[0][j] == strings[1][i + j]; j++)
+            if (j == size - 1)
+                found++;
+
+    /* Retorno e término do programa */
+    wprintf(L"Número de ocorrências de \"%ls\" em \"%ls\": %d\n", strings[0], strings[1], found);
+    return 0;
+}
--- a/Exercícios/22/mult_matriz.c
+++ b/Exercícios/22/mult_matriz.c
@ -0,0 +1,55 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+void read_matrix(double ** matrix, int * x, int * y) {
+    int i, j, j_max = 0, lin, col;
+    char div;
+    lin = col = 1;
+
+    /* Inicializa a matriz (vetor de vetores) antes do loop começar e, após este ter iniciado, redimenciona o número de linhas (vetores) conforme estas são acrescentadas */
+    matrix = (double **) malloc (sizeof(double *));
+    for (i = 0; div != '\n' || j != 0; i++){
+        if (i == lin) {
+            lin *= 2;
+            matrix = (double **) realloc (matrix, lin * sizeof(double *));
+        }
+
+        /* Inicializa a linha (vetor) antes do loop começar e, após este ter iniciado, redimenciona o número de colunas (índices) conforme estas são acrescentadas*/
+        matrix[i] = (double *) malloc (col * sizeof(double *));
+        for (j = 0; div != '\n'; j++) {
+            if (j == col) {
+                col *= 2;
+                matrix[i] = (double *) realloc (matrix[i], col * sizeof(double));
+            }
+
+            if (scanf("%d%c\n", &matrix[i][j], &div)) {
+                if (j > j_max)
+                    j_max = j;
+                if (div == '\n')
+                    break;
+            }
+            else {
+                if (j > 0 && j < j_max)
+                    for (; j <= j_max; j++)
+                        matrix[i][j] = 0;
+                *x = i;
+                *y = j_max + 1;
+                return
+            }
+        }
+    }
+}
+
+int main () {
+    int i, lenght, xa, ya, xb, yb;
+    double ** matrixA, **matrixB;
+    printf("Este programa lê duas matrizes e devolve o resultado da multiplicação destas. Digite, separados por espaços, os valores a serem armazenados na matriz. Pressione ENTER para iniciar uma nova linha, e pressione ENTER duas vezes para encerrar a matriz.\n");
+    for (i = 0; i < 2; i++){
+        printf("Descreva a %dª matriz\n", i + 1);
+        if (i == 0)
+            read_matrix (matrixA, &xa, &ya);
+        else
+            read_matrix (matrixB, &xb, &yb)/
+    }
+    return 0;
+}
--- a/Exercícios/22/pascal.c
+++ b/Exercícios/22/pascal.c
@ -0,0 +1,44 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main () {
+    int i, j, k, n, width, max, ** pascal;
+    width = k = 0;
+
+    printf("Este programa imprime as primeiras n linhas do triângulo de pascal.\nDê um valor positivo e não nulo para n: ");
+    if (!(scanf("%d", &n)) || n <= 0){
+        printf("Valor inválido\n");
+        return 1;
+    }
+
+    pascal = (int **) malloc (n * sizeof(int *));
+    for (i = 0; i < n; i++) {
+        pascal[i] = (int *) malloc (n * sizeof(int));
+    }
+
+    for (i = 0; i < n; i++) {
+        for (j = 0; j <= k; j++) {
+            if (i - 1 < 0 || j - 1 < 0 || j == k)
+                pascal[i][j] = 1;
+            else
+                pascal[i][j] = pascal[i - 1][j - 1] + pascal[i - 1][j];
+        }
+        k++;
+    }
+
+    max = pascal[i - 1][k / 2];
+    while (max != 0) {
+        width++;
+        max /= 10;
+    }
+
+    k = 0;
+    printf("\n");
+    for (i = 0; i < n; i++) {
+        for (j = 0; j <= k; j++)
+            printf("%*d ", width, pascal[i][j]);
+        printf("\n");
+        k++;
+    }
+    return 0;
+}
--- a/README.md
+++ b/README.md
@ -0,0 +1,3 @@
+# Introdução a Ciência da Computação
+
+Repositório de [resumos](Resumos) e [exercícios](Exerc%C3%ADcios) feitos à partir da leitura da referida [apostila](http://www.ime.usp.br/~hitoshi/introducao/).
--- a/computador.md
+++ b/computador.md
@ -0,0 +1,105 @@
+# Como funciona um computador
+
+## As partes de um computador
+
+A maioria dos computadores encaixa-se na descrição denominada "**arquitetura de von Neumann**", que os descreve enquanto um conjunto de três partes principais ligadas entre si por cabos (o "**barramento**"):
+
+- Unidade Central de Processamento (UCP, ou *CPU*);
+
+- Memória;
+
+- Dispositivos de Entrada e Saída.
+
+<img src="file:///home/user/Documents/Drives/USP/Transferência%20Interna/01%20-%20Introdução%20a%20Ciência%20da%20Computação/Resumos/Imagens/2021-03-30-21-52-08-image.png" title="" alt="" data-align="center">
+
+> Esquematização da arquitetura de von Neumann
+
+### Unidade Central de Processamento (UCP, ou *CPU*)
+
+De forma geral, a CPU pode ser compreendida em duas partes relacionadas entre si:
+
+#### Unidade Lógica e Aritmética (ULA)
+
+O componente que realiza
+
+- operações aritméticas, como somas e subtrações;
+
+- comparações, como *igual* ou *maior que*.
+
+#### Unidade de Controle (UC)
+
+O componente que lê as instruções e dados da **memória**, ou dos **dispositivos de entrada**, decodifica-os e, segundo estes,
+
+- alimenta dados à ULA, nas entradas adequadas;
+
+- recebe resultados da ULA e os encaminha à **memória** ou aos **dispositivos de saída**.
+
+##### Registradores
+
+Circuitos digitais da UC capazes de armazenar e deslocar informações binárias, tipicamente usados como dispositivos de armazenamento temporário. Alguns registros são particularmente importantes:
+
+- O **Contador de Programa** (*Program Counter*, ou *PC*), que armazena o endereço de uma dada instrução corrente, assim permitindo que esta seja realizada múltiplas vezes (isto é, até esta mesma indicar o endereço de uma instrução seguinte);
+
+- O **Registrador de Instruções (RI)**, que define a operação a ser executada.
+
+<img src="file:///home/user/Documents/Drives/USP/Transferência%20Interna/01%20-%20Introdução%20a%20Ciência%20da%20Computação/Resumos/Imagens/a1856b5e80d31b9b0e1c532abcc4a1b97ffd0f2f.png" title="" alt="" data-align="center">
+
+> Esquematização da integração entre ULA e UCP
+
+#### Microprocessadores
+
+Desde a década de 1980, os componentes da CPU encontram-se inseridos em um único circuito: o **microprocessador**. Cada microprocessador possui um conjunto de instruções finito, executado a uma determinada frequência[^1], em um ciclo infinito — ou até que o computador seja desligado.
+
+<img title="" src="file:///home/user/Documents/Drives/USP/Transferência%20Interna/01 - Introdução a Ciência da Computação/Resumos/Imagens/0587b4f3cf045d37f3d1136da10fd9275d48b2f3.JPG" alt="" data-align="center">
+
+> Microprocessador Athlon XP 1800+
+
+### Memória
+
+Conceitualmente, a memória do computador pode ser vista como uma lista de células, numeradas sequencialmente, capaz de armazenar uma quantidade fixa e pequena de informação. A numeração de uma célula corresponde ao seu **endereço**.
+
+A **informação** armazenada pode ser de **dois tipos**:
+
+- instruções, as quais descrevem a execução de uma função do computador;
+
+- dados, os quais são processados da realização de instruções.
+
+Enquanto a memória pode ser classificada em dois grupos:
+
+- **voláteis** (tipo *RAM ‒ Random Access Memory*), as quais necessitam ser abastecidas com energia para manter seu conteúdo (ou seja, que só funcionam enquanto o computador estiver ligado);
+
+<img src="file:///home/user/Documents/Drives/USP/Transferência%20Interna/01%20-%20Introdução%20a%20Ciência%20da%20Computação/Resumos/Imagens/824f897975e229bdbfe16beb171ee01e267000db.png" title="" alt="" data-align="center">
+
+> Chips de memória RAM
+
+- e **não voláteis**, que não necessitam, como o disco rígido.
+
+<img src="file:///home/user/Documents/Drives/USP/Transferência%20Interna/01%20-%20Introdução%20a%20Ciência%20da%20Computação/Resumos/Imagens/2021-03-30-22-13-11-image.png" title="" alt="" data-align="center">
+
+> Um disco rígido moderno aberto
+
+A memória não volátil possui maior capacidade de armazenamento e é relativamente mais barata, por volume de informação; não obstante, a memória RAM pode ser reescrita muito mais rapidamente, tornando possível o computador realizar o processamento de informações de forma mais eficiente.
+
+### Dispositivos de Entrada e Saída - E/S[^2]
+
+Os dispositivos aqueles por meio dos quais o computador recebe e emite, respectivamente, informação ao meio que o circunda. Alguns destes, como discos rígidos e placas de rede, que permitem conexões entre computadores, podem atuar tanto como dispositivos de entrada como de saída.
+
+<img src="file:///home/user/Documents/Drives/USP/Transferência%20Interna/01%20-%20Introdução%20a%20Ciência%20da%20Computação/Resumos/Imagens/3f1634311dffcc6d793fd5fb64d837fcd7f606ca.jpg" title="" alt="" data-align="center">
+
+> Placa de rede Wi-Fi com antena, soldada em outro componente.
+
+## Linguagens de programação
+
+Uma **linguagem de programação** é um método de escrita padronizado, formando um conjunto de regras sintáticas e semânticas, por meio do qual **algoritmos** —um conjunto de instruções finitas, executáveis, e não ambíguas — são descritos. Um texto escrito em linguagem de programação é denominado **código-fonte**. Esse pode ser traduzido em um conjunto de instruções de processamento executável por um computador (isto é, um programa, ou *software*), por meio de um programa denominado **compilador**; ou mesmo ser lido e executado pelo computador após ser por este **interpretado**, como é o caso com *scripts*.
+
+Uma das principais metas das linguagens de programação é que programadores tenham uma maior produtividade, permitindo expressar suas intenções mais facilmente do que quando comparado com a linguagem que um computador entende nativamente (código de máquina). Assim, linguagens de programação são projetadas para adotar uma sintaxe de **nível mais alto**, que pode ser mais facilmente entendida por programadores humanos.
+
+## Distinção entre *Hardware* e *Software*
+
+O ***hardware*** é um termo técnico (e anglicismo de engenharia eletrônica e engenharia mecânica) que foi traduzido para a língua portuguesa como **equipamento**, pode ser definido como um termo geral da língua inglesa que se refere a equipamentos físicos como chaves, fechaduras, dobradiças, etc. Este é bastante utilizado no âmbito da engenharia de computação para referir-se ao conjunto dos componentes do computador: a CPU, a memória, os dispositivos de entrada e saída.
+
+Enquanto o ***software*** é a parte "lógica": o conjunto de instruções e dados processados pelos circuitos eletrônicos do *hardware*.
+
+[^1]: Usualmente entre 1 e 3 GHz (Giga Hertz)
+
+[^2]: Ou i/o ‒*input/output*
--- a/Fundamentos.md
+++ b/Fundamentos.md
@ -0,0 +1,126 @@
+# Fundamentos
+
+## Declaração de variáveis
+
+A declaração de uma variável que guarda números inteiros em C de nome `num` é feita da seguinte forma:
+
+```c
+int num;
+```
+
+É possível declarar mais de uma variável em um único comando:
+
+```c
+int num1, num2, num3;
+```
+
+## Expressões aritméticas
+
+As expressões matemáticas envolvendo números inteiros e pelo menos um dos seguintes operadores:
+
+- **Soma:** `num1 + num2`
+
+- **Subtração:** `num1 - num2`
+
+- **Multiplicação:** `num1 * num2`
+
+- **Quociente de uma divisão inteira:** `num1 / num2`
+
+- **Resto de uma divisão inteira:** `num1 % num2`
+
+> Onde `num1` e `num2` podem ser tanto variáveis inteiras, ou números, ou outras expressões aritméticas.
+
+### Precedência de operadores
+
+Expressões aritméticas são calculadas *uma a uma*[^1], da esquerda para a direita, sendo que os operadores `*`, `/` e `%` são calculados antes de `+` e `-`. O uso de parenteses pode ser feito para separar expressões aritméticas distintas.
+
+## Expressão relacional
+
+As expressões que envolvem comparações simples, de resultado **verdadeiro** ou **falso**, por meio dos seguintes operadores:
+
+- **Menor:** <
+
+- **Maior:** >
+
+- **Menor ou igual:** <=
+
+- **Maior ou igual:** >=
+
+- **Diferente:** !=
+
+- **Igual:** ==
+
+## Leitura do teclado
+
+O comando `scanf` pode ser utilizado para armazenar um número inteiro fornecido pelo usuário em uma variável `num` quando descrito da seguinte forma:
+
+```c
+scanf ("%d", &num);
+```
+
+Não obstante, é possível armazenar mais de um número, os quais o usuário fornece cada qual separadamente (seja por espaços brancos, ou quebras de linha):
+
+```c
+scanf ("%d %d %d", &num1, &num2, num3);
+```
+
+## Impressão na tela
+
+A impressão de uma mensagem na tela pode ser feita pelo comando `printf`, da seguinte forma:
+
+```c
+printf ("mensagem");
+```
+
+### Caracteres especiais
+
+#### `%d`
+
+É substituído na mensagem impressa pelo resultado de expressões aritméticas subsequentes contidas no printf e separadas por vírgula. Por exemplo, para
+
+```c
+printf ("A soma dos números %d e %d é %d.\n", 12, 23, 35);
+```
+
+a mensagem impressa será
+
+```
+A soma dos números 12 e 23 é 35.
+```
+
+#### `\n`
+
+Caractere que indica uma quebra de linha. Por exemplo, para
+
+```c
+printf ("Linha 1\nLinha 2\n")
+```
+
+a mensagem impressa será
+
+```
+Linha 1
+Linha 2
+```
+
+## Atribuição
+
+O armazenamento em **uma** variável (previamente declarada) do resultado de uma expressão aritmética. Por exemplo, em
+
+```c
+int soma;
+soma = 3 + 2;
+```
+
+Armazena-se o valor inteiro `5` na variável `soma`.
+
+### Atribuição e comparação
+
+Note a diferença entre o operador de atribuição `=` e o operador relacional `==`. Observe os comandos:
+
+1. `a = b`
+2. `a == b`
+
+O primeiro armazena o conteúdo da variável `b` na variável `a`. O segundo, com significado bem diferente, compara se o conteúdo da variável `a` é igual ao conteúdo da variável `b`.
+
+[^1]: Por exemplo, o valor da expressão (3/4 * 100*) é **zero**. Como todas as operações são inteiras, o resultado de 3/4 é zero (e não 0.75, que é um número real), e multiplicado por 100 continua sendo zero. Isso, mesmo que, intuitivamente, fosse a presença de números reais como um todo permitida, o resultado ao final fosse outro numero inteiro: 75.
--- a/Resumos/04
+++ b/Resumos/04
@ -0,0 +1,14 @@
+# Comando de repetição: *while*
+
+## Descrição e sintaxe
+
+O `while` é um comando que executa outros comandos repetidamente, enquanto uma dada condição for **verdadeira**. Sua sintaxe pode ser descrita por:
+
+```c
+while (<condição>) {
+    <comando_1>;
+    <comando_2>;
+    ...
+    <comando_n>;
+}
+```
--- a/composta.md
+++ b/composta.md
@ -0,0 +1,47 @@
+# Comando de seleção simples e composta
+
+## Sintaxe
+
+### Seleção simples
+
+```c
+if (<condição>)
+    <comando>;
+```
+
+ou
+
+```c
+if (<condição>) {
+    <comando_1>
+    <comando_2>
+    ...
+    <comando_n>
+}
+```
+
+### Seleção composta
+
+```c
+if (<condição>)
+    <comando>;
+else
+    <comando>;
+```
+
+ou
+
+```c
+if (<condição>) {
+    <comando_1>
+    <comando_2>
+    ...
+    <comando_n>
+}
+else {
+    <comando_n+1>
+    <comando_n+2>
+    ...
+    <comando_n+k>
+}
+```
--- a/inteiros.md
+++ b/inteiros.md
@ -0,0 +1,31 @@
+# Sobre a divisão e resto de números inteiros
+
+## Divisão inteira
+
+Sabe-se que o resultado de uma divisão inteira é, sempre, um número inteiro. Assim, o resultado de 
+
+- `3 / 4 = 0`;
+
+- `9 / 4 = 2`;
+
+- `9 / 2 = 4`;
+
+- etc.
+
+Ou seja, a parte fracionária é simplesmente eliminada, ou "**truncada**".
+
+Não obstante, existem situações em que é a necessidade de se manipular os dígitos de um número inteiro e, nestas, pode ser útil dividir um número por um múltiplo de 10. Por exemplo, qualquer número de dois ou mais dígitos terá truncado seu último dígito ao ser dividido por 10, ou seus dois últimos dígitos ao ser dividido por 100, e assim por diante.
+
+## Resto de uma divisão inteira
+
+Como visto anteriormente, a operação `a % b` resulta no resto da divisão de `a` por `b`. Tal que:
+
+- `10 % 4 = 2`;
+
+- `3 % 10 = 3`;
+
+- `3 % 2 = 1`;
+
+- etc.
+
+Ou seja, esta operação pode ser utilizada, dividindo-se por um múltiplo de 10 para **extrair** (em vez de truncar) os últimos dígitos de um número. Feito este procedimento com o último digito de um número, pode-se determinar se este número é par ou ímpar se o resto da divisão do dígito por 2 é 0 ou 1, respectivamente.
--- a/Resumos/07
+++ b/Resumos/07
@ -0,0 +1,52 @@
+# Mais detalhes sobre a linguagem C
+
+## Abreviaturas do comando de atribuição
+
+- `num = num + 1` é equivalente à `num++`, tal qual `num--` implica `num = num - 1`;
+
+- `soma = soma + num` pode ser abreviado como `soma += num`, tal qual
+  
+  - `mult = mult * num` :arrow_right: `mult *= num`;
+  
+  - `div = div / num` :arrow_right: `div /= num`;
+  
+  - `rest %= rest * num` :arrow_right: `rest %= num`.
+
+## Atribuição múltipla
+
+```c
+i = 0;
+soma = 0;
+count = 0;
+```
+
+Pode ser abreviado como
+
+```c
+i = soma = count = 0;
+```
+
+Tendo em vista que atribuições são lidas da **direita** para a **esquerda**.
+
+## Atribuição na declaração de variáveis
+
+```c
+int num, soma, n;
+num = 0;
+soma = 0;
+```
+
+Pode ser abreviado como
+
+```c
+int num = 0, soma = 0, n;
+```
+
+## Definição de constantes
+
+É possı́vel definir constantes na linguagem C. Uma constante em um programa é um valor que não muda durante a sua execução. Diferente de uma variável, que durante a execução do programa pode assumir diferentes valores. Os seguintes comandos definem duas constantes, `ZERO` e `UM` de valor 0 e 1, respectivamente.
+
+```c
+# define true 1
+# define false 0
+```
--- a/lógicos.md
+++ b/lógicos.md
@ -0,0 +1,3 @@
+# Operadores lógicos
+
+Na linguagem C, em um comando de comparação, os operadores `&&` e `||` indicam, respectivamente, **e** e **ou**.
--- a/programação.md
+++ b/programação.md
@ -0,0 +1,85 @@
+# Dicas de programação
+
+## Padrões de programação
+
+Denomina-se um padrão o trecho de código-fonte que tem uma utilidade bem definida e, para tal, pode ser reutilizado noutros contextos.
+
+### Padrão sequência numérica lida
+
+Denominação dada ao padrão utilizado para a obtenção de valores à partir da leitura do teclado. Por exemplo:
+
+```c
+...
+printf ("Digite um número: ");
+scanf ("%d", &num);
+...
+```
+
+### Padrão sequência numérica gerada
+
+Denominação dada ao padrão utilizado para a geração de valores. Por exemplo:
+
+```c
+if (n < 2)
+    fatorial = 1;
+else
+    fatorial = n;
+while (n > 2) {
+    n--;
+    fatorial *= n;
+}
+```
+
+### Padrão sequência numérica selecionada
+
+Denominação dada ao padrão que seleciona uma amostra de números dentre aqueles gerados por um padrão de repetição. Por exemplo:
+
+```c
+while (cont < n) {
+    j = 1;
+    soma = 0;
+    while (j < i) {
+        if (i % j == 0)
+            soma += j;
+        j++;
+    }
+    if (soma == i) {
+        printf ("%d ", i);
+        cont++;
+    }
+    i++;
+}
+```
+
+### Padrão sequência numérica alternadamente selecionada
+
+Denominação dada ao padrão que seleciona **mais de uma** amostra de números dentre aqueles gerados por um padrão de repetição. Por exemplo:
+
+```c
+# include <stdio.h>
+
+int main () {
+    int n = 0, i = 1, soma_pares = 0, quant_impares = 0;
+    printf ("Este programa determina, para uma sequência de n números positivos consecutivos, inteiros, iniciada em 1, a soma dos números pares e a quantidade de números ímpares.\n");
+
+    while (n <= 0) {
+        printf ("Digite um valor para n: ");
+        scanf ("%d", &n);
+        if (n <= 0)
+            printf ("Valor inválido.\n");
+    }
+
+    printf ("Soma dos números pares: ");
+    while (i <= n) {
+        if (i % 2 == 0) {
+            if (i != 2)
+                printf (" + ");
+            printf ("%d", i);
+            soma_pares += i;
+        }
+    }
+
+    printf (" = %d\nQuantidade de número ímpares: %d\n", soma_pares, quant_impares);
+    return 0;
+}
+```
--- a/Resumos/10
+++ b/Resumos/10
@ -0,0 +1,18 @@
+# Comando de repetição *for*
+
+## Motivação
+
+O comando for trata-se de uma versão compacta do `while`, a ser utilizado em situações envolvendo repetições com um contador inicial e o incremento deste após cada iteração do bloco de comandos descrito pelo `for`.
+
+## Sintaxe
+
+```c
+for (<inicialização do contador>; <condição para iteração>; <incremento ou decremento do contador>) {
+    <comando_1>;
+    <comando_2>;
+    ...
+    <comando_n>
+}
+```
+
+
--- a/encaixada.md
+++ b/encaixada.md
@ -0,0 +1,14 @@
+# Repetição encaixada
+
+Denominação dada à repetição no interior doutra repetição.
+
+```c
+for (i = 4; count < n; i++) {
+    for (j = 3; j < i; j++) {
+        if ((j - 2) * (j - 1) * j != i)
+            continue;
+        printf ("%d * %d * %d = %d\n", j - 2, j - 1, j, i);
+        count ++;
+    }
+}
+```
--- a/passagem.md
+++ b/passagem.md
@ -0,0 +1,17 @@
+# Indicador de passagem
+
+Padrão bastante utilizado em computação para identificar a ocorrência de um
+evento que ajuda no controle do seu programa. O indicador de passagem é uma variável que inicia com um determinado valor, e caso o evento que ele marca ocorra, seu valor é alterado e não muda mais.
+
+```c
+i = n % 10;
+n /= 10;
+while (n != 0) {
+	if (n % 10 == i) {
+    	adjacente = true;
+		break;
+	}
+	i = n % 10;
+	n /= 10;
+}
+```
--- a/Resumos/13
+++ b/Resumos/13
@ -0,0 +1,173 @@
+# Números reais — Tipo *float*
+
+## Representação de números inteiros
+
+Os circuitos eletrônicos do computador armazenam a informação na forma binária (também chamada de digital). Um dı́gito binário pode assumir apenas 2 valores, representados pelos sı́mbolos 0 (zero) e 1 (um), e que nos circuitos podem corresponder, por exemplo, a uma chave aberta/fechada, a um capacitor carregado/descarregado, etc. Esse elemento básico é conhecido como **bit**.
+
+Os bits (dı́gitos binários) podem ser combinados para representar números da mesma forma que os dı́gitos decimais (dı́gitos de zero a nove), através de uma notação posicional, ou seja, o número 12 na base decimal equivale ao resultado da expressão 1 × 10^1^ + 2 × 10^0^ . Essa mesma quantia pode ser representada por 1100 na base binária pois equivale ao resultado da expressão 1 × 2^3^ + 1 × 2^2^ + 0 × 2^1^ + 0 × 2^0^.
+
+Por razões históricas, a memória do computador é dividida em bytes (conjunto de 8 bits), por isso a memória do seu computador pode ter, por exemplo, 128 MB (mega bytes, onde 1MB = 220 bytes) e o disco rígido 40 GB (giga bytes, onde 1GB = 230 bytes). Com um byte, é possı́vel representar 2^8^ = 256 valores (todas as possíveis configurações de 8 bits de 00000000 a 1111111).
+
+Nos computadores digitais, para representar de números negativos, é comum usar um bit para sinal. Se o bit de sinal é 0 (zero), então o número é positivo; caso contrário, o número é negativo. O bit de sinal é o bit **mais à esquerda possı́vel**. Considerando um byte com o bit de sinal é possı́vel representar 2^8^ = 256 valores (de −128 a +127).
+
+## Representação de números reais
+
+Na memória do computador não podemos armazenar 1/2 bit (apenas os zeros e uns). Como então representar um número fracionário, ou real? A representação é análoga à notação científica, feita em ponto flutuante da seguinte forma:
+
+$$
+0.x_1x_2x_3\dots x_k \cdot B^e
+$$
+
+Onde:
+
+- **x~1~x~2~x~3~...x~k~** é a *mantissa* (os *k* dígitos mais significativos do número);
+
+- **B** é a base; 
+
+- **e** é o expoente (por meio do qual se determina a posição correta do dı́gito mais significativo do número em ponto flutuante);
+
+Por exemplo,
+
+| Número | Notação Científica           | Mantissa | Base | Expoente |
+| ------ | ---------------------------- | -------- | ---- | -------- |
+| 456.78 | 0.45678 × 10^3^, ou 4.5678E2 | 45678    | 10   | 3        |
+
+Não obstante, em um computador os valores da mantissa, da base, e do expoente são todos binários.
+
+## Variável do tipo real
+
+Na linguagem C, podemos usar dois tipos de variáveis para representar números reais: `float` e `double`. A diferença entre esses estes dois tipos é que no tipo de dado `double`, podemos representar uma quantidade maior de números reais que no tipo `float` . O tipo `double` usa 8 bytes para guardar um número em ponto flutuante (53 bits para a mantissa e 11 para o expoente); enquanto o float usa 4 bytes (24 bits para a mantissa e 8 para o expoente).
+
+| Variável | Valor mínimo   | Valor máximo  |
+| -------- | -------------- | ------------- |
+| `float`  | 3.4 × 10^-38^  | 3.4 × 10^38^  |
+| `double` | 1.7 × 10^-308^ | 1.7 × 10^308^ |
+
+A declaração destas variáveis pode ser feita das mesmas formas que para variáveis de tipo `int`, ainda que para valores que podem, ou não, ser fracionais.
+
+## Leitura de um número real pelo teclado
+
+Para ler um número real pelo teclado, você deve utilizar `%f` dentro do comando scanf. Por exemplo:
+
+```c
+float x;
+printf ("Digite um número real: ");
+scanf ("%f", &x);
+```
+
+## Impressão de números reais
+
+É possível imprimir números reais em mais de uma forma:
+
+| Indicador | Representação                                                                    |
+| --------- | -------------------------------------------------------------------------------- |
+| `%e`      | imprime um valor real em **notação científica**                                  |
+| `%f`      | imprime um valor real em **notação decimal**                                     |
+| `%g`      | imprime um valor real na notação cientifica ou decimal, como for mais apropriada |
+
+Por exemplo, no seguinte programa,
+
+```c
+# include <stdio.h>
+
+int main () {
+    float f = 3.141592654;
+
+    printf ("formato e: f = %e\n", f);
+    printf ("formato f: f = %f\n", f);
+    printf ("formato e: f = %g\n", f);
+    return = 0;
+}
+```
+
+A saída é:
+
+```
+formato e: f = 3.141593e+000
+formato f: f = 3.141593
+formato g: f = 3.14159
+```
+
+### Formatação para impressão de números reais
+
+Muitas vezes, para facilitar a visualização dos resultados, é necessário formatar os dados na saı́da do programa. Tanto o formato `%d` quanto o `%f` podem ser formatados no sentido de reservar um número de dı́gitos para impressão. Para usar formatação, pode-se colocar entre o % e o caractere definindo o tipo (`d` ou `f`) o seguinte:
+
+- **um sinal de menos:** especifica o alinhamento à esquerda (o normal é à direita);
+
+- **um número inteiro:** especifica o tamanho mínimo do campo numérico.[^1]
+
+- **um ponto seguido de um número:** especifica o tamanho máximo de casas decimais a serem impressos após o ponto decimal.[^2]
+
+Por exemplo, no seguinte programa,
+
+```c
+# include <stdio.h>
+
+int main () {
+    float cempi = 314.159542;
+
+    printf ("cempi = |%-8.2f|\n", cempi);
+    printf ("cempi = |%8.2f|\n", cempi);
+    printf ("cempi = |%8.4f|\n", cempi);
+    printf ("cempi = |%8.4f|\n", cempi * 1000);
+
+    return = 0;
+}
+```
+
+a saída é:
+
+```
+cempi = |314.16  |
+cempi = |  314.16|
+cempi = |314.1595|
+cempi = |314159.5313|
+```
+
+## Expressões aritméticas envolvendo reais
+
+Ao utilizarmos números reais em nossos programas, é comum misturar números e variáveis inteiras com reais em nossas expressões aritméticas. Para cada operador (+, -, *, /, etc) da expressão, o compilador precisa decidir se a operação deve ser realizada como inteira ou como real, pois como a forma de representação de inteiros e reais é diferente, as operações precisam ser feitas usando a mesma representação. A regra básica é, se os operandos tiverem tipos diferentes, a representação real é preferida.
+
+### Exemplo no âmbito da divisão
+
+```c
+# include <stdio.h>
+
+int main () {
+    int i,j;
+    float y;
+
+    i = 5 / 3; /* divisão inteira, de resultado igual à 1 */
+    y = 5 / 3; /* divisão inteira, de resultado igual à 1.0 (y é real) */
+    y = 5.0 / 2; /* divisão em ponto flutuante com resultado 2.5 (o numerador é real) */
+    y = 5 / 2.0; /* divisão em ponto flutuante com resultado 2.5 (o denominador é real) */
+
+    y = i /2; /* divisão inteira (i e 2 são inteiros) */
+    y = i / 2.0; /* divisão em ponto flutuante (o denominador é real) */
+    y = i / j; /* divisão inteira (i e j são inteiros) */
+    y = (1.0 * i) / j; /* divisão em ponto flutuante (o numerador é real) */
+    y = 1.0 * (i / j); /* divisão inteira (i e j são inteiros) */
+    i = y / 2; /* Parte inteira da divisão real (a divisão real é real, mas i é inteiro) */
+}
+```
+
+Observe que o tipo da variável que recebe a atribuição **não** influencia a forma de calcular as expressões. Após o cálculo, o resultado é convertido ao tipo da  variável (ou seja, inteiro 6 passa a real 6.0 e real 7.5 passa a inteiro 7). É possı́vel forçar a mudança de tipos de um termo dentro de expressão através de definições explícitas conhecidas como *type casting*. Observe o exemplo abaixo:
+
+```c
+int i = 4, j = 5;
+ff loat f = 5.0, g;
+
+g = 6 * ((int) f / i);
+// Variável real g recebe resultado de expressão inteira (6),
+// pois a variável f foi explicitamente convertida para o tipo int.
+
+g = (float) 6 * j / i
+
+// O número 6 é convertido à float, e portanto o resultado é real (7.5).
+// Uma forma mais simples de obter o mesmo resultado seria definir o
+// número 6 como 6.0.
+```
+
+[^1]: Se o número a ser impresso ocupar menos espaço, o espaço restante é preenchido com brancos para completar o tamanho desejado, mas se o número ocupar um espaço maior, o limite definido não é respeitado.
+
+[^2]: A precisão padrão para números reais é de **6** casas decimais.
--- a/Infinitas).md
+++ b/Infinitas).md
@ -0,0 +1,46 @@
+# Fórmula de recorrência e séries (Somas Infinitas)
+
+## Fórmula de recorrência
+
+Uma fórmula de recorrência é uma relação entre os termos sucessivos de uma sequência numérica. Dessa forma, usando uma fórmula de recorrência, é possı́vel obter o próximo termo da sequência usando o valor de termos anteriores. Um exemplo clássico é a sequência de Fibonacci definida pela fórmula de recorrência:
+
+$$
+\begin{cases} F_1 = 1;\\ F_2 = 1\\ F_i = F_{i - 1} + F_{i - 2}\ \text{para } i \le 3. \end{cases}
+$$
+
+## Erro absoluto
+
+O módulo da diferença entre um valor aproximado e um valor real. Isto é, dado um número $x$ e uma aproximação $y$, o erro (também chamado erro absoluto) $E_{abs}$ é definido como $E_{abs} = | y - x|$.
+
+## Erro relativo
+
+O módulo $E_{rel}$ o módulo da divisão da diferença entre um valor aproximado e um valor real, e o valor real.
+
+$$
+E_{rel} = \left| \dfrac{y - x}x \right|
+$$
+
+O erro relativo é adequado para aferir a qualidade da aproximação nos casos em que o valor de $x$ não é próximo de 1. Por exemplo, o erro absoluto entre 1.01 e 1.00 é idêntico àquele entre 0.01 e 0.02, mas podemos afirmar que o primeiro caso é uma aproximação muito mais precisa pois tem um erro relativo de 0.01 (1%), enquanto o segundo caso tem um erro relativo de 1.00 (100%).
+
+### Nos casos em que $\bm{x = 0}$
+
+A definição de erro relativo é incompleta, pois não se aplica quando $x = 0$ (0 não pode ser denominador). Nestes casos, um valor arbitrário para $E_{rel}$ é adotado.
+
+Assim sendo, se:
+
+-  $x = 0 = y$, a aproximação é dita perfeita, $E_{rel} = 0$;
+
+- $x = 0 \not = y $, a aproximação é dita insatisfatória, $E_{rel} = 1$;
+
+Ou seja, uma definição mais completa do erro relativo seria
+
+$$
+E_{rel} (y, x) =
+\begin{cases}
+    \begin{matrix}
+        \left| \dfrac{y - x}x \right| & \text{se } x \not = 0 \\
+        0 & \text{se } x = 0 = y \\
+        1 & \text{se } x = 0 \not = y \\
+    \end{matrix}
+\end{cases}
+$$
--- a/Funções.md
+++ b/Funções.md
@ -0,0 +1,18 @@
+# Funções
+
+## Definição
+
+Porções de código-fonte préviamente declaradas que pode ser executada pela função principal do programa "invocando-a" pelo seu nome e provendo-a de parâmetros adequados. Esses parâmetros serão então processados pela função, sempre da mesma forma, produzindo um resultado correspondente. Assim, funções permitem evitar reescrever porções de código-fonte iguais em um programa.
+
+## Sintaxe
+
+```c
+<tipo> <nome_da_função> (<tipo> <parâmetro>, <tipo> <parâmetro>, ... ) {
+    <comando_1>;
+    <comando_2>;
+    <comando_3>;
+    ...
+    <comando_n>;
+    return <resultado>;
+}
+```
--- a/programas.md
+++ b/programas.md
@ -0,0 +1,122 @@
+# Definição e uso de funções em programas
+
+## Estrutura de um programa
+
+A estrutura de um programa com funções deve seguir a seguinte forma:
+
+- Includes;
+
+- Protótipos das funções[^1];
+
+- Definição das funções;
+
+- Função principal
+
+Por exemplo, para o seguinte programa:
+
+```c
+/* Includes */
+
+# include <stdio.h>
+
+/* Protótipos das funções */
+
+int fatorial (int n);
+int comb (int m, int n);
+
+/* Definição das funções */
+
+int fatorial (int n) {
+    int i, result = 1;
+    for (i = n; i > 1; i--)
+        result *= i;
+    return result;    
+}
+
+int comb (int m, int n) {
+    return fatorial (m) / (fatorial (n) * fatorial (m - n));
+}
+
+/* Função principal */
+
+int main () {
+    int n = -1, p;
+    printf ("Este programa imprime os coeficientes da expansão (a + b)^n, para um valor inteiro n >= 0.\n");
+
+    while (n < 0) {
+        printf ("Digite um valor para n: ");
+        scanf ("%d", &n);
+        if (n < 0)
+            printf ("Valor inválido.\n");
+    }
+
+    for (p = 0; p <= n; p++)
+        printf("%d ", comb (n,p));
+
+    printf ("\n");
+    return 0;
+}
+```
+
+## Funções que fazem parte de alguma Biblioteca
+
+As seguintes funções fazem parte da biblioteca `math.h`. Estas podem ser utilizadas estando presente a instrução `# include <math.h>` e compilando-se o programa com a opção `-lm`.
+
+### Trigonométricas
+
+- Seno: `double sin (double x);`
+
+- Cosseno: `double cos (double x);`
+
+- Tangente: `double tan (double x);`
+
+### Exponenciais e logarítmicas
+
+- Exponencial: `double exp (double x);`
+
+> Uso típico: `y = exp (x);`. Devolve $e^x$, ou seja, o número de Euler elevado à potencia $x$.
+
+- Logaritmo com base $e$: `double log (double x);`
+
+> Uso típico: `y = log (x);`. Devolve o logaritmo de $x$ na base $e$.[^2]
+
+- Logaritmo com base 10: `double log10 (double x);`
+
+> Uso típico: `y = log10 (x);`. Devolve o logaritmo de $x$ na base 10.[^2]
+
+### Raiz e potência
+
+- Raiz quadrada: `double sqrt (double x);`
+
+> Uso típico: `y = sqrt (x);`.[^2]
+
+- Potência: `double pow (double x, double y);`
+
+### Valor Absoluto
+
+- `double fabs (double x);`
+
+> Uso típico: `i = fabs (x);`
+
+### Arredondamentos
+
+- `double floor(double x);`
+
+> Uso típico: `i = floor (x)`.  Devolve o maior número inteiro que seja menor que ou igual a x. Por exemplo:
+> 
+> - `floor (1.8) = 1`;
+> 
+> - `floor (2.0) = 2`.
+
+- `double ceil (double x);`
+
+> Uso típico : `j = ceil (x)`. Devolve o maior número inteiro que seja maior que ou igual a x. Por exemplo:
+> 
+> - `floor (1.8) = 2`;
+> 
+> - `floor (2.0) = 2`.
+
+[^1]: Na realidade, a declaração explicita dos protótipos da funções não é necessária, mas é uma boa prática de programação pois permite que você defina as funções em qualquer ordem.
+Caso os protótipos não sejam declarados, as funções precisam ser definidas antes de serem utilizadas por outras funções.
+
+[^2]: Não devem ser utilizados com valores negativos para x.
--- a/Ponteiros.md
+++ b/Ponteiros.md
@ -0,0 +1,61 @@
+# Funções e Ponteiros
+
+## Memória
+
+![](/home/user/Documents/Drives/USP/Transferência%20Interna/01%20-%20Introdução%20a%20Ciência%20da%20Computação/Resumos/Imagens/2021-04-17-22-16-29-image.png)
+
+> Esquematização da memória de um computador.
+
+Pode-se dizer que a memória RAM de um computador é constituída por unidades denominadas **gavetas**. Cada gaveta possui 8 regiões: os bits, o bit mais a esquerda sendo o **bit de sinal**. Cada gaveta constitui, portanto, um *byte*. Em código binário, valores podem ser armazenados nas diferentes gavetas.
+
+Para cada gaveta na memória é associada uma identificação numérica (no exemplo, de 00 à 99, mas em computadores reais o último número pode ser muito maior), o respectivo **endereço**.
+
+## Declaração de variáveis
+
+Quando declara-se uma variável, reserva-se espaço suficiente na memória para armazenar seu valor. À depender da variável, uma ou mais gavetas são reservadas[^1]. Não obstante, sendo armazenada, a variável que ocupa tais gavetas adquire um **único endereço**.
+
+## Ponteiros (ou apontadores)
+
+Ponteiros são um tipo de variável que armazena endereços doutras variáveis quaisquer. Por exemplo, para armazenar no ponteiro `pon` o endereço da variável inteira `n` utiliza-se:
+
+```c
+pon = &n;
+```
+
+Onde o `&` antes do nome da variável `n` indica "endereço de".
+
+Se uma variável do tipo ponteiro `pon` armazena o endereço doutra variável `n`, diz-se `pon` *aponta para* `n` .
+
+### Declaração de variáveis do tipo ponteiro
+
+Existem ponteiros distintos para armazenar o endereço de variáveis de tipos distintos. Por exemplo, nos seguintes comandos criam-se ponteiros para armazenar o endereço de variáveis do tipo
+
+- `int`: `int * pon;`
+
+- `float`: `float * pon;`
+
+- `char`: `char * pon;`
+
+- etc.
+
+Onde o `*` antes da variável `pon` e após o tipo da variável indica "vai para".
+
+### Uso do operador "vai para"
+
+Uma vez que um ponteiro aponta para uma variável é possível ter acesso à esta usando o operador `*`. Por exemplo, no seguinte no seguinte comando:
+
+```c
+* pon = 10
+```
+
+Armazena-se o valor 10 na variável para qual o ponteiro encontra-se apontado. Assim sendo, ponteiros quando utilizados como **parâmetros de uma função** podem servir a modificar variáveis as quais encontram-se fora desta. Por exemplo:
+
+<img src="file:///home/user/Documents/Drives/USP/Transferência%20Interna/01%20-%20Introdução%20a%20Ciência%20da%20Computação/Resumos/Imagens/2021-04-18-12-32-32-image.png" title="" alt="" data-align="center">
+
+No código acima vemos a função `f`, por meio do ponteiro `*y` alterar o valor de da variável `b` declarada na função principal.
+
+## Funções do tipo *void*
+
+As funções aquelas que não retorna um valor pelo comando `return`.
+
+[^1]: Para variáveis inteiras são reservadas 4 gavetas (bytes). Para float e double são reservadas 4 e 8 bytes, respectivamente.
--- a/Vetores.md
+++ b/Vetores.md
@ -0,0 +1,41 @@
+# Vetores
+
+Vetores são estruturas indexadas utilizadas para armazenar dados de um mesmo tipo (seja `int`, `float`, `char`, etc.). O exemplo à seguir trata-se de um vetor de valores inteiros:
+
+| 0   | 1   | 2   | 3   | ... | 78  | 79  |
+|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| 10  | 12  | 17  | 12  |     | -42 | 34  |
+
+## Declaração de vetores
+
+A sintaxe da declaração de um vetor é a seguinte:
+
+```c
+<tipo_do_vetor> <nome_do_vetor>[<tamanho_do_vetor>];
+```
+
+Por exemplo:
+
+- `int v[80];` cria um vetor `v` capaz de armazenar 80 valores inteiros;
+
+- `float x[20];` cria um vetor `x` capaz de armazenar 20 valores reais;
+
+int
+
+## O uso de vetores
+
+Pelo uso de vetores torna-se possível armazenar múltiplos valores e ter acesso à estes por meio do índice destes no vetor. O índice sendo um número inteiro e positivo[^1].
+
+### Percorrimento de vetores
+
+Por "percorrer um vetor" significa acessar um vetor índice à índice em uma sequência. Muitos problemas computacionais que envolvem vetores têm como solução o uso de um padrão para percorrimento de vetores.
+
+```c
+for (indice = 0; indice < n; indice++) {
+    <algum, ou alguns, comandos usando o valor armazenado em vetor[i]>
+}
+```
+
+> Exemplo de percorrimento de um vetor de tamanho `n` do primeiro ao último índice.
+
+[^1]: Note-se: um vetor de tamanho 80 pode armazenar 80 valores com índices de 0 à 79.
--- a/funções.md
+++ b/funções.md
@ -0,0 +1,88 @@
+# Vetores, ponteiros e funções
+
+## Como vetores são armazenados na memória
+
+A organização das variáveis na memória depende de como o sistema operacional faz gerenciamento da memória. Em geral, para ser mais eficiente, o sistema operacional tende a colocar as variáveis sucessivamente. Assim, a  alocação do vetor na memória é feita de forma sucessiva, ou seja, `v[0]` antes de `v[1]`, que por sua vez antes de `v[2]`, e assim por diante.
+
+Na linguagem C não existe verificação de ı́ndices fora do vetor. Quem deve controlar o uso correto dos ı́ndices é o programador. Além disso, o acesso utilizando um ı́ndice errado pode ocasionar o acesso de outra variável
+na memória.
+
+<img src="file:///home/user/Documents/Drives/USP/Transferência%20Interna/01%20-%20Introdução%20a%20Ciência%20da%20Computação/Resumos/Imagens/2021-04-20-15-28-25-image.png" title="" alt="" data-align="center">
+
+No exemplo acima, `v[80]` acessaria a variável n. Se o acesso à memória é indevido recebe-se a mensagem `segmentation fault`.
+
+## Vetores e ponteiros
+
+Podemos apontar um ponteiro ao índice inicial de um vetor utilizando a sintaxe comum para apontar um ponteiro à demais tipos de variáveis:
+
+```c
+p = &v[0];
+```
+
+Doutra forma, podemos utilizar a **sintaxe especial para ponteiros e vetores**:
+
+```c
+p = v;
+```
+
+Esta é a única situação em que o nome do vetor tem sentido sem os colchetes. À partir de então, pode-se utilizar a sintaxe de vetores (`nome_do_vetor[índice]`) como ponteiro, e pode-se acessar o valor em `v[i]` utilizando `p[i]` .
+
+Mas se utiliza-se
+
+```c
+p = &v[3];
+```
+
+então, `p[0]` é o elemento `v[3]`, `p[1]` é o elemento `v[4]`, `p[2]` é o elemento `v[5]`, e assim por diante.
+
+### Operações aritméticas com ponteiros apontados para vetores
+
+Quando somamos 1 a um ponteiro para int ou para float (por exemplo, p) ele passa a apontar para o endereço de memória logo após a memória reservada para este inteiro. Exemplo, se `p = &v[4]`, então `p + 1` é o endereço de `v[5]`, `p + 2` é o endereço de `v[6]`, `p + i` é o endereço de `v[4 + i]`.
+
+É possível se fazer também operações aritméticas entre os índices para os quais os ponteiros encontram-se apontados:
+
+```c
+p = &v[20];
+q = &v[31];
+n = q - p /* O resultado é a diferença entre os índices, neste caso, 11. */
+```
+
+## Vetores como parâmetros de funções
+
+Quando se declara uma função que tem como parâmetro um vetor, este vetor é declarado somente com abre e fecha colchetes. Exemplo:
+
+```c
+# include <math.h>
+
+float modulo (float v[], int n) {
+    int i ;
+    float r = 0;
+    for (i = 0; i  < n; i++) {
+        r = r + v[i] ∗ v[i];
+    }
+    r = sqrt (r);
+    return r;
+}
+```
+
+Esta função recebe um vetor de reais `v` com `n` elementos e devolve o seu módulo via `return`. A declaração acima é equivalente a
+
+```c
+# include <math.h>
+
+float modulo (float *p, int n) {
+    int i ;
+    float r = 0;
+    for (i = 0; i  < n; i++) {
+        r = r + p[i] ∗ p[i];
+    }
+    r = sqrt (r);
+    return r;
+}
+```
+
+Na verdade, a declaração no argumento `float v[]` é a mesma coisa que `float ∗ p`, ou seja, `v` é um ponteiro.
+
+<img src="file:///home/user/Documents/Drives/USP/Transferência%20Interna/01%20-%20Introdução%20a%20Ciência%20da%20Computação/Resumos/Imagens/2021-04-20-17-10-26-image.png" title="" alt="" data-align="center">
+
+> Exemplo de declaração de funções com vetores como parâmetros
--- a/caracteres.md
+++ b/caracteres.md
@ -0,0 +1,30 @@
+# Caracteres (o tipo char)
+
+Na linguagem C, caracteres são armazenados na memória como números inteiros e convertidos para exibição enquanto caracteres conforme a **Tabela ASCII** (American Standard Code for Information Interchange).
+
+## Tabela ASCII
+
+Lista 128 caracteres ordenados alfanuméricamente e numerados de 0 à 127. Esta pode ser estendida de maneira a acomodar valores de -1 a -128 e, assim, acomodar caracteres acentuados, os quais estão ausentes na tabela original.
+
+### Caracteres de controle
+
+Os caracteres de código 0 à 31 são denominados como "de controle" pois indicam um comando o qual a impressora ou monitor devem executar. Tais quais:
+
+| Caractere | Código ASCII | Significado |
+| --- | --- | --- |
+nulo | 0 | indica o término de uma sequência de caracteres
+backspace | 8 | apaga um caractere
+line feed | 10 | pula uma linha
+carriage return | 13 | retorna o cursor ao início da linha
+
+### Conversão entre caracteres e números inteiros
+
+Na linguagem C, escrever um caractere entre apóstrofes equivale a escrever seu código ASCII. Assim, `'A' == 65`.
+
+## A variável do tipo `char`
+
+Trata-se de uma variável capaz de armazenar um número inteiro de -128 a 127. Adequada, portanto, para armazenar códigos ASCII com um consumo adequado de memória (1 byte).
+
+### Leitura ou impressão de Caracteres
+
+É feito no `scanf` e `printf` com `%c`. No scanf, este deve encontrar-se precedido por um espaço em branco (`scanf (" %c", &caractere)`) para evitar-se de ler este caractere ou o `<ENTER>`.
--- a/Strings.md
+++ b/Strings.md
@ -0,0 +1,29 @@
+# Strings
+
+Sequências de caracteres contidas em um vetor de caracteres `char[]` terminadas por `\0`, o caractere nulo.
+
+## Leitura
+
+Uma forma de se ler uma sequência de caracteres terminadas com `\n` (ENTER, nova linha) e armazená-la em uma variável `string` é:
+
+```c
+scanf("%[^\n]", string);
+```
+
+## Impressão
+
+Enquanto uma forma de se imprimir uma variável `string` é:
+
+```c
+printf("%s\n", string);
+```
+
+Onde `%s` é substituído pelo conteúdo da string na tela.
+
+## Biblioteca `<string.h>`
+
+A biblioteca `<string.h>` contém algumas funções para manipular strings, tais quais:
+
+- `int strlen (char s[])`: devolve via `return` o comprimento do vetor `s` até seu final ou caractere nulo;
+
+- `void strcpy (char s1[], char s2[])`: copia o string armazenado em `s2` para `s1`.
--- a/Matrizes.md
+++ b/Matrizes.md
@ -0,0 +1,29 @@
+# Matrizes
+
+Estruturas indexadas em forma matricial, como ilustra a figura abaixo.
+
+<img src="file:///home/user/Public/USP/Transferência%20Interna/01%20-%20Introdução%20a%20Ciência%20da%20Computação/Resumos/Imagens/2021-08-16-23-37-32-image.png" title="" alt="" data-align="center">
+
+Estas armazenam em cada índice diferentes valores de um mesmo tipo (seja este `int`, `char`, `float`, etc.).
+
+## Declaração
+
+```c
+<tipo da matriz> <nome da matriz>[<número de "linhas">][<número de "colunas">]
+```
+
+> Exemplo:
+> 
+> `int matriz[100][200]`
+
+## Percorrimento de Matrizes
+
+O seguinte loop de repetição acessa a todos os valores de uma matriz `m[l][c]`
+
+```c
+for (i = 0; i < l; i++) {
+    for (j = 0; j < c; j++) {
+        /* Código a ser executado na posição m[l][c] */    
+    }
+}
+```
--- a/Funções.md
+++ b/Funções.md
@ -0,0 +1,27 @@
+# Matrizes, Ponteiros e Funções
+
+## Como matrizes são alocadas na memória
+
+Não obstante a utilidade da representação gráfica de uma matriz enquanto uma tabela, na realidade a memória computacional é *linear*. Assim o sendo, matrizes são armazenadas na memória com cada uma de suas sucessivas linhas concatenadas uma seguida da outra.
+
+<img src="file:///home/user/Documents/Drives/USP/Introdução%20a%20Ciência%20da%20Computação/Imagens/2021-08-17-12-03-35-image.png" title="" alt="" data-align="center">
+
+Assim o sendo, o endereço do índice `&m[y][x]` em uma matriz `int m[a][l]` é:
+
+```c
+&m[y][x] == &m[0][0] + ((y * l + x) * sizeof(int));
+/* ou */
+&m[y][x] == m[y * l + x]
+```
+
+Fica demonstrado que enquanto vetores são ponteiros que apontam para uma sequência contínua de variáveis de determinado tipo (`&p[x] == *p + sizeof(type)`), uma matriz é um ponteiro que aponta para uma sequência contínua de vetores.
+
+### *Segmentation fault*
+
+Na linguagem C não existe verificação de ı́ndices fora da matriz. Quem deve controlar o uso correto dos ı́ndices é o programador. Se o acesso à memória é indevido, ao executar o programa recebe-se a mensagem de erro `segmantation fault`.
+
+## Matrizes como parâmetro de funções
+
+
+
+
--- a/Resumos/Imagens/0587b4f3cf045d37f3d1136da10fd9275d48b2f3.JPG
+++ b/Resumos/Imagens/0587b4f3cf045d37f3d1136da10fd9275d48b2f3.JPG
--- a/Resumos/Imagens/2021-03-29-21-02-42-image.png
+++ b/Resumos/Imagens/2021-03-29-21-02-42-image.png
--- a/Resumos/Imagens/2021-03-30-21-52-08-image.png
+++ b/Resumos/Imagens/2021-03-30-21-52-08-image.png
--- a/Resumos/Imagens/2021-03-30-22-13-11-image.png
+++ b/Resumos/Imagens/2021-03-30-22-13-11-image.png
--- a/Resumos/Imagens/2021-04-17-22-16-29-image.png
+++ b/Resumos/Imagens/2021-04-17-22-16-29-image.png
--- a/Resumos/Imagens/2021-04-18-12-32-32-image.png
+++ b/Resumos/Imagens/2021-04-18-12-32-32-image.png
--- a/Resumos/Imagens/2021-04-20-15-28-25-image.png
+++ b/Resumos/Imagens/2021-04-20-15-28-25-image.png
--- a/Resumos/Imagens/2021-04-20-17-10-26-image.png
+++ b/Resumos/Imagens/2021-04-20-17-10-26-image.png
--- a/Resumos/Imagens/2021-08-16-23-37-32-image.png
+++ b/Resumos/Imagens/2021-08-16-23-37-32-image.png
--- a/Resumos/Imagens/3f1634311dffcc6d793fd5fb64d837fcd7f606ca.jpg
+++ b/Resumos/Imagens/3f1634311dffcc6d793fd5fb64d837fcd7f606ca.jpg
--- a/Resumos/Imagens/824f897975e229bdbfe16beb171ee01e267000db.png
+++ b/Resumos/Imagens/824f897975e229bdbfe16beb171ee01e267000db.png
--- a/Resumos/Imagens/AMD_INFERIOR.JPG
+++ b/Resumos/Imagens/AMD_INFERIOR.JPG
--- a/Resumos/Imagens/Screenshot
+++ b/Resumos/Imagens/Screenshot
--- a/Resumos/Imagens/Wi-Fi_network_card_by_Askey_Computers_with_Wi-Fi_Antenna_by_Amphenol-9712.jpg
+++ b/Resumos/Imagens/Wi-Fi_network_card_by_Askey_Computers_with_Wi-Fi_Antenna_by_Amphenol-9712.jpg
--- a/Resumos/Imagens/a1856b5e80d31b9b0e1c532abcc4a1b97ffd0f2f.png
+++ b/Resumos/Imagens/a1856b5e80d31b9b0e1c532abcc4a1b97ffd0f2f.png