Added GDB annotations

2021/2/entrada.c

@@ -0,0 +1,41 @@
+#include <stdio.h>
+#include <stdbool.h>
+#include <math.h>
+
+bool isPrime (int num) {
+    int i;
+
+    if (num < 2)
+        return false;
+    for(i = 3; i < sqrt(num); i++)
+        if(num % i == 0)
+            return false;
+    return 0;
+}
+
+void countProducts() {
+    int n1, n2, cod, p, np;
+    p = np = 0;
+
+    while (scanf(" %d", &cod) && cod != 0) {
+        if(isPrime(cod))
+            p++;
+        else
+            np++;
+    }
+    if((n1 == p && n2 == np) || n1 + n2 == p || n1 + n2 == np)
+        printf("ROGeRIO POH DEIXAR ESSX AQUI ENTRAR QUE TA LIMPO\n");
+    else if (p == np && np == 0)
+        printf("vei sem nada neah? vai gasta moh grana ai dentro\n");
+    else
+        printf("tu ta achando q vai pa onde co essas muamba ai? va vende isso noutro lugar\n");
+
+}
+
+int main(){
+    int n;
+
+    for(scanf(" %d", &n); n > 0; n--)
+        countProducts();
+    return 0;
+}

2021/2/robo.c

@@ -0,0 +1,81 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int readElement() {
+    int i;
+    char c;
+
+    if (scanf(" %d", &i))
+        return i;
+    scanf(" %c", &c);
+    return c;
+}
+
+int ** readMatrix (int l, int c) {
+    int i, j, **matrix = malloc(l * sizeof(int *));
+
+    matrix[0] = malloc(c * sizeof(int));
+    matrix[0][0] = c;
+    matrix[0][1] = l;
+    for (i = 2; i < c; i++)
+        matrix[0][i] = readElement();
+    for (i = 1; i < l; i++) {
+        matrix[i] = malloc(c * sizeof(int));
+        for (j = 0; j < c; j++)
+            matrix[i][j] = readElement();
+    }
+    return matrix;
+}
+
+void freeMatrix (int **matrix, int l) {
+    int i;
+
+    for (i = 0; i < l; i++)
+        free (matrix[i]);
+}
+
+char * findFlavor (int **matrix, int l, int c, char food[30]) {
+    int i, j, m, n;
+    char *flavor = malloc(30 * sizeof(char));
+
+    for (i = m = n = 0; i < c; i++) {
+        for (j = 0; j < l; j++) {
+            if (food[m] != '\0')
+                if (matrix[j][i] == (int) food[m])
+                    m++;
+                else
+                    m = (matrix[j][i] == (int) food[0]) ? 1 : 0;
+            else {
+                if (matrix[j][i] >= 65 && matrix[j][i] <= 90)
+                    flavor[n++] = matrix[j][i];
+                else {
+                    flavor[n] = '\0';
+                    freeMatrix(matrix, l);
+                    return flavor;
+                }
+            }
+        }
+    }
+    freeMatrix(matrix, l);
+    return NULL;
+}
+
+int main () {
+    int n, l, c;
+    char food[30], *flavor;
+
+    n = l = c = 0;
+    for (scanf("%d", &n); n > 0; n--) {
+        scanf("%s %d %d", food, &l, &c);
+        flavor = findFlavor(readMatrix(l, c), l, c, food);
+        if (!flavor)
+            printf("Não foi possível determinar o sabor real de %s.\n", food);
+        else if (strcmp(food, flavor) == 0)
+            printf("Tá limpo!\n%s tem gosto de %s mesmo\n", food, flavor);
+        else
+            printf("Algum robo maldito mudou meu prato!!!\n%s tem sabor de %s\n", food, flavor);
+        free(flavor);
+    }
+    return 0;
+}

2021/Anotações.md

@@ -0,0 +1,51 @@
+# Anotações GDB
+
+- Compilar um programa com a flag '-O0' desabilita que o compilador realize otimizações no código, enquanto `-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`, ou `r`, roda o programa. `r < file.txt` passa um arquivo como argumento para a execução.
+
+- `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.