DEV Community: Hérika Costa

Portifólio 02: Paradigmas Imperativo, Funcional

Hérika Costa — Wed, 10 Apr 2024 15:02:39 +0000

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!

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!

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!

COD 03 - Indexação PYTHON:

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

last = frase[-4]
print(last)

Execução do codigo: Excute aqui!

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!

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!

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!

Portifólio 01: Paradigmas Imperativo e Declarativo.

Hérika Costa — Tue, 30 Jan 2024 13:54:45 +0000

O objetivo deste portfólio é apresentar as atividades desenvolvidas por mim, com base nas aulas da disciplina de laboratório de programação, na qual abordamos os Problemas em Paradigmas Imperativos relacionados ao processamento de strings, Problemas em Paradigmas Imperativos: Matemáticos, Problemas em Paradigmas Imperativos: Geometria Computacional. Realizamos também comparações entre os paradigmas Imperativo e Declarativo, os quais serão detalhados mais adiante. Além disso, conduzimos um exemplo de busca sequencial, utilizando iterações e recursividade.

Os códigos apresentados neste portfólio serão:
Cod 1: Busca sequencial utilizando iterações e recursividade
Cod 2 e 2.1 : Processamento de String com paradigma Imperativo
Cod 3 e 3.1 : Processamento de String com paradigma Declarativo
Cod 4 e 4.1 : Funções Matemáticas com paradigma Imperativo
Cod 5 e 5.1 : Funções Matemáticas com paradigma Declarativo
Cod 6 e 6.1 : Estruturas de Dados com paradigma Imperativo
Cod 7 e 7.1 : Estruturas de Dados com paradigma Declarativo

Todos os códigos estarão acompanhados de suas respectivas explicações, proporcionando um entendimento abrangente do conteúdo abordado na aula.

Paradigma Imperativo

Paradigma Declarativo

O paradigma declarativo determina que as instruções passadas ao computador devem especificar a sequência lógica e o resultado esperado, sem determinar o fluxo de controle. O foco da resolução está em determinar “o quê” deve ser resolvido, o que é um contraste a programação imperativa que determina “o como”.

Cod 1 - BUSCA SEQUENCIAL:
Com iterações

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

int buscaSequencialIterativa(char str[], char chave) {
    int comprimento = strlen(str);

    for (int i = 0; i < comprimento; i++) {
        if (str[i] == chave) {
            return i;
        }
    }
    return -1;
}

int main() {
    char str[] = "abcdefghijkalmnop";
    char chave = 'f'; 

    int posicao = buscaSequencialIterativa(str, chave);

    if (posicao != -1) {
        printf("O caractere '%c' foi encontrado na posição %d da string.\n", chave, posicao);
    } else {
        printf("O caractere '%c' não foi encontrado na string.\n", chave);
    }

    return 0;
}

Execução do codigo: Excute aqui!

Cod 1.1 - BUSCA SEQUENCIAL:
Com recusividade

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

int buscaSequencialRecursiva(char str[], char chave, int indice) {
    if (str[indice] == '\0') {
        return -1;  
    }
    if (str[indice] == chave) {
        return indice;  
    }

    return buscaSequencialRecursiva(str, chave, indice + 1);
}

int main() {
    char str[] = "EsfdbhDsadd";
    char chave = 'D';  

    int posicao = buscaSequencialRecursiva(str, chave, 0);

    if (posicao != -1) {
        printf("O caractere '%c' foi encontrado na posição %d da string.\n", chave, posicao);
    } else {
        printf("O caractere '%c' não foi encontrado na string.\n", chave);
    }

    return 0;
}

Execução do codigo: Excute aqui!

Cod 2 - PARADIGMA IMPERATIVO:
Concatenação de duas strings

// Criar exemplos para processamento de Strings em C, Java, Python, Rust, ...
// para os paradigmas apresentados.

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

int main() {
  // Definindo duas strings
  char str1[50] = "Laboratório de ";
  char str2[] = "programacao";

  // Calculando o comprimento das strings
  int len1 = strlen(str1);
  int len2 = strlen(str2);

  // Verificando se a concatenação excede o limite da string
  if (len1 + len2 < 50) {
    // Concatenando as duas strings
    strcat(str1, str2);

    // Exibindo a string resultante
    printf("A string resultante da concatenacao: %s\n", str1);
  } else {
    printf("Erro: A concatenação excede o limite da string.\n");
  }

  return 0;
}

Execução do codigo: Excute aqui!

Cod 2.1 - PARADIGMA IMPERATIVO:
Contagem de caracteres em uma string

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

int main() {
    // Definindo uma string
    char str[] = "Laboratorio de programacao";

    // Calculando o comprimento da string
    int len = strlen(str);

    // Exibindo o número de caracteres na string
    printf("A string tem %d caracteres.\n", len);

    return 0;
}

Execução do codigo: Excute aqui!

Cod 3 - PARADIGMA DECLARATIVO:
Concatenação de duas strings

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

int main() {
    // Definindo duas strings
    char str1[50] = "Laboratório de ";
    char str2[] = "Programaçao";

    // Concatenando as strings
    strcat(str1, str2);

    // Exibindo a string resultante
    printf("A string resultante da concatenacao: %s\n", str1);

    return 0;
}

Execução do codigo: Excute aqui!

Cod 3.1 - PARADIGMA DECLARATIVO:
Calculando o comprimento da string

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

int main() {
    // Definindo uma string
    char str[] = "Lab de Prog";

    // Calculando o comprimento da string
    int len = strlen(str);

    // Exibindo o número de caracteres na string
    printf("A string tem %d caracteres.\n", len);

    return 0;
}

Execução do codigo: Excute aqui!

Cod 4 - PARADIGMA DECLARATIVO:
Programa Declarativo com Funções Matemáticas (soma dos quadrados)

#include <stdio.h>

// Função para calcular o quadrado de um número
int calculaQuadrado(int x) {
    return x * x;
}

// Função para calcular a soma dos quadrados de dois números
int calculaSomaQuadrados(int a, int b) {
    return calculaQuadrado(a) + calculaQuadrado(b);
}

int main() {
    //Entrada
    int num1 = 3;
    int num2 = 4;

    // Chamada das funções
    int resultado = calculaSomaQuadrados(num1, num2);

    //Resultado
    printf("A soma dos quadrados de %d e %d é: %d\n", num1, num2, resultado);

    return 0;
}

Execução do codigo: Excute aqui!

Cod 4.1 - PARADIGMA DECLARATIVO:
Programa Declarativo com Funções Matemáticas(Produtos)

#include <stdio.h>

// Função para calcular o produto de dois números
int calculaProduto(int a, int b) {
    return a * b;
}

int main() {
    //Entrada
    int num1 = 5;
    int num2 = 7;

    // Chamada da função 
    int resultado = calculaProduto(num1, num2);

    //Resultado
    printf("O produto de %d e %d é: %d\n", num1, num2, resultado);

    return 0;
}

Execução do codigo: Excute aqui!

Cod 5 - PARADIGMA IMPERATIVO:
Programa Imperativo com Funções Matemáticas(Quociente)

#include <stdio.h>

// Função para calcular o quociente de dois números
float calculaQuociente(int a, int b) {
    return (float)a / b;
}

int main() {
    //Entrada
    int num1 = 10;
    int num2 = 2;

    // Chamada da função
    float resultado = calculaQuociente(num1, num2);

    //Resultado
    printf("O quociente de %d por %d é: %.2f\n", num1, num2, resultado);

    return 0;
}

Execução do codigo: Excute aqui!

Cod 5 - PARADIGMA IMPERATIVO:
Programa Imperativo com Funções Matemáticas(Soma dos quadrados)

#include <stdio.h>

// Função para calcular o quadrado de um número
int calculaQuadrado(int x) {
    return x * x;
}

// Função para calcular a soma dos quadrados de dois números
int calculaSomaQuadrados(int a, int b) {
    int quadradoA = calculaQuadrado(a);
    int quadradoB = calculaQuadrado(b);
    return quadradoA + quadradoB;
}

int main() {
    //Entrada
    int num1 = 3;
    int num2 = 4;

    // Chamada da função
    int resultado = calculaSomaQuadrados(num1, num2);

    //Resultado
    printf("A soma dos quadrados de %d e %d é: %d\n", num1, num2, resultado);

    return 0;
}

Execução do codigo: Excute aqui!

Cod 6 - PARADIGMA DECLARATIVO:
Programa Declarativo com Estrutura de Dados (Cálculo de Média)

#include <stdio.h>

// Função para calcular a média de um conjunto de números
float calculaMedia(const int numeros[], int tamanho) {
    int soma = 0;

    for (int i = 0; i < tamanho; i++) {
        soma += numeros[i];
    }

    return (float)soma / tamanho;
}

int main() {
    // Conjunto de números
    int numeros[] = {10, 20, 30, 40, 50};
    int tamanho = sizeof(numeros) / sizeof(numeros[0]);

    // Chamada da função
    float media = calculaMedia(numeros, tamanho);

    //Resultado
    printf("Cálculo de Média: A média dos números é: %.2f\n", media);

    return 0;
}

Execução do codigo: Excute aqui!

Cod 6.1 - PARADIGMA DECLARATIVO:
Programa Declarativo com Estrutura de Dados (Busca)

#include <stdio.h>

// Função para verificar se um número está presente em um conjunto
int verificaPresenca(const int numeros[], int tamanho, int alvo) {
    for (int i = 0; i < tamanho; i++) {
        if (numeros[i] == alvo) {
            return 1; // Verdadeiro (presente)
        }
    }

    return 0; // Falso (não presente)
}

int main() {
    // Conjunto de números
    int numeros[] = {10, 20, 30, 40, 50};
    int tamanho = sizeof(numeros) / sizeof(numeros[0]);

    // Número a ser buscado
    int alvo = 30;

    // Chamada da função
    int resultado = verificaPresenca(numeros, tamanho, alvo);

    //Resultado
    printf("Verificação de Presença: %d %s presente no conjunto.\n", alvo, resultado ? "está" : "não está");

    return 0;
}

Execução do codigo: Excute aqui!

Cod 7 - PARADIGMA IMPERATIVO:
Programa Imperativo com Estrutura de Dados (Cálculo de Média)

#include <stdio.h>

// Função para calcular a média de um conjunto de números
float calculaMedia(const int numeros[], int tamanho) {
    int soma = 0;

    for (int i = 0; i < tamanho; i++) {
        soma += numeros[i];
    }

    return (float)soma / tamanho;
}

int main() {
    // Conjunto de números
    int numeros[] = {10, 20, 30, 40, 50};
    int tamanho = sizeof(numeros) / sizeof(numeros[0]);

    // Chamada da função
    float media = calculaMedia(numeros, tamanho);

    //Resultado
    printf("Cálculo de Média: A média dos números é: %.2f\n", media);

    return 0;
}

Execução do codigo: Excute aqui!

Cod 7 - PARADIGMA IMPERATIVO:
Programa Imperativo com Estrutura de Dados (Busca)

#include <stdio.h>

// Função para verificar se um número está presente em um conjunto
int verificaPresenca(const int numeros[], int tamanho, int alvo) {
    for (int i = 0; i < tamanho; i++) {
        if (numeros[i] == alvo) {
            return 1; // Verdadeiro (presente)
        }
    }

    return 0; // Falso (não presente)
}

int main() {
    // Conjunto de números
    int numeros[] = {10, 20, 30, 40, 50};
    int tamanho = sizeof(numeros) / sizeof(numeros[0]);

    // Número a ser buscado
    int alvo = 30;

    // Chamada Chamada função
    int resultado = verificaPresenca(numeros, tamanho, alvo);

    //Resultado
    printf("Verificação de Presença: %d %s presente no conjunto.\n", alvo, resultado ? "está" : "não está");

    return 0;
}

Execução do codigo: Excute aqui!