Portifólio 01: Paradigmas Imperativo e Declarativo.
Published: 2024-01-30 13:54:45


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

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 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!](https://onlinegdb.com/iVRt-jVBfL)


**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!](https://onlinegdb.com/Zlk6jtbB4)


**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!](https://onlinegdb.com/nHCauUIJj)


**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!](https://onlinegdb.com/GWJ3kxyIK)


**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!](https://onlinegdb.com/8nAcBIpWg)


**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!](https://onlinegdb.com/f5n59qAcp)


**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!](https://onlinegdb.com/ZsBlATvFn)

**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!](https://onlinegdb.com/OJiQhaz3n)

**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!](https://onlinegdb.com/5RAPpbNuI)

**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!](https://onlinegdb.com/rypuScanF)

**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!](https://onlinegdb.com/4E5ZYADjO)

**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!](https://onlinegdb.com/BMzNND_H4)

**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!](https://onlinegdb.com/TBw4DmkDi)


**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!](https://onlinegdb.com/wQ6Qe9YQK2)