Portuguese, Brazilian subtitles

← 07xps-09 Bending Numbers Solution

07xps-09 Simplificando Números

Get Embed Code
3 Languages

Showing Revision 1 created 02/26/2013 by Lucilia Figueiredo.

  1. Neste exercício, nós pedimos que você
  2. fizesse algumas otimizações. As otimizações básicas
  3. que você pode fazer são otimizações muito, muito
  4. simples, sobre operações binárias,
  5. aritmética básica. E as que nós pedimos especificamente
  6. que você fizesse são estas aqui, além de
  7. substituir expressões por constantes, quando se aplica.
  8. Então, nós demos a você esta aqui e depois,
  9. para adicionar as outras, nós simplesmente fazemos
  10. este grande comando if-then-else. Então, a primeira
  11. é: nós verificamos se a operação é *,
  12. verificamos se a é "number", e se é o número 1,
  13. e, se for esse o caso, bem, 1 vezes
  14. qualquer coisa é esta segunda coisa -- e isso é b.
  15. Então, simplesmente retornamos b. Não teremos que executar
  16. isso quando estivermos interpretando.
  17. Isso gastaria mais eforço do que é necessário. Agora,
  18. temos que fazer o mesmo para o próximo: se b é 1
  19. e a é alguma outra coisa, simplesmente retornamos a.
  20. Agora podemos fazer a mesma coisa para adição com 0.
  21. Simplesmente verificamso se a operação é +
  22. e se a é um "number" e é o número 0,
  23. e então retornamos b. Se b for um
  24. "number" e for 0, então retornamos a.
  25. Finalmente, a última que pedimos que você fizesse é
  26. implementar que um número menos ele próprio é 0.
  27. Isso é muito fácil. Verificamos se
  28. a operação é - e então se
  29. a == b e, lembre-se, você pode fazer isso
  30. porque você pode verificar, em Python, se tuplas são
  31. iguais, não apenas para números. Então,
  32. nós retornamos a tupla ("number",0), para
  33. incluir o número 0 na nossa árvore de sintaxe abstrata.
  34. Agora, a simplificação de constantes dá um pouco mais de trabalho,
  35. mas não muito. Primeiro, verificamos se
  36. os elementos da tupla -- a e b -- são ambos
  37. do tipo "number". Então, se a operação é adição,
  38. se a operação é +, nós retornamos
  39. ("number", a+b).
  40. Desse modo, não teremos que executar
  41. essa operação mais tarde, quando estivermos
  42. executando o programa. E podemos fazer a mesma coisa,
  43. se a operação for subtração.
  44. Neste caso retornamos a tupla
  45. ("number", a-b).
  46. E de modo análogo para multiplicação: fazemos
  47. a mesma coisa para os elementos a e b --
  48. multiplicamos os dois. E uma vez que nós
  49. esperamos que essas operações sejam
  50. otimizadas de algum modo, nós as encapsulamos
  51. de novo em uma operação binária -- uma tupla ("binop",a,b) --
  52. e depois retornamos isso. E se nenhuma dessas
  53. funciona, se nós nem mesmo temos um "binop"
  54. para começar, simplesmente retornamos a expressão,
  55. porque tudo isso que estamos fazendo são otimizações.
  56. Então, vamos tentar isso com alguns destes casos de teste.
  57. Estes são os casos de teste que
  58. fornecemos para você. Temos zero, one e two --
  59. que são os números 0, 1 e 2 -- e
  60. algumas variáveis, que são antigos reis e rainhas
  61. da Pérsia e da Macedônia -- xerxes,
  62. darius, antiochus e musa. E então vamos definir
  63. um operação plus, apenas para que
  64. não tenhamos que escrever esta tupla,
  65. assim como uma operação minus e uma times,
  66. simplesmente para econimizar digitação.
  67. E, então, vamos verificar se
  68. uma expressão tal como, digamos, times(two,zero)
  69. é igual a zero, isto é, se a otimização realmente é feita.
  70. Vamos fazer a mesma coisa
  71. para a operação minus, e para outra operação,
  72. ligeiramente mais complicada: a terceira expressão é
  73. minus(plus(zero,plus(one,plus(two,zero)))),two).
  74. Isso é bem longo, então vamos examinar
  75. com um pouco mais de cuidado.
  76. plus(two,zero) -- 2+0 -- e depois encapsulamos isso
  77. nesta chamada a plus -- (2+0)+1 --
  78. e depois usamos isso em um plus com zero e, depois,
  79. de tudo isso, subtraímos com 2.
  80. Portanto, isso realmente deve dar simplesmente 3-2,
  81. se você conseguir passar por todos esses parênteses.
  82. Então, imprimos isso e
  83. nos certificamos de que, de fato, é igual a one.
  84. Fazemos a mesma coisa para essas outras expressões.
  85. Então, quando executamos isso,
  86. vemos que passamos em todos os casos de teste.
  87. E esses casos de teste envolvem um bocado de
  88. trabalho, onde simplesmente fizemos tudo isso
  89. para verificar que isso é o que deveria ser a resposta,
  90. e depois verificar que a otimização
  91. de fato faz o que pensamos que deve fazer.
  92. Essa não é necessariamente a forma como você
  93. faria normelmente, mas é suficientemente bom para
  94. serir aos nossos propósitos.