Segue o código original:
#include <stdio.h>
int main()
{
int index = 0, contador;
char letras[5] = "Joao";
for (contador=0; contador < 1000; contador++)
{
printf("\n%c",letras[index]);
(index==3) ? index=0: ++index;
}
}
E segue o desafio:
AUTO-AVALIAÇÃO
Veja como você está:
Altere o último exemplo para que ele escreva cada letra 5 vezes seguidas. Para isto, use
um ’if’ para testar se o contador é divisível por cinco (utilize o operador %) e só então realizar
a atualização em index.
Fonte:
Este documento foi retirado do Curso de C, ministrado via Internet pela UFMG. Os
interessados podem acessar http://ead1.eee.ufmg.br/curso/C
Provavelmente se algum programador passar por esse blog por esses dias, irá se sentir bem melhor consigo mesmo!
Deve ser cômico para um deles imaginar que alguem tenha dificuldade para compreender e alterar um código assim. Mas eu tive e bastante!
Uma parte realmente interessante vou mostrar abaixo:
char letras[4] = "Joao";
0 1 2 3 4
J
|
o
|
a
|
o
|
for(contador=0; contador < 5; contador++)
{
(index==0) ? index=0: ++index;
printf("\n%c",letras[index]);
}
Com a variável char, nós criamos a figura mostrada acima. Da forma com que foi criada e inicializada, char definirá uma quantidade de espaços que será preenchido quando damos a váriável um valor, como em nosso exemplo, joao.
O programinha proposto acima escreve j,o,a,o tantas vezes nós definirmos em nosso laço criado com 'for'. É bem fácil de compreender essa parte:
for(contador=0; contador < 5; contador++)
Após declararmos a variável contador, criamos um laço com 'for' para que uma determinada instrução seja repetida 5 vezes. A instrução contador++ é o mesmo que dizer contador=contador +1. Ou seja, partindo do zero a até 4 vezes, iremos acrestar 1 a variavel contador.
Eu compilei o programinha tal qual está na apostila, apenas alterei o tamanho do laço que na apostila está 1000. Segue o resultado:
c:\>notepad joao.c
c:\>gcc joao.c -o joao
c:\>joao
J
o
a
o
J
o
a
o
J
o
c:\>
Eu chamei o programinha de 'joao' e o resultado do compilador foi a palavra 'joao' sendo escrita até 'estourar' o limite do laço criado com for que foi igual a 10.
Para resolver o desafio, eu fiz algumas alterações no código que provavelmente não é das melhores. Eu acredito piamente que alguém a faria com um terço das linhas que eu coloquei. E isso server como exemplo,inclusive,como as coisas funcionam nesse mundo dos softwares. Quanto melhor esscrito um código,menos linhas,menos memória,processamento e assim vai.
Segue minha versão de como eu consegui escrever da forma solicitada pelo autor.
/* Codigo que repete letras ordenadamente*/
#include <stdio.h>
int main()
{
int index = 0, contador;
char letras[5] = "Joao";
/*primeiro for*/
for(contador=0; contador < 5; contador++)
{
(index==0) ? index=0: ++index;
printf("\n%c",letras[index]);
}
for (contador=0; contador < 5; contador++)
{
(index==1) ? index=1: ++index;
printf("\n%c",letras[index]);
}
for (contador=0; contador < 5; contador++)
{
(index==2) ? index=2: ++index;
printf("\n%c",letras[index]);
}
for (contador=0; contador < 5; contador++)
{
(index==3) ? index=3: ++index;
printf("\n%c",letras[index]);
}
}//main
Considerando que a matriz criada por 'char' possui um valor que indentificada cada 'quadradinho', e que nós criamos uma varíável chamada 'index' para representá-los. Eu repeti meu laço para cada 'quadradinho'. Ou seja, o programa irá escrever 5 vezes cada letra que está armazenada em cada posição do meu 'char'.
Como disse, uma solução mais compacta provavelmente deva existir e eu ainda devo achá-la,mas,com as ferramentas que eu tenho até aqui, essa foi uma solução. Pode não ser a mais elegante,mas consegui cumprir a tarefa. Vamos ver como fica a saída:
c:\>
c:\>notepad contadorcircular.c
c:\>gcc contadorcircular.c -o contadorcircular
c:\>contadorcircular
J
J
J
J
J
o
o
o
o
o
a
a
a
a
a
o
o
o
o
o
c:\>
Aqui está. Eu chamei de contadorcircular e ele apresentou as 4 letras 5 vezes.
Alguns pontos interessantes do código é por exemplo:
(index==0) ? index=0: ++index;
Isso equivale,na verdade, á:
if(index==0);
{
index=0
}
else
{
++index
}
Ou seja, é uma forma resumida de escrever todas essas linhas. E o que ambas querem dizer é o seguinte:
Estamos buscando um ponto de partida para processarmos o código. Aliáis, estamos sempre fazendo isso em programação. Ou seja, trabalhamos com variáveis,mas em um dado ponto do programa, temos que passar algum ponto em que as instruções se baseam.
O '==' é diferente de' ='. Enquanto no segundo caso nós iremos dizer algo do tipo a=0,ou seja, estamos partindo com um valor zero para 'a', no primeiro caso nós estamos nos referindo a possibilidade de 'a' ser zero. Se a for zero faça isso , se não foi faça aquilo.
Aplicando ao nosso programa, iniciando de um valor x para nosso index,ou seja, "pegue o valor que está no 'quadradinho' 'x' e repita ele quantas vezes o nosso laço determinar".
Como tenho feito em relação aos posts de C, vou repetir novamente. Minhas conclusões aqui podem não estarem totalmente corretas. Se alguem, que seja programador tenha lido o que escrevi e encontrar algum absurdo, por favor me corrija e eu postarei com certesa para que outros também aprendam.
Até um próximo.
No comments:
Post a Comment