Lógica de Programação e Algoritmos

O que vamos aprender?

Hoje você vai aprender sobre algoritmos e lógica de programação, a base
de tudo que faremos daqui pra frente.
Assim como em uma receita de bolo, na programação, devemos passo a
passo utilizar comandos para resolver um problema. Essa sequência de
comandos se chama algoritmo . Para criar um algoritmo, temos que
desenvolver uma capacidade analítica para transformar grandes
problemas em pequenos e encadeados comandos lógicos. Desenvolvemos
essa forma de raciocinar com a lógica de programação .

Você será capaz de:

● Quebrar grandes problemas em pequenos;

● Utilizar a lógica de programação na resolução de problemas.

Lógica de Programação

A lógica de programação consiste em uma série de regras e normas

baseadas na lógica matemática e em teorias da computação, que tem
como objetivo facilitar o raciocínio no momento da criação de uma cadeia
de comandos.
Antes de adentrar os requisitos mais técnicos, tenha em mente que
aprender a teoria sobre esse assunto não é suficiente. O processo de
utilização da lógica de programação demanda tempo e repetição, até que
se torne automático. Você desenvolverá essa habilidade aos poucos ao
longo de todo o curso!
Outro ponto importante é que a lógica de programação não se restringe a
uma linguagem específica. Você irá aprender a partir de JavaScript , mas
a lógica é aplicável a todas as outras linguagens. Por isso costuma-se
dizer que, a cada linguagem que aprendemos, fica mais fácil aprender a
próxima, pois já exercitamos nosso raciocínio e temos apenas que
adaptar nossos algoritmos , que veremos mais a frente, às
particularidades de determinada linguagem.
Assista esse vídeo para entender os conceitos da lógica:

temos que ser minuciosos em nossa programação, pois a máquina não

consegue completar lacunas no ou explicações pela metade.

A piada de programação é: “meu filho vá na padaria e traga leite, se tiver

ovos, traga 6”.
a maquina não vai saber se é para trazer leite ou ovos.

observe que no código, ainda gabriel vai tentar pegar 6 ovos, e pode não
ter 6 ovos.
Algoritmos

O algoritmo é uma série de comandos encadeados de forma lógica, que

busca resolver algum problema.
Utilizamos lógica em muitos momentos do nosso dia a dia de forma
automática. Pense no leite com achocolatado que você toma pela manhã.
Simples fazê-lo, não? Vejamos o passo a passo:
Copiar
1. Pegar um copo
2. Colocar o copo em cima da mesa
3. Abrir a porta da geladeira
4. Pegar o leite
5. Fechar a porta da geladeira
6. Colocar determinada quantidade de leite no copo
7. Abrir o armário
8. Pegar o achocolatado
9. Fechar a porta do armário
10. Colocar determinada quantidade de achocolatado no copo
11. Pegar uma colher
12. Mexer no copo com a colher
Imagine se tivéssemos que pensar em todo esse passo a passo toda
manhã. Felizmente, já conseguimos interpretar essa série de instruções
de forma lógica e automática.
Os computadores não tem esse poder. Para o bem ou para o mal,
computadores são isentos de vieses e interpretações. Por isso, cada
comando deve ser cirurgicamente determinado. Caso, no passo 4,
estivesse escrito "Pegar o lete", o que seria pra nós um simples erro
ortográfico, mas que não traria danos à execução do processo, para o
computador seria um erro de sintaxe, que inviabilizaria o funcionamento
do algoritmo. Provavelmente um erro como lete is not defined seria
retornado.
Porém, algumas ordens poderiam ser trocadas sem prejuízo na execução.
Por exemplo, poderíamos utilizar os passos 7, 8, 9 e 10 antes dos 3, 4, 5
e 6. Ou seja, colocar o achocolatado no copo antes do leite. Esse tipo de
decisão é comum na vida das pessoas desenvolvedoras.
Quando nos deparamos com problemas, devemos raciocinar e enxergar
quais os caminhos possíveis para a sua resolução. Muitas vezes esses
caminhos são múltiplos, o que nos leva a decidir qual percorrer. Alguns
fatores como performance, propriedades da linguagem utilizada,
legibilidade do código e tempo devem ser levados em consideração no
momento da decisão. No exemplo do leite com achocolatado, existem
pessoas que vão preferir do jeito como está, e existem pessoas que
optarão por colocar o achocolatado antes do leite, e desde que não haja
prejuízo nos fatores citados acima, tudo bem!
Agora, pegue papel e caneta ou abra um bloco de texto e gaste 5 minutos
escrevendo um algoritmo sobre como se vestir para uma festa.
Após escrever o algoritmo, responda as seguintes perguntas:

● Eu resolvi o problema?
● Havia outras maneiras de resolver o problema?
● A maneira que eu escolhi foi a mais eficiente possível, ou havia
como fazer a mesma coisa com menos passos?
● Seria possível inverter ou retirar algum passo?
● Se eu fosse um computador, conseguiria entender todas as
instruções?

Existe também, no processo de criação de um algoritmo, um conceito

muito importante chamado baby steps ou "passos de bebê".
Antes de falarmos dos baby steps , vamos analisar o seguinte exercício:
O enunciado diz:
Utilizando o array abaixo, percorra-o somando todos os valores. Caso o
valor final seja maior que 15, imprima-o. Caso seja igual ou menor que
15, imprima a mensagem: "valor menor que 16":

let fruits = [3, 4, 10, 1, 12];

A resolução do problema acontece em 3 etapas:

1. Interpretação;
2. Criação do algoritmo;
3. Codificação do algoritmo.

Portanto, primeiro vamos interpretar o que está sendo pedido, e essa

etapa é crucial para solucionar o problema. Se interpretarmos errado, o
algoritmo e consequentemente o código estará errado.
Analisando o enunciado, sabemos que:
 ● devemos utilizar o array fruits ;
● o termo " percorra " indica uma estrutura de repetição, ou loop;
● " somando todos os valores " mostra que devemos ter uma variável
que guarda o valor da soma dos valores;
● o termo " caso " indica uma estrutura condicional, ou if ;
● " imprima o valor final " indica um console.log ;

Pode parecer um pouco bobo, mas em enunciados complexos, analisar

friamente o enunciado nos afasta de cometermos erros e termos que
escrever todo os passos seguintes novamente.
Agora vamos criar o algoritmo, e pra isso faremos uso dos baby steps .
Eles nos estimulam a dividir grandes e complexos problemas em
pequenos e simples.

1. Adicionar o array;
2. Criar uma variável com valor 0;
3. Criar um loop que percorre o array;
4. Incrementar a variável com o valor correspondente a cada loop;
5. Criar um if com a condição da variável ser maior que 15;
6. Caso a variável obedeça a condição;
1. Imprimir a variável
7. Caso não obedeça a condição;
1. Imprimir a mensagem "valor menor que 16";

No momento já interpretamos o problema e já criamos um algoritmo,

baseado nos baby steps , para ele. Como última etapa, vamos codificá-lo,
seguindo nosso algoritmo:
Adicionar o array;

//exercise.js
let fruits = [3, 4, 10, 1, 12];

Criar uma variável com valor 0;

Copiar
//exercise.js
let fruits = [3, 4, 10, 1, 12];
let sum = 0;

Criar um loop que percorre o array;

Copiar
//exercise.js
let fruits = [3, 4, 10, 1, 12];
let sum = 0;

for (let index = 0; index < fruits.length; index += 1) {

}

Incrementar a variável com o valor correspondente a cada loop;

Copiar
//exercise.js
let fruits = [3, 4, 10, 1, 12];
let sum = 0;

for (let index = 0; index < fruits.length; index += 1) {

sum += fruits[index];
}

Criar um if com a condição da váriavel ser maior que 15;

Copiar
//exercise.js
let fruits = [3, 4, 10, 1, 12];
let sum = 0;

for (let index = 0; index < fruits.length; index += 1) {

sum += fruits[index];
}

if (sum > 15) {

} else {

Caso a variável obedeça a condição: Imprimir a variável;

Copiar
//exercise.js
let fruits = [3, 4, 10, 1, 12];
let sum = 0;

for (let index = 0; index < fruits.length; index += 1) {

sum += fruits[index];
}

if(sum > 15) {

console.log(sum);
} else {

}
Caso não obedeça a condição: Imprimir a mensagem “valor menor que
16”;
Copiar
//exercise.js
let fruits = [3, 4, 10, 1, 12];
let sum = 0;

for (let index = 0; index < fruits.length; index += 1) {

sum += fruits[index];
}

if (sum > 15) {

console.log(sum);
} else {
console.log('valor menor que 16');
}

Com o tempo e repetição, muitas dessas etapas se tornam automáticas.

Porém, é extremamente útil sabermos construir um algoritmo sem
codificá-lo. Por isso, até o momento da aula ao vivo, volte aos exercícios
do dia anterior, 4.2, e crie um algoritmo para cada.
Após escrever cada algoritmo, responda novamente as seguintes
perguntas:

● Eu resolvi o problema?
● Havia outras maneiras de resolver o problema?
● A maneira que eu escolhi foi a mais eficiente possível?
● Seria possível inverter ou retirar algum passo?
● Se eu fosse um computador, conseguiria entender todas as
intruções?

Lembre-se sempre: se você travar em algum exercício, recomece seu

raciocínio com baby steps! Certamente você será capaz de dividir algum
passo em outros passos menores. Isso ajudará muito na hora de resolver
problemas.

Complexidade de código

Um código muito complexo não é uma boa prática no mundo da

programação. Isso dificulta não só o acompanhamento do código, mas
também a testagem ou a implementação de mudanças.
É normal, principalmente no começo, que o seu código apresente erros de
complexidade e você precise encontrar uma maneira de desenvolver a
sua lógica de uma forma diferente.
Para medir a complexidade de um código, existe a complexidade
ciclomática , que é uma métrica de software que considera os caminhos
independentes que o algoritmo pode tomar. E, quanto maior for a
complexidade ciclomática , mais difícil é fazer o acompanhamento do
código, sua manutenção e testagem.
Para manter a complexidade baixa, você deve sempre tentar simplificar
os caminhos possíveis, como, por exemplo, quebrando o seu código em
partes menores.
Mas que caminhos são esses?
Você aprendeu sobre if/else , certo? Por exemplo, se o seu código
apresenta apenas uma condicional (somente um if/else ), ele tem dois
caminhos, ou faz isso ou faz aquilo. E, quanto mais caminhos tiver, mais
complexo vai ser. Existem várias formas de aumentar a quantidade
desses caminhos, não só usando condicionais. Pode-se, também, por
exemplo, aumentar usando laços de repetição, como for . Mas não foque
nisso agora!
Não se preocupe em como resolver esse erro por agora, pois você irá
entender melhor como fazer isso no conteúdo de amanhã! O foco hoje é
só entender que o erro de complexidade de código existe, para você não
ter uma surpresa no futuro.

achar o fatorial de um numero

let numero= 10;

let factorial = 1;
for(let index=numero; index > 1; index -=1 ) {
factorial *= index;
}
console.log(factorial);

podemos adicionar letras a uma string

como se fosse um numero.
podemos inverter uma palavra

observe que uma string também tem índice e posições como um array.
fizemos um for que irá da ultima letra a primeira da palavra e adiciona ela
na variavel inverse. olhe que a adicionamos com o comando +=.

outro modo de fazer isso é utiliza o método split, para separar todos os caracteres, seguido
do método reverse que fará a inversão do array criado pelo split
Por fim utilizaremos join, para juntar novamente o array em uma string e entregar ela para
nós de forma inversa

O programa abaixo é para achar o maior numero primo de 0 a 50

let marcador = 0;

for(numero = 50; numero> 2; numero-=1){

 marcador = 0;
for(divisor=2; divisor<= numero; divisor +=1 ){
if(numero % divisor == 0){
marcador += 1
}
}
if(marcador == 1){
console.log(numero)
break
}
}

achar a maior palavra de um array,

let array = ['java', 'javascript', 'python', 'html', 'css'];

let moreLetters = 0;
let arrayPossition = 0;

for(index = 0; index < array.length; index +=1){

if(moreLetters < array[index].length){
moreLetters = array[index].length;
arrayPossition = index;
}
}
console.log('A maior palavra é ' + array[arrayPossition])