A fórmula de Euler é considerada uma das mais elegantes da matemática: $e^{i\pi} + 1 = 0$. Ela conecta cinco constantes fundamentais.

Equação em bloco (display)

A integral gaussiana é um resultado clássico da análise:

Fração e derivada

A derivada do inverso de $x$ pode ser calculada assim:

Delimitadores alternativos

A função de Bessel de primeira espécie pode ser expressa usando colchetes:

Equações simples

A fórmula de Bhaskara para resolver equações quadráticas é dada por:

Onde $a$, $b$ e $c$ são os coeficientes da equação quadrática $ax^2 + bx + c = 0$.

O $\Delta$ da equação quadrática é calculado por:

Equação com expoentes

A fórmula de crescimento exponencial é expressa por:

Onde $P(t)$ é a população no tempo $t$, $P_0$ é a população inicial, $r$ é a taxa de crescimento e $e$ é a base do logaritmo natural.

Equação com logaritmos

A fórmula do logaritmo natural é dada por:

Equação com somatório

A fórmula do somatório para a série geométrica é:

Onde $a$ é o primeiro termo, $r$ é a razão e $n$ é o número de termos.

Equação com matrizes

A multiplicação de matrizes é definida por:

Onde $C_{ij} = \sum_{k=1}^{n} A_{ik} B_{kj}$ para matrizes $A$ de dimensão $m \times n$ e $B$ de dimensão $n \times p$.

Matriz de identidade

A matriz de identidade $I_n$ é uma matriz quadrada de ordem $n$ com 1’s na diagonal principal e 0’s em todas as outras posições:

Lógica

A tabela verdade para a conjunção lógica (AND) é:

Os conectivos lógicos são fundamentais para a construção de expressões booleanas e circuitos digitais.

São eles:

• Conjunção (AND): $P \land Q$
• Disjunção (OR): $P \lor Q$
• Negação (NOT): $\neg P$
• Implicação (IMPLIES): $P \rightarrow Q$
• Bicondicional (IFF): $P \leftrightarrow Q$
• XOR (Exclusive OR): $P \oplus Q$
• NAND (Not AND): $\overline{P \land Q}$
• NOR (Not OR): $\overline{P \lor Q}$

Limites

O limite fundamental do cálculo é:

Limite no infinito: $\lim_{n \to \infty} \left(1 + \frac{1}{n}\right)^n = e$.

Limite superior e inferior de uma sequência:

Letras gregas

O alfabeto grego é amplamente utilizado na matemática. Algumas letras minúsculas:

E suas versões maiúsculas: $\Gamma$, $\Delta$, $\Theta$, $\Lambda$, $\Xi$, $\Pi$, $\Sigma$, $\Phi$, $\Psi$, $\Omega$.

Variantes: $\varepsilon$, $\vartheta$, $\varphi$, $\varrho$, $\varsigma$.

Funções hiperbólicas

As funções hiperbólicas são análogas às trigonométricas:

Logaritmo com base

A mudança de base do logaritmo é expressa por:

O logaritmo decimal: $\lg 100 = 2$.

Derivadas de ordem superior

A segunda derivada de $f$ em relação a $x$:

A derivada parcial de segunda ordem:

Notação de linha para derivadas: $f’(x)$, $f’‘(x)$, $f’’‘(x)$.

Raízes

Raiz quadrada: $\sqrt{2}$. Raiz cúbica: $\sqrt[3]{27}$. Raiz quarta: $\sqrt[4]{16}$. Raiz quinta: $\sqrt[5]{x}$.

Conjuntos numéricos

Os principais conjuntos numéricos são $\mathbb{N}$ (naturais), $\mathbb{Z}$ (inteiros), $\mathbb{Q}$ (racionais), $\mathbb{R}$ (reais) e $\mathbb{C}$ (complexos).

Teoria de conjuntos

União e interseção: $A \cup B$, $A \cap B$. Diferença: $A \setminus B$. Conjunto vazio: $\varnothing$.

Pertinência e não pertinência: $x \in A$, $y \notin B$.

Subconjuntos: $A \subseteq B$, $A \supseteq B$, $A \not\subset B$.

Relações de comparação

Setas

Setas simples: $\rightarrow$, $\leftarrow$, $\leftrightarrow$, $\uparrow$, $\downarrow$.

Setas duplas: $\Rightarrow$, $\Leftarrow$, $\Leftrightarrow$.

Mapeamento: $f \colon A \to B$, $x \mapsto f(x)$.

Setas estendidas: $\xrightarrow{f}$, $\xleftarrow[\text{abaixo}]{\text{acima}}$.

Setas diagonais: $\nearrow$, $\searrow$, $\swarrow$, $\nwarrow$.

Equilíbrio químico: $\rightleftharpoons$.

Binomial e fatorial

O coeficiente binomial é dado por:

Casos (funções por partes)

A função valor absoluto pode ser definida por casos:

Matrizes

Matriz com parênteses:

Determinante:

Produto interno e norma

O produto interno é denotado por colchetes angulares:

A norma de um vetor é dada por:

Piso e teto

As funções piso e teto são definidas por:

Acentos matemáticos

Vetor: $\vec{v}$, $\overrightarrow{AB}$. Chapéu: $\hat{x}$, $\widehat{ABC}$. Barra: $\bar{x}$. Til: $\tilde{x}$. Ponto: $\dot{x}$, $\ddot{x}$.

Sobrescritos e subscritos especiais

Inverso: $A^{-1}$. Transposta: $A^T$. Graus: $90^{\circ}$.

Expoentes compostos: $e^{i\pi}$, $2^{2^n}$.

Números decimais

Constantes matemáticas: $\pi \approx 3.14159$, $e \approx 2.71828$, $\sqrt{2} \approx 1.41421$.

Razão e proporção

A razão áurea: $a : b = b : (a + b)$.

Aritmética modular

O teorema de Fermat: $a^{p-1} \equiv 1 \pmod{p}$.

Quantificadores

Negação genérica

Exemplos de negação: $a \not\equiv b$, $A \not\subset B$, $x \not\in S$, $a \not\parallel b$.

Overset, underset e stackrel

Operadores grandes adicionais

Coprodutório: $\coprod_{i=1}^{n} G_i$. União grande: $\bigcup_{i=1}^{n} A_i$. Interseção grande: $\bigcap_{i=1}^{n} A_i$.

Frações contínuas

A fração contínua de $\sqrt{2}$:

Operadores diversos

Produto tensorial: $V \otimes W$. Soma direta: $V \oplus W$. Composição: $f \circ g$. Divisão: $a \div b$.

Reticências: $1, 2, 3, \ldots, n$ e $1 + 2 + \cdots + n$.

Geometria: $\angle ABC = 90^{\circ}$, $\triangle ABC \sim \triangle DEF$.

Portanto e porque: $\therefore x = 1$, $\because x > 0$.

Phantom (espaçamento invisível)

Alinhamento usando phantom: $\phantom{-}3$ e $-3$.

Álgebra linear

O núcleo e a imagem de uma transformação linear:

Probabilidade e estatística

Parte real e imaginária: $\Re(z)$, $\Im(z)$.

Máximo divisor comum

zoom_in

Clique para ampliar

Apresentação

A evolução das interfaces do computador, que passaram dos terminais de texto para ambientes gráficos avançados, recursos 3D e dispositivos de computação ubíqua, trouxe desafios importantes para a inclusão de pessoas com deficiência visual. Nesse cenário, o leitor de telas se destaca como uma tecnologia assistiva essencial. Ele funciona como um intermediário entre o sistema operacional e a forma como a pessoa acessa o conteúdo, e por isso é uma ferramenta indispensável para a autonomia digital.

Este artigo apresenta a evolução histórica dos leitores de tela, explica conceitos fundamentais do seu funcionamento e descreve como essas ferramentas aparecem em diferentes plataformas. Também discute a diferença entre a usabilidade baseada na visão e a usabilidade baseada em recursos não visuais.

Além disso, destaca que a acessibilidade digital não depende apenas do leitor de telas. Ela é resultado da combinação entre aplicações (programas), frameworks (conjuntos de bibliotecas que ajudam a construir software), sistemas operacionais e mecanismos de acessibilidade que permitem que essas partes se comuniquem.

Mais do que um programa que “fala o que está na tela”, o leitor de telas é uma forma de interação com o ambiente digital para pessoas que não usam a visão como principal meio de acesso à informação. Em vez de depender de ícones, cores e posições na tela, a navegação acontece principalmente por voz e, em muitos casos, também por linhas Braille, que permitem a leitura tátil do conteúdo digital.

Com isso, torna-se possível ler textos, identificar botões, preencher formulários, acompanhar mensagens e usar diferentes tipos de aplicações. Na prática, essa tecnologia abre caminho para que pessoas com deficiência visual possam acessar serviços e funcionalidades comuns do dia a dia com mais independência.

Além dos leitores de tela tradicionais, ferramentas baseadas em inteligência artificial também têm ampliado possibilidades, principalmente em tarefas como descrição de imagens, leitura de conteúdos complexos e apoio à compreensão de contextos.

Ao contrário do que muitas pessoas imaginam, leitores de tela não leem tudo automaticamente do começo ao fim. O uso costuma ser guiado. A pessoa escolhe o que quer ouvir e para onde quer ir. É possível navegar por itens, campos de formulários, títulos, listas e menus, além de revisar um texto palavra por palavra. Com o tempo, forma-se um “mapa mental” do conteúdo, construído pela sequência de informações ou pelo Braille.

Tudo isso deixa claro que acessibilidade digital não é um detalhe nem um gesto de boa vontade. Quando sites, aplicativos e sistemas são desenvolvidos com cuidado, a experiência com leitor de telas tende a ser fluida. Botões têm nomes claros, campos explicam o que pedem, mensagens de erro dizem o que aconteceu e como resolver, e as etapas para concluir uma tarefa ficam mais fáceis de entender.

Por outro lado, quando a acessibilidade não é considerada, a autonomia diminui. Aparecem botões sem identificação, informações que dependem apenas de cor ou de imagem, conteúdos que mudam sem aviso e formulários difíceis de preencher usando apenas o teclado. Esses problemas são comuns e ajudam a explicar por que tantas pessoas com deficiência visual ainda enfrentam obstáculos em tarefas como comprar pela internet, acessar serviços públicos, estudar ou trabalhar.

Diante disso, busca-se apresentar o que é um leitor de telas, explicar seu papel no cotidiano e destacar as diferenças mais importantes entre a navegação visual e a navegação não visual, especialmente na internet e em aplicativos modernos. Ao longo do texto, também serão apresentados exemplos de práticas que ajudam ou atrapalham a usabilidade, além de uma visão geral das ferramentas mais utilizadas e das suas principais funcionalidades.

Um pouco de história: do texto à interface com janelas

A história dos leitores de tela está ligada, desde o início, à busca por autonomia no estudo e no trabalho de pessoas cegas, especialmente em áreas como matemática e ciência de dados no final do século XX. Em 1984, na IBM, Jim Thatcher e Jesse Wright discutiram como a tecnologia estava ficando cada vez mais visual e como isso poderia aumentar a exclusão de pessoas cegas.

Um exemplo claro dessa mudança foi a transição dos cartões perfurados para terminais de vídeo, que alterou profundamente a forma de interação com os computadores.

O surgimento dessa tecnologia ganhou um marco importante em 1986, com o lançamento do IBM Screen Reader para MS-DOS. Era um software simples, mas muito relevante para a época. Ele captava o conteúdo textual exibido pelo computador e transformava esse texto em fala sintetizada, com controle feito pelo teclado.

Como os computadores eram usados principalmente em modo texto, essa conversão era mais direta. O que aparecia na tela era, em grande parte, uma representação textual estruturada, o que facilitava que o leitor de telas “acompanhasse” a informação apresentada.

Nos anos 1990, esse cenário começou a mudar rapidamente. Pesquisas e relatos da época passaram a descrever uma espécie de “crise de acessibilidade”, causada pela popularização das interfaces gráficas, como as do Windows e do Macintosh. Antes, no DOS e em outros sistemas baseados em texto, a informação era apresentada de forma linear e fácil de transformar em fala.

Com as interfaces gráficas, a interação passou a depender muito mais de janelas, botões, ícones e imagens, que nem sempre tinham uma descrição textual clara para ser interpretada por tecnologias assistivas. Para lidar com esse novo contexto, leitores de tela precisaram evoluir.

Programas como o JAWS, criado em 1989 pela Henter-Joyce, avançaram para reconhecer componentes da interface, como menus, janelas e elementos mais complexos. Aos poucos, esses leitores passaram a organizar e interpretar a interface de um jeito que pudesse ser entendido por áudio, auxiliando pessoas cegas e pessoas com baixa visão a compreender a lógica do sistema e a navegar com mais segurança.

No fim dos anos 1990, a consolidação da web trouxe uma nova onda de desafios. A internet ampliou o acesso à informação, mas também aumentou a dependência de conteúdos visuais e de páginas com estruturas variadas. Em 1997, o W3C lançou a Iniciativa de Acessibilidade na Web (WAI), reforçando a ideia de que a força da web está em ser acessível para todas as pessoas.

A partir dos anos 2000, leitores de tela de código aberto passaram a se popularizar. Um exemplo importante é o NVDA, lançado em 2006, que contribuiu para tornar essas ferramentas mais acessíveis, já que antes as opções principais eram pagas e tinham preços elevados.

A seguir, serão destacados os principais eventos que impulsionaram a acessibilidade para pessoas com deficiência visual, acompanhando as transformações tecnológicas e o uso crescente de computadores e internet pela sociedade.

Observação: em telas pequenas, deslize a tabela para o lado para visualizar todo o conteúdo.

Esses são alguns dos marcos na história dos leitores de tela, embora existam outros avanços relevantes. Ao longo das décadas, esses dispositivos evoluíram para se adaptar às novas tecnologias e às necessidades de acessibilidade.

Hoje, os leitores de tela são fundamentais para a inclusão digital de pessoas com deficiência visual, proporcionando acesso autônomo a conteúdos e serviços online. Eles continuam a evoluir, incorporando recursos para melhorar a descrição de imagens e a compreensão de contextos, o que amplia ainda mais as possibilidades de acesso e participação na sociedade digital.

Como o leitor de telas funciona por dentro

Um leitor de telas moderno faz muito mais do que “ler o que está escrito”. Ele precisa entender o que cada parte da tela significa e em que situação ela está. Por exemplo, ele precisa diferenciar um botão de um link, saber se uma caixa de seleção está marcada ou desmarcada, identificar qual campo está com foco e avisar quando algo muda na tela.

Depois disso, ele transforma essas informações em uma sequência que a pessoa pode acompanhar por áudio ou, em muitos casos, por uma linha Braille. O importante é saber que ele é muito mais complexo do que parece, e que a qualidade da experiência depende muito de como o conteúdo foi estruturado e marcado por quem o desenvolveu.

O caminho da informação: do código à acessibilidade

Quando uma pessoa abre um site ou um aplicativo, o navegador ou o programa organiza o conteúdo internamente. No caso da web, o HTML é transformado em uma estrutura chamada DOM, que é como um “mapa” do que existe na página.

zoom_in

Clique para ampliar

O DOM não é o formato ideal para tecnologias assistivas porque reúne muitos detalhes visuais e de formatação, o que pode tornar difícil a navegação por leitores de tela. Por isso, os navegadores costumam criar uma estrutura paralela chamada árvore de acessibilidade.

Nessa árvore, o conteúdo é apresentado de maneira simplificada, destacando apenas os elementos fundamentais para garantir uma compreensão e navegação mais fáceis. Por exemplo, um botão é identificado como tal, com seu nome e função, enquanto elementos decorativos ou de formatação podem ser ignorados.

zoom_in

Clique para ampliar

zoom_in

Clique para ampliar

A árvore de acessibilidade foca no conteúdo relevante, ignorando elementos decorativos ou sem função. Quando uma página usa marcações genéricas e não define papéis claros para títulos, botões, links ou imagens, o leitor de telas não consegue organizar a informação corretamente.

Para que o leitor de telas consiga apresentar um elemento corretamente, cada item dessa árvore de acessibilidade precisa ter informações básicas, como:

• Nome: como o elemento deve ser chamado. Pode ser o texto de um botão, o rótulo de um campo ou a descrição de uma imagem. Exemplos: um botão de envio pode ter o nome “Enviar”, um campo de busca pode ser “Pesquisar produtos” e uma imagem de um gato pode ser “Foto de um gato preto com olhos verdes e orelhas pontudas”.

• Função: identifica o tipo de elemento, como botão, link, caixa de seleção ou cabeçalho. Exemplos: um botão de envio tem a função “botão”, um campo de busca é um “campo de texto” e uma imagem corresponde à função “imagem”.

• Estado: em que condição ele está naquele momento. Exemplos: um botão pode estar “desabilitado” ou “habilitado”, uma caixa de seleção pode estar “marcada” ou “desmarcada”, e um menu pode estar “expandido” ou “recolhido”.

• Valor: informação variável quando faz sentido. Exemplos: um campo de formulário pode ter o valor “João Silva”, um controle de volume pode estar em “50%” e um indicador de progresso pode mostrar “75% concluído”.

APIs de acessibilidade: a ponte entre o sistema e o leitor de telas

O leitor de telas não fica “lendo o código” da página o tempo todo. Na maioria dos casos, ele conversa com o sistema operacional (Windows, macOS, Linux, Android, iOS) por meio de APIs de acessibilidade, que funcionam como uma ponte.

Na prática, os programas “avisam” coisas importantes, como qual botão está selecionado, qual campo está com foco, se uma opção está marcada, se um menu foi aberto ou se apareceu uma mensagem de erro. O leitor de telas consulta essas informações e transforma tudo em retorno para a pessoa, geralmente por voz e, em alguns casos, também por Braille.

Cada sistema operacional tem suas próprias tecnologias para essa comunicação. No Windows, por exemplo, essas soluções foram mudando e melhorando com o tempo. Ferramentas mais modernas, como o UI Automation (que é uma API de acessibilidade do Windows), ajudaram a tornar a troca de informações mais estável e mais completa, especialmente em programas e navegadores atuais.

No macOS também existe uma infraestrutura própria de acessibilidade, integrada ao sistema. No Linux, há um conjunto de tecnologias com o mesmo objetivo. Elas não são iguais entre si. Cada sistema tem suas particularidades e sua forma de expor informações para leitores de tela.

Isso tem um efeito direto no dia a dia. Quando uma interface é construída de um jeito correto, o navegador e o sistema conseguem explicar com clareza o que cada elemento é. Por exemplo, um botão de verdade é entendido como botão, com nome, estado e comportamento esperados.

Já quando a interface é montada com elementos genéricos e “simulações”, fica mais difícil para o leitor de telas entender o que aquilo realmente é. O resultado costuma ser uma experiência frágil, com informações incompletas, confusas ou até silenciosas em momentos importantes.

Por isso que em programação, componentes como botões, links e formulários devem ser construídos corretamente. Simulá-los apenas visualmente sem significado lógico prejudica a experiência de usuários de tecnologias assistivas, como leitores de tela.

Saída por voz e por Braille

Depois de entender a interface, o leitor de telas precisa transformar tudo em uma forma de retorno que a pessoa consiga acompanhar.

A forma mais comum é a síntese de voz, também chamada de TTS. Esses recursos evoluíram muito com o tempo. As vozes antigas eram mais robóticas e pouco naturais. Hoje, existem modelos bem mais fluentes, com melhor entonação e com opções de velocidade, tom e pronúncia.

Outra forma muito importante é a linha Braille, um dispositivo que permite ler o conteúdo pelo tato. Nela, pequenos pinos sobem e descem para formar os caracteres em Braille, e esses caracteres mudam conforme a pessoa navega.

zoom_in

Clique para ampliar

Esse recurso é especialmente útil quando é necessário alta precisão, como na programação, na revisão de textos, na leitura de símbolos e especificamente importante para a população surdocega.

Algumas linhas Braille usam células de 8 pontos, o que ajuda a representar letras maiúsculas, números e símbolos com mais flexibilidade, além de apoiar melhor conteúdos técnicos.

Quais leitores de tela existem para cada sistema operacional?

Existem vários leitores de tela para diferentes sistemas operacionais, cada um com suas próprias funções. Alguns são nativos do sistema e outros exigem download.

Abaixo está uma tabela com os principais leitores de tela organizados por sistema operacional:

Diferenças entre usar a tecnologia com visão e usar com leitor de telas

Para entender como uma pessoa com deficiência visual usa computador ou celular, é importante saber que a experiência costuma ser bem diferente da de uma pessoa que enxerga.

Em vez de depender do que está visível na tela, a navegação acontece principalmente por áudio e por uma organização lógica do conteúdo feita por sistemas operacionais, aplicativos e leitores de tela.

Uma forma simples de imaginar isso é pensar na tela como uma sala cheia de objetos.

Para quem enxerga, é como entrar nessa sala com as luzes acesas. Dá para ver tudo ao mesmo tempo: porta, janela, mesa, cadeira. A pessoa olha rapidamente para onde quer, percebe cores, tamanhos, posição dos itens e entende o conjunto da “paisagem” de uma vez. Se quiser interagir com algo, basta apontar e clicar com o mouse, ou tocar diretamente no ponto certo da tela.

Para quem usa leitor de telas, é como estar nessa sala no escuro com uma lanterna que ilumina apenas um objeto por vez. Para conhecer o ambiente, é preciso percorrer item por item, seguindo uma ordem.

O leitor de telas anuncia um elemento de cada vez, como se a pessoa estivesse “varrendo” a tela. Com base no que escuta, a pessoa vai montando um mapa mental de como a página ou o aplicativo está organizado.

Por isso, a estrutura do conteúdo faz muita diferença. Quando um site ou aplicativo está bem construído, o leitor de telas consegue dizer claramente o que cada coisa é, como “botão”, “título”, “campo de edição”, “lista com 5 itens”.

Isso orienta a navegação e dá segurança. Quando a estrutura é ruim, a experiência se parece com uma sala em que todos os objetos são caixas iguais e sem etiqueta. A pessoa até consegue explorar, mas fica mais demorado, confuso e com maior chance de erro.

A seguir está uma tabela com algumas das principais diferenças entre a experiência de navegação visual e a navegação com leitor de telas:

Essas diferenças mostram que a experiência de uso para pessoas com deficiência visual é única e depende muito da qualidade da estrutura do conteúdo e da forma como as informações são organizadas.

Por isso, é fundamental que pessoas desenvolvedoras de software e designers tenham em mente essas particularidades para criar interfaces mais acessíveis e inclusivas.

Uma camada adicional de complexidade

Cada sistema operacional transmite informações de acessibilidade de forma única, e cada leitor de telas as interpreta de modo distinto. É fundamental conhecer tanto o sistema quanto o leitor de telas, já que diferentes leitores podem modificar bastante a experiência de uso.

Três pessoas cegas usando Windows 11 com NVDA, Jaws ou Narrador terão experiências distintas, pois cada leitor de telas possui comandos e configurações específicas que afetam a apresentação das informações. Além das teclas comuns do sistema operacional e dos atalhos universais nos aplicativos, cada leitor de tela utiliza comandos específicos e métodos próprios para organizar a experiência, que podem variar conforme o software escolhido.

Pequenas alterações em comandos, na navegação ou na interpretação de elementos gráficos podem impactar consideravelmente o acesso e a compreensão de conteúdos digitais por indivíduos com deficiência visual. Dessa forma, é indispensável realizar testes e adaptar as aplicações para múltiplas plataformas e ferramentas, garantindo uma experiência digital eficiente e inclusiva.

Da mesma forma, no contexto dos dispositivos móveis, a utilização do Google Talkback em sistemas Android pode apresentar variações conforme a marca do smartphone utilizado pela pessoa.

Ao migrar de um sistema operacional para outro, como do Windows para o macOS ou do Android para o iOS, é necessário não só aprender as regras e características do novo sistema, mas também se adaptar a um novo leitor de telas.

Esse processo de adaptação também ocorre dentro de um mesmo sistema operacional: por exemplo, ao deixar de usar o NVDA no Windows para utilizar o Jaws, será preciso aprender desde o início como funciona esse novo leitor de telas.

Além disso, cada programa possui suas próprias combinações de teclas de atalho, como ao trocar do Word para o Google Docs ou do Microsoft Edge para o Google Chrome, entre outros.

O uso de recursos digitais torna-se ainda mais desafiador: além de ser necessário aprender a lidar com o sistema operacional e os aplicativos desejados, é essencial compreender profundamente o leitor de telas. Caso haja troca de leitor, será preciso reaprender tudo novamente.

Esse domínio é fundamental, pois, sem ele, a pessoa pode não saber se uma dificuldade de acesso a determinado conteúdo ocorre devido à falta de acessibilidade ou simplesmente por não ter experiência suficiente com o leitor de telas para conseguir encontrar esse conteúdo.

Qual o motivo de tanta complexidade?

A variação de experiência acontece porque acessibilidade digital funciona como uma espécie de “cadeia de tradução”. Primeiro, o aplicativo (um site, um programa, uma tela do celular) precisa “contar” para o sistema operacional o que existe ali: se algo é um botão, um campo de texto, um menu, um alerta, se está marcado ou desmarcado, se está desabilitado, qual é o nome daquele elemento e o que acontece quando a pessoa ativa.

Depois, o leitor de telas “ouve” essas informações e decide como transformar isso em fala, em braille e em formas de navegação. O ponto central é que não existe uma única tradução universal: cada sistema operacional tem seu próprio jeito de receber e organizar essas informações, e cada leitor de telas tem seu próprio jeito de interpretá-las e apresentá-las.

É como se cada sistema operacional falasse um idioma interno diferente, e cada leitor de telas fosse um intérprete com estilo próprio. Mesmo quando dois intérpretes recebem a mesma frase, um pode preferir explicar mais, outro pode ser mais direto; um pode repetir detalhes para garantir clareza, outro pode economizar palavras; um pode organizar a informação em uma ordem, outro em outra.

Isso não significa que um esteja “errado” e o outro “certo” o tempo todo, muitas vezes são escolhas diferentes, feitas para públicos diferentes e hábitos diferentes. No Windows, por exemplo, três pessoas usando NVDA, JAWS e Narrador podem estar consumindo a “mesma tela”, mas cada leitor de telas tem seu próprio conjunto de comandos, seus próprios modos de navegação e até sua própria forma de anunciar informações.

Um pode dizer “botão, menu, colapsado” com mais frequência; outro pode anunciar menos coisas para ficar mais rápido; um pode facilitar saltos específicos por tipo de elemento; outro pode destacar mais mensagens automáticas. Além disso, cada pessoa costuma personalizar o leitor: muda nível de pontuação falada, velocidade, eco de teclas, forma de anunciar links, avisos, e assim por diante. Só isso já muda bastante a vivência.

Também existe um fator que não aparece “de fora”, mas pesa muito: aplicativos e sites nem sempre descrevem a interface de um jeito claro e completo. Quando um elemento é construído de forma “improvisada” (por exemplo, algo que parece botão, mas não se comporta como botão), cada leitor de telas pode tentar “adivinhar” o que aquilo é para tentar comunicar para a pessoa usuária.

Só que cada leitor faz essas adaptações do seu próprio jeito. É aí que duas pessoas podem ter resultados diferentes: uma encontra, a outra não; uma ouve um aviso útil, a outra não ouve; uma consegue ativar um controle, a outra precisa de outro caminho.

Na Web, costuma existir mais “regras em comum”, porque há recomendações e boas práticas bem conhecidas para construir páginas de um jeito mais compreensível por várias tecnologias assistivas.

Mesmo assim, isso não vira uma experiência idêntica, porque ainda existe o navegador no meio (Chrome, Edge, Firefox, Safari) e o leitor de telas em cima disso. É muita gente “traduzindo” em sequência: a página, o navegador, o sistema operacional e o leitor. Se qualquer etapa fizer um trabalho diferente, o resultado muda.

Em dispositivos móveis, a variação pode ser ainda mais evidente. No Android, por exemplo, o TalkBack pode apresentar diferenças conforme a marca do aparelho, a versão do sistema e até mudanças feitas pela fabricante. Às vezes o caminho de configurações muda; às vezes certos gestos funcionam de outro jeito; às vezes recursos aparecem ou somem dependendo do modelo. Então duas pessoas dizendo “eu uso TalkBack” podem, na prática, estar usando experiências bem diferentes.

Além disso, cada programa tem seus próprios atalhos e sua própria organização interna. Trocar do Word para o Google Docs, ou do Edge para o Chrome, muda menus, comandos, comportamento de edição e até a forma como a interface “se movimenta”. Para uma pessoa com deficiência visual, isso pesa porque o uso eficiente depende de memória muscular (atalhos), previsibilidade e domínio de navegação. Qualquer mudança nessas peças exige adaptação.

Então, por que não existe uma padronização completa, do tipo “tudo funciona igual para todo mundo”? Porque, na prática, estamos falando de muitos mundos diferentes tentando conversar ao mesmo tempo. Sistemas operacionais foram criados por empresas diferentes, em épocas diferentes, com objetivos e tecnologias diferentes.

Leitores de telas também foram criados com filosofias diferentes: alguns priorizam rapidez, outros priorizam detalhamento; alguns são mais “guiados”, outros são mais “exploratórios”; alguns investem mais em personalização, outros buscam simplicidade. E, no mobile, ainda entra o fator de cada fabricante mexer no sistema.

Existe, sim, padronização, só que ela costuma padronizar mais o “mínimo necessário para funcionar” do que o “jeito exato de usar”. Em outras palavras: há esforços para que botões sejam botões, campos sejam campos, e as informações essenciais estejam presentes.

Mas ninguém consegue (e nem seria desejável) impor que todos os leitores de telas tenham os mesmos atalhos, falem com as mesmas palavras, na mesma ordem, com a mesma quantidade de detalhes. Isso tiraria liberdade de evolução, impediria que cada produto atendesse melhor certos perfis de uso e ignoraria que pessoas diferentes preferem estilos diferentes de leitura.

Por fim, esse é o motivo pelo qual sem dominar bem o leitor de telas, pode ficar difícil saber se um problema é falta de acessibilidade ou falta de familiaridade com o próprio leitor. Como a experiência depende tanto da ferramenta e das configurações, uma pessoa pode “não encontrar” algo que está lá, ou pode achar que algo é inacessível quando, na verdade, é acessível, mas exige um modo de navegação diferente.

Testar diferentes combinações de leitores, navegadores e dispositivos permite identificar se o problema está na interface ou no uso das ferramentas, aumentando as chances de proporcionar uma boa experiência para mais pessoas.

Algumas dicas para melhorar a experiência de uso das pessoas com deficiência visual

A acessibilidade digital é um campo complexo, mas existem algumas práticas que podem ajudar a melhorar a experiência de uso para pessoas com deficiência visual. A seguir estão algumas dicas importantes para tornar seus materiais digitais mais acessíveis.

Pense em estrutura e semântica ao invés de aparência

Os leitores de tela utilizam a estrutura do conteúdo, independentemente do aspecto visual, para interpretar informações. Quando a estrutura é insuficiente ou inadequada, os dados tornam-se difíceis de identificar e a navegação pode ser inviabilizada ou significativamente comprometida.

Use títulos de verdade

Em documentos, como os produzidos via Word, Google Docs ou LibreOffice, utilize os títulos nativos do programa, como “Título 1”, “Título 2”, etc ao invés de apenas aumentar o tamanho da fonte e colocar em negrito.

No Word, a própria Microsoft recomenda usar estilos de título para facilitar navegação por estrutura.

Use listas de verdade

Para criar listas, utilize os recursos nativos de formatação de lista (marcada ou numerada) em vez de usar símbolos manuais (como asteriscos, hífens ou números digitados).

Use um sumário automático

Em documentos longos, utilize a funcionalidade de sumário automático, que cria links para os títulos e facilita a navegação.

Quebra de página

Em documentos, não use um monte de Enter para criar espaço entre seções. Por exemplo: Você acabou de escrever um capítulo e quer começar o próximo em uma nova página. Em vez de apertar Enter várias vezes, use a função de quebra de página do programa.

No Word você consegue fazer essa quebra de página com o atalho Ctrl + Enter.

No Google Docs, vá em “Inserir” → “Quebra” → “Quebra de página”.

Não use caixas de texto para conteúdo importante

Evite usar caixas de texto (text boxes) para colocar informações essenciais, pois elas podem ser ignoradas por leitores de tela. Se precisar usar uma caixa de texto, certifique-se de que ela esteja corretamente rotulada e seja acessível.

No PowerPoint, por exemplo, existe o recurso de “placeholder” que é uma caixa de texto pré-formatada e acessível, ideal para títulos e conteúdo principal. Evite criar caixas de texto personalizadas que não sejam reconhecidas como parte do fluxo de leitura.

Use descrições alternativas para imagens e gráficos

De acordo com as diretrizes de acessibilidade do W3C e das WCAG, todas as imagens e gráficos devem ter descrições alternativas que transmitam a mesma informação que a imagem visualmente apresenta.

A seguir está uma imagem de exemplo, para a qual serão mostradas duas formas de descrição alternativa: uma correta e outra incorreta.

zoom_in

Clique para ampliar

Descrição alternativa incorreta: “foto123.png”, “imagem.png”, “ilustracao-xgpowyqtpom976544.png” e variações do tipo “foto de mulher” ou “mulher com bengala”.

Essas descrições não transmitem informações relevantes sobre a imagem, como características visuais, contexto ou elementos importantes. Elas não ajudam a pessoa com deficiência visual a entender o conteúdo da imagem e podem ser consideradas inúteis para fins de acessibilidade.

Descrição alternativa correta: “Mulher de pele preta, cabelos curtos e cacheados, sorrindo, de óculos escuros e blazer rosa, segurando uma bengala branca em uma área externa com prédios ao fundo.”

Essa descrição alternativa é detalhada e informativa, fornecendo uma representação clara da imagem para pessoas com deficiência visual. Ela inclui informações sobre a aparência da mulher, suas expressões faciais, o que ela está vestindo e o ambiente ao seu redor, permitindo que a pessoa compreenda o conteúdo visual de forma mais completa.

Claro que, o texto alternativo tem limites de tamanho de acordo com as próprias diretrizes de acessibilidade, e é importante encontrar um equilíbrio entre ser detalhado e ser conciso. O ideal é incluir as informações mais relevantes para transmitir o significado da imagem, sem se tornar excessivamente longo ou difícil de entender.

Quando a imagem for muito complexa, como um gráfico ou uma ilustração com muitos elementos, não é indicado apenas o texto alternativo, mas também uma descrição mais detalhada com o conteúdo completo da imagem.

Se for uma página web, essa descrição pode ser colocada em uma <figcaption>, que é um elemento HTML usado para fornecer uma legenda ou descrição para uma figura que acompanha a imagem e que será reconhecida por leitores de tela como parte do conteúdo da imagem. Também é possível adicionar a descrição em um parágrafo de texto abaixo da imagem, desde que esteja claro que se trata de uma descrição da imagem e seja acessível para leitores de tela.

Em documentos de texto, slides e outros materiais, a descrição pode ser colocada em um parágrafo próximo à imagem, com uma indicação clara de que se trata de uma descrição detalhada da imagem. Isso é muito importante em contexto onde existem gráficos, mapas, organogramas e outros elementos visuais complexos.

Observação: Em hipótese alguma use o campo de texto alternativo, seja no Word, no Google Docs, PowerPoint ou em qualquer outro programa, para colocar a URL (endereço da imagem) ou informações irrelevantes, pois o leitor de telas irá ler exatamente o que está escrito ali.

Não use cores como única forma de transmitir informação

As cores podem ser usadas para destacar informações, mas não devem ser a única forma de transmitir uma mensagem importante. Portanto, é fundamental usar outros elementos visuais, como texto, ícones ou padrões, para garantir que a informação seja acessível.

Observação: É muito comum em aulas, apresentações e afins frases como “os itens em vermelho são obrigatórios” ou “tudo que está em verde é o saldo positivo”. Essas formas de comunicação não são acessíveis, fatalmente pessoas impossibilitadas de perceber as cores não terão acesso a essas informações.

Tabelas: use-as para dados tabulares, não para layout

As tabelas devem ser usadas apenas para apresentar dados tabulares, ou seja, informações organizadas em linhas e colunas que fazem sentido como um conjunto. Elas não devem ser usadas para criar layouts ou organizar o conteúdo visualmente, pois isso pode confundir os leitores de tela e dificultar a navegação.

Se for necessário usar uma tabela para organizar dados, certifique-se de que ela esteja corretamente estruturada, com cabeçalhos de coluna e linha, e que seja acessível para leitores de tela. Evite usar tabelas para criar espaçamento ou para organizar elementos visuais, pois isso pode tornar a experiência de navegação confusa e frustrante para pessoas com deficiência visual.

Use links descritivos (não cole a URL inteira)

Ao invés de colocar a URL completa como texto do link, use uma descrição clara e informativa do destino do link.

Por exemplo, em vez de usar https://www.exemplo.com/artigo-sobre-acessibilidade, use Leia nosso artigo sobre acessibilidade.

Isso torna o link mais compreensível e fácil de navegar não somente para pessoas com deficiência visual, mas para todas as pessoas, pois fornece contexto sobre o que esperar ao clicar no link.

Evite inserir caixas de texto “soltas” no PowerPoint

No PowerPoint, evite usar caixas de texto (text boxes) para inserir informações importantes, pois elas podem ser ignoradas por leitores de tela. Em vez disso, utilize os placeholders pré-formatados para títulos e conteúdo principal, que são reconhecidos como parte do fluxo de leitura. Se for necessário usar uma caixa de texto personalizada, certifique-se de que ela esteja corretamente rotulada e seja acessível para leitores de tela.

Além disso, não se esqueça de marcar conteúdo decorativo como tal, para que o leitor de telas possa ignorá-lo. Por exemplo, se você usar uma caixa de texto apenas para criar um efeito visual, como um destaque ou um fundo colorido, certifique-se de marcar essa caixa como decorativa para que ela não seja lida pelo leitor de telas.

Verifique e ajuste a ordem de tabulação

A ordem de tabulação, ou ordem de leitura, é a sequência em que os elementos de uma página ou aplicativo são acessados quando a pessoa navega usando o teclado (geralmente com a tecla Tab). É fundamental garantir que essa ordem seja lógica e intuitiva para que as pessoas com deficiência visual possam navegar de forma eficiente.

Ajuste via painel/lista de seleção de elementos: Em muitos programas, como o Word, Google Docs, PowerPoint e outros, existe um painel ou lista de seleção de elementos que permite visualizar a estrutura do documento e ajustar a ordem de leitura. Certifique-se de que os elementos estejam organizados de forma lógica, seguindo a hierarquia e a sequência natural do conteúdo.

Dicas por formato de arquivo

Excel (planilhas)

Planilhas são muito usadas para organizar informações, acompanhar atividades e apresentar resultados. Para pessoas que usam leitores de tela, a clareza da estrutura (tabelas, cabeçalhos e nomes de abas) faz toda a diferença.

• Descreva imagens/gráficos com texto alternativo: Especialmente gráficos que transmitem informação. Se um gráfico for a principal forma de apresentar um resultado, considere também explicar os dados no próprio texto da planilha (por exemplo, em uma célula próxima) ou em um documento de apoio.

• Estruture tabelas de forma simples: Evite células mescladas, divididas, aninhamento e muitas células em branco. Células em branco em sequência podem “parecer fim da tabela” para quem escuta a leitura, fazendo a pessoa perder contexto.

• Defina cabeçalhos na tabela: Cabeçalhos permitem ao leitor de telas associar corretamente coluna/linha com os dados. Sem isso, a leitura pode virar uma sequência de valores sem significado claro.

• Evite múltiplas tabelas na mesma planilha: Quando possível, separe conteúdos diferentes em abas diferentes (ou até em arquivos diferentes) para reduzir confusão de contexto.

• Renomeie as abas e remova planilhas vazias: Nomes claros ajudam na navegação com leitor de telas, porque a pessoa consegue entender rapidamente onde está e o que cada aba contém.

• Mantenha bom contraste: Use combinações de fundo e texto que sejam legíveis.

• Não use cor como único significado: Se algo está “em vermelho porque é crítico”, inclua também texto/indicador (por exemplo: “Crítico”, “Atrasado”, “Fora do prazo”, etc.).

PDF

Um PDF pode ser acessível, mas isso depende de ele ter estrutura (tags/marcações). Na prática, “parecer certo visualmente” não garante que a leitura por leitor de telas será boa.

• PDF acessível precisa de estrutura (tags/marcações): O arquivo deve ter ordem lógica de leitura, texto real (não só imagem), descrições alternativas quando necessário, tabelas estruturadas e formulários acessíveis.

• Gere o PDF a partir de um documento Office já acessível: Se o Word/Docs/LibreOffice estiverem bem estruturados (títulos, listas, tabelas), a exportação tende a preservar a semântica.

• Ao salvar como PDF, habilite marcas estruturais para acessibilidade: Procure opções do tipo “tags para acessibilidade”, “marcas estruturais” ou “estrutura do documento”, para preservar hierarquia de títulos, ordem de leitura e outras informações importantes.

• Evite “imprimir para PDF” em ferramentas que perdem tags: Alguns geradores por “impressora PDF” não preservam marcações e geram um PDF sem estrutura (ou seja, mais difícil de navegar com leitor de telas).

• Para PDFs complexos, pode ser necessário editor especializado: Especialmente para ajustar ordem de leitura, títulos, tabelas e formulários.

Documento digitalizado (scanner)

Quando um documento é digitalizado, muitas vezes ele vira apenas uma imagem dentro de um PDF. Isso muda completamente a acessibilidade.

• PDF digitalizado é imagem — leitor de telas não lê: Se o conteúdo virou uma “foto”, não há texto real para o leitor de telas interpretar.

• Use OCR para converter imagem em texto: Depois do OCR, revise o resultado. O OCR costuma errar mais quando há baixa resolução, fundo com ruído, fonte pequena, fonte cursiva/itálica/decorada, ou quando o documento está torto e com sombras.

• Depois que virar texto, aplique as mesmas regras de acessibilidade: Estrutura de títulos, descrições alternativas quando necessário, tabelas corretas, links descritivos, contraste adequado e assim por diante.

Checklist

Se você quiser priorizar o que mais costuma impactar a experiência, este checklist é um bom ponto de partida:

• Títulos com estilos semânticos (não “na mão”): Use os recursos de Título 1, Título 2, etc., para permitir navegação por estrutura.

• Imagens sempre com descrição útil (e descrições longas no texto quando necessário): Texto alternativo deve explicar o que importa na imagem, não o nome do arquivo.

• Nada essencial em caixa de texto / cabeçalho / rodapé: Informações importantes precisam estar no fluxo principal de leitura.

• Tabelas sem mesclagem e com cabeçalhos definidos: Evite células mescladas e garanta que cabeçalhos estejam configurados.

• Documento longo com sumário linkável: Um sumário automático facilita muito a navegação.

• Ordem de leitura correta (especialmente em slides): Garanta que a tabulação e a sequência de leitura façam sentido.

• PDF com tags/estrutura (não “impresso” como imagem): Prefira exportar preservando marcações.

• Digitalizados sempre com OCR + revisão: Sem OCR, vira imagem e deixa de ser lido.

• Nunca depender só de cor/efeito visual para transmitir informação: Sempre inclua texto ou outro indicador além da cor.

Conclusão

Leitores de tela não “adivinham” o que está na tela. Eles dependem do que o sistema, o navegador e o próprio conteúdo conseguem expor com clareza: nome, função, estado, valor e, principalmente, uma estrutura lógica. Quando essa estrutura existe, a navegação fica rápida, previsível e eficiente. Quando não existe, a experiência vira tentativa e erro.

Por isso, acessibilidade digital não é um detalhe que se coloca no final. Ela começa na forma como você organiza títulos, listas, tabelas e links, e continua no cuidado com gráficos, imagens e com a ordem de leitura, especialmente em documentos e apresentações.

Se você quer um caminho prático: priorize semântica, evite “gambiarras visuais”, descreva o que é essencial e teste seus materiais com teclado e com leitor de telas. O objetivo não é “passar em uma checklist”, e sim garantir que a pessoa consiga entender o conteúdo e concluir tarefas com autonomia.

Quando a gente projeta pensando também em quem acessa por áudio e por Braille, o resultado costuma ser melhor para todo mundo: documentos mais organizados, informações mais claras e interfaces mais fáceis de usar.

zoom_in

Clique para ampliar

Apresentação

A percepção equivocada de que pessoas com deficiência enfrentam obstáculos intransponíveis continua presente em diversos setores da sociedade, inclusive no contexto educacional. Tal visão contribui para a insuficiência de materiais e metodologias pedagógicas adaptadas, o que torna o processo de inclusão mais complexo.

A falta de informação, o pouco contato diário com pessoas com deficiência e a carência de ações voltadas à conscientização ajudam a manter preconceitos. Diante disso, este estudo investiga os desafios e as estratégias para ensinar a tabela periódica dos elementos químicos a estudantes com deficiência visual, destacando a relevância de adaptações específicas que sejam viáveis e aplicáveis.

O uso de recursos digitais, como o desenvolvimento web é essencial para ampliar o acesso de pessoas com deficiência visual ao conhecimento científico. Por isso, foi criada uma tabela periódica inclusiva, compatível com linhas Braille e leitores de tela.

A metodologia empregada envolveu uma revisão bibliográfica detalhada, seguida pela confecção prática da tabela, que foi validada por especialistas com deficiência visual. A acessibilidade foi analisada por meio de testes feitos por profissionais com deficiência visual que atuam nas áreas de acessibilidade digital, desenvolvimento de software, psicologia, pedagogia e outros campos.

Pessoas cegas e com baixa visão participaram da avaliação usando tecnologias assistivas em diferentes dispositivos. Os resultados mostram que, com adaptações e uso adequado da tecnologia, é possível garantir uma experiência educacional inclusiva no estudo da tabela periódica.

Essa iniciativa não só amplia o acesso ao conhecimento científico, como também ajuda a romper barreiras históricas e incentiva a participação ativa de estudantes com deficiência visual nas escolas. Além disso, destaca-se a importância de investir continuamente na melhoria de materiais didáticos acessíveis.

Ao divulgar essa proposta, busca-se promover uma educação mais inclusiva e justa, na qual todas as pessoas tenham oportunidades plenas de aprendizado e desenvolvimento, contribuindo assim para uma transformação social duradoura.

Conceitos gerais

Historicamente, pessoas com deficiência foram frequentemente consideradas incapazes. Em diversos contextos, elas acabaram sendo responsabilizadas por sua própria exclusão social, fenômeno atualmente identificado como capacitismo.

"Esse preconceito é tão forte na sociedade que atinge até instituições e pessoas que, em teoria, deveriam defender os direitos de grupos minorizados e marginalizados."

Nessa conjuntura, as pessoas com deficiência frequentemente são percebidas como menos aptas a experienciar, aprender, expressar desejos e, especialmente, serem alvo de desejo.

"Assim, são muitas vezes impedidas de viver plenamente e de exercer seus direitos."

O capacitismo é estrutural e persistente na sociedade porque:

"[...] desde o momento em que uma criança nasce ela emerge em um mundo onde recebe mensagens de que ser uma pessoa com deficiência é ser inferior."

Pessoas com deficiência visual também integram esse contexto, principalmente porque:

"[...] a sociedade reconhece o que é extremamente visual, privilegiando a visualização como condição de conhecer, em um universo constituído por símbolos gráficos, imagens, letras e números."

A educação, ao representar os valores da sociedade contemporânea e contribuir para o desenvolvimento das próximas gerações, fundamenta-se de maneira significativa no uso de recursos visuais, como jogos, imagens e gráficos (REIS, 2015).

A Química é uma área do conhecimento altamente dependente da visão. Ela é:

"[...] a ciência responsável pelo estudo da matéria e de suas transformações."

Nesta área, o emprego de representações visuais é fundamental, viabilizando a comunicação eficiente de um elevado volume de informações em tempo reduzido. A disciplina de Química contempla atividades experimentais, práticas laboratoriais, bem como a manipulação de vidrarias e substâncias químicas.

"Por isso, cores, gráficos e equações químicas fazem parte de sua linguagem simbólica."

Apesar dos desafios da Química para pessoas com deficiência visual, o uso de novas tecnologias permite criar estratégias inclusivas.

Cabe às instituições de ensino, equipes pedagógicas, docentes e ao Serviço de Atendimento Educacional Especializado (SAEE) planejar e aplicar adaptações que garantam o acesso à aprendizagem (BRASIL, 1996).

Educação e deficiência visual: principais questões

Segundo Reis (2015, p. 28), a deficiência visual pode ser entendida como “um impedimento total ou, ainda, a diminuição da capacidade visual”. Essa condição pode resultar de diferentes causas que acometem os olhos ou o sistema visual como um todo. É importante ressaltar que, além da cegueira, a baixa visão também integra o espectro das deficiências visuais.

De acordo com Reis (2015, p. 28), a deficiência visual é avaliada a partir de duas medidas oftalmológicas: acuidade visual (capacidade de enxergar a uma determinada distância) e campo visual (área alcançada pela visão).

zoom_in

Clique para ampliar

A baixa visão caracteriza-se por uma manifestação heterogênea, podendo os indivíduos apresentar distintos perfis de funcionamento visual. Essa variação decorre da interação entre fatores como acuidade visual, amplitude do campo visual e a etiologia (causa ou origem) da deficiência.

Segundo o Ministério da Educação (BRASIL, 2005, p.16), considera-se pessoa com baixa visão quem possui “desde a condição de indicar a projeção da luz até o grau em que a redução da acuidade visual interfere ou limita seu desenvolvimento”.

O e-book “Acessibilidade Para Estudantes Com Deficiência Visual: Orientações Para O Ensino Superior” define:

"[...] a baixa visão corresponde a um comprometimento do funcionamento visual, em ambos os olhos, que não pode ser sanado, por exemplo, com o uso de óculos convencionais, lentes de contato ou cirurgias oftalmológicas."

Dessa forma, condições como miopia, que podem ser corrigidas com o uso de óculos, não são classificadas como deficiência visual, mas sim como problemas visuais, uma vez que podem ser substancialmente reduzidas ou eliminadas por meio de recursos ópticos.

Principais características da baixa visão

De acordo com Garrutti de Lourenço et al. (2020, p. 2), a baixa visão está relacionada a distintos tipos de limitações visuais, que podem manifestar-se de forma isolada ou simultânea. Destacam-se entre essas limitações:

• redução da nitidez visual (acuidade visual diminuída);

• restrição do campo visual, limitando a percepção ao espaço imediatamente à frente;

• alteração na discriminação de contraste, dificultando a identificação de objetos;

• dificuldade de adaptação à luminosidade, tanto em ambientes intensamente iluminados quanto pouco iluminados;

• modificação na percepção das cores;

• limitação na visualização de objetos próximos ou distantes;

• percepção restrita do entorno, observando apenas uma área delimitada conforme a condição apresentada.

Fonte: Elaborado pelas autoras com base em GARRUTTI DE LOURENÇO et al., 2020.

Alterações visuais que muitas vezes passam despercebidas exigem adaptações específicas para leitura, escrita e outras atividades diárias. A baixa visão requer intervenções adequadas, pois a principal barreira à inclusão é a falta de crença na importância dessas adaptações, segundo Garrutti de Lourenço et al. (2020, p. 2).

Dentre as principais causas de baixa visão, incluem-se:

• complicações oculares em prematuros (retinopatia da prematuridade);

• inflamações decorrentes de toxoplasmose (retinocoroidite macular por toxoplasmose);

• albinismo;

• catarata congênita;

• doenças retinianas (retinose pigmentar);

• comprometimento do nervo óptico (atrofia ótica);

• glaucoma;

• retinopatia diabética.

Fonte: Elaborado pelas autoras com base em GARRUTTI DE LOURENÇO et al., 2020.

É fundamental que profissionais da educação identifiquem as necessidades educacionais específicas de cada estudante com baixa visão, visando práticas pedagógicas inclusivas e personalizadas (GARRUTTI DE LOURENÇO et al., 2020, p. 2).

Diante disso, são frequentes na escola situações envolvendo estudantes com baixa visão, tais como:

• Dificuldade ao ler textos com fonte pequena ou baixo contraste;

• Cansaço visual que surge rapidamente ao realizar tarefas de leitura e escrita;

• Dificuldade em enxergar os conteúdos mostrados no quadro ou nos materiais didáticos tradicionais;

• É preciso mais tempo para terminar tarefas que exigem processamento visual;

• Dificuldade na participação em atividades realizadas sob iluminação intensa ou em superfícies refletoras;

• Necessidade dispositivos ópticos, iluminação apropriada e materiais acessíveis.

Fonte: Elaborado pelas autoras com base em GARRUTTI DE LOURENÇO et al., 2020, p. 3.

As necessidades de cada estudante com baixa visão devem ser avaliadas individualmente, pois as dificuldades variam entre as pessoas (GARRUTTI DE LOURENÇO et al., 2020, p. 3-4).

Cegueira

Apesar de algumas pessoas cegas apresentarem certa percepção luminosa, a compreensão do ambiente ocorre predominantemente por meio dos sentidos táctil e auditivo. Dessa forma, a cegueira abrange desde a completa ausência de visão até uma mínima detecção de luz, demandando abordagens educacionais que valorizem métodos alternativos baseados no tato e na audição.

A disponibilização de materiais didáticos variados é igualmente essencial, pois proporciona diferentes possibilidades de aprendizagem aos estudantes cegos. Dentre as estratégias indicadas para promover a inclusão escolar de alunos com cegueira, ressaltam-se:

• Uso de materiais em Braille para facilitar a leitura e escrita;

• Oferta de recursos táteis, como mapas e gráficos em alto-relevo;

• Implementação de softwares leitores de tela para acesso aos conteúdos digitais;

• Adaptação das atividades para que possam ser realizadas por meio do tato e da audição;

• Formação dos professores acerca das necessidades educacionais específicas desses alunos.

Fonte: Elaborado pelas autoras com base em BRASIL, 2005; SIAULIYS; ORMELEZI; BRIANT, 2010.

É imprescindível que os ambientes educacionais promovam a efetivação dos direitos constitucionais e legais das pessoas com deficiência, concretizando as garantias previstas em lei. A adoção de medidas de acessibilidade física e digital, assim como a integração entre docentes, familiares e especialistas, constitui obrigação legal destinada a garantir o desenvolvimento acadêmico e social desses estudantes, conforme estabelecem a Constituição Federal e a Lei nº 13.146/2015 (BRASIL, 2015), bem como demais legislações aplicáveis à inclusão.

A Química

A Química, originada há muito tempo, firmou-se progressivamente como uma ciência moderna, especialmente nos séculos XVI e XVII, período em que surgiram modelos conceituais semelhantes aos atuais. Durante seu desenvolvimento, a disciplina ultrapassou métodos apenas quantitativos e passou a utilizar imagens, símbolos próprios e códigos de cores, tornando mais fácil entender os fenômenos naturais.

A introdução dessa disciplina nos currículos franceses do século XIX ocorreu devido ao destaque das ciências naturais nas reformas educacionais republicanas e ao método da “lição de coisas”, que favorecia o aprendizado prático com objetos.

O ensino de Química hoje inclui cálculos estequiométricos, observação sistemática, notação de fórmulas moleculares e uso de códigos cromáticos para facilitar a compreensão (KAHN, 2014; SCHWAHN; OAIGEN, 2009, 2008; SCHWAHN; ANDRADE NETO, 2011).

Razuck e Guimarães (2014, p. 3) reforçam a importância dessa abordagem visual afirmando que a Química:

"[...] se utiliza de grande apelo visual, pois muitos de seus conceitos se baseiam na visualização de esquemas para sua compreensão."

De acordo com os autores, o aprendizado em Química está intimamente ligado à utilização de imagens, ilustrações, diagramas ou modelos, pois esses recursos facilitam a compreensão dos conceitos. Eles ainda acrescentam que:

"[...] a utilização de imagens, como ferramenta, na compreensão de conceitos é verificada, por exemplo, no ensino de Modelos Atômicos, no qual cada modelo se associa a uma representação imagística."

O aspecto visual é fundamental na Química e constitui parte integrante de sua essência, visto que a disciplina consolidou, ao longo do tempo, uma linguagem específica composta por símbolos, fórmulas e representações gráficas. Entre os exemplos desse contexto destacam-se a tabela periódica, os modelos moleculares e as estruturas de Lewis, ferramentas que contribuem significativamente tanto para o processo de ensino quanto para a compreensão dos conteúdos químicos.

Segundo Almeida (2015) e Feltre (2004), compreender Química requer explicações teóricas e demonstrações práticas e visuais.

Assim, Química é definida como:

"[...] uma ciência que possui uma linguagem própria proveniente do aspecto representacional da ciência como o uso de fórmulas e reações."

A especificidade dos objetos de estudo da Química atribui à disciplina uma natureza peculiar, exigindo a integração de fundamentação teórica com atividades práticas e recursos visuais (FELTRE, 2004). Dessa forma, a padronização de equações, fórmulas, gráficos e textos é essencial, visto que a escolha das formas de representação interfere diretamente na clareza do conteúdo e pode influenciar os resultados obtidos (ALMEIDA, 2015).

A Química desenvolveu uma linguagem própria composta por símbolos, fórmulas, imagens e práticas. Entender Química exige interpretar e usar essa linguagem para estudar os fenômenos naturais.

Tabela periódica

Tolentino e Rocha-Filho (1997, p. 1) afirmam que:

"[...] A classificação periódica dos elementos é, sem dúvida, uma das maiores e mais valiosas generalizações científicas. Concretizada na segunda metade da década de 60 do século 19, desde então muito serviu como guia de pesquisas em Química e, aos poucos, se tornou um valioso instrumento didático no ensino da Química."

A tabela periódica organiza os elementos químicos por número atômico, destacando padrões nas propriedades devido à configuração eletrônica dos átomos.

As linhas horizontais da tabela periódica, denominadas períodos, localizam à esquerda os metais e à direita os não metais. As colunas verticais, conhecidas como grupos, reúnem elementos com propriedades específicas, exemplificados pelo grupo 1, que corresponde aos metais alcalinos (FELTRE, 2004).

Elementos de um mesmo grupo tendem a apresentar semelhanças marcantes, geralmente mais evidentes do que aquelas verificadas entre elementos de um mesmo período. Contudo, algumas exceções ocorrem, sendo as similaridades entre lantanídeos e actinídeos dentro de um mesmo período um exemplo relevante (FELTRE, 2004).

De acordo com a lei periódica de Moseley, as propriedades físicas e químicas dos elementos mudam periodicamente conforme seus números atômicos aumentam. Essas mudanças, chamadas de propriedades periódicas, aparecem ao longo da tabela periódica, como é o caso do raio atômico, da eletronegatividade e da eletropositividade (FELTRE, 2004).

A classificação em blocos na tabela periódica reflete a distribuição dos elétrons nos átomos.

• O bloco s inclui elementos como hidrogênio, hélio e metais alcalinos;

• O bloco p reúne elementos diversos, incluindo metaloides;

• O bloco d corresponde aos metais de transição;

• O bloco f agrupa lantanídeos e actinídeos.

A repetição de certos padrões, chamada periodicidade, é a base para criar a lei periódica e a tabela periódica. Isso significa que elementos em posições parecidas mostram características semelhantes, como o tamanho dos átomos, a facilidade para ganhar ou perder elétrons e a energia necessária para retirar um elétron.

Essa regularidade acontece por causa da configuração eletrônica única de cada elemento, o que define suas propriedades químicas e modos típicos de agir.

Propriedades da tabela periódica

Propriedades químicas seguem padrões na tabela periódica, facilitando comparações. Energia de ionização indica quão difícil é perder um elétron; afinidade eletrônica mostra a energia liberada ao receber um elétron. Ambos variam de forma previsível entre os elementos.

O raio atômico, que indica o tamanho do átomo, varia sistematicamente de acordo com a posição do elemento na tabela periódica.

zoom_in

Clique para ampliar

Além dessas características, observa-se uma diferença clara entre os grupos de elementos: os metais, que ficam majoritariamente à esquerda da tabela, apresentam-se geralmente sólidos em temperatura ambiente, conduzem bem calor e eletricidade, além de serem maleáveis e dúcteis; por outro lado, os não metais estão principalmente à direita da tabela, podendo ser encontrados nos estados sólido, líquido ou gasoso, e não são bons condutores de calor e eletricidade.

Mais do que apenas uma lista de símbolos, a tabela periódica é organizada de forma a revelar padrões, similaridades e distinções entre os elementos, o que torna mais fácil entender suas propriedades químicas e como eles se comportam.

Tecnologias assistivas no ensino de Química

Conforme estabelece a Lei nº 13.146, de 6 de julho de 2015, conhecida como Lei Brasileira de Inclusão da Pessoa com Deficiência (BRASIL, 2015), o Art. 3º, inciso III, define tecnologias assistivas nos seguintes termos:

"[...] produtos, equipamentos, dispositivos, recursos, metodologias, estratégias, práticas e serviços que objetivem promover a funcionalidade, relacionada à atividade e à participação da pessoa com deficiência ou com mobilidade reduzida, visando à sua autonomia, independência, qualidade de vida e inclusão social."

Tecnologias assistivas são ferramentas que possibilitam a participação de pessoas com deficiência, promovendo inclusão e autonomia. No ensino de Química, garantem acesso igualitário ao conteúdo para alunos com deficiência visual.

O uso dessas ferramentas se torna ainda mais eficaz quando está em sintonia com o conceito de desenho universal, que, segundo o artigo 3º, inciso III, da Lei Brasileira de Inclusão (Lei nº 13.146/2015), é definido como:

"[...] concepção de produtos, ambientes, programas e serviços a serem usados por todas as pessoas, sem necessidade de adaptação ou de projeto específico, incluindo os recursos de tecnologia assistiva."

Esse conceito defende que produtos e ambientes sejam criados desde o início para atender a todos, sem depender de adaptações posteriores, considerando diversas características físicas, sensoriais e cognitivas.

As tecnologias assistivas variam em complexidade. As chamadas low-tech (tecnologias de baixa complexidade) incluem opções simples, como:

• planos inclinados para leitura;
• lápis de ponta grossa;
• marcadores de página em Braille;
• materiais táteis confeccionados artesanalmente.

Por outro lado, as high-tech (tecnologias de alta complexidade) abrangem equipamentos e materiais industriais, como por exemplo:

• softwares leitores de tela;
• impressoras Braille;
• lupas eletrônicas;
• dispositivos de ampliação de tela.

Essas tecnologias podem ser organizadas em categorias específicas, que abrangem desde tarefas diárias até lazer. Exemplos são:

• Auxílios para a vida diária e prática: engrossadores de lápis, cadernos com pauta grossa, utensílios de cozinha adaptados.
• Comunicação alternativa (CAA): pranchas de comunicação, vocalizadores de fala, intérpretes virtuais de Libras.
• Acessibilidade ao computador: teclados adaptados, leitores de tela, softwares de comando de voz.
• Controle de ambiente: sistemas de iluminação controlados por voz, torneiras com sensor, assistentes virtuais como Alexa e Google Home.
• Projetos arquitetônicos acessíveis: rampas, pisos táteis, banheiros acessíveis.
• Órteses e próteses: próteses de membros, aparelhos ortopédicos, posicionadores posturais.
• Adequação postural: almofadas especiais, planos inclinados, encostos anatômicos.
• Auxílios de mobilidade: cadeiras de rodas, bengalas, andadores.
• Recursos para baixa visão e cegueira: lupas, ampliadores, Braille, relógios falantes.
• Recursos para surdez: legendas, sistemas de alerta vibratório em celulares, sinais visuais de alerta.
• Mobilidade veicular: automóveis adaptados, elevadores em ônibus.
• Esporte e lazer: bolas com guizo, dominó em alto relevo, baralhos em Braille.

Categorias da Tecnologia Assistiva (BERSCH, 2013).

Os exemplos mostram como as tecnologias assistivas são amplas e versáteis, capazes de transformar práticas educativas, especialmente nas aulas de Química. Além disso, essas ferramentas promovem inclusão e garantem que estudantes com deficiência tenham acesso efetivo em diferentes áreas do conhecimento.

Internet e desenvolvimento Web como tecnologias assistivas

A internet é uma rede mundial de computadores que permite a troca de informações entre usuários em qualquer lugar. Já a web consiste em páginas conectadas, acessadas por navegadores como Google Chrome, Firefox ou Safari.

O desenvolvimento web envolve planejar, criar e manter recursos online, utilizando linguagens e tecnologias específicas para assegurar a funcionalidade e a boa experiência em sites e aplicações (OLIVEIRA, 2021).

Esta área é organizada em dois domínios fundamentais:

• Front-end: refere-se à parte visual e interativa do site ou aplicação, com a qual as pessoas interagem diretamente. São os botões, menus, textos, mídias e outros elementos que compõem a interface do usuário.

• Back-end: é a parte que funciona nos bastidores, responsável por processar dados, gerenciar servidores e bancos de dados. O back-end lida com a lógica do sistema, as regras de negócio, autenticação de usuários, armazenamento de informações e comunicação com o front-end.

Conteúdos na internet podem ser acessíveis desde o início usando tecnologias apropriadas, tornando a web uma ferramenta assistiva graças à sua versatilidade.

Um site ou aplicativo vai além de uma imagem estática, composto por camadas de informação que se complementam para atender a diferentes necessidades. Por exemplo, um gráfico pode não ser acessível para pessoas cegas, mas um código bem estruturado pode detalhar cada ponto do gráfico, tornando-o compatível com leitores de tela.

Essa abordagem está em consonância com o conceito de Desenho Universal, cujo objetivo é criar produtos e ambientes acessíveis para todos, independentemente das necessidades individuais. O desenvolvimento da Internet e de aplicações Web com foco em acessibilidade contribui para a eliminação de barreiras educacionais, assegurando que o conteúdo esteja disponível para todas as pessoas.

Para isso, é essencial seguir as diretrizes de acessibilidade, como o WCAG (Web Content Accessibility Guidelines). O WCAG é um conjunto de recomendações internacionais que orienta a criação de conteúdos Web acessíveis para pessoas com deficiência.

Quando um site segue essas diretrizes, ele se torna compatível com tecnologias assistivas, como leitores de tela e linhas Braille. A inclusão, nesse sentido, não é um recurso extra, mas parte do processo de criação.

A internet e o desenvolvimento web tornam-se acessíveis ao aplicar práticas de codificação e design que garantem a leitura visual e semântica das informações. Assim, o conteúdo é logicamente estruturado para facilitar a interpretação por tecnologias assistivas que vão interfacear a comunicação entre a pessoa e o conteúdo digital.

Entre essas práticas, destacam-se os aspectos apresentados a seguir.

HTML Semântico

Trata-se do uso de elementos de código que deixam clara a função estrutural de cada parte da página.

Ao invés de usar apenas elementos genéricos, como <div> e <span>, o HTML semântico emprega tags (etiquetas) específicas, como:

• <header> para o cabeçalho,
• <nav> para a navegação,
• <article> para artigos,
• <section> para seções,
• <footer> para o rodapé,
• <ul> para listas não ordenadas,
• <ol> para listas ordenadas,
• <li> para itens de lista,
• E assim por diante.

Essas tags definem de forma explícita a função de cada seção do conteúdo, contribuindo para uma melhor compreensão da estrutura da página.

Em vez de a pessoa desenvolvedora criar tudo de maneira genérica e apenas alterar a aparência visual, desde o início são sugeridos elementos estruturais que facilitam a compreensão da natureza do conteúdo.

Os softwares leitores de tela reconhecem as marcações semânticas e informam as pessoas usuárias sobre como o conteúdo está organizado hierarquicamente, tornando a navegação e a compreensão do contexto mais fáceis.

zoom_in

Clique para ampliar

Descrição detalhada da imagem: A imagem é um infográfico em fundo preto, com o título grande no topo “HTML Semântico: Clareza Estrutural e Acessibilidade”, comparando duas formas de estruturar páginas.

À esquerda, a seção “Genérico (Ruim)” traz o subtítulo “Tudo igual, difícil de entender” e mostra um bloco cinza com várias caixas com tags de “<div>” e algumas “<span>”, ilustrando uma estrutura confusa. Uma seta azul liga esse bloco a um monitor com interrogações (“???”), indicando falta de clareza na organização do conteúdo.

O centro mostra um ícone de pessoa com notebook e a legenda “Estrutura desde o início”, ligado por linhas coloridas ao texto “Acessibilidade e compreensão”, destacando que uma estrutura adequada facilita o uso por pessoas com tecnologias assistivas como leitores de tela.

No lado direito encontra-se a seção “Semântico (Bom)”, com o subtítulo “Função explícita, fácil de entender”. Ali é apresentado um wireframe (esboço) azul de uma página, cujas áreas são claramente identificadas:

• no topo está o “<header>” tag para o cabeçalho da página,
• seguido por “<nav>”; para a barra de navegação (menu),
• o conteúdo principal aparece dividido em blocos verdes, com “<article>” (artigo) à esquerda, “<section>” (seção) ao centro e outra “<section>” (seção) à direita, que exibe exemplos de listas com “<ul>” (lista não ordenada), “<ol>” (lista ordenada) e “<li>” (item de lista).
• Na base da página encontra-se o “<footer>” (rodapé) da página.

Abaixo desse esquema visual, outro monitor apresenta um ícone de alto-falante e balões rotulados indicam os elementos facilmente reconhecíveis, como “Navegação”, “Cabeçalho”, “Artigo”, “Rodapé” e “Lista”.

Uma seta curva verde aponta para o layout semântico (página estruturada com as tags que indicam a função de cada elemento), acompanhada da frase “Organização hierárquica clara para todos, incluindo leitores de tela”, destacando que essa maneira de construir páginas facilita a compreensão para todas as pessoas incluindo aquelas que utilizam tecnologias assistivas como leitores de tela.

Resumindo: a imagem compara duas formas de estruturar páginas web, mostrando que o HTML semântico, com tags específicas, oferece clareza e acessibilidade, enquanto o HTML genérico dificulta a compreensão do conteúdo e trata tudo de forma igual.

Fim da descrição detalhada da imagem.

Texto Alternativo em Imagens (Alt Text)

O texto alternativo é uma descrição textual associada a imagens, inserida pelo atributo alt (texto alternativo) na tag <img> (que serve para inserir imagens) do HTML. Ele permite que pessoas cegas, usando leitores de tela, compreendam o conteúdo visual das imagens.

No ensino de Química, usar representações gráficas com textos alternativos detalhando a composição molecular é recomendado. Por exemplo:

zoom_in

Clique para ampliar

A imagem é inserida assim no código HTML:

<figure class="custom-figure text-center my-5">
    <div class="figure-container position-relative d-inline-block">
        <div class="image-wrapper position-relative overflow-hidden shadow-lg">

            <img class="img-fluid"
                 src="endereco-da-imagem"
                  alt="Estrutura molecular do benzeno (C6H6)."
                  loading="lazy"
                   />

            <div class="image-overlay position-absolute top-0 start-0 w-100 h-100 d-flex align-items-center justify-content-center"
                 aria-hidden="true">
                <div class="text-center">
                    <i class="material-icons text-white fs-1 mb-3 zoom-icon" aria-hidden="true">zoom_in</i>
                    <p class="text-white small mb-0 zoom-text">Clique para ampliar</p>
                </div>
            </div>
        </div>

        <div class="figure-decoration position-absolute bottom-0 start-50 translate-middle-x"
             aria-hidden="true">
            <div class="bg-primary rounded-pill shadow-sm accent-bar"></div>
        </div>
    </div>

    
</figure>

<figcaption>Descrição detalhada da imagem: A imagem mostra um desenho simples, em preto e branco, de uma molécula em forma de anel: seis letras “C” (carbono) formam um hexágono, como se fosse uma “argola” com seis lados. Entre esses carbonos aparecem linhas alternadas (algumas duplas e outras simples), indicando as ligações entre eles. Em volta do anel, há seis letras “H” (hidrogênio), uma ligada a cada carbono, apontando para fora do hexágono. É o tipo de esquema usado em química para mostrar a estrutura de uma molécula, com tudo bem centralizado em um fundo branco.</figcaption>

O atributo alt deve ser resumido, claro e descritivo, transmitindo a informação essencial da imagem. Para desenhos complexos, como gráficos ou diagramas, é recomendável fornecer uma descrição mais detalhada em um texto complementar próximo à imagem como é feito com a tag <figcaption> que serve para legendar figuras.

Compatibilidade com Leitores de Telas

Leitores de tela convertem conteúdo visual em áudio ou tato via dispositivos Braille. Sites e aplicativos devem garantir a interação eficiente desses softwares com todos os componentes da interface, incluindo botões, hiperlinks e menus de navegação.

A falta de compatibilidade dificulta o acesso à informação para pessoas com deficiência visual, tornando recursos digitais obstáculos à inclusão. Para assegurar essa compatibilidade, é essencial seguir as diretrizes de acessibilidade, como o WCAG, e testar regularmente os recursos com leitores de tela populares, como NVDA, JAWS e VoiceOver.

Design de Alto Contraste e Tamanho de Fonte Ajustável:

Para pessoas com baixa visão, a inclusão de recursos que possibilitam a personalização do contraste de cores e do tamanho da tipografia é fundamental para garantir a acessibilidade. O desenvolvimento web atual adota funcionalidades que permitem ajustar esses parâmetros visuais, conferindo a pessoa autonomia para adaptar a apresentação do conteúdo às suas necessidades perceptivas particulares.

WAI-ARIA (Accessible Rich Internet Applications)

WAI-ARIA (Accessible Rich Internet Applications ou em Português, Aplicações Ricas de Internet Acessíveis) é uma especificação técnica do W3C (World Wide Web Consortium - um consórcio internacional que desenvolve padrões para a web) que adiciona atributos ao HTML para melhorar a acessibilidade de aplicações web dinâmicas. Esses atributos fornecem metadados sobre função, estado e propriedades dos elementos, facilitando a interpretação por tecnologias assistivas.

Esta especificação é importante para implementar interfaces complexas, como abas, menus expansíveis e modais, onde a semântica estrutural do HTML pode não ser suficiente para descrever o comportamento e as relações dos elementos interativos.

Exemplos de atributos WAI-ARIA incluem:

• aria-label: fornece uma etiqueta descritiva para elementos interativos como botões ou links. Por exemplo, uma sequência de botões que só contém ícones pode usar aria-label para descrever a função de cada botão.

• aria-hidden: indica se um elemento deve ser ignorado por tecnologias assistivas. Isso é útil para ocultar elementos decorativos que não contribuem para a compreensão do conteúdo.

• role: define o papel de um elemento na interface que pode não ser evidente apenas pela tag HTML. Por exemplo, um <section> (seção) pode ser designado como um role=”dialog” para indicar que é uma janela modal interativa.

Acessibilidade no Código

A acessibilidade no código envolve a aplicação de boas práticas de desenvolvimento web para garantir que todas as pessoas, independentemente de suas habilidades, possam acessar e interagir com o conteúdo digital. Isso inclui o uso de HTML semântico, atributos WAI-ARIA, textos alternativos para imagens, navegação por teclado, entre outros.

Além disso, conteúdos suplementares, como tooltips ou submenus, não devem ser ativados exclusivamente através do foco por mouse (mouse over) ou teclado (focus), mas sim por ambos os métodos, garantindo que todas as pessoas possam acessar essas informações.

É fundamental também que a funcionalidade seja independente da orientação da tela, garantindo sempre múltiplas alternativas de acesso ao conteúdo. Mensagens relevantes para a pessoa, como confirmações de ações executadas ou notificações sobre o andamento de processos, devem ser comunicadas sem ocasionar alterações no contexto ou foco da interface.

Existem outras diretrizes que falam sobre toda funcionalidade baseada em arrastar e soltar ter alternativa por clique, toque, teclado ou comando de voz, entre outras recomendações. São muitas boas práticas que devem ser adotadas para garantir a acessibilidade no código.

O ideial é que equipes de desenvolvimento de software estejam sempre atualizadas sobre as melhores práticas e diretrizes de acessibilidade, como as do WCAG, para criar experiências digitais inclusivas. É sempre melhor um projeto nascer acessível do que tentar adaptar algo que já existe sem boas práticas de acessibilidade.

Desenvolvimento de uma Tabela Periódica Acessível

Considerando os desafios já destacados, criou-se uma tabela periódica focada na acessibilidade. Esse recurso foi desenvolvido seguindo princípios fundamentais para assegurar que qualquer pessoa, inclusive aquelas com diferentes condições visuais, possa acessar e utilizar a tabela com facilidade.

Os critérios de acessibilidade estabelecidos são:

• Compatibilidade com leitores de tela: A tabela foi estruturada para que pessoas que utilizam leitores de tela consigam acessar, entender e interagir facilmente com todas as informações fornecidas.

• Adaptabilidade: O design responsivo assegura que a tabela seja exibida corretamente em uma ampla variedade de dispositivos, incluindo smartphones, tablets e computadores. Dessa forma, o conteúdo permanece consistente e acessível independentemente do tamanho do texto ou das necessidades visuais da pessoa, viabilizando a navegação tanto nos modos retrato (vertical) quanto paisagem (horizontal), sem apresentar distorções.

• Independência das cores: As relações químicas são indicadas por sinais e descrições além das cores, facilitando a compreensão inclusive para quem tem deficiência de percepção cromática ou não enxerga.

• Alto contraste: Há opções com cores muito destacadas, como letras brancas em fundo preto e diferentes tons de cinza, facilitando a leitura para pessoas com baixa visão.

• Ajuste de tamanho do texto: O tamanho da fonte pode ser alterado conforme a necessidade, garantindo a manutenção da integridade e clareza das informações apresentadas.

• Integração com VLibras: Um botão exclusivo para VLibras (sistema de tradução automática para a Língua Brasileira de Sinais) permite converter textos para Libras, promovendo maior acessibilidade para pessoas surdas.

A Tabela Periódica Acessível busca garantir precisão semântica, preservando o significado original do conteúdo. Materiais fidedignos (fiéis) não apresentam alterações ou distorções em seu sentido.

É importante destacar que a interação entre tecnologias assistivas e conteúdo sem acessibilidade pode comprometer a transmissão eficiente de informações, impactando de forma significativa as áreas de ciências exatas e tecnológicas. Dessa forma, o desenvolvimento de recursos acessíveis torna-se fundamental para assegurar o acesso equitativo ao conhecimento científico por todas as pessoas.

A interpretação da tabela periódica pode ser bastante desafiadora para pessoas cegas ou com baixa visão, mesmo quando fazem uso de leitores de tela. A presença de símbolos, números e agrupamentos torna a compreensão auditiva difícil, principalmente se as descrições não forem bem-organizadas.

A maioria das soluções online ignora práticas de acessibilidade e dificulta o aprendizado de pessoas cegas, com daltonismo, dislexia ou baixa visão. Assim, criar uma tabela periódica acessível é fundamental para incluir todos os estudantes no estudo da Química.

Adicionalmente a solução foi desenvolvida para funcionar eficientemente mesmo com internet limitada e em dispositivos de baixo desempenho, priorizando o baixo uso de recursos e dados. O objetivo é facilitar o acesso à tabela periódica em regiões com infraestrutura tecnológica restrita, permitindo que mais pessoas consultem o recurso sem barreiras técnicas.

Metodologia

A criação da Tabela Periódica Acessível envolveu um processo iterativo de descoberta, prototipagem, testes, ajustes e otimizações, guiado por quatro objetivos principais:

• Compatibilidade com Tecnologias Assistivas: Assegurar que a ferramenta ofereça total funcionalidade para leitores de tela, linhas Braille e lupas eletrônicas, utilizando HTML semântico, recursos WAI-ARIA e gerenciamento apropriado de foco.

• Responsividade e Baixo Custo Cognitivo: Proporcionar uma experiência de uso eficiente em qualquer dispositivo, assegurando navegação intuitiva, áreas de toque adequadas e um layout responsivo que preserva a organização das informações.

• Configuração Visual: Oferecer as pessoas a possibilidade de modificar aspectos visuais da ferramenta, como contraste ou tamanho da fonte, conforme suas preferências, que podem ser armazenadas para uso futuro.

• Garantir a precisão semântica do conteúdo: Transmitir corretamente todas as informações e relações químicas, incluindo períodos, grupos e categorias, sem confiar apenas em elementos visuais como cores ou organização espacial.

Todas as decisões técnicas e de design seguiram quatro princípios fundamentais.

1. Independência de Modalidade Sensorial

As cores são usadas apenas para reforço visual e nunca como única fonte de informação. Cada categoria química é identificada por:

• Texto claro no rótulo

• Agrupamento em seções com cabeçalhos

• Atributos ARIA

• Detalhes nas janelas modais

Assim, qualquer pessoa, independentemente de sua capacidade visual, pode compreender as relações entre os elementos químicos.

2. Compatibilidade com Tecnologias Assistivas

Todos os componentes interativos estão devidamente configurados com atributos WAI-ARIA apropriados:

• role: determina o papel semântico do elemento (caixa de diálogo, botão, navegação, etc.);

• aria-label ou aria-labelledby: atribui rótulos acessíveis a elementos interativos;

• aria-pressed: sinaliza o estado (pressionado ou não) de botões do tipo alternância (toggle);

• aria-expanded: informa se um componente expansível está aberto ou fechado (como menus ou acordeões);

• aria-hidden: oculta elementos estritamente decorativos dos leitores de tela ou linhas Braille;

• aria-live: anuncia alterações dinâmicas no conteúdo sem interromper o foco atual como mensagens de confirmação ou erros.

O foco é gerenciado programaticamente para garantir que, ao abrir janelas modais, ele seja imediatamente direcionado ao primeiro elemento interativo. Ao fechar a janela, o foco retorna exatamente ao botão ativador, assegurando a continuidade e o contexto da navegação da pessoa.

3. Configurabilidade Visual Personalizada

Visando atender à pluralidade de necessidades visuais, foram desenvolvidos controles que possibilitam ampla personalização, a saber:

• Alto contraste: relação de luminância (medida da intensidade de luz emitida ou refletida por uma superfície) superior a 7:1, em conformidade com o nível AAA do WCAG (Web Content Accessibility Guidelines);

• Contraste negativo: inversão de polaridade (contraste negativo) destinada a pessoas sensíveis a fundos claros;

• Escala de cinza: supressão integral das informações cromáticas (cores) para facilitar a distinção de elementos por meio de formas e textos;

• Ajuste de tamanho de texto: possibilidade de escalonamento (zoom) entre 80% e 200%, mantendo a integridade do layout;

• Sublinhado de links: reforço visual para identificação independentemente da cor;

• Fontes aprimoradas: tipografias (fontes) otimizadas para maior legibilidade (distinção entre caracteres parecidos, como “I”, “l” e “1”).

Todos os ajustes realizados são armazenados via localStorage, que é um mecanismo do navegador Web (Google Chrome, Firefox, Safari, etc.) para salvar dados localmente no dispositivo da pessoa, permitindo que suas preferências sejam mantidas em visitas futuras.

4. Design Responsivo e Performático

A interface é otimizada para:

• Dispositivos móveis (smartphones e tablets),

• Computadores desktop e notebooks,

• Conexões lentas ou instáveis,

• Equipamentos com baixo processamento e memória.

A aplicação adota uma arquitetura JavaScript modular, incorporando técnicas de Code Splitting (divisão de código) e Lazy Loading (carregamento em partes), o que permite o carregamento dos scripts somente sob demanda e contribui para a redução do tempo de inicialização. Além disso, as imagens da tabela periódica são veiculadas (distribuídas) por meio de uma CDN (Content Delivery Network em Português Rede de Distribuição de Conteúdo), que armazena os arquivos em servidores (computadores dedicados a entregar conteúdos) distribuídos globalmente.

Outro papel importante da CDN é otimizar as imagens para diferentes tamanhos de tela e resoluções, garantindo que a qualidade visual seja mantida sem comprometer o desempenho. A CDN também faz a compressão automática das imagens, reduzindo o tamanho dos arquivos e acelerando o tempo de carregamento, especialmente em conexões mais lentas.

Essa compressão acontece também com os scripts e estilos (CSS) da aplicação, para que o uso de dados seja minimizado, tornando a ferramenta mais acessível em termos de requisitos técnicos. Dessa forma, garante-se baixa latência (tempo de resposta rápido) e economia de dados para a pessoa, independentemente das condições de conexão.

Arquitetura Técnica em Três Camadas

A fim de atingir esses objetivos e respeitar esses princípios anteriormente mencionados, a solução foi estruturada em três camadas técnicas separadas, cada uma com responsabilidades específicas, para garantir a manutenebilidade (facilidade de manutenção) do código e a organização lógica.

1. Camada de Controles Globais: Barra de Ferramentas de Acessibilidade

Esta camada apresenta uma barra de ferramentas de acessibilidade (A11y Toolbar) disponível em todas as páginas do site. Por meio dela, pessoas conseguem ajustar a aparência visual conforme suas preferências. As escolhas feitas são registradas no localStorage do navegador, garantindo que permaneçam salvas entre os acessos ao site.

Entre os controles oferecidos estão:

• Ajuste de texto: muda o tamanho da fonte.

• Alto contraste e contraste negativo: aumentam a luminância.

• Escala de cinza: elimina as cores.

• Sublinhado de links e fonte aprimorada: facilitam identificar elementos interativos e ler o texto.

O plugin VLibras também é incorporado a essa camada, sendo posicionado dinamicamente para evitar sobrepor outros controles.

2. Camada de Interface da Tabela Periódica

Esta página é a interface principal da tabela periódica, desenvolvida para garantir navegação fácil. Aqui estão apresentados os elementos essenciais que fazem parte dela, como:

• Link “Pular para o Conteúdo” (Skip Link): oferece às pessoas que usam teclado ou leitores de tela a possibilidade de ir direto ao conteúdo principal da página.

• Painel de Controle: apresenta botões de alternância (toggle) para a seleção dos modos de visualização (“Por Períodos”, “Por Grupos” e “Por Categorias”) e para ativação do sistema de cores opcional. As cores são oferecidas como recurso complementar para pessoas que as identificam, sem prejudicar a compreensão das relações químicas quando não utilizadas.

• Modais Informativas: Janelas de diálogo como “Como Usar”, “Saiba Mais” e créditos oferecem instruções, contextualizam a tabela e apresentam as pessoas responsáveis pelo desenvolvimento.

• Modal de Elemento: ao escolher um elemento, aparece uma janela modal detalhada mostrando todas as suas informações químicas (como número atômico, massa, distribuição eletrônica etc.) apresentadas de forma textual e linear.

3. Camada de Lógica: Geração do Conteúdo da Tabela Periódica

Esta camada é o núcleo funcional da ferramenta, formada por quatro scripts modulares que gerenciam dados e interatividade.

Os scripts são:

• tabela-periodica.js: Funciona como o repositório de dados da aplicação, exportando um Array (estrutura) de Objetos com as propriedades completas dos elementos químicos, servindo como a base de informações para os componentes da interface da tabela periódica.

• tabela-periodica-grupos.js: Módulo responsável pela lógica de agrupamento e renderização da visualização “Por Grupos”. Ele processa os dados brutos organizando-os por colunas e realiza a manipulação para injetar o HTML dinamicamente na interface da tabela periódica.

• tabela-periodica-categorias.js: Controlador da visualização “Por Categorias”, classifica elementos pelas séries químicas e organiza a interface hierarquicamente em categorias e subcategorias (como Metais Alcalinos e Gases Nobres) para segmentar a navegação.

• tabela-periodica-colors.js: Controla um sistema opcional de cores. Ele atribui classes CSS aos elementos conforme suas categorias químicas e usa um MutationObserver (observador de mudanças) para que a coloração seja mantida corretamente, mesmo quando os elementos são recriados dinamicamente ao mudar o modo de visualização.

A arquitetura modular organiza o sistema, melhora a eficiência e facilita a manutenção do código. Optou-se por JavaScript puro (vanilla JS) para evitar frameworks (bibliotecas ou estruturas de código pré-construídos) externos, reduzindo arquivos e melhorando o desempenho em conexões lentas.

Assim, depois que o sistema é carregado, ele continua funcionando normalmente mesmo com a internet instável. Apesar de não ser a opção tecnicamente mais avançada ou que utiliza os métodos mais modernos do desenvolvimento de software, essa solução é a que melhor satisfaz as necessidades de acessibilidade e usabilidade em cenários de conectividade limitada, que são justamente os contextos para os quais a ferramenta foi criada.

Validação e Testes

Para fazer a validação de acessibilidade da tabela periódica, foram realizados testes manuais com as seguintes tecnologias assistivas:

Observacao: em telas pequenas, deslize horizontalmente para ler todas as colunas da tabela.

Para garantir a compatibilidade da tabela periódica acessível, foram realizados testes nos seguintes navegadores:

• Google Chrome

• Mozilla Firefox

• Microsoft Edge

• Safari

O objetivo desses testes foi assegurar que a tabela funcionasse corretamente em diferentes ambientes, proporcionando uma experiência consistente para todas as pessoas usuárias, independentemente do navegador ou tecnologia assistiva utilizada.

Participaram do processo de validação 55 pessoas com deficiência visual, sendo:

• 47 pessoas (85%) cegas;

• 8 pessoas (15%) com baixa visão.

As regiões Sudeste e Nordeste do Brasil foram as mais representadas, somando mais de 70% do total de participantes. A distribuição geográfica completa está detalhada na Tabela a seguir.

Observacao: em telas pequenas, deslize horizontalmente para ler todas as colunas da tabela.

As áreas de atuaação das pessoas participantes estão distribuídas conforme a Tabela a seguir.

Observacao: em telas pequenas, deslize horizontalmente para ler todas as colunas da tabela.

Percebe-se uma diversidade significativa de áreas de atuação entre as pessoas participantes, porém há uma predominância de profissionais ligados à tecnologia e acessibilidade digital. Apesar disso, também há representantes de outras áreas, como advocacia, psicologia, docência e pedagogia, entre outras.

Essa variedade contribui para uma avaliação mais abrangente da tabela periódica acessível, considerando diferentes perspectivas e necessidades.

Os testes consistiram em:

• Navegação por teclado: Verificação da funcionalidade completa da tabela periódica utilizando apenas o teclado, garantindo que todas as interações possam ser realizadas sem o uso do mouse.

• Leitura por leitores de tela: Avaliação da compatibilidade da tabela periódica com diversos leitores de tela, assegurando que todas as informações sejam acessíveis e compreensíveis mantendo a semântica correta.

• Uso no mobile: Testes de usabilidade e acessibilidade em dispositivos móveis, verificando a responsividade do design e a facilidade de navegação em telas menores.

• Testes com lupas eletrônicas: Análise da legibilidade e usabilidade da tabela periódica quando ampliada por lupas eletrônicas, garantindo que o conteúdo permaneça claro e organizado mesmo em níveis elevados de zoom.

• Avaliação de personalização visual: Testes das funcionalidades de ajuste de contraste, tamanho de fonte e outras opções visuais para assegurar que as preferências da pessoa sejam aplicadas corretamente e que a tabela permaneça acessível em todas as configurações.

O objetivo era validar:

• A acessibilidade da tabela periódica para pessoas com diferentes condições visuais.

• A usabilidade em diversos dispositivos.

• A eficácia das opções de personalização visual.

• A compatibilidade com tecnologias assistivas populares.

• A manutenção da precisão semântica do conteúdo quando acessado por leitores de tela.

• A redução do custo cognitivo durante a navegação e interação com a tabela periódica.

• A satisfação geral das pessoas participantes com a experiência de uso da tabela periódica acessível.

Depois dos testes as pessoas participantes responderam, via formulário online, a uma pesquisa de satisfação com perguntas objetivas e subjetivas sobre a experiência de uso da tabela periódica acessível.

As perguntas do formulário foram:

Observacao: em telas pequenas, deslize horizontalmente para ler todas as colunas da tabela.

Esse questionamento aberto permitiu que as pessoas participantes expressassem suas opiniões e fornecessem feedback valioso para aprimorar a ferramenta.

Resultados e Impacto

A seguir são apresentados os resultados obtidos a partir dos testes de validação da tabela periódica acessível, bem como o impacto observado na experiência de uso das pessoas participantes. A análise dos dados coletados revelou que a maioria das pessoas avaliou a tabela periódica acessível como uma ferramenta necessária e inovadora, destacando seu baixo custo cognitivo e a facilidade de navegação.

Análise dos Resultados

Pergunta 1

zoom_in

Clique para ampliar

A maioria expressiva dos participantes (89,1%) avaliou que a tabela é mais acessível, fácil de usar e apresenta melhor design do que outras tabelas digitais. Uma parcela menor (10,9%) percebeu equivalência entre as opções, enquanto nenhum participante considerou que a tabela era menos acessível ou apresentava um design inferior.

A tabela periódica acessível se destaca pelas qualidades de acessibilidade, usabilidade e design. Estes resultados evidenciam a necessidade de envolvimento de pessoas com deficiência no processo de desenvolvimento de recursos educacionais, garantindo que suas necessidades sejam atendidas e que a experiência de uso seja satisfatória.

Pergunta 2

zoom_in

Clique para ampliar

72,7% dos participantes acham fácil usar apenas o teclado para navegar e encontrar informações. 27,3% classificaram como neutro, e nenhum relatou dificuldades impeditivas (0%).

Os resultados mostram que a tabela periódica acessível permite navegação eficiente por teclado, beneficiando pessoas que precisam desta modalidade de navegação. A falta de relatos de dificuldade confirma a eficácia do design acessível.

Pergunta 3

zoom_in

Clique para ampliar

Dos 55 participantes, a maior parte (69,1%) afirmou que a tabela funcionou perfeitamente com o leitor de telas usado. Uma parcela menor (14,5%) não utilizou o leitor de telas e 12,7% disseram que o funcionamento foi razoavelmente bom. Somente 3,6% dos entrevistados relataram que a tabela não funcionou bem.

Os participantes com baixa visão que não utilizaram leitores de tela recorreram a ampliadores (lupas), recursos de contraste e demais ferramentas de acessibilidade. Não foi possível identificar por que pessoas usuárias de leitores de tela avaliaram o funcionamento da tabela de maneiras tão diferentes, indo do “perfeito” ao “razoavelmente bem” ou “não funcionou bem”.

Vale ressaltar que cada participante apresenta diferentes níveis de habilidade ao usar leitores de tela, já que nem todos conhecem ou dominam totalmente as ferramentas oferecidas pelo software. Além disso, a compatibilidade pode ser afetada por fatores como a versão do leitor de telas, o sistema operacional e as configurações individuais.

Os resultados demonstram que a tabela periódica acessível apresenta compatibilidade consistente com leitores de tela, uma vez que a maior parte das pessoas usuárias relatou experiências positivas. Contudo, evidencia-se a necessidade de futuras pesquisas. Destaca-se a importância de considerar a diversidade de experiências e habilidades das pessoas usuárias para compreender as diferentes avaliações e identificar oportunidades de aprimoramento da ferramenta, caso necessário.

Pergunta 4

zoom_in

Clique para ampliar

A maioria dos participantes (85,5%) indicou que não utilizou os recursos de ajuste de contraste e tamanho da fonte. Dos que avaliaram a experiência, 14,5% consideraram-na como muito satisfatória. Não foram observados registros de avaliação intermediária (razoavelmente satisfatório) ou de insatisfação, ambos com índice de 0%.

O pequeno número de pessoas que utilizaram o recurso se deve à baixa participação de pessoas com baixa visão na pesquisa, já que a maioria dos participantes eram pessoas cegas que utilizam leitores de tela. Uma possibilidade para aprimorar pesquisas futuras é investir esforços adicionais na inclusão de um número mais significativo de pessoas com baixa visão.

Embora a participação seja voluntária, a expansão das estratégias de divulgação pode potencialmente aumentar o número de participantes, contribuindo para uma avaliação mais robusta da ferramenta. Porém, é importante destacar que a satisfação expressa por aqueles que utilizaram os recursos de personalização visual é um indicativo positivo da eficácia desses recursos para atender às necessidades visuais das pessoas usuárias.

Pergunta 5

A pergunta 5 era aberta (campo de texto livre) e buscava identificar dificuldades específicas relacionadas ao uso da tabela periódica acessível em dispositivos móveis. As respostas foram analisadas qualitativamente para identificar temas comuns e insights (percepções ou entendimentos) sobre a experiência de uso em plataformas móveis.

A maioria dos participantes relatou que a tabela periódica acessível funcionou bem em dispositivos móveis, sem dificuldades significativas. As pessoas com baixa visão que utilizaram a tabela em smartphones ou tablets mencionaram que os recursos de personalização visual, como ajuste de contraste e tamanho de fonte, foram úteis para melhorar a legibilidade e a usabilidade da tabela em telas menores.

Além disso, a ideia de dividir a tabela periódica em diferentes modos de visualização e em “cartões” (elementos químicos apresentados em formato de cartões) foi destacada como uma solução eficaz para facilitar a navegação e a compreensão do conteúdo em dispositivos móveis, onde o espaço de tela é limitado. Essa abordagem permitiu que as pessoas usuárias que apresentam campo visual reduzido ou que utilizam lupas eletrônicas pudessem acessar as informações de maneira mais organizada e acessível, sem grande custo cognitivo ou fadiga visual.

Para as pessoas usuárias de leitores de tela, a experiência de uso em dispositivos móveis também foi positiva, com relatos de que a tabela periódica acessível manteve sua funcionalidade e compatibilidade com os leitores de tela. A possibilidade de “granular” (filtrar ou organizar) as informações em diferentes modos de visualização contribuiu para uma navegação mais eficiente e direcionada, permitindo que as pessoas usuárias pudessem acessar as informações de maneira mais rápida e intuitiva.

A tabela periódica é uma ferramenta de consulta sobre os elementos químicos, e a possibilidade de acessar essas informações de maneira eficiente em dispositivos móveis é fundamental para garantir a inclusão e a equidade no acesso ao conhecimento científico. Os resultados indicam que a tabela periódica acessível foi bem-sucedida em atender às necessidades das pessoas usuárias em plataformas móveis, proporcionando uma experiência de uso satisfatória e inclusiva.

Pergunta 6

A pergunta 6 também era aberta (campo de texto livre) e buscava avaliar o nível geral de satisfação dos participantes com a tabela periódica acessível, além de permitir que eles compartilhassem comentários adicionais ou sugestões para melhorias. A análise qualitativa das respostas revelou um alto nível de satisfação geral com a tabela periódica acessível, com muitos participantes expressando entusiasmo e reconhecimento pela importância de uma ferramenta acessível para o ensino de Química.

Um ponto recorrente foi a insegurança em definir com precisão a fidelidade semântica da tabela periódica acessível. Muitas pessoas comentaram que suas dificuldades com o conteúdo de Química as levavam a se perguntar se suas dúvidas originavam-se de questões de acessibilidade ou simplesmente de problemas com um conteúdo que não dominam.

Houveram diversos relatos negativos relacionados a experiências educacionais das pessoas participantes, como a falta de recursos acessíveis em materiais didáticos, a ausência de apoio adequado por parte de instituições de ensino e a dificuldade em encontrar informações científicas apresentadas de forma inclusiva. Esses relatos reforçam a importância de iniciativas como a tabela periódica acessível, que visam preencher lacunas significativas na oferta de recursos educacionais para pessoas com deficiência visual.

Muitos participantes destacaram a relevância da tabela periódica acessível como uma ferramenta que promove a inclusão e a equidade no acesso ao conhecimento científico. Eles ressaltaram que a tabela não apenas facilita o aprendizado, mas também contribui para a autonomia e a participação ativa em ambientes educacionais.

Ferramenta Disponível para Uso

A tabela periódica acessível está disponível para uso público no seguinte endereço: https://pcdnaescola.com.br/ferramentas-tabela-periodica-acessivel-para-pessoas-com-deficiencia/. A ferramenta pode ser acessada gratuitamente por qualquer pessoa interessada, sem necessidade de cadastro ou pagamento.

A metodologia permitiu desenvolver uma ferramenta que torna a tabela periódica acessível a pessoas com deficiência visual, comprovando sua viabilidade técnica e pedagógica. A seguir são destacados os principais aspectos relacionados à ultilização da tabela periódica acessível:

1. Modos de Visualização

A tabela periódica pode ser visualizada de três maneiras diferentes: por períodos, por grupos e por categorias. Cada modo oferece uma perspectiva distinta sobre a organização dos elementos químicos, facilitando a compreensão das suas propriedades e relações.

zoom_in

Clique para ampliar

1.1 Visualização por Períodos

Os elementos estão organizados em seções que equivalem aos períodos (as linhas horizontais da tabela), tornando a tabela dividida em partes menores e mais fáceis de manejar, isso é especialmente útil em telas de smartphones, onde o conteúdo aparece na vertical.

zoom_in

Clique para ampliar

1.2 Visualização por Grupos

Os elementos estão dispostos em grupos (colunas verticais), possibilitando que a pessoa examine elementos com propriedades químicas semelhantes. Essa estrutura de navegação também se mostra mais adequada para dispositivos com telas reduzidas.

zoom_in

Clique para ampliar

1.3 Visualização por Categorias

Os elementos estão classificados de acordo com suas categorias químicas, distribuídos em quatro grupos principais. São eles:

• Metais

• Semimetais

• Não Metais

• Outros (Hidrogênio)

Ao agrupar elementos que compartilham características químicas, essa apresentação torna mais simples entender as propriedades e os comportamentos de cada um deles.

Por exemplo, no âmbito da categoria “Metais”, estão incluídas subcategorias como Metais Alcalinos, Metais Alcalinoterrosos, Metais de Transição, Lantanídeos, Actinídeos e Outros Metais.

A categoria “Não Metais” inclui os não metais, halogênios e gases nobres, enquanto o hidrogênio é classificado separadamente em “Outros” devido às suas características únicas.

Essa estrutura facilita a exploração didática da tabela periódica e a compreensão das relações e classificações dos elementos.

zoom_in

Clique para ampliar

zoom_in

Clique para ampliar

2. Painel de Controle

Um painel de controle fixo no topo permite alternar entre períodos, grupos, categorias e ativar ou desativar as cores da tabela.

zoom_in

Clique para ampliar

Ao habilitar a visualização por períodos, o painel apresenta uma seção intitulada “Navegue pelos períodos da tabela”, composta por botões referentes aos sete períodos, bem como opções específicas para lantanídeos e actinídeos. A seleção de qualquer um desses botões direciona a pessoa imediatamente para a respectiva seção da página.

zoom_in

Clique para ampliar

Na visualização por grupos, o painel mostra botões para cada um dos 18 grupos e para lantanídeos e actinídeos. Ao clicar em um botão, a pessoa vai direto à seção correspondente.

zoom_in

Clique para ampliar

Na visualização por categorias, o painel apresenta a seção “Navegue pelas categorias da tabela”, exibindo botões hierarquicamente organizados de acordo com as quatro principais categorias: Metais (com subdivisões como Alcalinos, Alcalinoterrosos, Transição, entre outras), Semimetais, Não Metais (incluindo Halogênios e Gases Nobres) e Outros (Hidrogênio). Ao selecionar um desses botões, a pessoa é direcionada para a respectiva categoria ou subcategoria, promovendo uma navegação eficiente pelo tipo de elemento químico.

zoom_in

Clique para ampliar

3. Cartões de Elementos Químicos

Cada elemento químico aparece em um cartão com símbolo, nome, período e coluna.

zoom_in

Clique para ampliar

Estes cartões permitem interação: ao usar o mouse, tocar na tela ou pressionar Enter, uma janela modal surge exibindo dados detalhados do elemento, incluindo símbolo, nome, número atômico, massa atômica e configuração eletrônica.

4. Modal de Detalhes do Elemento

Ao acessar um cartão de elemento por clique, toque ou Enter, abre-se uma janela modal com informações detalhadas.

• Gerenciamento de foco: Ao abrir a modal, o foco é automaticamente direcionado para o primeiro elemento interativo (geralmente o botão de fechar no canto superior direito), garantindo que pessoas que navegam por teclado ou usam leitores de tela saibam imediatamente onde estão e possam fechar a janela facilmente.

• Ao fechar a modal, o foco retorna automaticamente para o cartão do elemento que foi acessado, evitando que o usuário se perca na página e precise procurar novamente onde estava antes de abrir a janela.

• Estrutura semântica: A modal utiliza elementos HTML semânticos apropriados, com atributos ARIA role=”dialog” e aria-modal=”true”, informando aos leitores de tela que uma janela de diálogo foi aberta e alterando o modo de navegação.

• Rotulagem acessível: Cada modal possui um título claro (o nome do elemento), anunciado quando a janela é aberta. As informações são organizadas hierarquicamente com títulos (<h2>, <h3>) que permitem navegação rápida por marcos de referência.

Informações apresentadas na modal

A janela modal de cada elemento apresenta as seguintes informações:

• Nome do elemento: Apresentado como título principal da modal, sendo a primeira informação anunciada pelos leitores de tela.

• Ilustração do elemento: Uma imagem que mostra como o elemento aparece ou é utilizado no cotidiano. Por exemplo, para o carbono, pode ser uma ilustração de grafite ou diamante; para o oxigênio, uma representação de bolhas de ar.

• Grupo: Indica a família de elementos à qual pertence (por exemplo: “Metais Alcalinos”, “Halogênios”, “Gases Nobres”). Essa informação é fundamental para entender as propriedades químicas do elemento.

• Símbolo: A abreviatura química do elemento (exemplo: H para Hidrogênio, O para Oxigênio, Au para Ouro), apresentada de forma clara e acessível.

• Número atômico: Indica quantos prótons existem no núcleo do átomo, definindo a identidade do elemento e sua posição na tabela periódica.

• Número de massa (massa atômica): Representa a soma de prótons e nêutrons no núcleo, indicando a massa aproximada do átomo.

• Distribuição eletrônica: Apresentada de duas formas complementares para garantir acessibilidade total:

  • Visual: Um diagrama ilustrativo mostrando o núcleo do átomo no centro e as camadas eletrônicas ao redor, com os elétrons distribuídos em suas respectivas posições. Essa representação visual auxilia quem enxerga a compreender espacialmente a organização dos elétrons.

zoom_in

Clique para ampliar

• Linear (textual): A notação científica padrão da distribuição eletrônica, apresentada em formato de texto sequencial. Exemplo: Camada 1: 1s¹. A leitura dessa notação é direta, sequencial e construída usando atributos ARIA para garantir que leitores de tela anunciem corretamente cada parte da configuração eletrônica.

zoom_in

Clique para ampliar

Considerações Finais

Este artigo teve como objetivo investigar desafios e estratégias para o ensino da tabela periódica a estudantes com deficiência visual e, a partir disso, propor e validar uma ferramenta digital acessível. Esse objetivo foi alcançado por meio do desenvolvimento de uma Tabela Periódica Acessível baseada em tecnologias Web e em princípios de acessibilidade, contemplando o uso de HTML semântico, textos alternativos, compatibilidade com leitores de tela, navegação por teclado e rotulagem adequada com ARIA, além de modos de visualização que organizam o conteúdo em blocos menores e mais manejáveis.

Os resultados obtidos na validação indicam que a proposta responde diretamente ao problema da pesquisa: é possível disponibilizar a tabela periódica em formato digital sem que o recurso se torne uma barreira para pessoas com deficiência visual. A maioria dos participantes considerou a ferramenta mais acessível, mais usável e com melhor design do que outras tabelas digitais (89,1%). Também se observou boa avaliação da navegação por teclado (72,7% classificaram como fácil) e do funcionamento com leitores de tela (69,1% relataram funcionamento perfeito). Em conjunto, esses achados sugerem que as decisões de design e a estrutura técnica adotada contribuíram para reduzir barreiras, favorecendo autonomia e consistência na experiência de uso.

Como contribuição prática, a pesquisa disponibiliza uma ferramenta gratuita e pública que pode ser incorporada ao contexto educacional como recurso de apoio ao ensino de Química, especialmente quando se busca ampliar a autonomia e a participação de estudantes com deficiência visual. Do ponto de vista teórico e metodológico, o trabalho reforça a internet e o desenvolvimento Web como tecnologias assistivas viáveis, evidenciando que acessibilidade não é um complemento, mas um requisito estruturante do projeto. Além disso, o estudo exemplifica um caminho replicável de concepção de recursos educacionais: combinar princípios de Desenho Universal, boas práticas de acessibilidade e validação com pessoas usuárias para orientar decisões de desenvolvimento.

Apesar dos resultados positivos, algumas limitações devem ser consideradas. A amostra foi restrita e apresentou baixa participação de pessoas com baixa visão, o que reduz a generalização dos achados para todo o espectro da deficiência visual. A avaliação também foi baseada predominantemente em percepções de uso (questionário), sem contemplar medidas diretas de aprendizagem ou acompanhamento longitudinal em sala de aula. Adicionalmente, a experiência pode variar conforme dispositivo, sistema operacional, versão do leitor de tela e nível de familiaridade das pessoas participantes com tecnologias assistivas.

Como continuidade, recomenda-se ampliar a pesquisa com maior diversidade de participantes (incluindo mais pessoas com baixa visão) e com estudos em ambientes educacionais reais, investigando não apenas usabilidade e acessibilidade, mas também impactos no aprendizado, na motivação e na participação em atividades de Química. Outra direção relevante é aprofundar testes comparativos entre diferentes leitores de tela e plataformas, bem como aprimorar estratégias pedagógicas de uso da ferramenta (por exemplo, roteiros didáticos e orientações para docentes) para fortalecer sua integração ao currículo.

Por fim, novas investigações podem explorar a combinação de recursos digitais acessíveis com abordagens multissensoriais (como materiais táteis), buscando ampliar ainda mais as possibilidades de ensino inclusivo de conteúdos que dependem fortemente de representações visuais. A pesquisa reforça a importância de considerar a diversidade de necessidades e experiências das pessoas com deficiência visual no desenvolvimento de recursos educacionais, promovendo uma educação mais inclusiva, equitativa e centrada na autonomia dos estudantes.

Referências

• BERSCH, R. Classificações de Tecnologia Assistiva. Porto Alegre: Acessibilidade Brasil/Assistiva, 2013.
• BERSCH, R. Tecnologia Assistiva e Educação Inclusiva. In: Ensaios Pedagógicos. Brasília: Ministério da Educação, Secretaria de Educação Especial, 2006. p. 146.
• BRASIL. Lei nº 9.394, de 20 de dezembro de 1996. Estabelece as diretrizes e bases da educação nacional. Diário Oficial da União, Brasília, DF, v. 134, n. 248, 23 dez. 1996. Seção 1, p. 27834–27841.
• BRASIL. Lei nº 13.146, de 6 de julho de 2015. Institui a Lei Brasileira de Inclusão da Pessoa com Deficiência (Estatuto da Pessoa com Deficiência).
• BRASIL. Decreto nº 3.298, de 20 de dezembro de 1999. Regulamenta a Lei nº 7.853/1989 e dispõe sobre a Política Nacional para a Integração da Pessoa Portadora de Deficiência.
• BRASIL. Ministério da Educação. Secretaria de Educação Especial. Desenvolvendo competências para o atendimento das necessidades educacionais de alunos cegos e de alunos com baixa visão. Brasília: MEC/SEESP, 2005.
• CONDE, A. J. M. Definindo cegueira e baixa visão.
• FELTRE, R. Química Geral. São Paulo: Editora Moderna, 2004.
• GALVÃO FILHO, T. As novas tecnologias na escola e no mundo atual: fator de inclusão social do aluno com necessidades especiais? In: Anais do III Congresso Ibero-Americano de Informática na Educação Especial. Fortaleza: MEC, 2002.
• GALVÃO FILHO, T.; DAMASCENO, L. Programa InfoEsp: Premio Reina Sofia 2007 de Rehabilitación y de Integración. Boletín del Real Patronato Sobre Discapacidad, Ministerio de Educación, Política Social y Deporte, Madrid, n. 63, p. 14–23, abr. 2008. ISSN 1696-0998.
• GARRUTTI DE LOURENÇO, B. A.; et al. Acessibilidade para estudantes com deficiência visual: orientações para o ensino superior. São Paulo: UNIFESP, 2020.
• IVANOVICH, A. C. F.; GESSER, M. Deficiência e capacitismo: correção dos corpos e produção de sujeitos (a)políticos. Quaderns de Psicologia, v. 22, n. 3, e1618, 2020.
• JACYNTHO, M. D. de A. Processos para Desenvolvimento de Aplicações Web. 2008. 25 f. Monografia (Bacharelado em Ciência da Computação) — PUC-Rio, 2008.
• LIMA, A. G. JavaScript – Aplicações Interativas para a Web.
• MANTOAN, M. T. E. A tecnologia aplicada à educação na perspectiva inclusiva. Mimeo, 2005.
• RABELLO, E. T.; PASSOS, J. S. Vygotsky e o desenvolvimento humano.
• REBONATTO, M. T. Organização de Computadores – Notas de aula. Passo Fundo, 2003.
• REIS, C. de A. R. A baixa visão no meu caminho. Aracaju: Editora Triunfo, 2015.
• SANTOS, E. C. dos; FERRÉ, F. Introdução ao desenvolvimento Web usando HTML, CSS e PHP.
• SIAULIYS, M. O. C.; ORMELEZI, E. M.; BRIANT, M. E. (Org.). A deficiência visual associada à deficiência múltipla e o atendimento educacional especializado: encarando desafios e construindo possibilidades. São Paulo: Laramara, 2010.
• SILVA, M. O. E. Inclusão e Formação Docente. Eccos – Revista Científica, v. 10, n. 2, p. 479–495, [s.d.].
• W3C – World Wide Web Consortium. Web Content Accessibility Guidelines (WCAG) 2.2. 05 out. 2023.
• W3C – World Wide Web Consortium. Accessible Rich Internet Applications (WAI‑ARIA) 1.2. 06 set. 2023.

No artigo anterior, aprendemos sobre as estruturas de repetição em Ruby. Vimos o while e o until, que repetem código enquanto uma condição for verdadeira ou falsa. Depois, o for e o each, que percorrem coleções como arrays e ranges, e o times, que repete uma ação um número exato de vezes. Por fim, o loop, que cria um ciclo que só para com o comando break, e o next, que pula para a próxima iteração sem executar o restante do bloco.

Com esse artigo, encerramos o ciclo de apresentação dos fundamentos da programação nesta série. Ao longo dos últimos artigos, passamos por variáveis, tipos de dados, entrada e saída de dados, expressões condicionais e estruturas de repetição. São os blocos básicos com os quais qualquer programa é construído.

Mas saber o que existe e saber usar são coisas diferentes. É como aprender as regras de um jogo: você pode ler o manual inteiro e ainda não saber jogar. A leitura e os exemplos dos artigos anteriores apresentaram os conceitos isolados, agora chegou o momento de combiná-los para resolver problemas reais.

Neste artigo, esses conceitos serão colocados em prática com exercícios organizados em três níveis de dificuldade. No nível básico, os programas são curtos e diretos, focados em um conceito por vez. No intermediário, diferentes estruturas começam a ser combinadas para resolver problemas mais elaborados. No avançado, o desafio é pensar no programa como um sistema completo, com menus, validações e estruturas de dados.

Para cada exercício há o enunciado, uma explicação passo a passo de como chegar na solução e o código completo ao final.

Dica importante: Antes de ler a solução, tente resolver o exercício por conta própria. Mesmo que o resultado não seja perfeito, o esforço de pensar na solução é o que realmente desenvolve o raciocínio lógico. A solução apresentada aqui é apenas uma das formas possíveis de resolver cada problema.

Nível Básico

Os exercícios do nível básico focam nos fundamentos da programação: variáveis, entrada de dados, conversão de tipos e condicionais simples. Você vai praticar o uso de puts, print, gets.chomp, interpolação de strings, o operador de módulo % e estruturas if/else. São três programas curtos e diretos, ideais para quem está dando os primeiros passos na escrita de código.

Programa saudação personalizada

O programa pede para a pessoa digitar um nome e depois imprime uma saudação personalizada com o nome digitado.

Como fazer?

Para desenvolver este e qualquer outro programa, devemos dividir o problema grande em passos lógicos menores. O raciocínio deve seguir o fluxo:

• Entrada
• Processamento
• Saída

O problema é: Preciso pegar um texto da pessoa (o nome) e devolvê-lo dentro de uma frase.

Então precisamos de:

• Uma maneira de mostrar texto na tela.
• Uma maneira de capturar (pegar) o que a pessoa digita.
• Um lugar para guardar essa informação que a pessoa digitou (variável).

Precisamos criar uma variável vazia chamada nome para guardar o que a pessoa digitar depois. Então vamos criar e inicializar essa variável como uma string vazia.

nome = ""

Em Ruby, diferente de outras linguagens de programação, isso não é estritamente obrigatório (você poderia criar a variável direto no momento da leitura), mas ajuda na organização mental e do código.

O próximo passo é informar à pessoa o que o programa faz e pedir a informação correta. Vamos usar puts e print.

puts "Programa de Saudação Personalizada" # Título que pula linha no final
print "Por favor, digite seu nome: "      # Pergunta que não pula a linha

Agora o programa deve parar e esperar a pessoa digitar a informação e apertar ENTER.

Temos que lembrar de ler a informação do teclado (com o gets), mas também temos que limpar o espaço causado pela tecla Enter que vem junto, usando chomp.

Então usamos:

nome = gets.chomp

Agora temos o nome guardado na variável nome e precisamos misturá-lo com uma frase fixa.

Vamos escrever a frase fixa e, no meio dela, inserir o nome que está dentro da variável. Também vamos evitar que tenham espaços sobrando no nome guardado, tanto no começo quanto no final. Para limpar esses espaços, caso eles existam, vamos usar o método strip.

Podemos fazer isso assim:

puts "Olá #{nome.strip}! Receba as boas-vindas ao nosso programa!"

O programa completo ficou assim:

# Declara variável para receber o nome da pessoa
nome = ""

# Pede para a pessoa digitar seu nome
puts "Programa de Saudação Personalizada"
print "Por favor, digite seu nome: "
nome = gets.chomp

# Exibe a saudação personalizada
puts "Olá #{nome.strip}! Receba as boas-vindas ao nosso programa!"

Programa calculadora de idade atual

O programa deve pedir para a pessoa digitar um ano de nascimento (exemplo: 1995) e depois deve mostrar sua idade aproximada.

É importante lembrar de fazer a validação para impedir que a pessoa passe letras ao programa, uma data de nascimento que seja impossível (muito no passado, como 1500) ou uma data futura superior à data atual.

Como fazer?

O problema é: Precisamos garantir que a pessoa digite um dado válido. Se ela digitar errado, o programa não pode continuar; precisamos repetir a pergunta até receber uma informação válida.

Sabemos quantas tentativas a pessoa vai gastar até colocar um ano de nascimento válido? Não. Precisamos que o programa comece pedindo um ano de nascimento e só pare de pedir quando receber um valor correto.

Qual laço de repetição pode ser usado nestas condições? O while.

Para fazer o programa ser executado na primeira vez, vamos assumir que a pessoa ainda não tem uma idade válida (idade = 0). Enquanto a idade continuar inválida (ou zero), o programa fica preso num loop (laço de repetição) perguntando o ano.

idade = 0
while idade <= 0
  # Perguntas e validações acontecem aqui dentro
end

E se a pessoa digitar “abcd” em vez de números? Se tentarmos fazer algum cálculo matemático (“2025 menos abcd”), o programa vai “quebrar” (dar erro e fechar).

Temos que converter o que a pessoa digitar para números inteiros (porque não existem anos com vírgula, como 1995,2). Mas, se a pessoa digitar letras, ao invés de travar, temos que transformar o que ela digitou em um valor nulo (nil) silenciosamente.

Vamos tentar transformar o texto em número inteiro usando Integer(...). Se der erro (porque a pessoa não digitou números), vamos usar o rescue para capturar esse erro e transformar o valor em nil (nulo) em vez de travar o sistema.

Podemos fazer assim:

print "Digite o seu ano de nascimento (exemplo: 1990): "
ano_nascimento = Integer(gets.chomp) rescue nil

Isso é fundamental: sem o rescue nil, quando a pessoa digitar letras, isso travaria o programa imediatamente e ele seria encerrado com erro.

Ok! Mas agora, como fazer a validação do ano digitado?

Por exemplo, se a pessoa digitou um número absurdo, que não tem como ser um ano de nascimento (exemplo: ano 1500 ou ano 3000). A solução é criar um if com várias barreiras. A informação digitada é rejeitada se qualquer uma das condições ruins for verdade.

O ano será considerado inválido SE:

• For vazio (nil?, como no caso em que digitamos letras e o rescue converteu para nil) OU (||)
• For muito antigo, de forma que não tenha como a pessoa estar viva (menor que o ano 1900) OU (||)
• For no futuro (maior que o ano atual).

Então devemos perguntar se o ano de nascimento é nulo, se ele é menor que 1900 ou maior que o ano atual.

Podemos fazer isso assim:

if ano_nascimento.nil? || ano_nascimento < 1900 || ano_nascimento > Time.now.year
    puts "Ano de nascimento inválido. Por favor informe um ano válido."
else

Neste caso, o if está testando três condições ao mesmo tempo:

1. ano_nascimento.nil?: “O valor dentro da variável ano_nascimento é nulo?” (ou seja, a pessoa digitou letras?).
2. ano_nascimento < 1900: “A pessoa digitou uma data antes de 1900?” (o que provavelmente é um erro).
3. ano_nascimento > Time.now.year: “O ano de nascimento digitado é maior que o ano atual?” (o que também é um erro). O Time.now.year pega o ano atual direto do relógio do computador automaticamente.

Se o valor digitado passou pelas condições do if (não é nulo, não é menor que 1900 e não é futuro), entramos no “caso contrário”, o else. Dentro do else, fazemos o cálculo.

• Colocamos a variável ano_atual para receber o ano atual do relógio do computador.
• Depois, a idade vai receber o ano atual menos o ano digitado.
• Então a variável idade vai ser atualizada com esse resultado.
  • Por exemplo: idade = 2026 - 1995
  • A variável idade vai atualizar de 0 para 31.

Como a idade agora é um número positivo (exemplo: 31), quando o programa chegar no fim do bloco (no end) e voltar lá no while, a condição idade <= 0 será falsa. O loop quebra e o programa avança sem repetir a pergunta.

O código do else ficaria assim:

else
  # Calcular a idade atual
  ano_atual = Time.now.year
  idade = ano_atual - ano_nascimento
end

Depois de fazer todo esse cálculo, é preciso exibir o resultado para a pessoa:

puts "O ano atual é #{Time.now.year}, seu ano de nascimento é #{ano_nascimento}, então a sua idade atual é aproximadamente #{idade} anos."

O programa completo fica assim:

# Variável que vai guardar a idade da pessoa
idade = 0

# Vamos pedir o ano de nascimento da pessoa
# Lembrar de validar que a pessoa não digitou letras ou um ano impossível

puts "Programa calculadora de idade atual"

while idade <= 0

  print "Digite o seu ano de nascimento (exemplo: 1990): "
  ano_nascimento = Integer(gets.chomp) rescue nil

  if ano_nascimento.nil? || ano_nascimento < 1900 || ano_nascimento > Time.now.year
    puts "Ano de nascimento inválido. Por favor informe um ano válido."
  else
    # Calcular a idade atual
    ano_atual = Time.now.year
    idade = ano_atual - ano_nascimento
  end
end

puts "O ano atual é #{Time.now.year}, seu ano de nascimento é #{ano_nascimento}, então a sua idade atual é aproximadamente #{idade} anos."

Programa que identifica se o número é par ou ímpar

O programa deve receber um número digitado pelo usuário e determinar se ele é par ou ímpar.

Como fazer?

A pergunta que devemos fazer é: como eu ensino para uma máquina o que é um número par ou ímpar? Na matemática, um número é par se, ao ser dividido por 2, não sobra nada (o resto é zero). Se sobrar alguma coisa, então o número é ímpar.

Vamos precisar de uma variável para receber o número:

numero = 0.0

Depois, precisamos informar o nome do programa e pedir um número para a pessoa. Vamos usar o puts para exibir o nome do programa (com quebra de linha) e print para pedir o número (sem quebra de linha, mantendo o cursor ao lado).

puts "Programa que calcula se um número é par ou ímpar"
print "Digite um número: "

Depois vamos usar a variável numero para receber o que a pessoa digita. Precisamos converter para Float (número decimal com vírgula) e limpar o espaço causado pela tecla Enter.

Geralmente, este tipo de programa costuma usar números inteiros. Mas, usando Float, o programa não travará se alguém digitar “2.5” ou “7.2”. Se a pessoa digitar um número inteiro como 4, o programa converterá para 4.0 e o cálculo funcionará normalmente.

Podemos receber o número dessa forma:

numero = Float(gets.chomp)

Podemos usar um if numero % 2 == 0 para fazer a pergunta: se o número digitado for dividido por 2, o resto da divisão (o que sobra) é igual a 0?

• Se o resto da divisão for 0, a divisão foi exata. O número é PAR.
• Se o resto da divisão não for 0, o número é ÍMPAR.

Vamos usar o %, que é o operador no Ruby para calcular o resto de uma divisão.

O código da verificação ficaria assim:

if numero % 2 == 0
  puts "#{numero} dividido por 2 é igual a #{numero / 2}, portanto é um número par."
else
  puts "#{numero} dividido por 2 é igual a #{numero / 2}, portanto é um número ímpar."
end

Depois finalizamos o bloco condicional (if / else) com o end e imprimimos que o programa finalizou.

O código completo fica assim:

# Vamos pedir para a pessoa digitar um número e determinar se ele é par ou ímpar

numero = 0.0

puts "Programa que calcula se um número é par ou ímpar"

print "Digite um número: "
numero = Float(gets.chomp)

if numero % 2 == 0
  puts "#{numero} dividido por 2 é igual a #{numero / 2}, portanto é um número par."
else
  puts "#{numero} dividido por 2 é igual a #{numero / 2}, portanto é um número ímpar."
end

puts "Fim do programa."

Nível Intermediário

No nível intermediário, os exercícios combinam laços de repetição (for, while, each, loop, times) com lógicas mais elaboradas, como acumuladores, contadores, validação de entradas e o uso do rescue para tratar erros. Você vai implementar tabuadas, contar vogais, verificar números primos, somar quantidades variáveis de números, gerar a sequência de Fibonacci e criar um jogo de adivinhação. O objetivo é aprender a pensar além de um único bloco de código e combinar estruturas para resolver problemas mais complexos.

Programa para exibir a tabuada de um número

O programa deve receber um número digitado pela pessoa e informar a sua tabuada de multiplicação de 1 a 10.

Como fazer?

O problema consiste em repetir uma mesma operação matemática (multiplicação) várias vezes, alterando apenas um dos números.

Precisamos:

1. Receber o número que a pessoa quer calcular.
2. Criar um laço de repetição que vá de 1 até 10.
3. Dentro desse laço, multiplicar o número escolhido pelo contador atual e mostrar o resultado.

Vamos começar pedindo o número:

numero = 0

puts "\nPrograma para exibir a tabuada de um número.\n"
print "\nDigite um número inteiro: "
numero = Integer(gets.chomp)

Agora, vamos ver como resolver a repetição. Existem três formas principais de fazer isso em Ruby: o jeito clássico (for), o jeito manual (while) e o jeito “Ruby” (each).

1. O Jeito Clássico: O Laço for

for i in 1..10
  resultado = numero * i
  puts "#{numero} x #{i} = #{resultado}"
end

Aqui estamos dizendo: “Para (for) cada número (i) dentro do intervalo de 1 até 10 (1..10), faça o que está abaixo”. O computador pega o primeiro número (1), coloca na variável i, executa o bloco, volta, pega o próximo (2), e assim por diante até o 10.

2. O Jeito “Manual”: O Laço while

i = 1

while i <= 10
  resultado = numero * i
  puts "#{numero} x #{i} = #{resultado}"
  i += 1
end

O while significa “enquanto”. Definimos manualmente que i = 1. Enquanto i for menor ou igual a 10, ele executa.

Atenção: No while, precisamos aumentar o contador manualmente (i += 1). Se esquecermos isso, o i será sempre 1 e o programa ficará preso num loop infinito.

3. O Jeito “Ruby”: O Laço each

(1..10).each do |i|
  resultado = numero * i
  puts "#{numero} x #{i} = #{resultado}"
end

Este é o jeito preferido em Ruby.

• (1..10): Criamos o intervalo de números.
• .each do: Dizemos “para cada item dentro deste intervalo, faça…”.
• |i|: As barras verticais funcionam como uma pinça que pega o número da vez e coloca na variável i.

Embora os três produzam o mesmo resultado visual, o each é a maneira mais comum em Ruby, focada em percorrer coleções de dados.

No programa completo demonstrando os três métodos e fica assim:

numero = 0

puts "\nPrograma para exibir a tabuada de um número.\n"
print "\nDigite um número inteiro: "
numero = Integer(gets.chomp)

puts "Tabuada do número #{numero} usando o laço 'for':\n\n"

for i in 1..10
  resultado = numero * i
  puts "#{numero} x #{i} = #{resultado}"
end

puts "\nA mesma tabuada usando o laço 'while':\n\n"

i = 1

while i <= 10
  resultado = numero * i
  puts "#{numero} x #{i} = #{resultado}"
  i += 1
end

puts "\nA mesma tabuada usando o laço 'each':\n\n"

(1..10).each do |i|
  resultado = numero * i
  puts "#{numero} x #{i} = #{resultado}"
end

Programa contador de vogais

O programa deve receber uma frase ou texto digitado pela pessoa e identificar quantas vogais existem nele.

Como fazer?

O computador é muito literal: para ele, “a” é totalmente diferente de “á” ou “A”. Se não limparmos o texto, teríamos que procurar pela mesma letra várias vezes, testando cada possibilidade de acento ou maiúscula.

Então o fluxo lógico será:

1. Receber a frase.
2. Limpar a frase: remover acentos e transformar tudo em minúsculo.
3. Percorrer letra por letra da frase limpa.
4. Verificar se a letra atual é uma vogal conhecida.
5. Se for, somar 1 ao contador.

Primeiro, definimos o que são vogais e pedimos a frase:

vogais = ["a", "e", "i", "o", "u"]

puts "\nPrograma contador de vogais.\n\n"
print "Digite uma frase: "
frase_digitada = gets.chomp

Agora precisamos fazer o “tratamento dos dados”. Vamos usar o método tr (Translate/Traduzir) para trocar letras com acento por letras sem acento.

sem_acentos = frase_digitada.tr(
  "áàãâäéèêëíìîïóòõôöúùûüçÁÀÃÂÄÉÈÊËÍÌÎÏÓÒÕÔÖÚÙÛÜÇ",
  "aaaaaeeeeiiiiooooouuuucAAAAAEEEEIIIIOOOOOUUUUC"
)

Depois, transformamos tudo em letras minúsculas para padronizar a comparação:

frase_minuscula = sem_acentos.downcase

Agora que o texto está limpo, vamos contá-lo. Vamos iniciar um contador (total_vogais) em zero e verificar caractere por caractere.

total_vogais = 0

frase_minuscula.each_char do |char|
  if vogais.include?(char)
    total_vogais += 1
  end
end

• frase_minuscula.each_char do |char|: Para cada caractere da frase, coloque-o na variável temporária char.
• if vogais.include?(char): Pergunta “A letra que está em char faz parte da minha lista de vogais?”.
• Se sim, adicionamos 1 ao total_vogais.

O programa completo fica assim:

vogais = ["a", "e", "i", "o", "u"]

puts "\nPrograma contador de vogais.\n\n"
print "Digite uma frase: "
frase_digitada = gets.chomp

# Substituindo letras acentuadas por suas equivalentes sem acento
sem_acentos = frase_digitada.tr(
  "áàãâäéèêëíìîïóòõôöúùûüçÁÀÃÂÄÉÈÊËÍÌÎÏÓÒÕÔÖÚÙÛÜÇ",
  "aaaaaeeeeiiiiooooouuuucAAAAAEEEEIIIIOOOOOUUUUC"
)

frase_minuscula = sem_acentos.downcase

total_vogais = 0

frase_minuscula.each_char do |char|
  if vogais.include?(char)
    total_vogais += 1
  end
end

puts "\nA frase '#{frase_digitada}' possui #{total_vogais} vogais.\n\n"

Programa que verifica se um número é primo

O programa deve receber um número e identificar se ele é primo ou não, informando o resultado à pessoa.

Um número primo é aquele que só aceita ser dividido por 1 e por ele mesmo (exemplos: 2, 3, 5, 7, 11…). Se o número aceitar ser dividido por qualquer outro valor, ele não é primo.

Como fazer?

A lógica que vamos usar é a seguinte: usa uma estratégia chamada “bandeira” (flag). Vamos assumir inicialmente que o número é primo (bandeira levantada/true) e tentar provar o contrário. Se encontrarmos qualquer número que consiga dividir o número digitado pela pessoa, baixamos a bandeira (false) e paramos de procurar, pois já conseguiremos provar que o número não é primo.

Primeiro, recebemos o número:

numero = 0
puts "\nPrograma que verifica se um número é primo.\n\n"
print "Digite um número inteiro positivo (exemplo: 7): "
numero = Integer(gets.chomp)

primo = true # Começamos acreditando que é primo

Agora vamos às regras de validação:

1. Números menores que 2: Na matemática, 0, 1 e números negativos não são primos. Se o número for menor que 2, já definimos primo = false.
2. Números a partir de 2: Precisamos testar. Vamos criar um laço que vai do número 2 até o número imediatamente anterior ao digitado (numero - 1).
   • Por que começar do 2? Porque todo número divide por 1, então testar o 1 é inútil.
   • Por que parar no anterior? Porque todo número divide por ele mesmo. Queremos saber se existe algum “intruso” no meio do caminho que consiga dividir.

O código de verificação será:

if numero < 2
  primo = false
else
  # Testamos do 2 até o número anterior
  for i in 2..(numero - 1)
    if numero % i == 0
      primo = false
      break # Para o laço imediatamente, já sabemos que não é primo
    end
  end
end

Note o uso do break: ele funciona como um botão de emergência. Se descobrimos que 10 divide por 2, não precisamos testar se divide por 3, 4 ou 5. Já sabemos que não é primo, então paramos para economizar processamento.

Por fim, exibimos o resultado baseados no estado da nossa variável primo.

O programa completo fica assim:

numero = 0

puts "\nPrograma que verifica se um número é primo.\n\n"
print "Digite um número inteiro positivo (exemplo: 7): "
numero = Integer(gets.chomp)

primo = true

# Números menores que 2 não são primos
if numero < 2
  primo = false
else
  # Caso contrário, vamos testar do 2 até o número anterior ao escolhido
  for i in 2..(numero - 1)
    if numero % i == 0
      primo = false
      break # Para o laço porque já sabemos que não é primo
    end
  end
end

# Mostrando o resultado
if primo
  puts "\nO número #{numero} é primo!\n\n"
else
  puts "\nO número #{numero} não é primo!\n\n"
end

Programa que soma N números

O programa deve perguntar quantos números a pessoa deseja somar, depois pedir quais são os números e fazer a soma. No final deve exibir o valor total da soma.

Como fazer?

Vamos usar um acumulador (uma variável que começa em zero e guarda o total de números que a pessoa quer somar). Também vamos usar um loop (laço de repetição) que roda a quantidade de vezes que a pessoa definiu quando disse quantos números queria somar.

Exemplo: se a pessoa disser que quer somar 10 números o programa deve executar o laço de repetição 10 vezes.

Vamos começar declarando as variáveis. Isso é obrigatório no Ruby? Não, mas no estudo de lógica de programação isso ajuda a ir organizando o raciocínio.

Precisamos de:

• Uma variável para guardar quantos números vamos somar. Vamos iniciar ela com valor 0.
• Uma variável Float para registrar a soma dos números.
• Um array para guardar os números digitados
• Uma variável temporária para guardar o que a pessoa digitar no teclado.
• Uma variável temporária para guardar o número convertido para Float.

A declaração das variáveis fica assim:

# Vamos definir as variáveis "gavetas" que o programa vai precisar
# Vamos iniciar as variáveis com valores padrão (0, 0.0 e nil) para evitar erros

quantidade_numeros = 0 # Vai guardar quantos números a pessoa  quer somar
soma = 0.0              # Vai guardar a soma dos números
numeros_digitados = [] # Vai guardar os números digitados pela pessoa
entrada_digitada = nil # Vai guardar o que a pessoa digitou no teclado
numero_convertido = 0.0 # Vai guardar o número convertido para float

Depois podemos usar um puts para apresentar o programa.

puts "Programa que soma N números definidos por você."

Agora precisamos fazer duas coisas:

• Descobrir quantos números a pessoa quer somar
• Validar o que foi digitado pela pessoa

Queremos que a pessoa informe nesse primeiro momento quantos números ela quer somar, então:

• A quantidade de números a serem somados é um valor inteiro, pois não se pode somar 1,5 ou 3,4 números. Podemos somar 2 números, 3, 4, 5 e assim por diante.
• Quando fazemos a pergunta “quantos números você deseja somar?” não podemos aceitar valores como -5, -2 ou 0. Não temos como somar um número negativo de vezes e também não temos como somar 0 vezes, isso é o mesmo que não somar.
• Também não podemos aceitar o número 1. Somar um número vai dar ele mesmo, se perguntamos a pessoa quantos números ela quer somar e ela responder 1 vamos somar esse número com o quê? Com nada, então a resposta será esse próprio número. Não tem motivo para essa operação ser feita, então devemos impedir essa entrada.
• O valor mínimo para a quantidade de números que podem ser somados tem que ser 2, pois para fazer uma soma precisamos de pelo menos dois números.
• Além disso, devemos verificar se a pessoa digitou números mesmo e caso tenha digitado letras ou outros símbolos devemos impedir o avanço do programa até ela digitar um número válido.

Como vamos fazer isso? Vamos usar uma estratégia de forma que o programa não aceita avançar até que a pessoa coloque um número válido.

Vamos criar um ciclo infinito, de forma que o único jeito de sair dele é encontrar o comando break.

Dentro desse ciclo infinito vamos usar gets.chomp para o programa pausar e esperar a pessoa digitar. O .chomp é essencial para limpar o caractere Enter (nova linha) que vem junto com a digitação.

Para implementar essa estratégia de “não deixar passar até acertar”, vamos usar o bloco de tratamento de erros do Ruby. Pense nele como uma rede de segurança: nós tentamos (begin) converter o que a pessoa digitou para um número inteiro. Se a pessoa tiver digitado letras (como “dez” ou “abc”), o Ruby vai gerar um erro chamado ArgumentError. Em vez de o programa travar e fechar na cara da pessoa, nós resgatamos (rescue) esse erro e mostramos uma mensagem amigável.

O código para essa parte fica assim:

loop do
  print "Quantos números você quer somar? "
  begin
    entrada_digitada = gets.chomp
    # Tentamos converter o texto para um Inteiro estrito.
    # Se tiver letras, o comando Integer() grita um erro!
    quantidade_numeros = Integer(entrada_digitada)

    # Se a conversão funcionou, o código chega aqui.
    # Agora verificamos a regra de negócio: precisa ser pelo menos 2.
    if quantidade_numeros < 2
      puts "A quantidade de números deve ser pelo menos 2. Tente novamente."
    else
      # Se passou na conversão E passou na verificação de valor,
      # podemos quebrar o ciclo infinito e avançar.
      break
    end
  rescue ArgumentError
    # Se o Integer() falhou lá em cima, o código pula direto para cá.
    puts "Entrada inválida. Por favor, digite um número inteiro positivo (ex: 3)."
  end
end

Neste ponto, já garantimos que a variável quantidade_numeros tem um valor válido (por exemplo, 3). Agora precisamos pedir os números propriamente ditos que a pessoa quer somar.

Para isso, não vamos usar um while manual. O Ruby tem um jeito muito elegante de dizer “faça isso X vezes”: o método .times. Como a nossa variável quantidade_numeros é um número inteiro, ela “sabe” como repetir algo.

Dentro dessa repetição, precisaremos de outro ciclo de validação. Por que? Imagine que a pessoa disse que quer somar 5 números. Ela digita o primeiro, o segundo… e no terceiro ela digita “banana” sem querer. Não queremos que o programa volte lá para o início, queremos apenas que ele insista: “Ei, digite o 3º número corretamente”.

Além disso, para os números da soma, vamos aceitar números quebrados (com ponto), então usaremos Float() em vez de Integer() na conversão. E não esqueça: precisamos guardar cada número válido no nosso array numeros_digitados e somá-lo na variável soma.

Veja como fica essa lógica traduzida para código:

puts "Você quer somar #{quantidade_numeros} números."

# O |i| é o contador automático. Ele começa valendo 0.
quantidade_numeros.times do |i|
  loop do
    # Usamos (i + 1) para mostrar "1º número" em vez de "0º número"
    print "Digite o #{i + 1}º número para somar: "
    begin
      entrada_digitada = gets.chomp
      
      # Convertendo para Float para aceitar decimais (ex: 10.5)
      numero_convertido = Float(entrada_digitada)
      
      # Se chegou aqui, o número é válido! Vamos guardar nas gavetas.
      
      # 1. Guarda na lista para mostrar no final
      numeros_digitados << numero_convertido 
      
      # 2. Acumula no valor total
      soma += numero_convertido 
      
      # Pronto, pegamos esse número. Podemos sair do loop de validação
      # e deixar o.times ir para a próxima repetição.
      break 
    rescue ArgumentError
      puts "Entrada inválida. Digite um número válido (ex: 10, 4.5, -2)."
    end
  end
end

Agora que o laço .times terminou, significa que todos os números foram pedidos, validados, guardados e somados. As nossas variáveis estão cheias com as informações corretas.

A última etapa é apenas exibir o resultado. Para mostrar a lista de números que a pessoa digitou, o nosso array numeros_digitados precisa virar um texto bonito. O método .join("\n") faz exatamente isso: ele pega cada item da lista e cola um no outro usando uma “nova linha” (\n) como cola.

E para mostrar a soma, usamos a interpolação #{soma} dentro da string, o que evita termos que ficar convertendo tipos manualmente.

# Mostrando o resultado final

puts "Você digitou #{quantidade_numeros} números. São eles:\n#{numeros_digitados.join("\n")}."
puts "A soma dos números que você digitou é: #{soma}."
puts "Obrigado por usar o programa de soma!"

O código completo do programa fica assim:

# Vamos definir as variáveis "gavetas" que o programa vai precisar
# Vamos iniciar as variáveis com valores padrão (0, 0.0 e nil) para evitar erros

quantidade_numeros = 0 # Vai guardar quantos números a pessoa  quer somar
soma = 0.0              # Vai guardar a soma dos números
numeros_digitados = [] # Vai guardar os números digitados pela pessoa
entrada_digitada = nil # Vai guardar o que a pessoa digitou no teclado
numero_convertido = 0.0 # Vai guardar o número convertido para float

puts "Programa que soma N números definidos por você."

# Descobrindo quantos números a pessoa quer somar

loop do
  print "Quantos números você quer somar? "
  begin
    entrada_digitada = gets.chomp
    quantidade_numeros = Integer(entrada_digitada)
    if quantidade_numeros < 2
      puts "A quantidade de números a serem somados deve ser pelo menos 2 e devem ser números inteiros positivos, por exemplo: 3. Tente novamente."
    else
      break
    end
  rescue ArgumentError
    puts "Entrada inválida. Por favor, digite um número inteiro positivo. Exemplo: 3"
  end
end

# Pedindo os números para a pessoa e somando

puts "Você quer somar #{quantidade_numeros} números."

quantidade_numeros.times do |i|
  loop do
    print "Digite o #{i + 1}º número para somar: "
    begin
      entrada_digitada = gets.chomp
      numero_convertido = Float(entrada_digitada)
      numeros_digitados << numero_convertido
      soma += numero_convertido
      break
    rescue ArgumentError
      puts "Entrada inválida. Por favor, digite um número válido. Exemplos: 10, 4.5, -3.2, 200"
    end
  end
end

# Mostrando o resultado final para a pessoa

puts "Você digitou #{quantidade_numeros} números. São eles:\n#{numeros_digitados.join("\n")}."
puts "A soma dos números que você digitou é: #{soma}."
puts "Obrigado por usar o programa de soma!"

Programa que exibe a sequência de Fibonacci

O objetivo deste programa é gerar a Sequência de Fibonacci e exibir a quantidade de termos da sequência que a pessoa digitar. Ou seja, se a pessoa disser que quer visualizar 10 termos o programa deve mostrar os 10 primeiros números da sequência de Fibonacci.

Na matemática, essa sequência começa geralmente com 0 e 1, e cada número seguinte é a soma dos dois anteriores.

Exemplo da sequência: 0, 1, 1, 2, 3, 5, 8…

Porque:

• 0 + 1 = 1,
• 1 + 1 = 2,
• 1 + 2 = 3,
• 3 + 2 = 5
• 5 + 3 = 8.

E assim por diante.

Como fazer?

Vamos dividir o problema em três partes:

• Parte 1: Preparação e Validação da Entrada
• Parte 2: Configuração das Variáveis da Sequência
• Parte 3: Cálculo e Exibição da sequência

Vamos começar a etapa 1 de preparação e validação da entrada criando a variável quantidade_de_termos e atribuindo a ela o valor nil (nulo/vazio). Isso será feito porque precisamos que ela exista e esteja vazia para que a condição do while (que vamos criar depois) seja verdadeira na primeira vez que o programa rodar.

quantidade_de_termos = nil

Agora vamos mostrar a pessoa o título do programa:

puts "Programa para exibir a sequência de Fibonacci"

Agora o que vamos fazer é criar um laço de repetição que só para quando a pessoa digitar um número válido. Se ela digitar algo errado, a variável continua nil e o loop se repete.

Vamos usar o while que significa “enquanto”, pois queremos que enquanto a quantidade de termos (números) que a pessoa deseja visualizar for nula, o programa faça alguma coisa.

O while vai começar perguntando: a quantidade de termos é nula?

while quantidade_de_termos.nil?

Dentro do while vamos incluir:

• print: Para mostrar a pergunta na tela sem pular linha, assim a resposta vai ser digitada ao lado da pergunta.
• quantidade_de_termos =: É a variável que vai receber o número que a pessoa digitar.
• Integer(...): Para transformar o texto digitado em um Número Inteiro antes de armazenar na variável.
• gets.chomp: Para pegar o que a pessoa digitou e remover o “Enter” final.
• rescue nil: Se o Integer falhar (porque a pessoa digitou texto ao invés de números como “dez” ou “abc”), o comando normalmente daria erro e fecharia o programa. O rescue nil age nesse momento e se der erro, ele captura o erro e no lugar de fechar o programa ele devolve nil para ser colocado na variável.

Então a variável quantidade_de_termos deve receber o que a pessoa digitar (através do gets.chomp), esse conteúdo digitado deve ser convertido para um número inteiro antes de ser passado para a variável (pelo Integer(...)) e se o Integer(...) não conseguir converter o conteúdo digitado para inteiro o rescue vai passar o valor nil para a variável ao invés de só dar erro e encerrar o programa.

O código ficará assim:

print "Quantos números da sequência de Fibonacci você deseja ver? "
quantidade_de_termos = Integer(gets.chomp) rescue nil

Depois disso, vamos adicionar um if para avaliar se a conversão falhou (e virou nil), se sim avisamos para a pessoa.

Para encerrar essa parte colocamos um end para fechar o while. Se a pessoa digitou um número correto, quantidade_de_termos passa a ter um valor válido (exemplo: 5), o while percebe que não é mais nil e libera o programa para seguir em frente.

O código fica assim:

  if quantidade_de_termos.nil?
    puts "Erro: Por favor, digite um número inteiro válido."
  end
end

Agora vamos configurar as variáveis que serão usadas para calcular a sequência de Fibonacci propriamente dita.

Vamos usar:

• termo_anterior = 0
• termo_atual = 1
• i = 1

Mas, por que esses valores de inicialização para as variáveis?

A Sequência de Fibonacci funciona com uma regra simples: o próximo número é a soma dos dois anteriores. Para a matemática começar a funcionar, você precisa de dois números “semente” (o pontapé inicial). A sequência clássica começa assim: 0, 1, 1, 2, 3...

Se olharmos para as variáveis antes do laço de repetição começar:

• termo_anterior = 0 Representa o primeiro número da sequência.
• termo_atual = 1 Representa o segundo número da sequência.

O que aconteceria se termo_atual fosse 0? O cálculo seria: 0 (anterior) + 0 (atual) = 0 (próximo) O programa ficaria preso em zeros eternamente (0, 0, 0, 0…), porque 0 + 0 nunca vai dar outro resultado. Precisamos desse 1 para fazer a soma começar a crescer.

Já a variável i é o nosso contador, ela vai controlar quantas vezes vamos repetir o código.

Imagine que a pessoa pediu para ver 3 termos (quantidade_de_termos = 3).

A condição do nosso while é: enquanto i <= quantidade_de_termos

Então para atender essa condição qual valor precisamos inicializar i? Vamos testar…

• Se a gente iniciar i = 0 então:

Volta 1 do laço de repetição: i vale 0. (0 <= 3? Sim).

Volta 2 do laço de repetição: i vale 1. (1 <= 3? Sim).

Volta 3 do laço de repetição: i vale 2. (2 <= 3? Sim).

Volta 4 do laço de repetição: i vale 3. (3 <= 3? Sim).

Resultado: Mostrou 4 vezes, isso estaria errado, porque deveria exibir três vezes conforme o solicitado pela pessoa. Aqui teria mostrado um número a mais do que a pessoa pediu.

• Se a gente iniciar i = 1 então:

Volta 1 do laço de repetição: i vale 1. (1 <= 3? Sim. Mostra o 1º termo).

Volta 2 do laço de repetição: i vale 2. (2 <= 3? Sim. Mostra o 2º termo).

Volta 3 do laço de repetição: i vale 3. (3 <= 3? Sim. Mostra o 3º termo).

Volta 4 do laço de repetição: i vale 4. (4 <= 3? Não. Para de mostrar).

Resultado: Mostrou 3 vezes. Correto, é o número de termos que a pessoa pediu para ver.

Por isso, precisamos iniciar o i com 1.

Depois de inicializar as variáveis do cálculo, vamos mostrar um cabeçalho bonito, pulando uma linha (\n) antes de mostrar a sequência Fibonacci.

termo_anterior = 0
termo_atual = 1
i = 1 # Variável de controle para contar os termos exibidos

puts "\nSequência de Fibonacci (Exibindo #{quantidade_de_termos} termos):"

Agora vamos calcular a sequência enquanto o contador i for menor ou igual ao número que a pessoa pediu. Exemplo: Se a pessoa pediu 5 termos, o laço vai rodar quando i for 1, 2, 3, 4 e 5. Quando i for 6, ele para.

Precisamos ter bastante atenção neste cálculo, pois devido ao fato de fazermos a passagem dos valores por mais de uma variável pode ficar um pouco confuso.

Vamos lá…

Além das variáveis:

• termo_anterior, que inicializamos com 0, que servirá para guardar o número anterior da sequência.
• termo_atual, que inicializamos com 1, que servirá para guardar o número atual da sequência.
• i, que inicializamos com 1, que será o contador que garante que o laço de repetição não seja executado infinitamente.

Também vamos precisar da variável:

• proximo_termo, que vamos usar para calcular o próximo número (que será a soma dos dois anteriores).

Com essas variáveis o passo a passo do laço de repetição será:

1. Mostrar o número que está em termo_anterior.
2. Calcular o próximo termo
3. Atualizar os valores das variáveis
4. Incrementar o contador i para o laço de repetição avançar

O laço de repetição usado será um while para repetir até mostrar a quantidade de termos que a pessoa pediu, ou seja até que i <= quantidade_de_termos.

Com termo_anterior = 0 e termo_atual = 1 no início do while acontecerá o seguinte:

• mostra o valor de termo_anterior.
  • Na primeira vez 0, porque é o valor que iniciamos a variável.
• Depois vamos calcular o próximo termo que será proximo_termo = termo_anterior + termo_atual.
  • Na primeira vez proximo_termo = 0 + 1, ou seja, 1 porque termo_anterior neste momento é 0 e termo_atual é 1.
• Depois vamos atualizar os valores das variáveis termo_anterior passa a ser o antigo termo_atual e o termo_atual passa a ser o proximo_termo.
  • Então agora temos termo_anterior = 1 e termo_atual = 1.
• Depois precisamos incrementar o contador, para o laço de repetição avançar e não ficar se repetindo para sempre.
  • Então precisamos fazer i += 1.
• Na próxima execução do while ele vai mostrar no terminal o novo valor de termo_anterior.
  • Que agora é 1.
• Vai calcular o próximo termo que será proximo_termo = termo_anterior + termo_atual.
  • Agora 1 + 1 = 2 então o próximo termo será 2.
• Depois o laço vai atualizar as variáveis.
  • Agora termo_anterior = 1, termo_atual = 2.
• Depois ele vai incrementar o i mais uma vez para o laço ser executado novamente.

E assim, ele vai repetir esse processo até que o valor de i seja igual a quantidade de termos que a pessoa pediu para ver.

O código desse trecho ficará assim:

while i <= quantidade_de_termos
  print "\n#{termo_anterior}"

  proximo_termo = termo_anterior + termo_atual
  termo_anterior = termo_atual
  termo_atual = proximo_termo

  i += 1
end

O programa completo ficará assim:

quantidade_de_termos = nil

# Título do programa
puts "Programa para exibir a sequência de Fibonacci"

# Estrutura de repetição para garantir uma entrada válida
while quantidade_de_termos.nil?
  print "Quantos números da sequência de Fibonacci você deseja ver? "

  # Uso do rescue na mesma linha para retornar nil em caso de erro
  quantidade_de_termos = Integer(gets.chomp) rescue nil

  if quantidade_de_termos.nil?
    puts "Erro: Por favor, digite um número inteiro válido."
  end
end

termo_anterior = 0
termo_atual = 1
i = 1 # Variável de controle para contar os termos exibidos

puts "\nSequência de Fibonacci (Exibindo #{quantidade_de_termos} termos):"

while i <= quantidade_de_termos
  print "\n#{termo_anterior}"

  proximo_termo = termo_anterior + termo_atual
  termo_anterior = termo_atual
  termo_atual = proximo_termo

  i += 1
end

puts "\n\nFim do programa."

Programa que gera um número aleatório e pede para a pessoa adivinhar qual é

O computador vai “escolher” um número aleatório, de 1 a 10 e a pessoa vai tentar descobrir qual é. O programa não pode parar (fechar) até que a pessoa acerte. Se a pessoa errar, o programa deve pedir para ela tentar outra vez digitando outro número.

Lembre-se de impedir que o programa processe letras, números decimais ou qualquer coisa que não seja um número inteiro.

Como fazer?

Vamos começar criando uma variável chamada numero_secreto para receber o número gerado aleatoriamente. Mas, como vamos gerar esse número aleatório? Vamos usar rand(1..10) que significa: “sorteie um número dentro desse intervalo entre 1 e 10”.

Exemplo: pode sair 3, ou 7, ou 10… cada execução pode sortear um número diferente.

Então:

numero_secreto = rand(1..10)

Quer dizer “faça o sorteio de um número aleatório dentro do intervalo entre 1 e 10 e depois coloque esse número dentro da variável numero_secreto”.

Depois vamos criar a variável palpite e iniciar ela com valor 0.

Após a criação das variáveis vamos exibir mensagens para a pessoa com o nome do programa e a orientação do que ela deve fazer.

puts "Programa de Adivinhação de Números"
puts "Tente adivinhar o número secreto entre 1 e 10."

Agora enquanto o número informado pela pessoa for diferente do número armazenado na variável numero_secreto (o número sorteado), o programa deverá continuar executando o bloco de código responsável por solicitar novas tentativas de adivinhação a pessoa.

Para isso vamos usar o while:

while palpite != numero_secreto
  ...
end

Aqui estamos dizendo isso, enquanto o valor do palpite for diferente do número secreto, repita a execução do bloco.

Ou seja:

• Se a pessoa errar, o programa continua pedindo outro palpite.
• Só vai parar de pedir quando o palpite == numero_secreto (quando a pessoa acertar).

Dentro do while primeiro vamos colocar um print pedindo o palpite:

print "Digite seu palpite: "

Depois vamos ler a entrada digitada pela pessoa, remover a quebra de linha ao final e tentar convertê-la em um número inteiro.

Se a pessoa digitar um número válido, ele será convertido, mas se a entrada digitada não for um número, ocorre erro e por isso o rescue nil deve ser usado, pois ao invés de interromper o programa, retorna-se nil em caso de erro na conversão.

Colocaremos o valor que foi pego da entrada na variável palpite:

palpite = Integer (gets.chomp) rescue nil

Vamos comparar valores, mas antes precisamos validar a entrada para evitar cálculos com dados não numéricos. Se a entrada for inválida, o bloco rescue transforma o valor em nil, e é preciso checar se esse valor é nulo antes de continuar.

if palpite.nil?
  puts "Por favor, insira um número válido."
  next
end

Aqui palpite.nil? pergunta: “o palpite é nil?” Se for nil, significa que a pessoa digitou algo que não virou número então mostramos a mensagem informando o erro.

O next dentro do while é usado para fazer o inverso do comando break, se nós usamos o comando break para parar a execução imediatamente, o next é usado para interromper a atividade atual e iniciar a próxima atividade imediatamente no laço de repetição.

É como dizer: “Não é o resultado esperado, então interrompa e siga para o próximo comando no loop.”

Neste caso, o próximo comando será pedir o palpite de novo.

Agora temos que verificar se o palpite digitado pela pessoa está no intervalo entre os números 1 e 10. Precisamos garantir que o palpite não seja ≤ 0 (o, -1, -2, -3 e assim por diante nos números negativos), ele também não pode ser > 10 (11, 12, 13 e assim por diante).

Para garantir que o palpite vai estar entre 1 e 10 (que é o que queremos) vamos fazer:

if palpite <= 0 || palpite > 10
  puts "Seu palpite deve estar entre o número 1 e o número 10."
  next
end

Assim, estamos dizendo que se o palpite for menor ou igual a 0 OU maior que 10, ele é inválido e não pode ser aceito. Com o palpite inválido nós mostramos a mensagem:

puts "Seu palpite deve estar entre o número 1 e o número 10."

E usamos o next para pular as próximas etapas e pedir outro palpite de novo.

Agora que validamos o palpite chegou a hora de comparar ele com o número secreto. Como vamos fazer isso? Vamos verificar se ele é menor ou maior e se ele não for menor nem maior só poderá ser igual.

• Se o palpite for menor que o número secreto, precisamos dizer a pessoa que o número escolhido por ela é muito baixo e que ela precisa tentar de novo.
• Se o palpite for maior que o número secreto, precisamos dizer a pessoa que o número escolhido por ela é muito alto e que ela precisa tentar de novo.
• Se o palpite não for menor e também não for maior ele só poderá ser igual ao número secreto. Então isso significa que a pessoa vai ter acertado o número secreto, que seu palpite estava correto. Nesse caso precisamos exibir uma mensagem de parabéns.

Vamos fazer isso dessa forma:

if palpite < numero_secreto
  puts "Muito baixo! Tente novamente."
elsif palpite > numero_secreto
  puts "Muito alto! Tente novamente."
else
  puts "Parabéns! Você adivinhou o número secreto #{numero_secreto}!"
end

Nós começamos escolhendo as dicas:

• Se palpite < numero_secreto: isso quer dizer que a pessoa chutou um número menor do que o secreto então o programa diz: “Muito baixo!” para ela saber que o número que ela escolheu é menor que o número secreto.
• elsif palpite > numero_secreto: senão, se o número escolhido pela pessoa for maior que o número secreto então o programa diz: “Muito alto!” para ela saber disso.
• else: ou seja, se não é menor e não é maior, então só pode ser igual, logo a pessoa acertou o número. Neste caso, devemos imprimir parabéns e exibir o número. Por isso usamos #{numero_secreto} para inserir o número secreto na mensagem de parabéns.

Quando a pessoa acerta o número, o valor de palpite passa a ser exatamente igual ao numero_secreto.

O while só continua rodando (executando) enquanto os dois forem diferentes (palpite != numero_secreto). Então, no momento em que eles ficam iguais, essa condição deixa de ser verdadeira.

Em outras palavras: o laço existe para repetir o jogo até a pessoa acertar. Assim que acerta, a condição falha e o while simplesmente para de executar.

Assim o programa termina.

O programa completo fica assim:

numero_secreto = rand(1..10)
palpite = 0

puts "Programa de Adivinhação de Números"
puts "Tente adivinhar o número secreto entre 1 e 10."

# enquanto o palpite for diferente do número secredo

while palpite != numero_secreto
  print "Digite seu palpite: "
  palpite = Integer (gets.chomp) rescue nil

  if palpite.nil?
    puts "Por favor, insira um número válido."
    next
  end

  if palpite <= 0 || palpite > 10
    puts "Seu palpite deve estar entre o número 1 e o número 10."
    next
  end

  if palpite < numero_secreto
    puts "Muito baixo! Tente novamente."
  elsif palpite > numero_secreto
    puts "Muito alto! Tente novamente."
  else
    puts "Parabéns! Você adivinhou o número secreto #{numero_secreto}!"
  end
end

Nível Avançado

Os exercícios avançados exigem pensar no programa como um sistema completo, com menus interativos, validação rigorosa de entradas, ciclos de repetição com múltiplas condições de saída e estruturas de dados como arrays e hashes. O foco é integrar todos os recursos anteriores em programas mais robustos e próximos de aplicações reais.

Programa que converte dias, horas e minutos em segundos

Escreva um programa que recebe:

• Uma quantidade de dias (entre 1 e 365)
• Ou uma quantidade de horas (podem ser ilimitadas, mas não zero ou negativas)
• Ou uma quantidade de minutos (que também podem ser ilimitados, mas não zero ou negativos)

O programa deve identificar o que foi inserido, fazer a conversão e informar para a pessoa quantos segundos são equivalentes ao que item informado.

Como fazer?

A primeira etapa, como sempre, é apresentar o programa para as pessoas e dizer o que ele faz:

puts "Programa que converte dias, horas ou minutos em segundos."

Depois vamos usar um:

loop do
  ...
  break if resposta == "n"
end

Por que usar isso? Imagine que nós queremos converter dias em segundos; depois, minutos em segundos; em seguida, horas em segundos. Para garantir que o programa continue perguntando se a pessoa deseja fazer novas conversões e repita esse processo enquanto ela quiser, precisamos desse recurso.

Depois vamos criar o menu de opções, para isso precisamos de uma variável:

  # Menu de opções
  opcao = nil

Fazemos isso para que o while da próxima linha funcione na primeira vez.

Depois vamos inserir:

  while opcao.nil? || ![1, 2, 3].include?(opcao)

Essa linha quer dizer “enquanto a opção for nula (nil) OU não for 1, 2 ou 3, repita o bloco abaixo”.

Onde:

• opcao.nil? pergunta: “a opção está nula?”

• || representa o operador “ou”
• ![1, 2, 3].include?(opcao) pergunta: “a opção digitada pela pessoa NÃO está na lista [1, 2, 3]?” O ! na frente inverte a resposta, pergunta se é diferente.

Esse é um recurso de segurança do menu: não deixa a opção passar enquanto não for válida, ou seja 1, 2 ou 3.

Depois colocamos um:

    puts ""

Que Imprime uma linha em branco na tela só para dar um espaçamento visual e deixar mais bonito.

Na sequência colocamos:

    puts "Escolha qual informação você deseja converter"
    puts "1 - Converter dias em segundos"
    puts "2 - Converter horas em segundos"
    puts "3 - Converter minutos em segundos"

Aqui mostramos o menu com as 3 opções. Cada puts escreve uma linha na tela para que as opções fiquem uma abaixo da outra.

Depois colocamos:

    print "Digite sua opção: "

Usamos print para mostrar a mensagem, mas não pular para a próxima linha. Assim o cursor fica ali do lado, esperando a pessoa digitar na mesma linha e a resposta dela vai ficar ao lado da pergunta.

O próximo passo é incluir:

opcao = Integer(gets.chomp) rescue nil

Onde:

1. gets pega o que a pessoa digitou no teclado (incluindo o Enter)
2. .chomp tira o Enter do final
3. Integer(...) tenta converter o texto em número inteiro. Se a pessoa digitou “2”, vira o número 2
4. rescue nil é usado se der erro (exemplo: a pessoa digitou “banana”, que não é número), em vez de o programa quebrar e dar erro, ele coloca nil (nada) na variável, assim a opção será nula e o while, que verifica isso, vai pedir para ela digitar uma opção válida.

Depois criamos um:

    if opcao.nil? || ![1, 2, 3].include?(opcao)
      puts "Opção inválida! Escolha 1, 2 ou 3."
      opcao = nil
    end

Para verifica se a opção é inválida (mesma verificação do while). Se for:

• Avisa a pessoa que sim a opção é inválida
• Coloca nil na opcao de novo, para garantir que o while vai repetir

Já o end fecha o if.

Na próxima linha usaremos um end para fechar o while do menu. Se a opção foi válida, o programa segue em frente. Se não foi , volta para pedir a pessoa para digitar uma opção que seja.

Continuando vamos usar um case para analisar o valor da variável opcao e escolher qual caminho seguir.

# Entrada do valor conforme a opção escolhida
  case opcao

Quando a opção for 1 o case entra no bloco de conversão de dias.

Dentro desse bloco será criada uma variável chamada valor começando com nil (nulo), igual fizemos com a variável opcao.

  when 1
    valor = nil

Isso é feito para a variável ser usada em um while  logo abaixo.

O while será esse:

while valor.nil? || valor < 1 || valor > 365

Ou seja, estamos dizendo que “enquanto o valor for nulo (nada), OU menor que 1, OU maior que 365, repita o bloco para pedir a quantidade de dias para a pessoa.” Só será aceito um valor de dias entre 1 e 365 (os dias de um ano).

Usaremos:

print "Digite quantos dias você deseja converter para segundos: "

Para pedir o valor a pessoa, com o cursor na mesma linha que a pergunta.

E, usaremos:

valor = Float(gets.chomp) rescue nil

Para analisar o que foi digitado, limpar, verificar se é válido para colocar na variável valor. A diferença é que Float aceita números decimais como 1.5 (um dia e meio). Se a pessoa digitar algo inválido será transformado em nil (nulo).

Depois faremos um if para caso o valor não passar na validação, avisar a pessoa. Assim, o while vai repetir e pedir de novo para a pessoa digitar a quantidade de dias que ela quer converter.

Ele ficará assim:

      if valor.nil? || valor < 1 || valor > 365
        puts "Essa quantidade de dias é inválida! Por favor, insira um número entre 1 e 365."
      end

Depois usaremos um end para fechar o while da validação de dias.

O próximo passo é fazer a conta: dias × 24 horas × 60 minutos × 60 segundos.

segundos = (valor * 24 * 60 * 60).round

O .round arredonda o resultado para um número inteiro (exemplo: 129600.0 vira 129600), porque não faz sentido ter “meio segundo” aqui.

O próximo passo é mostrar o resultado.

puts "#{valor} dia(s) equivalem a #{segundos} segundos."

Assim encerramos o que acontece quando a opção for 1.

Quando a opção for 2 o case entra no bloco de conversão de horas.

Aqui seguiremos a mesma lógica dos dias (que criamos no caso 1), mas aqui o valor só precisa ser maior que zero. Pode ser qualquer número positivo, sem limite.

Então vamos colocar a variável valor como nula e configurar nosso while como:

    valor = nil

    while valor.nil? || valor <= 0

Depois colocaremos:

      print "Digite a quantidade de horas: "
      valor = Float(gets.chomp) rescue nil

      if valor.nil? || valor <= 0
        puts "Essa quantidade de horas é inválida! Por favor, insira um número maior que zero."
      end

Para pedir, converter e validar o valor seguindo a mesma estrutura que criamos no caso dos dias.

Usamos end para fechar o while das horas.

Na sequência fazemos o cálculo:

segundos = (valor * 60 * 60).round

Aqui, usamos Horas × 60 minutos × 60 segundos. Não precisamos multiplicar por 24 porque já estamos em horas.

No final usamos:

puts "#{valor} hora(s) equivalem a #{segundos} segundos."

Para mostrar o resultado e encerramos o caso 2.

Quando a opção for 3 o case entra no bloco de conversão de minutos.

Vamos usar:

    valor = nil

    while valor.nil? || valor <= 0
      print "Digite a quantidade de minutos: "
      valor = Float(gets.chomp) rescue nil

      if valor.nil? || valor <= 0
        puts "Essa quantidade de minutos é inválida! Por favor, insira um número maior que zero."
      end
    end

Que é uma estrutura semelhante as anteriores para pedir, converter, validar e repetir se for necessário.

Depois vamos fazer o cálculo de minutos × 60 segundos. Só uma multiplicação, porque minuto já está a um passo de segundo.

Será assim:

segundos = (valor * 60).round

Na sequência exibimos o resultado:

puts "#{valor} minuto(s) equivalem a #{segundos} segundos."

E, fechamos o case com end. O programa já fez a conversão e agora segue em frente.

Na sequência vamos colocar um:

  puts ""

Apenas para dar um espaço visual na resposta.

Depois, vamos criar uma variável chamada resposta iniciada com nil (nulo) para o próximo while que vamos fazer funcionar.

resposta = nil

Esse próximo while será assim:

  while resposta != "s" && resposta != "n"
    print "Deseja fazer outra conversão? (s para sim ou n para não): "
    resposta = gets.chomp.downcase

    if resposta != "s" && resposta != "n"
      puts "Resposta inválida! Por favor, digite 's' para sim ou 'n' para não."
    end
  end

Ou seja, enquanto a resposta for diferente de sim (!= "s") e de não (!= "n") vai mostrar a mensagem: "Resposta inválida! Por favor, digite 's' para sim ou 'n' para não." e depois vai perguntar se a pessoa deseja fazer outra conversão e ler a resposta novamente.

Daí é só colocar um break para o programa encerrar se resposta == “n”, encerrar o loop com end e colocar uma mensagem de fim do programa.

Vai ficar assim:

 break if resposta == "n"
end

puts "Programa encerrado. Até a próxima!"

O código completo fica assim:

puts "Programa que converte dias, horas ou minutos em segundos."

loop do
  # Menu de opções
  opcao = nil

  while opcao.nil? || ![1, 2, 3].include?(opcao)
    puts ""
    puts "Escolha qual informação você deseja converter"
    puts "1 - Converter dias em segundos"
    puts "2 - Converter horas em segundos"
    puts "3 - Converter minutos em segundos"
    print "Digite sua opção: "

    opcao = Integer(gets.chomp) rescue nil

    if opcao.nil? || ![1, 2, 3].include?(opcao)
      puts "Opção inválida! Escolha 1, 2 ou 3."
      opcao = nil
    end
  end

  # Entrada do valor conforme a opção escolhida
  case opcao
  when 1
    valor = nil

    while valor.nil? || valor < 1 || valor > 365
      print "Digite quantos dias você deseja converter para segundos: "
      valor = Float(gets.chomp) rescue nil

      if valor.nil? || valor < 1 || valor > 365
        puts "Essa quantidade de dias é inválida! Por favor, insira um número entre 1 e 365."
      end
    end

    segundos = (valor * 24 * 60 * 60).round
    puts "#{valor} dia(s) equivalem a #{segundos} segundos."
  when 2
    valor = nil

    while valor.nil? || valor <= 0
      print "Digite a quantidade de horas: "
      valor = Float(gets.chomp) rescue nil

      if valor.nil? || valor <= 0
        puts "Essa quantidade de horas é inválida! Por favor, insira um número maior que zero."
      end
    end

    segundos = (valor * 60 * 60).round
    puts "#{valor} hora(s) equivalem a #{segundos} segundos."
  when 3
    valor = nil

    while valor.nil? || valor <= 0
      print "Digite a quantidade de minutos: "
      valor = Float(gets.chomp) rescue nil

      if valor.nil? || valor <= 0
        puts "Essa quantidade de minutos é inválida! Por favor, insira um número maior que zero."
      end
    end

    segundos = (valor * 60).round
    puts "#{valor} minuto(s) equivalem a #{segundos} segundos."
  end

  # Pergunta se deseja continuar
  puts ""
  resposta = nil

  while resposta != "s" && resposta != "n"
    print "Deseja fazer outra conversão? (s para sim ou n para não): "
    resposta = gets.chomp.downcase

    if resposta != "s" && resposta != "n"
      puts "Resposta inválida! Por favor, digite 's' para sim ou 'n' para não."
    end
  end

  break if resposta == "n"
end

puts "Programa encerrado. Até a próxima!"

Programa para cadastrar pessoas

Crie um pequeno sistema para cadastrar pessoas com nome, idade. Guarde as informações em um array de hashes. Após os cadastros, mostre a lista completa.

Exemplo:

[{ nome: "João", idade: 20 }, { nome: "Ana", idade: 25 }]

Como fazer?

Vamos começar criando um array chamado pessoas, lembrando que um array é uma lista que segue uma ordem. Imagine ele como se fosse uma caixa vazia onde vamos guardar fichas de cadastro. Cada ficha terá o nome e a idade de uma pessoa. Por enquanto, a caixa está vazia.

Vamos também apresentar o programa e deixar uma linha em branco antes de pedir os dados para cadastrar.

pessoas = []  # Array que vai guardar os dados

puts "Programa para cadastrar pessoas"
puts ""

Agora, como o texto não deu detalhes de como quer que o sistema seja criado, existem várias formas de continuar o programa:

• Podemos perguntar quantas pessoas serão cadastradas e executar um laço de repetição, como o times ou for, para pedir os dados até chegar no total de pessoas.
• Podemos definir um número máximo de pessoas que poderão ser cadastradas e impedir que o sistema cadastre novas pessoas quando atingir este número.
• Podemos assumir que não sabemos o número de pessoas que devem ser cadastradas e deixar o sistema fazer cadastros até que quem esteja cadastrando digite algo como ‘sair’, assim podemos usar laços como o loop ou while para controlar o fluxo.

Nesses casos nós não vamos pela implementação ou código mais simples, vamos pela alternativa que cobre o maior número de possibilidades. Então vamos assumir que não sabemos quantas pessoas serão cadastradas e vamos preparar o sistema para isso.

Vamos usar um loop infinito, que executará até que um break o interrompa com alguma condição.

Tudo que estiver entre loop do e o end correspondente será executado repetidamente. A palavra do marca o início do bloco.

Dentro desse loop vamos fazer tudo, pedir o nome, a idade, ler, validar, tratar erros e guardar o que estiver correto para exibir no final do programa.

loop do

end

Primeiramente vamos pedir o nome que será cadastrado, informar que a palavra ‘sair’ pode ser usada para encerrar o programa, ler a entrada digitada e definir o break com a condição de parada que encerrará o loop, neste caso a condição é a palavra ‘sair’ ser digitada.

  print "Digite o nome da pessoa (ou 'sair' para encerrar): "
  nome = gets.chomp rescue nil

  break if nome&.downcase == "sair"

Com break if nome&.downcase == "sair" estamos dizendo: se o nome, após ser convertido para minúsculas, for igual a "sair", interrompa o loop.

• Com nome&.downcase: O texto é convertido para letras minúsculas. Isso é muito bom porque assim o sistema vai aceitar, "SAIR", "Sair" ou "sAiR" não importa, todas as formas de escrever serão tratadas como "sair".
• Mas, e esse & em nome&.downcase o que é e o que ele faz?
  • Esse operador (&) é chamado de safe navigation operator (operador de navegação segura em Português). Ele funciona assim: “se o nome não for nil, converta ele para minúsculas; mas se o nome for nil, não faça nada e retorne nil”.
  • Tentar chamar o .downcase em alguma coisa que seja nil causaria um erro. Este operador vai a verificação antes e já evita que o erro aconteça.

Agora precisamos validar o nome. Não queremos aceitar nomes vazios, nomes que sejam só espaços em branco ou nomes que tenham apenas números. Afinal, ninguém se chama "123" ou " ", certo? Então precisamos evitar que nomes assim consigam avançar no nosso código.

Como fazemos isso? Assim:

  if nome.nil? || nome.strip.empty? || nome.delete("0-9 ").empty?
    puts "Nome inválido. Tente novamente."
    next
  end

O que estamos fazendo aqui?

Aqui testamos três condições com o operador ||, onde se alguma for verdadeira, o nome é inválido:

• nome.nil?: verifica se o nome é nil.
• nome.strip.empty?: O método strip elimina os espaços em branco do começo e do fim do texto. Em seguida, empty? verifica se, após essa remoção, o texto ainda está vazio. Dessa forma, se a pessoa digitar apenas espaços em branco, o método irá detectar.
• nome.delete("0-9 ").empty?: O método delete remove dígitos de 0 a 9 e espaços em branco do texto. Se o resultado for vazio, o que é verificado com o empty?, isso significa que o nome continha apenas números ou espaços, o que o tornam inválido.

Se o nome for inválido, exibimos uma mensagem para a pessoa e usamos next. O next é como dizer: “pule o resto deste ciclo e volte para o começo do loop”. Ou seja, o programa vai pedir o nome de novo sem continuar para a parte da idade.

Se o nome for válido, o programa continua e agora vamos pedir a idade:

  print "Digite a idade de #{nome}: "
  idade = Integer(gets.chomp) rescue nil

Usamos print novamente para que a pessoa digite na mesma linha da pergunta. Repare que usamos #{nome} dentro da string, isso é a interpolação de strings do Ruby, ela coloca o valor da variável nome diretamente no meio do texto.

Para ler a idade, usamos Integer(gets.chomp). O gets.chomp lê o que foi digitado e remove a quebra de linha, como já vimos. Mas dessa vez precisamos transformar esse texto em um número inteiro, porque a idade não é um texto, é um número. O método Integer() faz exatamente isso: tenta converter o texto para um número inteiro.

E se a pessoa digitar algo que não é um número, como "abc"? O Integer() vai dar erro. Mas como temos o rescue nil ali, em vez de o programa quebrar, ele simplesmente coloca nil na variável idade. Mesma lógica que usamos antes com o nome.

Agora vamos fazer as validações da idade:

  if idade.nil? || idade <= 0 || idade > 120
    puts "Idade inválida. Tente novamente."
    next
  end

Aqui também estamos fazendo três validações:

• idade.nil?: se a conversão falhou (a pessoa digitou algo que não é um número), idade será nil. Aqui estamos verificando isso.
• idade <= 0: idade precisa ser um número positivo. Ninguém tem 0 anos ou idade negativa, por isso precisamos fazer essa validação no nosso cadastro.
• idade > 120: aqui estamos colocando um limite máximo para a idade inserida, 120 é um limite razoável. Se alguém digitar 999 ou 5000, o sistema vai recusar.

Se qualquer uma dessas condições for verdadeira, o programa exibe a mensagem de erro e volta ao início do loop com o next, pedindo para inserir a idade novamente.

Se tudo estiver certo, tanto o nome quanto a idade, finalmente vamos guardar os dados:

  pessoas << { nome: nome, idade: idade }
  puts "#{nome} cadastrada com sucesso!"
  puts ""

Aqui estamos usando o operador << para adicionar ao final do array pessoas o hash: { nome: nome, idade: idade }.

Pensa assim: pessoas é uma caixa de sapatos (array) onde você guarda as fichas de cadastro com as informações das pessoas cadastradas. O operador << é o gesto de enfiar uma ficha nova dentro da caixa.

E a ficha nova é o hash: { nome: nome, idade: idade }. Um hash é como uma ficha de cadastro de verdade, ele guarda informações em pares de chave e valor. Aqui temos duas chaves:

• nome: com o valor sendo o nome que a pessoa digitou.
• idade: com o valor sendo a idade que a pessoa digitou.

Então, se cadastramos “Ana” com 25 anos, o array pessoas ficaria assim:

[{ nome: "Ana", idade: 25 }]

Se depois cadastramos “João” com 30 anos, o array pessoas ficaria assim:

[{ nome: "Ana", idade: 25 }, { nome: "João", idade: 30 }]

Cada hash é uma ficha, e o array é a caixa que guarda todas elas, em ordem.

Depois de guardar, exibimos uma mensagem de sucesso do cadastro e uma linha em branco para organizar visualmente a saída no terminal.

E o loop continua rodando, pedindo novos nomes e idades, até que a pessoa digite "sair".

Quando a palavra "sair" é digitada, o break interrompe o loop e o programa segue para a parte final: exibir todas as pessoas que foram cadastradas.

Usamos:

puts "\nPessoas cadastradas:"
pessoas.each_with_index do |pessoa, index|
  puts "#{index + 1}. #{pessoa[:nome]} - #{pessoa[:idade]} anos"
end

Onde:

O \n no início do puts adiciona uma linha em branco antes do título, só para deixar a saída mais organizada.

Depois usamos o método each_with_index. Ele percorre cada elemento do array pessoas e, para cada um, nos dá duas coisas:

pessoa: o hash com os dados da pessoa atual (por exemplo, { nome: "Ana", idade: 25 }).

index: a posição dessa pessoa no array, começando do 0 (0, 1, 2, 3, e assim por diante…).

Como listas para humanos costumam começar do 1 e não do 0, usamos index + 1 para exibir a numeração de forma mais natural.

Para acessar os valores dentro do hash, usamos pessoa[:nome] e pessoa[:idade]. Os dois pontos antes da palavra (:nome, :idade) indicam que estamos acessando uma chave do tipo símbolo (symbol) no hash.

Se cadastramos Ana (25 anos) e João (30 anos), a saída final será:

Pessoas cadastradas:
1. Ana - 25 anos
2. João - 30 anos

E assim o programa encerra, mostrando todos os cadastros feitos durante a execução.

O código completo fica assim:

pessoas = []  # Array que vai guardar os dados

puts "Programa para cadastrar pessoas"
puts ""

loop do
  print "Digite o nome da pessoa (ou 'sair' para encerrar): "
  nome = gets.chomp rescue nil

  break if nome&.downcase == "sair"

  if nome.nil? || nome.strip.empty? || nome.delete("0-9 ").empty?
    puts "Nome inválido. Tente novamente."
    next
  end

  print "Digite a idade de #{nome}: "
  idade = Integer(gets.chomp) rescue nil

  if idade.nil? || idade <= 0 || idade > 120
    puts "Idade inválida. Tente novamente."
    next
  end

  pessoas << { nome: nome, idade: idade }
  puts "#{nome} cadastrada com sucesso!"
  puts ""
end

puts "\nPessoas cadastradas:"
pessoas.each_with_index do |pessoa, index|
  puts "#{index + 1}. #{pessoa[:nome]} - #{pessoa[:idade]} anos"
end

Programa jogo da forca básico

O computador sorteia uma palavra de uma lista e exibe apenas traços no lugar de cada letra. A pessoa tenta adivinhar a palavra digitando uma letra por vez. O programa aceita apenas letras válidas, impede que a mesma letra seja tentada mais de uma vez e avisa quando a letra está ou não está na palavra.

A pessoa tem 6 tentativas. Quando restam 3 ou menos, uma dica é exibida. Ao final de cada rodada, o programa informa se a pessoa ganhou ou perdeu, exibe o placar e pergunta se ela quer jogar novamente.

Como fazer?

Vamos dividir o problema em quatro partes:

• Parte 1: Configuração inicial dos dados e variáveis do jogo
• Parte 2: O laço externo, que controla se a pessoa quer jogar mais uma rodada
• Parte 3: O laço interno, que é a rodada em si
• Parte 4: Encerramento e placar final

Parte 1: Configuração inicial

Começamos definindo a lista de palavras do jogo. Um array é ideal para isso:

palavras = ["abacaxi", "elefante", "programacao", "computador", "teclado", "borboleta", "chocolate", "universo"]

Note que todas as palavras estão em minúsculo e sem acentos. Isso facilita a comparação com as letras digitadas pela pessoa mais adiante, evitando problemas de acentuação.

Definimos o número máximo de tentativas em uma variável:

max_tentativas = 6

Usar uma variável em vez de escrever o número 6 diretamente no código é uma boa prática: se quisermos mudar o limite de tentativas no futuro, basta alterar em um único lugar.

Agora precisamos das dicas. Cada dica está associada a uma palavra específica, um relacionamento claro de chave e valor, ideal para um hash. Aqui usamos a notação com => (chamada de hash rocket) porque as chaves são strings:

dicas = {
  "abacaxi" => "É uma fruta tropical",
  "elefante" => "É o maior animal terrestre",
  "programacao" => "É o que estamos aprendendo agora",
  ...
}

A chave é a palavra e o valor é a dica correspondente. Para buscar a dica de uma palavra específica, usaremos dicas[palavra] mais adiante.

Por fim, inicializamos os contadores de placar e exibimos a mensagem de boas-vindas:

vitorias = 0
derrotas = 0

puts "Receba as boas-vindas do Jogo da Forca!"
puts "Tente adivinhar a palavra secreta antes de esgotar suas tentativas."

Parte 2: O laço externo

O laço externo controla se a pessoa quer jogar mais uma rodada. Usamos uma variável jogar iniciada como true para que o jogo comece imediatamente:

jogar = true
while jogar
  ...
end

Enquanto jogar for true, o programa continua oferecendo novas rodadas. Ao final de cada uma, atualizamos jogar de acordo com a resposta da pessoa.

Dentro do while jogar, a primeira coisa é sortear uma palavra aleatória da lista usando o método .sample, que escolhe um elemento aleatório de um array:

palavra = palavras.sample

A cada nova rodada, uma palavra diferente pode ser sorteada de forma imprevisível.

Depois inicializamos todas as variáveis que controlam o estado da rodada atual:

letras_palavra = palavra.chars
letras_certas = []
letras_erradas = []
letras_tentadas = []
dica_exibida = false
rodada_ativa = true

Vamos entender cada uma:

• letras_palavra = palavra.chars: O método .chars transforma a string em um array de caracteres. Por exemplo, "gato".chars vira ["g", "a", "t", "o"]. Isso nos permite percorrer a palavra letra por letra.
• letras_certas = []: Array vazio que vai guardar as letras que a pessoa acertou.
• letras_erradas = []: Array vazio que vai guardar as letras erradas.
• letras_tentadas = []: Array vazio que reúne todas as letras já tentadas nesta rodada, certas ou erradas. Serve para impedir que a pessoa repita uma letra.
• dica_exibida = false: Uma variável “bandeira” (flag) que controla se a dica já foi mostrada. Queremos exibi-la apenas uma vez por rodada.
• rodada_ativa = true: Outra variável “bandeira” que controla se a rodada ainda está em andamento. Quando a pessoa ganhar ou perder, ela vai para false e o laço interno se encerra.

Parte 3: O laço interno

O laço interno roda enquanto a rodada estiver ativa:

while rodada_ativa
  ...
end

A primeira coisa dentro desse laço é construir e exibir a palavra com as letras descobertas e traços no lugar das restantes. Fazemos isso com o método .map:

exibicao = letras_palavra.map { |l| letras_certas.include?(l) ? l : "_" }.join(" ")

Essa linha tem algumas partes novas. Vamos destrinchá-la:

• letras_palavra.map { |l| ... }: O .map percorre cada elemento do array letras_palavra e transforma cada letra em outra coisa. Para cada letra l, o bloco { |l| ... } decide o que colocar no lugar.
• letras_certas.include?(l) ? l : "_": Essa é uma expressão ternária, uma forma compacta de escrever um if/else em linha única. Ela funciona assim:
  • letras_certas.include?(l) — “a letra l está na lista de letras certas?”
  • ? — “se sim…”
  • l — “…deixe a letra aparecer”
  • : — “se não…”
  • "_" — “…coloque um traço”
• .join(" "): Após o .map transformar o array, o .join(" ") junta todos os elementos em uma única string, separando cada um por um espaço. Assim ["_", "a", "_", "_"] vira "_ a _ _".

Depois exibimos o estado atual da rodada:

tentativas_restantes = max_tentativas - letras_erradas.size
puts ""
puts "Palavra: #{exibicao}"
puts "Letras erradas: #{letras_erradas.join(', ')}" unless letras_erradas.empty?
puts "Tentativas restantes: #{tentativas_restantes}"

Note o uso de unless em puts "Letras erradas: ..." unless letras_erradas.empty?. O unless é o oposto do if: ele executa a instrução somente quando a condição é falsa. Aqui estamos dizendo “exiba as letras erradas, a não ser que o array esteja vazio”. Isso evita mostrar uma linha “Letras erradas:” sem nada logo nas primeiras tentativas.

Depois verificamos se a pessoa ganhou. Quando não há mais nenhum "_" na exibição, todas as letras foram descobertas:

unless exibicao.include?("_")
  vitorias += 1
  puts "Parabéns! Você descobriu a palavra: #{palavra}!"
  rodada_ativa = false
  next
end

Se não há "_" na exibicao, a pessoa ganhou: somamos 1 às vitórias, exibimos a mensagem e definimos rodada_ativa = false. O next pula para a próxima iteração do while rodada_ativa, que vai verificar a condição novamente. Como agora é false, o laço interno encerra.

Em seguida verificamos se a pessoa perdeu:

if tentativas_restantes <= 0
  derrotas += 1
  puts "Você perdeu! A palavra era: #{palavra}."
  rodada_ativa = false
  next
end

Se as tentativas chegaram a zero, a lógica é a mesma: somamos 1 às derrotas, exibimos a mensagem e encerramos a rodada com rodada_ativa = false e next.

Agora verificamos se é hora de exibir a dica. Queremos mostrá-la apenas uma vez, quando restam 3 ou menos tentativas:

if !dica_exibida && tentativas_restantes <= 3
  puts "Dica: #{dicas[palavra]}"
  dica_exibida = true
end

As duas condições precisam ser verdadeiras ao mesmo tempo (&&):

• !dica_exibida: a dica ainda não foi exibida. O ! inverte o valor: se dica_exibida é false, então !dica_exibida é true.
• tentativas_restantes <= 3: restam 3 ou menos tentativas.

Quando exibimos a dica, marcamos dica_exibida = true para que ela não apareça novamente nas próximas iterações da mesma rodada.

Agora vem o bloco de leitura e validação da letra. Precisamos garantir que a entrada seja uma única letra do alfabeto e que ainda não tenha sido tentada:

letra = nil

while letra.nil?
  print "Digite uma letra: "
  entrada = gets.chomp.downcase

  unless ("a".."z").include?(entrada)
    puts "Entrada inválida! Digite apenas uma letra."
    next
  end

  if letras_tentadas.include?(entrada)
    puts "Você já tentou essa letra! Tente outra."
    next
  end

  letra = entrada
end

Iniciamos letra como nil e usamos while letra.nil? para repetir enquanto não tivermos uma entrada válida.

Dentro do laço:

• gets.chomp.downcase: lê a entrada, remove o Enter e converte para minúsculo. Assim "A" e "a" são tratados da mesma forma.
• ("a".."z").include?(entrada): O intervalo ("a".."z") representa todas as letras do alfabeto de “a” até “z”. O .include? verifica se o que foi digitado está dentro desse intervalo. Se a pessoa digitou um número, um espaço ou mais de uma letra, a condição falha e o programa informa o erro.
• letras_tentadas.include?(entrada): verifica se essa letra já foi tentada nesta rodada.

Só quando a entrada passa pelas duas verificações ela é atribuída à variável letra, encerrando o while letra.nil?.

Por fim, verificamos se a letra está na palavra e atualizamos os arrays:

letras_tentadas << letra
if palavra.include?(letra)
  letras_certas << letra
  puts "Boa! A letra '#{letra}' está na palavra."
else
  letras_erradas << letra
  puts "A letra '#{letra}' não está na palavra."
end

Independentemente de acerto ou erro, sempre adicionamos a letra em letras_tentadas para que não possa ser tentada novamente. Se acertou, vai também para letras_certas; se errou, vai para letras_erradas.

Parte 4: Encerramento da rodada

Após o laço interno terminar, exibimos o placar parcial e perguntamos se a pessoa quer jogar de novo:

puts ""
puts "Placar: #{vitorias} vitória(s) | #{derrotas} derrota(s)"

resposta = nil

while resposta != "s" && resposta != "n"
  puts ""
  print "Deseja jogar novamente? (s para sim ou n para não): "
  resposta = gets.chomp.downcase
  puts "Resposta inválida! Por favor, digite 's' para sim ou 'n' para não." unless resposta == "s" || resposta == "n"
end

jogar = resposta == "s"

A linha jogar = resposta == "s" é uma atribuição direta: a expressão resposta == "s" retorna true se a resposta for “s” e false se for “n”. Esse valor vai direto para a variável jogar. Se jogar for false, o while jogar do laço externo não se repete e o programa avança para o placar final.

Ao sair do laço externo, exibimos o placar final e encerramos:

puts ""
puts "Placar final: #{vitorias} vitória(s) | #{derrotas} derrota(s)"
puts "Obrigado por jogar! Até a próxima!"

O código do jogo da forca completo fica assim:

palavras = ["abacaxi", "elefante", "programacao", "computador", "teclado", "borboleta", "chocolate", "universo"]
max_tentativas = 6

dicas = {
  "abacaxi" => "É uma fruta tropical",
  "elefante" => "É o maior animal terrestre",
  "programacao" => "É o que estamos aprendendo agora",
  "computador" => "Máquina que você está usando",
  "teclado" => "Periférico usado para digitar",
  "borboleta" => "Inseto com asas coloridas",
  "chocolate" => "Doce feito de cacau",
  "universo" => "Tudo que existe no espaço"
}

vitorias = 0
derrotas = 0

puts "Receba as boas-vindas do Jogo da Forca!"
puts "Tente adivinhar a palavra secreta antes de esgotar suas tentativas."

jogar = true
while jogar
  palavra = palavras.sample
  letras_palavra = palavra.chars
  letras_certas = []
  letras_erradas = []
  letras_tentadas = []
  dica_exibida = false
  rodada_ativa = true

  while rodada_ativa
    # Exibe a palavra com as letras descobertas
    exibicao = letras_palavra.map { |l| letras_certas.include?(l) ? l : "_" }.join(" ")
    tentativas_restantes = max_tentativas - letras_erradas.size
    puts ""
    puts "Palavra: #{exibicao}"
    puts "Letras erradas: #{letras_erradas.join(', ')}" unless letras_erradas.empty?
    puts "Tentativas restantes: #{tentativas_restantes}"

    # Verifica se ganhou
    unless exibicao.include?("_")
      vitorias += 1
      puts "Parabéns! Você descobriu a palavra: #{palavra}!"
      rodada_ativa = false
      next
    end

    # Verifica se perdeu
    if tentativas_restantes <= 0
      derrotas += 1
      puts "Você perdeu! A palavra era: #{palavra}."
      rodada_ativa = false
      next
    end

    # Exibe dica quando restam 3 tentativas ou menos
    if !dica_exibida && tentativas_restantes <= 3
      puts "Dica: #{dicas[palavra]}"
      dica_exibida = true
    end

    # Entrada do jogador
    letra = nil

    while letra.nil?
      print "Digite uma letra: "
      entrada = gets.chomp.downcase

      unless ("a".."z").include?(entrada)
        puts "Entrada inválida! Digite apenas uma letra."
        next
      end

      if letras_tentadas.include?(entrada)
        puts "Você já tentou essa letra! Tente outra."
        next
      end

      letra = entrada
    end

    # Verifica se a letra está na palavra
    letras_tentadas << letra
    if palavra.include?(letra)
      letras_certas << letra
      puts "Boa! A letra '#{letra}' está na palavra."
    else
      letras_erradas << letra
      puts "A letra '#{letra}' não está na palavra."
    end
  end

  puts ""
  puts "Placar: #{vitorias} vitória(s) | #{derrotas} derrota(s)"

  # Pergunta se deseja jogar novamente
  resposta = nil

  while resposta != "s" && resposta != "n"
    puts ""
    print "Deseja jogar novamente? (s para sim ou n para não): "
    resposta = gets.chomp.downcase
    puts "Resposta inválida! Por favor, digite 's' para sim ou 'n' para não." unless resposta == "s" || resposta == "n"
  end

  jogar = resposta == "s"
end

puts ""
puts "Placar final: #{vitorias} vitória(s) | #{derrotas} derrota(s)"
puts "Obrigado por jogar! Até a próxima!"

Resumo

Neste artigo, praticamos os conceitos fundamentais da programação em Ruby por meio de doze exercícios organizados em três níveis de dificuldade.

No nível básico, criamos programas curtos para exercitar os conceitos mais essenciais. Escrevemos uma saudação personalizada usando variáveis, puts, print, gets.chomp e interpolação de strings. Calculamos a idade aproximada de uma pessoa a partir do ano de nascimento, aplicando validação de entrada com while, rescue e Time.now.year. E verificamos se um número é par ou ímpar usando o operador de módulo % e uma estrutura if/else.

No nível intermediário, os exercícios passaram a combinar estruturas de repetição com lógica mais elaborada. Geramos a tabuada de um número com for, while e each. Contamos vogais em uma frase usando each_char e corrigindo acentos com o método tr. Verificamos se um número é primo com a técnica da variável “bandeira” (flag) e o comando break. Somamos uma quantidade variável de números usando o método times, acumuladores e tratamento de erros com begin/rescue. Calculamos a sequência de Fibonacci, entendendo como a ordem de atualização das variáveis define o próximo termo. E criamos um jogo de adivinhação de número secreto com rand, while, next e break.

No nível avançado, os desafios exigiram pensar no programa como um sistema completo. Construímos um conversor de dias, horas ou minutos em segundos, com menu de opções usando case/when e um loop externo para permitir múltiplas conversões na mesma execução. Criamos um sistema de cadastro de pessoas que armazena os dados em um array de hashes e exibe a lista ao final com each_with_index. E implementamos um jogo da forca, combinando .sample, .chars, .map, expressão ternária, .join e variáveis “bandeira” para controlar o estado de cada rodada.

A prática continua sendo a forma mais eficaz de fixar o que foi aprendido. A cada novo programa escrito, mesmo que com erros, o raciocínio lógico vai ficando mais natural e a leitura de código mais fluida. Nenhum desses doze programas é o jeito único e definitivo de resolver o problema: são pontos de partida para explorar, modificar e melhorar.

zoom_in

Clique para ampliar

Apresentação

A partir de agora os programas que estão sendo desenvolvidos ganharão novas capacidades. Vamos pensar na pergunta: Como fazer um programa executar uma tarefa várias vezes sem precisar escrever o mesmo código várias vezes?

A resposta para essa pergunta está nas estruturas de repetição, elas servem para executar um mesmo trecho de código várias vezes, até que uma condição seja atendida (ou enquanto essa condição for verdadeira ou falsa, dependendo do tipo de estrutura usada).

Em outras palavras, você pode repetir o mesmo trecho de código quantas vezes forem necessárias, sem precisar escrever o código repetidamente. Para isso você cria uma estrutura de repetição que vai controlar quantas vezes o código será executado. Esse controle vai depender se a condição definida na estrutura de repetição for atendida ou não.

Enquanto a condição não for atendida, seja ela verdadeira ou falsa, o código dentro da estrutura de repetição continuará sendo executado por várias vezes automaticamente.

Imagine que você precisa lavar 50 pratos. Você não escreveria um manual de instruções dizendo:

• Lave o prato 1
• lave o prato 2
• lave o prato 3…

Assim vai até o prato 50. Isso seria muito cansativo e improdutivo (improdutivo é o mesmo que não produzir nada, ou seja, perder tempo).

Se você tivesse uma estrutura de repetição, você poderia dizer algo como:

• Enquanto houver pratos sujos, lave o próximo prato.
• Para cada prato sujo, lave o prato.

Estruturas de repetição são apenas formas de dizer ao computador: “Não pare ainda, continue trabalhando até que tal coisa aconteça”.

Observação: As estruturas de repetição também são chamadas de laços de repetição ou loops, com frequência até maior do que o termo estruturas de repetição. Então, se encontrar esses termos, saiba que eles significam a mesma coisa.

Tipos de laços de repetição em Ruby

No Ruby, existem dois tipos principais de laços:

• Os que se repetem enquanto uma condição for verdadeira ou falsa.
• Os que se repetem para cada item de uma coleção (como um array ou um hash).

zoom_in

Clique para ampliar

Explicando melhor cada um desses tipos de laços:

1. Laços que se repetem enquanto uma condição for verdadeira ou falsa: Esses laços fazem o mesmo comando várias vezes, desde que uma regra seja seguida. Por exemplo, dá para pedir ao usuário um número e só parar quando ele colocar um número correto.
   • Exemplos desses laços são: while e until.
2. Laços que se repetem para cada item de uma coleção: Esses laços passam por todos os elementos de um grupo, como uma lista ou tabela, e fazem uma tarefa para cada um. Por exemplo, você pode usar um laço para mostrar cada nome de uma lista de nomes.
   • Exemplos desses laços são: for e each.

Laço while

O laço while é o laço mais intuitivo. Ele funciona com base em uma condição verdadeira. Enquanto a condição for verdadeira, o código dentro do laço será executado repetidamente.

Sintaxe do laço while

A sintaxe básica do laço while é a seguinte:

i = 0

while i < 5
  puts i+1
  i += 1
end

O que estamos fazendo aqui é:

i = 0

Cria uma variável chamada i e atribui o valor 0 a ela. Em programação, é muito comum usar a variável i para contar quantas vezes um laço foi executado.

O nome da variável i vem de “index” (índice, em inglês) ou “iterador” (que é algo que itera, ou seja, que repete uma ação várias vezes). A variável i será usada para controlar quantas vezes o laço será executado.

while i < 5

Inicia a estrutura de repetição. O computador vai fazer a pergunta: “O valor de i é menor que 5?” por várias vezes. Enquanto a resposta for “sim” (ou seja, enquanto a condição for verdadeira), o código dentro do laço será executado.

Como i foi inicializado com 0, a condição i < 5 é verdadeira, então o código dentro do laço será executado pela primeira vez.

puts i+1

Exibe o valor de i + 1 na tela. Na primeira vez que o laço é executado, i é 0, então o que será exibido é 1.

Em computação, a contagem começa do 0. Por isso, se colocar apenas puts i, a saída será:

0

1

2

3

4

Que são cinco números, mas começam do 0.

Mas, na contagem humana, a maioria das pessoas começa a contar do 1. Por isso, somamos 1 ao valor de i para exibir os números de 1 a 5.

Ao fazer puts i+1, você não altera o valor da variável i na memória, você apenas exibe o valor dela somado a 1.

Quando i é 0, imprime 1.

Quando i é 4, imprime 5.

i += 1

Essa linha é responsável por aumentar o valor da variável i em 1 a cada vez que o laço é executado. É uma forma abreviada de escrever i = i + 1.

A linha atualiza a variável de controle para avançar o laço. É uma linha muito importante, a mais importante, para evitar que o programa trave e que o laço entre no que é conhecido como “loop infinito”. O loop infinito acontece quando a condição do laço nunca se torna falsa, fazendo com que o laço continue executando para sempre.

Se o valor de i não for aumentado, ele continuará valendo 0 para sempre. Quando o código voltar para a linha while i < 5, a pergunta “O valor de i é menor que 5?” continuará sendo respondida com “sim”, e o laço nunca terminará. O programa ficaria preso nesse laço para sempre, travando o computador.

Ao fazer i += 1 (ou i = i + 1), o valor de i aumenta a cada vez que o laço é executado. Quando for executado a primeira vez, i será 1. Na segunda vez, i será 2, na terceira vez, i será 3, na quarta vez, i será 4, e na quinta vez, i será 5.

Então quando o código voltar para a linha while i < 5 pela sexta vez, a pergunta “O valor de i é menor que 5?” será respondida com “não”, e o laço terminará.

end

Finaliza o laço while. Tudo que estiver entre while e end faz parte do laço e será executado repetidamente enquanto a condição for verdadeira.

Cuidado ao usar < e <=

Em programação, é importante entender a diferença entre os operadores < (menor que) e <= (menor ou igual a).

Isso é ainda mais importante na hora de escrever as condições dos laços de repetição, para evitar erros que podem fazer o programa não funcionar como esperado.

Por exemplo, considere o seguinte código:

i = 0

while i <= 5
  puts i
  i += 1
end

Nesse caso, o laço while continuará executando enquanto i for menor ou igual a 5. Isso significa que o laço será executado quando i for 0, 1, 2, 3, 4 e também quando for 5 dando um total de 6 execuções.

Se você quiser que o laço execute apenas 5 vezes, deve usar o operador < (menor que) em vez de <= (menor ou igual a).

Essa diferença pode parecer pequena, mas é muito, muito importante para garantir que o programa funcione corretamente.

Executar pelo menos uma vez com begin…end while

Existem situações em que você quer que o código dentro do laço seja executado pelo menos uma vez, mesmo que a condição inicial seja falsa. Para isso, você pode usar a estrutura begin...end while.

Por exemplo, vamos criar um menu simples que será exibido pelo menos uma vez, e continuará sendo exibido enquanto o usuário não escolher a opção de sair:

opcao = ""

begin
  puts "Menu:"
  puts "1. Opção 1"
  puts "2. Opção 2"
  puts "3. Sair"
  opcao = gets.chomp
end while opcao != "3"

Aqui, o menu será exibido pelo menos uma vez, e continuará sendo exibido enquanto a pessoa não digitar “3” para sair.

Laço until

O laço until é o oposto do laço while. Ele executa o código dentro do laço enquanto a condição for falsa. Quando a condição se torna verdadeira, o laço termina.

Sintaxe do laço until

A sintaxe básica do laço until é a seguinte:

bateria = 0

# Tradução: ATÉ QUE a bateria seja 100...
until bateria == 100 do
  puts "Carregando... #{bateria}%"
  bateria += 10
end

puts "Carga completa! Bateria em #{bateria}%"

O que estamos fazendo aqui é:

bateria = 0

Cria uma variável chamada bateria e atribui o valor 0 a ela. Essa variável será usada para simular o nível de carga da bateria.

until bateria == 100 do

Inicia a estrutura de repetição. O computador vai fazer a pergunta: “O valor de bateria é igual a 100?” por várias vezes. Enquanto a resposta for “não” (ou seja, enquanto a condição for falsa), o código dentro do laço será executado.

Como bateria foi inicializado com 0, a condição bateria == 100 é falsa, então o código dentro do laço será executado pela primeira vez.

puts "Carregando... #{bateria}%"

Exibe o nível atual de carga da bateria na tela. Na primeira vez que o laço é executado, bateria é 0, então o que será exibido é “Carregando… 0%”.

bateria += 10

Essa linha é responsável por aumentar o valor da variável bateria em 10 a cada vez que o laço é executado. É uma forma abreviada de escrever bateria = bateria + 10.

Ao fazer bateria += 10 (ou bateria = bateria + 10), o valor de bateria aumenta a cada vez que o laço é executado. Quando for executado a primeira vez, bateria será 10. Na segunda vez, bateria será 20, na terceira vez, bateria será 30, na quarta vez, bateria será 40, e assim por diante, até chegar a 100.

end

Finaliza o laço until. Tudo que estiver entre until e end faz parte do laço e será executado repetidamente enquanto a condição for falsa.

puts "Carga completa! Bateria em #{bateria}%"

Exibe uma mensagem indicando que a carga da bateria está completa, mostrando o valor final da variável bateria, que será 100 quando o laço terminar.

Exemplos com until

Observe os seguintes códigos que utilizam o laço until:

i = 0

until i == 3
  puts i+1
  i += 1
end

i = 0

until i <= 3
  puts i+1
  i += 1
end

i = 0

until i < 3
  puts i+1
  i += 1
end

O que vai acontecer em cada um desses códigos? Vamos analisar cada um deles:

1. Em until i == 3, o laço continuará executando enquanto i não for igual a 3 (ou seja, enquanto a condição for falsa). Portanto, ele imprimirá os números 1, 2 e 3 na tela por causa do puts i+1.

2. Em until i <= 3, nada será mostrado na tela. Isso porque a condição i <= 3 já é verdadeira desde o início (pois i começa em 0 e 0 é menor que 3). Como a condição já começou verdadeira e o laço until só executa enquanto a condição for falsa, o código dentro do laço nunca será executado.

3. O mesmo vai acontecer em until i < 3. A condição i < 3 já é verdadeira desde o início (pois i começa em 0 e 0 é menor que 3). Portanto, o código dentro do laço nunca será executado, e nada será mostrado na tela.

Dica sobre while e until

Use o laço while quando quiser que o código seja executado enquanto uma condição for verdadeira até que ela se torne falsa.

Já o laço until deve ser usado quando quiser que o código seja executado enquanto uma condição for falsa até que ela se torne verdadeira.

Para qualquer laço, não apenas while e until, o mais importante é ter certeza que a condição que você criou para o laço vai mudar em algum momento, para evitar que o laço entre em um loop infinito. Sempre atualize a variável de controle dentro do laço para garantir que a condição será eventualmente atendida e o laço terminará.

Sempre respeite a lógica do seu programa na hora de definir as condições dos laços. Por exemplo, na hora de definir seus operadores lógicos (<, <=, ==, etc.), escolha o operador que faz sentido para o que você quer alcançar com o laço.

Laço for

O laço for serve para passar por todos os itens de uma coleção (lista) de elementos, como um array ou range (intervalo de números). Para cada item dessa coleção (lista), o código que está dentro do laço é executado.

Sintaxe do laço for

A sintaxe básica do laço for é a seguinte:

idades = [10, 22, 35, 46, 57]
nomes = ["Ana", "Bruno", "Carla", "Daniel", "Eva"]
i = 0

for i in 0..4
  puts "#{i+1}ª execução do laço for."
  puts "#{nomes[i]} tem #{idades[i]} anos."
end

O que estamos fazendo aqui é um exemplo clássico de iteração (repetição) sobre dois arrays (listas) ao mesmo tempo, usando o laço for.

Primeiro idades = [10, 22, 35, 46, 57] cria um array chamado idades que contém cinco números representando idades.

Depois nomes = ["Ana", "Bruno", "Carla", "Daniel", "Eva"] cria outro array chamado nomes que contém cinco strings representando nomes.

Imagine esses dois arrays como duas listas paralelas, duas colunas em uma tabela do Excel, onde o primeiro nome corresponde à primeira idade, o segundo nome à segunda idade, e assim por diante.

As colunas estão alinhadas, ou seja, a informação que está na primeira posição de um array corresponde à informação que está na primeira posição do outro array. Como em uma tabela:

Observacao: em telas pequenas, deslize horizontalmente para ler todas as colunas da tabela.

Então o laço for i in 0..4 inicia a estrutura de repetição.

for i in 0..4

É como dizer ao computador:

“Para a nossa variável contadora i (que é como nosso dedo nossa maneira de apontar) repita os comandos do código abaixo começando com i = 0 e terminando com i = 4. A cada vez que o laço for executado o i deve mudar de valor e o código do laço deve ser executado de novo.”

O que o computador entende é:

“Vou executar o código a seguir 5 vezes. Na primeira vez, o i vale 0. Na segunda vez o i, vale 1. Na terceira vez o i vale 2. Na quarta vez o i vale 3. Na quinta e última vez o i vale 4.”

Então dentro do laço de repetição, temos dois comandos puts. O primeiro comando:

puts "#{i+1}ª execução do laço for."

Exibe na tela a mensagem indicando qual é a execução atual do laço, somando 1 ao valor de i para começar a contagem do 1.

Quando o i for 0, exibirá “1ª execução do laço for.”

Quando o i for 1, exibirá “2ª execução do laço for.”

E assim por diante, até a 5ª execução. Isso é apenas para ficar bonito na tela, não altera os dados das listas.

Já o segundo comando:

puts "#{nomes[i]} tem #{idades[i]} anos."

Exibe na tela o nome e a idade correspondentes, usando o valor de i para acessar os elementos corretos em cada array.

Por exemplo, quando i for 0, ele acessa nomes[0] (que é “Ana”) e idades[0] (que é 10), exibindo “Ana tem 10 anos.”

A simulação completa desse laço for resultará no seguinte:

Observacao: em telas pequenas, deslize horizontalmente para ler todas as colunas da tabela.

Usando for com arrays diretamente

Se você não precisar conectar dois arrays (listas) diferentes, pode usar o laço for diretamente com um array.

Veja o exemplo abaixo:

idades = [10, 22, 35, 46, 57]

# para cada idade na lista de idades faça:
for idade in idades
  puts "Idade: #{idade} anos."
end

Aqui, você não se preocupa em saber “onde” o item está (posição 0, 1, 2…), você só quer saber “o que” é o item.

Neste caso, a leitura do código é muito natural: “Para cada valor que estiver dentro da lista idades, chame esse valor temporariamente de idade e execute o código”.

A variável idade (no singular) é criada automaticamente pelo laço. Ela serve como uma “gaveta temporária” que guarda um valor diferente a cada volta do laço.

Comparando com uma playlist de música:

• Usando índice (i) como foi feito antes: É como dizer “Toque a música da faixa 1”, depois “Toque a música da faixa 2”. Você precisa saber o número da faixa para escolher a música.
• Usando o array diretamente (este exemplo): É como apertar o botão “Próxima”. Você não precisa saber qual é o número da faixa, apenas ouve a música que está tocando agora e passa para a seguinte automaticamente.

Usando for com ranges

O Range (intervalo) é um tipo de dado no Ruby que representa uma sequência de valores, geralmente números. É muito útil quando você quer repetir alguma coisa um número específico de vezes, mas não tem uma lista pronta.

A sintaxe é muito simples: você coloca o valor inicial, dois pontos (..) e o valor final.

Observe o exemplo:

# Vai contar de 1 até 5
for numero in 1..5
  puts "Contando: #{numero}"
end

A saída será:

Contando: 1

Contando: 2

Contando: 3

Contando: 4

Contando: 5

Diferença entre dois pontos (..) e três pontos (…)

Existe um detalhe importante nos intervalos do Ruby:

• 1..5 (dois pontos): Inclui o último número. Vai de 1 até 5 (1, 2, 3, 4, 5).
• 1...5 (três pontos): Exclui o último número. Vai de 1 até quase 5 (1, 2, 3, 4).

Exemplo com três pontos:

# Vai contar de 1 até 4 (o 5 fica de fora)
for numero in 1...5
  puts "Contando: #{numero}"
end

A saída será:

Contando: 1

Contando: 2

Contando: 3

Contando: 4

Isso é útil quando você quer evitar ultrapassar um limite específico.

Laço each

O laço each é a forma mais utilizada e “rubista” de fazer repetições em coleções. Enquanto o for é comum em muitas linguagens de programação (como C, Java, Python), o each é mais específico do Ruby e é preferido pela comunidade Ruby por ser mais elegante (para a comunidade Ruby, “elegante” significa “bonito e eficiente”).

A palavra “each” significa “cada”. A leitura é: “Para cada item da coleção, faça isso”.

A estrutura each é diferente do for. Aqui, o laço é um método que pertence as coleções (“array”, “range”, “hash”).

Devemos lembrar do que já foi dito em outros artigos: método = ação de um objeto.

Ou seja, o each é uma ação dos arrays (listas), ranges (intervalos) e hashes (tabelas) que faz o seguinte: “Para cada item da coleção, execute o código que está dentro do bloco.”

No caso do for, o laço é uma estrutura de controle da linguagem Ruby. As coleções estão lá paradas e o laço for passa por elas executando o código dentro do laço para cada item da coleção.

No caso do each, as coleções (arrays, ranges, hashes) têm o método each que faz o trabalho de passar por cada item da coleção e executar o código dentro do bloco. Ou seja, é a própria coleção (que é um objeto) que executa a ação de iterar (repetir) o código para cada um dos seus itens.

• for: Estrutura de controle da linguagem Ruby que itera sobre coleções.

• each: Método dos objetos coleção (arrays, ranges, hashes) que itera sobre seus próprios itens.

Sintaxe do laço each

nomes = ["Ana", "Bruno", "Carla"]

nomes.each do |nome|
  puts "Olá, #{nome}!"
end

Vamos entender as partes dessa estrutura:

1. nomes.each: Você pega a lista (nomes) e chama o método .each (ponto each). É como dar uma ordem para a lista: “Lista, para cada item seu, faça…”

2. do ... end: Isso define um bloco de código. Tudo que estiver entre o do e o end será executado para cada item.

3. |nome|: As barras verticais (pipes) funcionam como a “gaveta temporária”. O Ruby pega o item atual da lista e o coloca dentro da variável que você escreveu entre as barras. Você pode dar qualquer nome para essa variável (como |pessoa|, |item|, |x|).

4. puts "Olá, #{nome}!": Esse é o código que será executado para cada item. Aqui, ele exibe uma saudação personalizada usando o nome atual da lista.

A saída desse código será:

Olá, Ana!

Olá, Bruno!

Olá, Carla!

Sintaxe de uma linha (Blocos Inline)

Uma das características mais amadas do Ruby é a capacidade de escrever códigos concisos (conciso é o mesmo que breve ou resumido). Se o código dentro do bloco for curto (apenas uma linha), você pode substituir o do...end por chaves { ... }.

Veja como fica o exemplo anterior em uma única linha:

nomes = ["Ana", "Bruno", "Carla"]

nomes.each { |nome| puts "Olá, #{nome}!" }

O resultado é exatamente o mesmo, mas economiza espaço vertical na tela. Mas, cuidado para não exagerar! Se o código dentro do bloco for muito longo, é melhor usar o formato com do...end para manter a legibilidade.

Usando each com Hashes

O each é poderoso porque funciona em qualquer coleção. Nos Hashes (que são como dicionários com chave e valor), o bloco recebe duas variáveis: uma para a chave e outra para o valor.

# Criando um Hash com produtos e preços
produtos = { "Camiseta" => 29.90, "Calça" => 89.90, "Meia" => 9.90 }

produtos.each do |produto, preco|
  puts "O item #{produto} custa R$ #{preco}"
end

Observe que usamos |produto, preco| entre as barras verticais. O Ruby entende automaticamente que o primeiro item é a chave (nome do produto) e o segundo item é o valor (preço do produto).

E se eu precisar do índice? (each_with_index)

Às vezes, quando você está passando por cada item de uma lista (iterando) usando o each no Ruby, pode querer saber em que lugar aquele item está, ou seja, seu número na lista (índice). Para isso, existe o método each_with_index, que mostra o índice de cada item enquanto você percorre a coleção seja ela um array ou um hash.

O exemplo a seguir mostra como usar o each_with_index com um array:

frutas = ["Maçã", "Banana", "Cereja"]

frutas.each_with_index do |fruta, indice|
  puts "#{indice + 1}: #{fruta}"
end

Aqui, o bloco recebe dois parâmetros (|fruta, indice|): o nome da fruta e seu índice na lista. Note que somamos 1 ao índice para começar a contagem do 1, já que os índices em programação começam do 0.

A saída será:

1: Maçã

2: Banana

3: Cereja

Você também pode usar o each_with_index com hashes. Veja o exemplo:

pessoas = { "Ana" => 25, "Bruno" => 30, "Carla" => 28 }

pessoas.each_with_index do |(nome, idade), indice|
  puts "#{indice + 1}: #{nome} tem #{idade} anos."
end

Neste caso, o bloco recebe uma tupla, tupla é um grupo de valores, nesse caso o grupo de valores é o nome, a idade e o índice. A saída será:

1: Ana tem 25 anos.

2: Bruno tem 30 anos.

3: Carla tem 28 anos.

Então, o each_with_index é uma ferramenta muito útil quando você precisa tanto do valor quanto da posição do item na coleção enquanto itera sobre ela.

Laço times

Esse é um método exclusivo dos números inteiros (Integer) no Ruby. É a maneira mais fácil de dizer “Repita isso X vezes”. Não precisa criar uma variável para contar, como i = 0.

Como funciona? Você pega um número inteiro e chama o método times nele, passando um bloco de código que será executado esse número de vezes.

Sintaxe do laço times

Exemplo:

5.times do |i|
  puts "Esta é a execução número #{i + 1}"
end

Aqui, o número 5 indica que o bloco de código dentro do do...end será executado 5 vezes. A variável i dentro das barras verticais (|i|) representa o índice da execução atual, começando do 0, é apenas para mostrar qual é a execução atual.

A saída será:

Esta é a execução número 1

Esta é a execução número 2

Esta é a execução número 3

Esta é a execução número 4

Esta é a execução número 5

Outro exemplo com times:

3.times { puts "Repetindo esta mensagem!" }

Aqui, o bloco de código é simples e cabe em uma única linha, então usamos as chaves { ... } para definir o bloco. A mensagem “Repetindo esta mensagem!” será exibida 3 vezes.

Use o times quando você souber exatamente o número de repetições necessárias e não estiver percorrendo uma lista complexa.

Laços de repetição em uma frase

Observacao: em telas pequenas, deslize horizontalmente para ler todas as colunas da tabela.

Refazendo exercícios de artigos anteriores

Agora que os laços de repetição foram apresentados, serão refeitos alguns exercícios dos artigos anteriores, mas dessa vez utilizando laços de repetição para resolver os problemas.

Assim será possível ver como os laços de repetição podem facilitar a resolução de problemas que envolvem tarefas repetitivas.

Otimizando o menu de pagamento

No exercício original, se a pessoa digitasse uma opção inválida, o programa apenas dizia “Opção inválida” e encerrava. Com o while, podemos obrigar a pessoa a ficar no menu até escolher uma opção correta.

Código atualizado:

preco = 0.0
opcao = 0

print "Digite o preço normal do produto: "
preco = Float(gets.chomp)

# Otimização: O programa fica preso aqui ENQUANTO a opção for inválida
# (menor que 1 OU maior que 4)
while opcao < 1 || opcao > 4
  puts "\n--- Escolha a condição de pagamento ---"
  puts "1 - À vista em dinheiro (10% de desconto)"
  puts "2 - À vista no cartão (15% de desconto)"
  puts "3 - Em duas vezes (sem juros)"
  puts "4 - Em duas vezes (10% de juros)"
  print "Escolha uma opção: "
  
  opcao = Integer(gets.chomp) rescue 0 # 'rescue 0' evita erro se digitar letras
  
  if opcao < 1 || opcao > 4
    puts "Opção inválida! Tente novamente."
  end
end

# Daqui para baixo, sabemos que a opção é válida (1, 2, 3 ou 4)
case opcao
when 1
  puts "Valor final: R$ #{(preco * 0.90).round(2)}"
when 2
  puts "Valor final: R$ #{(preco * 0.85).round(2)}"
when 3
  puts "Valor final: R$ #{preco.round(2)} (2x de R$ #{(preco/2).round(2)})"
when 4
  total = preco * 1.10
  puts "Valor final: R$ #{total.round(2)} (2x de R$ #{(total/2).round(2)})"
end