Portifólio 02: Paradigmas Imperativo, Funcional
Published: 2024-04-10 15:02:39

O objetivo deste portfólio é apresentar as atividades desenvolvidas por nós (Hérika e Gabriel Aleixo), com base nas aulas da disciplina de laboratório de programação, na qual abordamos os Problemas em Paradigmas Imperativos: Estruturas de Dados, Problemas em Paradigmas Funcionais: Processamento de Strings, Problemas em Paradigmas Funcionais: Matemáticos. 

Os codigos apresentados neste portifólio, serão: 
COD 00 - Inserção e exclusão de elementos;
COD 01 - Inserção e deleção em uma lista;
COD 02 - cálculo do comprimento C;
COD 03 - Indexação PYTHON;
COD 04 - Manipulação de Strings JAVA;
COD 05 - Cálculo do comprimento;
COD 06 - Tabuada;

## Paradigma Imperativo

O paradigma imperativo determina que as instruções passadas ao computador devem especificar o passo a passo das ações que serão executadas. Tais ações mudam o estado do programa através do uso de variáveis que ficam armazenadas em memória, até chegar a um resultado esperado. O foco do paradigma está em determinar o “como” deve ser feito.


## Paradigma Funcional
O paradigma funcional é aquele que destaca o uso das funções e, na hora de resolver um problema, o divide em blocos onde são implementadas funções.

Estas funções definem algumas variáveis que podem ou não retornar resultados.

Este paradigma é indicado quando a resolução de algum entrave depende majoritariamente de uma base matemática. Após a conclusão, esta solução deverá ser integrada.

---
Nesta aula foram apresentados os conceitos de estrutura de dados e proposto para fazer um programa de inserção e exclusão de elementos.

**COD 00 - Inserção e exclusão de elementos:**

```
#include <stdio.h>
#include <stdlib.h>


struct noArv {
    int cpf;
    struct noArv* esq;
    struct noArv* dir;
};

typedef struct noArv Arv;

void imprimeEmOrdem (Arv* a);

Arv* insere (Arv* a, int cpf);
Arv* retira (Arv* r, int cpf);


void imprimeEmOrdem(Arv* a) {
    if (a != NULL) {
        imprimeEmOrdem(a->esq);
        printf("%d ", a->cpf);
        imprimeEmOrdem(a->dir);
    }
}

Arv* insere( Arv* a, int cpf) {
    if (a == NULL) {
        a = (Arv*)malloc(sizeof(Arv));
        a->cpf = cpf;
        a->esq = NULL;
        a->dir = NULL;
    } else if (cpf < a->cpf) {
        a->esq = insere (a->esq, cpf);
    } else if (cpf > a->cpf) {
        a->dir = insere(a->dir, cpf);
    }
    return a;
}

Arv* retira (Arv* r, int cpf){
    if (r==NULL) {
        return NULL;
    } else if (r->cpf > cpf) {
        r->esq = retira(r->esq, cpf);
    } else if (r-> cpf < cpf) {
        r->dir = retira(r->dir, cpf);
    } else {
        if (r->esq == NULL && r->dir == NULL) {
            free (r);
            r = NULL;
        } else if (r->esq == NULL) {
            Arv* aux = r;
            r = r->dir;
            free (aux);
        } else if (r->dir == NULL) {
            Arv* aux = r;
            r = r->esq;
            free (aux);
        }
    }
    return r;
}

void main() {

Arv* a = NULL;

    a = insere(a, 1254);
    a = insere(a, 2352);
    a = insere(a, 3412);
    a = insere(a, 4201);
    a = insere(a, 5698);

    printf("Saída:\n");
    imprimeEmOrdem(a);

    a = retira(a, 4201);


    printf("\n\nDepois de retirar o elemento 4201:\n");
    imprimeEmOrdem(a);
}

```
Execução do codigo: [Excute aqui!](https://onlinegdb.com/TmOsoDITJ)

---

**COD 01 - Inserção e deleção em uma lista:**

```
#include <stdio.h>
#include <stdlib.h>

// Definição da estrutura do nó da lista
struct Node {
    int data;           // Dado do nó
    struct Node* prev;  // Ponteiro para o nó anterior
    struct Node* next;  // Ponteiro para o próximo nó
};

// Função para criar um novo nó
struct Node* createNode(int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    if (newNode != NULL) {
        newNode->data = data;
        newNode->prev = NULL;
        newNode->next = NULL;
    }
    return newNode;
}

// Função para inserir um novo nó no início da lista
void insertAtBeginning(struct Node** head, int data) {
    struct Node* newNode = createNode(data);
    if (newNode != NULL) {
        newNode->next = *head;
        if (*head != NULL) {
            (*head)->prev = newNode;
        }
        *head = newNode;
    }
}

// Função para deletar um nó da lista
void deleteNode(struct Node** head, int data) {
    struct Node* current = *head;

    while (current != NULL && current->data != data) {
        current = current->next;
    }

    if (current == NULL) {
        printf("Nó com valor %d não encontrado na lista.\n", data);
        return;
    }

    if (current->prev != NULL) {
        current->prev->next = current->next;
    } else {
        *head = current->next;
    }

    if (current->next != NULL) {
        current->next->prev = current->prev;
    }

    free(current);
}

// Função para imprimir a lista do início ao fim
void printListForward(struct Node* head) {
    printf("Lista (do início ao fim): ");
    while (head != NULL) {
        printf("%d ", head->data);
        head = head->next;
    }
    printf("\n");
}

int main() {
    // Cabeça da lista (inicialmente vazia)
    struct Node* head = NULL;

    // Inserção de elementos no início da lista
    insertAtBeginning(&head, 30);
    insertAtBeginning(&head, 20);
    insertAtBeginning(&head, 10);

    // Impressão da lista do início ao fim
    printListForward(head);

    // Deleção de um elemento
    deleteNode(&head, 20);

    // Impressão da lista após deleção
    printListForward(head);

    // Liberação da memória da lista
    while (head != NULL) {
        struct Node* temp = head;
        head = head->next;
        free(temp);
    }

    return 0;
}
```
Execução do codigo: [Excute aqui!](https://onlinegdb.com/jENoYfxdo)

---

**Paradigma Procedural**

Esta aula foi sobre processamento de Strings. A seguir alguns exemplos de programas de manipulação de Strings, em C, Python e Java. 

**Processamento de string** 

**COD 02 - cálculo do comprimento C:**

```
#include <stdio.h>
#include <string.h>

// Função para calcular o comprimento da string
int calcularComprimento(const char* str) {
    return strlen(str);
}

// Função para inverter a string
void inverterString(char* str) {
    int tamanho = strlen(str);
    for (int i = 0; i < tamanho / 2; i++) {
        char temp = str[i];
        str[i] = str[tamanho - i - 1];
        str[tamanho - i - 1] = temp;
    }
}

// Função para converter a string para maiúsculas
void converterParaMaiusculas(char* str) {
    int tamanho = strlen(str);
    for (int i = 0; i < tamanho; i++) {
        if (str[i] >= 'a' && str[i] <= 'z') {
            // Converter caracteres minúsculos para maiúsculos
            str[i] = str[i] - ('a' - 'A');
        }
    }
}

int main() {
    // String de exemplo
    char minhaString[] = "UFOPA";

    // Calcular e imprimir o comprimento da string
    int comprimento = calcularComprimento(minhaString);
    printf("Comprimento da string: %d\n", comprimento);

    // Inverter a string e imprimir o resultado
    inverterString(minhaString);
    printf("String invertida: %s\n", minhaString);

    // Converter a string para maiúsculas e imprimir o resultado
    converterParaMaiusculas(minhaString);
    printf("String em maiúsculas: %s\n", minhaString);

    return 0;
}

```
Execução do codigo: [Excute aqui!](https://onlinegdb.com/njOfoheir)

---
**COD 03 - Indexação PYTHON:**

```
frase = "UFOPA BRASIL"
f = frase[3]
print(f)

last = frase[-4]
print(last)

```
Execução do codigo: [Excute aqui!](https://onlinegdb.com/YFBtz6Jer)

---

**COD 04 - Manipulação de Strings JAVA:**

```
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        String s = "UFOPA";
        String t = "Gabriel Aleixo de Oliveira";
        String a = "2021005138";

        if (s.equals(t)) {
            System.out.println("As Strings são iguais.");
        } else {
            System.out.println("As Strings são diferentes.\n");
        }

        System.out.println(s.equals(a));//Sempre usar equals para comparar Strings.
        System.out.println(s.concat(" ") + t +(" ") + a);
        System.out.println(s.replace('O', '#'));// Troca um caractere por outro
        System.out.println(t.replace('i', '*'));
        System.out.println(t.toUpperCase());//Tudo em maiusculo
        System.out.println(t.toLowerCase());//Tudo em minusculo
        System.out.println(t.toLowerCase().indexOf("x"));//Retorna a posição da String
        System.out.println(a.length());//Comprimento da String

    }
}
```
Execução do codigo: [Excute aqui!](https://onlinegdb.com/f7ReXfteH)

---


**Paradigma Funcional**
Nesta aula vimos sobre o modo funcional no âmbito matemático e resolução problemas com este modo. A seguir alguns exemplos sobre.  

**COD 05 - Cálculo do comprimento:**

```
#include <stdio.h>
#include <string.h>

// Função para calcular o comprimento da string
int calcularComprimento(const char* str) {
    return strlen(str);
}

// Função para inverter a string
void inverterString(char* str) {
    int tamanho = strlen(str);
    for (int i = 0; i < tamanho / 2; i++) {
        char temp = str[i];
        str[i] = str[tamanho - i - 1];
        str[tamanho - i - 1] = temp;
    }
}

// Função para aplicar uma função a cada caractere da string
void aplicarFuncaoACadaCaractere(char* str, char (*funcao)(char)) {
    int tamanho = strlen(str);
    for (int i = 0; i < tamanho; i++) {
        str[i] = funcao(str[i]);
    }
}

// Função para converter um caractere para maiúsculas
char converterParaMaiusculas(char caractere) {
    if (caractere >= 'a' && caractere <= 'z') {
        return caractere - ('a' - 'A');
    }
    return caractere;
}

int main() {
    // String de exemplo
    char minhaString[] = "UFOPA";

    // Calcular e imprimir o comprimento da string
    int comprimento = calcularComprimento(minhaString);
    printf("Comprimento da string: %d\n", comprimento);

    // Inverter a string e imprimir o resultado
    inverterString(minhaString);
    printf("String invertida: %s\n", minhaString);

    // Converter a string para maiúsculas e imprimir o resultado
    aplicarFuncaoACadaCaractere(minhaString, converterParaMaiusculas);
    printf("String em maiúsculas: %s\n", minhaString);

    return 0;
}
```
Execução do codigo: [Excute aqui!](https://onlinegdb.com/iLg2dMimns)

---
**COD 06 - Tabuada:**

```
#include <stdio.h>

void tabuada(int num) {
    printf("\nTabuada do %d:\n", num);
    for (int i = 1; i <= 10; i++) {
        int result = num * i;
        printf("%d x %d = %d\n", num, i, result);
    }
}

int main() {
    int num;

    do {
        printf("Digite um número ou 0 para sair: ");
        scanf("%d", &num);

        if (num != 0) {
            tabuada(num);
        }
    } while (num != 0);

    return 0;
}
```
Execução do codigo: [Excute aqui!](https://onlinegdb.com/XiA3aSNdA)

---