SI
/
semestre_2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Added current files

This commit is contained in:
Abreu 2021-09-18 12:48:53 -03:00
parent 31f259be58
commit 6798e113da
No known key found for this signature in database
GPG Key ID: 64835466FF55F7E1
31 changed files with 1901 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored Normal file
View File

@ -0,0 +1,2 @@
*.out
*.pdf

70
Algoritmos e Estruturas de Dados I/Semana 01/Semana 01.md Normal file
View File

@ -0,0 +1,70 @@
# Semana 01
> 16/08/21 a 21/08. Por Guilherme de Abreu Barreto, nUSP: 12543033.
Respostas aos exercícios propostos.
## Exercício 01
Output com variável `nusp` do tipo `int`:
```
Imprimindo inteiro: 12543033
Imprimindo numero: 12543033
Imprimindo float (com cast): 12543033.000000
Imprimindo quociente: 6271516
Imprimindo resto: 1
Imprimindo quadrado: -1270180687
```
Notei que o resultado do quadrado é incorreto, imaginei ser uma questão de insuficiência da capacidade do tipo `int` para o armazenamento do resultado. Então repeti o procedimento designando à variável `nusp` o tipo `long long int`[^1] e assim obtive a resposta esperada:
```
Digite seu número USP: Imprimindo inteiro: 12543033
Imprimindo numero: 12543033
Imprimindo float (com cast): 12543033.000000
Imprimindo quociente: 6271516
Imprimindo resto: 1
Imprimindo quadrado: 157327676839089
```
## Exercício 02
Output:
```
x: 7 y: 13 z: 0x7fffdd1a03f8
&x: 0x7fffdd1a03f8 &y: 0x7fffdd1a03fc &z: 0x7fffdd1a0400
Novo valor de x: 20
```
Não obstante, o código, ao ser compilado, produziu os seguintes alertas:
```
e2.c: In function ‘main’:
e2.c:7:33: warning: format ‘%p’ expects argument of type ‘void *’, but argument 4 has type ‘int *’ [-Wformat=]
7 | printf("x: %i y: %i z: %p\n", x, y, z);
| ~^ ~
| | |
| void * int *
| %ls
e2.c:8:22: warning: format ‘%p’ expects argument of type ‘void *’, but argument 2 has type ‘int *’ [-Wformat=]
8 | printf("&x: %p &y: %p &z: %p\n", &x, &y, &z);
| ~^ ~~
| | |
| void * int *
| %ls
e2.c:8:29: warning: format ‘%p’ expects argument of type ‘void *’, but argument 3 has type ‘int *’ [-Wformat=]
8 | printf("&x: %p &y: %p &z: %p\n", &x, &y, &z);
| ~^ ~~
| | |
| void * int *
| %ls
e2.c:8:36: warning: format ‘%p’ expects argument of type ‘void *’, but argument 4 has type ‘int **’ [-Wformat=]
8 | printf("&x: %p &y: %p &z: %p\n", &x, &y, &z);
| ~^ ~~
| | |
| void * int **
```
[^1]: Foi necessário o uso da *flag* `-std=c99` para que o `gcc` compilase o código sem emitir alertas.

12
Algoritmos e Estruturas de Dados I/Semana 01/e2.md Normal file
View File

@ -0,0 +1,12 @@
## O especificador de formato %p
Este é utilizado para imprimir o endereço na memória de uma dada variável.
```
#include<stdio.h>
main() {
int x = 50;
int *ptr = &x;
printf("The address is: %p, the value is %d", ptr, *ptr);
}
```

15
Algoritmos e Estruturas de Dados I/Semana 01/nusp.c Normal file
View File

@ -0,0 +1,15 @@
#include <stdio.h>
int main() {
long long int nusp;
printf("Digite seu número USP: ");
scanf("%lld", &nusp);
printf("Imprimindo inteiro: %lli\n", nusp);
printf("Imprimindo numero: %lld\n", nusp);
printf("Imprimindo float (com cast): %f\n", (float) nusp);
printf("Imprimindo quociente: %lli\n", nusp/2);
printf("Imprimindo resto: %lld\n", nusp%2);
printf("Imprimindo quadrado: %lld\n", nusp*nusp);
return 0;
}

30
Algoritmos e Estruturas de Dados I/Semana 01/nusp.md Normal file
View File

@ -0,0 +1,30 @@
# Notas quanto ao exercício
1. Como jogar o prompt para o terminal e o output para o arquivo?
2. Como passar um argumento para o executável?
## Output com variável int:
```
Digite seu número USP: Imprimindo inteiro: 12543033
Imprimindo numero: 12543033
Imprimindo float (com cast): 12543033.000000
Imprimindo quociente: 6271516
Imprimindo resto: 1
Imprimindo quadrado: -1270180687
```
## Output com variável long long int
```
Digite seu número USP: Imprimindo inteiro: 12543033
Imprimindo numero: 12543033
Imprimindo float (com cast): 12543033.000000
Imprimindo quociente: 6271516
Imprimindo resto: 1
Imprimindo quadrado: 157327676839089
```
---
[Diferença entre os especificadores de formato %d e %i](https://www.geeksforgeeks.org/difference-d-format-specifier-c-language/)

19
Algoritmos e Estruturas de Dados I/Semana 02/e01.c Normal file
View File

@ -0,0 +1,19 @@
#include <stddef.h>
#include <stdlib.h>
typedef struct pessoa {
int id;
struct pessoa * mae, * pai;
} Pessoa;
Pessoa * inicializar (int id) {
Pessoa * init = malloc(sizeof(*init));
init->id = id;
init->mae = init->pai = NULL;
return init;
}
void registrar(Pessoa * filho, Pessoa * mae, Pessoa * pai) {
filho->mae = mae;
filho->pai = pai;
}

101
Algoritmos e Estruturas de Dados I/Semana 03/Semana 03.md Normal file
View File

@ -0,0 +1,101 @@
# Semana 03: respostas ao [exercício proposto](http://www.each.usp.br/digiampietri/ACH2023/ACH2023_AtividadeSemanal03.pdf)
> Por Guilherme de Abreu Barreto, nUSP: 12543033.
```c
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
typedef struct {
int size, * value;
} Array;
Array * initializeArray () {
Array * init = malloc(sizeof(*init));
init->size = 1;
init->value = malloc(sizeof(init->value));
return init;
}
int readSequence(Array * sequence) {
bool end = false;
int num, i = 0;
char c;
do {
switch (scanf("%d%c", &num, &c)) {
case 0:
return EOF;
case EOF:
end = true;
}
if (end == true)
break;
if (i == sequence->size - 1) {
sequence->size *= 2;
sequence->value = realloc(sequence->value, sequence->size * sizeof(sequence->value));
}
sequence->value[i] = num;
i++;
} while(c != '\n');
sequence->size = i;
return i;
}
bool isSorted (Array * sequence) {
int i;
for (i = 0; i < sequence->size - 1; i++)
if (sequence->value[i] > sequence->value[i + 1])
return false;
return true;
}
void selectionSort(Array * sequence) {
int i, j, pos, aux;
if (isSorted(sequence) == true)
return;
for (i = 0; i < sequence->size - 1; i++) {
pos = i;
for (j = i + 1; j < sequence->size; j++)
if (sequence->value[j] < sequence->value[pos])
pos = j;
if (pos == i)
continue;
aux = sequence->value[i];
sequence->value[i] = sequence->value[pos];
sequence->value[pos] = aux;
}
}
int main () {
int i;
Array * sequence = initializeArray();
printf("Este programa lê uma sequência de números inteiros e os ordena em ordem crescente. Digite uma sequência de números qualquer e pressione ENTER:\n");
switch (readSequence(sequence)) {
case EOF:
printf("Detectado valor inválido na sequência\n");
case 0:
return 1;
}
selectionSort(sequence);
printf("\n");
for (i = 0; i < sequence->size; i++)
printf("%d ", sequence->value[i]);
printf("\n");
return 0;
}
->size; i++)
printf("%d ", sequence->value[i]);
printf("\n");
return 0;
}
```

16
Algoritmos e Estruturas de Dados I/Semana 03/bubbleSort.c Normal file
View File

@ -0,0 +1,16 @@
void swap(int * a, int * b) {
int temp = *a;
*a = *b;
*b = temp;
}
void bubbleSort(int * v, int n){
if (n < 1)
return;
int i;
for (i=0; i<n; i++)
if (v[i] > v[i+1])
swap(&v[i], &v[i+1]);
bubbleSort(v, n-1);
}

22
Algoritmos e Estruturas de Dados I/Semana 03/selection_sort.c Normal file
View File

@ -0,0 +1,22 @@
int posMenorEl(int v[], int tam, int inicio) {
int i, posMenor;
posMenor = -1;
if (inicio >= 0 && inicio < tam) {
posMenor = inicio;
for (i = inicio + 1; i < tam; i++) {
if (v[i] < v[posMenor])
posMenor = i;
}
}
return posMenor;
}
void selecao (int v[, int tam) {
int i, posMenor, aux;
for (i = 0; i < tam - 1; i++) {
posMenor = posMenorEl(v, tam, i);
aux = v[i];
v[i] = v[posMenor];
v[posMenor] = aux;
}
}

90
Algoritmos e Estruturas de Dados I/Semana 03/sort.c Normal file
View File

@ -0,0 +1,90 @@
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
typedef struct {
int size, * value;
} Array;
Array * initializeArray () {
Array * init = malloc(sizeof(*init));
init->size = 1;
init->value = malloc(sizeof(init->value));
return init;
}
int readSequence(Array * sequence) {
bool end = false;
int num, i = 0;
char c;
do {
switch (scanf("%d%c", &num, &c)) {
case 0:
return EOF;
case EOF:
end = true;
}
if (end == true)
break;
if (i == sequence->size - 1) {
sequence->size *= 2;
sequence->value = realloc(sequence->value, sequence->size * sizeof(sequence->value));
}
sequence->value[i] = num;
i++;
} while(c != '\n');
sequence->size = i;
return i;
}
bool isSorted (Array * sequence) {
int i;
for (i = 0; i < sequence->size - 1; i++)
if (sequence->value[i] > sequence->value[i + 1])
return false;
return true;
}
void selectionSort(Array * sequence) {
int i, j, pos, aux;
if (isSorted(sequence) == true)
return;
for (i = 0; i < sequence->size - 1; i++) {
pos = i;
for (j = i + 1; j < sequence->size; j++)
if (sequence->value[j] < sequence->value[pos])
pos = j;
if (pos == i)
continue;
aux = sequence->value[i];
sequence->value[i] = sequence->value[pos];
sequence->value[pos] = aux;
}
}
int main () {
int i;
Array * sequence = initializeArray();
printf("Este programa lê uma sequência de números inteiros e os ordena em ordem crescente. Digite uma sequência de números qualquer e pressione ENTER:\n");
switch (readSequence(sequence)) {
case EOF:
printf("Detectado valor inválido na sequência\n");
case 0:
return 1;
}
selectionSort(sequence);
printf("\n");
for (i = 0; i < sequence->size; i++)
printf("%d ", sequence->value[i]);
printf("\n");
return 0;
}

142
Algoritmos e Estruturas de Dados I/Semana 04/Semana 04.md Normal file
View File

@ -0,0 +1,142 @@
# Semana 04: resposta ao [exercício proposto](http://www.each.usp.br/digiampietri/ACH2023/ACH2023_AtividadeSemanal04.pdf)
> Por Guilherme de Abreu Barreto, nUSP: 12543033.
```c
#include <stdio.h>
#include <stdlib.h>
typedef struct node {
int value;
struct node *prev;
struct node *next;
} Node;
typedef struct {
Node *start;
Node *end;
} List;
void insertIn (List *l, int value) {
Node *prev, *current, *next;
prev = next = NULL;
if (l->start != NULL) {
if (abs(value - l->start->value) < abs(value - l->end->value)) {
next = l->start;
while (next != NULL && next->value < value) {
prev = next;
next = next->next;
}
if (next != NULL && next->value == value)
return;
}
else {
prev = l->end;
while (prev != NULL && prev->value > value) {
next = prev;
prev = prev->prev;
}
if (prev != NULL && prev->value == value)
return;
}
}
current = malloc(sizeof(*current));
current->value = value;
if (prev == NULL) {
current->next = l->start;
l->start = current;
}
else {
current->next = prev->next;
prev->next = current;
}
if (next == NULL) {
current->prev = l->end;
l->end = current;
}
else {
current->prev = next->prev;
next->prev = current;
}
}
void removeFrom (List *l, int value) {
Node *current;
if (l->start == NULL)
return;
if (abs(value - l->start->value) < abs(value - l->end->value)) {
current = l->start;
while (current != NULL && current->value < value)
current = current->next;
}
else {
current = l->end;
while (current != NULL && current->value > value)
current = current->prev;
}
if (current == NULL)
return;
if (current->prev != NULL && current->next != NULL) {
current->prev->next = current->next;
current->next->prev = current->prev;
}
else {
if (current->prev == NULL) {
l->start = current->next;
if (current->next != NULL)
current->next->prev = NULL;
}
if (current->next == NULL) {
l->end = current->prev;
if (current->prev != NULL)
current->prev->next = NULL;
}
}
free(current);
}
void printList (List l) {
int i;
Node *current = l.start;
for (i = 0; current != NULL; i++) {
printf("\nÍndice: %-6d Valor: %-6d (Endereços) Anterior: %p Atual: %p Próximo: %p\n", i, current->value, current->prev, current, current->next);
current = current->next;
}
}
int main () {
int i;
char c;
List l = {0};
printf("Este programa adiciona valores inteiros à uma lista duplamente ligada, e depois permite excluí-los da mesma.\nDigite uma sequência de valores e pressione ENTER: ");
do {
if(!scanf("%d%c", &i, &c)) {
printf("Valor inválido detectado.");
return 1;
}
insertIn(&l, i);
} while (c != '\n');
printList(l);
printf("\nDigite uma sequência de valores a serem apagados e pressione ENTER: ");
do {
if(!scanf("%d%c", &i, &c)) {
printf("Valor inválido detectado.");
return 1;
}
removeFrom(&l, i);
} while (c != '\n');
printList(l);
return 0;
}
```

135
Algoritmos e Estruturas de Dados I/Semana 04/doubly_linked_list.c Normal file
View File

@ -0,0 +1,135 @@
#include <stdio.h>
#include <stdlib.h>
typedef struct node {
int value;
struct node *prev;
struct node *next;
} Node;
typedef struct {
Node *start;
Node *end;
} List;
void insertIn (List *l, int value) {
Node *prev, *current, *next;
prev = next = NULL;
if (l->start != NULL) {
if (abs(value - l->start->value) < abs(value - l->end->value)) {
next = l->start;
while (next != NULL && next->value < value) {
prev = next;
next = next->next;
}
if (next != NULL && next->value == value)
return;
}
else {
prev = l->end;
while (prev != NULL && prev->value > value) {
next = prev;
prev = prev->prev;
}
if (prev != NULL && prev->value == value)
return;
}
}
current = malloc(sizeof(*current));
current->value = value;
if (prev == NULL) {
current->next = l->start;
l->start = current;
}
else {
current->next = prev->next;
prev->next = current;
}
if (next == NULL) {
current->prev = l->end;
l->end = current;
}
else {
current->prev = next->prev;
next->prev = current;
}
}
void removeFrom (List *l, int value) {
Node *current;
if (l->start == NULL)
return;
if (abs(value - l->start->value) < abs(value - l->end->value)) {
current = l->start;
while (current != NULL && current->value < value)
current = current->next;
}
else {
current = l->end;
while (current != NULL && current->value > value)
current = current->prev;
}
if (current == NULL)
return;
if (current->prev != NULL && current->next != NULL) {
current->prev->next = current->next;
current->next->prev = current->prev;
}
else {
if (current->prev == NULL) {
l->start = current->next;
if (current->next != NULL)
current->next->prev = NULL;
}
if (current->next == NULL) {
l->end = current->prev;
if (current->prev != NULL)
current->prev->next = NULL;
}
}
free(current);
}
void printList (List l) {
int i;
Node *current = l.start;
for (i = 0; current != NULL; i++) {
printf("\nÍndice: %-6d Valor: %-6d (Endereços) Anterior: %p Atual: %p Próximo: %p\n", i, current->value, current->prev, current, current->next);
current = current->next;
}
}
int main () {
int i;
char c;
List l = {0};
printf("Este programa adiciona valores inteiros à uma lista duplamente ligada, e depois permite excluí-los da mesma.\nDigite uma sequência de valores e pressione ENTER: ");
do {
if(!scanf("%d%c", &i, &c)) {
printf("Valor inválido detectado.");
return 1;
}
insertIn(&l, i);
} while (c != '\n');
printList(l);
printf("\nDigite uma sequência de valores a serem apagados e pressione ENTER: ");
do {
if(!scanf("%d%c", &i, &c)) {
printf("Valor inválido detectado.");
return 1;
}
removeFrom(&l, i);
} while (c != '\n');
printList(l);
return 0;
}

99
Algoritmos e Estruturas de Dados I/Semana 04/dynamicList.c Normal file
View File

@ -0,0 +1,99 @@
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
typedef struct item {
int value;
struct item * next;
} Item;
typedef struct {
Item * start;
} List;
int listSize (List * l) {
int size;
Item * index = l->start;
for (size = 0; index != NULL; size++)
index = index->next;
return size;
}
Item * findInOrderedList(int value, List * l) {
Item * index = l->start;
while (index != NULL && index->value < value)
index = index->next;
if (index == NULL || index->value != value)
return NULL;
return index;
}
Item * findInOrderedListAux(int value, List * l, Item * prev) {
prev = NULL;
Item * index = l->start;
while (index != NULL && index->value < value){
prev = index;
index = index->next;
}
if (index == NULL || index->value != value)
return NULL;
return index;
}
bool insertInOrderedList (int value, List * l) {
Item * prev = NULL, * i;
i = findInOrderedListAux(value, l, prev);
if (i != NULL)
return false;
i = malloc(sizeof(*i));
i->value = value;
if (prev == NULL) {
i->next = l->start;
l->start = i;
}
else {
i->next = prev->next;
prev->next = i;
}
return true;
}
bool removeFromOrderedList (int value, List * l) {
Item * prev = NULL, * i;
i = findInOrderedListAux(value, l, prev);
if (i != NULL)
return false;
if (prev == NULL)
l->start = i->next;
else
prev->next = i->next;
free(i);
return true;
}
void reinitializeList (List * l) {
Item * prev, * i = l->start;
while (i != NULL) {
prev = i;
i = i->next;
free(prev);
}
l->start = NULL;
}
int main () {
List l = {0};
Item * index = l.start;
printf("Lista: \"");
while (index != NULL) {
printf("$i ", index->value);
index = index->next;
}
printf("\"\n");
}

98
Algoritmos e Estruturas de Dados I/Semana 04/staticList.c Normal file
View File

@ -0,0 +1,98 @@
#include <stdio.h>
#include <stdbool.h>
#define MAX 50
typedef struct {
int index, next;
} Item;
typedef struct {
Item a[MAX];
int start, open;
} List;
void init (List * l) {
int i;
for (i = 0; i < MAX - 1; i++)
l->a[i].next = i + 1;
l->a[MAX -1].next = EOF;
l->start = EOF;
l->open = 0;
}
int listSize (List * l) {
int i = l->start, size;
for (size = 0; i != EOF; size++)
i = l->a[i].next;
return size;
}
int findInOrderedList (int k, List * l) {
int i = l->start;
while (i != EOF && l->a[i].index < k)
i = l->a[i].next;
if (i == EOF || l->a[i].index != k)
return EOF;
return i;
}
int openIndex (List * l) {
int result = l->open;
if (l->open != EOF)
l->open = l->a[l->open].next;
return result;
}
void returnIndex(int i, List * l) {
l->a[i].next = l->open;
l->open = i;
}
bool insertInSortedList (Item insert, List * l) {
if (l->open == EOF)
return false;
int prev, i = l->start, k = insert.index;
for (prev = EOF; i != EOF && l->a[i].index < k; prev = i)
i = l->a[i].next;
if (i != EOF || l->a[i].index == k)
return false;
i = openIndex(l);
l->a[i].index = k;
if (prev == EOF) {
l->a[i].next = l->start;
l->start = i;
}
else {
l->a[i].next = l->a[prev].next;
l->a[prev].next = i;
}
return true;
}
bool removefromSortedList (List * l, int k) {
int prev, i = l->start;
for (prev = EOF; i != EOF && l->a[i].index < k; prev = i)
i = l->a[i].next;
if (i == EOF || l->a[i].index != k)
return false;
if (prev == EOF)
l->start = l->a[i].next;
else
l->a[prev].next = l->a[i].next;
returnIndex(i, l);
return true;
}

1
BxComp Submodule

@ -0,0 +1 @@
Subproject commit c1df3404964c1ab41cfad7618e7ef8d7b1e85668

69
Cálculo II/Atividade 1/Atividade 1.md Normal file
View File

@ -0,0 +1,69 @@
# Atividade 1
## Capítulo 4.9
### Exercício 29
Encontre $f$, onde $f'''(t) = \cos t$.
#### Resolução
Conforme a tabela dos integrais,
$f'''(t) = \cos t \\
f'' (t) = \sin t + C_1 \\
f' (t) = - \cos t + C_1x + C_2 \\
f(t) = - \sin t + \dfrac{C_1x^2}2 + C_2x + C_3
$
### Exercício 67
Um objeto é lançado para cima com velocidade inicial $v_0$ metros por segundo a partir de um ponto $s_0$ metros acima do solo. Mostre que
$$
[v(t)]^2 = v_0^2 - 19,6[s(t) - s_0]
$$
#### Resolução
$a(t) = v'(t) \approx -9,8 \\
v(t) = a(t)t + C_1 = a(t)t + v_0 = s'(t)\implies t = \dfrac{v(t) - v_0}{a(t)} \\
s(t) = \dfrac{a(t)t^2}2 + v_0t + C_2 = \dfrac{a(t)t^2}2 + v_0t + s_0 \\
s(t) - s_0 = t \left[ \dfrac{a(t)t}2 + v_0 \right] \\\ \\
s(t) - s_0 = \left[ \dfrac{v(t) - v_0}{a(t)} \right] \left[ \dfrac{\cancel{a(t)}}2 \cdot \dfrac{v(t) - v_0}{\cancel{a(t)}} + v_0 \right] \\\ \\
s(t) - s_0 = \dfrac{[v(t) - v_0][v(t) - \cancel{v_0} + \cancel 2v_0]}{2a(t)} \\\ \\
2a(t)[s(t) - s_0] = [v(t)]^2 - v_0^2 \\\ \\
\bm{[v(t)]^2 = v_0^2 -19,6 [s(t) - s_0]}
$
## Capítulo 5.2
### Exercício 37
Calcule a integral de $\int_{-3}^0 (1 + \sqrt{9 - x^2})\ dx$, interpretando-a em termos das áreas.
#### Resolução
$\int_{-3}^0 (1 + \sqrt{9 - x^2})\ dx =\\ \int_{-3}^0 1 \ dx + \int_{-3}^0 \sqrt{9 - x^2}\ dx =\\ 1 \cdot (0 - (-3)) + \int_{-3}^0 \sqrt{9 - x^2}\ dx = 3 + \int_{-3}^0 \sqrt{9 - x^2}\ dx$
Considerando $y = \sqrt{9 - x^2}$ temos que o segundo termo da equação anterior refere-se à uma área posicionada no segundo quadrante ($[-3,0]$) e estritamente positiva ($0 \le y \le 3$). Também percebemos que esta possui forma circular pois a equação se assemelha à aquela do círculo ($y^2 + x^2 = r^2$):
$y = \sqrt{9 - x^2} \implies y^2 + x^2 = 9$
Onde $r^2 = 9$. Assim, substituindo $\int_{-3}^0 \sqrt{9 - x^2}\ dx$ pela área de um quadrante de um círculo de raio $3$, temos:
$\int_{-3}^0 (1 + \sqrt{9 - x^2})\ dx = 3 + \dfrac{9\pi}4$
### Exercício 53
Cada uma das regiões $A$, $B$ e $C$ delimitadas pelo gráfico de $f$ e o eixo $x$ tem área $3$. Encontre o valor de
$$
\int_{-4}^2 [f(x) + 2x +5]\ dx
$$
<img src="file:///home/user/Public/USP/Sistemas%20de%20Informação/2º%20semestre/Cálculo%20II/Imagens/2021-08-31-19-16-21-image.png" title="" alt="" data-align="center">
#### Resolução
$\int_{-4}^2 [f(x) + 2x +5]\ dx = \int_{-4}^2 f(x)\ dx + \underbrace{\int_{-4}^2 2x \ dx}_{\text{função linear}} + \underbrace{\int_{-4}^2 5\ dx}_{\text{função constante}} =\\\ \\ (-3 + 3 - 3) + \left(\dfrac{2 \cdot 4}2 - \dfrac{4 \cdot 8}2 \right) + 5 (2 - (-4)) = \bm{15}$

56
Cálculo II/Atividade 1/Importantes tabelas de Cálculo.md Normal file
View File

@ -0,0 +1,56 @@
# Importantes tabelas de Cálculo
## Tabela das derivadas
| Primitiva | Derivada |
| --------------------------- | ---------------------------------------------------------- |
| $f(x) = c$ | $f'(x) = 0$ |
| $f(x) = x^n$ | $f'(x) = nx^{n - 1}$ |
| $f(x) = c x^n$ | $f'(x) = cnx^{n - 1}$ |
| $f(x) = g(x) h(x)$ | $f'(x) = g(x) h'(x) + g'(x) h(x)$ |
| $f(x) = \dfrac{g(x)}{h(x)}$ | $f'(x) = \dfrac{h(x)g'(x) + g(x) h'(x)}{\big(h(x)\big)^2}$ |
| $f(x) = a^x$ | $f'(x) = a^x\ln a $ |
| $f(x) = log_ax$ | $f'(x) = \dfrac1{x\ln a}$ |
### Derivadas trigonométricas
| Primitiva | Derivada |
| ------------------------- | ------------------------------------ |
| $f(x) = \sin x$ | $f'(x) = \cos x$ |
| $f(x) = \cos x$ | $f'(x) = - \sin x$ |
| $f(x) = \tan x$ | $f'(x) = \sec^2x$ |
| $f(x) = \cot x$ | $f'(x) = -\csc^2x$ |
| $f(x) = \sec x$ | $f'(x) = \sec x \tan x$ |
| $f(x) = \csc x$ | $f'(x) = - \csc x \cot x$ |
| $f(x) = \arcsin x$ | $f'(x) = \dfrac 1{\sqrt{1 - x^2}}$ |
| $f(x) = \arccos x$ | $f'(x) = - \dfrac 1{\sqrt{1 - x^2}}$ |
| $f(x) = \arctan x$ | $f'(x) = \dfrac 1{1 + x^2}$ |
| $f(x) = \text{arccot } x$ | $f'(x) = - \dfrac 1{1 + x^2}$ |
### Regra da cadeia
Se $y$ é uma função derivável de $u$ e $u$ é uma função derivável de $x$, então $y$ é uma função derivável de $x$ e
$$
\dfrac{dy}{dx} = \dfrac{dy}{du} \cdot \dfrac{du}{dx}
$$
## Tabela das integrais
| Derivada | Primitiva |
| -------------------------- | ------------------------------ |
| $cf'(x)$ | $cf(x) + C$ |
| $f'(x) + g'(x)$ | $f(x) + g(x) + C$ |
| $x^n, n \not = -1$ | $\dfrac{x^{n + 1}}{n + 1} + C$ |
| $\dfrac 1x$ | $\ln \|x\| + C$ |
| $e^x$ | $e^x + C$ |
| $a^x$ | $\dfrac{a^x}{\ln \|x\|}$ |
| $\cos x$ | $\sin x + C$ |
| $\sin x$ | $- \cos x + C$ |
| $\sec^2x$ | $\tan x + C$ |
| $\csc^2 x$ | $- \cot x + C$ |
| $\cosh x$ | $\sinh x + C$ |
| $\csc x \cot x$ | $- \csc x + C$ |
| $\sec x \tan x$ | $\sec x + C$ |
| $\dfrac 1{\sqrt{1 - x^2}}$ | $\sin^{-1} + C$ |
| $\dfrac 1{1 + x^2}$ | $\tan^{-1} + C$ |

46
Cálculo II/Atividade 1/Propriedades dos integrais e somatórios.md Normal file
View File

@ -0,0 +1,46 @@
# Propriedades dos integrais e somatórios
## Definição geral dos integrais
$$
\int_a^b f(x)\ dx = \lim_{n \to \infty}
\underbrace{\sum^n_{i = 1} f(x_i) \Delta x}
_{\text{Soma de Reimann}} = \lim_{n \to \infty} \dfrac{b - a}n \sum^n_{i = 1}
f\left(i \cdot \dfrac{b - a}n \right)
$$
## Propriedades dos integrais
1. $\displaystyle \int_a^b f(x)\ dx = - \int_b^a f(x)\ dx$
2. $\displaystyle \int_a^a f(x)\ dx = 0$
3. $\displaystyle \int_a^b c\ dx = c\ (b - a)$
4. $\displaystyle \int_a^b c f(x)\ dx = c \int_a^b f(x)\ dx$
5. $\displaystyle \int_a^b [f(x) \pm g(x)]\ dx = \int_a^b f(x)\ dx \pm \int_a^b g(x)\ dx$
6. $\displaystyle \int_a^b f(x)\ dx + \int_b^c f(x)\ dx = \int_a^c f(x)\ dx$
7. $\displaystyle \int dx = x$
## Propriedades da somatória
1. $\displaystyle \sum^n_{i = 1} i = \dfrac{n (n + 1)}2$[^1]
2. $\displaystyle \sum^n_{i = 1} i^2 = \dfrac{n (n + 1)(2n + 1)}6$
3. $\displaystyle \sum^n_{i = 1} i^3 = \left[\dfrac{n (n + 1)}2\right]^2$
4. $\displaystyle \sum^n_{i = 1} c = nc$
5. $\displaystyle \sum^n_{i = 1} c\ a_i = \displaystyle c \sum^n_{i = 1} a_i$
6. $\displaystyle \sum^n_{i = 1} (a_i \pm b_i) = \sum^n_{i = 1} a_i \pm \sum^n_{i = 1} b_i$
7. $\displaystyle \sum^n_{i = 1} a^i = \dfrac{a(a^n - 1)}{a - 1}$[^2]
[^1]: Fórmula da somatória de uma progressão aritmética
[^2]: Fórmula da somatória de uma progressão geométrica

124
Cálculo II/Atividade 2/Atividade 2.md Normal file
View File

@ -0,0 +1,124 @@
# Atividade 2
Resolução dos exercícios obrigatórios, feita por Guilherme de Abreu Barreto[^1].
## Capítulo 5.3
### Exercício 45
O que está errado com a seguinte equação?
$$
\displaystyle \int^1_{-2} x^{-4}\ dx = \dfrac{x^{-3}}{-3} \Bigg ]^1_{-2} = - \dfrac 38
$$
#### Resolução
A equação em questão faz uso do Teorema Fundamental do Cálculo (TFC) para calcular o valor da integral da função $f(x) = x^{-4}$ no intervalo $[1, -2]$. Entretanto, o TFC, conforme sua definição, aplica-se somente às integrais de **funções contínuas**. Este não é o caso aqui, pois nota-se que $f(x) = x^{-4}$ apresenta descontinuidade no ponto $x = 0$.
### Exercício 65
A função de Fresnel $S$ foi definida no Exemplo 3, e seus gráficos estão nas Figuras 7 e 8.
<img src="file:///home/user/Documents/Drives/USP/Introdução%20a%20Ciência%20da%20Computação/Imagens/2021-09-06-16-23-50-image.png" title="" alt="" data-align="center">
**(a)** Em que valores de x essa função tem valores máximos locais?
**(b)** Em que intervalos a função é côncava para cima?
**(c)** Use um gráfico para resolver a seguinte equação, com precisão de duas casas decimais:
$$
\displaystyle \int^x_0 \sin \left(\dfrac{\pi t^2}2\right)\ dt = \dfrac 15
$$
#### Resolução
**(a)** Conforme se observa pela figura 7, a função de Fresnel apresenta valores máximos e mínimos para os valores de $x$ aqueles em que sua função derivada $S'(x) = \sin (\pi x^2/2)$ tem valor 0. O que ocorre sempre que o valor de $x$ é diferente de 0 e múltiplo de √2:
$$
S'(x) = \sin \left(\dfrac{\pi (n \sqrt 2)^2}2\right) = 0 \implies
\begin{cases}
\text{Máximo local, se \textit k for} \begin{cases}
\text{ímpar e positivo} \\
\text{par e negativo}
\end{cases} \\\ \\
\text{Mínimo local, se k for} \begin{cases}
\text{par e positivo} \\
\text{ímpar e negativo}
\end{cases} \\
\end{cases}
$$
Onde $n$ é um número inteiro e positivo. Ou seja, para $x > 0$ tem-se um máximo local quando:
$$
\dfrac{\pi x^2}2 = (2n + 1)\pi \implies x = \sqrt{2(2n + 1)}
$$
Enquanto, para $x < 0$, isso ocorre quando:
$$
\dfrac{\pi x^2}2 = 2n\pi \implies x = -2\sqrt x
$$
**(b)** Conforme as propriedades das funções derivadas, enquanto a função derivada descreve a localização dos pontos máximos e mínimos da função da qual foi derivada, por vez, a função derivada desta primeira descreve a concavidade desta última: para cima quando $S''(x) > 0$ e para baixo quando $S''(x) < 0$. Onde $S'''(x)$ é:
$$
S'(x) = \sin \left(\dfrac{\pi x^2}2\right) \implies S''(x) = \cos \left(\dfrac{\pi x^2}2\right) \cdot \pi x
$$
Logo, para $x > 0$:
$$
\cos \left(\dfrac{\pi x^2}2\right) \cdot \pi x > 0 \implies \cos \left(\dfrac{\pi x^2}2\right) > 0 \implies 0 < \dfrac{\pi x^2}2 < \dfrac \pi 2
$$
Generalizando:
$$
\left(2n - \dfrac 32 \right)\pi < \dfrac{\pi x^2}2 < \left(2n - \dfrac 12 \right)\pi \\\ \\
\sqrt{4n - 3} < x < \sqrt{4n - 1}
$$
Para qualquer número inteiro e positivo $n$.
De maneira análoga, para $x < 0$:
$$
\cos \left(\dfrac{\pi x^2}2\right) \cdot \pi x > 0 \implies \cos \left(\dfrac{\pi x^2}2\right) < 0 \implies \dfrac \pi 2 < \dfrac{\pi x^2}2 < \dfrac{3\pi} 2
$$
Generalizando:
$$
\left(2n - \dfrac 12 \right)\pi < \dfrac{\pi x^2}2 < \left(2n - \dfrac 32 \right)\pi\\\ \\
\sqrt{4n - 1} < |x| < \sqrt{4n - 3}
$$
**(c)** O gráfico à seguir foi gerado aplicando a fórmula da integral em uma calculadora gráfica e experimentando-se valores para x menores que √2 até ser encontrado o valor aquele que corresponde à área descrita pelo enunciado em **x = 0.74**.
<img src="file:///home/user/Public/USP/Sistemas%20de%20Informação/2º%20semestre/Cálculo%20II/Atividade%202/Imagens/2021-09-06-22-15-00-image.png" title="" alt="" data-align="center">
## Capítulo 5.4
### Exercício 45
Calcule a integral de $\int^2_{-1} (x - 2 |x|)\ dx$
### Resolução
$\text{(I) } \int^2_{-1} (x - 2 |x|)\ dx = \int_{-1}^0 (x + 2x)\ dx + \int_0^2 (x - 2x)\ dx =\\\ \\ 3 \int_{-1}^0 x\ dx - \int_0^2 x\ dx = 3[F(0) - F(-1)] - [F(2) - F(0)] \\\ \\
\text{(II) } f(x) = x \implies F(x) = \dfrac{x^2}2 \\\ \\
\text{(I) e (II) } 3 \cdot - \dfrac 12 - \dfrac 42 = - \dfrac 72
$
### Exercício 67
O custo marginal de fabricação de x metros de um certo tecido é C'(x) = 3 - 0,01x + 0,000006x^2^ US$/m (em dólares por metro). Ache o aumento do custo (A) se o nível de produção for elevado de 2 000 para 4 000 metros.
#### Resolução
$ C'(x) = 3 - 10^{-2}x + 6 \cdot 10^{-6}x \implies C(x) = 3x - \dfrac{10^{-2}}2x^2 + 2 \cdot 10^{-6}x^3\\\ \\A = \displaystyle \int_{2 \cdot 10^3}^{4 \cdot 10^3} C'(x) dx = C(4 \cdot 10^3) - C(2 \cdot 10^3) = \\\ \\4 \cdot 10^3 \left[3 - \dfrac{10^{-2} \cdot 4 \cdot 10^3}2 + 2 \cdot 10^{-6} \cdot 16 \cdot 10^6\right] - 2 \cdot 10^3 (3 - 10 + 8)\\\ \\ = \bm{58 \cdot 10^3 \textbf{ dollares/m}}$
[^1]: nUSP 12543033

BIN
Cálculo II/Atividade 2/Imagens/2021-09-06-22-15-00-image.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 36 KiB

102
Cálculo II/Atividade 3/Atividade 3.md Normal file
View File

@ -0,0 +1,102 @@
# Atividade 3
Resolução dos exercícios obrigatórios, feita por Guilherme de Abreu Barreto[^1].
## Capítulo 5.5
### Exercício 73
Avalie a integral definida:
$$
\int^1_0 \dfrac 1{(1 + \sqrt x)^4}\ dx
$$
#### Resolução
$
\displaystyle \int^1_0 \dfrac 1{(1 + \sqrt x)^4}\ dx \begin{cases}
u = \sqrt x \\
du = \dfrac{x^{-\frac 12}}{2}\ dx = \dfrac{dx}{2\sqrt x} = \dfrac{dx}{2u} \implies 2u\ du = dx
\end{cases}\\\ \\
2 \int^{\sqrt 1 = 1}_{\sqrt 0 = 0} \dfrac{u}{(1 + u)^4}\ du
\begin{cases}
v = 1 + u \implies u = v - 1 \\
dv = du
\end{cases}\\\ \\
2 \int^{1 + 1 = 2}_{0 + 1 = 1} \dfrac{v - 1}{v^4}\ dv =
2 \left[\int^2_1 \dfrac v{v^4}\ dv - \int^2_1 \dfrac 1{v^4}\ dv \right] = 2 \left[ - \dfrac{v^{-2}}2 \Bigg |^2_1 + \dfrac{v^{-3}}3 \Bigg |^2_1 \right] = \\\ \\
2 \left[\dfrac 1{3 \cdot 8} - \dfrac 13 - \dfrac 1{2 \cdot 4} + \dfrac 12\right] = \dfrac 16
$
### Exercício 83
A respiração é cíclica e o ciclo completo respiratório desde o início da inalação até o fim da expiração demora cerca de $5\ s$. A taxa máxima de fluxo de ar nos pulmões é de cerca de $0,5\ L/s$. Isso explica, em partes, porque a função $f(x) = \frac 12 \sin \left(\frac{2\pi t}5\right)$ tem sido frequentemente utilizada para modelar a taxa de fluxo de ar nos pulmões. Use esse modelo para encontrar o volume da ar inalado no instante $t$.
#### Resolução
O volume de ar inalado desde o início do ciclo respiratório (0) até o instante t pode ser aferido pela integral da taxa de fluxo de ar, aferida entre estes dois momentos:
$\displaystyle \int^t_0 \dfrac 12 \sin \left(\dfrac{2\pi x}5\right)\ dx = \dfrac 12 \int^t_0 \sin \left(\dfrac{2\pi x}5\right)\ dx
\begin{cases}
u = \dfrac{2\pi x}5 \\\ \\
du = \dfrac{2 \pi}5\ dx \implies dx = \dfrac 5{2\pi}\ du
\end{cases}\\\ \\
\dfrac 12 \cdot \dfrac 5{2\pi}\int^{\frac{2\pi t}5}_0 \sin u\ du = \dfrac 5{4\pi} \cdot -\cos u \Bigg |^{\frac{2\pi t}5}_0 = \dfrac 5{4\pi} \left[1 - \cos\left(\dfrac{2\pi t}5\right)\right]
$
## Capítulo 7.1
### Exercício 51
Use integração por partes para demonstrar a seguinte redução:
$$
\int (\ln x)^n\ dx = x(\ln x)^n - n\int (\ln x)^{n - 1}\ dx
$$
#### Resolução
Conforme a definição, a fórmula da integração por partes para integrais indefinidas pode ser expressa nos seguintes termos:
$$
\int u \ dv = uv - \int v\ du
$$
Assim o sendo,
$\displaystyle \int (\ln x)^n\ dx
\begin{cases}
u = (\ln x)^n \implies du = n (\ln x)^{n - 1}\ dx\\
dv = dx \implies v = x
\end{cases}\\\ \\
\displaystyle \int (\ln x)^n\ dx = x(\ln x)^n - \int n(\ln x)^{n - 1}\ dx = \bm{x(\ln x)^n - n\int (\ln x)^{n - 1}\ dx }
$
### Exercício 67
Uma partícula que se move ao longo de uma reta tem velocidade igual a $v(t) = t^2e^{-t}$ metros por segundo após t segundos. Qual a distância que essa partícula percorrerá durante os primeiros t segundos?
#### Resolução
A função velocidade trata-se da função derivada da função espaço. Assim o sendo, para obtermos a variação $\Delta S$ entre a posição inicial $S(0)$ e final $S(t)$, temos:
$S(t) = \displaystyle \int \dfrac{t^2}{e^t}\ dt
\begin{cases}
u = t^2 \implies du = 2t\ dt\\
dv = \dfrac{dt}{e^t} \implies v = \int e^{-t}dt
\begin{cases}
w = -t\\ dw = -dt
\end{cases}
\therefore v = - \int e^w\ dw = -e^{-t}
\end{cases}\\\ \\
S(t) = - \dfrac{t^2}{e^t} + 2 \int \dfrac t{e^t}\ dt
\begin{cases}
u = t \implies du = dt \\
dv = \dfrac{dt}{e^t} \implies v = -e^{-t}
\end{cases}\\\ \\
S(t) = - \dfrac{t^2}{e^t} + 2 \left(- \dfrac t{e^t} + \int e^{-t}dt\right) = \dfrac{t^2}{e^t} + 2 \left(-\dfrac{t}{e^t} + \dfrac 1{e^t}\right) + \underbrace C_{=\ S(0)} \\\ \\
\implies \Delta S = \dfrac{-t^2 - 2t + 2}{e^t}
$
[^1]: nUSP 12543033

BIN
Cálculo II/Imagens/2021-08-31-19-16-21-image.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 5.1 KiB

61
Introdução à Análise de Algoritmos/Correção.md Normal file
View File

@ -0,0 +1,61 @@
# Correção
- Identificar invariáveis
- Inicialização
- Manutenção
- Término
## Anotações GDB
- Compilar um programa com a flag `-g` faz com que este programa armazene seu código fonte, permitindo-o ser debugado em sua execução.
- Para se debugar um programa, chama-se este com o comando `gdb` no terminal.
- `run` roda o programa.
- `layout next` muda a forma de exibição da interface.
- `refresh` atualiza a interface.
- `next`, ou `n`, avança o programa em uma linha de comando *no escopo atual*.
- `print`, ou apenas `p`, pode ser utilizado para realizar calculos aritméticos com o valor de variáveis.
- `print var` apresenta o valor da variável var.
- `print vector@x` apresenta os primeiros `x` valores de um vetor `vector`.
- `print *vector@x` apresenta os valores apontados por um vetor de ponteiros `vector`.
- `step` avança o programa em uma linha de comando *no escopo global*, entrando em funções, etc.
- `break x` coloca um ponto de interrupção da execução na linha `x`.
- `break function` coloca um ponto de interrupção da execução no início de uma função `function`.
- `info break` lista todos os pontos de interrupção;
- `del x` apaga o breakpoint de número `x`, tal qual descrito por `info break`.
- `clear function` retira os pontos de interrupção colocados na função `function`.
- `display i` para cada comando seguinte, mostrar o valor de `i`. `undisplay n` cessa este comportamento para a variável de índice `n`.
- `watch [expressão]` (*watchpoint*) interrompe a execução do programa toda vez que o valor de uma expressão se altera.
- `whatis i`, ou `what i`, mostra o tipo da variável `i`.
- `backtrace` (`bt`) no caso de um Segmentation Fault, aponta-se a linha em que este ocorreu e os valores das variáveis à este ponto.
- `finish` executa a função atual e interrompe a execução quando esta termina, indicando onde no código esta retorna e com qual valor.
- `quit` sai do debugger.
## Comandos avançados
- `target record-full` grava a execução e permite voltar para passos anteriores com `reverse-next`, `reverse-step`, `reverse-continue` (`rn`, `rs`).
- `set var i = x` altera o valor da variável `i` para `x` e permite a continuidade da execução do código.

1
Introdução à Análise de Algoritmos/apostila-iaa Submodule

@ -0,0 +1 @@
Subproject commit 66fe50f7094e682862b1e86ce4aee4571725b7d6

67
Matemática Discreta I/Argumentos.md Normal file
View File

@ -0,0 +1,67 @@
# Argumentos
## 1.
**(a)** "*Pode-se vir ao trabalho de ônibus ou carro. Fulano veio ao trabalho de ônibus, logo, não usou seu carro*". Este argumento é falacioso pois as alternativas não são mutuamente exclusivas: fulano pode ter percorrido diferentes partes do trajeto com cada um dos modos de transporte.
**(b)** "Se estiver chovendo, fulano virá com um guarda-chuva. Fulano veio com um guarda-chuva, logo, choveu". Este argumento é falacioso pois o pressuposto e o consequente não se implicam mutuamente. Embora a ocorrência de chuva leve fulano a carregar seu guarda-chuva consigo, por outro lado a não ocorrência de chuva não é proibitiva para que fulano carregue seu guarda-chuva.
**(c)** "Se estiver chovendo, fulano virá com um guarda-chuva. Não choveu, então fulano não virá com um guarda-chuva." A mesma falácia do argumento anterior, mas na sua forma negativa.
## 2.
**(a)** isLower(7, 4) ⟶ ¬ isPrime(7) ∴ ¬ isLower(7, 4) ⟶ isPrime(7)
Se admitimos que ser ou não menor que quatro é condição para não ser ou ser, respectivamente, um número primo, então sim, a proposta é válida. Não obstante, essa condição não é coerente com a definição de número primo.
**(b)** isEqual(l~1~, l~2~) ⟶ isEqual(a~1~, a~2~) ∴ ¬isEqual(l~1~, l~2~) ⟶ ¬ isEqual(a~1~, a~2~)
A conclusão apresentada é correta (congruente com a definição de triângulo isóceles), mas a argumentação feita é inválida (falácia da negação do antecedente).
## 3.
Considerando p ≡ "hoje é terça feira" e q ≡ "João irá trabalhar", a proposição $(p \to q) \land p \to q$ sendo verdadeira equivale à:
Se hoje é terça-feira então João irá trabalhar.
Hoje é terça-feira.
Logo, João irá trabalhar.
## 4.
De maneira análoga ao exemplo anterior, temos que:
Se hoje é terça-feira então João irá trabalhar.
João não irá trabalhar.
Hoje não é terça-feira.
## 5.
**Modus ponendo tollens:** $\neg (p \land q), p \vdash \neg q$
Não é possível Pedro e Quércia ambos ganharem em uma mesma partida de xadrez.
Pedro venceu a partida de xadrez.
Logo, Quércia perdeu a partida.
**Modus tollendo ponens:** $p \lor q, \neg p \vdash q$
Por certo, Pedro ou Quércia compareceriam à reunião.
Pedro não compareceu.
Então Quércia compareceu.
| $p$ | V | V | F | F |
| --------------------------- |:---:|:---:|:---:|:---:|
| $q$ | V | F | V | F |
| $p \to q$ | V | F | V | V |
| $\neg p \to \neg q$ | V | V | F | V |
| $q \to p$ | V | V | F | V |
| $\neg q \to \neg p$ | V | F | V | V |
| $(p \to q) \land (q \to p)$ | V | F | F | V |
| $p \iff q$ | V | F | F | V |

BIN
Matemática Discreta I/Imagens/0369ea5b86b01fc8aeb895c8cb044b3f13f05215.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 26 KiB

310
Matemática Discreta I/Lógica elementar.md Normal file
View File

@ -0,0 +1,310 @@
# Lógica elementar
Respostas à [1ª lista de exercícios](https://classroom.google.com/u/0/c/MzgyMTU0Njc2MjQ1/m/MzgyMTYxMjEwMzg2/details)
## 1.
**(a)** $(q \land \lnot r) \to p$
"*Se o céu está estrelado e não está fazendo frio então Eva vai sair para uma caminhada*"
**(b)** $q \to (\lnot r \to p)$
A proposição acima equivale à $q \to (r \lor p)$, conforme demonstra a seguinte **tabela verdade**:
| $r$ | $p$ | $\lnot r \to p$ | $r \lor p $ |
|:---:|:---:|:---------------:|:-----------:|
| F | F | F | F |
| F | V | V | V |
| V | F | V | V |
| V | V | V | V |
Logo, a oração fica: "*Se o céu está estrelado então está fazendo frio ou Eva vai sair para uma caminhada.*"
**(c)** $\lnot(p \iff (q \lor r))$
Abordemos a proposição em partes:
- $p \iff (q \lor r)$: Eva vai sair para uma caminhada se, e somente se, o céu está estrelado ou está fazendo frio.
- $\lnot(p \iff (q \lor r))$ (a negação da proposta anterior): Eva **não** vai sair para uma caminhada se, e somente se, o céu está estrelado ou está fazendo frio.
**(d)** $p \iff q$
**(e)** $(r \land \lnot q) \to \lnot p$
**(f)** $r \land p$
## 2.
| $p$ | $q$ | $p \to q$ | $\lnot p \lor q $ |
|:---:|:---:|:---------:|:-----------------:|
| F | F | V | V |
| F | V | V | V |
| V | F | F | F |
| V | V | V | V |
## 3.
Se q é uma tautologia, $q \equiv V$ sempre. Enquanto, se r é uma contradição, $r \equiv F$ sempre. Logo,
| $p$ | $q$ | $r$ | $p \lor q$ | $p \land r$ |
|:---:|:---:|:---:|:----------:|:-----------:|
| V | V | F | V | F |
| F | V | F | V | F |
## 4.
**(a)** Nota-se que o valor verdade de tais proposições são equivalentes na tabela verdade:
| $p$ | $q$ | $r$ | $p \land (q \lor r)$ | $(p \land q) \lor (p \land r)$ |
|:---:|:---:|:---:|:--------------------:|:------------------------------:|
| F | F | F | F | F |
| F | V | F | F | F |
| F | F | V | F | F |
| F | V | V | F | F |
| V | V | V | V | V |
| V | V | F | V | V |
| V | F | V | V | V |
| V | F | F | F | F |
**(b)** Tal qual anterioremente,
| $p$ | $q$ | $r$ | $p \lor (q \land r)$ | $(p\lor q) \land (p \lor r)$ |
|:---:|:---:|:---:|:--------------------:|:----------------------------:|
| F | F | F | F | F |
| F | V | F | F | F |
| F | F | V | F | F |
| F | V | V | V | V |
| V | V | V | V | V |
| V | V | F | V | V |
| V | F | V | V | V |
| V | F | F | V | V |
## 5.
Demonstração da segunda lei de Morgan:
| $p$ | $q$ | $\lnot (p \lor q)$ | $\lnot p \land \lnot q$ |
|:---:|:---:|:------------------:|:-----------------------:|
| V | V | F | F |
| V | F | F | F |
| F | V | F | F |
| F | F | V | V |
## 6.
A Lei de Morgan aplica-se de maneira equivalente na teoria dos conjuntos e na lógica proposicional. Veja que o complemento à intercessão entre dois conjuntos $A$ e $B$ é a união dos complementos de $A$ e $B$:
![](/home/user/Public/USP/Sistemas%20de%20Informação/2º%20semestre/Matemática%20Discreta%20I/Imagens/0369ea5b86b01fc8aeb895c8cb044b3f13f05215.png)
Assim o sendo, para $n$ conjuntos $P$ tem-se que:
$$
\left(\bigcap^n_{i = 1}P_i\right)^c = \bigcup^n_{i = 1} P_i^{\ c}
$$
e também:
$$
\left(\bigcup^n_{i = 1} P_i\right)^c = \bigcap^n_{i = 1} P_i^{\ c}
$$
## 7.
**(a)** Tautologia
| $p$ | $q$ | $(p \to q) \lor p$ |
|:---:|:---:|:------------------:|
| V | V | V |
| V | F | V |
| F | V | V |
| F | F | V |
**(b)** Reescrevendo a equação em termos de $\land$ e $\lor$:
$(p \to (q \to r)) \to ((p \to q) \to (p \to r)) \equiv \\
\lnot (\lnot p \lor (\lnot q \lor r)) \lor (\lnot(\lnot p \lor q) \lor (\lnot p \lor r)) \equiv \\
(p \land \lnot (\lnot q \lor r)) \lor ((p\land q) \lor (\lnot p \lor r)) \equiv \\
(p \land (q \land \lnot r)) \lor ((p \land q) \lor (\lnot p \lor r)) \equiv \\
((p \land q) \land (p \land \lnot r)) \lor ((p \land q) \lor (\lnot p \lor r))
$
| $p$ | $q$ | $r$ | $((p \land q) \land (p \land \lnot r)) \lor ((p \land q) \lor (\lnot p \lor r))$ |
|:---:|:---:|:---:|:--------------------------------------------------------------------------------:|
| F | F | F | $(F \land F) \lor (F \lor V) \equiv V$ |
| F | V | F | $(F \land F) \lor (F \lor V) \equiv V$ |
| F | F | V | $(F \land F) \lor (F \lor V) \equiv V$ |
| F | V | V | $(F \land F) \lor (F \lor V) \equiv V$ |
| V | V | V | $(V \land F) \lor (V \lor V) \equiv V$ |
| V | V | F | $(V \land V) \lor (V \lor F) \equiv V$ |
| V | F | V | $(F \land F) \lor (F \lor V) \equiv V$ |
| V | F | F | $(F \land V) \lor (F \lor V) \equiv F$ |
## 8.
| $p$ | $p \lor \lnot p$ | $p \land \lnot p$ |
|:---:|:-------------------:|:--------------------:|
| F | $F \lor V \equiv V$ | $F \land V \equiv F$ |
| V | $V \lor F \equiv V$ | $V \land F \equiv F$ |
## 9.
$p \to (q \to r) \equiv \lnot p \lor (\lnot q \lor r) \equiv \lnot (p \land q) \lor (\lnot p \lor r) \\
(p \to q)\to r \equiv \lnot(\lnot p \lor q) \lor r \equiv (p \land \lnot q) \lor r \equiv (p \lor r) \land (r \lor \lnot q)
$
| $p$ | $q$ | $r$ | $\lnot (p \land q) \lor (\lnot p \lor r)$ | $(p \lor r) \land (r \lor \lnot q)$ |
|:---:|:---:|:---:|:-----------------------------------------:|:-----------------------------------:|
| F | F | F | $V \lor V \equiv V$ | $F \land V \equiv F$ |
| F | V | F | $V \lor V \equiv V$ | $F \land F \equiv F$ |
| F | F | V | $V \lor V \equiv V$ | $V \land V \equiv V$ |
| F | V | V | $V \lor V \equiv V$ | $V \land V \equiv V$ |
| V | V | V | $F \lor V \equiv V$ | $V \land V \equiv V$ |
| V | V | F | $F \lor F \equiv F$ | $V \land F \equiv F$ |
| V | F | V | $V \lor V \equiv V$ | $V \land V \equiv V$ |
| V | F | F | $V \lor F \equiv V$ | $V \land V \equiv V$ |
## 10.
Conforme a seguinte tabela verdade, isso pode ser feito de duas formas: reunindo-se apenas com o representante turco ou, senão, apenas com os representantes turco e russo.
| $a$ | $t$ | $r$ | $(a \land \lnot t) \lor (\lnot a \land t)$ | $(r \lor t)$ | $\lnot (a \land r)$ |
|:---:|:---:|:---:|:------------------------------------------:|:------------:|:-------------------:|
| F | F | F | F | F | V |
| F | V | F | V | V | V |
| F | F | V | F | V | V |
| F | V | V | V | V | V |
| V | V | V | F | V | F |
| V | V | F | F | V | V |
| V | F | V | V | V | F |
| V | F | F | V | F | V |
## 11.
O **princípio da equivalência** descreve que para quaisquer proposições $p$ e $q$ equivalentes entre si que contenham os conectivos $\lnot$, $\land$ ou $\lor$, mas não necessariamente todos, as proposições **duais** destas (proposições obtidas pela substituição de cada $\land$ por $\lor$ e vice-versa; e de cada constante $V$ por $F$ e vice versa) também são equivalentes entre si.
Por exemplo,
$p \land (p \lor p) \iff p$
Como, por hipótese, temos que $p \equiv q$, então
$p \land (p \lor q) \iff p$
Podemos ainda adicionar à formulação anterior o elemento neutro $\lor\ F$:
$(p \lor F) \land (p \lor q) \iff p$
E então simplificá-la:
$\underbrace{p \lor \underbrace{(F \land q)}_{\text{Identidade}}}_{\text{Distributiva}} \iff p \\\ \\
p \lor F \iff p \\
p \iff p
$
Consideremos agora a formulação dual deste mesmo teorema:
$p \lor (p \land q) \iff p \\
(p \land V) \lor (p \land q) \iff p \\
p \land (V \lor q) \iff p \\
p \land V \iff p \\
p \iff p
$
Fica demonstrado que realizando as substituições propostas, "duais", alcançamos resultados equivalentes.
## 12.
Podemos descrever o XOR em termos de conjunção e disjunção da seguinte forma:
$$
p\ \underline \lor\ q \equiv (p \land \lnot q) \lor (\lnot p \land q)
$$
Assim, para este temos a seguinte tabela verdade:
| $p$ | $q$ | $(p \land \lnot q) \lor (\lnot p \land q)$ |
|:---:|:---:|:------------------------------------------:|
| F | V | V |
| F | F | F |
| V | V | F |
| V | F | V |
## 13.
**(a)** Vamos simplificar a proposição e admitir que esta seja falsa:
$$
(p \iff (\neg q \lor r)) \to (\neg p \to q) \equiv
(p \iff (\neg q \lor r)) \to (p \lor q) \equiv F
$$
Analizemos a tabela verdade para identificar os valores de $(p \iff (\neg q \lor r))$ e $(p \lor q)$ que levam a este resultado:
| $(p \iff (\neg q \lor r))$ | $(p \lor q)$ | $(p \iff (\neg q \lor r)) \to (p \lor q)$ |
|:--------------------------:|:------------:|:-----------------------------------------:|
| V | V | V |
| V | F | F |
| F | V | V |
| F | F | V |
Apenas quando $(p \iff (\neg q \lor r)) \equiv V$ e $(p \lor q) \equiv F$ obtêm-se tal resultado. Para $(p \lor q) \equiv F$, $p \equiv q \equiv F$. Substituindo estes valores, temos:
$(F \iff (\neg F \lor r)) \equiv V \\
(F \iff (V \lor r)) \equiv V \\
F \iff V \equiv V
$
Chegamos a um absurdo. Assim o sendo, não é possível que esta expressão seja falsa: trata-se de uma **tautologia**.
**(b)** $(p \to (q \lor r)) \lor (p \lor q) \equiv (p \to q) \lor (p \to r)\ \cancel{\lor\ (p \to q)}\ \equiv p \to (q \lor r) \equiv F$
Para produzir esse resultado bastaria que $p \equiv V$ e $q \equiv r \equiv F$. Qualquer outra configuração não produziria resultado verdadeiro. Não se reduziu ao absurdo, esta não se trata de uma tautologia ou contradição.
## 14.
**(a)** $p \land q \equiv \neg(\neg p \lor \neg q)$
**(b)** $p \to q \equiv \neg p \lor q$
**(c)** $p \to q \equiv \neg(p \land \neg q)$
**(d)** $p \land q \equiv \neg (p \to \neg q)$
**(e)** $p \lor q \equiv \neg p \to q$
## 15.
**(a)**
| $p$ | $q$ | $p \uparrow q$ | $\neg p \uparrow \neg q$ |
|:---:|:---:|:--------------:|:------------------------:|
| V | V | F | V |
| V | F | V | V |
| F | V | V | V |
| F | F | V | F |
**(b)**
$\neg p \iff p \uparrow p$
$p \land q \iff (p \uparrow q) \uparrow (p \uparrow q)$
$p \lor q \iff (p \uparrow p) \uparrow (q \uparrow q)$
**(c)**
$(p \to q) \iff p \uparrow (q \uparrow q) \iff p \uparrow (p \uparrow q)$
$(p \iff q) \iff (p \uparrow q) \uparrow ((p \uparrow p) \uparrow (q \uparrow q))$
## 16.
**(a)** $(p \iff (((\neg q) \lor r) \to p)) \equiv \\
p \iff ((\neg q \lor r) \to p) \equiv \\
(p \iff \neg q \lor r) \to (p \iff p) \equiv \\
p \iff \neg q \lor r\ \underbrace{\to p}_{\text{redundante}} \equiv \\
p \iff \neg q \lor r
$
**(b)** Como assim? O próprio enunciado demonstrou.

62
Matrizes, Vetores e Geometria Analítica/01 - Definição de Espaço Vetorial.md Normal file
View File

@ -0,0 +1,62 @@
# Definição de *Espaço Vetorial*
Todo conjunto $V \not = \empty$ definido sobre um campo qualquer $\mathbb D$[^1] (por exemplo, $\R$ ou $\mathbb C$) em que existe:
1. adição $(u, v) \in V \mapsto u + v \in V$
2. e multiplicação $(a, u), a \in \R, u \in V \mapsto au \in V$
com determinados axiomas (8 no total).
## I. Propriedades da adição
Para $\forall u, v, w \in V$:
1. Comutação
$$
u + v = v + u
$$
2. Associação
$$
u + (v + w) = (u + v) + w
$$
3. Existe um elemento neutro, aqui indicado por $e$, que não altera o resultado de uma adição ao ser acrescentado nesta
$$
\exist\ e \in V \mid u + e = u
$$
4. Para todo elemento $u$ existe um *oposto* $(-u)$ tal que:
$$
\exist\ (-u) \in V \mid u + (-u) = e
$$
## II. Propriedades da multiplicação
Para $\forall a, b \in \R$ e $\forall u, v \in V$:
1. $a(bu) = (ab)u$
2. $(a + b)u = au + bu$
3. $a(u + v) = au + av$
4. $1u = u$
## O espaço vetorial $\R^n$
As propriedades anteriormente descritas se aplicam a qualquer n-upla de números ordenados:
$
(x_1, y_1) + (x_2, y_2) = (x_1 + x_2, y_1 + y_2), \forall x, y \in \R^2 \\
(x_1, y_1, z_1) + (x_2, y_2, z_2) = (x_1 + x_2, y_1 + y_2, z_1 + z_2), \forall x, y, z \in \R^3 \\
\vdots \\
(a_1, \dots a_n) + (b_1, \dots, b_n) = (a_1 + b_1, \dots a_n + b_n), \forall a_1, \dots, a_n, b_1, \dots, b_n \in \R^n
$
[^1]: Daqui por diante assumiremos $\R$, mas tais propriedades aplicariam-se a qualquer outro campo.

115
Matrizes, Vetores e Geometria Analítica/02 - Propriedades do Espaço Vetorial.md Normal file
View File

@ -0,0 +1,115 @@
# Propriedades do Espaço Vetorial
Admitindo $\forall a, b \in \R$ e $\forall u, v \in V$,
## P1
$ae = e$
**Prova:** Dados os axiomas I-3, I-4 e II-3 e da definição de espaço vetorial, têm-se:
$ae = a(e) = \overbrace{a\underbrace{(e + e)}_{\text{I-3}}}^{\text{II-3}} = ae +ae\\ \implies \underbrace{ae + e}_{\text{I-3}} = ae + ae\\ \implies ae + ae + (-ae ) = ae + ae\\ \implies ae + (-ae) = ae + ae + (-ae)\\ \implies \overbrace{e = \underbrace{ae + \cancel e}_{I-3}}^{I-4}$
## P2
$0u = e$
**Prova:** $0u = u(0 + 0) = 0u + 0u \implies 0u + (-0u) = 0u + 0u + (-0u) \implies e = 0u + \cancel e$
## P3
$au = e \iff a = 0 \lor u = e$.
**Prova:** Suponhamos que $a \not= 0$, daí existe o número real $a^{-1}$. Assim, temos:
$$
au = e \implies \dfrac{au}a = \dfrac ea
$$
Aplicando-se os axiomas II-1, II-4 e a propriedade 1:
$$
\underbrace{\dfrac{au}a = \left(\dfrac aa\right) u}_{\text{II-1}} =
\underbrace{1u = u}_{\text{II-4}} \\\ \\
\dfrac ea = \underbrace{a^{-1}e = e}_{\text{P1}}\\\ \\
\therefore u = e
$$
## P4
$(-a)u = a(-u) = -(au)$
**Prova:** Aplicando-se o axioma I-4 e a propriedade 2, temos:
$(au) + (-au) = e \\
\implies au + (-au) = au + (-a)u \\
\implies au + (-au) + (-au) = au + (-a)u + (-au) \\
\implies (-au) + e = (-a)u + e \\
\implies (-au) = (-a)u
$
E um raciocínio análogo demonstrará que $a(-u) = -(au)$.
## P5
$(a - b)u = au - bu$
**Prova:** $(a - b)u = (a + (-b))u = au + (-bu) = au - bu$
## P6
$b\left(\displaystyle \sum^n_{i = 1} a_iu_i\right) = \sum^n_{i = 1} (ba_i)u_i$
**Prova:** Faz-se por indução a partir dos axiomas II-1 e II-3.
## P7
O vetor nulo ($e$) de qualquer espaço vetorial $V$ é único.
**Prova:** digamos que, sei lá, existe $g$ que, tal qual $e$, satisfaz a propriedade I-3
$$
\exist\ e \in V \mid u + e = u
$$
Assim, $e = e + u = u + g = g \implies e = g
$.
## P8
Para cada vetor $u$ de um espaço vetorial $V$ existe um único vetor $(-u)$ oposto de $u$.
**Prova:** Digamos que existe $g$ tal que $u + g = e$. Daí então,
$$
-u = -u + e = -u (u + g) = (-u + u) + g = e + g = g
$$
## P9
Para cada $u \in V$ tem-se $-(-u) = u$.
**Prova:** $u + (-u) = e \implies u = -(-u) + e \implies u = -(-u)$
## P10
$u + v = u + w \iff v = w$
**Prova:**
$$
(-u) + (u + v) = (-u) + (u + w) \implies ((-u) + u) + v = (-u) + (u + w) \\
e + v = e + w \\
v = w
$$
## P11
Existe um único vetor $v$ tal que $u + v = w$.
**Prova:**
$(-u) + u + v = (-u) + w \implies e + v = w + (-u) \implies v = w + (-u)$

31
Matrizes, Vetores e Geometria Analítica/03 - Definição de sub-espaço vetorial.md Normal file
View File

@ -0,0 +1,31 @@
# Definição de sub-espaço vetorial
Seja $V$ um espaço vetorial sobre $\R$. Um **sub-espaço vetorial** $W$ de $V$ é um subconjunto $W \subset V$ tal que possui as mesmas propriedades de espaço vetorial (possui um elemento neutro, possui adição e multiplicação) restritas a um alguns dos elementos presentes no espaço $V$ (senão todos).
## Combinações Lineares
Tomemos um subconjunto $S = {u_1, \dots , u_n} \subset V$. Indiquemos por $[S]$ o seguinte subconjunto:
$$
[S] = \{a_1u_1 + \dots + a_nu_n \mid a_1, \dots a_n \in \R\}
$$
O sub-espaço $[S]$ recebe o nome de *sub-espaço gerado por $S$*. Cada elemento de $[S]$ é uma combinação linear de $S$.
Por enquanto um conjunto $S$ seja finito, o conjunto $[S]$, exemplificado acima, abarca o produto de todos os valores de $S$ por todos os valores em $\R$ e é, portanto, **infinito**.
## Espaços vetoriais finitamente gerados
Um espaço vetorial $V$ é finitamente gerado se existe $S \subset V$, $S$ finito, tal que $V = [S]$. Por exemplo, observemos, em $\R^3$, o conjunto:
$$
S = \{(1,0,0), (0,1,0), (0,0,1)\}
$$
Onde
$$
a = (1,0,0);\ b = (0,1,0);\ c = (0,0,1)
$$
Podemos dizer que os vetores em $S$ correspondem à, ou geram um, espaço $\R^3$, e $[S]$ abarca a todos os valores contidos neste.

5
Matrizes, Vetores e Geometria Analítica/04 - Dependência linear.md Normal file
View File

@ -0,0 +1,5 @@
# Dependência linear
Seja $V$ um espaço vetorial sobre $\R$.