Lógica deprogramação

Autor: Eduardo FranciscoRevisão Ortográfica: Josué Souza

Copyleft: Este é um trabalho livre, você pode copiar, distribuir emodificar sob os termos da licença Art Libre: https://artlibre.org

SumarioIntrodução................................................................................................0Abstrações................................................................................................1Paradigmas...............................................................................................2

* Imperativo........................................................................................2* Funcional..........................................................................................2* Declarativo.......................................................................................2* Orientado a objetos.........................................................................2

Estrutura de dados..................................................................................3Operações.................................................................................................4Controle de fluxo.....................................................................................5Variáveis...................................................................................................6Sintaxe......................................................................................................7Semântica.................................................................................................8Estilo de código........................................................................................9Como prosseguir....................................................................................10Problemas...............................................................................................11Funções...................................................................................................13Funções variádicas................................................................................14Recursão.................................................................................................15Problemas recursivos............................................................................16Arranjos..................................................................................................17Problemas array....................................................................................18Sistema de tipos.....................................................................................19Operação bitwise...................................................................................20Algorítimos............................................................................................21Conclusão...............................................................................................22Dicas........................................................................................................23

Introdução

Neste livro você aprenderá os fundamentos da programação e sua lógica, e por entender esse processo será capaz de compreender e utilizar qualquer linguagem de programação.

Inicialmente iremos fazer uso de uma linguagem, que iremos declarar no decorrer do livro, ganhando assim entendimento de cada parte no processo.

Os conceitos se darão em sua forma mais simples (já que são equivalentes as formas mais complexas) e desse modo facilitará o entendimento.

Foque no conceito e não na forma, desse modo será capaz de ver as diferentes formas e compreendê-las como iguais (mesmo que no fim não sejam a mesma coisa).

0

Abstrações

A abstração, na ciência da computação, é a fuga do não essencial ouacidental para o contexto primário, por exemplo: se você criou um jogo, não deveria importar qual máquina o executa, o processo deveria ser indiferente a esse aspecto; e isso é possibilitado por abstrações, onde você programa o código somente uma vez, e o compilador/interpretador se encarrega de ser a ponte daquele abstrato para a máquina.

Para a linguagem de programação abstrações permitem dar forma e estruturar a lógica em verbo (o processo em texto), dessa forma você foge da necessidade de lidar com os dados em um campo desestruturado e instável (no sentido de que as máquinas que executam o processo podem ser fundamentalmente diferentes) para um campo estável e lógico.

É importante notar que abstrações tem um preço, quanto maior o nível de abstração mais se sacrifica o desempenho, tanto em nível de tradução quanto de execução.

1

Paradigmas

Os paradigmas são os padrões de abstração, aqui veremos somente os mais comuns/relevantes:

* Imperativo

O paradigma imperativo é baseado na mudança de estado constante e possui controle de fluxo explícito, que é declarado em tempo verbal imperativo (não se deve lhe dar como sinônimo de algorítimo).

* Funcional

O paradigma funcional é baseado na imutabilidade e possui controle de fluxo explícito (usa recursão ao invés de iteração).

* Declarativo

O paradigma declarativo se dá por declarar o que deve ser feito semdeclarar o controle de fluxo (que é implícito).

* Orientado a objetos

O paradigma orientado a objetos é baseado no conceito de “objetos” que podem conter dados na forma de campos (atributos) e código na forma de procedimentos/funções (métodos).

Geralmente as linguagens de programação podem expressar múltiplos paradigmas (seja de forma natural ou “emulada”), e os próprios paradigmas repetem uns aos outros em muitos aspectos. Daqui em diante vamos declarar uma linguagem de programação, eassim ver muitas das abstrações que compõem esses paradigmas (embora nossa linguagem, em si, será imperativa).

2

Estrutura de dados

Qualquer código que exista se trata de transformação, dos dados recebidos aos dados que serão mostrados. Por questões de desempenho e mantenabilidade, estruturamos os dados durante esse processo. Por enquanto aprenderemos somente uma dessas estruturas, pois será necessário para declarar nossa linguagem.

O stack é uma estrutura de dados LIFO (Last In First Out¹), usada para armazenar e obter valores de forma ordenada, possuindo duasoperações “pop” e “push”, que servem para retirar e adicionar valores respectivamente.

Em nossa linguagem faremos uso dessa estrutura de forma implícita, então todo valor dado entrará automaticamente no stacke poderá ser consumido por operações.

[1]: Último a entrar, primeiro a sair

3

Operações

Em nossa linguagem precisaremos de operações matemáticas simples, então vamos defini-las:

Operação SímboloSOMA +SUBTRAÇÃO -DIVISÃO /MODULO %

Essas operações consomem dois valores e retornam um valor pós operação.

Operação SímboloIGUAL =MAIOR >MENOR <MAIOR OU IGUAL >=MENOR OU IGUAL <=NEGAÇÃO !

Essas operações consome dois valores e retornam um valor “booleano”, isso é verdadeiro ou falso, que serão representados por1 e 0 respectivamente.

4

# Qualquer texto após esse caractere “#” é um# comentário10 + 10 # (20) Notação convencional10 10 + # (20) Notação polonesa reversa (stack)# Acostume-se com a notação de stack# como dito anteriormente faremos uso dela25 10 * 50 + # (300)10 5 > # (1)10 5 > ! # (0)10 2 % # (0)

Controle de fluxo

Operações de controle de fluxo servem para ordenar a execução de instruções. Existe controle implícito (como em linguagens declarativas) e explícito (como em linguagens imperativas).

Em nossa linguagem faremos uso de um controle explícito, por meio de somente duas operações, sendo estas “if” e “goto” que servem de condicional e pulo respectivamente.

Em nossa linguagem o “if” será uma palavra reservada que deve sersucedida de dois blocos, a condição e o corpo de instruções, esses devem estar isolados pelos caracteres “{}”.

O “goto” será uma palavra reservada que deve ser sucedida de um “label” (o ponto de pulo), que já deve estar declarado da seguinte forma “nome:”.

5

Variáveis

As variáveis são referências nomeadas, um ponteiro que leva a um endereço de memória que possui a informação atrelada a ela. Por meio desta referência se torna possível reter e alterar valores. Qualquer alteração na referência é refletida na região a qual a mesma aponta.

Em nossa linguagem elas serão declaradas da seguinte forma: “valor nome”; A operação irá consumir do stack o valor →atribuído à variável.

6

Sintaxe

Sintaxe é o conjunto de regras que determinam as possibilidades deassociação das palavras.

• Mim ser um brasileiro nativo # Erro de sintaxe

• Eu sou um brasileiro nativo

No exemplo acima você pode perceber que embora o significado seja o mesmo em ambas as frases, uma delas está incorreta, pois não se pode usar “mim” enquanto se refere ao sujeito da oração.

Com isso em mente vamos ver a sintaxe da nossa linguagem até o momento:

7

<instruções> ::= qualquer código<boolean> ::= valor “booleano”<comentario> ::= qualquer texto<nome> ::= qualquer palavra (Aa a Zz)###############################################<instruções>if { <boolean> } { <instruções> }goto <nome><nome>:# <comentário>

Semântica

Semântica trata do significado e a relação entre significantes.

• Eu fui forçado a quarta-feira

• Ontem dormi verde horas antes de subir a América

Esses são exemplos de erros de semântica, dado que não podemos tirar sentido algum dessas frases.

Vamos ver parte da semântica de nossa linguagem:

Como pode ver a semântica, sendo o significado, pode descrever o comportamento de uma linguagem de programação.

8

if { <condição> } { <expressões> }# O segundo bloco só é executado se a# condição for verdadeira<nome>:# O “nome” se torna um ponto de# pulo para operações “goto”goto <label># O fluxo de execução é movido ao ponto “nome”→ <nome># O “nome” se torna uma variável e o valor# atribuído a ela sera consumido do stack

Estilo de código

O estilo de código é um conjunto de regras, além das sintáticas e semânticas, que é utilizado para organizar o código em si. Esse é um ponto bem subjetivo; o mais importante é ser consistente com um estilo após escolhido.

O estilo de nossa linguagem será o seguinte:

Esteja ciente de que um estilo geralmente se aplica somente a linguagem utilizada (embora haja fatores comuns como indentação).

9

# uma instrução por linha10 10 + 15 * ! ! → xgoto label01# instruções de bloco estruturadas da seguinte# forma:if {x} {

”Olá” # indentação dentro de blocoslabel01: # pontos de pulo não são indentados}

Como prosseguir

Mais à frente veremos problemas para serem solucionados com a nossa linguagem, e todo esse processo deverá ser feito manualmente (mesmo porque não existem compiladores ou interpretadores para nossa linguagem), lendo linha por linha, acompanhando o fluxo e o estado do stack. Também é bom que tente solucionar os problemas antes de ver suas soluções.

Problemas

A este ponto podemos começar a fazer uso da linguagem (embora não esteja completa e haverão adições conforme necessário para explicar outros pontos).

Vamos começar com um problema simples: FizzBuzz; esse teste consiste de imprimir os valores de 1 a 100, mas para múltiplos de 3 ou 5 deve-se imprimir as frases “Fizz” e “Buzz” respectivamente; e para múltiplos de 3 e 5 deve-se imprimir a frase “FizzBuzz”.

Primeiro vamos dissecar o problema, ele consiste basicamente de três conceitos: repetição, módulo e impressão; a repetição é usada para “andar” de 1 a 100 (seja pelo método que for: iteração, recursão, loop desenrolado, etc.); a operação de módulo que nos permite encontrar os valores múltiplos, por retornar o resto de uma divisão; e impressão que é uma operação de “output”(saída).

Todos esses pontos citados são possíveis de se implementar com nossa linguagem, de exceção a saída (já que devemos nos mesmos “executar” o código), então vamos simplesmente jogar os valores no stack como método de impressão e separá-los com uma quebra de linha “\n”.

10

A solução possui três condicionais que quando executadas pulam para a quebra de linha, quando nenhuma condicional é chamada o número é jogado ao stack. Após a quebra de linha o loop é executado de novo caso não tenha chegado até 100.

11

# FizzBuzz0 → iloop:i 1 + → iif {i 15 % 0 =} {

”FizzBuzz”goto next

}if {i 3 % 0 =} {

"Fizz"goto next

}if {i 5 % 0 =} {

"Buzz"goto next

}inext:"\n"if {i 100 <} {

goto loop}

Imprima uma pirâmide com tamanho definido por uma variável, usando os caracteres “*” e “#” como espaço e parte da piramide respectivamente.

A solução possui duas condicionais que são executadas em um loop até preencher o stack com uma parte da pirâmide e seu espaçamento, em relação a parte anterior; em seguida uma quebra de linha é “impressa” e o loop é executado novamente, com o tamanho da próxima parte reduzido em dois, e isso se repeti até o tamanho ser inferior ou igual a zero.

12

5 → tamanho0 → espaço0 → tmploop0:"*"if {tmp} {

tmp 1 - → tmpgoto loop0

}tamanho → tmploop1:"#"if {tamanho} {

tamanho 1 - → tamanhogoto loop1

}"\n"tmp 2 - → tamanhoespaço 1 + → espaçoespaço → tmpif {tamanho 0 >=} goto loop0;

Funções

As funções são rotinas, capazes de receber e retornar valores; que quando chamadas alteram o fluxo de execução para o bloco de instruções daquela função, executando-o, e após isso retornando aofluxo comum.

Também a adicionaremos a nossa linguagem, vejamos a sua sintaxee semântica abaixo:

13

<argumentos> ::= lista de <nomes> separados por virgula###############################################func <nome> <argumentos> { <instruções> }# após declarada, a função pode ser chamada# como uma operação, que atribui variáveis de# acordo com os <argumentos>return <valor># retorna ao fluxo comum de execução (quando a# função foi chamada) junto do “valor” dado

Funções variádicas

As funções variádicas são como funções comuns, com diferença quepodem receber um número indeterminado de argumentos.

Não faremos uso de funções variádicas em nossa linguagem, mas é bom as conhecer.

14

Função(Argumentos) # Notação mais comumFunção Argumentos # Notação polonesaArgumentos Função # Notação polonesa reversa

# Função ComumFC(x, y, z)FC(10, 20, 30) # corretoFC(10) # incorretoFC(10, 20, 30, 40) # incorreto# Função variádicaFV(…)FV(50) # corretoFV(10, 20, 30) # corretoFV(10, 20, 30, 40) # correto

Recursão

A recursão é um processo em que um de seus passos envolve a repetição completa de si. Isso em programação é aplicável a funções que chamam a si mesmas; e também aplicável como qualidade (por exemplo estruturas recursivas, como seria o caso deuma lista encadeada).

A recursão é utilizada para quebrar um problema, em um monte departes menores (na lógica do “dividir para conquistar”), e assim possibilitar uma solução mais compreensível para certos problemasque seriam de difícil compreensão em outros modelos (como um “merge sort”).

Alguns paradigmas tornam o uso desse modelo essencial, como é o caso do paradigma funcional.

15

Problemas recursivos

Vejamos abaixo alguns problemas e suas soluções, essas que deverão se dar de forma recursiva.

Crie uma função que retorne o fatorial de um dado número:

Uma característica a notar dessa solução é que a recursão é o último evento da função, o que torna a recursão uma “recursão de calda”, assim permitindo compiladores optimizarem a mesma (Isso é mais uma nota, pois será um termo que virá a encontrar, mas nãoadentraremos em técnicas de optimização).

Crie uma função que retorne a sequência Fibonacci de um dado número:

16

func fatorial x {if {x 1 <=} {

return 1}# em notação comum# x = x * fatorial(x - 1)x x 1 – fatorial * → xreturn x

}

func fib x {if {x 1 <=} {

return x}# em notação comum# x = fib(x–1) + fib(x-2)x 1 – fib x 2 – fib + → xreturn x

}

Arranjos

Os arranjos, as chamadas “arrays”, são uma estrutura de dados que guarda uma coleção de elementos de forma sequencial na memória,dessa forma permitindo o acesso do mesmo por indexes.

Essa estrutura tem um bom uso de cache do processador (devido a memória contígua), acesso randômico rápido (por indexes) e tamanho fixo (toda extensão de tamanho requer criar uma nova array e copiar a antiga).

Arrays também podem possuir múltiplas dimensões, que será visto nas linguagens como múltiplos indexes: X[3][2]; cada índex representa uma dimensão.

Vamos adicionar essa estrutura a nossa linguagem:

17

<index> ::= index separado por virgulas para dimensão###############################################[<valores>] → <nome># consome os “valores” e cria uma array “nome”<nome>[<index>]# acessa o “index” da array “nome”<valor> → <nome>[<index>]# consome do stack o “valor” e o atribui a# variável “nome” em “index”

Problemas array

Crie uma função que some todos os elementos de uma array:

Perceba que a forma como essa função foi feita a torna equivalente a uma função variádica (embora na prática ambas, arrays e funçõesvariádicas, sejam utilizadas para casos diferentes).

Vamos declarar e acessar matrizes, isso é, arranjos multidimensionais (arranjos de arranjos):

18

func soma tab, tamanho {0 → total0 → idx

loop:if {1 idx + tamanho =} {

return total}tab[idx] total + → totalidx 1 + → idxgoto loop

}

# exemplo de uso[78, 10, 60] → tabelatabela 3 soma

[[1, 2], [3, 4]] → x # 2Dx[0, 0] # retorna 1x[1, 0] # retorna 3[[[1, 2], [3, 4]], [[5, 6], [7, 8]]] → y # 3Dy[0, 0, 0] # retorna 1y[0, 1, 1] # retorna 4y[1, 0, 1] # retorna 6

Sistema de tipos

Um sistema de tipos é um sistema lógico que declara um conjunto de regras que atribuem uma propriedade chamada “tipo” para várias das construções abstratas que fazem parte do programa, como expressões, funções, variáveis ou módulos. Esses tipos definem lógicas de como as estruturas irão interagir entre si, por exemplo uma função que soma números não deveria receber uma string (mensagem).

A checagem de tipos pode se dar de diversas formas: estática contra dinâmica, na primeira forma a tipagem de todos os construtos podem ser verificadas em tempo de compilação (isso é, o fluxo não interfere), já na segunda a checagem ocorre em tempo de execução (certos tipos de checagem mais complexos tornam obrigatório esse método) ; manifesto contra inferido, na primeira forma o tipo é dado a um construto de forma explícita, já na segunda o tipo é implícito, declarado a partir do valor dado; nominal contra estrutural, na primeira forma construtos só são equivalentes/compatíveis quando declarada a equivalência de forma explícita ou por partilhar o exato mesmo tipo(nome), já na segunda os construtos podem ser compatíveis se forem estruturados de forma equivalente.

- Sistema de tipos da nossa linguagem: dinâmica, inferido e estrutural

O propósito primário de um sistema de tipos é capturar “bugs”(erros) em programas, por definir regras para interfaces queagora poderão interagir de forma consistente.

19

Operação bitwise

Operações bitwise (bit-a-bit) são basicamente o reflexo de portões lógicos, abstraído para lidar com números binários.

Temos então uma operação de entrada única: NOT; e três operaçõesde entrada dupla: AND, OR e XOR.

Além dessas há mais três operações de entrada dupla: NAND, NOR eXNOR; que são reflexos negativos das anteriores:

Essas operações geralmente não são muito utilizadas em linguagens de alto nível, ainda sim é bom conhecê-las.

20

Algorítimos

Um algorítimo é um conjunto de instruções que descreve a solução de um dado problema.

Os algorítimo possuem diversas classificações: classificação de fluxo, serial (um parte por vez até o fim), paralelo (múltiplas partesem execução simultânea) ou distribuído (alternância de execução das partes); classificação de retorno, exato ou heurístico (aproximado); classificação de processo, determinístico ou não-determinístico; classificação de paradigma, força bruta (tentar tudoaté encontrar a melhor solução), dividir para conquistar (quebrar oproblema, geralmente com recursão), reducionismo (tornar o problema em um problema similar já conhecido), etc; classificação de optimização, linear, dinâmica ou gananciosa.

Também podemos categorizar a complexidade teórica de um algoritmo, tanto para espaço quanto tempo. Para isso usamos a notação “grande O”:

Constante O(1)

Logarítmico O(log n)

Linear O(n)

Polinomial O(n )ᶜExponencial O(c )ⁿFatorial O(n!)

Onde “n” é relacionado ao input e “c” é uma constante (importantenotar que a notação não se resumi àquela tabela).

Como esse é um assunto mais complexo, não haverá uma abordagem profunda do mesmo, mas se quiser se aprofundar os tópicos aqui citados sobre o assunto lhe darão uma direção do que procurar.

21

Conclusão

Aqui o ponto central é entender o processo de programação, por isso declaramos e fizemos uso de uma linguagem inexistente; e também ver muitas das abstrações e termos básicos mais comuns.

O entendimento do processo deve-se dar de forma que o fazer se torne algo fluído e intuitivo; para isso é extremamente importante que você mesmo resolva diversos problemas de diversa formas.

Caso deseje partir daqui direto para uma linguagem de verdade, lembre-se de não se prender na forma, por exemplo: em “C” você terá a palavra reservada “for”, como um dos meios de executar um loop, e embora não tenhamos visto aqui essa forma de loop, sabemos que o mesmo se trata somente de um controle de fluxo, e, portanto, podemos compreendê-lo como tal.

A linguagem que viu não é um “desperdício” completo no processo de partir para uma de verdade, pois qualquer linguagem baseada em stack (como FORTH) será extremamente similar em muitos aspectos.

Para aprender outras linguagens analise sua sintaxe e semântica, pode ser tanto por ver documentos que as descrevem de forma técnica (como com BNF) ou por ver suas palavras reservadas e o uso das mesmas.

22

Dicas

Sobre idiomaticidade: muitas linguagens possuem estilos de código oficiais, nesses casos faça uso deles e se mantenha consistente com os mesmos, além disso leia código considerado idiomático nessa linguagem para ter ideia de como o seu código deveria se parecer para ter essa qualidade.

Sobre complexidade: complexidade desnecessária é a raiz de todos os problemas em programação, então prefira sempre algorítimos/estruturas mais simples e óbvios, e não compare progresso com o número de linhas, que idealmente deve ser reduzido ao máximo possível, sem sacrificar a legibilidade.

Sobre optimização: optimização é um processo geralmente mal executado, resultando em programas inchados; por via de regra você primeiro escreve o código se preocupando com sua legibilidade e elegância (ou seja, simples e bem estruturado), e apósterminado, se e somente se o programa estiver lento (dentro de seucontexto) você o optimiza após mensurar sua execução, assim identificando os “bottlenecks” (pontos de estrangulamento, isso é, os pontos que de fato limitam o desempenho do programa), que geralmente se dão na forma de um uso pobre do cache.

Sobre linguagens: linguagens de programação geralmente são de proposito geral, não caia no meme de as comparar com ferramentas (como martelos), onde cada uma tem seu propósito; é preferível que conheça uma só linguagem e masterize-a, do que conhecer muitas e não programar bem em nenhuma.

Sobre cópia: sempre que copiar uma solução de terceiros copie-a manualmente e tente entender a solução; caso não consiga ao menos faça o processo manualmente, eventualmente as coisas começam a fazer sentido naturalmente.

23

Sobre estrutura de dados: para a grande maioria dos programas essas estruturas de dados: arranjos, listas encadeadas, tabelas de hash e árvores binárias; são suficiente, e além disso fáceis de implementar e entender.

Sobre organização: para preservar a manutenibilidade de um projeto é estritamente necessário que o mesmo esteja organizado, para isso deve-se estruturar os arquivos em uma hierarquia de diretórios que faça sentido para o mesmo (por exemplo separar arquivos estáticos do código), além disso é bom considerar usar umversionador (como GIT ou Mercurial) e dessa forma ter um histórico de mudanças, por consequência ganhando maior controlesobre as mesmas.

Sobre matemática: conhecimento matemático não é estritamente necessário, embora útil para entender muitos assuntos mais afundo, então isso não deveria impedi-lo de programar. Para quem já tem bom conhecimento matemático, lembre-se o código é escritopara seres humanos compreenderem, aprenda a utilizar sua linguagem de forma idiomática, o campo prático é geralmente consideravelmente diferente do teórico.

Sobre inglês: embora não seja estritamente necessário conhecer inglês para programar, é extremamente recomendado, pois nesse campo essa é a língua franca. Não se impeça de começar o processo se não o souber, mas vá aprendendo-o junto, pois será extremamente útil mais tarde.

24