Arvore AVL, complexidade, AVL grafica entre outros mais recentes

UNP/.vscode/settings.json

@@ -8,5 +8,10 @@
     "[python]": {
         "editor.defaultFormatter": "ms-python.autopep8"
     },
-    "python.formatting.provider": "none"
+    "python.formatting.provider": "none",
+    "cSpell.words": [
+        "declaracao",
+        "Dinamica",
+        "posicao"
+    ]
 }

UNP/.vscode/tasks.json

@@ -3,13 +3,25 @@
         {
             "type": "cppbuild",
             "label": "C/C++: gcc.exe arquivo de build ativo",
-            "command": "C:\\Program Files\\CodeBlocks\\MinGW\\bin\\gcc.exe",
+            "command": "clang",
             "args": [
                 "-fdiagnostics-color=always",
                 "-g",
                 "${file}",
                 "-o",
-                "${fileDirname}\\${fileBasenameNoExtension}.exe"
+                "-ferror-limit=1",
+                "-gdwarf-4",
+                "-ggdb3",
+                "-O0",
+                "-std=c11",
+                "-Wall",
+                "-Werror",
+                "-Wextra",
+                "-Wno-gnu-folding-constant",
+                "-Wno-sign-compare",
+                "-Wno-unused-parameter",
+                "-Wshadow",
+                "${fileDirname}\\${fileBasenameNoExtension}.out"
             ],
             "options": {
                 "cwd": "${fileDirname}"
@@ -21,7 +33,7 @@
                 "kind": "build",
                 "isDefault": true
             },
-            "detail": "Tarefa gerada pelo Depurador."
+            "detail": "Tarefa gerada pelo Ed."
         }
     ],
     "version": "2.0.0"

UNP/2024/1seg/arrays/cumprimente.c

@@ -1,10 +1,12 @@
 #include <stdio.h>
 
-int main(int argc, char *argv[]) {
+int main(int argc, char *argv[])
+{
   // espera o usuário executar com o nome do usuário. Assim:
   // ./cumprimente Edkallenn. A saída será:
   // Olá Edkallenn, seja bem vindo!
-  if (argc != 2) {
+  if (argc != 2)
+  {
     printf("Faltando argumento de linha de comando!\n");
     return 1;
     // neste caso faltaram argumentos (ou foram demais.)
@@ -13,8 +15,8 @@ int main(int argc, char *argv[]) {
   }
   printf("Olá %s, seja bem vindo!\n", argv[1]);
 
-  // para verificar o retorno do aplicativo (se retornou 0 ou 1 bsta fazer: 
-  // echo $? 
+  // para verificar o retorno do aplicativo (se retornou 0 ou 1 bsta fazer:
+  // echo $?
   // no prompt do terminal)
   return 0;
 }

UNP/2024/1seg/arrays/media.c

@@ -0,0 +1,43 @@
+#include <stdio.h>
+void le_notas(float[], int);
+void exibe_notas(float[], int);
+float calcula_media(float *notas, int quantidade);
+int main()
+{
+    int quantidade;
+    printf("Digite a quantidade de notas: ");
+    scanf(" %d", &quantidade);
+
+    float notas[quantidade];
+    le_notas(notas, quantidade);
+    exibe_notas(notas, quantidade);
+    float media = calcula_media(notas, quantidade);
+    printf("A média foi: %g\n", media);
+}
+
+void le_notas(float array[], int n)
+{
+    for (int i = 0; i < n; i++)
+    {
+        printf("Digite a nota %d: ", i + 1);
+        scanf(" %f", &array[i]);
+    }
+}
+
+void exibe_notas(float array[], int n)
+{
+    for (int i = 0; i < n; i++)
+    {
+        printf("Nota[%d]: %f \n", i + 1, array[i]);
+    }
+}
+
+float calcula_media(float *notas, int quantidade)
+{
+    float soma = 0;
+    for (int i = 0; i < quantidade; i++)
+    {
+        soma += notas[i];
+    }
+    return soma / quantidade;
+}

UNP/2024/1seg/arrays/media_dinamica.c

@@ -0,0 +1,54 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+void le_notas(float[], int);
+void exibe_notas(float[], int);
+float calcula_media(float *notas, int quantidade);
+
+int main()
+{
+    int quantidade;
+    printf("Digite a quantidade de notas: ");
+    scanf(" %d", &quantidade);
+
+    // float notas[quantidade];
+    float *notas;
+    notas = malloc(sizeof(float) * quantidade);
+    if (notas == NULL)
+    {
+        printf("Erro ao alocar a memória!\n");
+        exit(1);
+    }
+
+    le_notas(notas, quantidade);
+    exibe_notas(notas, quantidade);
+    float media = calcula_media(notas, quantidade);
+    printf("A média foi: %g\n", media);
+}
+
+void le_notas(float array[], int n)
+{
+    for (int i = 0; i < n; i++)
+    {
+        printf("Digite a nota %d: ", i + 1);
+        scanf(" %f", &array[i]);
+    }
+}
+
+void exibe_notas(float array[], int n)
+{
+    for (int i = 0; i < n; i++)
+    {
+        printf("Nota[%d]: %f \n", i + 1, array[i]);
+    }
+}
+
+float calcula_media(float *notas, int quantidade)
+{
+    float soma = 0;
+    for (int i = 0; i < quantidade; i++)
+    {
+        soma += notas[i];
+    }
+    return soma / quantidade;
+}

UNP/2024/1seg/basico/long_long.c

@@ -0,0 +1,34 @@
+#include <stdio.h>
+#include <limits.h>
+
+int main()
+{
+    printf("Tamanho de um long long em bytes: %d\n", sizeof(long long));
+    printf("Tamanho de um long em bytes: %d\n", sizeof(long));
+
+    printf("Maior valor de um int: %d\n", INT_MAX);
+    printf("Maior valor de um long: %ld\n", LONG_MAX);
+    printf("Maior valor de um long long: %lld\n", LLONG_MAX);
+
+    return 0;
+}
+
+/*
+    O tamanho de um long long é 8 bytes, e o tamanho de um long é 4 bytes.
+    O maior valor de um int é 2,147,483,647, e o maior valor de um long é 9,223,372,036,854,775,807.
+*/
+
+/*
+    O tamanho de um long long é 8 bytes, e o tamanho de um long é 4 bytes.
+    O maior valor de um int é 2,147,483,647, e o maior valor de um long é 9,223,372,036,854,775,807.
+*/
+
+/*
+    O tamanho de um long long é 8 bytes, e o tamanho de um long é 4 bytes.
+    O maior valor de um int é 2,147,483,647, e o maior valor de um long é 9,223,372,036,854,775,807.
+*/
+
+/*
+    O tamanho de um long long é 8 bytes, e o tamanho de um long é 4 bytes.
+
+*/

UNP/2024/1seg/basico/teste.py

@@ -0,0 +1,31 @@
+print("Calculando fatoriais de 1 a 15")
+
+
+def calcular_fatorial(valor):
+    contador = 1
+    resultado = 0
+    listaDeFatoriais = []
+
+   # listagem de fatorial
+
+    while contador <= valor:
+        listaDeFatoriais.insert(0, contador)
+        contador = contador + 1
+
+    # multiplicando os fatoriais
+    if len(listaDeFatoriais) > 1:
+        for x in range(len(listaDeFatoriais)-1):
+            if x == 0:
+                resultado = listaDeFatoriais[x] * listaDeFatoriais[x+1]
+            else:
+                resultado = resultado * listaDeFatoriais[x+1]
+
+    else:
+        resultado = listaDeFatoriais[0]
+
+    return resultado
+
+
+for x in range(16):
+    if x != 0:
+        print(f"O fatorial de {x} é: ", calcular_fatorial(x))

UNP/2024/1seg/funcoes/armstrong.c

@@ -0,0 +1,49 @@
+#include <math.h>
+#include <stdbool.h>
+#include <stdio.h>
+
+// Função para contar os dígitos de um número
+long long contar_digitos(int n)
+{
+    if (n == 0)
+        return 1;
+    int contador = 0;
+    while (n != 0)
+    {
+        n /= 10;
+        contador++;
+    }
+    return contador;
+}
+
+// Função para verificar se um número é um número de Armstrong
+bool eh_numero_armstrong(int n)
+{
+    long original = n;
+    long long soma = 0;
+    long long num_digitos = contar_digitos(n);
+    while (n != 0)
+    {
+        int digito = n % 10;
+        soma += pow(digito, num_digitos);
+        n /= 10;
+    }
+    return original == soma;
+}
+
+int main()
+{
+
+    int num;
+    printf("Digite um número inteiro: ");
+    scanf(" %d", &num);
+    printf("Números de Armstrong entre 1 e %d:\n", num);
+    for (int i = 1; i <= num; i++)
+    {
+        if (eh_numero_armstrong(i))
+        {
+            printf("%d\n", i);
+        }
+    }
+    return 0;
+}

UNP/2024/1seg/funcoes/fat-crescente-decrescente.c

@@ -0,0 +1,37 @@
+#include <stdio.h>
+
+// Função para calcular a potência fatorial crescente
+int potencia_fatorial_crescente(int x, int n)
+{
+    int resultado = 1;
+    for (int i = 1; i <= n; i++)
+    {
+        resultado *= (x + i - 1);
+    }
+    return resultado;
+}
+
+// Função para calcular a potência fatorial decrescente
+int potencia_fatorial_decrescente(int x, int n)
+{
+    int resultado = 1;
+    for (int i = n; i > 0; i--)
+    {
+        resultado *= (x - i + 1);
+    }
+    return resultado;
+}
+
+int main()
+{
+    int x = 3;
+    int n = 5;
+
+    int resultado_crescente = potencia_fatorial_crescente(x, n);
+    int resultado_decrescente = potencia_fatorial_decrescente(x, n);
+
+    printf("A potência fatorial crescente de %d^%d = %d\n", x, n, resultado_crescente);
+    printf("A potência fatorial decrescente de %d_%d = %d\n", x, n, resultado_decrescente);
+
+    return 0;
+}

UNP/2024/1seg/funcoes/fibonacci_maximo.c

@@ -0,0 +1,41 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int *fibonacci_max(int max)
+{
+    int n = 2;
+    int *fibs = malloc(sizeof(int) * (max + 2));
+    fibs[0] = 0;
+    fibs[1] = 1;
+
+    while (fibs[n - 1] <= max)
+    {
+        fibs[n] = fibs[n - 1] + fibs[n - 2];
+        n++;
+    }
+
+    fibs[n] = -1;
+    return fibs;
+}
+
+int main()
+{
+    int max;
+    printf("Digite o valor máximo: ");
+    scanf("%d", &max);
+
+    int *fibs = fibonacci_max(max);
+    int i = 0;
+
+    printf("Sequência de Fibonacci até %d: ", max);
+    while (fibs[i] != -1)
+    {
+        printf("%d ", fibs[i]);
+        i++;
+    }
+
+    printf("\n");
+
+    free(fibs);
+    return 0;
+}