perguntas_Basicas.html 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261
  1. <!DOCTYPE HTML>
  2. <html>
  3. <head>
  4. <meta charset="UTF-8"/>
  5. <title>Exemplos</title>
  6. </head>
  7. <body>
  8. <h1>3 - Perguntas básicas para implementar um algoritmo</h1>
  9. <p>
  10. No restante desta apostila procuraremos mostrar como desenvolver programas utilizando as linguagens C e Python. Os problemas que abordaremos são, em sua
  11. maioria, bastante simples, no sentido de ser possível resolvê-los manualmente (sem o auxílio de programas de computador). A dificuldade consiste em obter
  12. soluções computacinais para tais problemas, ou seja, em escrever um processo que resolva tais problemas servindo-se de uma linguagem extremamente rígida e
  13. um pouco limitada.<br />
  14. Um <b>programa</b> pode ser entendido como uma sequência finita de comandos que manipulam um numero limitado de variaveis e que deve devolver
  15. algum conjunto-resposta. Em geral, os problemas que admitem solucoes via computador apresentam caracterısticas de repeticao, isto ́e, permitem que
  16. uma mesma sequência de passos seja repetida (um numero finito de vezes) ate que se obtenha o resultado desejado.<br />
  17. Sugerimos ao leitor, principalmente aos iniciantes em programação, que se concentre em quatro questões chaves à resolução de problemas via algoritmos,
  18. independentemente da linguagem a ser utilizada, seja ela qual for.<br />
  19. <ul>
  20. <li><b>1ª Pergunta:</b> Quais variáveis são necessárias?</li>
  21. <li><b>2ª Pergunta:</b> Quais comandos devem apareceer dentro de um bloco de repetição?</li>
  22. <li><b>3ª Pergunta:</b> Qual a condição para que continue a repetição?</li>
  23. <li><b>4ª Pergunta:</b> Quais os comandos neceessários antes e depois do bloco de repetição?</li>
  24. </ul>
  25. <br />
  26. Nem sempre é possível responder completamente estas perguntas nesta sequência. Muitas vezes, ao longo da descrição do programa surge a necessidades de novas
  27. variáveis, que devem ser acrescentadas à lista inicialmente pensada como resposta à 1ª pergunta. Por outro lado, com o passar do tempo (e aquisiçao de
  28. experiência na programação), será natural que ao tentar responder a 2ª pergunta ja se note a necessidade de alguns comandos que devem aparecer antes do
  29. bloco de repetição (4ª pergunta). Alem disto, somente “problemas pequenos” possuem um ́unico bloco de repetição, sendo que as perguntas 2 a 4 devem ser
  30. levadas em conta para cada novo bloco de repetição. No entanto, a experiência tem-nos mostrado que, pelo menos enquanto se esta comecando a aprender a
  31. descrever processos em liguagens estruturadas, estas perguntas servem como um bom roteiro ao programador iniciante.<br />
  32. Veremos, a seguir, o desenvolvimento de programas para alguns problemas.
  33. </p>
  34. <h2>3.1 - Como somar um número arbitrário de valores</h2>
  35. <p>
  36. <b>Problema: </b> Faça um programa que leia uma sequência de números inteiros, diferentes de zero, e calcule a sua soma.<br />
  37. <br />
  38. Se a sequência de entrada tivesse um tamanho fixo conhecido, digamos 4, a descrição do processo não seria complicada, bastando escrever:
  39. <center>
  40. <table border='1'>
  41. <tr>
  42. <th> C </th>
  43. <th>Python</th></tr>
  44. <tr>
  45. <td>
  46. <pre>
  47. #include < stdio.h> //inclui a biblioteca que lida com scanf e printf
  48. int main(){ //inicia a função principal
  49. int n1, n2, n3, n4, soma; //cria as 5 variáveis que serão utilizadas
  50. scanf("%d %d %d %d", &n1, &n2, &n3, &n4); //lê 4 inteiros
  51. soma = n1+n2+n3+n4; //soma os 4 inteiros lidos
  52. printf("%d", soma); //imprime o resultado da soma
  53. return 0; //finaliza a função principal
  54. }
  55. </pre>
  56. </td>
  57. <td>
  58. <pre>
  59. n1 = input() //lê o primeiro inteiro
  60. n2 = input() //lê o segundo inteiro
  61. n3 = input() //lê o terceiro inteiro
  62. n4 = input() //lê o quarto inteiro
  63. soma = n1+n2+n3+n4 //soma os 4 inteiros
  64. print(soma) //imprime o resultado da soma
  65. </pre>
  66. </td>
  67. </tr>
  68. </table>
  69. </center>
  70. <br />
  71. No entanto a solução muda radicalmente se desejamos escrever um algoritmo que funcione para um número arbitrário de valores de entrada (este número é
  72. definido pelo usuário durante a execução do algoritmo). Neste caso, a dificuldade reside no fato de o programa ser capaz de somar uma sequência de qualquer
  73. tamanho.<br /><br />
  74. Antes de continuar, reflita um pouco sobre esta questão e tente escrever um código que permita a soma de uma sequência de qualquer tamanho.<br /><br />
  75. Duas possíveis soluções são:
  76. <ul>
  77. <li>Ao início da execução do algoritmo o usuário digitar qual o tamanho da sequência</li>
  78. <li>Utilizarmos um caracter de escape que indicará o final da sequência</li>
  79. </ul>
  80. <br />
  81. Abaixo iremos apresentar a segunda solução, utilizar um caracter de escape.<br />
  82. Uma boa técnica para iniciar o processo de rogramação é admitir algumas sequências de dados de entrada e pensar a partir destes dados. Então examinaremos,
  83. por exemplo, a soma da seguinte sequência de entrada: 8 11 3 -7 2 ... 0
  84. <ol>
  85. <li>Leia o primeiro número 8;</li>
  86. <li>Como o número lido !=(diferente) 0, leia o próximo número 3, guardando a soma destes dois 19+3 = 22;</li>
  87. <li>Como o último número lido != 0, leia o próximo número 3, guardando com a soma anterior 19+3=22;</li>
  88. <li>Como o último número lido != 0, leia o próximo número -7, guardando com a soma anterior 22+(-7)=15;</li>
  89. <center>
  90. <pre>
  91. .
  92. .
  93. .
  94. </pre>
  95. </center>
  96. <li>Lê o 0, e como o número lido foi 0 imprime a soma final</li>
  97. </ol>
  98. <h3>Quais variáveis são necessárias?</h3>
  99. Vemos a necessidades de 2 variáveis: uma para guardar o último número lido e outra para guardar a soma dos número já lidos. Então teremos:
  100. <center>
  101. <table border='1'>
  102. <tr>
  103. <th> C </th>
  104. <th>Python</th></tr>
  105. <tr>
  106. <td>
  107. <pre>int num, soma;</pre>
  108. </td>
  109. <td>
  110. <pre>
  111. num = 0
  112. soma = 0</pre>
  113. </td>
  114. </tr>
  115. </table>
  116. </center>
  117. <h3>Quais os comandos necessários antes e depois do bloco de repetição?</h3>
  118. <p>
  119. Inicialmente, no código em C o valor das variáveis(quaisquer) está indefinido, já no código em Python está definido em 0 e portanto devemos cuidar das
  120. "inicializações" antes do primeiro teste <b>while (num !=0)</b>. Quanto deve valer a variável num neste momento inicial?<br />
  121. Uma solução possível é o tratamento do primeiro número da sequência como caso à parte, antes de entrarmos no comando de repetição. Deste modo, devemos ler
  122. o primeiro número fora da repetição e já contabilizar na soma.<br />
  123. <br />
  124. <b>Exercício 1</b> Tente elaborar outra solução, que não faça uma primeira leitura de num dentro do laço<br />
  125. <br />
  126. Após a repetição devemos imprimir o conteúdo da variável <b>soma</b>, que deverá conter a soma dos elementos da sequência de entrada.<br />
  127. Escrevendo o código temos:<br />
  128. <center>
  129. <table border='1'>
  130. <tr>
  131. <th> C </th>
  132. <th>Python</th></tr>
  133. <tr>
  134. <td>
  135. <pre>
  136. 1 int num, soma;
  137. 2 scanf("%d", &num);
  138. 3 soma = num;
  139. 4 while (num != 0){
  140. 5 scanf(%d, &num);
  141. 6 soma = soma + num;
  142. 7 }
  143. 8 printf("%d",soma);
  144. </pre>
  145. </td>
  146. <td>
  147. <pre>
  148. 1 num = input();
  149. 2 soma = num;
  150. 3 while num != 0
  151. 4 num = input()
  152. 5 soma = soma + num
  153. 6 print(soma)
  154. </pre>
  155. </td>
  156. </tr>
  157. </table>
  158. </center>
  159. <h3>Conceito de simulação de um Algoritmo</h3>
  160. Um conceito muito importante à programação é o processo de <b>simulação</b> de um algoritmo. Útil na verificação da corretude do mesmo e também para entender
  161. o seu funcionamento. Na simulação de um algoritmo/programa devemos anotar todas as alterações, de todas suas variáveis, ao longo de seu fluxo de execução para algum
  162. conjunto de entrada<br />
  163. Melhor que muitas explicações complicadas é um bom exemplo. Vejamos a simulação do programa acima para o conjunto de entradas 10 3 4 0 no algoritmo em C:
  164. <center>
  165. <table border='1'>
  166. <tr>
  167. <th>num</th>
  168. <th>soma</th>
  169. <th>comando em execução</th>
  170. <th>observações</th>
  171. </tr>
  172. <tr>
  173. <td>?</td>
  174. <td>?</td>
  175. <td> </td>
  176. <td>no início do programa valores das variáveis são desconhecidos, elas apenas foram declaradas</td>
  177. </tr>
  178. <tr>
  179. <td>10</td>
  180. <td>?</td>
  181. <td>scanf("%d", &num)</td>
  182. <td>pega o 1º número de entrada e guarda em num</td>
  183. </tr>
  184. <tr>
  185. <td>10</td>
  186. <td>10</td>
  187. <td>soma = num</td>
  188. <td>Atribui o valor de num a soma</td>
  189. </tr>
  190. <tr>
  191. <td>10</td>
  192. <td>10</td>
  193. <td> while (num != 0) </td>
  194. <td>Como num é diferente de 0, executa os comandos dentro do bloco de repetição (linhas 5 e 6)</td>
  195. </tr>
  196. <tr>
  197. <td>3</td>
  198. <td>10</td>
  199. <td> scanf("%d", num) </td>
  200. <td>Recebe o 2º número de entrada e guarda em num</td>
  201. </tr>
  202. <tr>
  203. <td>3</td>
  204. <td>13</td>
  205. <td> soma = soma + num </td>
  206. <td>atribui a soma o valor da expressão soma + num</td>
  207. </tr>
  208. <tr>
  209. <td>3</td>
  210. <td>13</td>
  211. <td> while(num!=0) </td>
  212. <td>Como num é diferente de 0, o programa continuará a repetição</td>
  213. </tr>
  214. <tr>
  215. <td>4</td>
  216. <td>13</td>
  217. <td> scanf("%d", num) </td>
  218. <td></td>
  219. </tr>
  220. <tr>
  221. <td>4</td>
  222. <td>17</td>
  223. <td>soma = soma+ num</td>
  224. <td></td>
  225. </tr>
  226. <tr>
  227. <td>4</td>
  228. <td>17</td>
  229. <td>while(num!=0)</td>
  230. <td></td>
  231. </tr>
  232. <tr>
  233. <td>0</td>
  234. <td>17</td>
  235. <td> soma = soma + num </td>
  236. <td></td>
  237. </tr>
  238. <tr>
  239. <td>0</td>
  240. <td>17</td>
  241. <td> while(num!=0) </td>
  242. <td>Como soma é igual a 0, o programa pula para a linha 8</td>
  243. </tr>
  244. <tr>
  245. <td>0</td>
  246. <td>17</td>
  247. <td>printf("%d", soma)</td>
  248. <td>Imprime o valor de soma: 17</td>
  249. </tr>
  250. </table>
  251. </center>
  252. </p>
  253. </body>
  254. </html>