DEV Community: Matheus 🇧🇷

CS61A: Projeto Hog (Parte 2)

Matheus 🇧🇷 — Mon, 16 Oct 2023 12:10:47 +0000

Introdução

O curso CS 61A da Universidade da Califórnia, Berkeley, é um curso de introdução à ciência da computação. Ele busca fornecer uma base sólida em programação, abordando conceitos fundamentais de estruturas de dados, algoritmos e paradigmas de programação. O curso é conhecido por sua ênfase em Python como a linguagem principal de programação e pela abordagem prática e desafiadora.

Fase 1: Problema 2

Implemente boar_brawl, que recebe a pontuação do jogador player_score e a pontuação do oponente opponent_score, e retorna o número de pontos feitos pelo Boar Brawl quando o jogador joga 0 dados.

Boar Brawl: Jogador que rola pontuação zero do dado pontua três vezes a diferença absoluta entre o digito das dezenas da pontuação do oponente e o dígito da unidade da pontuação do jogador, ou 1, o que for maior. Se a pontuação do jogador for de dígito único (menor do que 10), o dígito das dezenas do jogador será 0.

Exemplos

Exemplo 1:
- A pontuação atual do jogador é de 21 pontos e a da oponente é de 46 pontos, e o jogador da rodada escolher rodar nenhum dado (zero dados).
- O dígito das dezenas da pontuação do oponente é 4 e o dígito das unidades do jogador é 1.
- Então, o jogador ganha 3 * abs(4 - 1) = 9 pontos.
Exemplo 2:
- A pontuação atual do jogador é de 45 pontos e o oponente é de 52 pontos, o jogador da rodada escolhe rodar nenhum dado (zero dados).
- O dígito das dezenas da pontuação é 5 e o das unidades do jogador é 5.
- Então, 3 * abs(5 - 5) = 0, o jogador ganhará 1 ponto.
Exemplo 3:
- A pontuação atual do jogador é de 2 pontos e a do oponente é de 5 pontos, o jogador da rodada escolhe rodar nenhum dado (zero dados).
- O dígito das dezenas do oponente é 0 e o dígito das unidades do jogador é 2.
- Então, o jogador ganha 3 * abs(0 - 2) = 6 pontos.

Dica importante!
Don't assume that scores are below 100. Write your boar_brawl function so that it works correctly for any non-negative score.

Solução

A solução deste desafio é puramente matemática, e passa pelo entendimento das operações // e %, e da manipulação dos termos chamados resto e quociente.

O operando // retorna o quociente de uma divisão.
O operando % retorna o resto de uma divisão.

Segue na imagem abaixo uma representação melhor do uso destes operandos:

A partir daí, eu já posso olhar para os exemplos dados pela atividade para elaborar o algoritmo a ser utilizado para a solução desta fase do projeto.

Então, olhando para o Exemplo 1.

Pontuação do jogador é 21 pontos, quero o valor do seu dígito das unidades que é 1;
Pontuação do oponente é 46 pontos, quero o valor do seu dígito das dezenas que é 4;

Quais operações devo fazer, usando apenas a divisão para extrair os números que quero na proposta deste desafio. Deixei uma pista na divisão do 15 ÷ 10.

Se eu realizar a operação 21 ÷ 10 e procurar pelo o seu resto, vou obter 1.
Se eu realizar a operação 46 ÷ 10 e procurar pelo o seu quociente, vou obter 4.

Excelente!

Mas e nas situações que o valor da pontuação for maior do que 100? Igual ao colocado na terceira representação de divisão da imagem acima.

Vamos para mais uma imagem para a representação deste caso:

Observamos que para o caso da pontuação do jogador, onde se busca o dígito das unidades, nada se altera.
Para o caso da pontuação do oponente, precisamos realizar duas operações.
- Primeiro buscamos o seu quociente através do operador //.
- Com o seu quociente, repetimos a operação mas agora buscando o seu resto através do operador %.

A partir do entendimento do problema e da criação da solução, podemos então ir para a parte do código e testar para ver se atende todos os casos possíveis.

Solução em Python:

Aprovado em todos os testes:

Conclusão

A partir do momento que se entende o padrão, utilizar a ferramenta da linguagem de programação é o processo mais fácil da atividade. Este desafio testou muito mais a utilização de operações matemáticas para encontrar a sua solução e manter a lógica de pontuação do 'Jogo do Hog', através deste sistema Boar Brawl.

Espero que a explicação esteja clara e ajude a quem está começando. Nos vemos na próxima!

CS61A: Projeto HOG (Parte 1)

Matheus 🇧🇷 — Fri, 13 Oct 2023 22:07:12 +0000

Introdução

O curso CS 61A da Universidade da Califórnia, Berkeley, é um curso de introdução à ciência da computação. Ele busca fornecer uma base sólida em programação, abordando conceitos fundamentais de estruturas de dados, algoritmos e paradigmas de programação. O curso é conhecido por sua ênfase em Python como a linguagem principal de programação e pela abordagem prática e desafiadora.

Esta publicação vai focar no primeiro projeto desta disciplina que é chamado 'O jogo de Hog'. Eu confesso que não conhecia este jogo até começar a fazer este desafio, continuo não tendo o jogado mas compreendi as regras que são explicadas na página do projeto.

Ainda não terminei de fazer este desafio, então vou publicar meus sucessos, dúvidas e dificuldades como forma de estudo e buscar trabalhar em cima da minha comunicação também. O projeto está divido em fases e cada fase possui uma série de problemas a serem solucionados.

Fase 1: Problema 1

Implemente a função roll_dice em hog.py. Esta função recebe dois argumentos: um número inteiro positivo chamado num_rolls recebendo o número de vezes que o dado será rolado e uma função dice. Esta função retornará o número de pontos ao rolar o dado aquele número de vezes em uma rodada: será tanto a soma de suas saídas ou 1 (Sow Sad).

Sow Sad. Se qualquer resultado do dado lançado for 1, a pontuação do jogador na rodada será 1.

Exemplos

Exemplo 1: O jogador da rodada joga o dado 7 vezes, 5 destas são 1. A pontuação do turno será 1.
Exemplo 2: O jogador da rodada joga o dado 4 vezes, em todas são 3. Como Sow Sad não ocorreu, a pontuação do turno ao jogador será de 12.

Solução

Uma dica importante fornecida na descrição do problema é a seguinte:

"You should call dice() exactly num_rolls times in the body of roll_dice."

A primeira abordagem que me veio à mente ao olhar para os exemplos foi utilizar as condicionais para verificar se o valor de algum dos dados é igual a 1 e, caso positivo, retornar 1.

No entanto, essa abordagem enfrenta um desafio que vai em direção oposta a dica importante fornecida na descrição do problema. No momento que o laço repetitivo encontrar o valor, interromperá o laço, ou seja, impedirá que a função dice() seja chamada exatamente num_rolls vezes, como exigido pelo problema.

Uma alternativa que encontrei foi a utilização de uma flag (valor booleano). Quando um valor igual a 1 é encontrado em uma jogada, a flag é definida como verdadeira. O loop continua rodando o número de vezes especificado em num_rolls.

Após o término do loop, outra condicional pode ser usada para determinar o valor da resposta, que será 1 se a flag for verdadeira (indicando que ocorreu o Sow Sad), ou o valor acumulado das jogadas, caso contrário.

Conclusão

Trocar um for _ in range() por um while foi um marco para mim na solução deste desafio, e a utilização de flags para indicar a ocorrência de uma ação tornou o código mais claro.

Quero buscar falar de cada problema que for fazendo e aprimorar minha capacidade de solucionar problemas, espero que isto ajude a quem buscar fazer este curso.

30 dias de Cybersegurança: Os sete primeiros dias de descobertas

Matheus 🇧🇷 — Thu, 07 Sep 2023 19:44:24 +0000

Olá! Este texto busca sintetizar os aprendizados destes sete primeiros dias de desafios propostas pela comunidade Menina de Cybersec, cujo objetivo é, segundo a própria comunidade: "A ideia dessa série de desafios é fazer com que você conheça o mundo de cibersegurança, profissionais, livros, podcasts e quem sabe, encontre a área dos sonhos."

Tento colocar aqui em algumas palavras esta área que venho buscando acrescentar diariamente aos meus estudos, e propor para os que estejam também curiosos a se juntar a esta comunidade no Discord.

Aviso: Embora numa oportunidade eu tenha feito o treinamento intensivo da FEBRABAN em parceria com a Accenture Brasil, eu considerei o começo desta atividade da comunidade Menina de CyberSec como se estivesse começando do zero. Visto como uma série de desafios para me auxiliar no aprendizado deste setor que me vem despertando um grande interesse e alvo de estudos.

Vamos começar!

Conhecendo Cybersecurity

No primeiro dia, começamos nossa jornada explorando um ponto de partida interessante para segmentar os dois lados da mesma moeda no campo da cibersegurança: a segurança defensiva e a segurança ofensiva. Não sendo uma melhor ou pior do que a outra, são duas áreas complementares que buscam o trabalho constante de atualização e compartilhamento de experiências para otimizar suas tarefas e rotinas.

O desafio proposto pela comunidade envolve a leitura e a prática dentro da plataforma TryHackMe, que abrange conteúdos relacionados a essas duas áreas de segurança cibernética e oferece atividades para aprofundar o conhecimento. O que foi muito positivo neste primeiro dia é conhecer também os cargos disponíveis em ambas as frentes de segurança, bem como o escopo de atividades relacionadas a cada uma.

Segurança Ofensiva

A segurança ofensiva está fortemente relacionada à descoberta de vulnerabilidades. Esta é uma área onde busca-se identificar fragilidades em diferentes aplicações e tecnologias por meio de testes. Um dos cargos mais comuns nesse campo é o de pentester.

Segurança Defensiva

Em contraste com a segurança ofensiva, a segurança defensiva é responsável por detectar e interromper ataques. Essa área envolve monitoramento constante e análise para identificar anomalias e se manter atualizada, já que novas formas de ataque e tecnologias são descobertas todos os dias. Um cargo comum nessa área é o de analista de segurança.

Conhecendo a Segurança Ofensiva

Neste dia, aprofundamos nossa compreensão da segurança ofensiva, um campo que requer uma abordagem única. É fundamental adotar a mentalidade do "pensar fora da caixa" para identificar vulnerabilidades antes que aqueles com intenções maliciosas o façam.

Uma citação notável que encapsula essa abordagem é: "Para vencer um hacker, você precisa se comportar como um hacker."

Durante este processo de aprendizagem, também iniciamos uma atividade prática em um ambiente de laboratório. Nessa experiência, você terá seu primeiro contato com a linha de comando, com o objetivo final de obter uma mensagem secreta. Este é o começo da jornada na exploração das táticas e técnicas.

Conhecendo a Segurança Defensiva

No outro lado da moeda, temos o campo que se dedica a defender a rede de uma organização e seus sistemas, monitorando e identificando potenciais ameaças. Este campo é frequentemente representado pelo SOC (Security Operations Center), o departamento responsável pelo monitoramento proativo e resposta a incidentes de segurança.

O SOC desempenha um papel crítico na proteção de ativos digitais, identificando atividades suspeitas e agindo rapidamente para mitigar ameaças. É um ambiente dinâmico onde os profissionais de segurança trabalham para manter a integridade das operações da organização.

Até este ponto, podemos perceber que a cibersegurança é bem interessante, abordando tanto a ofensiva quanto a defensiva. Entender os diferentes níveis de ataques e as estratégias para combatê-los é uma jornada que promete desafios a cada dia.

Os Pilares de Segurança da Informação

Ao adentrar o mundo da cibersegurança, somos apresentados a um novo termo fundamental nesta série de desafios: o CID, que representa Confidencialidade, Integridade e Disponibilidade. Esses três pilares são a base da segurança da informação e são essenciais para proteger os ativos digitais de qualquer organização.

Confidencialidade: Como o próprio nome diz respeito à garantia de que as informações sensíveis e os dados críticos sejam acessíveis apenas por pessoas autorizadas.
Integridade: A integridade concentra-se em manter a precisão e a integridade dos dados ao longo do tempo. Isso significa garantir que os dados não sejam alterados de forma não autorizada, e assim permaneçam confiáveis.
Disponibilidade: A disponibilidade se refere à acessibilidade dos dados e serviços quando são necessários. Em outras palavras, os dados e sistemas críticos devem estar disponíveis e funcionando para os usuários sempre quando necessário.

Recapitulação da Primeira Semana

Um dos momentos mais marcantes desta primeira semana foi a minha percepção pessoal de que termos como Red Team ou Blue Team não representam inimigos que competem entre si para vencer. Pelo contrário, eles são como duas partes complementares e interligadas, colaborando para promover a progressão e a melhoria contínua dos sistemas, aplicações, tecnologias e a segurança geral de uma organização.

Red Team: O Red Team desempenha um papel fundamental ao atuar como o "atacante" que testa e identifica vulnerabilidades em sistemas e redes. Essa equipe desafia o status quo e ajuda a identificar pontos fracos antes que pessoas com intenções maliciosas o façam.
Blue Team: O Blue Team, por sua vez, é a equipe de defesa, encarregada de monitorar e proteger os sistemas contra ameaças. Eles respondem aos desafios apresentados pelo Red Team e trabalham para fortalecer a postura de segurança da organização.

A cooperação entre essas duas equipes é crucial para a cibersegurança eficaz de qualquer organização. Em vez de serem adversários, eles compartilham um objetivo comum: proteger os ativos digitais e garantir a continuidade das operações.

Vamos para a próxima semana!

Guia para Iniciantes: Criando uma API com Node.js, PostgreSQL e Padrão MVC

Matheus 🇧🇷 — Tue, 22 Aug 2023 23:05:11 +0000

Introdução

Este artigo de hoje, está mais para uma guia de introdução para a construção de uma API utilizando as tecnologias mencionadas no título: Node.JS, PostgreSQL e utilizando o padrão MVC.

Não tive a pretensão de escrever um guia completo, procurei escrever de uma maneira que eu gostaria de ter encontrado quando comecei a estudar, sem ter todas as respostas, mas que me indicassem um norte de onde seria o próximo passo para estudar e aprofundar.

Este guia busca isso, ser menos teórico, quando comparado a publicações anteriores, e mais aplicação prática. Assim como, estou aceitando correções, pois também estou aprendendo e compartilhando como eu mesmo faço.

Este artigo é parte de uma síntese de anotações soltas sobre desenvolvimento web e do Bootcamp que estou fazendo atualmente em desenvolvimento full stack.

Então, vamos começar!

Passo 1: Configuração do Projeto

Primeiro, é necessário configurar o ambiente de desenvolvimento e nos certificamos de que possuímos o Node.Js instalado em nosso sistema operacional. Para isto, verifique se o Node.Js com o seguinte comando em seu terminal:

node -v

Se o Node.Js estiver instalado, aparecerá a versão correspondente. Se não, não tem problema. Basta instalar o Node.Js seguindo as instruções no site oficial

Em seguida, crie uma pasta onde será armazenado o seu projeto. No meu caso, nomearei a pasta de projdesafio pois estou dando prosseguimento ao projeto relacionado a um desafio feito no Bootcamp da Atlantico Avanti

Em seu terminal, digite o seguinte comando para a criação de uma pasta:

# mkdir nome_da_pasta
mkdir projdesafio

Navegue até a pasta criada usando o seguinte comando:

# cd nome_da_pasta
cd projdesafio

Agora, dentro da pasta, é hora de iniciar o projeto em Node.Js, com o seguinte comando:

npm init -y

Ao executar este último comando, será criado um arquivo package.json com valores padrões. Este arquivo é essencial para projetos em Node.Js, pois contém informações sobre os projetos, dependências, scripts personalizados (olá nodemon!) e outros.

O gerenciador de pacotes fornecerá um método para instalar novas dependências (também chamadas de "pacotes"), gerenciar onde os pacotes são armazenados em seu sistema de arquivos e oferecer recursos para que você possa publicar seus próprios pacotes.

Em teoria, você pode não precisar de um gerenciador de pacotes e poderia baixar e armazenar manualmente as dependências do seu projeto, mas um gerenciador de pacotes lidará automaticamente com a instalação e desinstalação dos pacotes. Se você não usasse um, teria que lidar manualmente com isso.
mdn web docs

No diretório projdesafio, crie um arquivo chamado app.js. E assim, estará nossa estrutura de arquivos até aqui:

projdesafio/
├── app.js
└── package.json

Agora vamos instalar o Express como uma dependência do nosso projeto. Abra o seu terminal e introduza este comando para a instalação:

npm install express

Após a instalação, aparecerá uma nova chamada node_modules dentro da sua pasta. Em breve, vamos começar a a configurar o nosso arquivo app.js para utilizar o Express e começar a construir a nossa API.

projdesafio/
├── node_modules/
│   ├── ... (dependências instaladas)
├── app.js
└── package.json

Passo 2: Configurando o Banco de Dados

Perfeito!

Vamos continuar agora para a parte do banco de dados. No projeto do Bootcamp eu estarei partindo do principio que você conhece tanto as partes DDL quanto DML em SQL.

Caso não tenha ideia do que estou falando, segue esta publicação onde abordei estes assuntos:

Entendendo a Relação entre SQL, DML e DDL: Fundamentos de Banco de Dados

O Banco de Dados já está criado com esta tabela a seguir:

-- tabela cliente
create table Cliente (
    id serial primary key,
    nome varchar(255) not null,
    cpf varchar(11) not null unique
);

-- tabela certidao
create table Certidao (
    id serial primary key,
    cliente_id int not null references Cliente(id),
    data_emissao date not null,
    hora_emissao time not null,
    validade date not null,
    codigo_validacao boolean not null
);

Esta é só uma parte, como esta publicação só tem o intuito de apresentar inicialmente e não se aprofundará sobre outros aspectos.

No diretório projdesafio, abra o terminal e instale o pacote pg, que vai nos permitir termos uma interface com o banco de dados PostgreSQL em nossa aplicação Node.Js.

npm install pg

Em seguida, crie uma pasta chamada config, é esta pasta que será usada para armazenar as configurações com o nosso banco de dados.

projdesafio/
├── node_modules/
│   ├── ... (dependências instaladas)
├── config/
├── app.js
└── package.json

Dentro da pasta config, crie um arquivo chamado db.js. Este arquivo conterá o código para estabelecer conexão com o PostgreSQL.

const { Pool } = require('pg');

// Configurações do banco de dados
const pool = new Pool({
  user: 'altere_para_seu_usuario',
  host: 'localhost',
  database: 'altere_para_o_seu_banco_de_dados',
  password: 'altere_para_a_sua_senha',
  port: 5432, // Porta padrão do PostgreSQL
});

module.exports = pool; //Exportando para usarmos posteriomente

Usamos o module.exports para permitir que outras partes da aplicação posteriormente possam utilizar estas configurações para acessar o banco de dados.

Desta forma, posteriormente, outros módulos poderão obter uma conexão com o banco de dados, e assim realizar as operações SQL necessárias da nossa API.

Assim agora se encontrar a nossa estrutura de pastas e arquivos:

projdesafio/
├── node_modules/
│   ├── ... (dependências instaladas)
├── config/
│   ├── db.js
├── app.js
└── package.json

Passo 3: Estrutura MVC

Apesar de muitas pessoas considerarem essa sigla como um padrão de design de interface, na verdade ele é um padrão de arquitetura de software responsável por contribuir na otimização da velocidade entre as requisições feitas pelo comando dos usuários.

Com quase 50 anos de formulação, a arquitetura MVC é dividida em três componentes essenciais: Model, Controller e View.
Le wagon - O que é MVC?

Como neste projeto aqui se trata apenas de uma API sem interface gráfica, a pasta views ficará vazia, mas será criadas apenas para fins de documentação desta publicação.

No diretório projdesafio, crie três pastas: models, controllers, views.

mkdir models controllers views

Estrutura de pastas e arquivos do projeto até então:

projdesafio/
├── node_modules/
│   ├── ... (dependências instaladas)
├── config/
│   ├── db.js
├── models/
├── controllers/
├── views/
├── app.js
└── package.json

Passo 4: Modelagem de Dados

Vamos começar pela criação do modelo na pasta models, seguindo o padrão MVC. Criaremos duas funções realizando funções SQL para interagir com o banco de dados.

getAllClients (buscar todos os clientes)
createNewClient(adicionar novo cliente)

No diretório projdesafio/models, crie um arquivo chamado ClienteModel.js. Abra o arquivo ClienteModel.js e importe a configuração com o banco de dados e implemente as funções e consultas.

const db = require('../config/db'); // Importe a configuração do banco de dados

const Cliente = {
  getAllClients: async () => {
    try {
      const query = 'SELECT * FROM Cliente';
      const result = await db.query(query);
      return result.rows;
    } catch (error) {
      throw error;
    }
  },

  createNewClient: async (nome, cpf) => {
    try {
      const query = 'INSERT INTO Cliente (nome, cpf) VALUES ($1, $2) RETURNING *';
      const values = [nome, cpf];
      const result = await db.query(query, values);
      return result.rows[0];
    } catch (error) {
      throw error;
    }
  }
};

module.exports = Cliente;

Exportando o módulo como Cliente, agora podemos acessar quando criarmos os nossos controladores para acessar o banco de dados, realizar as funções SQL e implementar as operações da nossa API.

Aqui está a estrutura até então do nosso projeto:

projdesafio/
├── node_modules/
│   ├── ... (dependências instaladas)
├── config/
│   ├── db.js
├── models/
│   ├── ClienteModel.js
├── controllers/
├── views/
├── app.js
└── package.json

Isso tudo aqui é muito básico e eu ainda estou aprendendo também. Pode expandir, adicionar validações, tratamento de erros e outras funcionalidades.

Passo 5: Criando Controladores

Seguindo vamos para a criação dos controladores que irão manipular as ações relacionadas ao modelo Cliente.

Controladores fazem a intermediação entre as requisições HTTP e os Models.

No diretório projdesafio/controllers, crie um arquivo chamado clienteController.js. Abra o arquivo clienteController.js e importe o modelo criado anteriormente:

const ClienteModel = require('../models/ClienteModel'); // Importe o modelo

const clienteController = {
  getAllClients: async (req, res) => {
    try {
      const clients = await ClienteModel.getAllClients();
      res.status(200).json(clients);
    } catch (error) {
      res.status(500).json({ error: 'Erro ao obter lista de clientes.' });
    }
  },

  createNewClient: async (req, res) => {
    const { nome, cpf } = req.body;
    try {
      const newClient = await ClienteModel.createNewClient(nome, cpf);
      res.status(201).json(newClient);
    } catch (error) {
      res.status(500).json({ error: 'Erro ao criar novo cliente.' });
    }
  }
};

module.exports = clienteController;

A partir daqui, podemos configurar o nosso app.js usando os controladores para definir as rotas e quais ações correspondentes.

Aqui está a estrutura até então do nosso projeto:

projdesafio/
├── node_modules/
│   ├── ... (dependências instaladas)
├── config/
│   ├── db.js
├── models/
│   ├── ClienteModel.js
├── controllers/
│   ├── clienteController.js
├── views/
├── app.js
└── package.json

Passo 6: Integração de Controladores e Modelos

Abra o nosso arquivo app.js e vamos começar importando as dependências necessárias, incluindo a configuração com o banco de dados, o express e o controlador.

const express = require('express');
const db = require('./config/db');
const clienteController = require('./controllers/clienteController');

const app = express(); //Instância do Express
const PORT = 3000; //Porta para o servidor, por exemplo a 3000

app.use(express.json()); //Middleware para tratar os dados no formato JSON

app.get('/api/clientes', clienteController.getAllClients); //Rota para obter todos os clientes
app.post('/api/clientes', clienteController.createNewClient); //Rota para adicionar um novo cliente

app.listen(PORT, () => {
  console.log(`Servidor na porta ${PORT}`);
});

Passo 7: Testando a API

Vamos testar a nossa API utilizando o Postman

Testando a rota GET para listar todos os clientes:

1- Servidor precisa estar em execução, assim como o banco de dados;
2- Crie uma nova requisição no Postman;
3- Selecione o método HTTP como GET;
4- Insira a URL: http://localhost:3000/api/clientes
5- Clique em Send (Enviar)

Testando a rota POST para criar um novo cliente:

1- Crie uma nova requisição no Postman;
2- Selecione o método HTTP como POST;
4- Insira a URL: http://localhost:3000/api/clientes
5- Na seção Body, selecione raw e escolha o formato JSON.
6- Insira os dados no formato JSON:
{
  "nome": "Blue",
  "cpf": "12345678901"
}
7- Clique em Send (Enviar)

O Postman enviará as requisições para o nosso servidor local e você verá as respostas da API.

Conclusão

Parabéns! Terminamos nosso guia de introdução aqui, e fica para você continuar estudando, implementando e melhorando a aplicação.

A partir daí, você consegue estabelecer um CRUD (criar, ler, atualizar e deletar), seguindo o mesmo fluxo de informação de um módulo para outro, utilizando Node.Js, PostgreSQL e o padrão de arquitetura MVC.

Desvendando as Diferenças: APIs, Web Services, SOAP e HTTP Simplificados

Matheus 🇧🇷 — Fri, 11 Aug 2023 11:48:52 +0000

Introdução

Neste artigo irei explorar sobre as APIs (Interfaces de Programação de Aplicativos) que desempenham este papel intermediário para que diferentes sistemas se comuniquem.

No entanto, o universo da APIs é cercado de terminologias que, as vezes, pode tornar a compreensão complexa, com termos como API interna, API externa, Web API, Web Services, SOAP, HTTP e etc.

Este artigo é parte de uma síntese de anotações soltas sobre desenvolvimento web e do Bootcamp que estou fazendo atualmente em desenvolvimento full stack.

Então, vamos começar!

APIs: A Base da Interconexão

Uma API (Application Programming Interface) é um conjunto de características e regras existentes em uma aplicação que possibilitam interações com essa através de um software - ao contrário de uma interface de usuário humana. A API pode ser entendida como um simples contrato entre a aplicação que a fornece e outros itens, como outros componentes do software, ou software de terceiros. mdn web docs

É importante entender que as APIs servem como pontes entre sistemas e aplicativos, servindo para a troca de informações de forma padronizada.

Cardápio de restaurante como a API

Desta maneira, vamos pensar numa situação de um cardápio de restaurante. Imagina que você é um cliente (software) e deseja fazer a solicitação de um item do menu (dados) do restaurante (sistema ou aplicativo).

Em vez de você entrar na cozinha e fazer o pedido diretamente aos cozinheiros (código interno do restaurante), você olha para o cardápio (API) que lista os pratos disponíveis para a sua requisição.

Assim como no cardápio terá o detalhamento de cada item como: prato, preço, ingredientes e como fazer o pedido; A API define as regras para que um software faça a solicitação para um sistema ou aplicativo.

Ou seja, a API permite que você, como cliente/usuário, possa fazer a solicitação dos dados e/ou funcionalidades de uma aplicação ou sistema.

Principais tipos de API

API Pública

A API é disponibilizada para todos. Terceiros podem desenvolver aplicações que interajam com a sua API e isso pode se tornar uma fonte de inovação. Red hat

Também conhecida como API Externa, estas são projetadas para permitir que diferentes aplicativos ou sistemas interajam uns com os outros, mesmo que não tenham sido desenvolvidas pela mesma equipe ou organização.

Utilizando o mesmo contexto do restaurante, vamos imaginar agora que o restaurante decide oferecer um serviço de entrega.

O restaurante não pode deslocar um atendendo para ficar entregando comida todo o tempo. Então o restaurante passa a fornecer uma lista dos itens disponíveis (dados) com todas as informações necessárias como preço e o endereço de entrega.

Desta maneira, a API externa permite que o serviço de entrega acesse as informações de forma padronizada, para que possam buscar os pedidos e entregar a comida corretamente.

API Privada

A API é usada apenas internamente. Isso oferece às empresas um maior controle. Red hat

Também conhecida como API Interna, estas são projetadas para comunicação interna entre diferentes módulos de um mesmo sistema ou de uma organização. Essas APIs permitem dividir o código, promovendo a reutilização de código, simplificação e melhorar o gerenciamento sobre os serviços internos da organização.

No contexto do restaurante, vamos pensar agora que possui diversos departamentos diferentes, sendo estes a própria cozinha, o caixa e o atendimento, por exemplo. Estes departamentos precisam se comunicar de maneira organizada para que não gere ruídos e garanta que os pedidos sejam atendidos corretamente.

Desta maneira, usa-se uma API Interna para a comunicação. Após o cliente fazer um pedido, o atendendo alimenta o sistema de pedidos (API interna) onde o cozinheiro consegue saber o momento que tem que começar a preparar o prato solicitado pelo cliente.

Essa troca de informação dentro de um restaurante, sem envolver o cliente, representa a ação de uma API interna.

Web Services vs. Web APIs: Definindo o Contexto

Existe uma confusão sobre estes dois termos, tanto Web API quanto Web Services, pois frequentemente lemos ou escutamos as pessoas usando estes termos de forma intercambiável, mas existe nuances entre esses dois conceitos.

Web API

Uma Web API é considerada uma API externa. Sendo esta um tipo específico de API que utilizada os protocolos da web para fornecer serviços/recursos pela internet.

As Web APIs são acessíveis de forma remota por meio da internet, ou seja, permite que aplicativos, sistemas e serviços se comuniquem e interajam com elas.

Desta maneira, muitas vezes, as Web APIs tendem a ter seu foco em fornecer acesso a dados específicos.

Web Service

Web Service é um sistema de software que suporta interações interoperáveis de máquina para máquina por meio de uma rede. Ele possui uma interface descrita em um formato processável por máquina (especificamente, Linguagem de Definição de Serviço da Web, ou WSDL).

Web Services desempenham uma tarefa específica ou um conjunto de tarefas. Um Web Service é descrito usando uma notação XML padrão e formal, chamada descrição de serviço, que fornece todos os detalhes necessários para interagir com o serviço, incluindo formatos de mensagem (que detalham as operações), protocolos de transporte e localização.IBM

É um termo que inclui as Web APIs, mas também abrange outros protocolos de comunicação, incluindo aqueles que não são baseados em HTTP.

Resumindo

Característica	Web API	Web Service
Protocolo Comum	Geralmente usa HTTP/HTTPS	Pode usar vários protocolos, incluindo SOAP
Formatos de Dados	JSON ou XML	Pode usar JSON, XML, SOAP
Estilo de Arquitetura	Pode ser RESTful ou não	Pode ser SOAP-based ou RESTful
Acessibilidade	Acessível via URLs	Acessível via URLs (em REST) ou ponto de extremidade (em SOAP)
Segurança	Autenticação por tokens, chaves de API	Pode usar WS-Security (SOAP) ou outras abordagens

Todos os Web Services são Web APIs, mas nem todos as Web APIs são Web Services;

SOAP vs. HTTP: Escolhendo a Abordagem

A escolha sempre depende de fatores como: necessidades específicas do projeto, do levantamento de requisitos, da preferência da equipe, por exemplo.

Vamos falar sobre os pontos relevantes na consideração de cada uma:

SOAP

O SOAP é um protocolo elaborado para facilitar a chamada remota de funções via Internet, permitindo que dois programas se comuniquem de uma maneira tecnicamente muito semelhante à invocação de páginas Web. linhadecodigo

Segurança e confiabilidade;
Integração entre sistemas heterogêneos;
Contratos formais.

Em uma situação hipotética onde a segurança e a confiabilidade do seu serviço é primordial, por exemplo, lidando com informações sensíveis, como as financeiras, você pode optar pelo uso do SOAP para garantir robustez em segurança, como criptografia e autenticação.

HTTP

Protocolo amplamente utilizada para a troca de dados na internet. Muitas Web APIs são construídas sobre o HTTP, usando seus métodos como: GET, POST, PUT e DELETE, e com os dados em formato JSON.

Simplicidade;
Performance;
Comunicação pela Internet.

Dado uma segunda situação hipotética onde existe uma urgência na agilidade sobre a implementação e o foco está na simplicidade e no desempenho, o uso de HTTP usando RESTful pode ser o mais aconselhável. É um cenário onde a troca de dados é praticamente entre um aplicativo mobile e um servidor na internet.

Conclusão

Muito dos assuntos aqui foram tratados de forma simples e generalista, a fim de tentar sintetizar todas essas terminologias e conceitos numa perspectiva de desenvolvimento.

Buscar entender como todos esses termos estão situados no mesmo conjunto de ideias é importante para sua melhor compreensão nos seus estudos.

Fico por aqui e deixo minhas últimas publicações para caso queira acompanhar outros assuntos que estou estudando e compartilhando no momento.

Bootcamp da Atlântico Avanti

Entendendo a Relação entre SQL, DML e DDL: Fundamentos de Banco de Dados

Tecnólogo em ADS: Estrutura de Dados

Até a próxima!

Sobre o Autor

Meu gosto pela escrita se entrelaça com a vontade de compartilhar o que estou aprendendo ao longo desse percurso. Acredito que cada artigo é uma oportunidade não apenas de solidificar meu conhecimento, mas também de oferecer insights valiosos a outros aprendizes.

Minha esperança é que essas contribuições não apenas auxiliem quem busca conhecimento, mas também me impulsionem na busca por novas oportunidades e desafios na indústria de desenvolvimento de software.

Explorando as Fundamentais Estruturas de Dados: Recursão

Matheus 🇧🇷 — Wed, 09 Aug 2023 11:18:59 +0000

Introdução

Vamos retomar nossa jornada de explorar os fundamentos de estrutura de dados e algoritmos. Na última publicação, mencionei sobre o uso da técnica recursiva para o uso de um método de ordenação, e agora vamos nos aprofundar sobre recursão.

Essa série de publicações seguem meus estudos nesta disciplina de Estrutura de Dados do tecnólogo que estou fazendo, para acompanhar o que foi tratado até aqui, seguem os links das publicações anteriores.

Vamos começar!

Entendendo a Recursão

Começando pelo começo, começar a usar recursão é difícil.

Uma forma de pensar sobre recursão é como se fosse uma função que chama ela mesmo até resolver um problema proposto. Isto envolver a utilização de um Caso BASE. E o caso base é o momento onde o problema é resolvido.

Explicando tudo isto, vamos para um dos exemplos mais comum a respeito de recursão, calcular o somatório de números inteiros positivos no intervalo de [1, n].

Aqui percebemos que uma função recursiva deve seguir duas regras fundamentais:

Ter um Caso BASE (condição de parada) - se não a função realizará computação infinita
Ter o Passo Recursivo (chamada recursiva) - onde a função chama a si mesmo, e sempre buscando resolver um problema quebrando-o em instâncias menores do que a chamada anterior.

Vamos começar a destrinchar essa recursão e entender essas etapas fundamentais.

A mecânica na técnica recursiva

Para fins de esclarecimento, o símbolo Σ (sigma) representa o somatório. Este símbolo, neste exemplo, significa que estamos fazendo repetidas somas dentro de um intervalo estabelecido, aqui, significa que ele vai de 1 até N.

Pseudocódigo

função Soma(N)
    se N = 1 então
        retorne 1
    senão
        retorne N + Soma(N-1)
    fim se
fim função

Que pode equivaler a esta ideia

Então numa situação onde façamos o somatório até o número 5, seria o equivalente a dizer que

Java

public class SomatorioRecursivo {
    public static int calcularSomatorio(int n) {
        if (n == 1) {
            return 1;
        } else {
            return n + calcularSomatorio(n - 1);
        }
    }

    public static void main(String[] args) {
        int N = 5;
        int resultado = calcularSomatorio(N);
        System.out.println("O somatório de 1 até " + N + " é: " + resultado);
    }
}

Typescript

function calcularSomatorio(n: number): number {
    if (n === 1) {
        return 1;
    } else {
        return n + calcularSomatorio(n - 1);
    }
}

const N = 5;
const resultado = calcularSomatorio(N);
console.log(`O somatório de 1 até ${N} é: ${resultado}`);

Praticando com Recursão

De posse deste conhecimento teórico até aqui, vamos praticar! Usualmente, costumo praticar o uso de técnicas e a melhora da minha capacidade de solucionar problemas com o site Codewars.

6 kyu - Mutual Recursion

Descrição do Problema

A Mutual Recursion nos permite aproveitar a diversão da recursão regular (onde uma função chama a si mesma até atingir uma condição de término) e aplicá-la a múltiplas funções que se chamam reciprocamente!

Vamos usar as sequências Feminina e Masculina de Hofstadter para demonstrar essa técnica. Você precisará criar duas funções, F e M, de forma que as seguintes equações sejam verdadeiras:

Exemplo

F(0) = 1
M(0) = 0
F(n) = n - M(F(n - 1))
M(n) = n - F(M(n - 1))

Solução

Aqui é bem simples, o problema nos dá o caso base e o passo recursivo então é só traduzir isto em código.

export function F(n:number):number {
  if (n === 0) return 1;

  return n - M(F(n-1));
}

export function M(n:number):number {
  if (n === 0) return 0;

  return n - F(M(n-1));
}

6 kyu - The Book of Mormon

Descrição

Os mórmons estão tentando encontrar novos seguidores e, para fazer isso, embarcam em missões.

Cada vez que eles vão em uma missão, cada mórmon converte um número fixo de pessoas (reach) em seguidores. Isso continua e todos os mórmons recém-convertidos, bem como todos os mórmons originais, embarcam em outra missão e convertem o mesmo número fixo de pessoas cada um. O processo continua até que eles alcancem um número predefinido de seguidores (target).

Os mórmons convertidos são únicos, de modo que não há duplicação entre eles.

Complete a função que calcula quantas missões os mórmons precisam embarcar para alcançar sua meta. Embora cada solução correta passe, para mais diversão, tente criar uma função recursiva.

Todas as entradas são inteiros positivos válidos.

Exemplo

starting_number = 10, reach = 3, target = 9  -->  0
# No missions needed because the number of followers already exceeds target

starting_number = 40, reach = 2, target = 120  -->  1
# Every mormon converts 2 people, so after 1 mission there are 40 + 80 = 120 mormons

starting_number = 20_000, reach = 2, target = 7_000_000_000  -->  12
# Mormons dominate the world after only 12 missions!

Solução

Diferentemente do primeiro desafio, aqui o problema nos apresenta situações que a partir da nossa interpretação devemos tirar nossas próprias conclusões para encontrar a solução.

A primeira coisa que conseguimos obter é o caso base e o caso mais importante, pois ele será a condição de parada para que nossa recursão não seja um loop infinito.

starting_number = 10, reach = 3, target = 9  -->  0
# No missions needed because the number of followers already exceeds target

Então quando startingNumber for maior que o target ele vai retornar 0.

Agora vamos ver os passos recursivos e como devemos chamar a função repetidamente para retornar o número de ciclos que a condição seja atingida.

starting_number = 40, reach = 2, target = 120  -->  1
# Every mormon converts 2 people, so after 1 mission there are 40 + 80 = 120 mormons

Ele faz uma verificação somando o número inicial (startingNumber) com o produto do número inicial vezes o alcance (reach), o que eu quero dizer é: 40 + (40 * 2).

Como no próximo ciclo, ele será igual ao target, ele retorna 1. E importante, que agora nós obtemos mais uma informação do Caso BASE, é que não basta ser só maior, tem que ser maior ou igual.

Então para cada ciclo de conversão soma-se 1.

Vamos a solução que eu encontrei para este problema:

export function Mormons(startingNumber:number, reach:number, target:number):number{

  if (startingNumber >= target) return 0;

  return 1 + Mormons(startingNumber + startingNumber * reach, reach, target);

}

Considerações Importantes sobre Recursão

É importante considerar sempre com muito cuidado a condição de parada, ou seja, o processo que as chamadas deverão ser interrompidas.

A recursão não obrigatoriamente traz economia de memória, afinal, os valores que são mantidos em pilhas para cada etapa em que são processados (leia sobre stack overflow).

Stack Overflow: É um efeito adverso de uma recursão mal elaborada. A função recursiva chama a si mesmo repetidamente sem encontrar um ponto de parada até que não haja mais espaço disponível em memória.

Nem sempre será mais rápido, justamente por conta do motivo acima citado.

Conclusão

Chegamos ao fim de mais um capítulo nesta série sobre Estruturas de Dados e Algoritmos, e encontramos nessa técnica uma maneira de solucionar problemas de forma elegante e modular.

Em contrapartida, mais importante do que ser uma forma elegante é a sua importância quando formos estudar estruturas de dados como as árvores, onde entender recursão é essencial para esta etapa do aprendizado e do conhecimento.

Até a próxima!

Sobre o Autor

Entendendo a Relação entre SQL, DML e DDL: Fundamentos de Banco de Dados

Matheus 🇧🇷 — Mon, 07 Aug 2023 19:34:31 +0000

Introdução:

Neste artigo, irei explorar sobre a linguagem SQL para a manipulação e o gerenciamento de dados em bancos de dados relacionais. É importante destacar que o SQL os quatro tipos de comandos: Criar, Ler, Atualizar e Deletar.

Estas quatro operações são carinhosamente chamadas de CRUD. Por isso, vamos discutir e compreender essa relação entre o SQL, DML e DDL.

Este artigo é parte de uma síntese de notas soltas entre a disciplina de banco de dados do tecnólogo que faço, e do bootcamp que estou fazendo no momento.

Então, vamos começar!

Abordando a linguagem SQL

O SQL é uma linguagem com o propósito de permitir que pessoas técnicas e não técnicas façam requisições, manipulem e transformem os dados em um banco de dados relacional.

Por ser uma linguagem simples, os banco de dados SQL são seguros e fornecem suporte a escalabilidade para muitos serviços na web quanto em aplicações mobile.

A Importância da DML na Manipulação de Dados

Em português, a DML pode ter o significado de "Linguagem de Manipulação de Dados", ou seja, a DML é essencial por permitir ao usuário realizar operações cruciais em um banco de dados relacional.

Seguem os comandos DML:

SELECT; /*Permite que os usuários busquem por informações gerais ou específicas*/
INSERT; /*Permite que se adicione novos registros (linhas) a uma tabela*/
UPDATE; /*Permite modificar valores de colunas existentes*/
DELETE; /*Permite a remoção de registros de uma tabela*/

Desta maneira, a DML permite que aqueles que irão manipular o banco de dados realizem as operações de forma eficiente e segura.

Explorando a DDL e sua Relação com a Estrutura do Banco de Dados

Em português, a DDL se traduz como a "Linguagem de Definição de Dados". Enquanto na anterior falamos sobre a manipulação em um banco de dados relacionais, agora nós passamos a falar sobre a definição da estrutura do banco de dados pretendido, ou seja, gerenciamento dos objetos que o compõe.

Seguem os comandos DDL:

CREATE; /*Criar novos objetos no banco de dados, tabelas, índices, views*/
ALTER; /*Modificcar a estrutura de objetos já existentes, add ou remover colunas, tipo de dado*/
DROP; /*Excluir objetos do banco de dados*/
TRUNCATE; /*Remover todos os dados de uma tabela, mantendo sua estrutura intacta*/

A DDL é crucial pelo seu aspecto administrativo onde busca criar e modificar o banco de dados com o propósito de atender a necessidade do sistema e dos usuários. Sendo assim, importante para:

Criar e modificar tabelas e objetos;
Garantir a integridade dos dados;
Otimização do desempenho;
Segurança;
Manutenção e escalabilidade.

Praticando

A maneira de praticar conceitos teóricos aprendidos é sempre fundamental para concretizar os estudos, mas diferentemente de praticar com desafios de códigos, praticar SQL depende muito mais de já encontrarmos banco de dados prontos e então experimentar técnicas nele para extrair informações.

CS50: Semana 7 - SQL Deixarei aqui minhas soluções da semana 7 do CS50 que trata diretamente de manipulação de banco de dados com SQL.

Neste post encontra-se as respostas que investiguei para os desafios do laboratório, recomendo sempre o CS50 como um excelente estudo de base para diversos conceitos introdutórios e fundamentais para desenvolvimento de software.

Conclusão

Tanto a DML quanto a DDL são as duas partes principais da linguagem SQL, onde juntas oferecem uma abordagem completa para criar, manipular e gerenciar bancos de dados relacionais.

Fico por aqui, e se estiver interessado em saber mais sobre estrutura de dados e algoritmos, acompanhe minha série em desenvolvimento sobre esse assunto.

Até a próxima!

Explorando as Fundamentais Estruturas de Dados: Algoritmos de Ordenação

Matheus 🇧🇷 — Sun, 06 Aug 2023 22:04:49 +0000

Introdução

Continuando essa série de publicações sobre estrutura de dados. Na publicação anterior falei que essa série de publicações faz parte das minhas anotações e estudos sobre o assunto dentro da disciplina do tecnólogo que faço. A disciplina é de Estrutura de Dados e vamos continuar aprofundando.

Neste próximo passo, vamos explorar sobre os algoritmos de ordenação. Vamos começar!

A importância da Ordenação

Antes de aprofundar especificamente em ordenação, gostaria de falar sobre o que é esse grupo de algoritmos. Na publicação anterior, comentei que:

Um conjunto de dados é um tipo abstrato de dados, estabelecendo uma relação, as funções e as operações que podem ser aplicados a estes dados.

Desta maneira, os algoritmos de ordenação são ferramentas onde os métodos de ordenação são funções e/ou operações a esse conjunto de dados que possuem técnicas diversas de ordenação para resolver uma mesma tarefa.

Podemos assumir então que ordenar os dados é uma operação essencial, pois se refere a organização de um conjunto de dados que pode facilitar a busca, a recuperação e a análise desses mesmos dados.

Explorando diferentes tipos de ordenação

Existem vários tipos de algoritmos de ordenação, cada um com suas próprias características e eficiência.

Não falarei de todos, falarei dos dois que seguem nessa tabela a seguir:

Algoritmo	Descrição	Complexidade Big O
Bubble Sort	Comparação e troca de elementos adjacentes.	O(n^2)
Quick Sort	Algoritmo de divisão e conquista com escolha de pivô	O(n log n)
	e particionamento recursivo da lista.

O motivo de não falar de outros como o Merge Sort, por exemplo, é devido ao texto ficar muito longo e quero dar mais o tom do texto que existe tanto quanto a técnica iterativa quanto recursiva.

Estas anotações não isentam o estudo de outros métodos de ordenação.

Bubble Sort

Os elementos vão se deslocando a cada iteração até a posição correta para ordenação da lista. É importante lembrar que como os elementos neste tipo de ordenação são constantemente trocados, há um alto custo com essa troca de elementos.

Um aspecto interessante do Bubble Sort é que sempre é necessário apenas uma iteração em toda a lista para que o maior item de uma lista seja deslocado para o final dela.

Pseudocódigo

Procedimento BubbleSort(lista)
    n <- tamanho da lista
    i, j, aux inteiro

    Para i de 0 até n-1
        trocou <- Falso

        Para j de 0 até n-i-1
            Se lista[j] > lista[j+1] Então
                // Troca os elementos de posição
                aux <- lista[j]
                lista[j] <- lista[j+1]
                lista[j+1] <- aux
                trocou <- Verdadeiro
            Fim Se

        Fim Para

        Se trocou = Falso Então
            // A lista está totalmente ordenada, podemos encerrar o loop
            Parar
        Fim Se

    Fim Para

Fim Procedimento

Java

import java.util.Arrays;

public class BubbleSort {
    public static void main(String[] args) {
        int[] lista = {26, 47, 38, 11, 95};
        bubbleSort(lista);
        System.out.println("Lista ordenada: " + Arrays.toString(lista));
    }

    public static void bubbleSort(int[] arr) {
        int n = arr.length;

        for (int i = 0; i < n - 1; i++) {

            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    // Troca os elementos de posição
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;

                }
            }
        }
    }
}

Typescript

function bubbleSort(arr: number[]): void {
    const n = arr.length;

    for (let i = 0; i < n - 1; i++) {
        for (let j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                // Troca os elementos de posição
                const temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

const lista = [26, 47, 38, 11, 95];
bubbleSort(lista);
console.log("Lista ordenada:", lista);

Quick Sort

Este é um algoritmo de ordenação que utiliza a técnica de recursão para resolver problemas de ordenação. A ideia é baseada na ideia de Dividir e Conquistar:

Dividir: Pega-se um problema M e divide-se em subproblemas menores de forma recursiva.
Conquistar: Une as soluções dos subproblemas para obter a solução do problema maior P.

Pseudocódigo

Como visto no pseudocódigo abaixo, para desenvolver este algoritmo vamos precisar de duas funções:

1ª Função é a Partição: É quem vai produzir o pivô que vai deslocar os elementos que são menores para um lado, e maiores para o outro.
2ª Função é o Quick Sort: É quem vai empregar a técnica recursiva e fazer uso da ideia de Dividir e Conquistar falada acima.

quicksort(p inteiro, q inteiro, vetor[] inteiro)
    inicio_modulo
        Declarar
            x inteiro;

        se (p < q)
            então
                x <- particao(p, q, vetor);
                quicksort(p, x - 1, vetor);
                quicksort(x + 1, q, vetor);
        fimse;
    fimMódulo;

Java

import java.util.Arrays;

public class QuickSort {
    public static void main(String[] args) {
        int[] lista = {26, 47, 38, 11, 95};
        quickSort(lista, 0, lista.length - 1);
        System.out.println("Lista ordenada: " + Arrays.toString(lista));
    }

    public static void quickSort(int[] arr, int low, int high) {
        if (low >= high) {
            return;
        }

        int idxPivo = partition(arr, low, high);

        quickSort(arr, low, idxPivo - 1);
        quickSort(arr, idxPivo + 1, high);
    }

    public static int partition(int[] arr, int low, int high) {
        int pivo = arr[high];
        int idx = low - 1;

        for (int i = low; i < high; ++i) {
            if (arr[i] <= pivo) {
                idx++;
                int temp = arr[i];
                arr[i] = arr[idx];
                arr[idx] = temp;
            }
        }

        idx++;
        arr[high] = arr[idx];
        arr[idx] = pivo;

        return idx;
    }
}

Typescript

function qs(arr: number[], low: number, high: number): void {
    if (low >= high) {
        return;
    }

    const idxPivo = partition(arr, low, high);

    qs(arr, low, idxPivo - 1);
    qs(arr, idxPivo + 1, high);
}

function partition(arr: number[], low: number, high: number): number {
    const pivo = arr[high];

    let idx = low -1;

    for(let i = low; i < high; ++i) {
        if(arr[i] <= pivo) {
            idx++;
            const temp = arr[i];
            arr[i] = arr[idx];
            arr[idx] = temp;
        }
    }

    idx++;
    arr[high] = arr[idx];
    arr[idx] = pivo;

    return idx;
}

function quickSort(arr: number[]): void {
    qs(arr, 0, arr.length - 1);
}

const lista = [26, 47, 38, 11, 95];
quickSort(lista);
console.log("Lista ordenada:", lista);

Praticando

Sempre após o estudo teórico de um assunto, a melhor maneira de concretizar o entendimento dos fundamentos é praticando com desafios de código. Retornando ao Codewars vamos buscar solucionar alguns desafios que tenham a ordenação como objetivo a ser alcançado.

7 kyu - Sort Numbers

Descrição do problema:

Complete a solução para que ela ordene a matriz de números passada como parâmetro. Se a função receber uma array vazia ou um valor nulo, ela deve retornar uma array vazia.

Por exemplo:

solution([1, 2, 10, 50, 5]); // should return [1, 2, 5, 10, 50]
solution([]); // should return []

Solução:

Aqui, optei pelo uso do Bubble Sort, é um algoritmo mais simples de escrever, o custo computacional não é uma questão aqui e serve exatamente para o que eu quero fazer.

export function solution(nums: number[]): number[] {
  //A condição de contorno caso a função receba um array vazio ou nulo
  if (nums.length === 0 || nums === null) return [];

  //Operação exata do algoritmo de Bubble Sort comentado anteriormente
  for (let i = 0; i < nums.length; i++) {
    for (let j = 0; j < nums.length - i - 1; j++) {
      if (nums[j] > nums[j+1]) {
        //Trocar os elementos de posição
        const temp = nums[j];
        nums[j] = nums[j+1];
        nums[j+1] = temp;
      }
    }
  }

  return nums;
}

Conclusão

Chegamos ao final desta segunda publicação desta série sobre Estrutura de Dados e Algoritmos. Lembrando que essa síntese de ideias fazem parte de anotações soltas e pessoais para o estudo da disciplina do tecnólogo, e aqui é uma forma de eu sintetizar essas ideias e poder compartilhar algo que estou aprendendo.

Se puder, vamos nos conectar no LinkedIn!

Até a próxima!

Explorando as Fundamentais Estruturas de Dados: Uma Introdução

Matheus 🇧🇷 — Tue, 01 Aug 2023 20:21:01 +0000

Introdução

Seja bem-vindo a esta primeira publicação de uma série que pretendo fazer sobre estrutura de dados. Sou um estudante, em transição de carreira, que está estudando esta disciplina no tecnólogo em análise e desenvolvimento de sistemas, e gostaria de compartilhar tudo aquilo que estou aprendendo e estudando mais sobre o assunto.

Nesta série vamos explorar os blocos fundamentais no que diz respeito ao desenvolvimento de software e solução de problemas. Vamos começar!

Definição

Podemos pensar que Estrutura de Dados são conjuntos que armazenam dados de forma eficiente, fornecendo ao usuário operações que o auxiliam a trabalhar com estas estruturas (ordenar, buscar e outros).

Um conjunto de dados é um tipo abstrato de dados, estabelecendo uma relação, as funções e as operações que podem ser aplicados a estes dados. Assim, uma estrutura de dados é uma implementação de um tipo abstrato de dados.

Deste modo, temos alguns tipos de Estrutura de Dados como Vetores, Matrizes, Pilhas, Filas, Árvores, Hashtables e Grafos.

Básico

Complexidade Big O

Big O é uma forma de categorizarmos algoritmos em tempo de execução e consumo de memória com base no tamanho da entrada de dados fornecida. Big O não tenta ser uma medida exata, e sim uma ideia generalizada para compreender a ordem de grandeza do algoritmo.

E é importante entender isto pois é uma ferramenta que nos ajuda na tomada de decisões sobre qual estrutura de dados será implementada para determinado algoritmo pretendido. Sabendo como o algoritmo vai performar, nos dá uma segurança maior sobre a qualidade do programa que será desenvolvido.

Estrutura de Vetores e Matrizes

Essas estruturas de dados são homogêneas pois todos os elementos tem o mesmo tipo associado.

Desta maneira, temos os Vetores que é:

Variável composta homogênea unidimensional;
Formada por uma sequência de valores, todos do mesmo tipo, com o mesmo identificador e alocadas em sequência na memória.
Uma vez que todos os valores possuem o mesmo identificador, o que distingue um valor do outro é a sua posição nesta sequência (estrutura), aqui chamaremos esta posição de índice.

Todos os Vetores são Matrizes, a diferença é que a Matriz possui mais de uma dimensão, ou seja, Matriz é:

Variável composta homogênea multidimensional;
Formada por uma sequência de valores, todos do mesmo tipo, com o mesmo identificador e alocadas em sequência na memória.
Uma vez que todos os valores possuem o mesmo identificador, o que distingue um valor do outro é a sua posição nesta sequência (estrutura), aqui chamaremos esta posição de índice.

Pseudocódigo

// Declarando vetor
Declarar
    notas[3] real;

    // Atribuindo em Vetor
    notas[0] <- 9,0;
    notas[1] <- 8,0;
    notas[2] <- 9,5;

// Declarando matriz
Declarar
    notas[2][2] real;

    // Atribuindo em Matriz
    notas[0][0] <- 9,5;
    notas[0][1] <- 9,0;
    notas[1][0] <- 7,0;
    notas[1][1] <- 5.6;

// Mostrando Valores
Algoritmo MostrarVetor
inicio_algoritmo
    Declarar
        vet[25],i inteiro;

    para i de 0 até 24 passo + 1 faça
        escrever("Digite um valor inteiro");
        ler(vet[i]);
        escrever(vet[i]);
    fimpara;
fim_algoritmo

Java

import javax.swing.JOptionPane;

public class SomaDeValores {

    public static void main(String[] args) {
        int tamanhoVetor = 10;
        int[] valores = new int[tamanhoVetor];

        for (int i = 0; i < tamanhoVetor; i++) {
            String entrada = JOptionPane.showInputDialog("Digite o valor " + (i + 1) + ":");
            valores[i] = Integer.parseInt(entrada);
        }

        int soma = 0;
        for (int valor : valores) {
            soma += valor;
        }

        JOptionPane.showMessageDialog(null, "A soma dos valores é: " + soma);
    }
}

Typescript

Em Typescript não há um tipo específico chamado "vetor", mas os vetores são utilizados por meio de arrays.
Assim, pode-se trabalhar com arrays para representar estruturas de dados semelhantes aos vetores.
Arrays em Typescript é uma coleção ordenada de elementos do mesmo tipo (ou de tipos compatíveis) e é definido pela sintaxe dos colchetes [] ou Array<> = [].

function somarValores(array: number[]): number {
  let soma = 0;
  for (let i = 0; i < array.length; i++) {
    soma += array[i];
  }
  return soma;
}

// Array com 10 valores
const numeros: number[] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

// Chama a função para somar os valores da array
const resultado = somarValores(numeros);

console.log(`A soma dos valores é: ${resultado}`);

Praticando

Gosto de praticar o que foi estudado resolvendo problemas na plataforma Codewars. Desta forma consigo aplicar conceitos teóricos para a resolução de problemas e desafios. Vamos praticar!

8 kyu - Add Length

Descrição do problema:

E se precisarmos que o comprimento das palavras, separadas por um espaço, seja adicionado ao final da própria palavra e que seja retornado como um array?

Exemplo(Entrada --> Saída)

"apple ban" --> ["apple 5", "ban 3"]
"you will win" --> ["you 3", "will 4", "win 3"]

Sua tarefa é escrever uma função que receba uma String e retorne um Array com o comprimento de cada palavra adicionado a cada elemento.

Solução:

export function addLength(str: string): string[] {
  //Transformando a string em uma array
  let strArray = str.split(' ');

  //Criando uma array vazia de Strings para a resposta
  let strReturnArray: string[] = [];

  //Loop para iterar sobre todos os elementos desta array de strings
  for (let i = 0; i < strArray.length; i++) {
    //Template: "String StringLength"
    let str = `${strArray[i]} ${strArray[i].length}`;

    //Utilizando uma operação de Arrays para adicionar essa string na Array.
    strReturnArray.push(str);
  }

  return strReturnArray;
}

Conclusão

Chegamos ao final desta publicação sobre Estrutura de Dados. Este será a primeira publicação de uma série que quero fazer utilizando minhas anotações de estudo, e para que possa compartilhar aquilo que estou aprendendo e como estudo.

Até a próxima!

CS50: Semana 7 | Lab: Músicas

Matheus 🇧🇷 — Wed, 14 Jun 2023 13:39:24 +0000

Retornando com o laboratório de SQL do CS50.

Semana 7: SQL

Um dos motivos que eu considero o CS50 um curso bem completo, principalmente para quem está começando é por conta desta semana.

Se você estiver procurando formas de estudar SQL, provavelmente vai encontrar pela internet diversos locais oferecendo caminhos turvos demais pra algo que poderia ser de forma mais simples e é exatamente isso que essa semana faz. Te dá algo simples, mas poderoso e a partir daí, só tende a crescer conforme a prática.

Laboratório: Songs

É uma atividade onde você vai praticar o uso do banco de dados SQLite e a partir do conhecimento adquirido na aula ira escrever queries SQL para responder diferentes perguntas pedindo para filtrar e selecionar diferentes tipos de dados em uma ou mais tabelas.

Resolução

1.Escreva uma query SQL para retornar uma lista com todas as músicas presentes no banco de dados.

SELECT name FROM songs;

2.Escreva uma query SQL para retornar uma lista com as músicas em ordem de tempo.

SELECT name FROM songs ORDER BY tempo;

3.Escreva uma query SQL para retornar uma lista com o top 5 em termos de duração, em ordem decrescente.

SELECT name FROM songs ORDER BY tempo DESC LIMIT 5;

4.Escreva uma query SQL que retorne uma lista que tenha os termos "danceability", "energy", e "valence" maior que 0.75

SELECT name FROM songs
WHERE (danceability > 0.75
AND energy > 0.75
AND valence > 0.75);

5.Escreva uma query SQL que retorne a média de energia de todas as músicas

SELECT AVG(energy) FROM songs;

6.Escreva uma query SQL que retorne a lista com todas as músicas que são do Post Malone

SELECT songs.name FROM songs JOIN artists ON songs.artists_id = artists.id WHERE artists.name = 'Post Malone';

7.Escreva uma query SQL que retorne a média de energia das músicas que são do Drake.

SELECT AVG(songs.energy) FROM songs
JOIN artists
ON songs.artist_id = artist.id
WHERE artist.name = 'Drake';

8.Escreva uma query SQL que retorne as músicas que incluem participações de outros artistas.

SELECT name FROM songs WHERE name LIKE '%feat%';

Conclusão

Esse laboratório é bem simples e muito divertido de se fazer, é quase um trabalho de investigação e obter o resultado pretendido traz uma satisfação enorme de entender como algo tão simples também é tão poderoso.

Se estiver com dúvidas, só deixar seu comentário aí embaixo.

Até a próxima!

CS50 : Semana 6 | Lab: Copa do Mundo

Matheus 🇧🇷 — Fri, 05 May 2023 19:29:20 +0000

Retornando após uma pausa na escrita, a última vez que escrevi sobre o CS50 foi para o desáfio de pluralidade da Semana 3.

Eu vi que neste ano, o curso adicionou uns laboratórios muito interessantes para se fazer, e vou buscar realizar eles e trazer para cá.

Semana 6: Python

A semana 6 é bem interessante, o curso introduz a linguagem dinâmica Python e refaz uma releitura de todo o curso, só que agora, nesta nova linguagem.

Trata as dificuldades antes enfrentadas na linguagem C e escancara as facilidades que uma linguagem como Python oferece, mas é claro apresenta o trade-off.

Ao final, apresentam-se duas modalidades de atividades:

Lab: Uma atividade que, em tese, é esperado que se faça junto com um ou dois amigos. Vamos tratar deste laboratório nesta postagem.
Problem Sets: Série de atividades com dois níveis de dificuldades. Nesta semana em específico, é refazer os mesmos desafios feitos em C, só que agora em Python.

Como eu já falei destes exercícios em C, no momento não planejo traze-los aqui em Python, mas se tiver alguma dúvida, é só falar.

Laboratório: Copa do Mundo

Eu achei essa atividade muito legal, é para rodar simulações da Copa do Mundo.

Existem duas planilhas .csv com duas colunas (seleções, ratings).
Fará a simulação usando conceitos de funções, leitura de arquivos, manipulação de listas e dicionários, e todos os outros blocos fundamentais de programação

O resultado esperado é um output como este informando a probabilidade da equipe ser campeã.

$ python tournament.py 2018m.csv
Belgium: 20.9% chance of winning
Brazil: 20.3% chance of winning
Portugal: 14.5% chance of winning
Spain: 13.6% chance of winning
Switzerland: 10.5% chance of winning
Argentina: 6.5% chance of winning
England: 3.7% chance of winning
France: 3.3% chance of winning
Denmark: 2.2% chance of winning
Croatia: 2.0% chance of winning
Colombia: 1.8% chance of winning
Sweden: 0.5% chance of winning
Uruguay: 0.1% chance of winning
Mexico: 0.1% chance of winning

Detalhes da Implementação

Seguindo exatamente as etapas de implementação oferecida pelo site do cs50.

PRIMEIRA ETAPA. Primeiro, na main, leia as informações sobre as seleções no arquivo csv para a memória do seu programa (armazenar em uma variável) e adicione cada time a sua lista times.

def main():
    # Ensure correct usage
    if len(sys.argv) != 2:
        sys.exit("Usage: python tournament.py FILENAME")
    teams = []
    # TODO: Read teams into memory from file
    counts = {}
    # TODO: Simulate N tournaments and keep track of win counts
    # Print each team's chances of winning, according to simulation
    for team in sorted(counts, key=lambda team: counts[team], reverse=True):
        print(f"{team}: {counts[team] * 100 / N:.1f}% chance of winning")

Podemos notar que é esperado que se passe na linha de comando dois argumento, sendo um deles o arquivo .csv.
Será lido esse arquivo, no modo leitura.
Para cada linha, vamos criar um par key:value onde teremos uma seleção e seu respectivo rating (nota)
Para cada par criado, vamos adicionar na lista teams.

teams = []
    # TODO: Read teams into memory from file
    with open(sys.argv[1], "r") as csvfile:
        reader = csv.DictReader(csvfile)
        for row in reader:
            team = {"team": row["team"], "rating": int(row["rating"])}
            teams += [team] #append each team in csv in teams list

SEGUNDA ETAPA. Em seguida, implementar a função simulate_tournament. Essa função vai receber como parâmetro a lista com as equipes e simulará rodadas até que sobre apenas uma equipe. Essa função deve retornar o nome desta equipe.

def simulate_tournament(teams):
    """Simulate a tournament. Return name of winning team."""
    # TODO

Já existe uma função simulate_round(teams) que simula as rodadas.
A minha lógica diz que, simular rodadas até que sobre apenas uma equipe, ou seja, até que o tamanho desta lista seja de apenas uma equipe.

def simulate_tournament(teams):
    """Simulate a tournament. Return name of winning team."""
    # TODO
    while len(teams) != 1:
        teams = simulate_round(teams)

    return teams

TERCEIRA ETAPA. Retorne a função main, rode a simulate_tournament N vezes, e mantenha um registro de quantas vezes cada equipe ganhou dentro de um dicionário chamado counts.

counts = {}
    # TODO: Simulate N tournaments and keep track of win counts

Será realizado loops N vezes chamando a função simulate_tournament.
A função simulate_tournament retorna uma lista neste formato:

[{'team': Brazil, 'rating': 1384}]

Usando uma conotação para extrair apenas o valor da chave team, verificamos se o dicionário counts já contêm esta equipe.
Se existir, soma-se 1 (um). Se não, adiciona-se esta equipe ao dicionário de contagens.

counts = {}
    # TODO: Simulate N tournaments and keep track of win counts
    for i in range(N):
        winner = simulate_tournament(teams)
        print(winner[0]["team"])
        if winner[0]["team"] not in counts:
            counts.update({winner[0]["team"]: 1})
        else:
            counts[winner[0]["team"]] += 1

Assim está terminado o desafio.

Conclusão

Este exercicio de laboratório foi muito divertido de se fazer, e pelas possibilidades de poder ensaiar confrontos para outras modalidades e competições que você queira utilizar.

Considero este laboratório muito bom para aprender e praticar os conceitos fundamentais da linguagem python.

Se estiver com dúvidas, ou caso tenha gostado.
Deixe seu comentário aí embaixo, e me adicione nas redes.

Github: repositório da atividade | mpfdev (pessoal)

CS50 : S3 | Pluralidade

Matheus 🇧🇷 — Thu, 01 Sep 2022 23:54:47 +0000

Plurality

Retornando com os desafios do CS50x (versão online), seguimos para a semana 3.

Neste desafio, é pedido que completemos duas funções, sendo estas função vote e a função print_winner

Função vote

Ao baixarmos os arquivos, temos a função desta maneira:

// Update vote totals given a new vote
bool vote(string name)
{
    // TODO
    return false;
}

vote recebe apenas um argumento do tipo string, representando o nome do candidato.
Se o nome for o mesmo de um dos candidatos na eleição, então seu valor de número de votos será incrementado com um novo voto. Assim, a função retornará true para indicar que o voto teve sucesso.

Aqui, temos que nos atentar a estrutura já criada pelo código que baixamos, temos este struct que define que cada candidato, terá um name e um votes, sendo estes caractéristicas desta estrutura da dados.

// Candidates have name and vote count
typedef struct
{
    string name;
    int votes;
}
candidate;

E analisando o código, também temos essa importante informação, indicando que teremos um vetor (array) com o nome de candidates do tipo candidate, ou seja, caso seja criado um vetor com três (3) espaços, cada espaço deste tipo de dado, terá uma estrutura envolvendo um name e um vote particular de cada candidato.

// Array of candidates
candidate candidates[MAX];

Então teremos que percorrer essa lista, e procurar se para cada candidato há uma "match" com o nome inserido para a votação.

for(int i = 0; i < candidate_count; i++) {
        if(strcmp(name, candidates[i].name) == 0) {
            candidates[i].votes += 1;
            return true;
        }
    }

Percorremos essa lista do index inicial (lembrando que é baseado no número 0 como posição inicial), até ao número de candidatos existentes.
Em C, precisamos utilizar desta função strcmp() para comparar valores de strings. Igualamos a zero, pois a documentação nos diz que:

This function returns

    an int less than 0 if s1 comes before s2,
    0 if s1 is the same as s2,
    an int greater than 0 if s1 comes after s2.

Então se o namefor igual ao candidates[i].name retornará o valor zero (0).

Encontrando, incrementa-se o valor do candidato em 1.
Retorne true

Se o name não der match com o nome de nenhum candidato na eleição, então o valor total de votos não se altera, e a função retorna false para indicar que o voto não foi computado.

Temos então, a função vote final.

// Update vote totals given a new vote
bool vote(string name)
{
    for(int i = 0; i < candidate_count; i++) {
        if(strcmp(name, candidates[i].name) == 0) {
            candidates[i].votes += 1;
            return true;
        }
    }
    return false;
}

Função print_winner

A função deve retornar o nome do candidato com o maior número de votos, e então imprimir uma nova linha.

Primeira vamos procurar o número total de votos que existe nesse vetor candidates. E vamos utilizar do loop e criar uma variável para armazenar o maior valor total de votos que existe entre os candidatos.

// Print the winner (or winners) of the election
void print_winner(void)
{
    int max_votes = 0;
    for(int i = 0; i < candidate_count; i++) {
        if(candidates[i].votes > max_votes) {
            max_votes = candidates[i].votes;
        }
    }
}

Criei uma várivel do tipo int para registrar o maior número de votos existente entre os candidatos.
Percorro a lista de candidatos e comparo cada o número de votes de cada candidato ao valor da minha variável.
Se o valor de votos do candidato seja maior que da minha variável original, então o número de votos do candidato é atribuído a variável max_votes.

É possível que uma eleição termine em empate, onde múltiplos candidatos possuem o mesmo número de votos. Neste caso, imprima o nome de cada candidato em linhas separadas.

Aqui, optei por percorrer de novo a lista e agora, comparar quais candidatos possuem o mesmo número de votos da variável max_votes. Desta maneira, seja um ou multíplos candidatos, sempre será imprimido em tela aqueles que tiverem a mesma quantidade de votos que a variável preenchida anteriormente.

// Print the winner (or winners) of the election
void print_winner(void)
{
    int max_votes = 0;
    for(int i = 0; i < candidate_count; i++) {
        if(candidates[i].votes > max_votes) {
            max_votes = candidates[i].votes;
        }
    }

    for(int i = 0; i < candidate_count; i++) {
        if(candidates[i].votes == max_votes) {
            printf("%s\n", candidates[i].name);
        }
    }

}

Percorro a lista, e vou comparando o número de votos de cada candidato com o número máximo de votos computados anteriormente.
Se for igual, será impresso em tela o nome em tela, e junto com o marcador \n para pular a próxima linha.

É isso, pessoal!

Termina por aqui, o PSET da semana 3.