Jekyll2022-10-22T13:43:38+00:00http://www.jeiks.net/prog1/prog1/feed.xmlProgramação 1Esta página foi desenvolvida para dar apoio aos estudantes de Programação 1. Serão disponibilizados aqui os conteúdos da disciplina e informações úteis para que vocês possam acompanhar bem a disciplna. Sintam-se livres para me contactar e também para marcar um horário e tirar dúvidas em minha sala. Para isso, me enviem um e-mail, por favor. Minha meta é o seu aprendizado. Vamos nos divertir? Ok, então, bora programar.Conteúdo das Aulas2022-08-07T21:22:06+00:002022-08-07T21:22:06+00:00http://www.jeiks.net/prog1/prog1/2022/08/07/conteudo-das-aulas<p>Para facilitar, sumarizei o conteúdo do site aqui:</p>
<ol>
<li><a href="/2022/05/27/conteudo-aula-linux.html">(extra) Trabalhando com GNU/Linux</a></li>
<li><a href="/prog1/2022/05/27/conteudo-aula-printf.html">Imprimindo na tela com printf</a></li>
<li><a href="/prog1/2022/05/27/conteudo-aula-scanf.html">Lendo dados do usuário com scanf</a></li>
<li><a href="/prog1/2022/05/27/atividades-01.html">Atividades 01</a></li>
<li><a href="/prog1/2022/06/03/atividades-02.html">Atividades 02</a></li>
<li><a href="/prog1/2022/06/10/switch.html">Condicionais com o switch</a></li>
<li><a href="/prog1/2022/06/10/atividades-03.html">Atividades 03</a></li>
<li><a href="/prog1/2022/06/10/atividades-04.html">Atividades 04</a></li>
<li><a href="/prog1/2022/06/10/lacos-de-repeticao.html">Laços de repetição</a></li>
<li><a href="/prog1/2022/06/10/atividades-05.html">Atividades 05</a></li>
<li><a href="/prog1/2022/06/24/atividades_revisao_01.html">Atividades de revisão para Avaliação 1</a></li>
<li><a href="/prog1/2022/07/08/vetores.html">Vetores Unidimensionais</a></li>
<li><a href="/prog1/2022/07/09/atividades-avaliativas-vetores.html">Atividades Avaliativas de Vetores</a></li>
<li><a href="/prog1/2022/07/15/vetores-multidimensionais.html">Vetores Multidimensionais</a></li>
<li><a href="/prog1/2022/07/27/exercicio-volei.html">(extra) Exemplo - Exercício vôlei</a></li>
<li><a href="/prog1/2022/08/01/estruturas-e-funcoes.html">Estruturas, funções e ponteiros</a></li>
<li><a href="/prog1/files/Atividades_Recursividade.pdf">Recursividade</a></li>
</ol>
<p>Se divirtam! =D</p>Para facilitar, sumarizei o conteúdo do site aqui: (extra) Trabalhando com GNU/Linux Imprimindo na tela com printf Lendo dados do usuário com scanf Atividades 01 Atividades 02 Condicionais com o switch Atividades 03 Atividades 04 Laços de repetição Atividades 05 Atividades de revisão para Avaliação 1 Vetores Unidimensionais Atividades Avaliativas de Vetores Vetores Multidimensionais (extra) Exemplo - Exercício vôlei Estruturas, funções e ponteiros RecursividadeEstruturas, funções e ponteiros2022-08-01T21:39:09+00:002022-08-01T21:39:09+00:00http://www.jeiks.net/prog1/prog1/2022/08/01/estruturas-e-funcoes<p>Os estudos, podem seguir os seguintes livros:</p>
<ul>
<li><strong>ref1</strong>: <a href="https://drive.google.com/file/d/12pJXzerYzzJrkV_CLCAUX0K6ucX7EI51/view?usp=sharing">Aguiar, M. O., Silva, R. F. <em>Linguagem C: Introdução ao C em 10 aulas</em>.</a></li>
<li><strong>ref2</strong>: Paul Deitel, Harvey Deitel. <em>C: Como Programar</em>. Pearson, 2011.</li>
</ul>
<p>Capítulos:</p>
<ul>
<li><strong>Estruturas</strong>: Cap 6 da <strong>ref1</strong>. E sessões 10.1 à 10.7 da <strong>ref2</strong>.<br />Exercícios:
<ol>
<li>Diga se cada uma das seguintes afirmações é verdadeira ou falsa. Se falsa, explique porquê.
<ul>
<li>As estruturas podem conter apenas um tipo de dado.</li>
<li>O identificador (que vai após as chaves “}”) de uma estrutura é opcional.</li>
<li>Os membros de diferentes estruturas devem ter nomes exclusivos.</li>
<li>A palavra-chave typedef é usada para definir novos tipos de dados.</li>
<li>As estruturas são sempre passadas a funções por meio de chamadas por referência.</li>
</ul>
</li>
<li>Faça:
<ul>
<li>Defina uma estrutura chamada <em>objeto</em> contendo as variáveis:
<em>numero</em>, do tipo <em>int</em>; array (vetor)
<em>nome</em>, do tipo <em>char</em>, que pode ter o comprimento de até 25 caracteres.</li>
<li>Utilize o <em>typedef</em> para nomear esse novo tipo de dado com o identificador <em>tipoObjeto</em>.</li>
<li>Declare uma variável estática do tipo de dado <em>tipoObjeto</em>.</li>
<li>Declare uma variável dinâmica (ponteiro e <em>malloc</em>) do tipo de dado <em>tipoObjeto</em>.</li>
<li>Declare um vetor estático de 3 posições do tipo de dado <em>tipoObjeto</em>.</li>
<li>Declare um vetor dinâmico (ponteiro e <em>malloc</em>) de 3 posições do tipo de dado <em>tipoObjeto</em>.</li>
<li>Faça a leitura de um número e um nome para cada uma das variáveis anteriores.</li>
<li>Escreva na tela o valor dessas variáveis.</li>
</ul>
</li>
<li>Faça:
<ul>
<li>Crie uma estrutura para armazenar dados de um livro. Ela deve ter o nome <em>tipoLivro</em> e deve ser composta de: <em>nome</em> do tipo char, <em>autor</em> do tipo char e <em>ano</em> de publicação do tipo int.</li>
<li>Agora, crie uma estrutura para armazenar uma sessão de livros composta de: <em>nome</em> (tipo char) da sessão, <em>quantidade</em> (tipo int) de livros armazenados na sessão e um vetor (tipo <em>tipoLivro</em>) de 20 livros (é o máximo de livros que poderão ser armazenados na sessão).</li>
<li>Crie um programa para perguntar o ome da sessão, quantos livros deseja armazenar na sessão e ler todas as informações necessárias de cada livro.</li>
<li>Depois, escreva as informações lidas na tela.</li>
</ul>
</li>
</ol>
</li>
<li><strong>Funções</strong>: Capítulo 7 da <strong>ref1</strong>. E capítulo 5 da <strong>ref2</strong>.<br />Exercícios:
<ol>
<li>Responda as perguntas abaixo para o programa a seguir:
<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code> <span class="cp">#include <stdio.h>
</span> <span class="kt">int</span> <span class="nf">cubo</span><span class="p">(</span><span class="kt">int</span> <span class="n">y</span><span class="p">)</span> <span class="p">{</span>
<span class="k">return</span> <span class="n">y</span> <span class="o">*</span> <span class="n">y</span><span class="p">;</span>
<span class="p">}</span>
<span class="kt">void</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
<span class="kt">int</span> <span class="n">x</span><span class="p">;</span>
<span class="k">for</span> <span class="p">(</span><span class="n">x</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span> <span class="n">x</span> <span class="o"><=</span> <span class="mi">5</span><span class="p">;</span> <span class="n">x</span><span class="o">++</span><span class="p">)</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"%d</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">cubo</span><span class="p">(</span><span class="n">x</span><span class="p">));</span>
<span class="p">}</span>
</code></pre></div> </div>
<ul>
<li>O que é escopo?</li>
<li>Qual o escopo da variável x?</li>
<li>Qual o escopo da variável y?</li>
<li>De onde pode ser acessada a variável x?</li>
<li>De onde pode ser acessada a variável y?</li>
<li>De onde pode ser chamada a função cubo?</li>
<li>Quais os valores impressos na tela?</li>
</ul>
</li>
<li>Crie uma função para calcular a hipotenusa de um triângulo. Ela deve receber dois argumentos (lado1 e lado2: ponto flutuante, i.e., float) e deve retornar um ponto flutuante referente ao valor da hipotenusa.</li>
<li>Crie uma função para retornar o menor valor entre três inteiros.</li>
<li>Crie uma função que não recebe nenhum argumento e não retorna nenhum valor. Ela deve só escrever uma mensagem na tela.</li>
<li>Dada o seguinte tipo de dado já definido:
<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code> <span class="k">typedef</span> <span class="k">struct</span> <span class="p">{</span>
<span class="kt">char</span> <span class="n">nome</span><span class="p">[</span><span class="mi">20</span><span class="p">];</span>
<span class="kt">float</span> <span class="n">peso</span><span class="p">,</span> <span class="n">altura</span><span class="p">;</span>
<span class="p">}</span> <span class="n">tipoIMC</span><span class="p">;</span>
</code></pre></div> </div>
<ul>
<li>Crie uma função que receba uma variável dessa estrutura em seu argumento e que retorne o valor do IMC.</li>
<li>Crie uma função que receba uma variável dessa estrutura em seu argumento, mas passada por referência (i.e., usando ponteiro) e que retorne o valor do IMC.</li>
<li>Crie uma função que seja capaz de receber um vetor do tipo <em>tipoIMC</em> e que retorne a média dos IMCs (calculada por uma das funções criadas acima) calculada sobre todos os componentes do vetor.</li>
<li>Crie uma função que seja capaz de receber um vetor do tipo <em>tipoIMC</em> e que escreva na tela o nome da pessoa com o maior IMCs e o nome da pessoa com menor IMC.</li>
</ul>
</li>
<li>Encontre o erro em cada um dos seguintes códigos, faça sua identação e mostre a correção de cada um:
<ul>
<li>a)
<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code> <span class="kt">int</span> <span class="nf">g</span><span class="p">(</span><span class="kt">void</span><span class="p">)</span> <span class="p">{</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"Dentro da funcao g</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
<span class="kt">int</span> <span class="n">h</span><span class="p">(</span><span class="kt">void</span><span class="p">)</span> <span class="p">{</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"Dentro da funcao h</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
<span class="p">}</span>
<span class="p">}</span>
</code></pre></div> </div>
</li>
<li>b)
<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code> <span class="kt">int</span> <span class="nf">soma</span><span class="p">(</span><span class="kt">int</span> <span class="n">x</span><span class="p">,</span> <span class="kt">int</span> <span class="n">y</span><span class="p">)</span> <span class="p">{</span>
<span class="kt">int</span> <span class="n">resultado</span><span class="p">;</span>
<span class="n">resultado</span> <span class="o">=</span> <span class="n">x</span> <span class="o">+</span> <span class="n">y</span><span class="p">;</span>
</code></pre></div> </div>
</li>
<li>c)
<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code> <span class="kt">int</span> <span class="nf">soma</span><span class="p">(</span><span class="kt">int</span> <span class="n">n</span><span class="p">)</span> <span class="p">{</span>
<span class="k">if</span> <span class="p">(</span><span class="n">n</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
<span class="k">else</span>
<span class="n">n</span> <span class="o">+</span> <span class="n">soma</span><span class="p">(</span><span class="n">n</span> <span class="o">-</span> <span class="mi">1</span><span class="p">);</span>
</code></pre></div> </div>
</li>
<li>d)
<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code> <span class="kt">void</span> <span class="nf">f</span><span class="p">(</span><span class="kt">float</span> <span class="n">a</span><span class="p">);</span> <span class="p">{</span>
<span class="kt">float</span> <span class="n">a</span><span class="p">;</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"%f"</span><span class="p">,</span> <span class="n">a</span><span class="p">);</span>
<span class="p">}</span>
</code></pre></div> </div>
</li>
<li>e)
<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code> <span class="kt">void</span> <span class="nf">produto</span><span class="p">(</span><span class="kt">void</span><span class="p">)</span> <span class="p">{</span>
<span class="kt">int</span> <span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">,</span> <span class="n">c</span><span class="p">,</span> <span class="n">result</span><span class="p">;</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"Entre com tres inteiros: "</span><span class="p">)</span> <span class="n">scanf</span><span class="p">)</span><span class="s">"%d%d%d"</span><span class="p">,</span> <span class="o">&</span><span class="n">a</span><span class="p">,</span> <span class="o">&</span><span class="n">b</span><span class="p">,</span> <span class="o">&</span><span class="n">c</span><span class="p">);</span>
<span class="n">result</span> <span class="o">=</span> <span class="n">a</span> <span class="o">*</span> <span class="n">b</span> <span class="o">*</span>
<span class="n">c</span><span class="p">;</span> <span class="n">printf</span><span class="p">(</span><span class="s">"O resultado e %d"</span><span class="p">,</span> <span class="n">result</span><span class="p">);</span> <span class="k">return</span> <span class="n">result</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div> </div>
</li>
</ul>
</li>
<li>Faça um programa que teste as seguintes funções prontas da linguagem C.<br />
Observação: é necessário incluir a biblioteca <em>math.h</em>:
<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code> <span class="cp">#include <math.h>
</span></code></pre></div> </div>
<p>E na hora de compilar, deve adicionar o <em>-lm</em>.</p>
<table>
<thead>
<tr>
<th>Função</th>
<th>Descrição</th>
<th>Exemplos</th>
</tr>
</thead>
<tbody>
<tr>
<td>sqrt(x)</td>
<td>Raiz quadrada de x</td>
<td>sqrt(900.0) é 30<br />sqrt(9.0) é 10</td>
</tr>
<tr>
<td>exp(x)</td>
<td>Função exponecial de e^x</td>
<td>exp(1.0) é 2.718282<br />exp(2.0) é 7.389056</td>
</tr>
<tr>
<td>log(x)</td>
<td>Logaritmo natural de x (base e)</td>
<td>log (2.718282) é 1.0<br />log (7.389056) é 2.0</td>
</tr>
<tr>
<td>log10(x)</td>
<td>Log de x (base 10)</td>
<td>log10(1.0) é 0.0<br />log10(10.0) é 1.0<br />log10(100.0) é 10.0</td>
</tr>
<tr>
<td>fabs(x)</td>
<td>Valor absoluto de x</td>
<td>Se x > 0 então fabs(x) é x<br />Se x = 0 então fabs(x) é 0.0<br />Se x < 0 então fabs(x) é –x</td>
</tr>
<tr>
<td>ceil(x)</td>
<td>Arredonda x para o menor inteiro</td>
<td>ceil(9.2) é 10<br />ceil(-9.8) é -9</td>
</tr>
<tr>
<td>floor(x)</td>
<td>Arredonda x para o maior inteiro</td>
<td>floor(9.2) é 9<br />floor(-9.8) é -10</td>
</tr>
<tr>
<td>pow(x,y)</td>
<td>x elevado a potencia y</td>
<td>pow(2,7) é 128.0<br />pow(9, .5) é 3.0</td>
</tr>
<tr>
<td>fmod(x,y)</td>
<td>Resto de x/y, mas com ponto flutuante</td>
<td>fmod(13.657, 2.333) é 1.992</td>
</tr>
<tr>
<td>sin(x)</td>
<td>Seno trigonométrico de x em rad</td>
<td>sin(0.0) é 0</td>
</tr>
<tr>
<td>cos(x)</td>
<td>Cosseno trigonométrico de x em rad</td>
<td>tos(0.0) é 1</td>
</tr>
<tr>
<td>tan(x)</td>
<td>Tangente trigonométrico de x em rad</td>
<td>tan(0.0) é 0</td>
</tr>
</tbody>
</table>
</li>
</ol>
</li>
<li><strong>Ponteiros</strong>: Capítulo 9 da <strong>ref1</strong>. E capítulo 7 da <strong>ref2</strong>.
<ul>
<li>Observações:
<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code> <span class="cp">#include <stdio.h>
</span> <span class="cp">#include <stdlib.h>
</span>
<span class="kt">int</span> <span class="nf">main</span><span class="p">()</span>
<span class="p">{</span>
<span class="kt">float</span> <span class="o">*</span><span class="n">notas</span><span class="p">,</span> <span class="o">*</span><span class="n">aux</span><span class="p">;</span>
<span class="kt">int</span> <span class="n">i</span><span class="p">;</span>
<span class="c1">//(o número 5 foi escolhido aleatoriamente como tamanho do vetor)</span>
<span class="c1">//Essa instrução:</span>
<span class="c1">//notas = malloc(5*sizeof(float));</span>
<span class="c1">//é igual a essa:</span>
<span class="n">notas</span> <span class="o">=</span> <span class="n">calloc</span><span class="p">(</span><span class="mi">5</span><span class="p">,</span> <span class="k">sizeof</span><span class="p">(</span><span class="kt">float</span><span class="p">));</span>
<span class="c1">//vamos ler o valor de 5 notas:</span>
<span class="k">for</span> <span class="p">(</span><span class="n">i</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span><span class="n">i</span><span class="o"><</span><span class="mi">5</span><span class="p">;</span><span class="n">i</span><span class="o">++</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"Digite o valor da nota %d: "</span><span class="p">,</span> <span class="n">i</span><span class="p">);</span>
<span class="c1">//Essa instrução:</span>
<span class="c1">//scanf("%f", notas[i]);</span>
<span class="c1">//é igual a essa:</span>
<span class="n">scanf</span><span class="p">(</span><span class="s">"%f"</span><span class="p">,</span> <span class="p">(</span><span class="n">notas</span><span class="o">+</span><span class="n">i</span><span class="p">));</span> <span class="c1">//soma-se: endereço_inicial+salto*tamanho_da_variável</span>
<span class="c1">//ou seja: notas + i*sizeof(float)</span>
<span class="p">}</span>
<span class="c1">// vendo se leu tudo corretamente:</span>
<span class="k">for</span> <span class="p">(</span><span class="n">i</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span><span class="n">i</span><span class="o"><</span><span class="mi">5</span><span class="p">;</span><span class="n">i</span><span class="o">++</span><span class="p">)</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"Nota %d: %.2f</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">i</span><span class="p">,</span> <span class="n">notas</span><span class="p">[</span><span class="n">i</span><span class="p">]);</span>
<span class="c1">//achando a maior nota:</span>
<span class="n">aux</span> <span class="o">=</span> <span class="o">&</span><span class="n">notas</span><span class="p">[</span><span class="mi">0</span><span class="p">];</span> <span class="c1">//ponteiro "aux" apontando para a primeira nota</span>
<span class="k">for</span> <span class="p">(</span><span class="n">i</span><span class="o">=</span><span class="mi">1</span><span class="p">;</span><span class="n">i</span><span class="o"><</span><span class="mi">5</span><span class="p">;</span><span class="n">i</span><span class="o">++</span><span class="p">)</span> <span class="c1">//percorrendo os demais elementos de notas</span>
<span class="p">{</span>
<span class="k">if</span> <span class="p">(</span><span class="n">notas</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">></span> <span class="o">*</span><span class="n">aux</span><span class="p">)</span>
<span class="n">aux</span> <span class="o">=</span> <span class="o">&</span><span class="n">notas</span><span class="p">[</span><span class="n">i</span><span class="p">];</span>
<span class="p">}</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"A maior nota é %.2f</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="o">*</span><span class="n">aux</span><span class="p">);</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"Mas eu não sei sua posição, pois não guardei o valor de 'i'.</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
<span class="c1">//liberando as posições alocadas pelo calloc para o vetor:</span>
<span class="n">free</span><span class="p">(</span><span class="n">notas</span><span class="p">);</span>
<span class="p">}</span>
</code></pre></div> </div>
</li>
<li>Exercícios:
<ol>
<li>Declare um vetor dinâmico (usando ponteiro e malloc – ou malloc) do tipo float com 10 elementos e inicialize os elementos com os valores 0.0, 1.1, 2.2, …, 9.9.</li>
<li>Declare uma variável estática e um ponteiro, ambos tipo float. Faça com que o ponteiro aponte para a variável estática e o utilize para trocar o valor da variável estática.</li>
<li>No programa de exemplo acima, mude o <code class="language-plaintext highlighter-rouge">printf</code> de:
<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code> <span class="k">for</span> <span class="p">(</span><span class="n">i</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span><span class="n">i</span><span class="o"><</span><span class="mi">5</span><span class="p">;</span><span class="n">i</span><span class="o">++</span><span class="p">)</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"Nota %d: %.2f</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">i</span><span class="p">,</span> <span class="n">notas</span><span class="p">[</span><span class="n">i</span><span class="p">]);</span>
</code></pre></div> </div>
<p>para seguir o exemplo de acesso ao vetor apresentado no <code class="language-plaintext highlighter-rouge">scanf</code> abaixo:</p>
<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code> <span class="k">for</span> <span class="p">(</span><span class="n">i</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span><span class="n">i</span><span class="o"><</span><span class="mi">5</span><span class="p">;</span><span class="n">i</span><span class="o">++</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"Digite o valor da nota %d: "</span><span class="p">,</span> <span class="n">i</span><span class="p">);</span>
<span class="n">scanf</span><span class="p">(</span><span class="s">"%f"</span><span class="p">,</span> <span class="p">(</span><span class="n">notas</span><span class="o">+</span><span class="n">i</span><span class="p">));</span>
<span class="p">}</span>
</code></pre></div> </div>
</li>
<li>Crie uma função que receba, como referência, um número do tipo <em>float</em> e o altere para seu dobro.</li>
<li>Crie um vetor dinâmico com 5 posições e uma função que deverá encontrar o menor elemento dele. A função deve receber o vetor por referência.</li>
<li>Crie um novo tipo de dado com idade e altura. Depois, uma variável dinâmica que armazene 4 estruturas desse novo tipo de dado. Então, uma função para encontrar a menor idade e a maior altura.</li>
<li>Passe todas as variáveis do programa abaixo para ponteiros:
<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code> <span class="cp">#include <stdio.h>
</span> <span class="cp">#include <string.h>
</span>
<span class="cp">#define TAM 5
</span>
<span class="k">typedef</span> <span class="k">struct</span> <span class="p">{</span>
<span class="kt">char</span> <span class="n">nome</span><span class="p">[</span><span class="mi">20</span><span class="p">];</span>
<span class="kt">float</span> <span class="n">valor</span><span class="p">;</span>
<span class="p">}</span><span class="n">tipoProduto</span><span class="p">;</span>
<span class="kt">void</span> <span class="nf">copia_produto</span><span class="p">(</span><span class="n">tipoProduto</span> <span class="o">*</span><span class="n">origem</span><span class="p">,</span> <span class="n">tipoProduto</span> <span class="o">*</span><span class="n">destino</span><span class="p">)</span>
<span class="p">{</span>
<span class="c1">// copia a string origem.nome para a destino.nome:</span>
<span class="n">strcpy</span><span class="p">(</span><span class="n">destino</span><span class="o">-></span><span class="n">nome</span><span class="p">,</span> <span class="n">origem</span><span class="o">-></span><span class="n">nome</span><span class="p">);</span>
<span class="n">destino</span><span class="o">-></span><span class="n">valor</span> <span class="o">=</span> <span class="n">origem</span><span class="o">-></span><span class="n">valor</span><span class="p">;</span>
<span class="p">}</span>
<span class="kt">int</span> <span class="nf">main</span><span class="p">()</span>
<span class="p">{</span>
<span class="n">tipoProduto</span> <span class="n">produtos</span><span class="p">[</span><span class="n">TAM</span><span class="p">],</span> <span class="n">mais_caro</span><span class="p">;</span>
<span class="kt">int</span> <span class="n">i</span><span class="p">;</span>
<span class="k">for</span> <span class="p">(</span><span class="n">i</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span><span class="n">i</span><span class="o"><</span><span class="n">TAM</span><span class="p">;</span><span class="n">i</span><span class="o">++</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"Produto %d:</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">i</span><span class="p">);</span>
<span class="n">printf</span><span class="p">(</span><span class="s">" Nome: "</span><span class="p">);</span>
<span class="n">scanf</span><span class="p">(</span><span class="s">"%s"</span><span class="p">,</span> <span class="n">produtos</span><span class="p">[</span><span class="n">i</span><span class="p">].</span><span class="n">nome</span><span class="p">);</span>
<span class="n">printf</span><span class="p">(</span><span class="s">" Valor: "</span><span class="p">);</span>
<span class="n">scanf</span><span class="p">(</span><span class="s">"%f"</span><span class="p">,</span> <span class="o">&</span><span class="n">produtos</span><span class="p">[</span><span class="n">i</span><span class="p">].</span><span class="n">valor</span><span class="p">);</span>
<span class="p">}</span>
<span class="c1">// considero o primeiro como o mais caro:</span>
<span class="n">copia_produto</span><span class="p">(</span><span class="o">&</span><span class="n">produtos</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="o">&</span><span class="n">mais_caro</span><span class="p">);</span>
<span class="c1">// percorrendo e comparando com os demais:</span>
<span class="k">for</span> <span class="p">(</span><span class="n">i</span><span class="o">=</span><span class="mi">1</span><span class="p">;</span><span class="n">i</span><span class="o"><</span><span class="n">TAM</span><span class="p">;</span><span class="n">i</span><span class="o">++</span><span class="p">)</span>
<span class="p">{</span>
<span class="k">if</span> <span class="p">(</span><span class="n">produtos</span><span class="p">[</span><span class="n">i</span><span class="p">].</span><span class="n">valor</span> <span class="o">></span> <span class="n">mais_caro</span><span class="p">.</span><span class="n">valor</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">copia_produto</span><span class="p">(</span><span class="o">&</span><span class="n">produtos</span><span class="p">[</span><span class="n">i</span><span class="p">],</span> <span class="o">&</span><span class="n">mais_caro</span><span class="p">);</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"O produto mais caro é o </span><span class="se">\"</span><span class="s">%s</span><span class="se">\"</span><span class="s">, custando R$ %.2f</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">mais_caro</span><span class="p">.</span><span class="n">nome</span><span class="p">,</span> <span class="n">mais_caro</span><span class="p">.</span><span class="n">valor</span><span class="p">);</span>
<span class="p">}</span>
</code></pre></div> </div>
</li>
</ol>
</li>
</ul>
</li>
</ul>
<p>Nos livros, tem mais exercícios. Aproveitem para fazer aprender cada vez mais.</p>
<hr />
<p><br />
Você pode ter acesso à <strong>ref2</strong> pela UFES através da Biblioteca Virtual. Para isso:</p>
<ul>
<li>Faça o cadastro na Biblioteca Digital Cengage seguindo <a href="https://biblioteca.ufes.br/sites/biblioteca.ufes.br/files/field/anexo/tutorial_para_realicar_cadasgro_para_acesso_a_biblioteca_digital_cengage.pdf">esses passos</a>.</li>
<li>Após isso, logue na <a href="https://plataforma.bvirtual.com.br/Account/Login">plataforma virtual da Cengage</a> e procure pelo livro.</li>
</ul>
<hr />
<p><br />
Também criei esses resumos de estruturas e um de funções:</p>
<ul>
<li><a href="/prog1/files/estruturas.pdf">Resumo de estruturas</a></li>
<li><a href="/prog1/files/funcoes.pdf">Resumo de funções</a></li>
</ul>
<p>Abraços</p>Os estudos, podem seguir os seguintes livros: ref1: Aguiar, M. O., Silva, R. F. Linguagem C: Introdução ao C em 10 aulas. ref2: Paul Deitel, Harvey Deitel. C: Como Programar. Pearson, 2011.Extra - Exercício Vôlei2022-07-27T12:58:56+00:002022-07-27T12:58:56+00:00http://www.jeiks.net/prog1/prog1/2022/07/27/exercicio-volei<p>Recebi, por e-mail, a pergunta de como fazer esse exercício:</p>
<blockquote>
<p>Em um campeonato Europeu de Volleyball, se inscreveram 30 países. Sabendo-se que na lista oficial de cada país consta, além de outros dados, peso e idade de 12 jogadores, crie um programa que leia e apresente as seguintes informações:
<br />• O peso médio e a idade média de cada um dos times;
<br />• O atleta mais pesado de cada time;
<br />• O atleta mais jovem de cada time;
<br />• O peso médio e a idade média de todos os participantes</p>
</blockquote>
<p>Resolvi fazer o exercício e disponibilizar para vocês.
<br />Lembro-lhes que é somente uma das formas de fazer o exercício.
<br />Como atividade, vocês podem tentar implementar (sozinhos e do zero) de outra forma, ou melhorando a atual.</p>
<p>Obs.: Como o exercício pede para 30 países e 12 jogadores, ficaria difícil de testá-lo. Portanto, eu implementei com duas macros que definem isso: NUM_PAISES e NUM_JOG. Assim, só mudar os números definidos nessas macros que o programa se adaptará à nova quantidade de países (times) e de jogadores por país/time.</p>
<p><a href="/prog1/files/exercises/exercicio_volei.html">Implementação disponível aqui</a></p>
<p>Para estudar, a melhor forma será imprimir e entender o funcionamento do código. Só então, vá testá-lo e modificá-lo no computador.</p>Recebi, por e-mail, a pergunta de como fazer esse exercício:Vetores Multidimensionais - Matrizes2022-07-15T19:47:24+00:002022-07-15T19:47:24+00:00http://www.jeiks.net/prog1/prog1/2022/07/15/vetores-multidimensionais<h3 id="slides"><a href="/prog1/files/slides/vetores-multidimensionais.pdf">Slides</a></h3>
<h3 id="conteúdo-do-livro-capítulo-4"><a href="https://drive.google.com/file/d/12pJXzerYzzJrkV_CLCAUX0K6ucX7EI51/view?usp=sharing">Conteúdo do livro (capítulo 4)</a></h3>
<h3 id="atividades-online"><a href="/prog1/files/exercises/vetores_02.html">Atividades online</a></h3>
<h3 id="atividades-práticas">Atividades práticas</h3>
<ol>
<li>Crie um programa que crie uma matriz de 10x10 preenchida com números aleatórios.
<ul>
<li>escreva todos os números dessa matriz na tela;</li>
<li>informe quantos números ímpares tem em cada coluna;</li>
<li>informe quantos números ímpares tem em cada linha;</li>
<li>imprima a soma dos números ímpares para cada coluna;</li>
<li>imprima a soma dos números ímpares para cada linha;</li>
<li>imprima a soma de todos os números ímpares da matriz;</li>
<li>imprima a soma de cada coluna;</li>
<li>imprima a soma de cada linha;</li>
<li>imprima a soma da diagonal.</li>
</ul>
</li>
</ol>SlidesAtividades Avaliativas - Vetores2022-07-09T20:53:52+00:002022-07-09T20:53:52+00:00http://www.jeiks.net/prog1/prog1/2022/07/09/atividades-avaliativas-vetores<h3 id="atividades-avaliativas-programas"><a href="/prog1/files/Atividades_avaliativas-Vetores.pdf">Atividades avaliativas</a> <a href="/prog1/files/Atividades_avaliativas-Vetores.html">(Programas)</a></h3>
<h4 id="instruções-para-entrega">Instruções para entrega:</h4>
<ul>
<li>As respostas deverão estar em um arquivo .zip, contendo:
<ul>
<li>Um documento em “DOC” ou “ODT”</li>
<li>O código fonte de todas as implementações que fez para resolver os exercícios.</li>
</ul>
</li>
<li>Entregar no Google Classroom</li>
<li>Data de entrega: 14/07/2022</li>
</ul>
<p>Obs.: fiz esses exercícios para que vocês possam aprender se exercitando.
E, por favor, não copie, você está enganando a si mesmo.
Na próxima avaliação, sua cópia aqui não terá sentido algum.</p>
<p>Abraços</p>Atividades avaliativas (Programas)Vetores2022-07-08T20:39:44+00:002022-07-08T20:39:44+00:00http://www.jeiks.net/prog1/prog1/2022/07/08/vetores<h3 id="slides"><a href="/prog1/files/slides/vetores.pdf">Slides</a></h3>
<h3 id="conteúdo-do-livro-capítulo-4"><a href="https://drive.google.com/file/d/12pJXzerYzzJrkV_CLCAUX0K6ucX7EI51/view?usp=sharing">Conteúdo do livro (capítulo 4)</a></h3>
<h3 id="atividades-online"><a href="/prog1/files/exercises/vetores_01.html">Atividades online</a></h3>
<h3 id="atividades-práticas">Atividades práticas</h3>
<ol>
<li>Crie um vetor de 30 posições e preencha com valores de 1 a 30. Depois, imprima seus valores na tela.</li>
<li>Crie um vetor de 20 posições e preencha com múltiplos de 2, sendo cada posição com valor 2*seu índice.</li>
<li>Crie um vetor de 15 posições só com números ímpares.</li>
<li>Crie um vetor, de forma automática, com a seguinte P.A.:<br />
2n+1, onde n = índice do vetor.<br />
Ele deve ser do tipo float e ter 100 posições.<br />
Após isso, imprima os 10 primeiros valores do vetor na tela.<br /></li>
<li>Copie o código pronto e funcional do programa 4 e adicione uma pesquisa por um número no vetor. Seu programa deve pedir um número ao usuário e, então, pesquisá-lo no vetor. Se encontrar, deve imprimir qual é o índice que o número desejado está. Caso contrário, deve imprimir “número não encontrado”.</li>
<li>Copie o código pronto e funcional do programa 4 e adicione um laço que permita percorrer todo o vetor e imprimir na tela os múltiplos de 3 ou de 5.</li>
<li>Faça um programa com um vetor de 20 números inteiros. Depois, imprima todos seus números em ordem reversa.</li>
<li>Faça um programa que armazene as notas das provas 1 e 2 de 5 alunos.
Depois, calcule e armazene a média arredondada em outro vetor.
Armazene também a situação do aluno: 1 para Aprovado ou 0 para Reprovado.
Então, o programa deve imprimir uma listagem com as notas, a média e a situação de cada aluno.</li>
</ol>SlidesAtividades de revisão para Avaliação2022-06-24T22:27:57+00:002022-06-24T22:27:57+00:00http://www.jeiks.net/prog1/prog1/2022/06/24/atividades_revisao_01<p><a href="/prog1/files/atividades_revisao-01.pdf">Pode fazer o download aqui</a></p>Pode fazer o download aquiAtividades 052022-06-10T20:17:45+00:002022-06-10T20:17:45+00:00http://www.jeiks.net/prog1/prog1/2022/06/10/atividades-05<p>Da seção 3.12 do <a href="https://drive.google.com/file/d/12pJXzerYzzJrkV_CLCAUX0K6ucX7EI51/view?usp=sharing">livro texto</a>, faça os exercícios:</p>
<ul>
<li>1,</li>
<li>3,</li>
<li>6,</li>
<li>8 (mas com 5 pessoas só),</li>
<li>11.</li>
</ul>
<p>Para cada exercício, crie seu código e teste. Ele deve compilar e funcionar.</p>
<p>Como postar no GitHub:</p>
<ul>
<li>nome do arquivo: <em>exerc_cap3_NUM.c</em>
<br />Sendo <em>NUM</em> o número do exercício.
<br />Exemplo para o exercício 1: <em>exerc_cap3_1.c</em></li>
<li>Data final para postar: <strong>22/06/22</strong></li>
</ul>Da seção 3.12 do livro texto, faça os exercícios: 1, 3, 6, 8 (mas com 5 pessoas só), 11.Laços de Repetição2022-06-10T18:10:00+00:002022-06-10T18:10:00+00:00http://www.jeiks.net/prog1/prog1/2022/06/10/lacos-de-repeticao<p>Estudem o capítulo 3 do <a href="https://drive.google.com/file/d/12pJXzerYzzJrkV_CLCAUX0K6ucX7EI51/view?usp=sharing">livro texto</a>.</p>
<p>Adicionalmente, segue uma explicação adicional. Por favor, tentem compilar e executar cada um dos exemplos de código.</p>
<p>Muitas vezes, em programas em <strong>C</strong>, torna-se necessário repetir trechos de código por uma certa quantidade de vezes. Algumas vezes, conhecemos a quantidade de repetições (iterações), mas outras vezes a quantidade de iterações é determinada somente na hora que o programa está executando.</p>
<p>Suponham, por exemplo, o problema que fizemos em sala, onde deve-se calcular o caixa da semana para o vovô Inácio, recebendo o valor de cada dia:</p>
<figure class="highlight"><pre><code class="language-c" data-lang="c"><span class="cp">#include <stdio.h>
</span><span class="kt">int</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
<span class="kt">float</span> <span class="n">recebido</span><span class="p">,</span> <span class="n">pagamentos</span><span class="p">,</span> <span class="n">soma</span><span class="p">,</span> <span class="n">auxilio</span><span class="p">;</span>
<span class="n">recebido</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="n">pagamentos</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="n">soma</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="c1">// Segunda-Feira:</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"Digite o valor recebido na segunda-feira: "</span><span class="p">);</span>
<span class="n">scanf</span><span class="p">(</span><span class="s">"%f"</span><span class="p">,</span> <span class="o">&</span><span class="n">auxilio</span><span class="p">);</span>
<span class="n">recebido</span> <span class="o">+=</span> <span class="n">auxilio</span><span class="p">;</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"Digite o valor pago na segunda-feira: "</span><span class="p">);</span>
<span class="n">scanf</span><span class="p">(</span><span class="s">"%f"</span><span class="p">,</span> <span class="o">&</span><span class="n">auxilio</span><span class="p">);</span>
<span class="n">pagamentos</span> <span class="o">+=</span> <span class="n">auxilio</span><span class="p">;</span>
<span class="c1">// soma:</span>
<span class="n">soma</span> <span class="o">=</span> <span class="n">recebido</span> <span class="o">-</span> <span class="n">pagamentos</span><span class="p">;</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"[Valor do caixa atual: R$ %.2f]</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">soma</span><span class="p">);</span>
<span class="c1">// avisos:</span>
<span class="k">if</span> <span class="p">(</span><span class="n">soma</span> <span class="o">></span> <span class="mi">2000</span><span class="p">)</span> <span class="p">{</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"AVISO:</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
<span class="n">printf</span><span class="p">(</span><span class="s">" Total de dinheiro recebido: R$ %.2f</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">recebido</span><span class="p">);</span>
<span class="n">printf</span><span class="p">(</span><span class="s">" Total de pagamentos realizados: R$ %.2f</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">pagamentos</span><span class="p">);</span>
<span class="n">printf</span><span class="p">(</span><span class="s">" Saldo atual: R$ %.2f</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">soma</span><span class="p">);</span>
<span class="p">}</span> <span class="k">else</span> <span class="k">if</span> <span class="p">(</span><span class="n">soma</span> <span class="o"><</span> <span class="o">-</span><span class="mi">500</span><span class="p">)</span> <span class="p">{</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"AVISO:</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
<span class="n">printf</span><span class="p">(</span><span class="s">" Total de dinheiro recebido: R$ %.2f</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">recebido</span><span class="p">);</span>
<span class="n">printf</span><span class="p">(</span><span class="s">" Total de pagamentos realizados: R$ %.2f</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">pagamentos</span><span class="p">);</span>
<span class="n">printf</span><span class="p">(</span><span class="s">" Saldo atual: R$ %.2f</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">soma</span><span class="p">);</span>
<span class="p">}</span>
<span class="c1">// Terça-Feira:</span>
<span class="c1">// mesmo código de cima, mas para terça feira</span>
<span class="c1">// Repete o código de novo para o resto da semana</span>
<span class="p">}</span></code></pre></figure>
<p>Há três formas de iterações de códigos em <strong>C</strong>.</p>
<figure class="highlight"><pre><code class="language-c" data-lang="c"><span class="c1">// utilizando o for:</span>
<span class="k">for</span> <span class="p">(</span><span class="n">valor_inicial</span><span class="p">;</span> <span class="n">teste_condicional</span><span class="p">;</span> <span class="n">incremento_ou_decremento</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">escopo</span> <span class="n">a</span> <span class="n">executar</span>
<span class="p">}</span>
<span class="c1">// utilizando o while:</span>
<span class="k">while</span> <span class="p">(</span><span class="n">teste_condicional</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">escopo</span> <span class="n">a</span> <span class="n">executar</span>
<span class="p">}</span>
<span class="c1">// utilizando do-while</span>
<span class="k">do</span> <span class="p">{</span>
<span class="n">escopo</span> <span class="n">a</span> <span class="n">executar</span>
<span class="p">}</span> <span class="k">while</span><span class="p">(</span><span class="n">teste_condicional</span><span class="p">);</span></code></pre></figure>
<p>Para ficar mais fácil de gravar, traduza para o português as palavras chaves (for=para;while=enquanto;do=faça) e pense assim:</p>
<ul>
<li>laço <code class="language-plaintext highlighter-rouge">for</code>:
<ul>
<li><em>para</em> o <code class="language-plaintext highlighter-rouge">valor_inicial</code> igual a um número, eu repito:
<ul>
<li>se o <code class="language-plaintext highlighter-rouge">teste_condicional</code> for verdadeiro:
<ul>
<li>executo o <code class="language-plaintext highlighter-rouge">escopo a executar</code>,</li>
<li>faço o <code class="language-plaintext highlighter-rouge">incremento_ou_decremento</code></li>
</ul>
</li>
<li>senão, saio do laço.</li>
</ul>
</li>
</ul>
</li>
<li>laço <code class="language-plaintext highlighter-rouge">while</code>:
<ul>
<li><em>enquanto</em> o <code class="language-plaintext highlighter-rouge">teste_condicional</code> for verdadeiro, repita:
<ul>
<li><code class="language-plaintext highlighter-rouge">escopo a executar</code></li>
</ul>
</li>
</ul>
</li>
<li>laço <code class="language-plaintext highlighter-rouge">do-while</code>:
<ul>
<li><em>faça</em> (ou execute) repetidamente:
<ul>
<li>o <code class="language-plaintext highlighter-rouge">escopo a executar</code></li>
<li>se <code class="language-plaintext highlighter-rouge">teste_condicional</code> for falso, saia do laço.</li>
</ul>
</li>
</ul>
</li>
</ul>
<p>No exemplos abaixo, vamos simplesmente escrever na tela os números de 1 à 10 utilizando cada um desses tipos de laços. Tente entender como é a execução de cada um. Para isso, anote a saída na tela e o valor das variáveis em cada iteração (repetição do laço).</p>
<figure class="highlight"><pre><code class="language-c" data-lang="c"><span class="c1">// Utilizando o for:</span>
<span class="cp">#include <stdio.h>
</span><span class="kt">int</span> <span class="nf">main</span><span class="p">()</span>
<span class="p">{</span>
<span class="kt">int</span> <span class="n">num</span> <span class="o">=</span> <span class="mi">1</span><span class="p">,</span> <span class="n">i</span><span class="p">;</span>
<span class="k">for</span> <span class="p">(</span><span class="n">i</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span><span class="n">i</span><span class="o"><</span><span class="mi">5</span><span class="p">;</span><span class="n">i</span><span class="o">++</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"Numero: %d</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">num</span><span class="o">++</span><span class="p">);</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="c1">// Utilizando o while:</span>
<span class="cp">#include <stdio.h>
</span><span class="kt">int</span> <span class="nf">main</span><span class="p">()</span>
<span class="p">{</span>
<span class="kt">int</span> <span class="n">num</span> <span class="o">=</span> <span class="mi">1</span><span class="p">,</span> <span class="n">i</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span>
<span class="k">while</span> <span class="p">(</span><span class="n">i</span> <span class="o"><</span> <span class="mi">5</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"Numero: %d</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">num</span><span class="o">++</span><span class="p">);</span>
<span class="n">i</span><span class="o">++</span><span class="p">;</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="c1">// Utilizando o do-while:</span>
<span class="cp">#include <stdio.h>
</span><span class="kt">int</span> <span class="nf">main</span><span class="p">()</span>
<span class="p">{</span>
<span class="kt">int</span> <span class="n">num</span> <span class="o">=</span> <span class="mi">1</span><span class="p">,</span> <span class="n">i</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span>
<span class="k">do</span>
<span class="p">{</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"Numero: %d</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">num</span><span class="o">++</span><span class="p">);</span>
<span class="n">i</span><span class="o">++</span><span class="p">;</span>
<span class="p">}</span><span class="k">while</span> <span class="p">(</span><span class="n">i</span> <span class="o"><</span> <span class="mi">5</span><span class="p">);</span>
<span class="p">}</span></code></pre></figure>
<p>A principal diferença entre eles é que o <code class="language-plaintext highlighter-rouge">for</code> já possui o incremento em um de seus argumentos. Já o <code class="language-plaintext highlighter-rouge">while</code> e o <code class="language-plaintext highlighter-rouge">do-while</code> necessitam que você controle o valor da variável que será controlada no <code class="language-plaintext highlighter-rouge">teste_condicional</code>. Se você não fizer esse controle, o seu programa ficará agarrado executando o <code class="language-plaintext highlighter-rouge">escopo a executar</code> para sempre (ou até que você peça o sistema operacional para finalizar o programa).</p>
<p>Assim, o programa para ajudar o vovô Inácio pode ser refeito da seguinte forma:</p>
<figure class="highlight"><pre><code class="language-c" data-lang="c"><span class="cp">#include <stdio.h>
</span><span class="kt">int</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
<span class="kt">float</span> <span class="n">recebido</span><span class="p">,</span> <span class="n">pagamentos</span><span class="p">,</span> <span class="n">soma</span><span class="p">,</span> <span class="n">auxilio</span><span class="p">;</span>
<span class="kt">int</span> <span class="n">dia</span><span class="p">;</span>
<span class="n">recebido</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="n">pagamentos</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="n">soma</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"Por favor, considere:</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"1: segunda-feira</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"2: terça-feira</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"3: quarta-feira</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"4: quinta-feira</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"5: sexta-feira</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
<span class="k">for</span> <span class="p">(</span><span class="n">dia</span><span class="o">=</span><span class="mi">1</span> <span class="p">;</span> <span class="n">dia</span><span class="o"><=</span><span class="mi">5</span><span class="p">;</span> <span class="n">dia</span><span class="o">++</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"</span><span class="se">\n</span><span class="s">[Dia: %d]</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">dia</span><span class="p">);</span>
<span class="n">printf</span><span class="p">(</span><span class="s">" Digite o valor recebido: "</span><span class="p">);</span>
<span class="n">scanf</span><span class="p">(</span><span class="s">"%f"</span><span class="p">,</span> <span class="o">&</span><span class="n">auxilio</span><span class="p">);</span>
<span class="n">recebido</span> <span class="o">+=</span> <span class="n">auxilio</span><span class="p">;</span>
<span class="n">printf</span><span class="p">(</span><span class="s">" Digite o valor dos pagamentos: "</span><span class="p">);</span>
<span class="n">scanf</span><span class="p">(</span><span class="s">"%f"</span><span class="p">,</span> <span class="o">&</span><span class="n">auxilio</span><span class="p">);</span>
<span class="n">pagamentos</span> <span class="o">+=</span> <span class="n">auxilio</span><span class="p">;</span>
<span class="c1">// soma:</span>
<span class="n">soma</span> <span class="o">=</span> <span class="n">recebido</span> <span class="o">-</span> <span class="n">pagamentos</span><span class="p">;</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"[Valor do caixa atual: R$ %.2f]</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">soma</span><span class="p">);</span>
<span class="c1">// aviso:</span>
<span class="k">if</span> <span class="p">(</span><span class="n">soma</span> <span class="o">></span> <span class="mi">2000</span> <span class="o">||</span> <span class="n">soma</span> <span class="o"><</span> <span class="o">-</span><span class="mi">500</span><span class="p">)</span> <span class="c1">//podemos melhorar aqui também</span>
<span class="p">{</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"===== AVISO: =====</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
<span class="n">printf</span><span class="p">(</span><span class="s">" Total de dinheiro recebido: R$ %.2f</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">recebido</span><span class="p">);</span>
<span class="n">printf</span><span class="p">(</span><span class="s">" Total de pagamentos realizados: R$ %.2f</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">pagamentos</span><span class="p">);</span>
<span class="n">printf</span><span class="p">(</span><span class="s">" Saldo atual: R$ %.2f</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">soma</span><span class="p">);</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"==================</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="p">}</span></code></pre></figure>
<p>Como podemos ver, o código ficou bem menor e com menos repetições.</p>
<p>Tente reescrever esse código uma vez utilizando <code class="language-plaintext highlighter-rouge">for</code> e outra utilzando <code class="language-plaintext highlighter-rouge">do-while</code>.</p>
<p>Ah.. note que as repetições podem ser incrementando ou decrementando as variáveis. Exemplo:</p>
<figure class="highlight"><pre><code class="language-c" data-lang="c"><span class="cp">#include <stdio.h>
</span><span class="c1">// Incrementando:</span>
<span class="kt">int</span> <span class="nf">main</span><span class="p">()</span>
<span class="p">{</span>
<span class="kt">int</span> <span class="n">num</span><span class="p">;</span>
<span class="k">for</span> <span class="p">(</span><span class="n">num</span><span class="o">=</span><span class="mi">0</span> <span class="p">;</span> <span class="n">num</span><span class="o"><</span><span class="mi">5</span> <span class="p">;</span> <span class="n">num</span><span class="o">++</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"Numero: %d</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">num</span><span class="p">);</span>
<span class="p">}</span>
<span class="p">}</span></code></pre></figure>
<figure class="highlight"><pre><code class="language-c" data-lang="c"><span class="cp">#include <stdio.h>
</span><span class="c1">// Decrementando:</span>
<span class="kt">int</span> <span class="nf">main</span><span class="p">()</span>
<span class="p">{</span>
<span class="kt">int</span> <span class="n">num</span><span class="p">;</span>
<span class="k">for</span> <span class="p">(</span><span class="n">num</span><span class="o">=</span><span class="mi">5</span> <span class="p">;</span> <span class="n">num</span><span class="o">></span><span class="mi">0</span> <span class="p">;</span> <span class="n">num</span><span class="o">--</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"Numero: %d</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">num</span><span class="p">);</span>
<span class="p">}</span>
<span class="p">}</span></code></pre></figure>
<p>Execute esses programas e verifique a saída de cada um na tela.</p>Estudem o capítulo 3 do livro texto.Atividades 042022-06-10T16:22:00+00:002022-06-10T16:22:00+00:00http://www.jeiks.net/prog1/prog1/2022/06/10/atividades-04<h2 id="problema-1-zero-para-cancelar"><em>Problema 1:</em> Zero para cancelar</h2>
<p>Seu chefe está ao telefone, com muita pressa. Ele quer que você some uma sequência de números (de suas vendas) que ele vai falar rapidamente para você ao telefone.
<br />Ao final, ele deseja saber o valor total das vendas que ele já fez.
<br />Assim, seu chefe vai falar uma sequência de números e você deve ir somando eles.
<br />Foi combinado que você deve parar de somar e fornecer o resultado quando ele disser o número “zero”.</p>
<p><strong>Atividade:</strong></p>
<ol>
<li>Crie um arquivo com o nome “atividade-zero_cancelar-01.c”</li>
<li>Faça um programa para lhe ajudar a resolver esse problema.</li>
<li>E no início deste arquivo, crie um comentário com:
<ul>
<li>o algoritmo que você criou antes de implementar esse programa,</li>
<li>a escolha de cada tipo de variável,</li>
<li>a explicação do fluxo de execução do programa.</li>
</ul>
</li>
<li>Agora, melhore seu programa. Para isso:
<ol>
<li>crie um arquivo com o nome “atividade-zero_cancelar-02.c”</li>
<li>copie o conteúdo do arquivo anterior para esse arquivo.</li>
<li>Considere o seguinte complemento da história:
<em><br />Infelizmente, de vez em quando seu chefe fala números errados para você ao telefone.
<br />Mas seu chefe sempre percebe que falou um número errado logo após seu erro.
<br />Assim, vocês combinaram que, quando ele disser “menos um” (-1), você deve ignorar o último número corrente.</em></li>
<li>Então, ajuste o programa feito anteriormente para resolver esse problema.</li>
</ol>
</li>
</ol>
<hr />
<hr />
<h2 id="problema-2-sorte-grande"><em>Problema 2:</em> Sorte grande!</h2>
<p>Em uma escola moderna, eles resolveram fazer um jogo da sorte tecnológico.
<br />Para isso, eles querem sua ajuda.
<br />Informações para fazer o programa:</p>
<ul>
<li>são 5 prêmios;</li>
<li>os números da sorte para cada prêmio são: 7, 43, 56, 87, 92;</li>
<li>para cada um dos números da sorte, o professor informará:
<ul>
<li>o prêmio referente e</li>
<li>a senha para retirá-lo.</li>
</ul>
</li>
<li>após isso, cada aluno poderá digitar um número para tentar acertar um dos números da sorte;</li>
<li>caso o aluno acerte um dos números, ele deverá ser informado de qual prêmio ganhou e a senha para pegar o prêmio.</li>
</ul>
<p>Notas:</p>
<ul>
<li>o programa não pode dar o mesmo prêmio para mais de um aluno;</li>
<li>o programa deve encerrar quando não tiver mais nenhum prêmio disponível.</li>
</ul>
<p><strong>Atividade:</strong></p>
<ol>
<li>Crie um arquivo com o nome “atividade-sorte_grande.c”</li>
<li>Faça um programa para lhe ajudar a resolver esse problema.</li>
<li>E no início deste arquivo, crie um comentário com:
<ul>
<li>o algoritmo que você criou antes de implementar esse programa,</li>
<li>a escolha de cada tipo de variável,</li>
<li>a explicação do fluxo de execução do programa.</li>
</ul>
</li>
</ol>
<hr />
<hr />
<h2 id="problema-3-torneio-de-tênis"><em>Problema 3:</em> Torneio de tênis</h2>
<p>A prefeitura contratou um novo professor para ensinar as crianças do bairro a jogar tênis na quadra de tênis do parque municipal. O professor convidou todas as crianças do bairro interessadas em aprender a jogar tênis. Ao final do primeiro mês de aulas e treinamentos foi organizado um torneio em que cada participante disputou exatamente seis jogos. O professor vai usar o desempenho no torneio para separar as crianças em três grupos, de forma a ter grupos de treino em que os participantes tenham habilidades mais ou menos iguais, usando o seguinte critério:</p>
<ul>
<li>participantes que venceram 5 ou 6 jogos serão colocados no Grupo 1;</li>
<li>participantes que venceram 3 ou 4 jogos serão colocados no Grupo 2;</li>
<li>participantes que venceram 1 ou 2 jogos serão colocados no Grupo 3;</li>
<li>participantes que não venceram nenhum jogo não serão convidados a continuar com os treinamentos.</li>
</ul>
<p>Dada uma lista com o resultado dos jogos de um participante, escreva um programa para determinar em qual grupo ele será colocado.</p>
<h3 id="entrada">Entrada</h3>
<p>A entrada do programa consiste de seis linhas, cada linha indicando o resultado de um jogo do participante. Cada linha contém um único número: 1 se o participante venceu o jogo, ou 0 se perdeu o jogo. Não há empates nos jogos.</p>
<h3 id="saída">Saída</h3>
<p>Seu programa deve informar qual é o grupo em que o participante será colocado ou se ele deverá continuar treinando.</p>
<p><em>Exemplo 1:</em></p>
<blockquote>
<p>Entrada (valor que o usuário vai digitar):
<br /> 1
<br /> 1
<br /> 0
<br /> 0
<br /> 0
<br /> 1
<br /><br />
Saída do seu programa:
<br /> Ele deve ser colocado no grupo 2</p>
</blockquote>
<p><em>Exemplo 2:</em></p>
<blockquote>
<p>Entrada (valor que o usuário vai digitar):
<br /> 0
<br /> 0
<br /> 0
<br /> 0
<br /> 0
<br /> 0
<br /><br />
Saída do seu programa:
<br /> Ele deve continuar treinando</p>
</blockquote>
<p><strong>Atividade:</strong></p>
<ol>
<li>Crie um arquivo com o nome “atividade-torneio_tenis.c”</li>
<li>Faça um programa para resolver esse problema.</li>
<li>E no início deste arquivo, crie um comentário com:
<ul>
<li>o algoritmo que você criou antes de implementar esse programa,</li>
<li>a escolha de cada tipo de variável,</li>
<li>a explicação do fluxo de execução do programa.</li>
</ul>
</li>
</ol>Problema 1: Zero para cancelar