Transcrições
1. Boas-vindas: Bem-vindo ao nosso curso, como
aprender a programar com o CTO Code Sou Jans D Mercies. Juntos,
aprenderemos passo a passo como resolver problemas simples e mais complicados
com o Cyto Code Um pouco sobre minha formação. Sou formado em
Engenharia Informática e de Telecomunicações com mais de 12 anos de experiência em desenvolvimento
web e mais de
nove anos em fotografia No entanto, minha verdadeira pessoa está no ensino de programação, usando o código CDO Nosso objetivo é que, ao
final das aulas, possamos escrever código
CTO para resolver problemas Esse conhecimento nos ajudará a nos familiarizar com
a mentalidade da programação Mas por que aprendemos a escrever código
CTO antes de
começar a programar Converter um programa escrito em código
CTO em qualquer
logotipo de programação é simples. Isso ocorre porque a
única coisa necessária é aprender o vocabulário
da linguagem de programação em
que ela se Mas vamos ver como alcançaremos
gradualmente esse objetivo. Inicialmente, falaremos sobre o que um computador
entende para resolver um problema para nós fazendo uma visão geral histórica. Em seguida, veremos
qual
é o problema e como pensamos para
chegar à solução. Depois de entendermos a
mentalidade da solução de problemas, poderemos passar
a escrever o código CDO Discutiremos
detalhadamente com exemplos os blocos de construção de
algoritmos com código CDO, bem
como a parte um pouco mais
complexa de s. Dessa forma, obteremos o
conhecimento necessário para nos familiarizarmos
com a programação Ao longo dessa jornada, gradualmente
adquiriremos conhecimentos que nos
ajudarão a resolver problemas usando programas
escritos em código CDO Um desses problemas a serem resolvidos será a tarefa
deste curso Posteriormente, depois de
abordarmos alguns conceitos básicos
sobre o Código CDO, veremos exatamente o que precisamos fazer para
a tarefa No final, espero
ver seus esforços
e seus programas. No entanto, não vamos
demorar mais e começar essa jornada
no mundo da programação.
2. Introdução à codificação: Nesta primeira seção,
forneceremos uma introdução para
definir os algoritmos. Todos nós já ouvimos o
conceito de algoritmo. Mas o que exatamente é isso? Simplesmente, um algoritmo
é uma série de instruções seguidas por um
computador para resolver um problema. Por exemplo, o
glórito a seguir converte
quilômetros em milhas. O usuário simplesmente
insere um valor em quilômetros e o algoritmo
calcula e calcula No código CTO, isso
seria assim. Se quiséssemos dar uma definição
completa, seria essa. Para chamar uma série de
instruções e algoritmos, eles devem atender aos
critérios de entrada, saída, definição,
finitude Vamos ver o que cada um
deles significa. Em primeiro lugar, todo algoritmo
começa com uma entrada. A definição que
vemos aqui significa que precisamos fornecer ao
algoritmo alguns valores, que ele processará para chegar
à solução do problema. No final de cada algoritmo, deve
haver uma saída. O algoritmo deve
fornecer o resultado, que é a solução
para o problema. Esse resultado é
impresso para o usuário ou usado como entrada
para outro algoritmo. Outra característica que
um algoritmo deve ter é a definição As instruções em um algoritmo devem ser claras e óbvias, sem
deixar margem para dúvidas sobre como elas
devem ser executadas. Devemos considerar todos os cenários
possíveis que possam afetar o
fluxo do algoritmo Por exemplo, uma
instrução de divisão deve considerar o caso em que
o divisor é zero Além disso, devemos garantir que o algoritmo que
escrevemos tenha finitude O algoritmo deve terminar após um número finito de etapas Não podemos ter um algoritmo
que funcione para sempre. Por exemplo, adicionar números
positivos até que a soma se torne zero ou
negativa não pode acontecer, então o algoritmo
nunca pararia de funcionar. O último critério
é a eficácia. Cada instrução em um
algoritmo deve ser simples. Isso significa que uma
instrução não
só deve ser definida, mas
também executável Esse critério é violado
nos seguintes casos. Calcule a soma de todos os números
primos até n
e, em seguida, encontre a
raiz quadrada do resultado. O problema é que
essa instrução é muito complexa e consiste em
muitas ações sucessivas, como combater números primos, calcular a soma e
extrair a É difícil de
executar diretamente e deve ser dividido em instruções
semelhantes. Outra instrução é
encontrar a média
dos números negativos em um conjunto que não contém números
negativos. O problema é que, se o conjunto não
contiver números negativos, a instrução não poderá
ser executada, pois não
há números negativos
para calcular a média. A instrução não é executável
sob essas condições. Conforme mencionado
anteriormente, o objetivo de todo algoritmo é
resolver um problema. No entanto, os tipos de problemas não
se limitam aos problemas de
computação. Eles também podem ser outros
problemas em nossa vida diária. Por que os computadores
resolvem um problema em primeiro lugar, em vez
de resolvê-lo nós mesmos? É certo que os humanos estavam resolvendo problemas muito
antes do
surgimento dos computadores e continuam resolvendo
isso mesmo após o
desenvolvimento da tecnologia. No entanto, muitas vezes,
optamos por designar o computador para resolver um problema em vez de resolvê-lo nós mesmos. Por que isso acontece? Em primeiro lugar, os computadores executam instruções e operações
muito mais rápido do que nós. Depois disso, os computadores lidam com
processos repetitivos de forma eficiente Por exemplo, um
computador típico pode realizar cálculos à velocidade
de trilhões por segundo Além disso, os computadores
podem realizar facilmente cálculos
complexos que podem ser desafiadores para humanos. Por fim, preferimos computadores
quando o conjunto de dados problemáticos é extenso, pois eles podem processar grandes quantidades de dados com
rapidez e precisão.
3. Como os computadores operam: Depois de apresentar o
conceito de algoritmos e sua contribuição para a
solução de problemas nas aulas anteriores, é hora de entender um
pouco melhor como os computadores operam e como executam
os comandos que damos a eles. A linguagem que o computador entende é zero e um, conhecida como linguagem de máquina. Com zero e um, indicamos se a corrente está fluindo
ou não, respectivamente. É por isso que os primeiros
computadores tinham switches. Quando queriam
comandar um computador para realizar uma operação,
como um cálculo, ajustavam as
opções apropriadas para dar o comando O primeiro computador
já construído foi muito diferente
dos que usamos hoje Eles tinham um tamanho enorme, eram muito mais lentos no processamento de dados e suas capacidades eram
incomparavelmente O principal problema era que, para cada nova operação que eles
queriam realizar, eles precisavam reconfigurar
os switches Esse era um processo
demorado, especialmente porque os
computadores eram salas inteiras. Com o avanço
da tecnologia, os comutadores foram substituídos por outras tecnologias mais rápidas,
mais confiáveis e
que exigiam menos energia, como
tubos de vácuo, transistores, circuitos
integrados
e No entanto, permaneceu o
problema de que a única maneira de se comunicar com computadores
era por meio da linguagem de máquina. Os programadores
dos primeiros computadores precisavam conhecer muito bem essa
linguagem, o que criou problemas
significativos Não era
compreensível para os humanos , mas era compreensível
pelo computador Os computadores eram
enormes salas inteiras
e, mesmo para uma pequena operação, era necessário muito trabalho. Mesmo que um programa fosse
feito em um computador, ele só funcionaria
nesse computador específico e seria compreensível
por outro Para resolver esses problemas, foi criada
a linguagem de baixo nível ou linguagem
assembly. Essa linguagem era mais
compreensível pelos humanos ,
pois não consistia em
uma sequência de zeros e uns, mas usava palavras como
ad, etc Na linguagem assembly, as palavras correspondem a sequências
de zeros e Assim, um programador poderia dar comandos ao
computador usando palavras
específicas com o computador traduzido
internamente em zeros e uns, usando um programa especial
chamado No entanto, mesmo essa linguagem falhou em resolver problemas
fundamentais. Os programas ainda não puderam ser transferidos de um
computador para outro. O programador precisava ter uma compreensão profunda da arquitetura dos
computadores Os programas em linguagem assembly
eram grandes e complexos, os
tornava difíceis
de manter. Em seguida, veio a linguagem de alto
nível, que surgiu no final dos anos 50 e resolveu o problema
de transferir um programa de um computador para outro. Como isso foi feito? Cada computador usou internamente outros procedimentos que
pegaram os comandos dados em uma
linguagem de alto nível, como Java, e finalmente os
traduziram para a linguagem de máquina Outra vantagem é que
é ainda mais
compreensível para humanos Uma vez que usa vocabulário
como ler e escrever. Além disso, quando outro programa
examina o programa, pode
entender facilmente o que ele faz
e, se necessário, corrigi-lo, facilitando a manutenção
do programa. A única desvantagem é
que, como existe esse processo interno de
tradução de
uma linguagem de alto nível para uma
linguagem de máquina, isso leva tempo No entanto, hoje, a velocidade do
computador é tão alta que esse tempo
é insignificante E não adianta
escrever em linguagem de máquina. Por exemplo, poderíamos escrever um programa em
linguagem de máquina em anos e ele seria
diretamente executável, ou poderíamos escrevê-lo em um
dia em uma linguagem de alto nível e levaria 1
segundo para ser executado Embora escrever em linguagem de alto
nível seja mais fácil, também
precisamos ter
alguma experiência básica em escrever algoritmos para,
eventualmente, escrever o programa. Em outras palavras, criar
um algoritmo ou um programa é voltado para quem tem conhecimento
em programação. Para tornar esse processo mais
acessível para não programadores, foram criadas
linguagens de
quarta geração Um exemplo é o SQL para bancos de dados. A função é que conversamos de forma
muito simples com o programa e ele nos fornece alguns
dados. Por exemplo, forneça os nomes dos alunos que obtiveram notas acima de
dez em programação. Para dar comandos tão simples, não é
preciso ser programador No entanto, o que
podemos solicitar é mais limitado do que escrever um programa em uma linguagem de alto
nível. Concluindo, toda linguagem de
programação tem seus pontos fortes
e fracos Para a pergunta que poderia ser considerada a melhor
e mais eficaz, a resposta é que não
podemos afirmar com certeza que uma linguagem de
programação é objetivamente melhor
do que as outras porque tal linguagem
simplesmente não Não existe uma linguagem de programação conveniente para todos os
tipos de problemas. Alguns podem ser adequados para problemas matemáticos
soberanos. Outros para problemas de negócios e outros para aplicativos
diferentes? Por exemplo, se
alguém quiser
aprender a criar
sites sem um CMS, aprenderá PHP ou
Python e não Java , pois isso serve a
um Isso levanta a questão, já que todos esses atrasos
visam criar um programa Por que os mencionamos
e como nos ajudamos a entender o conceito de algoritmo Ao
escrever um algoritmo, nosso objetivo é ser capaz de
escrever um programa equivalente em qualquer linguagem de programação que resolva um problema específico O algoritmo é escrito em uma linguagem hipotética
chamada código sido código Sydo segue todos os princípios básicos
da programação, mas é um conceito teórico
e, normalmente, um programa é escrito em linguagem de
programação Um programador pode pegar a solução para um
problema escrito em código
CDO e convertê-la em uma linguagem de alto nível
para escrever o Para alguns programadores de UT, é muito mais fácil
entender primeiro o código CDO, pois eles não
precisam aprender muito sobre sua
linguagem de programação imediatamente Com o CDO Code, nos
familiarizamos com a maneira de pensar necessária
para escrever um programa E então, aprendendo o vocabulário da
linguagem de programação adequada para nós, podemos criar o
4. Algoritmos e programas: Vamos
examinar rapidamente alguns conceitos que nos ajudarão na
continuação das aulas Como já mencionamos, um algoritmo é um conceito
teórico. Refere-se ao processo de pensamento a seguir para resolver um problema. Para representar praticamente
esse processo de pensamento, descrevemos os algoritmos
das seguintes maneiras Texto livre,
linguagens naturais passo
a passo, técnicas agramáticas e codificação Usaremos apenas
codificação, ou seja, escreveremos um programa em código
CDO que, quando executado, produzirá os mesmos
resultados do algoritmo Vamos ver brevemente quais são
os outros métodos
com um único exemplo. Em nosso exemplo, queremos
combater o perímetro de um quadrado Em texto livre,
escreveríamos da seguinte forma. Inicialmente, pedimos ao usuário que forneça o comprimento de
um lado de um quadrado. Depois de recebermos o comprimento do lado, mantemos como dado para
os cálculos subsequentes. Multiplicamos o assento por quatro e o resultado dessa operação é o perímetro do quadrado Por fim, apresentamos
o resultado que encontramos, o perímetro do
quadrado para o usuário Em páginas naturais,
escreveríamos da seguinte forma. Início do algoritmo: peça para
descobrir a duração da sessão. Pegue o comprimento do lado,
multiplique o assento por quatro. O resultado é o
perímetro do quadrado. Exiba o
perímetro calculado, d do algoritmo. Em um gráfico flutuante, nós o
descreveríamos da seguinte maneira. Na codificação,
escreveríamos da seguinte maneira. Codificamos quando queremos
escrever o programa
ou um algoritmo A diferença
com os algoritmos é que a codificação é feita no código CDO Enquanto estiver em programas, isso é feito
em uma linguagem de programação. Para entender melhor
a diferença entre um algoritmo
e um programa, vamos dar uma olhada em alguns exemplos. Isso é um algoritmo,
isso está em Python, e isso está em
5. Análise de problemas: Nas aulas anteriores, apresentamos o conceito de
algoritmo e código CDO Portanto, a diferença
entre código CDO e programação
enfatizou por que é
importante estar
familiarizado com o código CDO antes de continuar
aprendendo uma linguagem de Neste capítulo,
veremos como começamos a
resolver um problema. Qual a
estrutura básica de controle que usamos. E quais comandos usamos. Ao mesmo tempo,
começaremos a resolver problemas
simples e
mais complexos codificando com código CDO Como mencionamos em
nossa primeira lição, o propósito de criar um
programa é resolver um problema. No entanto, antes de analisarmos as etapas que precisamos
seguir para conseguir
isso, é importante entender o conceito de
problema como um todo. Esta lição tem muitos aspectos
teóricos. Se fôssemos dar uma definição, diríamos que o
problema é um estado de dificuldade que
precisa ser resolvido. Os problemas existiram na vida diária das
pessoas ao longo dos anos de nossa história e podem estar relacionados a campos de vírus,
como física, matemática, lógica, vida
cotidiana, etc Para abordá-los,
é necessário
compreender completamente todas as
extensões e dimensões. Isso exige que o problema
seja claramente articulado. Se nosso código fizer
uso inadequado da terminologia e o STAC incorreto poderá Isso nos distanciará
de resolver o problema. Mesmo que
as regras verbais e do STAC sejam seguidas, existe a possibilidade de
entender mal o problema Vejamos um exemplo. Dois amigos Ben e Michael
estão falando ao telefone na sexta-feira de manhã para marcar
um horário para passear. Ben pergunta, você pode
chegar no sábado manhã ou à
tarde às seis? Michael respondeu que a
tarde às seis é melhor. No entanto, os dois amigos não
encontraram Ben esperando por
Michael naquela tarde, mas Michael não
apareceu na reunião. A consulta
da tarde às seis está aberta à dupla
interpretação. Ben quis dizer aquela tarde
do mesmo dia, sexta-feira às seis, enquanto Michael quis dizer domingo
à tarde às seis. Portanto, entendemos o
quanto é importante para a formulação adequada
de um problema resolvido Tendo, portanto, formulado
corretamente o problema que desejamos resolver, precisamos então prosseguir
com a estrutura do registro Aqui, podemos ver
a definição
do termo estrutura de um problema. Nós. Se tivermos um problema muito
difícil, nós o dividimos em
subproblemas e depois
dividimos esses subproblemas em problemas
menores e assim por diante Até a solução para os
problemas, é óbvio. Ao resolver esses problemas
simples, também resolvemos
nosso problema original. Outro
requisito importante para resolver um problema é poder
determinar seus requisitos. Em outras palavras, os
dados, o que sabemos e os objetivos, o que
estamos procurando,
devem ser identificados. Em alguns problemas, isso
pode ser facilmente entendido, mas também há
alguns nos quais devemos descobrir os dados e os objetivos a
partir
da descrição do problema. Em resumo, vamos
ver as etapas que
seguimos para resolver um
problema usando um diagrama. Primeiro, devemos entender completamente o problema e identificar
seus dados e objetivos. Em seguida, devemos
analisar o problema. Para fazer isso, devemos
dividir o problema em subproblemas até que suas
soluções sejam visualizadas Finalmente, chegaremos
à solução para o problema original
resolvendo esses subproblemas
6. Estruturas de controle: introdução: Nas seções anteriores, discutimos o que é um programa
escrito em Código CDO, sua finalidade e como ele
nos ajuda a nos preparar para a programação Também abordamos
o que definimos como um problema e os estados
da solução de problemas. Com base nesse conhecimento
e para nos afastarmos do
conceito teórico de algoritmos para a aplicação
prática, usaremos nosso intérprete
on-line Isso nos ajudará a
escrever código CDO em uma linguagem de
programação hipotética, criando nossos próprios uma linguagem de
programação hipotética, criando nossos próprios
programas. É importante esclarecer
que normalmente um programa é escrito em um
atraso de programação e não em código CDO O intérprete on-line é usado
para fins educacionais e nos ajuda a nos
familiarizar com a programação do
processo de pensamento Tudo o que nos resta fazer
para escrever um programa é aprender o vocabulário da linguagem de
programação
na qual
estamos interessados, como Python Agora podemos mergulhar
nos aspectos práticos
e nas estruturas de controle. Essas estruturas são como ferramentas que permitem
ao programador decidir quais partes
do código serão executadas quando e quantas vezes Se aprendermos bem essa estrutura, junto com outras que
abordaremos posteriormente, poderemos escrever qualquer programa em qualquer linguagem de
programação que quisermos. Como a principal diferença é o vocabulário desse idioma Para uma melhor compreensão, serão
dados
exemplos em seu caso, que resolveremos
passo a passo juntos. Vamos ver o que é essa estrutura de
algoritmo ou estrutura de controle
no código do. Estrutura de sequência, estrutura
de seleção, estrutura de seleção
múltipla, procedimentos
aninhados e
estrutura ou loops de repetição
7. Estruturas de controle: estrutura de sequência: No caso em que
temos um problema simples que é resolvido em uma sequência
específica, usamos a estrutura da sequência. Por exemplo, crie um programa
que leia dois números, os
adicione e imprima a
soma na tela do PC Neste ponto, vamos dar uma olhada no que nosso programa
principal faz. Primeiro, ele exibe uma mensagem tela
do usuário solicitando
que ele insira dois números. Em seguida, ele lê esses
dois números e os
armazena em duas
variáveis, A e B. Depois disso, ele
os adiciona e atribui o resultado a uma terceira
variável C. Finalmente, ele exibe uma mensagem
na tela do usuário, seguida pelo resultado
da adição Antes de prosseguir
com a explicação dos comandos usados
neste exemplo, precisamos esclarecer
alguns conceitos O termo comando
se refere a cada palavra no código
CDO que corresponde
a uma ação específica Cada comando é predefinido em
todas as linguagens de programação e nós o usamos como está, por exemplo, para ver o resultado do
programa em nosso Código CDO Usamos o comando publish and not so me, print, etc Outros conceitos úteis são
as seguintes constantes. Por esse termo, nos referimos
a valores predefinidos que permanecem alterados durante a
execução de um programa Variáveis. Um valor
é atribuído à variável que pode mudar durante a
execução do programa. Dependendo do tipo
de valor que elas podem assumir, as variáveis são categorizadas
em indexadores, reais, caracteres Os operadores são símbolos conhecidos usados para realizar várias ações. Os operadores são categorizados
em numéricos, lógicos, também conhecidos como Ed ou
Em nosso código Sydo, são expressos com um ou outro e
um comparativo Uma expressão é uma
sequência de operantes, que são constantes, e
as variáveis também são operadores Uma expressão pode consistir em apenas uma variável ou constante, até uma
representação matemática complexa. Usamos uma
declaração de atribuição para colocar o resultado de uma
expressão em uma variável Vamos agora analisar detalhadamente o programa que escrevemos anteriormente. A primeira coisa que precisamos é
inserir os dados no programa. Para isso, usando
o comando publicado, pedimos ao usuário que nos
forneça os dados. Neste ponto, vale ressaltar que sempre que
nos referimos a impressão, exibição ou saída, isso significa a mesma coisa, mostrar algo para o usuário Isso é feito usando o comando
publicado. Em seguida, usamos a palavra recuperar e o nome de uma
ou mais variáveis A ou B, etc. Com esse comando, a variável A receberá um
valor numérico como seu conteúdo Por exemplo, se o usuário
digitar dois e quatro, variável A será duas e a
variável B quatro, respectivamente. No código CDO, quando usamos
o comando retrieve, ele é
sinônimo de leitura ou entrada e significa ler algo seguida, há uma declaração
de atribuição
cuja finalidade é realizar operações e atribuir o resultado
a uma variável Em nosso exemplo, ele assume
esse formato, mas geralmente pode
ser expresso como expressão de
declaração de atribuição de
variável Sempre à esquerda, temos a variável à direita
da expressão. Isso significa armazenar
o resultado da adição
A e B
na variável C. Por fim, há o comando publicado, que gera o resultado do programa na tela do PC O programa que
acabamos de descrever atende a
todos os critérios que mencionamos anteriormente desde a primeira elação. O comando retrieve A
e B serve como entrada, e o comando publish C serve como saída,
que é o resultado Além disso, é caracterizado pela definição, comandos
definidos, finitude, um
número específico de comandos
e eficácia, comandos claros
e Esse problema pode ter
sido muito simples. Mas se adicionarmos mais
alguns comandos como o nome do programa, as variáveis que usaremos, as
instruções de início e término do programa. Teremos um
programa completo que será executado em nosso interpretador de
código CDO online Aumentaremos gradualmente a dificuldade até
chegarmos às covarias de classificação Agora vamos ver
outro exemplo, um pouco mais complexo. E desta vez, vamos resolver
isso passo a passo juntos. O problema que temos
é o seguinte. Em um teatro infantil, ingressos custam $20 para adultos
e $15 para Precisamos escrever um
programa que
aceite o número de
adultos e crianças que assistiram à
apresentação e mostre a
receita total do teatro. Em primeiro lugar, para resolver o problema, precisamos descobrir quais dados
temos e quais dados devemos
encontrar. Os dados que temos são
que o ingresso para adulto é igual a $20 e o ingresso
para crianças Além disso, pediremos ao usuário
do programa que
nos diga quantos adultos e quantas crianças
frequentaram o teatro. O objetivo é
encontrar a receita total gerada pelo teatro
com a apresentação. Antes de escrever os comandos
que resolvem o problema, vamos revisar os comandos
que dissemos serem necessários
para todos os programas. Primeiro, damos um
nome ao nosso programa, usamos o nome do programa de comando. Esse nome deve sempre começar com uma letra e pode conter
números ou um sublinhado Mas não símbolos ou
outros sinais de pontuação. Em seguida, precisamos
definir as variáveis. Para indicar que
as variáveis virão em seguida, declaramos o
início das variáveis com um comando, variáveis locais E abaixo disso, declaramos as variáveis com os comandos
correspondentes Por exemplo, para declarar variáveis
merecedoras, usamos merecimentos locais Observe aqui que, após os comandos de categoria
para as variáveis, seguem
os dois pontos C, enquanto não há nenhuma coluna nas variáveis locais do comando Como estamos no
início do programa, ainda não
sabemos
quais variáveis inteiras precisaremos em nosso programa Então, escreveremos os números inteiros locais do
comando e os
preencheremos depois de
terminarmos o código CDO
para o programa principal Após a declaração da variável, prosseguimos com o comando
start operation, que indica
o início do código sto
do programa principal. Agora vamos escrever o código principal
do Cado e
dividir nosso problema inicial
em subproblemas A primeira coisa que precisamos
fazer é descobrir quantos adultos e
quantas crianças
frequentaram o teatro. Então, no programa,
escreveríamos isso. Publique, diga-me quantos adultos e quantas crianças
frequentaram o teatro, recupere adultos, crianças em coma O outro problema que
precisamos resolver é
calcular a
receita total para fazer isso. Só precisamos primeiro encontrar a receita total
dos ingressos para
adultos multiplicando o número de adultos
pelo código do ingresso Em seguida, faremos o mesmo com os ingressos
para crianças. Por fim, adicionaremos
a receita de ingressos para
adultos à receita de ingressos para crianças
C para
encontrar a receita total. Tudo o que resta agora é
mostrar ao usuário
o resultado que encontramos. Então, adicionaremos o
seguinte comando. Publique a receita total do
teatro em coma, receita
total, coma dólares. O último comando que
adicionaremos é o programa Ed, que indica o
final do programa. Não esquecemos que
, para funcionar, precisamos declarar as variáveis que usamos no início
do programa Índice local,
adultos, crianças em coma, adultos com
receita,
crianças com receita em coma, receita total Esses são todos os
comandos que usamos e agora vamos ver um exemplo para verificar se o programa
que escrevemos funciona. Por exemplo, se os adultos tivessem dez anos e as
crianças 20, o programa exibiria
a quantia de $500
8. Estruturas de controle: estrutura de seleção (condicional): Se nosso problema
envolve uma escolha, precisamos usar uma estrutura
de seleção. Por exemplo, crie
um programa que decida se
vamos viajar ou não, dependendo do clima. Criamos um programa
e pedimos
ao usuário que nos diga como está o
tempo lá fora. Se a resposta
for que está chovendo muito, o programa deve nos dizer
que ficaremos em casa Caso contrário, faremos uma viagem. Nesse caso, não
seguimos etapas específicas, mas existe a possibilidade de escolha dependendo
do clima externo. Geralmente, a
estrutura de seleção nos ajuda a tomar uma decisão, dependendo se a condição
é verdadeira ou falsa. A forma geral do comando
de seleção é a seguinte. Se for uma condição verdadeira,
então faça comandos, caso contrário, comandos e
D. Vamos ver um exemplo. Queremos criar um programa que determine se um
número inteiro é negativo ou se é
maior ou igual a zero Neste programa, pedimos ao
usuário que insira um número inteiro. Em seguida, primeiro verificamos se o
número é menor que zero
ou, em um caso diferente, se é maior
ou igual a zero, e exibiremos a
mensagem correspondente ao usuário. Agora, vamos resolver um problema um pouco mais complexo
passo a passo. Queremos escrever um programa
que aceite dois indexadores. Se o primeiro número for
maior que o segundo, sua soma será exibida. Caso contrário, sua multiplicação
será exibida. Primeiro, escrevemos os comandos
na seção de declaração e os concluiremos. No final, agora, precisamos pedir ao usuário
do programa que
forneça os indexadores. Em seguida, usaremos o
comando retrieve para inserir os números em
duas variáveis, A e B. Em seguida, precisamos
verificar a condição, se o primeiro número for
maior que o segundo Assim, usamos o
comando de seleção, se verdadeiro. Caso
o primeiro número seja maior que o segundo, daremos o comando
para adicionar os dois números. Colocaremos a soma em uma nova variável chamada C. Se
essa condição não for atendida, seja, qualquer outra condição, multiplicaremos os números e a estrutura de seleção
será concluída No final, exibiremos
ao usuário o conteúdo
da variável C e o programa
será concluído. Optamos por colocar o comando
publicado após o final I para
exibir o resultado, mas poderíamos ter
adicionado aqui e aqui. A única diferença
nesse caso é que
escrevemos publicado duas vezes. Não devemos esquecer que,
para nosso trabalho programado, precisamos declarar as variáveis no início do Locais A, B, C. Vamos ver se o programa
que acabamos de escrever funciona Como podemos ver aqui, se o primeiro número for
maior que o segundo, o programa os adiciona. Por outro lado, se o
segundo for maior, o programa os multiplica.
9. Estruturas de controle: estrutura de seleção múltipla: Várias escolhas um pouco mais complexas do que a estrutura de
seleção, pois se aplicam a problemas em decisões
diferentes podem ser tomadas dependendo do valor
de uma expressão. Geralmente, nos referimos a várias escolhas quando
temos mais de dois casos. A forma geral
do comando de seleção múltipla é a seguinte. Em uma condição verdadeira, então
execute um comando ou comandos, caso
contrário, se for condição, então
faça um comando ou comandos. Caso contrário, comando ou comandos, e vejamos
um exemplo que nos
ajudará a entender a lógica
da múltipla escolha. Queremos escrever um
programa no qual o usuário dê uma
classificação para um serviço de 0 a 10 e o programa exiba a
mensagem apropriada para o usuário Se a classificação for de 0 a 3, ela exibirá uma classificação ruim Se for 4-6, será
exibido como moderado. E se for de 7 a 10, a exibição será muito boa Neste exemplo específico,
analisamos três casos. Se a classificação for de zero a
três, exiba uma classificação ruim; caso
contrário, se for 4-6, exiba uma
classificação moderada; caso contrário, exiba uma classificação muito boa Caso contrário, inclui
todas as outras opções
e, se alguém inserir um número negativo,
ele será exibido. Para ser mais correto, devemos
dizer se verdadeiro zero a três, LF quatro a seis, LC sete a dez No caso de querermos
contabilizar alguém digitando
um número negativo e
evitar que um número negativo e o programa
fique preso, podemos dizer se o verdadeiro
zero a três, o
LC quatro a seis, o
LC sete a dez, caso contrário,
será exibido Vamos ver como
escrevemos o programa. Geralmente, assim que esse programa for executado, ele
fará o seguinte. Com o comando publicado, ele exibirá os métodos, atribuirá a classificação
do serviço em uma escala de 0 a 10 ao usuário Ele esperará até
ler um número do teclado e
o
atribuirá à variável A. Ele começará a realizar as verificações usando
o comando true até encontrar a
primeira condição verdadeira e executará os
comandos dentro dela. Em seguida, ele irá para os comandos abaixo do NT, se existirem. Caso contrário, o programa pára aí ou exibe a mensagem
apropriada. Neste ponto, é
importante destacar
a diferença entre “
bem” e “um”. Em nosso código, adicionamos “
bem” e “não , pois
ambas as condições precisam ser satisfeitas ao
mesmo tempo. Nós usaríamos qualquer um em um caso em que, se pelo menos uma
condição fosse satisfeita, os comandos seriam executados. Por exemplo, considere um programa
que lê a nota de um exame escrito em um
quadrante da escala de 1 a 1 por dois A nota final é dada
pela pontuação média
dos dois examinadores. Se a diferença
na nota for maior ou igual a 15, será exibida uma mensagem indicando que um terceiro examinador precisa revisar o exame
e o programa será encerrado O programa que devemos escrever é nome do programa Exame
1, variáveis
locais, também local, A coma, nota final, iniciar a operação, publicar,
dar as duas notas, recuperar A vírgula B. Se for verdade, isto ou isso, então publicar um terceiro
examinador também será Caso contrário, a nota final é
a mais b dividida por dois. Publicar a nota final é a
nota final e, se for o programa. Outro exemplo que mostra
em detalhes a forma de um programa com procedimentos de múltipla escolha
é o seguinte. provedor de comunicações
aplica a orientação de preços para chamadas
internacionais de 0 a 3
minutos: $1 por minuto, nos próximos três a 10 minutos,
$0,80 por minuto
e todos os minutos restantes, $0,50 Queremos escrever um programa
que receba
os minutos de uma chamada e
exiba a cobrança por ela. Começamos nosso programa com
uma seção de declaração,
onde, nesse caso específico, temos variáveis reais em
vez de indexadores, como nos exemplos
anteriores,
porque alguém pode inserir os minutos
de velocidade em formato decimal Em seguida, solicitaremos que o usuário forneça a
duração da chamada. Isso será feito com o comando
publicado para
exibir a mensagem. Em seguida, o programa
lerá o número
do teclado e o atribuirá
à variável chamada duração. Publique, forneça a duração da chamada em minutos, recupere a duração seguir, trataremos
do caso em que os minutos estão dentro do
limite dos primeiros gráficos. Então, simplesmente
multiplicaremos os minutos
pelos gráficos por minuto Em seguida, continuamos
com o caso em que a duração está acima de
três a 10 minutos. O resultado é a soma
da cobrança dos primeiros 3 minutos mais os minutos restantes multiplicada pela carga correspondente Ou seja, nos
primeiros 3 minutos, multiplicaremos por $1
e, pela duração menos
os primeiros 3 minutos, multiplicaremos Em seguida, se a duração do
resfriamento for superior a 10 minutos, fazemos algo semelhante Calculamos a
cobrança nos primeiros 3 minutos. Adicione os gráficos para
os próximos 7 minutos
e os minutos restantes
serão multiplicados por 0,50 USD Em seguida, também consideraremos o caso em que alguém
insere um número negativo. No final,
mostraremos a saída, que são os gráficos da chamada, e fecharemos o programa com
o comando end program. Não devemos esquecer que,
para que nosso programa funcione, precisamos declarar as variáveis que usamos no início
do programa Gráficos locais de vírgula de duração. Agora, vamos executar o programa. Suponha que a
duração da chamada seja de 11 minutos. O programa entra
no terceiro caso e fornece o resultado correto.
10. Estruturas de controle: procedimentos aninhados: Procedimentos aninhados se referem
à possibilidade de ter
um caso dentro de um caso Aqui está um exemplo.
Crie um programa que leia a altura e a cor do
cabelo do usuário. Se a altura for maior que 6,2 e o usuário for loiro,
ele exibirá uma cabeça alta e loira Se a altura estiver abaixo de 6,2
e o usuário for loiro, ele exibirá
altura média e cabeça loira Nesse caso, temos
duas declarações if. Um se está aninhado dentro de outro. Então, temos que escrever um programa que
tenha aproximadamente quatro casos. Se o usuário é loiro
e é loiro, se o usuário é moreno e moreno, se o usuário tem
estatura média e sangue é contratado, e se o usuário tem
estatura média e morena, vamos ver agora como
escreveríamos esse programa Nós damos um nome
com o nome do programa. Começamos as variáveis
com variáveis locais. Inicie a operação. Publique , forneça a altura em ajustes,
recupere a altura Publique, dê cor ao cabelo
loiro ou calor escuro. Recupere a altura. Se for verdade. Altura maior que
6,2, então faça. Se for verdade. é igual a cabelo loiro,
então publique cabelo loiro e cabelo ensanguentado. Caso contrário, publique a
ferramenta e a cabeça escura. Fechamos a declaração IF
com F. Caso contrário, é verdade, cabelo é igual a cabeça
loira, então
publique altura média e coração
sanguíneo, caso contrário,
publique
altura média e cabeça escura, e se for, e Adicionamos a altura Ls local e os caracteres
locais aqui. A única diferença aqui
é que temos um fim se isso marcar o
fim de seu aninhamento, se for verdadeiro, e outro para
o externo É importante observar
que, neste exemplo, não
estamos considerando
casos em que alguém insere algo diferente
do que pedimos Vejamos um exemplo
que resolveremos juntos, escreveremos um programa que leia as notas de zero a
dez de um aluno de educação física
em dois esportes e exibições nas
quais ele passou. Começamos nosso programa com
a seção de declaração,
onde, neste caso específico, temos variáveis reais porque alguém pode inserir as
notas em formato decimal Primeiro, com o comando
publicado, solicitaremos ao usuário
as duas notas. Em seguida, o programa os
lerá e
os atribuirá às variáveis
A e B, respectivamente. Publique, dê a nota para o primeiro esporte em uma escala de 0 a 10, recupere A, publique,
dê a nota para o segundo esporte na
escala de 0 a 10, recupere B. Então precisamos verificar as
condições A primeira condição que
vamos verificar é se o aluno foi aprovado na primeira
e também na segunda disciplina. Nesse caso, uma mensagem de
parabéns será exibida para o usuário Em seguida, o LC será executado somente se o segundo
assunto não for aprovado Embora saibamos
pela licença
externa que o primeiro
assunto foi aprovado. Nesse caso,
mostraremos que o aluno foi aprovado apenas
na primeira disciplina. Caso contrário, publique uma entrada inválida para o segundo assunto e
, em caso afirmativo, fecharemos a próxima para ser maior
ou igual a cinco, bem
como menor ou igual a dez com o comando
end I. seguir, passaremos para o
caso em que o aluno não foi
aprovado na primeira disciplina e nem na segunda. Mostraremos que o aluno não foi aprovado em nenhuma disciplina. Com a publicação, você não
passa nas duas disciplinas. Se o aluno não foi
aprovado na primeira disciplina, que verificamos
na dif externa, mas foi aprovado na segunda
disciplina verificada com viz, mostraremos que o aluno foi aprovado somente
na segunda O programa executará os comandos dentro
do caso contrário. Somente se o número fornecido estiver fora das bordas de zero a dez. Em seguida, fechamos o df aninhado e a única coisa que
resta é o caso em que um valor incorreto é fornecido para o primeiro
assunto em uma variável A. Em seguida, fechamos o
externo, se verdadeiro, e o programa é concluído com o comando end program Vejamos, se o programa com apenas uma estrada funciona, como vemos aqui, inserimos dois números em que
ambos são maiores que cinco, e ele exibe a mensagem
apropriada. Mas se você inserir números
para os outros casos, verá que ele também exibe a mensagem
apropriada.
11. Estruturas de controle: estrutura de repetição: Quando precisamos realizar
uma etapa várias vezes, usamos uma estrutura de repetição. Por exemplo, se quisermos exibir todos os números inteiros de 1 a Para evitar escrever um programa que inclua todos esses números
grandes e entediantes, usamos uma das três estruturas de
repetição As estruturas de repetição
são as seguintes. Quando sabemos com antecedência
quantas vezes queremos que
o loop seja executado,
usamos a estrutura de loop
que é para o loop I, começando em zero
e terminando em três, publique I e loop. Ele inclui todos os
elementos necessários para o loop, que é o
valor inicial da variável I e seu valor final.
Vamos ver um exemplo. Queremos escrever um
programa que adicione todos os indexadores de 1 a 100
e exiba a soma Adição 100 do nome do programa, variáveis
locais, indexadores locais
I sum. Inicie a operação. Inicializamos a soma com zero. Para o loop I, começando
em zero com a intenção de 100, soma é S mais I loop, publique su end program Neste exemplo, a variável I aumenta
em um em sua iteração, é por isso que não precisamos
escrevê-la no programa Aqui, devemos observar
que as etapas padrão que aumentam I são uma. Se quisermos ser qualquer
outra coisa, por exemplo, três, devemos declará-la com
o comando step Vamos também dar uma olhada
nesse exemplo. Queremos encontrar a soma dos números inteiros pares de 1
a 100. O programa que escreveremos
não é muito
diferente do anterior. A única diferença
é que aqui
adicionamos a etapa como um terceiro
argumento, que é dois. Nesse caso, escrevemos
o nome do loop,
a variável I com
seu intervalo de valores,
que é de 2 a 100 e,
finalmente, o valor dois, que é a etapa pela qual a variável I aumenta
em sua iteração A segunda
estrutura de repetição é a seguinte. Enquanto a condição for,
faça o seguinte. Comando ou loop de comandos. Vejamos um
exemplo nesse caso. Queremos escrever um
programa no qual o usuário insira números
positivos e o programa os
exiba. O programa será encerrado quando o usuário inserir
um número negativo e não exibir o número
negativo Depois de iniciar a operação,
recupere x, desde que x seja maior que
zero, faça o seguinte Publique x, recupere x e faça um loop, finalize o programa Nesse caso, antes
do início do loop, a variável x deve ser definida ou
lida no teclado. Suponha que, no exemplo acima, um número negativo seja fornecido
diretamente como a primeira entrada. Nesse caso, o programa
não entrará no loop e terminará aí No entanto, se fosse positivo, repetiria todas as etapas
do loop, desde que. Quando o programa recebe
um número negativo, ele não entra
no loop para exibir o número negativo
devido à condição, mas vai diretamente para os
comandos após o loop final. Nesse caso específico, não
há outros comandos, então o programa termina aí A instrução inicial do loop up
until indica que os comandos serão executados até que a
condição seja verdadeira. Quando a condição for verdadeira, o programa continua com os comandos que
seguem o pentil Está estruturado da seguinte forma. Inicie o comando ou comandos de loop. Até a condição. O programa que vimos na estrutura de gás
tão longa, que lê exibe todos os números
positivos, pode ser escrito de forma correspondente usando
a estrutura inicial do loop Nesse caso de loop, o
programa não precisa saber o valor da
variável x antes do loop. Portanto, temos o comando retrieve
dentro do loop e a condição será verificada
no final da iteração,
não no início Vamos supor que,
no exemplo acima, um número negativo
seja fornecido diretamente. O loop começa com
um comando start loop, lê o
número negativo e o exibe. Em seguida, a condição é
verificada e o loop termina. No entanto, se o
número for positivo, ele repetirá todas as etapas do comando
start loop. Esses dois loops,
o as long gas e loop
inicial, têm três
diferenças entre eles. Para que o
circuito de gás do salão
seja executado, a condição deve ser x maior que zero, enquanto que no circuito inicial, x deve ser menor que zero. Como podemos ver, as
duas condições são opostas uma à outra. No caso em que
o primeiro número fornecido pelo usuário fosse negativo, o loop aslng gas
não seria executado de forma alguma, enquanto o loop inicial seria executado uma vez antes Portanto, o circuito de gás azalng pode não ser executado nem Como a verificação é feita
no início do loop, o
loop inicial
será executado pelo menos uma vez. No entanto, para que a condição seja verificada no comando as
long gas, a variável x deve ser
definida antes do loop. Já no loop inicial, a variável geralmente é
definida dentro do loop. Até agora, discutimos todos os comandos necessários
para escrever um programa. Em seguida, usaremos esses
comandos para resolver problemas
mais complexos
usando matrizes Por favor, deixe-me saber se você tiver alguma dúvida na discussão.
12. Arrays: introdução: Até agora, estudamos as estruturas básicas de controle
escritas no Código CDO No entanto, existem
certas categorias de problemas que exigem
diferentes tipos de estruturas para serem resolvidos. Quais são essas estruturas? Tanto na programação
quanto no código CDO, quando precisamos gerenciar um grande volume de dados
do mesmo tipo, podemos usar matrizes
em vez de variáveis Nesta seção, veremos
o que definimos como uma matriz.
Quando usamos matrizes, quais tipos de matrizes existem
e como as matrizes funcionam em cdocol Essa é a definição
para matrizes. Mas o que isso significa? Suponha que tenhamos a seguinte
matriz que contém a umidade máxima de seu
dia para o homem anterior. Essa matriz pode ser
definida da seguinte forma. Matriz e entre colchetes. Os valores variam de 0 a 30 para os 31 dias
do homem anterior O é o índice da matriz. Por exemplo, se quisermos usar
a umidade do
quarto dia em nosso programa, nos referimos à matriz com umidade três, que é igual Nesse caso, o
índice é um indexador, constante
ou variável entre colchetes Em raios, temos dados
do mesmo tipo, que podem ser numéricos,
lógicos ou caracteres Para cada matriz que
criamos, devemos declarar seu nome, tipo e o número de
elementos que ela
conterá . O tipo de matriz
pode ser
unidimensional, bidimensional, etc., e declarado no início do programa, como veremos Examinaremos matrizes unidimensionais e bidimensionais, já que nosso objetivo é
introduzir a codificação
13. Arrays: unidimensionais: Vamos começar com
matrizes unidimensionais e ver um exemplo Suponha que desejemos criar um programa com base na
matriz que vimos anteriormente, que contém a
umidade máxima do mês. Escreveremos um programa
que lê a umidade de 31 dias e calcula
a umidade máxima média do mês Sem usar uma matriz, esse programa
seria escrito da seguinte maneira. Nesse caso, usamos somente
variáveis sem uma matriz. Mas se quisermos descobrir por
quantos dias a umidade
foi menor que a média sem
perguntar novamente ao usuário os valores de umidade
por 31 dias, precisaríamos armazenar todos os valores de umidade e compará-los
com a média. Precisaríamos criar
31 variáveis diferentes correspondentes à
umidade de 31 dias. Portanto, o programa que
escreveríamos teria 31 comandos de
recuperação 31, se forem comandos verdadeiros. Essa solução
pode estar correta, mas não é prática para
uma grande quantidade de dados. Por exemplo, se
quisermos os valores
de umidade de um ano inteiro, nesse caso, a solução
é dada usando uma área. Nessa matriz, os valores de
umidade terão posições contínuas e cada elemento
da matriz
será identificado por seu índice Por exemplo, a umidade
30 corresponde ao dia 30 e contém o valor de
umidade de 50. Como usamos apenas um índice
para nos referirmos a um elemento, nossa matriz é unidimensional. O programa, que escreveremos
para descobrir em quantos dias a umidade é inferior ao valor médio do
mês, é o seguinte. Inicialmente, criamos
uma matriz chamada umidade e alocamos
31 posições, que é sempre do
tamanho da matriz É importante observar aqui que o tamanho
da matriz é fixo e ela não pode ter
mais elementos do que o tamanho declarado
durante sua criação, nem pode ter aqui? Nesse caso específico, não pode ser diferente
de 31 elementos. Em seguida, atribuímos o valor
zero à variável total e veremos mais tarde
por que fazemos isso. Em seguida, precisamos
preencher a matriz com os valores de umidade fornecidos
pelo usuário para o dia. Uma posição na matriz
representa um dia do mês e cada elemento
na matriz é um valor
que representa a umidade. Portanto, como sabemos exatamente
quantas matrizes
precisaremos para preencher a matriz, sempre
usamos a iteração de quatro
loops com I tomando valores para cada dia do primeiro ao 31º Em seguida, exibimos
a mensagem que o usuário verá
na tela, para
que ele entenda o
que precisa inserir, que é fornecer
a umidade do dia seguida
pela variável I, que é o número
do respectivo dia. Colocamos o
valor de umidade que o usuário acabou fornecer na
posição correspondente na matriz, usando a
matriz de umidade e o índice I. Como precisamos calcular
a umidade média
de todos os dias, agora
usaremos a
variável total, que inicializamos com
zero no início Ao final do ciclo, essa variável conterá a soma de todos os
valores de umidade do mês. Em seguida, dividiremos o total
por 31 para encontrar a média. Agora, para descobrir
quantas datas tiveram menos umidade do que a
média do mês, precisaremos definir
os dados no Ay. Para fazer isso, usaremos o loop 1-31 para acessar os valores
contidos no Ay Em sua iteração, convertemos
o valor de umidade do dia atual do primeiro para o último com
a média mensal Se for encontrado um dia com umidade
inferior à média, temos um contador, que é essencialmente uma
variável chamada dias. Esse contador aumenta em um. É hora de a condição de
comparação anterior ser atendida. Depois de verificar todos os
elementos na matriz, exibiremos duas
mensagens para o usuário. Uma delas será a mensagem. A umidade média
do mês é seguida pelo
valor da média e a outra
será a mensagem. Os dias com
umidade menor que a média são seguidos
pelo número de dias. Nesse ponto, o programa termina com um programa final de
comando Esse foi o nosso exemplo para
matrizes unidimensionais. Agora vamos ver um exemplo com uma matriz bidimensional.
14. Arrays: bidimensionais: No caso de matrizes
bidimensionais, usamos dois índices para
especificar um elemento Por exemplo, se quiséssemos
calcular a umidade média de dez cidades ao longo um mês e determinar em
quantos dias a umidade foi maior que o valor médio correspondente. A matriz que
criaríamos seria a seguinte. Essa matriz é de 31 por dez, uma matriz bidimensional, então temos 31 valores de umidade, mas para dez cidades diferentes, que significa um total de
310 valores de umidade Para definir os elementos de
uma matriz bidimensional, usamos dois índices
no formato matriz, r vírgula C. O primeiro corresponde às linhas
da matriz
e o segundo às colunas, e o segundo às colunas, C R é para linhas no momento da definição da matriz e índice da
linha durante o C é para colunas no momento
da definição da matriz e
do
índice da coluna durante o eixo. Por exemplo, na matriz
anterior, a umidade do elemento
31 tem um valor de 50. Qual seria o valor do
elemento umidade 210? A resposta correta é 73. Para resolver o problema anterior, escreveríamos o
seguinte programa. A lógica é a mesma do exemplo anterior,
em que tínhamos uma matriz
unidimensional. Mas aqui, a diferença é que, além
da variável I, também
temos a variável j. Vamos ver como criaríamos a matriz por apenas um
dia para todas as dez cidades. Para Loop, começando em
um e terminando em dez. Pressione, forneça a umidade da cidade J, recupere a
umidade, faça um loop Agora fica mais fácil
ver como faríamos
isso com uma
matriz bidimensional ou 31 dias. Para Loop, começando em
um e terminando em 31, para Loop, começando em um
e terminando em dez, Publish, forneça a umidade
para a cidade J, o dia I. Recupere a umidade
I, loop final e loop final Essencialmente,
adicionamos mais um loop para os 31 dias do mês, que conterá
o loop anterior que tratava dos
valores de umidade de cada cidade Além disso, o I que adicionamos
nos comandos published e retrieve se refere aos índices
do Ry
bidimensional Vamos ver como essa matriz
seria preenchida na prática. Inicialmente, entramos no
loop com I igual a um. Ou seja, no primeiro dia, e diretamente no
circuito j igual a um, a umidade da
primeira cidade será adicionada Então j se tornará dois enquanto ainda estamos em I é
igual a um e assim por diante Então, quando j for igual a dez, teremos os valores de umidade para as dez cidades
no primeiro dia O loop j então terminará. Eu me tornarei dois e J assumirá novamente os valores 1 a 10 até que os valores do
segundo dia sejam concluídos Isso continuará
até que I seja igual a 31 e j seja igual a dez, ponto
em que o
loop externo I Neste ponto, eles serão
preenchidos com os dados que queremos. Agora, vamos ver como encontrar
a umidade média
de cada cidade
consultando a matriz e utilizando os dados
que ela já contém Como queremos ler
a matriz por cidade, isso significa que precisamos
ler os dados verticalmente por cidade. Para conseguir isso, desta vez,
o loop externo será J e o loop interno será I,
para loop, começando em
um e terminando em dez,
para loop, começando em
um e terminando em um. Inicialmente, queremos um total de chamadas
variável que conterá a soma de
todos os valores de uma cidade. Com base nessa soma,
encontraremos a média
de cada cidade. E antes de passar
para a próxima cidade, devemos redefinir essa variável. Para loop, começando em
um e terminando em dez. Inicializamos o total com zero. Para o loop I, começando
em um e terminando em 31. O total é o total
anteriormente mais a umidade I. Fechamos o circuito e a média é o
total dividido por 31. Para armazenar a média
de cada cidade, criaremos uma matriz
unidimensional com a média de cada
cidade chamada média. Neste ponto,
preenchemos a matriz média, que contém a
média de cada cidade. Agora queremos
pesquisar na matriz para ver em
quantos dias a umidade foi maior do que a média da cidade. Examinaremos a
matriz verticalmente, comparando a umidade do dia com a média da cidade Nos dias em que a umidade for maior que a média, nossos dias contadores aumentarão. Antes do término
do ciclo da primeira cidade, exibimos a
umidade média da cidade e os dias em que a umidade foi
maior do que a média do usuário. Em seguida, esse ciclo será repetido
para as cidades restantes, quando é hora de nossos
contadores de dias serem reiniciados. Depois disso, o programa
será concluído. Como vimos, a única
diferença entre matrizes
bidimensionais unidimensionais é o número de dados usados, significando R para matrizes unidimensionais e R comum para matrizes
bidimensionais Para preencher uma
matriz unidimensional, usamos um loop. Já para matrizes
bidimensionais, precisamos de um loop padrão. Até agora, vimos
como declarar uma matriz, como preencher a matriz com dados e como pesquisar uma matriz
para fazer cálculos Agora, vamos analisar algo
mais desafiador do que o que vimos até agora, que é classificar uma matriz
15. Arrays: classificação: Classificar uma matriz é uma operação muito
importante que organiza os dados de uma matriz
em ordem crescente ou
decrescente Ao mesmo tempo, é
uma oportunidade de ver um exemplo
mais exigente do que os que vimos até agora. Vamos agora ver um exemplo de como classificar uma matriz
em ordem crescente Nós temos essa matriz.
Nove, cinco, sete e dois, e
queremos classificá-lo em uma ordem de configuração para que
fique assim. Vamos ver como
pensaríamos em criar esse programa. Inicialmente, sabemos que os elementos da
matriz são quatro. Precisaremos de um loop para mover o número dois para o
início da matriz. Para que isso aconteça,
compararemos o último elemento da matriz
com todos os anteriores. E saberemos no
final da aparência que o primeiro elemento da matriz também
é o menor
da matriz. Então, a partir do
último número R A quatro, vamos comparar o número
dois com o anterior, RA quatro menos um,
que é R A três, e se for menor, vamos movê-lo
uma linha acima na matriz Isso será repetido
para o elemento R três com y três menos um Isso é dois com cinco. Então, vai ficar assim. E, finalmente, será
repetido para o elemento RA dois com R dois menos um, ou
seja, dois com nove Então, vai ficar assim. Não há necessidade de continuar o loop comparando a matriz
um com y um menos um, pois não há matriz
zero nessa matriz Isso ocorre porque começamos a
contar a matriz de 1 a 4. Poderíamos começar a contar
a matriz de 0 a 3
sem problemas, pois isso significa
o mesmo que um a quatro Se tivéssemos iniciado arri
com índices 0-3, haveria nenhum
elemento menos um em y. E o último loop
não poderia converter o elemento
R A zero com R A zero menos um Porque, simplificando, R A
menos um não existe. O número de repetições
necessárias para mover o número dois para a
primeira linha foi três Por esse motivo, começaremos nosso loop com i
igual a quatro a dois Com um passo de menos
um, para que
comecemos do final do exército
e subamos gradualmente Neste ponto, queremos
trocar o conteúdo de y por y menos Para conseguir isso, usaremos uma variável chamada temp
como variável temporária Nessa variável,
armazenaremos o valor atual de R, que na primeira
iteração é igual a dois Então, temos i igual a dois
e dez é igual a dois. Em seguida, atribuiremos o
valor de A i menos um, o
que significa que os dois RA
serão substituídos por sete, e colocaremos o valor
antigo de A, que armazenamos na variável n igual
a dois em i Se não usássemos
a variável dez, perderíamos o
valor anterior armazenado em A durante isso. Então, o programa que escreveríamos
até agora é esse. Nesse ponto, a classificação da matriz ainda não está completa pois somente o menor elemento foi classificado até o
início da Esse processo também deve ser feito para os elementos restantes. Portanto, usaremos mais
uma aparência externa
para conseguir isso. Esse loop com a variável j
assumirá valores do elemento
dois ao elemento quatro. Apenas três comparações são suficientes para comparar todos os
números entre si Isso faz sentido porque
quando comparamos n números, o número de comparações que
faremos é n menos um Vamos ver como isso funciona e explicaremos passo
a passo. Já classificamos
o número dois e iniciamos o mesmo processo a partir do
último elemento da matriz Comparamos RA quatro
com R quatro menos um, ou
seja, sete com cinco E como sete,
maior que cinco, esses dois elementos
não mudarão de lugar. Portanto, a matriz nesta
etapa permanecerá como está. Em seguida, compararemos y três
com R três menos um, ou
seja, cinco com nove, e como cinco menos que nove, o ary se tornará o seguinte O segundo
loop externo para aqui, pois não
há necessidade de
comparar dois com cinco. Segue outro loop para
classificar o último elemento. Comparamos RA quatro com RA quatro menos um e, como sete, menos de nove, ocorrerá uma troca
dos dois elementos e a matriz
assumirá sua forma final O programa final
será assim. É importante notar que nessa forma
final do programa, no loop, substituímos
os dois por uma variável. Vamos agora ver o porquê, passo a passo. Usamos a variável para contar o número de
comparações que precisamos No entanto, à medida
que as comparações que fazemos aumentam, também aumentam os elementos
que são classificados Por esse motivo,
no loop interno, iniciamos a comparação a partir do último elemento, como
o raio quatro Mas o número de comparações que precisaremos não será constante Ele diminuirá cada
vez que o loop externo for executado. significa que J aumentará, e isso significa que o
número de loops net de que precisamos diminuirá após
cada loop externo Esse é o processo que seguimos para classificar a matriz usando
o método de classificação por bolhas É importante notar
aqui que esse é um
dos algoritmos de classificação mais simples de entender,
mas, ao mesmo tempo, é um dos mais demorados
16. Projeto: Neste ponto,
concluímos nossa teoria e os exercícios de exemplo que
demonstramos e resolvemos juntos. Agora você pode resolver problemas
sozinho usando programas. Para começar, você pode começar
com nosso projeto. Todas as
informações necessárias para resolver esse problema são encontradas
nas lições anteriores. Uma solução simples já foi enviada para a galeria de projetos da
classe. No entanto, essa não é
a única solução. Essa é a beleza
da programação. Isso pode ser feito de
várias maneiras diferentes , desde que produza
os resultados corretos. Eu ficaria feliz em
ver seu programa com a solução para o problema
escrita no Código CDO
17. Conclusão: Ao concluirmos nossas aulas, vamos
analisar o que abordamos. Inicialmente, voltamos no tempo e analisamos a
evolução de como
damos comandos aos computadores de uma linguagem senoidal para linguagens de quarta
geração Em seguida, discutimos o
conceito de um problema
e, especificamente,
o processo de pensamento que seguimos para resolver um problema. Com esses
conceitos básicos em mente, estávamos prontos para
falar sobre o código CDO Exploramos como os programas nos
ajudam a resolver problemas, as estruturas de controle que usamos e como cada uma delas funciona Em seguida, passamos para aspectos
um pouco mais complexos da programação e
conversamos sobre matrizes Quando os usamos para nos ajudar, como pesquisamos um
elemento em uma matriz e como os classificamos. Agora, a única coisa que
resta é praticar o que todos nós já aprendemos
resolvendo mais exercícios. E estamos prontos para entrar
no campo da programação. Sou Janes De Merzz. Obrigado a todos por se juntarem a mim nessa jornada pela codificação. Sinta-se à vontade para perguntar qualquer coisa
que você não tenha entendido ou se há alguma parte
do curso que você acha que
poderia ser melhorada. Não se esqueça de
me seguir para obter mais conteúdo. E lembre-se: mantenha-se curioso, mantenha-se inspirado e
nunca pare de aprender.