en to pt translation catalogue (1461 entries)

note: type: Content of: outside any tag (error?)
en: This world was invented by Lyn Turbak, at Wellesley College. It is full of Buggles, little animals understanding simple orders, and offers numerous possibilities of interaction with the world: taking or dropping objects, paint the ground, hit walls, etc.
pt: Este mundo foi inventado por Lyn Turbak, na Wellesley College. Está cheio de Buggles, pequenos animais que entendem ordens simples e oferece numerosas possiblidades de interação com o mundo: apanhar e soltar objetos, pintar o chão, bater em paredes, etc.

note: type: Content of: <h2>
en: Methods understood by buggles
pt: Métodos que os buggles entendem

note: type: Content of: <table><tr><td>
en: <b>Moving</b>
pt: <b>A mover</b>

note: type: Content of: <table><tr><td>
en: (See also the note on exceptions, below)
pt: (Veja também a nota sobre exceções, abaixo)

note: type: Content of: <table><tr><td><b>
en: <b>Turn left
pt: <b>Virar à esquerda

note: type: Content of: <table><tr><td><b>
en: Turn right
pt: Virar à direita

note: type: Content of: <table><tr><td><b>
en: Turn back
pt: Dar meia volta

note: type: Content of: <table><tr><td><b>
en: Moving forward
pt: Mover para a frente

note: type: Content of: <table><tr><td>
en: Moving back</b>
pt: Mover para trás</b>

note: type: Content of: <table><tr><td><b>
en: <b>Get X coordinate
pt: <b>Obter coordenada X

note: type: Content of: <table><tr><td><b>
en: Get Y coordinate
pt: Obter coordenada Y

note: type: Content of: <table><tr><td><b>
en: Set X coordinate
pt: Ajustar coordenada X

note: type: Content of: <table><tr><td><b>
en: Set Y coordinate
pt: Ajustar coordenada Y

note: type: Content of: <table><tr><td>
en: Set position</b>
pt: Ajustar posição</b>

note: type: Content of: <table><tr><td>
en: Note that the point (0,0) is on the top left corner, as it is often the case in Computer Science.
pt: Observe que o ponto (0,0) está no canto superior esquerdo, o que é comum em ciência da computação.

note: type: Content of: <table><tr><td>
en: <b>Information on the buggle</b>
pt: <b>Informações sobre o buggle</b>

note: type: Content of: <table><tr><td><b>
en: <b>Get the color of the body
pt: <b>Obter a cor do corpo

note: type: Content of: <table><tr><td>
en: Set the color of the body</b>
pt: Ajustar a cor do corpo</b>

note: type: Content of: <table><tr><td>
en: [!java|c]void [/!]setBodyColor([!java|c]Color [/!]c[!scala]:Color[/!])
pt: [!java|c]void [/!]setCorDoCorpo([!java|c]Cor [/!]c[!scala]:Cor[/!])

note: type: Content of: <table><tr><td><b>
en: <b>Look for a wall forward
pt: <b>Procura por uma parede à frente

note: type: Content of: <table><tr><td>
en: Look for a wall backward</b>
pt: Procura por uma parede atrás</b>

note: type: Content of: <table><tr><td><b>
en: <b>Get heading
pt: <b>Obter direção

note: type: Content of: <table><tr><td>
en: Set heading</b>
pt: Ajustar direção</b>

note: type: Content of: <table><tr><td>
en: valid directions are:
pt: direções válidas são:

note: type: Content of: <table><tr><td>
en: [!java|c]void [/!]setDirection([!java|c]Direction [/!]dir[!scala]:Direction[/!])
pt: [!java|c]void [/!]ajustaDireção([!java|c]Direção [/!]dir[!scala]:Direção[/!])

note: type: Content of: <table><tr><td>
en: [!scala|java|python]Direction.[/!]NORTH, [!scala|java|python]Direction.[/!]EAST, [!scala|java|python]Direction.[/!]SOUTH and [!scala|java|python]Direction.[/!]WEST
pt: [!scala|java|python]Direção.[/!]NORTE, [!scala|java|python]Direção.[/!]LESTE, [!scala|java|python]Direção.[/!]SUL e [!scala|java|python]Direção.[/!]OESTE

note: type: Content of: <table><tr><td>
en: Check whether the buggle is currently <b>selected in the interface</b>
pt: Verifica se o buggle está atualmente <b>selecionado na interface</b>

note: type: Content of: <table><tr><td>
en: <b>About the brush</b>
pt: <b>Sobre o pincel</b>

note: type: Content of: <table><tr><td><b>
en: <b>Brush down
pt: <b>Abaixar pincel

note: type: Content of: <table><tr><td><b>
en: Brush up
pt: Levantar pincel

note: type: Content of: <table><tr><td>
en: Get brush position</b>
pt: Obter a posição do pincel

note: type: Content of: <table><tr><td><b>
en: <b>Change the brush color
pt: <b>Muda a cor do pincel

note: type: Content of: <table><tr><td>
en: Get the color of the brush</b>
pt: Obtém a cor do pincel</b>

note: type: Content of: <table><tr><td>
en: [!java|c]void [/!]setBrushColor([!java|c]Color [/!]c[!scala]:Color[/!])
pt: [!java|c]void [/!]setCorDoPincel([!java|c]Color [/!]c[!scala]:Color[/!])

note: type: Content of: <table><tr><td>
en: <b>Interacting with the world</b>
pt: <b>A interagir com o mundo</b>

note: type: Content of: <table><tr><td>
en: <b>Get the color of the ground</b>
pt: <b>Obtém a cor do chão</b>

note: type: Content of: <table><tr><td><b>
en: <b>Look for a baggle on the ground
pt: <b>Procura por um "baggle" no chão

note: type: Content of: <table><tr><td><b>
en: Look for a baggle in bag
pt: Procura por um "baggle" na bolsa

note: type: Content of: <table><tr><td><b>
en: Pickup a baggle
pt: Apanhar um "baggle"

note: type: Content of: <table><tr><td>
en: Drop a baggle</b>
pt: Solta um "baggle"</b>

note: type: Content of: <table><tr><td>
en: (see the note on exceptions)
pt: (veja a nota sobre exceções)

note: type: Content of: <table><tr><td><b>
en: <b>Look for a message
pt: <b>Procura por uma mensagem

note: type: Content of: <table><tr><td><b>
en: Add a message
pt: Adiciona uma mensagem

note: type: Content of: <table><tr><td><b>
en: Read the message
pt: Lê a mensagem

note: type: Content of: <table><tr><td>
en: Erase the message</b>
pt: Apaga a mensagem</b>

note: type: Content of: <table><tr><td>
en: [!java]void [/!]writeMessage([!java]String [/!][!c]char* [/!]msg[!scala]:String[/!])
pt: [!java]void [/!]escreverMensagem([!java]String [/!][!c]char* [/!]msg[!scala]:String[/!])

note: type: Content of: <h2>
en: Valid colors
pt: Cores válidas

note: type: Content of: <table><tr><td>
en: Name
pt: Nome

note: type: Content of: <table><tr><td>
en: Color
pt: Cor

note: type: Content of: <table><tr><td>
en: [!scala|java|python]Color.[/!]black
pt: [!scala|java|python]Cor.[/!]black

note: type: Content of: <table><tr><td>
en: [!scala|java|python]Color.[/!]blue
pt: [!scala|java|python]Cor.[/!]azul

note: type: Content of: <table><tr><td>
en: [!scala|java|python]Color.[/!]cyan
pt: [!scala|java|python]Cor.[/!]ciano

note: type: Content of: <table><tr><td>
en: [!scala|java|python]Color.[/!]darkGray
pt: [!scala|java|python]Cor.[/!]cinzentoEscuro

note: type: Content of: <table><tr><td>
en: [!scala|java|python]Color.[/!]gray
pt: [!scala|java|python]Cor.[/!]cinzento

note: type: Content of: <table><tr><td>
en: [!scala|java|python]Color.[/!]green
pt: [!scala|java|python]Cor.[/!]verde

note: type: Content of: <table><tr><td>
en: [!scala|java|python]Color.[/!]lightGray
pt: [!scala|java|python]Cor.[/!]cinzentoClaro

note: type: Content of: <table><tr><td>
en: [!scala|java|python]Color.[/!]magenta
pt: [!scala|java|python]Cor.[/!]magenta

note: type: Content of: <table><tr><td>
en: [!scala|java|python]Color.[/!]orange
pt: [!scala|java|python]Cor.[/!]laranja

note: type: Content of: <table><tr><td>
en: [!scala|java|python]Color.[/!]pink
pt: [!scala|java|python]Cor.[/!]rosa

note: type: Content of: <table><tr><td>
en: [!scala|java|python]Color.[/!]red
pt: [!scala|java|python]Cor.[/!]vermelho

note: type: Content of: <table><tr><td>
en: [!scala|java|python]Color.[/!]white
pt: [!scala|java|python]Cor.[/!]branco

note: type: Content of: <table><tr><td>
en: [!scala|java|python]Color.[/!]yellow
pt: [!scala|java|python]Cor.[/!]amarelo

note: type: Content of: <h2>
en: Note on exceptions
pt: Nota sobre exceções

note: type: Content of: outside any tag (error?)
en: Regular buggles throw a BuggleWallException exception if you ask them to traverse a wall.  They throw a NoBaggleUnderBuggleException exception if you ask them to pickup a baggle from an empty cell, or a AlreadyHaveBaggleException exception if they already carry a baggle.  Trying to drop a baggle on a cell already containing one throws an AlreadyHaveBaggleException exception.  Dropping a baggle when you have none throws a DontHaveBaggleException.
pt: Buggles normais lançam uma exceção BuggleWallException se os pede atravessar uma parede.  Lançam uma exceção NoBaggleUnderBuggleException se os pede tirar um "baggle" de uma célula vazia, ou uma exceção AlreadyHaveBaggleException se eles já carregam um "baggle".  Tentar soltar um "baggle" numa célula que já contém outro lança uma exceção AlreadyHaveBaggleException.  Soltar um "baggle" quando não tem nenhum lança uma DontHaveBaggleException.

note: type: Content of: <p>
en: SimpleBuggles (ie, the one used in first exercises) display an error message on problem so that you don't need to know what an exception is.
pt: SimpleBuggles (ie, aqueles usados nos primeiros exercícios) exibem uma mensagem de erro num problema de forma que não precise saber o que é uma exceção.

note: type: Content of: <p>
en: This world is a simplistic testing environment largely inspired from the http://codingbat.com invented by Nick Parlente.
pt: Este mundo é um ambiente de testes simplista largamente inspirado no http://codingbat.com criado por Nick Parlente.

note: type: Content of: <p>
en: The typical exercises are very short ones, aiming at improving the tactical programming abilities of the students. That is to say that you will be presented a quite long list of very little exercises about rather simple things. The idea is to train you on these issues until they become automatic to you.
pt: Os exercícios são bem curtos e têm como objetivo melhorar as habilidades de programação tática dos estudantes. Isto significa que irá ser apresentado a uma longa lista de pequenos exercícios sobre coisas simples. A ideia é treinar estes aspectos simples até que eles fiquem automáticos para si.

note: type: Content of: <p>
en: In contrary to the other worlds, the BatWorld does not provide any fancy abstraction nor visualization. You have to fill a function, which gets called for a bunch of parameter sets, and that's it.
pt: Ao contrário dos outros mundos, o "BatWorld" não fornece qualquer abstração ou visualização legal. Tem simplesmente que preencher uma função, que é chamada com um conjunto de parâmetros e é isto.

note: type: Content of: <p>
en: For more information, you should refer to the CodingBat.com documentation, which contains for example a very useful documentation on boolean operators: http://codingbat.com/doc/ifboolean.html
pt: Para mais informações, deve consultar a documentação do CodingBat.com, que contém por exemplo uma documentação sobre operadores booleanos bem útil: http://codingbat.com/doc/ifboolean.html

note: type: Content of: <h3>
en: First steps
pt: Primeiros passos

note: type: Content of: outside any tag (error?)
en: This first lesson will lead your first steps in programming. It is intended for beginners. List of seen notions per exercise:
pt: A primeira lição vai te guiar pelos primeiros passos em programação. Ela é feita para iniciantes. Lista de noções vistas por exercício:

note: type: Content of: <h2>
en: Instructions
pt: Instruções

note: type: Content of: <table><tr><td>
en: Comments
pt: Comentários

note: type: Content of: <table><tr><td>
en: Conditionals/ Expressions
pt: Condicionais/ Expressões

note: type: Content of: <h2>
en: While loops
pt: Loops while (enquanto)

note: type: Content of: <table><tr><td>
en: Variables
pt: Variáveis

note: type: Content of: <h2>
en: For loops
pt: Loops for

note: type: Content of: <table><tr><td>
en: Do/While loops
pt: loops Do/While (faça/enquanto)

note: type: Content of: <h2>
en: Methods
pt: Métodos

note: type: Content of: <table><tr><td>
en: Welcome in the Buggles' World
pt: Bem-vindo ao mundo dos Buggles

note: type: Content of: <table><tr><td>
en: Java Instructions
pt: Instruções Java

note: type: Content of: <h2>
en: Writing more complex programs
pt: A escrever programas mais complexos

note: type: Content of: <h2>
en: Conditional instructions
pt: Instruções condicionais

note: type: Content of: <h2>
en: Baggle Seeking
pt: A procurar Baggles

note: type: Content of: <h2>
en: Storing and manipulating data
pt: A armazenar e a manipular dados

note: type: Content of: <h2>
en: Do .. while loops
pt: Loops Do .. while (faça .. enquanto)

note: type: Content of: <h2>
en: Building methodically
pt: Construir metodicamente

note: type: Content of: <table><tr><td>
en: Methods returning a result
pt: Métodos a retornar um resultado

note: type: Content of: <h2>
en: Methods with parameters
pt: Métodos com perâmetros

note: type: Content of: <h2>
en: Methodically drawing
pt: Desenhar metodicamente

note: type: Content of: <h2>
en: Methodically drawing (only bigger)
pt: Desenhar metodicamente (apenas grande)

note: type: Content of: <h2>
en: Drawing bigger and bigger
pt: Desenhar maior e maior

note: type: Content of: <table><tr><td>
en: Even more pattern to draw
pt: Mais padrões para desenhar

note: type: Content of: <h2>
en: Slug Hunting
pt: Caça à lesma

note: type: Content of: <h2>
en: Slug Tracking
pt: Rastrear a lesma

note: type: Content of: <h2>
en: Snake World
pt: Mundo das cobras

note: type: Content of: <table><tr><td>
en: Knitting and Arrays
pt: tricô e Arrays

note: type: Content of: <table><tr><td>
en: Knitting, Arrays and modulos
pt: tricô, arrays e módulos

note: type: Content of: <h2>
en: Traversal by column
pt: Percorrer pelas colunas

note: type: Content of: <h2>
en: Traversal by line
pt: Percorrer pelas linhas

note: type: Content of: <h2>
en: Zig-zag traversal
pt: Percorrer em zig-zag

note: type: Content of: <h2>
en: Diagonal Traversal
pt: Percorrer na diagonal

note: type: Content of: <h2>
en: Meaning of the symbols
pt: Significado dos símbolos

note: type: Content of: <table><tr><td>
en: Introducing the concept
pt: Introduzir o conceito

note: type: Content of: <table><tr><td>
en: Working on the concept
pt: Trabalhar no conceito

note: type: Content of: <table><tr><td>
en: Concept assumed mastered
pt: Conceito tido como dominado

note: type: Content of: <table><tr><td>
en: Concept not mandated by the exercise
pt: Conceito não é obrigatório para o exercício

note: type: Content of: <h2>
en: What will I learn?
pt: O que irei aprender?

note: type: Content of: <p>
en: You will learn the very basics of programming. At least, you will be presented the most important concepts, allowing you to read most simple algorithms. You will not be able to write or read full programs because you will still not know about objects, but you will master what is called "Tactical programming", meaning that you will master the syntax enough to not have any issue with it, allowing you to focus on the fundamental problems of what you want to solve instead of struggling with syntactic difficulties.
pt: Irá aprender o básico de programação. pelo menos, irá ser apresentado aos mais importantes conceitos, a permitir que leia a maioria dos algoritmos simples. Não será capaz de escrever ou ler programas completos por que ainda não saberá nada sobre objetos, mas irá dominar o que é chamado de "programação tática", ou seja, vai dominar a sintaxe o suficiente para não ter qualquer problema com ela, a permitir que foque nos problemas funcamentais que quer resolver ao invés de se debater com dificuldades de sintaxe.

note: type: Content of: <p>
en: This first lesson will lead your first steps in programming. It is intended for beginners.
pt: Esta primeira lição vai guiar-lo pelos primeiros passos em programação. Ela foi feita para iniciantes.

note: type: Content of: <p>
en: If you are not sure, go for this lesson that will teach you the bases of programming.
pt: Se está perdido, venha para esta lição que ela irá te ensinar as bases da programação.

note: type: Content of: <h2>
en: Welcome to the PLM
pt: Bem-vindo ao PLM

note: type: Content of: <p>
en: The goal of this first exercise is to instruct your buggle to move forward by one step. Switch between the views on the right for more info. <i>World</i> depicts the world as it is now, while <i>Objective</i> depicts what you should get.
pt: O objectivo deste primeiro exercício é instruir o seu buggle para avançar um passo. Alterne entre as vistas à direita para mais informações. O <i>Mundo</i> retrata o mundo como é agora, enquanto o <i>Objetivo</i> retrata o que deve obter.

note: type: Content of: <h3>
en: My <i>buggle</i>? What is this??
pt: O que é o meu <i>buggle</i>?

note: type: Content of: <p>
en: Buggles are little animals obeying any order you may give them. Currently, you must use the [!thelang/] programming language for that, but you can change the language from the menu, or by clicking the icon in the status bar.
pt: Os buggles são pequenos animais que obedecem todas as suas ordens. Atualmente, deve usar a linguagem de programação [!thelang/] para isso, mas pode mudar a linguagem a partir do menu, ou a clicar no ícone na barra de estado.

note: type: Content of: <h3>
en: How to proceed?
pt: Como proceder?

note: type: Content of: <p>
en: Write your program in the "Code" pane. It should read as follows:
pt: Escreva o seu programa no painel "Código". Deve ser lido da seguinte forma:

note: type: Content of: <p>
en: Do not forget the final <code>;</code> which tells the compiler that the instruction is over (yes, computers are so dumb that they cannot <i>guess</i> obvious stuff like this).
pt: Não se esqueça do <code>;</code> final que diz ao compilador que a instrução está encerrada (sim, o computador é tão bobo que não consegue <i>adivinhar</i> coisas óbvias como isto).

note: type: Content of: <p>
en: Once done, click on Run to execute your code.
pt: Quando feito, clique em Executar para executar o seu código.

note: type: Content of: <p>
en: If your code contains errors, that's perfectly OK: Even talented programmers struggle on their code.  The computer will display error messages in the console to help you fixing them. These messages may sound scary at first glance, but don't panic. The compiler is only somehow limited in its communication abilities, but it's not mean. If you look closer, the solution to solve your issue is written somewhere in those cryptic messages. You will see, with a bit of habit, we get used to it.
pt: Se o seu código contém erros, tudo bem: até os programadores talentosos lutam com o seu código.  O computador exibirá mensagens de erro na consola para o ajudar a corrigi-los. Estas mensagens podem parecer assustadoras à primeira vista, mas não entre em pânico. O compilador é apenas de alguma forma limitado nas suas habilidades de comunicação, mas não é mau. Se olhar mais de perto, a solução para resolver o seu problema está escrita em algum lugar nessas mensagens crípticas. Verá, com um pouco de hábito, que nos acostumamos a isso.

note: type: Content of: <h3>
en: But that's [!thelang]!
pt: Mas isso é [!thelang]!

note: type: Content of: outside any tag (error?)
en: Currently, the PLM is configured to accept [!thelang] programs, but it can also accept [!java]Python or Scala[/!][!scala]Java or Python[/!][!python]Java or Scala[/!] programs.  Either click on the language icon at the very bottom right of the window, or head to the <tt>Language/Computer</tt> menu item to change it.
pt: Atualmente, o PLM está configurado para aceitar programas [!thelang], mas também pode aceitar programas [!java]Python ou Scala[/!][!scala]Java ou Python[/!][!python]Java ou Scala[/!].  Clique no ícone da linguagem no canto inferior direito da janela, ou vá para o item de menu <tt>Language/Computer</tt> para mudá-lo.

note: type: Content of: outside any tag (error?)
en: Congratulations! You just wrote your first program! You got the idea now: programming is nothing more than giving simple instructions to the computer that blindly apply them. The main difficulty is to explain stuff to something as stupid as a computer...
pt: Parabéns! Acaba de escrever o seu primeiro programa! Agora captou a ideia: programar é nada mais que dar instruções simples ao computador, que as realiza cegamente. A maior dificuldade é explicar tudo para algo tão idiota quanto um computador...

note: type: Content of: <p>
en: Our second program will be a bit more complicated, but not much. The goal for your buggle is simply to draw a house (a box), and hide inside. Check the objective world to see exactly what this means.
pt: O nosso segundo programa vai ser um pouco mais complicado, mas não muito. O objetivo do seu buggle é simplesmente desenhar uma casa (uma caixa) e esconder-se dentro dela. Confira o mundo objetivo para ver exatamente o que isso significa.

note: type: Content of: <p>
en: For that, you will need <code>forward()</code>, <code>left()</code> and <code>right()</code>. Use your brush to mark the ground as you walk. Start marking the ground with <code>brushDown()</code>, and stop it with <code>brushUp()</code> afterward (e.g., to enter your house without marking its ground).
pt: Para isso, vai precisar de <code>forward()</code>, <code>left()</code> e <code>right()</code>. Use o seu pincel para marcar o chão enquanto anda. Comece a marcar o chão com <code>brushDown()</code> e pare com <code>brushUp()</code> depois (por exemplo, para entrar na sua casa sem marcar o chão).

note: type: Content of: <h3>
en: What exactly is a program?
pt: O que exatamente é um programa?

note: type: Content of: <p>
en: Programs are mainly suites of method calls, which are no more than a list of simple orders given to the machine. It is very similar to a recipe stating <i>Melt the chocolate pieces, add sugar, cool the mix and serve</i>.  [!thelang] wants to have the instructions separated by semi-columns (;)[!python|scala] or by new lines[/!], and followed by parenthesis. Our little receipe would thus be written in the following way[!python|scala] (you can also add semi-columns at the end of the lines, but this is not mandatory)[/!].
pt: Os programas são principalmente conjuntos de chamadas de métodos, que não são mais que uma lista de ordens simples dadas à máquina. É como uma receita que diz <i>Derreter os pedaços de chocolate, adicionar açúcar, esfriar a mistura e servir</i>.  [!thelang] quer ter as instruções separadas por ponto-e-virgula (;)[!python|scala] ou por novas linhas[/!], seguidas de parênteses. A nossa pequena receita seria assim escrita da seguinte forma[!python|scala] (também pode adicionar ponto-e-virgula no final das linhas, mas isso não é obrigatório)[/!].

note: type: Content of: <p>
en: Do not write it all on one line only even if the computer would accept it [!python|scala](provided that you don't omit the semi-columns)[/!]. This is a <b>really bad idea</b>, hindering the readability.  <i>Programs must be written for people to read, and only incidentally for machines to execute,</i> as said Harold Abelson.
pt: Não escreva tudo numa só linha, mesmo que o computador o aceite [!python|scala](desde que não omita ponto-e-virgulas)[/!]. Esta é uma <b>péssima idéia</b>, que dificulta a legibilidade.  <i>Programas devem ser escritos para pessoas as lerem e apenas incidentalmente para as máquinas executarem,</i> como disse Harold Abelson.

note: type: Content of: <p>
en: There is a limited set of instructions that buggles understand, and we will eventually learn how to define new ones. For now, there is a method for each button of the interactive control panel. To achieve the same effect than the <b>forward</b> button (making the buggle moving one step forward), you need to write the following in the editor:
pt: Há um conjunto limitado de instruções que os buggles entendem e eventualmente aprenderemos a definir novas instruções. Por enquanto, existe um método para cada botão do painel de controle interativo. Para alcançar o mesmo efeito que o botão <b>forward</b> (a fazer o buggle mover um passo à frente), precisa escrever o seguinte no editor:

note: type: Content of: <p>
en: Likewise, to achieve the same effect than the <b>[!java|scala|python]backward[/!][!c]stepBackward[/!]</b>, <b>left</b> and <b>right</b> buttons, you need to use respectively:
pt: Da mesma forma, para obter o mesmo efeito que os botões <b>[!java|scala|python]recuar[/!][!c]recuarUmPasso[/!]</b>, <b>esquerda</b> e <b>direita</b>, precisa respetivamente:

note: type: Content of: <p>
en: The <b>mark</b> button is a bit particular, since it correspond to two methods: the first one moves the pen up while the second moves it down.
pt: O botão <b>marcar</b> é diferente, pois corresponde a dois métodos: o primeiro move a caneta para cima e o segundo move a caneta para baixo.

note: type: Content of: <p>
en: The buggle offers other methods, that are presented from the "Help/about this world" menu and will be introduced on need.
pt: O buggle tem outros métodos, que estão no menu "Ajuda/sobre este mundo" e serão introduzidos quando forem necessários.

note: type: Content of: outside any tag (error?)
en: Now that we know how to draw things on the board, we'll enjoy this ability and draw a beautiful G on the board (check Objective panel for details on what is expected).
pt: Agora que sabemos como desenhar coisas no tabuleiro, vamos aproveitar esta habilidade e desenhar um belo G (Veja o painel de Objetivo para detalhes).

note: type: Content of: <p>
en: When you write a quite complex program, it is sometimes useful to <b>add comments</b> to simplify the code reviews afterward. Here for example, it's quite easy to get lost in the drawing process, and you may want to add comments like <i>vertical bar done</i> or <i>finished drawing the G. Time to move back to initial position</i>. Commenting your code is almost mandatory if you (or someone else) want to read it afterward, although over-commenting (describing obvious stuff) is a bad idea as the important idea get lost in the noise.
pt: Quando escreve um programa bem complexo, por vezes é útil <b>adicionar comentários</b> para simplificar uma posterior revisão do código. Aqui, por exemplo, é fácil se perder no processo de desenho e podeadicionar comentários como <i>barra vertical desenhada</i> ou <i>terminei de desenhar o G. hora de voltar para posição inicial</i>. Comentar o seu código é quase obrigatório se (ou mais alguém) quiser lê-lo depois, embora comentar demais (a descrever coisas óbvias) é ruim pois as ideias importantes se perdem no meio do ruído.

note: type: Content of: <p>
en: There is [!java]three[/!][!python|scala|c]two[/!] types of comments in [!thelang], instructing the [!java|scala|c]compiler[/!][!python]interpreter[/!] to not read the text you add for humans:
pt: Existem [!java]três[/!][!python|scala|c]dois[/!] tipos de comentários em [!thelang], que instruem o [!java|scala|c]compilador[/!][!python]interpretador[/!] a não ler o texto que adiciona para humanos:

note: type: Content of: <ul><li>
en: <b>Comments on a single line</b>. When the [!java|scala|c]compiler[/!][!python]interpreter[/!] encounters the symbol [!java|scala|c]//[/!][!python]#[/!], it ignores the end of the line.
pt: <b>Comentários de uma única linha</b>. Quando o [!java|scala|c]compilador[/!][!python]interpretador[/!] encontra o símbolo [!java|scala|c]//[/!][!python]#[/!], ignora o resto da linha.

note: type: Content of: <ul><li>
en: <b>Comments on several lines</b>. The [!java|scala|c]compiler[/!][!python]interpreter[/!] ignores anything placed between [!java|scala|c]the symbols /* and */ even if they are placed on differing lines.[/!] [!python]a line beginning with ''' until the next line ending with '''.[/!]
pt: <b>Comentários em várias linhas</b>. O [!java|scala|c]compilador[/!][!python]interpretador[/!] ignora tudo entre [!java|scala|c]os símbolos /* e */ mesmo quando eles são postos em linhas diferentes.[/!] [!python]uma linha a comaçar com ''' até a próxima linha terminado com '''.[/!]

note: type: Content of: <pre>
en: methodCallReadByThe[!java|scala|c]Compiler[/!][!python]Interpreter[/!]()[!java|c];[/!] <span class="comment">[!java|scala|c]//[/!][!python]#[/!] all this is ignored</span>
    otherCall()[!java|c];[/!] [!java|scala|c]<span class="comment">/* This is</span>
    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <span class="comment"> also ignored */</span>[/!]
    [!python]<span class="comment">''' This is</span>
    <span class="comment">also ignored  '''</span>[/!]
    yetAnotherCall()[!java|c];[/!]
pt: methodCallReadByThe[!java|scala|c]Compiler[/!][!python]Interpreter[/!]()[!java|c];[/!] <span class="comment">[!java|scala|c]//[/!][!python]#[/!] tudo isto é ignorado</span>
    otherCall()[!java|c];[/!] [!java|scala|c]<span class="comment">/* Isto também </span>
    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <span class="comment"> é ignorado */</span>[/!]
    [!python]<span class="comment">''' Isto também</span>
    <span class="comment">é ignorado  '''</span>[/!]
    yetAnotherCall()[!java|c];[/!]

note: type: Content of: <p>
en: There is a third kind of comments in Java, between /** and */, which are read by a specific program called JavaDoc to generate automatically the documentation explaining how to use the code. These comments must follow a very precise formalism.
pt: Existe um terceiro tipo de comentário em Java, entre /** e */, que é lido por um programa específico chamado JavaDoc para gerar automaticamente a documentação a explicar como usar o código. Estes comentários devem seguir um formalismo bem preciso.

note: type: Content of: <p>
en: The comments on several lines are often used to document how to use the code, while others are more used to describe how this code works.
pt: Os comentários de várias linhas são frequentemente usados para documentar como usar o código, enquanto os outros são usados para descrever como este código funciona.

note: type: Content of: outside any tag (error?)
en: Programs made of simple suite of instructions similar to previous exercise are quite boring. They always do the same thing, and cannot react to external conditions. A <b>conditional</b> let the program adapt by doing something like <i>if it's raining, take an umbrella</i>.
pt: Programas feitos simplesmente de um conjunto de instruções similares ao do exercício anterior são bastante chatos. Sempre fazem a mesma coisa e não reagem a condições externas. Um <b>condicional</b> faz o programa se adaptar a fazer coisas do tipo <i>se está a chover, leve um guarda-chuva</i>.

note: type: Content of: <p>
en: The [!thelang] syntax is the following:
pt: A sintaxe de [!thelang] é a seguinte:

note: type: Content of: <pre>
en: [!java|scala|c]if (<b>condition</b>) {
    &nbsp;&nbsp;&nbsp;&nbsp;<b>whatToDoIfTrue();</b>
    &nbsp;&nbsp;&nbsp;&nbsp;<b>whatToDoNextIfTrue();</b>
    }[/!][!python]if <b>condition</b>:
    &nbsp;&nbsp;&nbsp;&nbsp;<b>whatToDoIfTrue()</b>
    &nbsp;&nbsp;&nbsp;&nbsp;<b>whatToDoNextIfTrue()</b>[/!]
    <b>whatToDoAnyway()[!java|c];[/!]</b>
pt: [!java|scala|c]if (<b>condição</b>) {
    &nbsp;&nbsp;&nbsp;&nbsp;<b>whatToDoIfTrue();</b>
    &nbsp;&nbsp;&nbsp;&nbsp;<b>whatToDoNextIfTrue();</b>
    }[/!][!python]if <b>condição</b>:
    &nbsp;&nbsp;&nbsp;&nbsp;<b>whatToDoIfTrue()</b>
    &nbsp;&nbsp;&nbsp;&nbsp;<b>whatToDoNextIfTrue()</b>[/!]
    <b>whatToDoAnyway()[!java|c];[/!]</b>

note: type: Content of: <p>
en: If the condition is true, the code of the next block will be executed and then it will continue with the rest of the code.  If the condition is false, the next block is ignored and the execution continues after it.  The conditional block can contain several instructions, it can even contain other tests, along with their sub-blocks.
pt: Se a condição for verdade, o código do próximo bloco será executado e então o resto do código continua. Se a condição for falsa, o próximo bloco é ignorado e a execução continua depois disto. O bloco condicional pode conter várias instruções, pode até mesmo conter outros testes, com os próprios sub-testes dele.

note: type: Content of: <p>
en: In this example, the instructions <code>whatToDoIfTrue()</code> and <code>whatToDoNextIfTrue()</code> will be executed if and only if the condition is true, while the instruction <code>whatToDoAnyway()</code> will be executed whether or not the condition is true.
pt: Neste exemplo, as instruções <code>whatToDoIfTrue()</code> e <code>whatToDoNextIfTrue()</code> serão executadas se e somente se a condição for verdadeira, mas a instrução <code>whatToDoAnyway()</code> vai ser executada se a condição for verdadeira ou não.

note: type: Content of: <p>
en: In [!thelang], the blocks of code are [!java|scala|c]enclosed between curly brackets: a { sign opens the block, while a } sign closes it.  White spaces are not important[/!][!java|c].[/!][!scala], provided that your instructions are still separated with a semi-column or an end of line.[/!] [!java|scala|c]It is still very important to correctly indent your code to keep it readable.[/!] [!python]marked by the indentation: every lines that are a bit shifted to the right with white spaces belong to the block. Quite often, people use 4 spaces for indentation, but it works if you use more or less spaces. Simply, any lines of the block must use the same amount of spaces.  The end of Python code blocks are not marked by any specific char.  Indenting lines starts a block and unindenting ends it. Do not forget the colon (:) at the end of the <code>if</code> line, python needs it to know that a new block begins. The fact that python relies on indentation to delimit blocks is a very good property for beginners: it will force you to adhere to strict code presentation standards.[/!] It is very easy to get lost in your own code if it's not properly indented, so you want to clean it up so that working on your code remains pleasant and productive.
pt: Em [!thelang], os blocos de código são [!java|scala|c]envolvidos entre chaves: um { abre o bloco e um } fecha-o.  Espaços em branco não são importantes[/!][!java|c].[/!][!scala], uma vez que as suas instruções ainda estejam separadas com um ponto-e-vírgula ou um fim-de-linha.[/!] [!java|scala|c]Ainda assim é muito importante indentar corretamente o seu código para mantê-lo legível.[/!] [!python]marcados pela indentação: todas as linhas que estiverem um pouco deslocadas para a direita com espaços pertencem ao bloco. Frequentemente se usam 4 espaços para indentação, mas funciona se usar mais ou menos espaços. A resumir, quaisquer linhas do bloco devem usar a mesma quantidade de espaços. O fim do bloco de código Python não é marcado por nenhum caractere específico. Indentar linhas começa um bloco e parar de indentar termina o bloco. Não se esqueça do dois-pontos (:) no final da linha do <code>if</code>, python precisa dele para saber que um novo bloco vai começar. O fato de que python se baseia em indentação para delimitar blocos é uma ótima propriedade para iniciantes: vai forçá-lo a aderir a padrões de apresentação de código estritos.[/!] É muito fácil se perder no seu próprio código se não for corretamente indentado, então precisa deixá-lo bem-arrumado para que trabalhar nele continue a ser agradável e produtivo.

note: type: Content of: <p>
en: All indentations of a given block must be consistent, and it is not possible to cut a block. The two following codes are incorrect and will raise errors.
pt: Todas as indentações de um dado bloco devem ser consistentes e não é possível cortar um bloco. os dois códigos a seguir estão incorretos e devem resultar em erro.

note: type: Content of: <pre>
en: if <b>condition</b>:
    &nbsp;&nbsp;&nbsp;&nbsp;<b>whatToDo()</b>
    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<b>whatToDoNext()</b> <span class="comment"># one space too much </span>
    <b>whatToDoAnyway()</b>
pt: if <b>condição</b>:
    &nbsp;&nbsp;&nbsp;&nbsp;<b>whatToDo()</b>
    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<b>whatToDoNext()</b> <span class="comment"># um espaço a mais </span>
    <b>whatToDoAnyway()</b>

note: type: Content of: <pre>
en: if <b>condition</b>:
    &nbsp;&nbsp;&nbsp;&nbsp;<b>whatToDo()</b>
    <b>whatToDoAnyway()</b>
    &nbsp;&nbsp;&nbsp;&nbsp;<b>whatToDoNext()</b> <span class="comment"># this block is not hanging to a condition line</span>
pt: se <b>condição</b>:
    &nbsp;&nbsp;&nbsp;&nbsp;<b>whatToDo()</b>
    <b>whatToDoAnyway()</b>
    &nbsp;&nbsp;&nbsp;&nbsp;<b>whatToDoNext()</b> <span class="comment"># este bloco não está condicionado a uma linha de condição</span>

note: type: Content of: <p>
en: The condition must be a <code>[!c]int[/!][!java]boolean[/!][!scala|python]Boolean[/!]</code> expression.  The inner block of code will get executed if the expression is evaluated to <code>[!c]1[/!][!java|scala]true[/!][!python]True[/!]</code> and it will be ignored if it is <code>[!c]0[/!][!java|scala]false[/!][!python]False[/!]</code>.  [!python|scala|java]<code>[!java|scala]true[/!][!python]True[/!]</code> and <code>[!java|scala]false[/!][!python]False[/!]</code> are constant values defined by [!thelang] directly, just as 0 or 1 in mathematics.[/!]
pt: A condição deve ser uma expressão <code>[!c]int[/!][!java]boolean[/!][!scala|python]Boolean[/!]</code>. O bloco interno do código será executado se a expressão for calculada como <code>[!c]1[/!][!java|scala]true[/!][!python]True[/!]</code> e será ignorado se for <code>[!c]0[/!][!java|scala]false[/!][!python]False[/!]</code>. [!python|scala|java]<code>[!java|scala]true[/!][!python]True[/!]</code> e <code>[!java|scala]false[/!][!python]False[/!]</code> são valores constantes definidos por [!thelang] diretamente, assim como 0 ou 1 na matemática.[/!]

note: type: Content of: <p>
en: The condition can be a <code>[!c]int[/!][!java]boolean[/!][!scala|python]Boolean[/!]</code> variable (we will come back on variables in a later exercise, don't worry) or an arithmetic test, such as <code>x == 5</code>, which checks whether the current value of <code>x</code> is 5, or such as <b>!=</b> (checking inequality, that is, returning [!c]1[/!][!java|scala]true[/!][!python]True[/!] only if the left-hand side is different from the right-hand side), <b>&lt;</b> (smaller than), <b>&gt;</b> (larger than), <b>&lt;=</b> (smaller or equal to), <b>&gt;=</b> (larger or equal to).
pt: A condição pode ser uma variável <code>[!c]int[/!][!java]boolean[/!][!scala|python]Boolean[/!]</code> (vamos voltar a falar de variáveis num próximo exercício, não se preocupe) ou um teste aritmético, como <code>x == 5</code>, que verifica se o valor atual de <code>x</code> é 5, ou algo como <b>!=</b> (a verificar inequação, ou seja, a retornar [!c]1[/!][!java|scala]true[/!][!python]True[/!] apenas se o lado esquerdo é diferente do lado direito), <b>&lt;</b> (menor que), <b>&gt;</b> (maior que), <b>&lt;=</b> (menor ou igual a), <b>&gt;=</b> (maior ou igual a).

note: type: Content of: <p>
en: Beware of the classical trap, which consists in testing the equality of a variable using = instead of ==. Hopefully, the [!java|scala|c]compiler[/!][!python]interpreter[/!] detects this problem most of the time, but it could get trapped is some cases (such as when you are affecting a [!c]int[/!][!java|python|scala]boolean[/!] variable). So you'd better to be careful...
pt: Cuidado com um erro clássico, que é verificar a igualdade da variável a usar = no lugar de ==. Ainda bem que o [!java|scala|c]compilador[/!][!python]interpretador[/!] detecta este problema na maior parte das vezes, mas às vezes passa (como quando está a atribuir valor a uma variável [!c]int[/!][!java|python|scala]booleana[/!]). Então é bom ter cuidado...

note: type: Content of: <p>
en: The condition can also be a call to some particular methods returning a boolean. For example, the <code>isFacingWall()</code> method of the buggle returns [!c]1[/!][!java|python|scala]true[/!] if the buggle is facing a wall, and [!c]0[/!][!java|python|scala]false[/!] in the other case.
pt: A condição pode também ser uma chamada para alguns métodos particulares que retornam booleano. Por exemplo, o método <code>isFacingWall()</code> do buggle retorna [!c]1[/!][!java|python|scala]true[/!] se o buggle está a olhar para uma parede e false caso contrário.

note: type: Content of: <p>
en: Finally, a condition can be composed of several sub-conditions connected by boolean operations:
pt: Finalmente, uma condição pode ser composta de várias sub-condições conectadas por operadores booleanos:

note: type: Content of: <ul><li>
en: <code>cond1 [!java|scala|c]&&[/!][!python]and[/!] cond2</code> is true when <tt>cond1</tt> <b>and</b> <tt>cond2</tt> are both true (if <tt>cond1</tt> is false, <tt>cond2</tt> is not even evaluated as we already know that the conjunction of both propositions cannot be true).
pt: <code>cond1 [!java|scala|c]&&[/!][!python]and[/!] cond2</code> é true quando <tt>cond1</tt> <b>e</b> <tt>cond2</tt> são ambos trues (se <tt>cond1</tt> é false, <tt>cond2</tt> não é nem sequer calculado pois sabe-se previamente que a conjunção das duas proposições não pode ser verdadeira).

note: type: Content of: <ul><li>
en: <code>cond1 [!java|scala|c]||[/!][!python]or[/!] cond2</code> is true if <tt>cond1</tt> <b>or</b> <tt>cond2</tt> is true (if <tt>cond1</tt> is true, <tt>cond2</tt> is not even evaluated as we already know that the disjunction of both propositions cannot be false).
pt: <code>cond1 [!java|scala|c]||[/!][!python]or[/!] cond2</code> é true se <tt>cond1</tt> <b>ou</b> <tt>cond2</tt> é true (se <tt>cond1</tt> é true, <tt>cond2</tt> não é nem sequer calculada pois já se sabe que a disjunção de ambas as proposições não pode ser verdadeira).

note: type: Content of: <ul><li>
en: <code>[!java|scala|c]![/!][!python]not [/!]cond</code> is true if <tt>cond</tt> is false.
pt: <code>[!java|scala|c]![/!][!python]not [/!]cond</code> é verdadeira se <tt>cond</tt> é falsa.

note: type: Content of: <ul><li>
en: When the expression becomes complicated, it is better to add parenthesis to force the order of evaluation.  Do not hesitate to add more parenthesis to remove any ambiguities that may appear in an expression.
pt: Quando a expressão se torna complicada, é melhor adicionar parêntesis para forçar a ordem de cálculo. Não hesite em adicionar mais parêntesis para remover ambiguidades que apareçam na expressão.

note: type: Content of: <p>
en: Last, it is possible to specify what to do when the condition is false using the following syntax. In this case, the instruction <code>whatToDoIfItsFalse</code> will be executed only if the condition is false.
pt: Por fim, é possível especificar o que fazer quando a condição é falsa a usar a seguinte sintaxe. Neste caso, a instrução <code>oQueFazerSeForFalso</code> será executada apenas se a condição for falsa.

note: type: Content of: <pre>
en: [!java|scala|c]if (<b>condition</b>) {
    &nbsp;&nbsp;&nbsp;&nbsp;<b>whatToDoIfTheConditionIsTrue();</b>
    } else {
    &nbsp;&nbsp;&nbsp;&nbsp;<b>whatToDoIfItsFalse();</b>
    }[/!][!python]if (<b>condition</b>):
    &nbsp;&nbsp;&nbsp;&nbsp;<b>whatToDoIfTheConditionIsTrue()</b>
    else:
    &nbsp;&nbsp;&nbsp;&nbsp;<b>whatToDoIfItsFalse()</b>[/!]
pt: [!java|scala|c]if (<b>condição</b>) {
    &nbsp;&nbsp;&nbsp;&nbsp;<b>whatToDoIfTheConditionIsTrue();</b>
    } else {
    &nbsp;&nbsp;&nbsp;&nbsp;<b>whatToDoIfItsFalse();</b>
    }[/!][!python]if (<b>condição</b>):
    &nbsp;&nbsp;&nbsp;&nbsp;<b>whatToDoIfTheConditionIsTrue()</b>
    else:
    &nbsp;&nbsp;&nbsp;&nbsp;<b>whatToDoIfItsFalse()</b>[/!]

note: type: Content of: <p>
en: Don't forget the colon (:) after the else, it is indicating that a new block is beginning.
pt: Não se esqueça do dois-pontos (:) depois do else, indica que um novo bloco está a começar.

note: type: Content of: <h3>
en: Exercise goal
pt: Objetivo do exercício

note: type: Content of: outside any tag (error?)
en: <a name="Objectives"/> If the buggle is facing a wall, you must move one step back. If not, you must move one step forward. To detect whether you are facing a wall, simply use the <code>isFacingWall()</code> built-in, that every buggle understands.
pt: <a name="Objectives"/> Se o buggle está de cara para uma parede, deve mover um passo para trás. Se não, deve mover um passo para frente. Para detetar se está de cara para uma parede, simplesmente use a função pré-fabricada <code>isFacingWall()</code>, que todos os buggles entendem.

note: type: Content of: <p>
en: This exercise is a bit different: your code has to work for several buggles, each of them being in a specific initial condition. The same code will be executed for each of them.
pt: Este exercício é um pouco diferente: o seu código tem que funcionar para vários buggles, cada um a começar numa posição diferente. O mesmo código será executado para cada um deles.

note: type: Content of: <p>
en: When your program works, move forward to the next exercise, that is hidden in a sub-tree of the selection window.
pt: Quando o seu programa funcionar, vá ao próximo exercício, que está escondido numa sub-árvore da janela de seleção.

note: type: Content of: <p>
en: In addition to conditionals, another handy construction is the ability to repeat an action while a specific condition does not appear. A while loop is used for that, with the following syntax.
pt: Além dos condicionais, outra construção bem útil é a habilidade de repetir uma ação enquanto uma condição específica não acontece. Um loop 'while' é usado para isto, com a seguinte sintaxe.

note: type: Content of: <pre>
en: [!java|scala|c]while (<b>condition</b>) {
    &nbsp;&nbsp;&nbsp;&nbsp;<b>action()</b>;
    }[/!][!python]while <b>condition</b>:
    &nbsp;&nbsp;&nbsp;&nbsp;<b>action()</b>[/!]
pt: [!java|scala|c]while (<b>condição</b>) {
    &nbsp;&nbsp;&nbsp;&nbsp;<b>action()</b>;
    }[/!][!python]while <b>condição</b>:
    &nbsp;&nbsp;&nbsp;&nbsp;<b>action()</b>[/!]

note: type: Content of: <p>
en: The inner bloc is then executed again and again, as long as the condition remains true.  More specifically, the buggle tests the value of the condition. If it's false, it ignores the bloc and continue below.  If it's true, it executes the bloc.  After that, it tests the condition. If it's now false (for example because the moves of the block made us facing the wall), it now ignores the bloc and continue.  If it's still true, it execute the bloc and reevaluate the condition. It does so as long as the condition remains true.
pt: O bloco interno é então executado várias e várias vezes, enquanto a condição se mantiver verdadeira. Mais especificamente, o buggle testa o valor da condição. Se for falsa, ignora o bloco e continua abaixo. Se for verdadeira, executa o bloco. Depois disto, testa a condição. Se agora for falsa (por exemplo, porque os movimentos do bloco nos deixaram de cara à parede), agora ignora o bloco e continua. Se ainda for true, executa o bloco e reavalia a condição. Faz isto enquanto a condição se mantém verdadeira.

note: type: Content of: <p>
en: Naturally, if the chosen action does not modify the value of the condition, the buggle will do the action endlessly. The <b>stop</b> button of the interface becomes then handy. To test this, you can try to type the following code in the editor:
pt: Naturalmente, se a ação escolhida não modifica o valor da condição, o buggle vai fazer a ação infinitamente. O botão <b>stop</b> na interface se torna útil nestes casos. Para testar isto, pode tentar digitar o seguinte código no editor:

note: type: Content of: <p>
en: This will let the buggle turn left as long as <code>[!c]1[/!][!java|scala]true[/!][!python]True[/!]</code> remains true (ie, endlessly), or until you stop it manually using the stop button.
pt: Isto vai fazer o buggle virar à esquerda enquanto <code>[!c]1[/!][!java|scala]true[/!][!python]True[/!]</code> permanecer true (ou seja, infinitamente), ou até que pare manualmente a usar o botão parar.

note: type: Content of: outside any tag (error?)
en: You now have to write some code so that your buggles move forward until they encounter a wall. The idea is thus to do something like:
pt: Agora tem que escrever algum código para os seus buggles se moverem para a frente até que eles encontrem uma parede. A ideia é então fazer algo assim:

note: type: Content of: <pre>
en: while we are not facing a wall, do:
    &nbsp;&nbsp;moveForward()
pt: Enquanto não estiver de cara para uma parede, faça:
    &nbsp;&nbsp;moveForward()

note: type: Content of: <p>
en: Look at the documentation (in "Help/About this world") for the full list of buggles' methods.
pt: Procure na documentação (em "Ajuda/Sobre este mundo") para a lista completa dos métodos dos buggles.

note: type: Content of: <p>
en: The buggle world can sometimes contain some <i>baggles</i>, which are little biscuits that buggles can carry from one point to another. For that, they have to use specific methods such as <code>isOverBaggle(), isCarryingBaggle(), pickupBaggle()</code> or <code>dropBaggle()</code>. Check their documentation in "Help/About this world" for more details.
pt: O mundo dos buggles pode algumas vezes conter alguns <i>baggles</i>, que são pequenos biscoitos que os buggles podem carregar de um ponto a outro. Para isto, eles têm que usar métodos específicos como <code>isOverBaggle(), isCarryingBaggle(), pickupBaggle()</code> ou <code>pickupBaggle()</code>. Verifique a documentação deles em "Ajuda/Sobre este mundo" para mais detalhes.

note: type: Content of: <p>
en: Let each buggle find its baggle by adapting the code you wrote in previous exercise (copy/paste what you've done before if you want).
pt: Deixe cada buggle encontrar o baggle dele por adaptar o código que escreveu no exercício anterior (copie e cole o que fez antes se quiser).

note: type: Content of: <p>
en: The programs we wrote so far are missing a fundamental point in computing.  Actually, it is all about processing <b>data</b> through specific <b>instructions</b>. In the buggle world, the main data are a bit hidden behind the graphical representation, but that's no reason to never manipulate some data explicitly.
pt: Os programas que escrevemos até agora não tem um ponto fundamental da computação. Na verdade, é sobre processar <b>dados</b> através de <b>instruções</b> específicas. No mundo dos buggles, os dados principais estão escondidos atrás de uma representação gráfica, mas isto não é motivo para nunca manipular alguns dados explicitamente.

note: type: Content of: <h3>
en: Data in [!thelang]
pt: Dados em [!thelang]

note: type: Content of: <p>
en: In a program, you can use several <i>types</i> of data, such as integers or strings of chars. If you want to use a data several times, you need to store it within a <i>variable</i>, which is a memory cell containing a value: you put your data (say the value '5') in the variable (say 'length'), and you can retrieve it later when you need it. That's very similar to a box of label 'gift' in which you would put some stuff, like a bottle of perfume "Channel N°5".
pt: Num programa, pode usar vários <i>tipos</i> de dados, tais como números inteiros ou cadeias de caracteres, ou caracteres. Se quiser usar um dado várias vezes, precisa armazená-la numa <i>variável</i>, que é uma célula de memória a conter um valor: põe o seu dado (digamos o valor '5') na variável (digamos 'comprimento') e pode recuperá-la mais tarde quando precisar dela. Isto é muito similar a uma caixa com o rótulo 'presente' na qual pode pôr alguma coisa, como um perfume "Channel N°5".

note: type: Content of: <h3>
en: Variable declarations
pt: Declaração de variáveis

note: type: Content of: <p>
en: <b>Declaring</b> (ie, creating) a variable in [!thelang], is very simple. You just need to write [!java]its type, a space, and the variable name.[/!] [!scala]the <code>var</code> keyword, the variable name, a column (:) and the variable type an equal sign (=) and an initial value.[/!] [!python]the variable name, an equal sign (=) and an initial value.[/!] The variable name is the label to retrieve it afterward[!python].[/!] [!java|scala] while the type is the kind of data that this variable accepts to store.[/!] It is forbidden to use spaces in variable names. You can name a variable <code>stepAmount</code> if you want, but <code>step amount</code> is not a valid name.
pt: <b>Declarar</b> (ie, criar) uma variável em [!thelang], é muito simples. Simplesmente escreve [!java]o tipo dele, um espaço e o nome da variável.[/!] [!scala]a palavra-chave <code>var</code>, o nome da variável, um dois-pontos (:) e o tipo da variável, um sinal de igualdade (=) e um valor inicial.[/!] [!python]o nome da variável, um sinal de igual (=) e um valor inicial.[/!] O nome da variável é o rótulo para recuperar ela depois[!python].[/!] [!java|scala] enquanto o tipo é o tipo de dado que a variável aceita guardar.[/!] É proibido usar espaços em nomes de variáveis. Pode nomear uma variável <code>quantidadeDePassos</code> se quiser, mas <code>quantidade de passos</code> não é um nome válidos.

note: type: Content of: <p>
en: So, to create a variable named <b>x</b> intended to contain integers, one should write:
pt: Então, para criar uma variável chamada <b>x</b> para guardar inteiros, deve escrever:

note: type: Content of: <p>
en: If you want, you can specify the initial value of the variable by adding an equal sign (=) followed by the value after the declaration.
pt: Se quiser, pode especificar o valor inicial da variável a adicionar um símbolo de igual (=) seguido do valor depois da declaração.

note: type: Content of: <p>
en: So, if you want that the variable contains 5 as initial value, you should type:
pt: Então se quiser que a variável tenha o valor inicial de 5, deve digitar:

note: type: Content of: <p>
en: So, to create a variable named <b>x</b> intended to contain integers with 42 as initial value, one should write:
pt: Logo, para criar uma variável chamada <b>x</b> que vai guardar inteiros e com 42 como valor inicial, deve escrever:

note: type: Content of: <p>
en: In most cases, the compiler is able to guess the type of the variable from the initialization value, and you can omit it:
pt: Na maioria dos casos, o compilador é capaz de adivinhar o tipo da variável baseado no valor inicial e pode omitir o tipo:

note: type: Content of: <p>
en: You still have to specify if you use some generic values as an initialization, such as the very particular value <code>null</code>, which type happens to be ambiguous. Even when the type is clear, you can still specify it if you prefer.  So you want that the variable contains 5 as initial value, you should type:
pt: Ainda tem que especificar se usa alguns valores genéricos como uma inicialização, tais como o valor muito especial <code>null</code>, cujo tipo parece ser ambíguo. Mesmo quando o tipo é claro, ainda pode especificar o tipo se preferir. Portanto, se quiser que a variável contenha 5 como valor inicial, deve digitar:

note: type: Content of: <pre>
en: var x: Int =  5 <span class="comment">// I can define the type if I want to</span>
    var y =  10      <span class="comment">// or I can omit the type if I prefer</span>
pt: var x: Int =  5 <span class="comment">// Posso definir o tipo se quiser</span>
    var y =  10      <span class="comment">// ou posso omitir o tipo se preferir</span>

note: type: Content of: <p>
en: As you can see, the variables are <b>typed</b> in [!thelang], which means that they are somehow specialized: A given variable can only store data of a given type; Don't even think of storing numbers in a variable that is tailored for letters! The [!thelang] language is said to be <b>statically typed</b>.
pt: Como pode ver, as variáveis são <b>tipadas</b> em [!thelang], que significa que elas são de certa forma especializadas: Uma dada variável pode armazenar apenas dados de um tipo; nem pense em guardar números numa variável que é feita para letras! Dizemos que a linguagem [!thelang] é <b>estaticamente tipada</b>.

note: type: Content of: <p>
en: Other languages (such as Python) are less picky and allow you to store any kind of data in any variable, without restriction (those languages are said to be <b>dynamically typed</b>).  This seems easier at the first glance, but this kind of restriction allows the compiler to catch more logic errors for you, which is also good. In some sense, Python is easier to write but errors can sneak in more easily than in [!thelang].
pt: Outras linguages (como Python) são menos charas e permitem que guarde qualquer tipo de dado em qualquer variável, sem restrições (estas linguagens são ditas <b>dinamicamente tipadas</b>). Parecem mais fáceis à primeira vista, mas este tipo de restrição permite que o compilador perceba mais erros de lógica para você, o que é bom. Num certo sentido, Python é mais fácil de escrever mas os erros surgem com mais frequencia do que em [!thelang].

note: type: Content of: <p>
en: Here are some existing types in [!thelang]:
pt: Aqui estão alguns dos tipos em [!thelang]:

note: type: Content of: <ul><li>
en: <b>[!java|c]int[/!][!scala]Int[/!]</b>, for integers;
pt: <b>[!java|c]int[/!][!scala]Int[/!]</b>, para inteiros;

note: type: Content of: <ul><li>
en: <b>[!java|c]double[/!][!scala]Double[/!]</b>, for dot numbers;
pt: <b>[!java|c]double[/!][!scala]Double[/!]</b>, para números com vírgula;

note: type: Content of: <ul><li>
en: <b>[!c]int[/!][!java]boolean[/!][!scala]Boolean[/!]</b>, for booleans that are values being either [!c]1[/!][!java|scala]true[/!] or [!c]0[/!][!java|scala]false[/!];
pt: <b>[!c]int[/!][!java]boolean[/!][!scala]Boolean[/!]</b>, para booleanos, que são valores ou [!c]1[/!][!java|scala]true[/!] ou [!c]0[/!][!java|scala]false[/!];

note: type: Content of: <ul><li>
en: <b>[!c]char*[/!][!java|scala]String[/!]</b>, for char strings.
pt: <b>[!c]char*[/!][!java|scala]String[/!]</b>, para cadeias de caracteres.

note: type: Content of: <p>
en: As you can see, the variables are not <b>typed</b> in Python, which means that they are not specialized in any type of data.  A given variable store any type of data of a given type: you can store a number in a variable and later on store a number in the same variable.  The values themselves are still typed, but not the variable. Python is said to be <b>dynamically typed</b>.
pt: Como pode ver, as variáveis não são <b>digitadas</b> em Python, o que significa que elas não são especializadas em nenhum tipo de dado.  Uma determinada variável armazena qualquer tipo de dado de um determinado tipo: pode armazenar um número numa variável e, mais tarde, armazenar um número na mesma variável.  Os valores ainda são digitados, mas não a variável. Diz-se que Python é de <b>tipagem dinâmica</b>.

note: type: Content of: <p>
en: Other languages (such as Java, Scala or C) are much more picky and prevent you to mix data types in a given variable (they are said to be <b>statically typed</b>).  This seems annoying at the first glance, but this kind of restriction allows the compiler to catch more logic errors for you, which is also good. In some sense, Python is easier to write but errors can sneak in more easily.
pt: Outras linguagens (como Java, Scala ou C), são muito mais exigentes e impedem que misture tipos de dados numa certa variável (dizemos que elas são <b>esticamente tipadas</b>). Isto parece inconveniente à primeira vista, mas este tipo de restrição permite que o compilador capture mais erros de lógica para você, o que também é bom. Num certo sentido, Python é mais fácil de escrever mas erros podem surgir mais facilmente.

note: type: Content of: <p>
en: If you know that the value of your "variable" will never change (eg because it contains the screen size or some other constant value), then you should make it a <b>value</b> instead of a variable. Simply change the <code>var</code> keyword with the <code>val</code> one. The compiler can then check your actions and catch your error when you inadvertently modify the value. More interestingly, the compiler can produce faster code in some cases.
pt: Se sabe que o valor da sua "variável" nunca vai mudar (eg quando ela contém o tamanho do ecrã ou outro valor constante), então deve fazer dela um <b>valor</b> ao invés de uma variável. Simplesmente mude a palavra-chave <code>var</code> para <code>val</code>. O compilador pode então verificar as suas ações e capturar o seu erro quando inadvertidamente modificar o valor. Mais interessante ainda, o compilador pode produzir código mais rápido em alguns casos.

note: type: Content of: <p>
en: Variables work very similarly for strings, floating point numbers and boolean values.
pt: Variáveis funcionam muito parecido com cadeias, números com vírgula e valores booleanos.

note: type: Content of: <pre>
en: char* name = "Martin Quinson";
    double height=1.77; <span class="comment">// in meters</span>
    int married=1;<span class="comment">// 1 means "true"; "false" would be written 0</span>
pt: char* nome = "Martin Quinson";
    double altura=1.77; <span class="comment">// em metros</span>
    int casado=1;<span class="comment">// 1 significa "verdadeiro"; false é 0</span>

note: type: Content of: <pre>
en: String name = "Martin Quinson";
    double height=1.77; <span class="comment">// in meters</span>
    boolean married=true;<span class="comment">// the contrary would be written "false"</span>
pt: Cadeia nome = "Martin Quinson";
    double altura=1.77; <span class="comment">// em metros</span>
    boolean casado=true;<span class="comment">// o contrário se escreve "false"</span>

note: type: Content of: <pre>
en: val name:String = "Martin Quinson"; <span class="comment">// this cannot be modified (it's a value)</span>
    var height: Double = 1.77; <span class="comment">// in meters</span>
    var married = true; <span class="comment">// the contrary would be written "false"</span>
    <span class="comment">// Scala knows that 'true' is a Boolean value, no need to repeat it here</span>
pt: val nome:String = "Martin Quinson"; <span class="comment">// isto não pode ser modificado (é um valor)</span>
    var altura: Double = 1.77; <span class="comment">// em metros</span>
    var casado = true; <span class="comment">// o contrário se escreve "false"</span>
    <span class="comment">// Scala sabe que 'true' é um valor Booleano, não precisa repetir</span>

note: type: Content of: <pre>
en: firstName = "Martin"
    lastName = 'Quinson' <span class="comment"># both single and double quote work here</span>
    motto = "I never finish anyth' (but I keep trying)" <span class="comment"># having single quote within double quote is fine</span> 
    height=1.77 <span class="comment"># in meters</span>
    married=True <span class="comment"># the contrary would be written "False"</span>
pt: firstName = "Martin"
    lastName = 'Quinson' <span class="comment"># aspas e aspas simples funcionam aqui</span>
    frase = "uma gota d'água é sempre melhor que nada" <span class="comment"># uma aspas simples entre aspas duplas vale</span> 
    altura=1.77 <span class="comment"># em metros</span>
    casado=True <span class="comment"># o contrário se escreve "False"</span>

note: type: Content of: <h3>
en: Affectations
pt: Atribuições

note: type: Content of: <p>
en: Once your variable is declared, you can <b>affect</b> a new value to it later in the program. That's really easy:
pt: Uma vez que a sua variável está declarada, pode lhe <b>atribuir</b> um novo valor mais tarde no programa. Isto é bem fácil:

note: type: Content of: <p>
en: To the right of the equal symbol, you can put an arithmetic expression containing constants, variables and operations.
pt: À esquerda do símbolo de igual pode pôr uma expressão aritmética a conter constantes, variáveis e operações.

note: type: Content of: <pre>
en: x = 3 + 2[!java|c];[/!]
    x = 3 * x[!java|c];[/!]
    [!java|scala|python]greeting = "Hello "+name[!java];[/!] <span class="comment">[!python]#[/!][!scala|java]//[/!] + is (also) the operation to concatenate (ie, to join) strings[/!]</span>
pt: x = 3 + 2[!java|c];[/!]
    x = 3 * x[!java|c];[/!]
    [!java|scala|python]saudação = "Oi "+nome[!java];[/!] <span class="comment">[!python]#[/!][!scala|java]//[/!] + é (também) a operação para concatenar (ie, para juntar) cadeias[/!]</span>

note: type: Content of: outside any tag (error?)
en: It is now time to do more challenging exercises, don't you think? The objective is now to move forward until you find a baggle, pick it up, and then move back to your initial location before dropping the baggle.
pt: Agora vamos fazer exercícios mais desafiantes, certo? O objetivo agora é mover para a frente até encontrar um baggle, apanhar-lo e mover para trás até a localização inicial antes de sotar o baggle.

note: type: Content of: <h3>
en: How to do this?
pt: Como fazer isto?

note: type: Content of: <p>
en: To solve this problem, you have to decompose it in easier sub-parts. For example, you may want to do the following steps:
pt: Para resolver este problema, tem que decompor-lo em sub-partes menores. Por exemplo, pode fazer os passos seguintes:

note: type: Content of: <p><ol><li>
en: Move forward until located over a baggle
pt: Mover para a frente até se pôr sobre um baggle

note: type: Content of: <p><ol><li>
en: Pickup the baggle
pt: Apanhar o baggle

note: type: Content of: <p><ol><li>
en: Move backward of the same amount of steps than done in first step
pt: Mover para trás a mesma quantidade de passos que deu no primeiro passo

note: type: Content of: <p><ol><li>
en: Drop back the baggle
pt: Soltar o baggle de novo

note: type: Content of: <p>
en: Naturally, it is impossible to do the right amount of steps backward at step 3 if you didn't count the amount of steps done in the first phase. You can use a variable for that, which can be named <code>stepAmount</code>.
pt: Naturalmente, é impossível dar a quantidade certa de passos para trás no passo 3 se não contou a quantidade de passos dados na primeira fase. Pode usar uma variável para isto, que pode ser chamada <code>quantidadeDePassos</code>.

note: type: Content of: <p>
en: Create an integer variable before phase 1, initialize it to 0, and each time you move one step forward, increment its value by one (<code>stepAmount = stepAmount + 1;</code>[!java|c] or <code>stepAmount++;</code>, both syntaxes being equivalent[/!]).  Such variable which takes every values of a given range is often called a <b>stepper</b>.
pt: Crie uma variável inteira antes da fase 1, inicie ela com 0 e a cada vez que der um passo para frente, incremente ela de um (<code>quantidadeDePassos = quantidadeDePassos + 1;</code>[!java] ou <code>quantidadeDePassos++;</code>, ambas as sintaxes são equivalentes[/!]).  Tais variáveis que obtèm cada valor de um dado intervalo são normalmente chamadas de <b>stepper</b>.

note: type: Content of: <p>
en: If you know Java or other languages, you will probably try to use the <code>++</code> operator to increment the variable, but it's not allowed in [!thelang].  This is because it would be difficult to define this operator for every data types.  For example, what should ++ do when applied to a Complex value or to a String? The problem does not occur in Java as <code>int</code> is not an object but a primitive type.  (if you don't know the <code>++</code>, just ignore this paragraph: it does not exist in [!thelang])
pt: Se conhece Java ou outras linguagens, provavelmente vai tentar usar o operador <code>++</code> para incrementar a variável, mas isto não é permitido em [!thelang].  Isto é por que seria difícil definir este operador para todos os tipos de dados.  Por exemplo, o que faria ++ quando aplicado a um valor complexo ou a uma cadeia? O problema não ocorre em Java, pois <code>int</code> não é um objeto e sim um tipo primitivo.  (se não conhece o <code>++</code>, simplesmente ignore este parágrafo: fnão existe em [!thelang])

note: type: Content of: <p>
en: Then, phase 3 consists in simply creating a new integer variable <code>doneSteps</code> initialized to 0, and do one step backward as long as <code>doneSteps</code> is not equal to <code>stepAmount</code>, incrementing <code>doneSteps</code> each time. The <code>!=</code> operator should be used to test the inequality (whether some values are NOT equal).
pt: Então, a fase 3 consiste em simplesmente criar uma nova variável inteira <code>passosDados</code> iniciada como 0 e dar um passos para trás enquanto <code>passosDados</code> não for igual a <code>quantidadeDePassos</code>, a aumentar <code>passosDados</code> a cada vez. O operador <code>!=</code> deve ser usado para testar a inequação (quando um valor NÃO É igual).

note: type: Content of: <p>
en: It's your turn now!
pt: Agora é a sua vez!

note: type: Content of: <h2>
en: Run Four bases
pt: Ande quatro bases

note: type: Content of: <p>
en: Today is a great day for the buggles: the Big Buggles' Race begun. It's a traditional competition in which young buggles prove their value to the tribe. Both force and intelligence is exercised: you have to rush forward, but stop as soon as you reach your fourth baggle.  Please help the buggles to move forward while counting the baggles and to determine when to stop.
pt: Hoje é um grande dia para os buggles: a grande corrida dos Buggles começou. Esta é uma competição tradicional na qual jovens buggles mostram o valor deles para a tribo. Tanto força quanto inteligência são exercitados: tem que correr, mas parar assim que alcançar o quarto baggle. Por favor, ajude os buggles a se moverem para frente enquanto conta os baggles e determina quando parar.

note: type: Content of: <h2>
en: The Four Halves run
pt: A corrida dos quatro meios

note: type: Content of: <p>
en: Here is the second day of the Big Buggles' Race.  As previously, you have to run forward until you reach the right cell to stop on.  But this time, you have to reach the cell where the amount of baggles you saw is the double of the orange cells plus 1.  In other words, the following condition must become true: <code>2 * baggles = orangeCells + 1</code>.
pt: Chegamos ao segundo dia da grande corrida dos Buggles. Como antes, tem que correr até alcançar a célula certa para parar. Mas desta vez, tem que alcançar a célula onde a quantidade de baggles que viu é o dobro da quantidade de células laranjas mais 1. Em outras palavras, a seguinte condição deve se tornar verdadeira <code>2 * baggles = célulasLaranjas + 1</code>.

note: type: Content of: <p>
en: You can determine whether you are over a orange cell with the <code>isOverOrange()</code> method.
pt: Pode determinar quando está sobre uma célula laranja com o método <code>isOverOrange()</code>.

note: type: Content of: <p>
en: While loops are well adapted to situations where you want to achieve an action while a condition stays true, but it is less adapted to achieve a given action a predetermined amount of time. For example, when we wanted to move <code>stepAmount</code> steps backward in a previous exercise, we had to create a new variable, initialize it, and move backward while incrementing this variable until it became equal to <code>stepAmount</code>.
pt: loops 'while' são bem adaptados a situações onde precise realizar uma ação enquanto uma condição se mantém verdadeira, mas são menos preparados para realizar uma ação numa quantidade predeterminada. Por exemplo, quando nos quisemos mover <code>quantidadeDePassos</code> para trás num exercício anterior, tivemos que criar uma nova variável, inicializar ela e mover para trás enquanto aumentávamos esta variável até ela se tornar igual a <code>quantidadeDePassos</code>.

note: type: Content of: <p>
en: In such situations, <code>for</code> loops become handy. Their syntax is the following:
pt: Em tais situações, loops <code>for</code> se tornam úteis. As sintaxes delas são as seguintes:

note: type: Content of: <pre>
en: [!java|c]for (<b>initializing</b>; <b>condition</b>; <b>incrementing</b>) {
        <b>action</b>();
    }[/!][!python]for <b>variable</b> in <b>sequence of values</b>:
        <b>action</b>()[/!][!scala] for (<b>variable</b> &lt;- <b>firstValue</b> to <b>lastValue</b>) { 
        <b>action</b>();
    }[/!]
pt: [!java|c]for (<b>inicialização</b>; <b>condição</b>; <b>incremento</b>) {
        <b>ação</b>();
    }[/!][!python]for <b>variável</b> in <b>sequência-de-valores</b>:
        <b>ação</b>()[/!][!scala] for (<b>variável</b> &lt;- <b>primeiroValor</b> to <b>últimoValor</b>) { 
        <b>ação</b>();
    }[/!]

note: type: Content of: <p>
en: For example to repeat the loop body <code>n</code> times, [!python] it is handy to use the instruction <code>range(n)</code> to generate the sequence n integer value from 0 to n-1.[/!] [!java|scala|c] one should write:[/!]
pt: Por exemplo, para repetir o corpo do loop <code>n</code> vezes, [!python] é útil usar a instrução <code>range(n)</code> para gerar a sequência de n valores inteiros de 0 a n-1.[/!] [!java|scala|c] deve escrever:[/!]

note: type: Content of: <pre>
en: [!java]for (int stepper=0; stepper&lt;n; stepper++) {
        <b>action</b>();
    }[/!][!c]int stepper;
    for (stepper=0; stepper&lt;n; stepper++) {
        <b>action</b>();
    }[/!][!python]for <b>stepper</b> in <b>range(n)</b>:
        <b>action</b>()[/!][!scala] for (<b>stepper</b> &lt;- <b>1</b> to <b>n</b>) { 
        <b>action</b>();
    }[/!]
pt: [!java]for (int iterador=0; iterador&lt;n; iterador++) {
        <b>ação</b>();
    }[/!][!c]int iterador;
    for (iterador=0; iterador&lt;n; iterador++) {
        <b>ação</b>();
    }[/!][!python]for <b>iterador</b> in <b>range(n)</b>:
        <b>ação</b>()[/!][!scala] for (<b>iterador</b> &lt;- <b>1</b> to <b>n</b>) { 
        <b>ação</b>();
    }[/!]

note: type: Content of: <p>
en: This code is then equivalent to the following one from the computer point of view. From the programmer point of view, one form or the other can make the source code easier to read, depending on the situation. You should chose wisely in each situation whether you want to use a for loop or a while loop. Your uttermost goal should remain to keep your code simple and easy to read, to ensure that your day remain pleasant and productive.
pt: Este código é então equivalente ao seguinte do ponto de vista do computador. Do ponto de vista do programador, uma forma ou outra pode ser mais difícil ou mais fácil de ler, a depender da situação. Deve escolher sabiamente em qual situação usar um loop for ou um loop while. O seu objetivo principal deve ser manter o seu código simples e fácil de ler, para garantir que o seu dia seja agradável e produtivo.

note: type: Content of: <pre>
en: [!java|c]int stepper = 0;
    while (stepper &lt; n) {
    &nbsp;&nbsp;&nbsp;&nbsp;<b>action</b>();
    &nbsp;&nbsp;&nbsp;&nbsp;<b>stepper++</b>;
    }[/!][!python]stepper=0
    while stepper &lt; n: 
        action()
        stepper = stepper + 1[/!][!scala]
    var stepper = 1
    while (stepper &lt;= n) {
        <b>action</b>()
        stepper = stepper + 1
    }[/!]
pt: [!java|c]int iterador = 0;
    while (iterador &lt; n) {
    &nbsp;&nbsp;&nbsp;&nbsp;<b>ação</b>();
    &nbsp;&nbsp;&nbsp;&nbsp;<b>iterador++</b>;
    }[/!][!python]iterador=0
    while iterador &lt; n: 
        ação()
        iterador = iterador + 1[/!][!scala]
    var iterador = 1
    while (iterador &lt;= n) {
        <b>ação</b>()
        iterador = iterador + 1
    }[/!]

note: type: Content of: <p>
en: In that case, the <code>for</code> loop is easier to read, don't you think?
pt: Neste caso, o loop <code>for</code> é fácil de ler, não acha?

note: type: Content of: <p>
en: It is possible to build more advanced <tt>for</tt> loops since any valid instruction can be used as initialization, condition and incrementing instruction. The following example is a bit extreme as there is no need for a loop body to move the buggle forward until it reaches the wall, but it works well: all the work is done in the condition and incrementing instruction.
pt: É possível construir loops <tt>for</tt> mais avançados já que qualquer instrução válida pode ser usada como inicialização, condição e instrução de incrementação. O exemplo seguinte é um pouco extremo, pois não existe necessidade para um corpo de loop mover um buggle para frente até alcançar a parede, mas funciona bem: todo o trabalho é feito nas instruções de condição e incremento.

note: type: Content of: <pre>
en: for (; !isFacingWall() ; forward()) { 
       <span class="comment">/* nothing in the loop body */</span>
    }
    <span class="comment">/* the buggle now faces a wall */</span>
pt: for (; !isFacingWall() ; forward()) { 
       <span class="comment">/* nada no corpo do loop */</span>
    }
    <span class="comment">/* o buggle agora está de cara para uma parede */</span>

note: type: Content of: <p>
en: If you want to nest several loops, you can do it on one line in Scala. This means that the two following chunks are equivalent:
pt: Se quer aninhar vários loops, pode fazer-lo numa linha no Scala. Isto significa que os dois blocos seguintes são equivalentes:

note: type: Content of: <pre>
en: for (stepper1 &lt;- 1 to n) {
        for (stepper2 &lt;- 1 to m) {
           actions()
        }
    }
pt: for (iterador1 &lt;- 1 to n) {
        for (iterador2 &lt;- 1 to m) {
           ações()
        }
    }

note: type: Content of: <pre>
en: for (stepper1 &lt;- 1 to n; stepper2 &lt;- 1 to m) { <span class="comment">// Simply separate both loop conditions with a semi-column</span>
        actions()
    }
pt: for (iterador1 &lt;- 1 to n; iterador2 &lt;- 1 to m) { <span class="comment">// Simplesmente separe as duas condições de loop com um ponto-e-vírgula</span>
        ações()
    }

note: type: Content of: <p>
en: You now have to redo the same exercise than previously (move forward until being over a baggle, pick it up, move back to your original location, drop the baggle), but using a <code>for</code> loop instead of a <code>while</code> loop to move back to the initial location.
pt: Agora tem que refazer o mesmo exercício de antes (mover para frente até estar sobre um baggle, pegá-lo, mover para trás até a localização original, soltar o baggle), mas a usar um loop <code>for</code> no lugar de um loop <code>while</code> para mover de volta ao local inicial.

note: type: Content of: <p>
en: Once done, you can proceed to next exercise.
pt: Uma vez feito, pode seguir ao próximo exercício.

note: type: Content of: <h2>
en: Stairway to Heaven
pt: Uma escadaria para o Céu

note: type: Content of: <p>
en: Your buggle feels a bit depressed today, but it's currently facing a magic stair: It leads directly to heaven, and each time you walk on it, joyful colors spur all around.
pt: O seu buggle está um pouco deprimido hoje, mas está em frente de uma escada mágica: ela leva diretamente ao paraíso e cada vez que anda nela, belas cores surgem de todos os lados.

note: type: Content of: <p>
en: Your goal is to take this stair, one step after the other.  First devise the four instructions you have to give you buggle to take one stair step, and then put them in a loop to take the whole stair.
pt: O seu objetivo é subir a escada, um passo de cada vez. Primeiro "devise" as quatro instruções que tem que dar ao buggle para subir um degrau e então ponha-a num loop para subir toda a escada.

note: type: Content of: <p>
en: Before that, walk a bit forward to reach that stair, and ensure that you are in the right situation for your loop content to run properly. And once you reach the heaven, take some steps in your new home.  Meanwhile, you just have to walk your way, the colors appear automagically.
pt: Antes disto, ande um pouco para a frente para alcançar a escada e certifique-se de estar na situação certa para que o que o loop faz seja feito corretamente. E uma vez alcançado o Céu, dê uns passos no seu novo lar. Enquanto isto, deve apenas seguir o seu caminho, as cores aparecem automagicamente.

note: type: Content of: <h2>
en: Training Buggle
pt: Treinar o Buggle

note: type: Content of: <p>
en: Today, your buggle wants to get some serious exercise: It wants to run 'till the track burns! Its super-shoes are just perfect to run like hell, but unfortunately, they can actually damage the track on the long run...
pt: Hoje o seu buggle quer fazer exercício seriamente: quer correr até tocar fogo na trilha! Os super-sapatos deles são perfeitos para correr loucamente, mas infelizmente, podem estragar seriamente a trilha a longo prazo...

note: type: Content of: <p>
en: Your goal is to run the track 10 times, no matter what happens.  Even if the track suffers, you <b>really HAVE</b> to take that run.  Remember, the track has four sides, that take eight steps each to run along.  Now go, and show them what these super shoes can do.
pt: O seu objetivo é percorrer a trilha 10 vezes, não importa o que aconteça. Mesmo se a trilha "suffers", <b>TEM MESMO</b> que fazer esta corrida. Lembre-se, a triha tem quatro lados, cada lado com oito passos. Agora vá e mostre-lhe o que os seus super-sapatos podem fazer.

note: type: Content of: <p>
en: You don't have to do anything particular with regard of the colors: your shoes will do it for you. Just take that run!
pt: Não tem que fazer nada de particular com respeito às cores: os seus sapatos vão fazer isto para si. Apenas corra!

note: type: Content of: <h2>
en: Outdoor Training Buggle
pt: Treinamento ao ar livre do Buggle

note: type: Content of: <p>
en: Well, our last training didn't went that well. The track actually burned, and we are now banned from there.  This time, our buggle decided to practice outdoor, in the middle of the forest, with its good old shoes instead.  The problem is that you have to be careful to not fall into water. The track on which you can run is rather narrow: One side is now 4 steps forward, 2 steps to the left, 4 steps to the right, 2 steps to the right, 4 steps to the left, and you want to run 7 around.
pt: Bem, nosso último treino teve um probleminha. A trilha tocou fogo e fomos banidos de lá. Desta vez, nosso buggle decidiu praticar ao ar livre, no meio da floresta, com os sapatos velhos deles. O problema é que tem que ser cuidadoso para não cair na água. A trilha onde corre é estreita: "One side is now" 4 passos para a frente, 2 passos para a esquerda, 4 passos para a direita, 2 passos para a direita, 4 passos para a esquerda, "and you want to run 7 around".

note: type: Content of: <p>
en: Oh crap, running on the grass seems to destroy it too! So just take your 7 loops around the garden, and move along to the next exercise before anyone notices the damage you made...
pt: Putz, correr na grama destrói a grama também! Então dê apenas 7 voltas no jardim e depois vá ao próximo exercício antes que alguém perceba o estrago que fez...

note: type: Content of: <p>
en: Some cells of the world are yellow, but your buggle cannot stand being in such cells. Write the necessary code to move forward until the ground gets white. For that, use the provided method <code>isGroundWhite()</code>.
pt: Algumas células do mundo são amarelas, mas o seu buggle não pode ficar sobre estas células. Escreva o código necessário para mover para a frente até que o chão fique branco. Para isto use o método fornecido <code>isGroundWhite()</code>.

note: type: Content of: <p>
en: The trick is that most buggles of this world are currently on this yellow ground that they dislike so much. That is why they are in panic, and every buggle rushes one cell forward, even the buggle that was not on a yellow cell at first. In other worlds, even if the ground is white on the first cell, you still want to move forward to the next cell.
pt: O truque é que a maioria dos buggles deste mundo ficam sobre o chão amarelo que eles não gostam. é por isto que eles estão em pânico e cada buggle "rushes" uma célula para a frente, mesmo aqueles que não estavam numa célula amarela no começo. Em outras palavras, mesmo se o chão for branco na primeira célula, ainda vai mover para a próxima célula.

note: type: Content of: <p>
en: The general idea is to do something like:
pt: A ideia geral é fazer algo como:

note: type: Content of: <pre>
en: move forward until located in a white cell
pt: Mover para a frente até estar numa célula branca

note: type: Content of: <p>
en: The main difficulty is that we want this loop body to be executed once, even we are already on a white cell.  It would be easy to do so by duplicating the loop content before the actual loop, but this would be a bad idea: code duplication is a <b>very</b> bad habit, and you should <b>always</b> avoid it.
pt: A coisa mais difícil é que queremos executar o corpo do loop uma vez, mesmo se já estivermos numa célula branca. Isto é fácil a duplicar o código do loop'antes do loop em si, mas esta é uma má ideia: diplicação de código é um hábito <b>muito</b> ruim e deve evitar isto <b>sempre</b>.

note: type: Content of: <p>
en: Code duplication easily turns code maintenance into a nightmare: reading the code becomes difficult as the reader must ensure that no slight difference exist between the versions. Debugging the code becomes difficult, as bugs have to be fixed in all versions. Actually, every modification of the code becomes difficult. So, really, you should <b>always</b> strive to not duplicate your code if you can avoid. And the good news is that you always can...
pt: Duplicação de código faz da manutenção de código um pesadelo rapidamente: é fdifícil ler o código e o leitor tem que garantir que nenhuma pequena diferença exista entre as versões. Depurar o código se torna difícil, pois os bugs devem ser consertados em todas as versões. Na verdade, cada modificação do código se torna difícil. Então, na verdade, deve <b>sempre</b> se esforçar para não duplicar o seu código sempre que possível. Mas a boa notícia é que sempre pode...

note: type: Content of: <h3>
en: Executing the loop body at least once
pt: A executar o corpo do loop pelo menos uma vez

note: type: Content of: <p>
en: Some languages have specific constructs for that, but not the Python language. No problem, we can do it on our own! A good way is to have a dedicated variable indicating whether we are taking the loop for the first time or not, as follows.
pt: Algumas linguagens tem construções específicas para isto, mas não a linguagem Python. Sem problemas, podemos fazer isto nós mesmos! Uma boa forma é ter uma variável dedicada a indicar se estamos a entrar no loop a primeira vez ou não, como segue.

note: type: Content of: <pre>
en: firstTime = True
    while firstTime or (other conditions):
      firstTime = False
      (loop body)
pt: primeiraVez = True
    while primeiraVez or (outras condições):
      primeiraVez = False
      (corpo do loop)

note: type: Content of: <p>
en: When <code>firstTime</code> is true, the loop body is executed even if the other conditions would imply the contrary.  Once the loop body has been executed once, it is set to false and never impact again the decision to enter the body or not.
pt: Quando <code>primeiraVez</code> é true, o corpo do loop é executado mesmo se as outras condições digam o contrário.  uma vez que o loop tenha sido executado uma vez, esta variável vira false e nunca mais impacta na decisão de entrar ou não no loop.

note: type: Content of: <p>
en: In a <tt>while</tt> loop, the condition is evaluated before anything else, and if it's false, the loop body is never evaluated. Sometimes (although not that often), you would prefer the loop body to get evaluated at least once, even if the condition is initially false. For that, a variation of the <tt>while</tt> loop gets used, using the following syntax in [!thelang].  [!java|c]Do not forget the semi-column (;) after the condition, it is mandatory.[/!]
pt: Num loop <tt>while</tt>, a condição é calculada antes de qualquer coisa e se for falsa, o corpo do loop nunca é executado. Algumas vezes (mas não muito frequentemente), pode preferir que o corpo do loop seja executado pelo menos uma vez, mesmo se a condição seja inicialmente falsa. Para isto, uma variação do loop <tt>while</tt> é usada, com a seguinte sintaxe em [!thelang].  [!java|c]Não se esqueça do ponto-e-vírgula (;) depois da condição, que é obrigatório.[/!]

note: type: Content of: <p><pre>
en: do {
        <b>action()</b>[!java];[/!]
    } while (<b>condition</b>)[!java];[/!]
pt: do {
        <b>ação()</b>[!java];[/!]
    } while (<b>condição</b>)[!java];[/!]

note: type: Content of: <h2>
en: Tracks of buggles
pt: Trilhas de buggles

note: type: Content of: <p>
en: Your buggle got lost in a strange maze, and you must help it to find the exit that is represented in orange.  You cannot simply explain the path to the exit in something like <code>right();forward();forward();forward()</code> because you have to save two buggles at the same time, that are lost in similar but not identical worlds.  You can switch to the other world by using the combobox above the world representation (where it's written 'Deep Forest' right now), and selecting the other entry (that should read 'Deeper Forest').
pt: O seu buggle perdeu-se num estranho labirinto e deve ajudá-lo a achar a saída que está representada em laranja. Não pode simplesmente explicar o caminho para a saída com algo do tipo <code>right();forward();forward();forward()</code> por que tem que gravar dois buggles ao mesmo tempo, que estão presos em mundos similares, mas não iguais. Pode alternar para o outro mundo a usar o combobox acima da representação do mundo (onde está escrito 'Floresta Fechada' agora) e selecionar a outra entrada (que deve ler 'Floresta Mais Fechada').

note: type: Content of: <p>
en: The good news is that the path to the exit is written on the ground. As you can see, the world is made of several corridors, with baggles on the ground. After each corridor, you should turn left if the corridor contains three baggels or more, and you have to turn right if there is only 2 baggles or less.
pt: A boa nova é que o caminho para a saída está desenhado no chão. Como pode ver, o mundo é feito de vários corredores, com baggles no chão. Depois de cada corredor, deve virar à esquerda se o corredor tiver três baggels ou mais e virar a direita se tiver apenas 2 ou menos baggles.

note: type: Content of: <p>
en: You should count exactly 5 cells per corridor, from intersection to intersection.  Consider in your count the intersection ending the corridor but not the intersection before the corridor.
pt: Deve contar exatamente 5 células por corredor, de intersecção a intersecção.  Considere na sua contagem a intersecção terminar o corredor, mas não a intersecção antes do corredor.

note: type: Content of: <p>
en: So, the general form of your code must be something like "while I did not find the exit, take the next corridor to decide whether I should turn left or right at the next intersection". You can determine whether you are on the exit cell (that is orange) with the provided <code>exitReached()</code> method.
pt: Logo, a forma geral do seu código deve ser algo como "enquanto não encontrar a saída, escolha o próximo corredor para decidir se vira à esqueda ou à direita na próxima intersecção". Pode determinar se está na célula de saída (que é laranja) com o método <code>exitReached()</code> fornecido.

note: type: Content of: <p>
en: To take one corridor, you simply have to run from one intersection to another while counting the baggles you see on your path. That's easy: there is 5 steps in each corridors so a simple <code>for</code> loop suffices.
pt: Para entrar num corredor, tem que simplesmente correr de uma intersecção para outra enquanto conta os baggles que vê no seu caminho. Isto é fácil: existem 5 passos em cada corredor, de forma que um simples loop <code>for</code> resolve.

note: type: Attribute 'alt' of: <p><div>
en: I cannot imagine how to count the baggles I see.
pt: Não consigo imaginar como contar os baggles que vejo.

note: type: Content of: <p><div>
en: You need a variable that is initialized to 0, and incremented each time you see a baggle on the ground. A variable used this way is often called <i>counter</i>.
pt: Precisa de uma variável que é inicializada em 0 e incrementada cada vez que vê um baggle no chão. Uma variável usada desta forma é frequentemente chamada de <i>contador</i>.

note: type: Content of: <p><div>
en: Don't forget to reset your counter to 0 at the beginning of each corridor!
pt: Não se esqueça de resetar o seu contador para 0 no começo de cada corredor!

note: type: Content of: <p>
en: Oh, and when you reach the exit, don't forget to take an extra step to actually exit the maze!
pt: Ah, e quando chegar na saída, não se esqueça de dar um passo a mais para sair de fato do labirinto!

note: type: Content of: <h2>
en: More buggles tracks
pt: Mais rastros de buggles

note: type: Content of: <p>
en: Hu oh! Your buggle got lost again in the same kind of maze, but this time, the corridors are not always of the same size. Since there is no way to know the length of the corridor before taking it, a <code>for</code> will not suffice anymore. Instead, you will have to change your inner loop to use a <code>while</code> loop, using the method <code>crossing()</code> that tells whether your buggle currently stands on an intersection.
pt: Uau! O seu buggle perdeu-se novamente no mesmo tipo de labirinto, mas desta vez, os corredores nem sempre são do mesmo tamanho. Porque não há como saber a comprimento do corredor antes de tomá-lo, um <code>for</code> não será mais suficiente. Ao invés disso, terá que mudar o seu loop interno para usar um loop <code>while</code>, a usar o método <code>crossing()</code> que diz se o seu buggle está atualmente numa intersecção.

note: type: Content of: <p>
en: The extra complexity is that at the beginning of a corridor, you obviously stand on an intersection, but you still want to move on.  [!java|scala|c]For that, the easiest is to use a <code>do / while</code> loop instead of a regular <code>while</code> loop to move until the next intersection.[/!] [!python]For that, use an extra variable indicating whether you already entered the corridor, as follows. This will ensure that you execute the loop body at least once (when <code>firstTime</code> is true) before we actually use the value returned by <code>crossing()</code> to determine to continue or not.[/!]
pt: A complexidade adicional é que no início de um corredor, obviamente está num cruzamento, mas ainda quer seguir.  [!java|scala|c]Para isso, o mais fácil é usar um loop <code>do / while</code> em vez de um loop regular <code>while</code> para mover até a próxima intersecção.[/!] [!python]Para isso, use uma variável adicional para indicar se já entrou no corredor, como a seguir. Isto assegurará que execute o corpo do loop pelo menos uma vez (quando <code>firstTime</code> for true) antes de usarmos o valor retornado por <code>crossing()</code> para determinar se devemos continuar ou não.[/!]

note: type: Content of: <pre>
en: firstTime = True
    while firstTime or not crossing():
      firstTime = False
      (loop body)
pt: primeiraVez = True
    while primeiraVez or not crossing():
      primeiraVez = False
      (corpo do loop)

note: type: Content of: <p>
en: With that new trick, your buggle should exit this maze quite easily.
pt: Com esse novo truque, o seu buggle deve sair desse labirinto muito facilmente.

note: type: Content of: <h1>
en: [!java|scala]Arrays[/!][!python]Lists[/!] and Knotting
pt: [!java|scala]Arrays[/!][!python]Lists[/!] e nós

note: type: Content of: outside any tag (error?)
en: The goal of this exercise is to reproduce the pattern of the first row in the other rows with a shift of one cell (see the Objective tab for details). The biggest difference between this exercise and the others we had on patterns is that you have to read the pattern (on first row) before reproducing it. You cannot do otherwise because the same code will be executed on three different worlds, each of them having a specific pattern.
pt: O objetivo deste exercício é reproduzir o padrão da primeira linha nas outras linhas com um deslocamento de uma célula (veja a guia Objetivo para detalhes). A maior diferença entre este exercício e os outros sobre padrões é que tem que ler o padrão (na primeira linha) antes de reproduzí-lo. Não pode fazer de outro jeito por que o mesmo código será executado em três mundos diferentes, cada um com um próprio padrão.

note: type: Content of: <p>
en: One solution is to read the next cell, and go copy it in position before coming back to read the second cell. But since it is forbidden to use the methods to teleport the buggle to a specific position (<code>setPos()</code> and similar), this approach will be a pain to implement.
pt: Uma solução é ler a próxima célula e copiá-la à posição antes de voltar para ler a segunda célula. Mas já que é proibido usar os métodos de teletransporte de buggle para uma posição específica (<code>setPos()</code> e similares), esta abordagem seria muito difícil de implementar.

note: type: Content of: <p>
en: The simplest is to store the sequence of colors that constitute the whole pattern in an [!java|scala]<b>array</b>[/!][!python]<b>list</b>[/!].  But before we can do so, we should learn a bit what [!java|scala]arrays[/!][!python]lists[/!] are.
pt: O mais simples é armazenar a sequência de cores que constituem o padrão inteiro numa [!java|scala]<b>array</b>[/!][!python]<b>list</b>[/!].  Mas antes de fazer isto, devemos aprender um pouco sobre o que [!java|scala]arrays[/!][!python]lists[/!] são.

note: type: Content of: <p>
en: [!java|scala]An array[/!][!python]A list[/!] is an ordered sequence of variables that go together.  It is somehow similar to a shelve where each level can store a separate value. Each variable of the sequence is identified by its position, and can store a specific value. [!java|scala]All cells of the array must store values of the same type because arrays are homogeneous in [!thelang]. It is possible to trick this restriction by using the datatype <code>[!java]Object[/!][!scala]Any[/!]</code> that can contain [!java]almost[/!] any other datatype. [!java]Primitive types such as the ones we saw so far (int, boolean, double, char, etc) cannot be stored in an Object variable, but their objectified counter-part (Integer, Boolean, Double, Char, Boolean, etc) can.[/!] It is however a good practice to make the type of an array as specific as possible, i.e., if you plan to store some integers in your array, make it an array of integers, not of [!java]Object[/!][!scala]Any[/!].[/!] [!python]Lists can even mix values of differing types, such as integer values in some cells and colors in other cells.[/!]
pt: [!java|scala]Uma array[/!][!python]Uma list[/!] é uma sequência ordenada de variáveis que ficam juntas. é similar a uma estante onde em cada prateleira se coloca um valor separado. Cada variável da sequência é identificada pela posição dela e pode armazenar um valor específico. [!java|scala]todas as células da array devem armazenar valores do mesmo tipo por que arrays são homogêneas em [!thelang]. É possível burlar esta restrição a usar tipos de dados <code>[!java]Object[/!][!scala]Any[/!]</code> que contenham [!java]praticamente[/!] qualquer outro tipo de dados. [!java]Tipos primitivos como aqueles que vimos anteriormente (int, boolean, double, char, etc) não podem ser armazenados numa variável Object, mas suas contrapartidas objetificadas (Integer, Boolean, Double, Char, Boolean, etc) podem.[/!] Entretanto, é boa prática fazer o tipo de uma array o mais específico possível, p.ex., se planea armazenar alguns inteiros na sua array, faça dela uma array de inteiros, não de [!java]Object[/!][!scala]Any[/!].[/!] [!python]Lists podematé mesmo misturar valores de diferentes tipos, como valores inteiros em algumas células e cores em outras células.[/!]

note: type: Content of: <p>
en: T is the [!java|scala]array[/!][!python]list[/!]'s name, [!java|python]T[0][/!][!scala]T(0)[/!] is the name of the first cell, [!java|python]T[1][/!][!scala]T(1)[/!] the name of the second cell, [!java|python]T[2][/!][!scala]T(2)[/!] the third one, etc. And yes, the first cell is numbered [!java|python]T[0][/!][!scala]T(0)[/!] while the last one of [!java|scala]an array[/!][!python]a list[/!] of size N is [!java|python]T[N-1][/!][!scala]T(N-1)[/!]. It may seem funny to count starting from 0 and not from 1 as usual, but some historical reasons make it unavoidable here.
pt: T é o nome da [!java|scala]array[/!][!python]list[/!], [!java|python]T[0][/!][!scala]T(0)[/!] é o nome da primeira célula, [!java|python]T[1][/!][!scala]T(1)[/!] é o nome da segunda célula, [!java|python]T[2][/!][!scala]T(2)[/!] da terceira e etc. E sim, a primeira célula é numerada [!java|python]T[0][/!][!scala]T(0)[/!] e a última de uma [!java|scala]array[/!][!python]list[/!] de tamanho N é [!java|python]T[N-1][/!][!scala]T(N-1)[/!]. Pode parecer estranho contar a partir de 0 e não de 1 como normalmente, mas por motivos históricos isto agora é inevitável.

note: type: Content of: <h3>
en: Basic usage
pt: Uso básico

note: type: Content of: <p>
en: We can use an integer variable <i>i</i> to access with [!java|python]T[i][/!][!scala]T(i)[/!] to the cells: when the value of <i>i</i> is 0, then [!java|python]T[i][/!][!scala]T(i)[/!] accesses [!java|python]T[0][/!][!scala]T(0)[/!]; when the value of <i>i</i> is 10, then [!java|python]T[i][/!][!scala]T(i)[/!] accesses [!java|python]T[10][/!][!scala]T(10)[/!].  <i>i</i> is said to be the <b>index</b> in T.  <code>[!java|python]T[i][/!][!scala]T(i)[/!]</code> can be used just like any variable. We can set a new value:
pt: Podemos usar uma variável inteira <i>i</i> para acessar com [!java|python]T[i][/!][!scala]T(i)[/!] as células: quando o valor de <i>i</i> é 0, [!java|python]T[i][/!][!scala]T(i)[/!] acessa [!java|python]T[0][/!][!scala]T(0)[/!]; quando o valor de <i>i</i> é 10, [!java|python]T[i][/!][!scala]T(i)[/!] acessa [!java|python]T[10][/!][!scala]T(10)[/!]. Sizemos que <i>i</i> é o <b>índice</b> em T. <code>[!java|python]T[i][/!][!scala]T(i)[/!]</code> pode ser usada simplesmente como qualquer variável. Podemos configurar um novo valor:

note: type: Content of: <p>
en: We can retrieve and use its value:
pt: Podemos recuperar e usar valor dele:

note: type: Content of: <p>
en: We can test this value:
pt: Podemos testar este valor:

note: type: Content of: <pre>
en: if ([!java|python]T[i][/!][!scala]T(i)[/!] > 0) [!scala|java]{[/!][!python]:[/!]
        [!java|scala]//[/!][!python]#[/!] instructions...
    [!java|scala]}[/!]
pt: if ([!java|python]T[i][/!][!scala]T(i)[/!] > 0) [!scala|java]{[/!][!python]:[/!]
        [!java|scala]//[/!][!python]#[/!] instruções...
    [!java|scala]}[/!]

note: type: Content of: <p>
en: It is very easy to traverse the whole [!scala|java]array[/!][!python]list[/!], for example to initialize each cells.
pt: É muito fácil percorrer toda a [!scala|java]array[/!][!python]list[/!], por exemplo para iniciar as células.

note: type: Content of: <p>
en: [!java|scala]The notation <code>T.length</code> retrieves the length of the array T,[/!] [!python]The function <code>len()</code> retrieves the length of the list T,[/!] allowing to build a classical for loop easily.  [!python]Actually, the <code>len()</code> function is much more generic and can be used to retrieve the length of many objects.  Applied to strings for example, it returns the amount of chars in this string.[/!] [!scala]Don't forget to start at <code>0</code> and stop at <code>T.length-1</code> instead of <code>1</code> to <code>T.length</code> however.[/!]
pt: [!java|scala]A notação <code>T.length</code> recupera o comprimento (length) da  array T,[/!] [!python]A função <code>len()</code> recupera o comprimento da lista T,[/!] a permitir que se construa um loop clássico facilmente.  [!python]Na verdade, a função <code>len()</code> é muito mais genérica e pode ser usada para recuperar o comprimento de muitos objetos. Aplicada numa cadeia, por exemplo, ela retorna a quantidade de caracteres na cadeia.[/!] [!scala]Não se esqueça de começar em <code>0</code> e terminar em <code>T.length-1</code> ao invés de ir de <code>1</code> até <code>T.length</code>.[/!]

note: type: Content of: <p>
en: If you just want to iterate over the values of T without keeping track of their index, you can simply write:
pt: Se quer simplesmente iterar nos valores de T sem controlar o índice, pode simplesmente escrever:

note: type: Content of: <pre>
en: [!java]for (int i: T) {[/!][!scala]for (i &lt;- T) {[/!][!python]for i in T:[/!]
      action()[!java];[/!]
    [!java|scala]}[/!]
pt: [!java]for (int i: T) {[/!][!scala]for (i &lt;- T) {[/!][!python]for i in T:[/!]
      ação()[!java];[/!]
    [!java|scala]}[/!]

note: type: Content of: <p>
en: [!java]This construct is called an <i>extended loop</i> in Java. The variable <i>i</i> takes all values of the set located to the right of the colon (:), one after the other.[/!] [!python|scala]This is actually very similar to the previous construct.  Simply, <code>[!python]range(n)[/!][!scala]i to j[/!]</code> returns a set of integers over which the for construct iterates.  Actually, [!thelang] offers much more elegant ways to traverse [!python]lists[/!][!scala]arrays[/!] and other data collections, but this should be the topic of a specific set of exercises (that are still to be written in PLM).[/!]
pt: [!java]Esta construção é chamada um <i>loop extendido</i> em Java. A variável <i>i</i> assume todos os valores do conjunto localizado a direita do dois-pontos (:), um depois do outro.[/!] [!python|scala]Isto é na verdade muito similar à construção anterior. Simplesmente, <code>[!python]range(n)[/!][!scala]i to j[/!]</code> retorna um conjunto de inteiros sobre os quais o loop for itera. Na verdade, [!thelang] oferece formas muito mais elegantes de percorrer [!python]lists[/!][!scala]arrays[/!] e outras coleções de dados, mas isto fica para um conjunto específico de exercícios (que ainda será escrito no PLM).[/!]

note: type: Content of: <h3>
en: Declaring [!python]a list[/!][!java|scala]an array[/!]
pt: Declarar uma [!python]list[/!][!java|scala]array[/!]

note: type: Content of: <p>
en: If you know beforehand the content of your list, you can affect these values all together.  Just put them between square braces and separated by commas as follows:
pt: Se sabe antecipadamente o conteúdo da sua lista, pode atribuir os valores todos juntos. Ponha eles simplesmente entre colchetes e separados por vírgulas como segue:

note: type: Content of: <pre>
en: L = [1, 3, 5, 7, 9] 
    <span class="comment"># L is now an array of 5 values, all of them being integers</span>
pt: L = [1, 3, 5, 7, 9] 
    <span class="comment"># L agora é uma array de 5 valores, todos eles inteiros</span>

note: type: Content of: <p>
en: Otherwise, you probably want to create an empty list and then append each values separately to the list:
pt: Por outro lado, provavelmente vai criar uma lista vazia e depois anexar-la os valores separadamente:

note: type: Content of: <pre>
en: L2 = [] 
    <span class="comment"># L2 is now an empty list</span>
    L2.append(1)
    L2.append(3)
    L2.append(5)
    L2.append(7)
    L2.append(9) 
    <span class="comment"># Its content is now the same as L previously</span>
pt: L2 = [] 
    <span class="comment"># neste momento, L2 é uma lista vazia</span>
    L2.append(1)
    L2.append(3)
    L2.append(5)
    L2.append(7)
    L2.append(9) 
    <span class="comment"># E agora o seu conteúdo é igual ao de L, vista antes</span>

note: type: Content of: <p>
en: To declare a variable named <b>T</b> that can store an array of integers, one should write:
pt: Para declarar uma variável chamada <b>T</b> que pode guardar uma array de inteiros, deve escrever:

note: type: Content of: <p>
en: [!java]<code>int</code> means that the elements of the array are of type integer; <code>[]</code> means that we are speaking of an array and <code>T</code> is the name of the variable.  For historical reasons, this can also be written as <code>int T[]</code> (with the [] after the variable name), but this is less readable and should probably be avoided.[/!] [!scala]The <code>[Int]</code> notation specializes the Array type (that is generic), specifying that each cell of this array is an integer. An array of booleans would simply by written <code>Array[Boolean]</code>.[/!]
pt: [!java]<code>int</code> significa que os elementos da array são do tipo inteiro; <code>[]</code> significa que estamos a falar de uma array e <code>T</code> é o nome da variável. Por motivos históricos, também pode ser escrito como <code>int T[]</code> (com o [] depois do nome da variável), mas como assim é menos legível, é melhor evitar esta forma.[/!] [!scala]A notação <code>[Int]</code> especializa o tipo Array (que é genérico), a especificar que cada célula desta array é um inteiro. Um array de booleanos deve ser escrito simplesmente como <code>Array[Boolean]</code>.[/!]

note: type: Content of: <h3>
en: Allocating an array
pt: Alocar uma array

note: type: Content of: <p>
en: Declaring a variable <code>T</code> that stores an array only reserve the <b>name</b> <code>T</code> for later use, but not the memory area to store the cells. The array is not initialized yet: it does not have any value. What would <code>[!java]T[4][/!][!scala]T(4)[/!]</code> mean if we didn't say that the array is 5 cells long?
pt: Declarar uma variável <code>T</code> que armazena uma array apenas reserva o <b>nome</b> <code>T</code> para uso futuro, mas não reserva a área de memória para armazenar as células. A array ainda não está inicializada: ela não tem qualquer valor. O que significa <code>[!java]T[4][/!][!scala]T(4)[/!]</code> se ainda não dissemos que a array tem 5 células?

note: type: Content of: <p>
en: First and foremost, we have to give a value to <code>T</code>:
pt: Primeiramente, temos que dar um valor a <code>T</code>:

note: type: Content of: <p>
en: <code>new</code> means that we want to create something, and <code>[!java]int[10][/!][!scala]Array[Int](10)[/!]</code> means that it is an array of 10 integer values.  In return, an array of 10 integer cells is created in memory, and the <code>T</code> variable <b>references</b> this array.
pt: <code>new</code> (novo) significa que queremos criar algo e <code>[!java]int[10][/!][!scala]Array[Int](10)[/!]</code> significa que é uma array de 10 valores inteiros. Como resultado, uma array de 10 células para valores inteiros é criada na memória e a variável <code>T</code> <b>faz referência</b> a esta array.

note: type: Content of: <p>
en: The size of an array is fixed and cannot be changed after the creation of the array. The size of a <code>T</code> array can be retrieve by consulting the variable <code>T.length</code>.
pt: O tamanho de uma array é fixo e não pode ser mudado depois da criação da array. O tamanho de uma array <code>T</code> pode ser recuperado ao se consultar a variável <code>T.length</code>.

note: type: Content of: <p>
en: While allocating, you can specify the size with a variable: <code>[!java]int[] T = new int[i];[/!][!scala]var T = new Array[Int](i);[/!]</code> In this case, the array's size will be set to the value of <code>i</code> <i>when <code>new</code> gets called</i>.  The size of the array still cannot be modified: even if the variable <code>i</code> changes afterward, the size remains to the value given when it was allocated.  [!java]Also, it is forbidden to write something like <code>int T[10];</code> when declaring the variable.  You are required to use the <code>new</code> instruction to allocate it, as in <code>int[] T = new int[10];</code> [/!]
pt: Ao alocar pode especificar o tamanho com uma variável: <code>[!java]int[] T = new int[i];[/!][!scala]var T = new Array[Int](i);[/!]</code> Neste caso, o tamanho da array será ajustado para o valor de <code>i</code> <i>quando <code>new</code> for chamado</i>.  O tamanho da array ainda não pode ser modificado: mesmo se a variável <code>i</code> mudar depois disto, o tamanho permanece o do valor dado no momento da alocação.  [!java]Além disto, é proibido escrever algo como <code>int T[10];</code> no momento de declarar a variável. Deve usar a instrução <code>new</code> para alocar o array, como em <code>int[] T = new int[10];</code> [/!]

note: type: Content of: <h4>
en: Declaration and initialization
pt: Declaração e inicialização

note: type: Content of: <p>
en: If you know beforehand the content of your array, you can declare, allocate and initialize it in one shoot:
pt: Se sabe previamente o conteúdo da sua array, pode declarar, alocar e inicializar-la toda de uma vez:

note: type: Content of: <p>
en: To know the size of the array to allocate, the compiler counts the provided values.  This code is equivalent to:
pt: Para saber o tamanho da array para alocar, o compilador conta os valores dados. Este código é equivalente a:

note: type: Content of: <p>
en: It is also equivalent to:
pt: também é equivalente a:

note: type: Content of: <h3>
en: [!python]Lists[/!][!scala|java]Arrays[/!] and method parameters
pt: [!python]Lists[/!][!scala|java]Arrays[/!] e parâmetros de métodos

note: type: Content of: <p>
en: It is perfectly OK to pass [!python]a list[/!][!java|scala]an array[/!] to a method as a parameter.  This method can then use this parameter as if it were defined locally:
pt: Não há nenhum problema em passar uma [!python]list[/!][!java|scala]array[/!] para um método como parâmetro. Este método pode então usar este parâmetro como se fosse definido localmente:

note: type: Content of: <p>
en: On the caller side, that also very simple:
pt: No lado de quem invoca também é bastante simples:

note: type: Content of: <pre>
en: [!java]int[] tab = new int[10];[/!][!scala]var tab = new Array[Int] (10)[/!][!python]tab = [1, 3, 5, 7, 9][/!]
    [!java|scala]<span class="comment">// Values initialization omitted</span>
    [/!]if (has42First(tab))[!java|scala] {[/!][!python]:[/!]
       <span class="comment">[!java|scala]//[/!][!python]#[/!] do something</span>
    [!java|scala]}[/!]
pt: [!java]int[] tab = new int[10];[/!][!scala]var tab = new Array[Int] (10)[/!][!python]tab = [1, 3, 5, 7, 9][/!]
    [!java|scala]<span class="comment">// inicialização de valores omitida</span>
    [/!]if (has42First(tab))[!java|scala] {[/!][!python]:[/!]
       <span class="comment">[!java|scala]//[/!][!python]#[/!] faz algo</span>
    [!java|scala]}[/!]

note: type: Content of: <p>
en: If you want to allocate and initialize the array in one shoot, that's a bit more complicated as the compiler has to know the type of the parameter you are creating.  For that, use the following (ugly) construct:
pt: Se quer alocar e inicializar o array de uma vez só, é um pouco mais complicado pois o compilador terá que saber o tipo do parâmetro queestá a criar. Para isto, use a seguinte construção (feia):

note: type: Content of: <pre>
en: if (has42First(   new int[] {1, 3, 5, 7, 9}   ) {
       <span class="comment">// do something</span>
    }
pt: if (has42First(   new int[] {1, 3, 5, 7, 9}   ) {
       <span class="comment">// faz algo</span>
    }

note: type: Content of: <p>
en: Methods can also return [!java|scala]arrays[/!][!python]lists[/!] as result without any complication.  Here is a method that returns [!java|scala]an array[/!][!python]a list[/!] of the requested size, filled with 42s.
pt: Métodos também podem retornar [!java|scala]arrays[/!][!python]lists[/!] como resultado sem nenhuma complicação. Aqui está um método que retorna uma [!java|scala]array[/!][!python]list[/!] do tamanho pedido, preenchido com 42s.

note: type: Content of: <h3>
en: Goal of this exercise
pt: Objetivo deste exercício

note: type: Content of: <p>
en: At least! After this long explanation, we can come back to the exercise.
pt: Finalmente! Depois desta longa explicação, podemos voltar ao exercício.

note: type: Content of: <p>
en: Your mission is rather simple actually.  Your code should save the color pattern observed on the first row into [!java|scala]an array[/!][!python]a list[/!].  [!python]The easiest is to create an empty list, and then <code>append()</code> the colors one after the others as you read them (with <code>getGroundColor()</code>).[/!] [!java|scala]For that, you should declare and allocate an array of <code>Color</code>. Beware, there is several worlds, of differing size; use <code>getWorldHeight()</code> to retrieve the size of the current world.  Once the array allocated, fill it by reading the ground color in each locations (with <code>getGroundColor()</code>).[/!]
pt: A sua missão é bastante simples, na verdade. O seu código deve guardar o padrão de cores observado na primeira linha numa [!java|scala]array[/!][!python]list[/!].  [!python]O mais fácil é criar uma lista vazia e depois usar <code>append()</code>para adicionar as cores uma por uma à medida que for a ler elas (com <code>getGroundColor()</code>).[/!] [!java|scala]Para isto, deve declarar e alocar uma array de <code>Cor</code>. Mas atencção, existem vários mundos, de diferentes tamanhos; use <code>getWorldHeight()</code> para recuperar o tamanho do mundo atual. Uma que a array esteja alocada, preencha ela a ler a cor do chão em cada um dos pontos (com <code>getGroundColor()</code>).[/!]

note: type: Content of: <p>
en: Once you managed to read and save the pattern on the first row, you have to reapply the pattern on every rows, for example by executing <code>getWorldHeight()</code> times a method written specifically for this.
pt: Uma vez que conseguiu ler e gravar o padrão na primeira linha, tem que reaplicar o padrão nas outras linhas, por exemplo a executar <code>getWorldHeight()</code> vezes um método escrito especificamente para isto.

note: type: Content of: <h1>
en: [!java|scala]Arrays[/!][!python]Lists[/!], Knotting and Modulos
pt: [!java|scala]Arrays[/!][!python]Lists[/!], Nós e Módulos

note: type: Content of: <p>
en: This exercise is similar to the previous one: you have to reproduce the color pattern of the first cell into the other ones.
pt: Este exercício é similar ao anterior: tem que reproduzir o padrão de cores da primeira célula para as outras.

note: type: Content of: <p>
en: The first difference is that the world is bordered of walls: you thus have to slightly modify your trajectory to ensure that the buggle does not crash into a wall. The simpler for that is to handle the first cell out of the <code>for</code> loop and do only <code>getWorldHeight()-1</code> steps in the loop.
pt: A primeira diferença é que o mundo é cercado de muros: portanto tem que modificar levemente a sua trajetória para garantir que o buggle não bata num muro. O jeito mais simples é manipular a primeira célula fora do loop <code>for</code> e fazer apenas <code>getWorldHeight()-1</code> passos no loop.

note: type: Content of: <p>
en: The other difference is that the offset to apply between columns is not fixed, but written on the first cell of each column. To get the info as an integer, we can use:
pt: A outra diferença é que o deslocamento para aplicar entre as colunas não é fixo, mas está escrito na primeira célula de cada coluna. Para obter a informação como um inteiro, podemos usar:

note: type: Content of: <pre>
en: [!java]int offset = Integer.parseInt(readMessage())[/!][!python]offset = int( readMessage() )[/!][!scala]val offset = readMessage().toInt[/!]
pt: [!java]int deslocamento = Integer.parseInt(readMessage())[/!][!python]deslocamento = int( readMessage() )[/!][!scala]val deslocamento = readMessage().toInt[/!]

note: type: Content of: <p>
en: <code>readMessage()</code> gets the message on the ground as a [!java|scala]String[/!][!python]string[/!], while <code>[!java]Integer.parseInt(str)[/!][!scala]str.toInt[/!][!python]int(str)[/!]</code> transforms the string <code>str</code> into an integer by <i>reading</i> it.
pt: <code>readMessage()</code> obtém a mensagem no chão como uma [!java|scala]String[/!][!python]string[/!], enquanto <code>[!java]Integer.parseInt(str)[/!][!scala]str.toInt[/!][!python]int(str)[/!]</code> transforma a cadeia <code>str</code> num inteiro ao <i>ler</i> ela.

note: type: Content of: <p>
en: Then, to pick the right color, the easier is to use the <code>%</code> (modulo) operator. For example, <code>(i + 5) % size</code> allows to retrieve the <code>i</code>th cell of an array of size <code>size</code> with an offset of <code>5</code>.
pt: Então, para escolher a cor certa, o mais fácil é usar o operador <code>%</code> (operador módulo). Por exemplo, <code>(i + 5) % tam</code> serve para recuperar a <code>i</code>-ésima célula de uma array de tamanho <code>tam</code> com um deslocamento de <code>5</code>.

note: type: Content of: <p>
en: You're up.
pt: Agora é consigo.

note: type: Content of: <h1>
en: Searching for a given value
pt: Procurar por um dado valor

note: type: Content of: <p>
en: The goal of this exercise is to search the cell of a given value, and return its position.
pt: O objetivo deste exercício é procurar a célula de um dado valor e retornar a posição dela.

note: type: Content of: <p>
en: To that extend, you should fill the method <code>indexOf()</code>, which parameters are the array to explore, and the value to search. If the value <code>lookingFor</code> is not in the array <code>tab</code>, the method should return -1.
pt: Para isto, deve preencher o método <code>indexOf()</code>, cujos parâmetros são a array a ser explorada e o valor a ser procurado. Se o valor <code>lookingFor</code> não está na array <code>tab</code>, o método deve retornar -1.

note: type: Content of: <p>
en: The idea of the algorithm is to sweep over the whole array, checking the value of each cell. If it's the searched value, you should return the index of the cell currently checked.
pt: A ideia do algoritmo é varrer toda a array, a verificar o valor de cada célula. Se for o valor procurado, deve retornar o índice da célula que está a ser verificada.

note: type: Content of: <p>
en: Remember that indices begin at 0 and not at 1. So, if there is 3 cells, their indices will be 0, 1 and 2. There would not be any cell numbered 3.
pt: Lembre-se que os índices começam com 0 e não com 1. Logo, se houverem 3 células, os índices delas serão 0, 1 e 2. Não vai haver nenhuma célula numerada com 3.

note: type: Content of: <p>
en: Remember also that the amount of cells in an array can be retrieved using the <code>length</code> attribute. So, if your array is called <code>tab</code>, its size can be retrieved as <code>tab.length</code>.  Note that there is no () after <code>length</code>. An attribute is a sort of variable embedded in another object (here, the array).
pt: Lembre-se também que a quantidade de células numa array pode ser recuperada a usar o atributo <code>length</code>. Portanto, se a sua array é chamada <code>tab</code>, o tamanho dela será recuperado como <code>tab.length</code>. Observe que não existe um () depois de <code>length</code>. Um atributo é como uma variável dentro de outro objeto (no caso, a array).

note: type: Content of: <p>
en: So, the last value of an array is given by <code>tab[tab.length - 1]</code>.
pt: Logo, o último valor de uma array é dado por <code>tab[tab.length - 1]</code>.

note: type: Content of: <p>
en: Remember also that the amount of cells in an array can be retrieved with the <code>len()</code> function. So, if your array is called <code>tab</code>, its size can be retrieved as <code>len(tab)</code>.
pt: Lembre-se também que a quantidade de células numa array pode ser recuperada com a função <code>len()</code>. Logo, se a sua array é chamada <code>tab</code>, o tamanho dela pode ser recuperado como <code>len(tab)</code>.

note: type: Content of: <p>
en: So, the last value of an array is given by <code>tab[ len(tab) - 1]</code>.
pt: Logo, o último valor de uma array é dado por <code>tab[ len(tab) - 1]</code>.

note: type: Content of: <h1>
en: Index of the maximum value
pt: ìndice do valor máximo

note: type: Content of: <p>
en: In this exercise, you must compute the index of the tab cell containing the biggest value.
pt: Neste exercício, deve calcular o índice da célula da tab a conter o maior valor.

note: type: Content of: <p>
en: For that, fill the <code>indexOfMaximum()</code> method. Its parameter is the array to explore. Should the array contain the searched value several times, you should return the index of the first occurrence.
pt: Para isto, complete o método <code>indexOfMaximum()</code>. O parâmetro dele é a array para explorar. Caso a array contenha o valor procurado várias vezes, deve retornar o índice da primeira ocorrência.

note: type: Content of: <p>
en: To solve this exercise, you should sweep over the whole array. For each value, if it's bigger than the biggest value you saw so far, you must save this new champion and its position.  You will thus need 2 extra variables; the initial value of the champion could be the value of the first cell.
pt: Para resolver este exercício, deve varrer a array completamente. Para cada valor, se for maior que o maior até o momento, este passa a ser o novo maior e guarda o valor e a posição dele. Precisa de 2 variáveis adicionais; o valor inicial do maior pode ser o valor da primeira célula.

note: type: Content of: <h1>
en: Average value
pt: Valor médio

note: type: Content of: <p>
en: The objective of this exercise is to compute the average value of the integer values stored in an array.
pt: O objetivo deste exercício é calcular o valor médio dos valores inteiros armazenados numa array.

note: type: Content of: <p>
en: You have to fill the body of the method <code>average()</code> which takes as parameter the array of integers of which it computes and returns the average value. Please note that this method must return an integer.
pt: Tem que preencher o corpo do método <code>average()</code> que leva como parâmetro a array de inteiros da qual calcula e retorna o valor médio. Por favor note que este método deve retornar um inteiro.

note: type: Content of: <p>
en: To compute the average value of an integer, it is necessary to traverse the whole array and to compute the sum of all its values (so you will need a variable to store this temporary result), then you have to divide this sum by the size of the array.
pt: para calcular o valor médio de um inteiro, é necessário percorrer toda a array e calcular a soma de todos os valores (logo, precisa de uma variável para armazenar este valor temporário) e por fim dividir esta soma pelo tamanho da array.

note: type: Content of: <p>
en: In Java, you can get the size of an array <code>myarray</code> by consulting its <code>length</code> attribute (in other words, <code>myarray.length</code>). Notice that there is no parenthesis after <code>length</code>.
pt: Em Java, pode obter o tamanho de uma array <code>minhaarray</code> ao consultar o atributo <code>length</code> (tamanho) dele (em outras palavras, <code>minhaarray.length</code>). Observe que não existe parêntesis depois do <code>length</code>.

note: type: Content of: <p>
en: In python, retrieving the size of an array <code>myarray</code> is as easy as calling <code>len(myarray)</code>.
pt: Em python, recuperar o tamanho de uma array <code>minhaarray</code> é tão fácil como chamar <code>len(myarray)</code>.

note: type: Content of: <h1>
en: Maximal value
pt: Valor maximal

note: type: Content of: <p>
en: In this exercise, you must compute the maximal value contained in an array.  For that, fill the <code>maximum()</code> method, which parameter is the array to explore.
pt: Neste exercício, deve calcular o valor maximal contido numa array. Para isto, preencha o método <code>maximum()</code>, cujo parâmetro é a array para explorar.

note: type: Content of: <p>
en: To compute this value, sweep over the whole parameter. For each value, if it's bigger than the biggest value you saw so far, you must save this value somewhere to remember it afterward. You thus need an extra variable, which can be initialized to the value of the first array cell.
pt: Para calcular este valor, percorra o parâmetro todo. Para cada valor, se for maior que o maior valor até o momento, deve gravar este valor em algum lugar para lembrar dele mais tarde. Vai precisar então de uma variável adicional, que pode ser iniciada para o valor da primeira célula do array.

note: type: Content of: <h1>
en: Occurrence of a value
pt: Ocorrência de um valor

note: type: Content of: <p>
en: In this exercise, you must compute the amount of occurrences of a given value in an array (that is, the amount of time that this value appears in the array). For that, fill the <code>occurrences()</code> method, which returns the number of occurrence of <code>lookingFor</code> in <code>tab</code>.
pt: Neste exercício, deve calcular a quantidade de ocorrências de um dado valor numa array (ou seja, a quantidade de tempo que este valor aparece na array). Para isto, preencha o método <code>occurrences()</code>, que retorna a quantidade de ocorrências de <code>lookingFor</code> em <code>tab</code>.

note: type: Content of: <p>
en: To compute this value, simply sweep over the array counting for the amount of cells containing the searched value. You thus need an extra variable for that.
pt: Para calcular este valor, simplesmente percorra a array a contar a quantidade de células a conter o valor procurado. Vai precisar de uma variável adicional para isso.

note: type: Content of: <h1>
en: Maxima and Minima
pt: Máximo e Mínimo

note: type: Content of: outside any tag (error?)
en: In this exercise, you must return the difference between the maxima (i.e., the largest value of the array) and the minima (i.e., its smallest value). The returned value is then a positive number.  Beware, you can only do one traversal of the array to gather all informations that you need.
pt: Neste exercício, deve retornar a diferença entre o máximo (p.ex., o maior valor da array) e o mínimo (p.ex., o menor valor). O valor retornado é então um número positivo. Mas atenção, só pode percorrer o array uma vez para obter todas as informações de que necessita.

note: type: Content of: <h1>
en: Second Biggest Value
pt: Segundo Maior Valor

note: type: Content of: <p>
en: In this exercise, you must compute the second maximal value contained in an array, i.e. the value that becomes the maximum if you remove every instance of the current maximum from the array.
pt: Neste exercício, deve calcular o segundo valor maximal contido numa array, ou seja o valor que se torna máximo se remover cada instância do máximo atual da array.

note: type: Content of: <p>
en: As usual, you should gather the information in only one traversal of the array.  You can assume that the second biggest value actual exists (there is at least two distinct values in the array), and that all values in the array are greater than [!python] -100000000.[/!] [!java|scala]<code>Integer.MIN_VALUE</code> (which is the smallest representable integer existing in [!thelang]).[/!]
pt: Como normalmente, deve obter informações em apenas uma passagem pela array. Pode assumir que o segundo maior valor "actual" existe (existe pelo menos dois valores distintos na array) e que todos os valores na array são maiores que [!python] -100000000.[/!] [!java|scala]<code>Integer.MIN_VALUE</code> (que é o menor inteiro representável que existe em [!thelang]).[/!]

note: type: Content of: outside any tag (error?)
en: Given an array of integers, return true if .. 1, 2, 3, .. appears in the array somewhere.
pt: Dada uma array de inteiros, retorna true se .. 1, 2, 3, .. aparece em algum lugar da array.

note: type: Content of: <p>
en: This exercise was converted to PLM from the excellent exercising site http://codingbat.com/
pt: Este exercício foi convertido para o PLM do excelente sítio de exercícios http://codingbat.com/

note: type: Content of: outside any tag (error?)
en: Given an array of integers, return the number of times that two 6's are next to each other in the array. Also count instances where the second "6" is actually a 7.
pt: Dada uma array de inteiros, retorna a quantidade de vezes no qual dois 6 estão vizinhos na array. Também conta as instâncias onde o segundo "6" é, na verdade um 7.

note: type: Content of: outside any tag (error?)
en: Given an array of integers, return the number of 9's in the array.
pt: Dada uma array de inteiros, retorna a quantidade de 9's na array.

note: type: Content of: outside any tag (error?)
en: Given an array of integers, return true if one of the first 4 elements in the array is a 9. The array length may be less than 4.
pt: Dada uma array de inteiros, retorna true se um dos primeiros 4 elementos na array é um 9. O comprimento da array pode ser menor que 4.

note: type: Content of: <h1>
en: NoTriples
pt: NenhumaTripla

note: type: Content of: outside any tag (error?)
en: Given an array of integers, we'll say that a triple is a value appearing 3 times in a row in the array. Return true if the array does not contain any triples.
pt: Dada uma array de inteiros, digamos que uma tripla é um valor que aparece 3 vezes seguidas na array. Retorne true se a array não contém nenhuma tripla.

note: type: Content of: <p>
en: Given an array of integers, return true if it contains a 2, 7, 1 pattern -- a value, followed by the value plus 5, followed by the initial value minus 1.  So, 2,7,1 is such a pattern because 7 is 5+2 and 1 is 2-1. 3,8,2 is also such a pattern.
pt: Dada uma array de inteiros, retorne true se ela contém um padrão 2, 7, 1 -- um valor, seguido dele mais 5, seguinte dele menos 1. Então, 2,7,1 é um exemplo deste padrão pois  7 é 5+2 e 1 é 2-1. 3,8,2 é outro exemplo.

note: type: Content of: <p>
en: Additionally the 271 counts even if the "1" differs by 2 or less from the correct value.
pt: Acicionalmente, o 271 "counts even" se o "1" difere por 2 ou menos do valor correto.

note: type: Content of: <h1>
en: Golomb sequence
pt: sequência de Golomb

note: type: Content of: outside any tag (error?)
en: The Golomb sequence is a non-decreasing integer sequence where a(n) is the number of times that n occurs in the sequence, with a(1) = 1.
pt: A sequência de Golomb é uma sequência de inteiros não decrescente onde a(n) é a quantidade de vezes que n ocorre na sequência, com a(1) = 1.

note: type: Content of: <p>
en: Since a(1)=1, it means that 1 occurs only once in the sequence, so a(2) must be different. Since the sequence is non-decreasing, a(2)  must be greater than 1. Since a(2)>1, the digit 2 must appear more than one time in the sequence. So a(2)=2.
pt: Como a(1)=1, significa que 1 ocorre apenas uma vez na sequência, então a(2) deve ser diferente. Uma vez que a sequência é não-decrescente, a(2) deve ser maior que 1. Como a(2)>1, o dígito 2 deve aparecer mais de uma vez na sequência. Logo, a(2)=2.

note: type: Content of: <p>
en: Since a(2)=2, there is two 2 in the sequence, so we know the value of a(3). And so on for the other values of the sequence.
pt: Como a(2)=2, existem duas ocorrências de 2 na sequência, logo sabemos o valor de a(3). E assim por diante para os outros valores da sequência.

note: type: Content of: <p>
en: Write a function that computes the Nth element of the sequence.
pt: Escreva uma função que calcule o N-ésimo elemento da sequência.

note: type: Content of: <h1>
en: Buggles' Island
pt: Ilha dos Buggles

note: type: Content of: outside any tag (error?)
en: You just received the traveling notes of your old aunt who traveled accross the country of the Buggles' Islands. She wrote down the altitude every kilometer during her trip, resulting in a sequence of numbers as follows.
pt: Acaba de receber as anotações de viagem da sua tia velha que atravessou o país das Ilhas dos Buggles. Ela escreveu a altitude a cada quilômetro durante a viagem, a resultar numa sequência de números como segue.

note: type: Content of: <p>
en: Here is a cut of the islands on that path:
pt: Aqui está um corte das ilhas por este caminho:

note: type: Content of: <pre>
en:        /***\       /*\         &lt;-- 2 meters above the see level
       /***********\ /*******\     &lt;-- 1 meter above the see level
    ***************************    &lt;-- see level
    | | | | | | | | | | | | | |
    0 0 1 1 2 2 1 1 0 1 2 1 1 0    &lt;-- altitude on each point
pt:        /***\       /*\         &lt;-- 2 metros acima do nível do mar
       /***********\ /*******\     &lt;-- 1 metro acima do nível do mar
    ***************************    &lt;-- nível do mar
    | | | | | | | | | | | | | |
    0 0 1 1 2 2 1 1 0 1 2 1 1 0    &lt;-- altitude em cada ponto

note: type: Content of: <p>
en: This example is constituted of four levels of island:
pt: Este exemplo é constituído de quatro níveis de ilhas:

note: type: Content of: <ul><li>
en: 1 1 2 2 1 1 (the island on the left)
pt: 1 1 2 2 1 1 (a ilha da esquerda)

note: type: Content of: <ul><li>
en: 2 2 (the mountain topping the left island)
pt: 2 2 (o topo da montanha da ilha da esquerda)

note: type: Content of: <ul><li>
en: 1 2 1 1 (the right island)
pt: 1 2 1 1 (a ilha da direita)

note: type: Content of: <ul><li>
en: 2 (the mountain on the right)
pt: 2 (a montanha da direita)

note: type: Content of: <p>
en: This can also be visualized this way:
pt: Isto também pode ser visualizado desta forma:

note: type: Content of: <p>
en: Could you write a little program to compute the amount of levels in a given sequence of altitudes? Actually, there is an iterative and a recursive solution to that problem.
pt: Poderia escrever um pequeno programa que calculasse a quantidade de níveis numa dada sequência de altitudes? Na verdade, existem uma solução iterativa e uma recursiva para este problema.

note: type: Content of: <p>
en: We will now write our own methods. It somehow comes down to extending the buggle vocabulary by teaching it new tricks.
pt: Vamos agora escrever nossos próprios métodos. Isto é como extender o vocabulário do buggle a ensinar novos truques.

note: type: Content of: <p>
en: For example, we saw in a previous exercise how to ask the buggle to go get the baggle in front of it, and bring it back. If there is several baggles on the board, and if we want to bring all of them on the bottom line, you have to repeat this code several times, or include it in a loop. In any case, you should avoid to duplicate your code to keep it pleasant to read and easily understandable.  It would be better if the buggle could obey an <code>goAndGet()</code> order just like it understands a <code>[!c]stepForward()[/!][!scala|java|python]forward()[/!]</code> one.
pt: Por exemplo, vimos num exercício anterior como pedir ao buggle para apanhar o baggle à frente dele e trazê-lo de volta. Se existem vários baggles no tabuleiro e se queremos trazê-los todos à linha de baixo, tem que repetir este código várias vezes, ou incluí-lo num loop. Em qualquer caso, deve evitar duplicar o seu código para mantê-lo agradável de ler e fácil de entender. Será melhor se o buggle puder obedecer uma ordem <code>goAndGet()()</code> assim como entende uma <code>[!c]stepForward()[/!][!scala|java|python]forward()[/!]</code>.

note: type: Content of: <h3>
en: Defining methods
pt: Definir métodos

note: type: Content of: <p>
en: The [!thelang] syntax to write a simple method called <code>goAndGet</code> is the following:
pt: A sintaxe de [!thelang] para escrever um método simples chamado <code>goAndGet()</code> é a seguinte:

note: type: Content of: <pre>
en: [!java|c]void goAndGet() {[/!][!python]def goAndGet():[/!][!scala]def goAndGet() {[/!]
      actions()[!java|c];[/!]
      to()[!java|c];[/!]
      do()[!java|c];[/!]
    [!java|scala|c]}[/!]
pt: [!java|c]void goAndGet()() {[/!][!python]def goAndGet()():[/!][!scala]def goAndGet()() {[/!]
      ações()[!java|c];[/!]
      ações()[!java|c];[/!]
      eMaisAções()[!java|c];[/!]
    [!java|scala|c]}[/!]

note: type: Content of: <p>
en: The method body [!java|scala|c](between curly braces)[/!][!python](the indented block)[/!] will be executed when we call the method later on (that is, when we write <code>goAndGet()</code> somewhere in our code). This method body can contain as many instructions as you want, and any construction we saw so far (for, while, if, etc).  [!java|c]The <code>void</code> keyword means that this method does not return any result. For example, the <code>isOverBaggle()</code> method does return a result, which is a [!c]int[/!][!java]boolean[/!] indicating whether or not the buggle is located over a baggle. We will soon learn to define such methods too. For now, just write <code>void</code> at this location.[/!]
pt: O corpo do método [!java|scala](entre chaves)[/!][!python](o bloco indentado)[/!] será executado quando chamarmos o método mais tarde (ou seja, quando escrevermos <code>goAndGet()()</code> em algum lugar do código). Este corpo do método pode conter tantas instruções quantas quiser e as construções que quisermos (for, while, if, etc).  [!java]A palavra-chave <code>void</code> significa que este método não retorna qualquer resultado. Por exemplo, o método <code>isOverBaggle()</code> retorna um resultado, que é um booleano a indicar se o buggle está ou não localizado sobre um baggle. Vamos em breve aprender a definir tais métodos também. Por agora, apenas escreva <code>void</code> neste local.[/!]

note: type: Content of: <h3>
en: Documenting methods
pt: Documentar métodos

note: type: Content of: <p>
en: You should strive to document your code to keep it readable. When you write it, its purpose and limitations are clear to you, but most of the time, this does not last for long. You will soon forget about the details of every specific method, and this day you will be happy to read its documentation. In the following example, we use the specific formalism of [!java]javadoc[/!][!scala]scaladoc[/!][!python]pydoc[/!], a program that extracts the documentation of [!thelang] source code to produce html pages. The main advantage is that it allows to keep the documentation near to the code.  So, when you change your code, you have less chances to forget to update the documentation.
pt: Deve esforçar-se para documentar o seu código para mantê-lo legível. Quando escreve código, fica claro o objetivo e as limitações, mas na maioria das vezes, isto é esquecido. Rapidamente esquecerá dos detalhes de cada método específico e vai chegar o dia em que ficará feliz em ler a documentação. No exemplo seguinte, usamos o formalismo específico de [!java]javadoc[/!][!scala]scaladoc[/!][!python]pydoc[/!], um programa que extrai a documentação do código-fonte de [!thelang] e produz páginas html. A principal vantagem é que permite que a documentação fique junto ao código. Então, quando mudar o código, tem menos chances de esquecer de atualizar a documentação.

note: type: Content of: <p>
en: [!java|scala][!java]javadoc[/!][!scala]scaladoc[/!] comments begin with the <code>/**</code> marker (with two asterisks). They must be placed right before the method they document for the tool to find them.[/!] [!python]pydoc comments should be placed at the beginning of the method body so that the tool finds them. They should be placed between <code>"""</code>, which mark multi-line strings in python.[/!] The first line should be a brief description of what this method does while any subsequent lines should provide any important details about the method.
pt: comentários em [!java|scala][!java]javadoc[/!][!scala]scaladoc[/!] começam com a marca <code>/**</code> (com dois asteriscos). Eles devem ser postos exatamente antes do método que documentam para a ferramenta encontrá-los.[/!] [!python]comentários pydoc devem ser postos no começo do corpo do método de forma que a ferramenta possa encontrá-los. Eles devem ser postos entre <code>"""</code>, que marcam cadeias multilinhas em python.[/!] A primeira linha deve ser uma breve descrição do que o método faz enquanto as linhas subsequentes devem fornecer qualquer detalhes importantes sobre o método.

note: type: Content of: <pre>
en: [!java|scala]/**
     *  Go, retrieves the baggle in front of the buggle, and brings it back 
     *
     *   Does not check for walls, so be careful to not call it when walls are present.
     */[/!]
    [!java]void goAndGet() {[/!]
    [!scala]def goAndGet() {[/!]
    [!python]def goAndGet():
      """Go, retrieves the baggle in front of the buggle, and brings it back.
    
      Does not check for walls, so be careful to not call it when walls are present."""[/!]
      actions()[!java];[/!]
      to()[!java];[/!]
      do()[!java];[/!]
    [!java|scala]}[/!]
pt: [!java|scala]/**
     *  Força, recupera o baggle em frente do buggle e traz de volta 
     *
     *  Não verifica se tem paredes, então cuidado para não chamá-lo quando paredes estiverem presentes.
     */[/!]
    [!java]void goAndGet()() {[/!]
    [!scala]def goAndGet()() {[/!]
    [!python]def goAndGet()():
      """Vai, recupera o baggle em frente do buggle e traz de volta.
    
      Não verifica se tem paredes, então cuidado para não o chamar quando uma parede estiver presente."""[/!]
      ações()[!java];[/!]
      to()[!java];[/!]
      do()[!java];[/!]
    [!java|scala]}[/!]

note: type: Content of: <h3>
en: Naming conventions
pt: Convenções de nomes

note: type: Content of: <p>
en: Most programming language forbid the use of spaces in method and variable identifiers (=their names).  Accented letters are sometimes allowed (as in [!thelang]), but they can lead to portability issues between operating systems and should thus be avoided when possible.
pt: A maioria das linguagens de programação proíbe o uso de espaços em indentificadores de métodos e variáveis (=seus nomes).  Letras acentuadas são algumas vezes permitidas (como em [!thelang]), mas elas geram problemas de portabilidade entre sistemas operacionais e devem ser evitadas sempre que possível.

note: type: Content of: <p>
en: Across all programming languages, there is two main conventions to name variables and methods. The first one, consists in concatenating all words with only the first letter of each word in upper case. "go and get" becomes goAndGet().  It is called CamelCase because identifiers written this way graphically remind of a camel back. The other convention, called snake_case, is to write every words in lower case, separated with underscores symbols (_). "go and get" becomes go_and_get().
pt: Entre todas as linguagens de programação, existem duas convenções para nomear variáveis e métodos. A primeira, consiste em concatenar todas as palavras com apenas a primeria letra de cada palavra em maiúscula. "vai e apanha" torna-se goAndGet(). Isto é chamado "CamelCase" por que identificadores escritos desta forma parecem graficamente com as costas de um camelo. A outra convenção, chamada "snake_case", é escrever todas as palavras em minúsculas, separadas com sublinhados (_). "vai e apanha" se torna vai_e_apanha().

note: type: Content of: <p>
en: Which convention to use is the topic of heated discussion across developers, but each programming language has its own habits. In Python, Perl and the C language, the snake_case is often used for methods and variables. Java and Scala prefer the lowerCamelCase (the very first letter is lower case) for that.
pt: Que convenção usar é o tópico de discussões acaloradas entre programadores, mas cada linguagem de programação tem os próprios hábitos deles. Em Python, Perl e C, o snake_case é normalmente usado para métodos e variáveis. Java e Scala preferemo lowerCamelCase (só a primeira letra inicial é minúscula) para isto.

note: type: Content of: <p>
en: The CamelCase convention is used everywhere in PLM because this program is written in Java itself, so we kept our habits when adding new languages. But the fact that the Python bindings of PLM use the CamelCase instead of the snake_case is considered as a bug that we will fix in further releases.
pt: A convenção CamelCase é sempre usada no PLM por que este programa foi escrito em Java, então mantivemos o hábito quando inserimos novas linguagens. Mas o fato de os vínculos Python do PLM usarem CamelCase e não snake_case é considerado um bug que será corrigido em algum lançamento futuro.

note: type: Content of: <p>
en: The goal of this exercise is to write a method called <code>goAndGet()</code> which does the same than in a previous exercises (move forward until over a baggle, pick it up, move back to initial position, drop baggle).
pt: O objetivo deste exercício é escrever um método chamado <code>goAndGet()()</code> que faça a mesma coisa que foi feita num exercício anterior (vai para a frente até estar sobre um baggle, apanha-o, vai para trás até a posição inicial e solta o baggle).

note: type: Content of: <p>
en: This exercise is a bit different because you will not write all of the code executed by the buggle. Instead, you should only write one method that get called automagically added when you click on <b>Start</b>. Your buggle calls your <code>goAndGet()</code> method on each row, until the baggle is found. [!python|scala]The code for that is already provided under the <code>goAndGet()</code> method, but you probably don't want to change it.[/!] [!java]You don't need to write the code calling <code>goAndGet()</code> yourself. It's automagically there already, even if you cannot see it.[/!]
pt: Este exercício é um pouco diferente por que não vai precisar escrever todo o código executado pelo buggle. Ao invés disto, deve apenas escrever um método que será chamado automagicamente quando clica em <b>Iniciar</b>. O seu buggle vai chamar o seu método <code>goAndGet()()</code> em cada linha, até que o baggle seja encontrado. [!python|scala]O código para isto já está pronto no método <code>goAndGet()()</code>, mas provavelmente não vai mudar isto. [/!] [!java]Não precisa escrever o código chamado <code>goAndGet()()</code>. Já está lá automaticamente, mesmo se não possa vê-lo.[/!]

note: type: Content of: <p>
en: But for that to work, you have to actually write this <code>goAndGet()</code> method now.
pt: Mas para isto funcionar, tem na verdade que escrever este método <code>goAndGet()</code> agora.

note: type: Content of: outside any tag (error?)
en: We now would like to teach the buggle to build a doghouse. The naive approach consists in directly writing the needed code as follows.  This works because the buggle of this exercise leaves a red path as it moves.
pt: Agora queremos ensinar ao buggle como construir uma casa de cachorro. A abordagem simplória consiste em escrever diretamente o código necessário como segue. Isto funciona por que o buggle deste exercício deixa um caminho vermelho à medida em que anda.

note: type: Content of: <p>
en: It becomes harder when we want to draw two doghouses: we have to rewrite the same code twice, which is not really handy. When the code becomes a bit long as this one, it becomes easier to see why we insist since a while on the pure evilness that code duplication represents. Indeed, if you realize that an error sneaked into a code that you copied at several locations, you will have to fix it several times. And mind your back if you forget one of these locations.
pt: Vai ficar mais difícil se tivermos que desenhar duas casas de cachorro: teremos que reescrever o mesmo código duas vezes, o que não é muito prático. Quando o código se torna um pouco longo como este, torna-se fácil ver por que insistimos já tem um tempinho namais pura maldade que duplicação de código representa. Na verdade, imagine um erro que se infiltrou no código que copiou para vários lugares, vai ter que corrigir várias vezes. E ai de se esquercer de corrigir num destes lugares.

note: type: Content of: <p>
en: There is even a name to this good principle in programming: DRY/SPOT, which means "Don't Repeat Yourself / Single Point Of Truth". The latter part means that each information must be written in only one location of your program to avoid the differing locations to get out of synch when you modify your code.
pt: Existe até um nome para esta boa prática de programação: DRY/SPOT, que em inglês significa "Don't Repeat Yourself / Single Point Of Truth" (não se repita/ponto único de confiança). A última parte significa que cada informação deve ser escrita em apenas um local do seu programa para evitar que diferentes locais fiquem desincronizados quando modificar o código.

note: type: Content of: <p>
en: So, let's apply this good principle and <b>factorize our code</b>, ie to write it only once, for example in a method. You should even to go further by factorizing the method body with a <code>for</code> loop, as seen previously.  If you do it correctly (what you should), you can use the method <code>left()</code> only once.
pt: Portanto, vamos aplicar este bom princípio de programação e <b>fatorizar o nosso código</b>, p.ex. escrevê-lo apenas uma vez, por exemplo num método. Pode ir até mais longe a fatorizar o corpo do método com um loop <code>for</code>, como visto anteriormente. Se o faz corretamente (o que se espera), dá para usar o método <code>left()</code> apenas uma vez.

note: type: Content of: <p>
en: The goal of this exercise is to write a method called <code>dogHouse</code> achieving the same result than the code above, but with a for loop to keep it short.  The buggle will call your creation to create several dog houses around its world.
pt: O objetivo deste exercício é escrever um método chamado <code>casaDeCachorro</code> que faz a mesma coisa que o código acima, mas com um loop for para mantê-lo curto. O buggle vai chamar a sua criação para construir várias casas de cachorro neste mundo.

note: type: Content of: outside any tag (error?)
en: In this exercise, we will reproduce the geometric drawing that you can see in the "Objective" tab.
pt: Neste exercício, vamos reproduzir o desenho geométrico que pode ver na guia "Objetivo".

note: type: Content of: <p>
en: Your goal (here and in any well written program) is to write the simplest possible code. For that, you have to decompose your work in sub-steps, and write a specific method for each sub-step.
pt: O seu objetivo (aqui e em qualquer programa bem escrito) é escrever o código mais simples possível. Para isto, tem que decompor o seu trabalho em sub-passos e escrever métodos específicos para cada sub-passo.

note: type: Content of: <p>
en: If you observe carefully the picture to draw, it is constituted of four parts depicting a sort of V. A possible decomposition is to write a method in charge of drawing a V from the current position. Its prototype can be: <code>[!java|c]void [/!]makeV()</code>
pt: Se observar cuidadosamente a figura que tem que desenhar, ela é constituída de quatro partes a descrever um V. Uma decomposição possível é escrever um método responsável por escrever um V a partir da posição atual. O protótipo dele pode ser: <code>[!java|c]void [/!]makeV()</code>

note: type: Content of: <p>
en: In this method, you should use the methods <code>brushUp()</code> and <code>brushDown()</code> to mark the ground (you may want to factorize this in another method). It may be wise to write the <code>makeV()</code> so that it places directly the buggle in position for the next V.
pt: Neste método, deve usar os métodos <code>brushUp()</code> e <code>brushDown()</code> para marcar o chão (se quiser, faça um método só para isto). É uma decisão inteligente escrever <code>makeV()</code> para pôr o buggle diretamente em posição ao próximo V.

note: type: Content of: <p>
en: Your turn. Your code should not be longer than 4 lines (not counting <code>makeV</code>)...
pt: É a sua vez. O seu código não deve ser maior que 4 linhas (sem contar <code>fazerV</code>)...

note: type: Content of: outside any tag (error?)
en: We will now reproduce an even bigger geometrical drawing. Once again, you can see the model by clicking on the "Objective" tab.
pt: Vamos agora reproduzir um desenho geométrico ainda maior. Novamente,pode ver o modelo a clicar na guia "Objetivo".

note: type: Content of: <p>
en: You can naturally reuse all the code you typed in previous exercise (select the other exercise, do Ctrl-C, come back to the code of this exercise, do Ctrl-V).
pt: Pode naturalmente reutilizar todo o código que digitou em exercícios anteriores (selecione o outro exercício, faça Ctrl-C, volte para o código deste exercício e faça Ctrl-V).

note: type: Content of: <p>
en: But you want to keep your code as simple as possible. For that, define new methods to deal simply with the repetitions in the pattern. For example, a method <code>makePattern()</code> achieving the pattern of previous example seems to be a good idea (but this may not be enough).
pt: Mas quer manter o seu código tão simples quanto possível. Para isto, defina novos métodos para lidar simplesmente com as repetições no padrão. Por exemplo, um método <code>makePattern()</code> a fazer o padrão do exemplo anterior parece ser uma boa ideia (mas pode não ser o suficiente).

note: type: Content of: <p>
en: Why don't you give it a shot? The main code method shouldn't take more than 2 lines (included in a for loop)
pt: Por que não tentar? O método do código principal não deve levar mais de 2 linhas (incluindo o loop for)

note: type: Content of: outside any tag (error?)
en: As you can imagine, you have to reproduce the geometric drawing depicted in the "Objectives" tab. As you can see, it is even bigger than the previous one.
pt: Como pode imaginar, vai ter que reproduzir o desenho geométrico descrito na guia "Objetivos". Como pode ver, é até maior do que o anterior.

note: type: Content of: <p>
en: You thus have to declare even more methods to use the repetitions of the pattern and factorize your code.  Your turn...
pt: Portanto tem que declarar até mais métodos para usar as repetições do padrão e fatorar o seu código. É a sua vez...

note: type: Content of: <h1>
en: Functions
pt: Funções

note: type: Content of: <p>
en: Quite often, you want to write a method that compute some value and returns it. Methods returning results are called <b>functions</b>.  Writing a function is not really harder than writing a simple method.  [!java|c]You simply have to specify the data type of expected results before the function name (where we previously had <code>void</code>).[/!] [!scala]You simply have to add a colon (:) after the parenthesis and write the type of data that your function will return, and add an equal sign (=). This syntax is actually rather close to defining a variable, with its type, that is actually a function.[/!] You can use the <code>return</code> instruction anywhere in your function body to specify that the computation is done (the function is not further executed), and that the result is the value following the <code>return</code> keyword.
pt: Frequentemente, vai escrever um método que calcula algum valor e o retorna. Métodos a retornar resultados são chamados <b>funções</b>. Escrever uma função não é realmente mais difícil do que escrever um simples método.  [!java|c]Simplesmente tem que especificar o tipo de dados do resultado esperado entes do nome da função (onde previamente tínhamos <code>void</code>).[/!] [!scala]Simplesmente tem que adicionar um dois-pontos (:) depois do parêntesis e escrever o tipo de dados que a função dele vai retornar e adicionar um símbolo de igualdade (=). Esta sintaxe é na verdade mais próxima de definir uma variável, com o tipo dela, do que na verdade escrever uma função.[/!] Pode usar a instrução <code>return</code> em qualquer lugar do corpo da sua função para especificar que o cálculo foi feito (a função não continuará a ser executada) e que o resultado é o valor que acompanha a palavra-chave <code>return</code>.

note: type: Content of: <p>
en: Actually, you can also use that <code>return</code> keyword in methods that do not return any result, to interupt the computation. Of course, you should not provide any value to return in that case.
pt: Na verdade, também pode usar a palavra-chave <code>return</code> em métodos que não retornam qualquer resultado, para interromper o cálculo. Obviamente que nestes casos não passa nenhum valor para retornar.

note: type: Content of: <p>
en: It is possible to have several <code>return</code> instructions in several branches of a conditional. In fact, it is forbidden to have any execution path of your body without any <code>return</code>, or to write some code after the <code>return</code> instruction. Indeed, if the machine reaches the end of the function without finding any <code>return</code>, it cannot know what actual value to give back to the function caller.  Moreover, <code>return</code> interrupts immediately the function execution (why bother looking further when you know the function result?). So, if there is some code after a <code>return</code>, it must be an error and the compiler warns you.
pt: É possível ter várias instruções <code>return</code> em várias ramificações de um condicional. De fato, é proibido ter um caminho de execução no corpo da função sem nenhum <code>return</code>, ou escrever algum código depois da instrução <code>return</code>. Na verdade, se a máquina alcança o fim da função sem encontrar qualquer <code>return</code>, ela não sabe o real valor que deve retornar a quem chamou a função. Além disto, o <code>return</code> interrompe imediatamente a execução da função (por que se preocupar a olhar além quando sabe o resultado da função?). Então, se existe algum código depois de um <code>return</code>, deve ser um erro e o compilador irá te alertar disto.

note: type: Content of: <pre>
en: [!java|scala|c][!java]boolean [/!][!c]int [/!][!scala]def [/!]isFrontFree()[!scala]:Boolean =[/!] {
        if (isFacingWall() == [!java|scala]true[/!][!c]1[/!]) {
            return [!java|scala]false[/!][!c]0[/!];
            <span class="comment">/* no code allowed here */</span>
        } else {
            return [!java|scala]true[/!][!c]1[/!];
            <span class="comment">/* here neither */</span>
        }
        <span class="comment">/* even here, forget it */</span>
    }[/!][!python]def isFrontFree():
        if isFacingWall() == True:
            return False
            <span class="comment"># no code allowed here</span>
        else
            return True
            <span class="comment"># here neither</span>
    <span class="comment"># even here, forget it</span>[/!]
pt: [!java|scala|c][!java]boolean [/!][!c]int [/!][!scala]def [/!]isFrontFree()[!scala]:Boolean =[/!] {
        if (isFacingWall() == [!java|scala]true[/!][!c]1[/!]) {
            return [!java|scala]false[/!][!c]0[/!];
            <span class="comment">/* proibido pôr código aqui */</span>
        } else {
            return [!java|scala]true[/!][!c]1[/!];
            <span class="comment">/* nem aqui */</span>
        }
        <span class="comment">/* e nem mesmo aqui. desista */</span>
    }[/!][!python]def livreEmFrente():
        if isFacingWall() == True:
            return False
            <span class="comment"># proibido pôr código aqui</span>
        else
            return True
            <span class="comment"># nem aqui</span>
    <span class="comment"># e nem mesmo aqui, desista</span>[/!]

note: type: Content of: outside any tag (error?)
en: You will once again write a function that the buggle will use. Its name must be <code>haveBaggle</code>, and it returns a boolean value indicating whether the row in front of the buggle contains a baggle or not. The buggle will use it to search the first row containing a baggle, and stop here.
pt: Vai mais uma vez escrever uma função que o buggle vai usar. O nome dela deve ser <code>temBaggle</code> e retorna um valor booleano a indicar se a linha na frente do buggle contém um baggle ou não. O buggle vai usar isto para buscar a primeira linha a conter um baggle e parar nela.

note: type: Content of: <p>
en: The easier for this function is to use a boolean variable called <code>seenBaggle</code> indicating whether or not we saw a baggle so far. Its initial value is '[!python]False[/!][!scala|java]false[/!][!c]0[/!]'.
pt: A forma fácil de fazer esta função é usar uma variável booleana chamada <code>baggleAvistado</code> a indicar se vimos ou não um baggle até o momento. O valor inicial é '[!python]False[/!][!scala|java]false[/!][!c]0[/!]'.

note: type: Content of: <p>
en: Then, move 6 steps forward (the world contains 7 cells and we already are on one of them). For each cell, if it contains a baggle, we store true in <code>sawBaggle</code> (and we don't do anything but moving forward if not).
pt: Então mova 6 passos para frente (o mundo contém 7 células e já estamos numa delas). Para cada célula, se ela contiver um baggle, vamos guardar true em <code>baggleVisto</code> (e se não, vamos simplesmente andar para frente).

note: type: Content of: <p>
en: At the end, we move back by 6 steps, and we return the value of <code>seenBaggle</code> to the caller.
pt: No final, vamos nos mover 6 passos para trás e retornar o valor de <code>baggleVisto</code> para quem chamou o método.

note: type: Content of: <p>
en: Note that the used buggle provides some hidden code that will call your <code>haveBaggle</code> function on each column, moving automatically between columns. It is thus very important that your <code>haveBaggle</code> function have no side effect: the position (and orientation) at the end of your code must be the one observed at the beginning of this code. It will move in between to seek for the baggle, but come back to the column start.
pt: Observe que o buggle usado fornece código oculto que irá chamar a sua função <code>haveBaggle</code> em cada coluna, movendo automaticamente entre colunas. Portanto, é muito importante que a sua função <code>haveBaggle</code> não tenha nenhum efeito colateral: a posição (e orientação) no final do seu código deve ser a observada no início deste código. Ela moverá entre elas para buscar a baggle, mas volta para o início da coluna.

note: type: Content of: <p>
en: Also, this exercise is a bit different since there is two initial worlds, each with a specific objective. Your code must work for each of them. Observe that the world selection scrolling menu (right below the speed slider)  allows to switch the observed world.
pt: Além disso, este exercício é um pouco diferente, pois existem dois mundos iniciais, cada um com um objetivo específico. O seu código deve funcionar para cada um deles. Observe que o menu de rolagem de seleção de mundos (logo abaixo do controle deslizante de velocidade) permite mudar o mundo observado.

note: type: Content of: <p>
en: When your function <code>haveBaggle</code> works, proceed to next exercise.
pt: Quando a sua função <code>temBaggle</code> funcionar, siga ao próximo exercício.

note: type: Content of: <p>
en: Don't you get tired of writing again and again the code to move by a fixed amount of steps? On the other hand, writing <tt>forward2()</tt>, <tt>forward3()</tt>, <tt>forward4()</tt>, as well as <tt>backward2()</tt>, <tt>backward3()</tt>, <tt>backward4()</tt>, and so on does not really help, to say the less.
pt: Não está cansado de escrever o mesmo código várias vezes para se mover uma certa quantidade de passos? Por outro lado, escrever <tt>forward2()</tt>, <tt>forward3()</tt>, <tt>forward4()</tt>, assim como <tt>backward2()</tt>, <tt>backward3()</tt>, <tt>backward4()</tt> e etc também não ajudam, para dizer o mínimo.

note: type: Content of: <p>
en: Luckily, it is possible to pass <b>parameters</b> to your methods. You have to specify their type and name between the parenthesis after the method name. Then, you can use them in the method body as if it were variables defined in there, and which initial value is what the caller specified.
pt: Felizmente, é possível passar <b>parâmetros</b> para os seus métodos. Tem que especificar o tipo e nome entre parêntesis depois do nome do método. Então, pode usá-los no corpo do método como se eles fossem variáveis definidas lá e com valores iniciais que o "caller" especificou.

note: type: Content of: <pre>
en: [!java|c]double [/!]divideByTwo([!java|c]double [/!]x[!scala]: Double[/!])[!scala]: Double =[/!] [!java|scala|c]{[/!][!python]:[/!]
         return x / 2[!java|c];[/!]
    [!scala|java|c]}[/!]
pt: [!java|c]double [/!]dividirPorDois([!java|c]double [/!]x[!scala]: Double[/!])[!scala]: Double =[/!] [!java|scala|c]{[/!][!python]:[/!]
         return x / 2[!java|c];[/!]
    [!scala|java|c]}[/!]

note: type: Content of: <p>
en: As caller, you have to specify the initial value of this "variables" between the call's parenthesis.
pt: Como o "caller", deve especificar o valor inicial destas "variáveis" entre parêntesis na chamada.

note: type: Content of: <pre>
en: [!java|c]double [/!][!scala]val [/!]result = divideByTwo(3.14)[!java|c];[/!]
pt: [!java|c]double [/!][!scala]val [/!]result = dividirPorDois(3.14)[!java|c];[/!]

note: type: Content of: <p>
en: If you want several parameters, you need to separate them with comas (,)  both in the declaration and calls.
pt: Se quiser vários parâmetros, precisa separar-os com vírgulas (,) tanto na declaração quanto na chamada.

note: type: Content of: <pre>
en: [!java|c]double divide(double x, double y) {[/!]
    [!scala]def divide(x:Double, y:Double): Double = {[/!]
    [!python]def divide(x, y):[/!]
         return x / y[!java|c];[/!]
    [!java|scala|c]}[/!]
pt: [!java|c]double dividir(double x, double y) {[/!]
    [!scala]def dividir(x:Double, y:Double): Double = {[/!]
    [!python]def dividir(x, y):[/!]
         return x / y[!java|c];[/!]
    [!java|scala|c]}[/!]

note: type: Content of: <pre>
en: [!java|c]double res = divide(3.14 , 1.5);[/!]
    [!scala]val res = divide(3.14 , 1.5)[/!]
    [!python]res = divide(3.14 , 1.5)[/!]
pt: [!java|c]double res = dividir(3.14 , 1.5);[/!]
    [!scala]val res = dividir(3.14 , 1.5)[/!]
    [!python]res = dividir(3.14 , 1.5)[/!]

note: type: Content of: <p>
en: In [!thelang], you can declare several methods of the same name as long as they don't have the same <b>signature</b>, that is, the same amount of parameters and the same parameters' types.
pt: Em [!thelang], pode declarar vários métodos de mesmo nome desde que eles não tenham a mesma <b>assinatura</b>, ou seja, a mesma quantidade e tipo de parâmetros.

note: type: Content of: <p>
en: Observe that we omitted the <tt>else</tt> branches of each <tt>if</tt>. It works anyway because a <tt>return</tt> interrupts the method execution. If we arrive to the last line of <code>[!java]max(int,int)[/!][!scala]max(Int,Int):Int[/!]</code>, we know that <code>x&lt;=y</code> because otherwise, the <tt>return</tt> of line 2 would have stopped the execution.
pt: Observe que omitimos os ramos <tt>else</tt> de cada <tt>if</tt>. Isto funciona de qualquer jeito por que um <tt>return</tt> interrompe a execução do método. Se chegarmos à última linha de <code>[!java]max(int,int)[/!][!scala]max(Int,Int):Int[/!]</code>, vamos saber que <code>x&lt;=y</code> por que de outra forma, o <tt>return</tt> da linha 2 deveria ter parado a execução.

note: type: Content of: <p>
en: This time, you have to write a <code> [!java|c]move(int stepCount,[!java]boolean[/!][!c]int[/!] forward)[/!] [!scala]move(stepCount: Int,forward: Boolean)[/!] [!python]move(stepCount,forward)[/!] </code> method which moves forward by <code>stepCount</code> steps if <code>forward</code> is true, and moves back of that amount of steps if the boolean is false.
pt: Agora vai ter que escrever um método <code> [!java|c]mover(int contaPassos,[!java]boolean[/!][!c]int[/!] forward)[/!] [!scala]mover(contaPassos: Int,forward: Boolean)[/!] [!python]mover(contaPassos,forward)[/!] </code> que move para a frente <code>contaPassos</code> passos se <code>forward</code> for true e move para trás a mesmas quantidade de passos se o booleano for false.

note: type: Content of: <p>
en: This time, there is only one world but seven buggles, all sharing the same code.  This code should not be really problematic for you to write, actually.
pt: Desta vez existe apenas um mundo mas sete buggles, todos a compartilhar o mesmo código. Este código não deve te dar muito trabalho para escrever, na verdade.

note: type: Content of: <h2>
en: Flower Pot
pt: Vaso de Flores

note: type: Content of: <p>
en: Your buggle decided to flower a bit the pot it lives in. You have to help it reproducing the drawing of its dreams (check the "Objective" tab to see it).
pt: O seu buggle decidiu plantar umas flores no pote onde vive. Tem que ajudá-lo a reproduzir o desenho dos sonhos dele (verifique a guia "Objetivo" para ver o sonho).

note: type: Content of: <p>
en: For that, you have to write a <code>growFlowers()</code> method that does not take any parameter and does not return any result. You could probably make it without defining this method, but this is part of the assignment.
pt: Para isso, tem que escrever um método <code>growFlowers()</code> que não toma nenhum parâmetro e não retorna nenhum resultado. Provavelmente poderia fazê-lo sem definir este método, mas isto é parte da atribuição.

note: type: Content of: <p>
en: Also, you should try to decompose this complex drawing in sub-steps so that your code remains short and easy to read. A method to draw one flower of the color passed in parameter sounds like a good start, but it is probably not enough.
pt: Além disso, deve tentar decompor este desenho complexo em sub-passos para que o seu código permaneça curto e fácil de ler. Um método para desenhar uma flor da cor passada no parâmetro parece um bom começo, mas provavelmente não é suficiente.

note: type: Content of: <p>
en: For your information, this drawing uses five colors that are listed below.  [!java|scala|c]The data type of these constants is <code>Color</code>, that naturally describes a particular color.[/!]
pt: Para sua informação, este desenho usa cinco cores que estão listadas abaixo.  [!java|scala|c]o tipo de dados destas constantes é <code>Cor</code>, que naturalmente descreve uma cor particular.[/!]

note: type: Content of: <ul><li>
en: <code>[!scala|java|python]Color.[/!]RED</code>
pt: <code>[!scala|java|python]Cor.[/!]VERMELHO</code>

note: type: Content of: <ul><li>
en: <code>[!scala|java|python]Color.[/!]PINK</code>
pt: <code>[!scala|java|python]Cor.[/!]ROSA</code>

note: type: Content of: <ul><li>
en: <code>[!scala|java|python]Color.[/!]CYAN</code>
pt: <code>[!scala|java|python]Cor.[/!]CIANO</code>

note: type: Content of: <ul><li>
en: <code>[!scala|java|python]Color.[/!]ORANGE</code>
pt: <code>[!scala|java|python]Cor.[/!]LARANJA</code>

note: type: Content of: <ul><li>
en: <code>[!scala|java|python]Color.[/!]GREEN</code>
pt: <code>[!scala|java|python]Cor.[/!]VERDE</code>

note: type: Content of: <ul><li>
en: <code>[!scala|java|python]Color.[/!]YELLOW</code>
pt: <code>[!scala|java|python]Cor.[/!]AMARELO</code>

note: type: Content of: <h2>
en: Flower Display Case
pt: Vitrine de flores

note: type: Content of: <p>
en: Whao! That's not a little pot anymore! That's a huge large flower display case! Your buggle can't help but starts flowering this gorgeous place. You should help it to prevent that it bumps into a wall...
pt: Uau! isto não é mais um potinho! É uma grande vitrine de flores! O seu buggle mal pode esperar para começar a florir este belo lugar. Deve ajudá-lo a não bater nas paredes...

note: type: Content of: <p>
en: PS: the newly used color is <code>Color.BLUE</code>.
pt: PS: a cor recentemente usada é <code>Cor.AZUL</code>.

note: type: Content of: <h2>
en: Colorful drawing
pt: Desenho colorido

note: type: Content of: <p>
en: If you observe carefully the picture to draw, it is constituted of four parts depicting a sort of V using a different color. A possible decomposition is to write a method in charge of drawing a V of the specified color from the current position. Its prototype can be:
pt: Se observar cuidadosamente a figura para pintar, é constituída de quatro partes a descrever um tipo de V a usar uma cor diferente. Uma decomposição possível é escrever um método responsável por pintar um V de uma cor específica a partir da posição atual. O protótipo dela pode ser:

note: type: Content of: <pre>
en: [!java|c]void [/!]makeV([!java|c]Color [/!]c[!scala]: Color[/!])[!python]  <span class="comment"># parameter c is of type Color</span>[/!]
pt: [!java|c]void [/!]fazerV([!java|c]Cor [/!]c[!scala]: Cor[/!])[!python]  <span class="comment"># parâmetro c é do tipo Cor</span>[/!]

note: type: Content of: <p>
en: The <code>Color</code> data type naturally describes a particular color. Your code should probably call <code>makeV</code> with the following arguments (a different color for each call):
pt: O tipo de dados <code>Cor</code> descreve obviamente uma cor particular. O seu código provavelmente vai chamar <code>fazerV</code> com os seguintes argumentos (uma cor diferente para cada chamada):

note: type: Content of: <ul><li>
en: [!java|scala|python]Color.[/!]YELLOW
pt: [!java|scala|python]Cor.[/!]AMARELO

note: type: Content of: <ul><li>
en: [!java|scala|python]Color.[/!]RED
pt: [!java|scala|python]Cor.[/!]VERMELHO

note: type: Content of: <ul><li>
en: [!java|scala|python]Color.[/!]BLUE
pt: [!java|scala|python]Cor.[/!]AZUL

note: type: Content of: <ul><li>
en: [!java|scala|python]Color.[/!]GREEN
pt: [!java|scala|python]Cor.[/!]VERDE

note: type: Content of: <p>
en: In <code>makeV()</code>, you should use the <code>setBrushColor()</code> method (predefined in the buggle) to change the color of the buggle's brush, as well as <code>brushUp()</code> and <code>brushDown()</code> to change the brush position.
pt: Em <code>makeV()</code>, deve usar o método <code>setBrushColor()</code> (pré-definido no buggle) para mudar a cor do pincel do buggle, assim como <code>brushUp()</code> e <code>brushDown()</code> para mudar a posição do pincel.

note: type: Content of: <p>
en: It may be wise to write the <code>makeV()</code> so that it places directly the buggle in position for the next V.
pt: É recomendável escrever o código do <code>makeV()</code> de forma que deixe o buggle na posição ao próximo V.

note: type: Content of: <p>
en: Your turn now. I'm sure you can imagine the other methods you need to keep your code simple and pleasant to read.  Complete the method <code>run()</code> that should be called automatically (once).  [!java]the <code>public</code> keyword means more or less that anybody can call this method, which is good because the PLM infrastructure calls it directly.[/!]
pt: Agora é a sua vez. Tenho certeza de que pode imaginar os outros métodos necessários para manter o seu código simples e agradável de ler. Complete o método <code>run()</code> que será chamado automaticamente (uma vez).  [!java]a palavra-chave <code>public</code> significa mais ou menos que todo o mundo pode chamar este método, o que é bom, pois a infraestrutura do PLM chama-o diretamente.[/!]

note: type: Content of: <h2>
en: Larger colorful drawing
pt: Um desenho colorido maior

note: type: Content of: <p>
en: You thus have to declare even more methods to use the repetitions of the pattern and factorize your code. Another solution is to <i>parametrize</i> your functions to reuse the code you wrote previously by changing the size.
pt: Agora tem que declarar ainda mais métodos para usar as repetições de padrões e fatorizar o seu código. Outra soução é <i>parametrizar</i> as suas funções para reusar o código que escreveu previamente a mudar o tamanho.

note: type: Content of: <p>
en: Your turn...
pt: É asua vez...

note: type: Content of: <h2>
en: Another Colorful Pattern
pt: Outro padrão colorido

note: type: Content of: outside any tag (error?)
en: Here is yet another exercise where you have to reproduce the pattern provided in the "Objective" tab.
pt: Aqui está outro exercício onde tem que reproduzir o padrão fornecido na guia "Objetivo".

note: type: Content of: <p>
en: This one is a bit more difficult than the one seen previously. Look for repeating patterns, even if the color changes, and write a method drawing each of them.
pt: Este é um pouco mais difícil do que o anterior. Procure por padrões de repetição, mesmo se a cor mudar e escreva um método a desenhar cada um deles.

note: type: Content of: <p>
en: Good luck!
pt: Boa Sorte!

note: type: Content of: <p>
en: Now that your <code>isFacingTrail()</code> method is working, it's time to write the code to organize the hunting party. Copy/paste your code from the previous exercise, and complete the <code>hunt()</code> method.
pt: Agora que o seu método <code>isFacingTrail()</code> está a funcionar, é hora de escrever o código para organizar a festa da caçada. Copie-e-cole o seu código do exercício anterior e complete o método <code>hunt()</code>.

note: type: Content of: <p>
en: Following a track is not very difficult: move forward as long as you have the track in front of you.  If there is not track in front of you anymore, check whether the rest of the track is on your left or on your right, and follow it further.
pt: Seguir uma trilha não é difícil: avance até ter a trilha à sua frente. Se não houver trilha mais trilha à sua frente, verifique se o restante da trilha está à sua esquerda ou à sua direita e vá nesta direção.

note: type: Content of: <p>
en: To ensure that you don't mix the track you come from with the one in front of you, the easier is to erase the track when you follow it. Use the method <code>brushDown()</code> to put your brush down and mark the ground, and <code>brushUp()</code> to move it up again.
pt: Para garantir que não misture o caminho de onde veio com o para aonde vai, o fácil é apagar o caminho por onde passa. Use o método <code>brushDown()</code> para abaixar o seu pincel e marcar o chão e <code>brushUp()</code> para levantá-lo de novo.

note: type: Content of: <p>
en: Finally, do not forget to capture your prey once you found it (using <code>pickupBaggle()</code>).
pt: Finalmente, não se esqueça de capturar a sua presa quando encontrá-la (a usar <code>pickupBaggle()</code>).

note: type: Content of: outside any tag (error?)
en: <a name="Objectives"> Complete the <code>hunt()</code> method. You probably want to copy over the <code>isFacingTrail()</code> method that you wrote in previous exercise.  </a>
pt: <a name="Objetivos"> Complete o método <code>hunt()</code>. Não gostaria de copiar o método <code>isFacingTrail()</code> que escreveu no exercício anterior?</a>

note: type: Content of: <p>
en: Your buggle is super happy! It just found the green dribbling trail, certainly left by a big yummy slug.  At its end, the buggle is certain to entertain itself with this appetizing slug (represented as a baggle).
pt: O seu buggle está super-feliz! Acabou de encontrar o rastro verde e úmido, certamente deixado por um apetitosa e grande lesma.  No final dele, o buggle tem certeza de que vai se divertir com est deliciosa lesma (representada por um baggle).

note: type: Content of: <p>
en: To reach that goal, you had to write a method <tt>isFacingTrail</tt> that will be called automatically by the buggle on each step. Your method should return [!python]True[/!][!java|scala]true[/!] if facing a green cell, or [!python]False[/!][!java|scala]false[/!] if not. Of course, if we are facing a wall, it should return false without bumping into it. You should make sure that this method has no <b>side effect</b>, i.e. that it does not change the state of the calling buggle nor of its world.
pt: Para atingir esse objetivo, teve que escrever um método <tt>isFacingTrail</tt> que será chamado automaticamente pelo buggle a cada passo. O seu método deve retornar [!python]True[/!][!java|scala]true[/!] se estiver diante de uma célula verde, ou [!python]False[/!][!java|scala]false[/!] se não estiver. Claro, se estivermos de frente para uma parede, deve retornar false sem esbarrar nela. Deve ter certeza de que este método não tem <b>efeitos colaterais</b>, ou seja, que não muda o estado do buggle chamado nem do mundo dele.

note: type: Content of: <p>
en: Your tool to that end is the <code>getGroundColor()</code> that returns the color of the current cell. Just go to the cell you want to test and run that function.  [!java]You cannot test whether this color is equal to <code>Color.green</code> with an <code>==</code> sign but instead you have to write something like <code>getGroundColor().equals(Color.green)</code>. This is because green is an <i>object</i> in Java, and <code>.equals()</code> is the way to go to test equality between Java objects.[/!] [!python|scala|c]So you just have to test whether the returned color is equal to the value <code>[!scala|python]Color.green[/!][!c]GREEN[/!]</code>, that represents the green color.[/!]
pt: A sua ferramenta para este objetivo é o <code>getGroundColor()</code> que retorna a cor da célula atual. Simplesmente vá à célula que quer testar e execute esta função.  [!java]Não pode testar se esta cor é igual a <code>Cor.verde</code> com um símbolo de <code>==</code> mas sim escrever algo como <code>getGroundColor().equals(Cor.verde)</code>. Isto acontece por que verde é um  <i>objeto</i> em Java e <code>.equals()</code> é a forma de testar igualdade entre objetos Java.[/!] [!python|scala]Então tem que testar se a cor retornada é igual ao valor <code>Cor.verde</code>, que representa verde.[/!]

note: type: Content of: <p>
en: Complete the <code>isFacingTrail()</code> method (which gets called automatically).
pt: Complete o método <code>isFacingTrail()</code> (que será chamado automaticamente).

note: type: Content of: <h2>
en: Slugs and Snails
pt: Lesmas e Caracóis

note: type: Content of: <p>
en: Yuhu! This time, your buggle found the tracks of much more preys! In the first world, that's a yummy Kitty Slug (leaving a pink trail) while on the second world, that's a big fat snail that awaits your buggle at the end of the orange trail.
pt: Iuhu! Desta vez, o seu buggle encontrou trilhas com muitas presas! No primeiro mundo, era uma bela lesma deliciosa (que deixava um rastro rosa) e no segundo mundo, uma grande e o caracol gordo que esperava o seu buggle no final do rastro laranja.

note: type: Content of: <p>
en: You have to copy/paste your code again, and change it so that your methods take the color of the trail to follow as a parameter. Beside of this, your code should work as earlier.
pt: Tem que copiar/colar o seu código de novo e mudá-lo de forma que os seus métodos fiquem com a cor do rastro para seguir como um parâmetro. E mesmo assim, o seu código deve funcionar como antes.

note: type: Content of: <p>
en: Don't get lost on false leads! <code>The hunt()</code> method was given a parameter to tell you which color to follow (and it is not the same in all worlds). Add a parameter to your <code>isFacingTrail()</code> method to only follow the requested color, as the other colors lead to dead ends...
pt: Cuidado para não seguir pistas falsas! O método <code>hunt()</code> recebe um parâmetro para dizer que cor seguir (e não é o mesmo em todos os mundos). Adicione um parâmetro ao seu método <code>isFacingTrail()</code> para apenas seguir a cor requisitada, pois as outras cores vão levar a becos...

note: type: Content of: <p>
en: After these races, it's time to party! For that, we will teach the buggles to play Dance Revolution, this game beloved of some students: The player has to move the feet on the carpet according to the instructions presented on the screen, and following the music. But before that, we have some details to study first.
pt: Depois destas corridas, é hora de festejar! Para isto, vamos ensinar os buggles a jogar Dance Revolution, este jogo amado por alguns estudantes: O jogador tem que mover os pés num carpete de acordo com as instruções apresentadas no ecrã e seguir a música. Mas antes disto, temos alguns detalhes para estudar primeiro.

note: type: Content of: <h3>
en: Conditionals without curly braces
pt: Condicionais sem colchetes

note: type: Content of: <p>
en: There is one detail we omitted about the conditional syntax: if a branch contains only one instruction, then the curly braces become optional. So, the two chunk of code are equivalent:
pt: Existe um detalhe que omitimos sobre a sintaxe do condicional: se um ramo contém apenas uma instrução, então o colchetes se torna opcional. Portanto, estes dois pedaços de código são equivalentes:

note: type: Content of: <pre>
en: if (<b>condition</b>) {
        <b>whatToDoIfTheConditionIsTrue();</b>
    } else {
        <b>whatToDoElse();</b>
    }
pt: if (<b>condição</b>) {
        <b>oQueFazerSeACondiçãoÉVerdadeira();</b>
    } else {
        <b>oQueFazerCasoContrário();</b>
    }

note: type: Content of: <pre>
en: if (<b>condition</b>) 
        <b>whatToDoIfTheConditionIsTrue();</b>
    else
        <b>whatToDoElse();</b>
pt: if (<b>condição</b>) 
        <b>oQueFazerSeACondiçãoÉVerdadeira();</b>
    else
        <b>oQueFazerCasoContrário();</b>

note: type: Content of: <p>
en: Actually, you can do the same for loops body that are reduced to one instruction only.  But beware, this becomes dangerous if you chain the <tt>if</tt> instructions like this:
pt: Na verdade, pode fazer o mesmo em corpos de loop que se reduzem a apenas uma instrução. Mas cuidado, isto torna-se perigoso se cadeiar as instruções <tt>if</tt> como a seguir:

note: type: Content of: <pre>
en: if (isOverBaggle())    
         if (x == 5)
              left();
    else // Do not write it this way, it's misleading!
         right(); 
    [!c]stepForward();[/!][!java|scala]forward();[/!]
pt: if (isOverBaggle())    
         if (x == 5)
              left();
    else // Não escreva desta forma, é enganoso!
         right(); 
    [!c]stepForward();[/!][!java|scala]forward();[/!]

note: type: Content of: <p>
en: You think that <code>right()</code> refers to the first <code>if</code> and get executed when <code>isOverBaggle()</code> returns false, but in fact, it refers to the second one <code>if</code> and will be executed when <code>isOverBaggle()</code> returns true and <code>x != 5</code>. Yes, despite the indentation, the buggle understands the previous code as follows:
pt: Pensa que <code>right()</code> se refere ao primeiro <code>if</code> e será executado quando <code>isOverBaggle()</code> retorna false, mas, na verdade, refere-se ao segundo <code>if</code> e será executado quando <code>isOverBaggle()</code> retorna true e <code>x != 5</code>. Sim, apesar da indentação, o buggle entende o código anterior da seguinte forma:

note: type: Content of: <p>
en: In [!thelang] the computer connects a <tt>else</tt> branch to the closest <tt>if</tt>. If you find it ambiguous, you should add more braces than strictly necessary. Computers don't even look at the indentation in [!thelang]. The previous code could even be written as follows and lead to the same result.
pt: Em [!thelang] o computador conecta um ramo <tt>else</tt> ao <tt>if</tt> mais próximo. Se o achar ambíguo, deve adicionar mais aspas do que estritamente necessário. Os computadores nem sequer olham para a indentação em [!thelang]. O código anterior pode até ser escrito da seguinte forma e levar ao mesmo resultado.

note: type: Content of: <p>
en: But for humans, <b>you really want to indent your code correctly correctly</b>. For example if you want a professor to review or even grade your code, if you want to reuse your own code later, or even if you need to debug it. That is right: you need to write readable code for your own comfort.
pt: Mas para humanos, <b>realmente é melhor indentar o seu código corretamente</b>. Por exemplo, se quer que um professor reveja ou mesmo avalie o seu código, se quer reutilizar o seu próprio código mais tarde, ou mesmo se precisa depurá-lo. Isso é certo: precisa escrever um código legível para o seu próprio conforto.

note: type: Content of: <h3>
en: Chaining conditionals
pt: Encadear condicionais

note: type: Content of: <p>
en: You sometimes want to ask the buggle something similar to:
pt: Algumas vezes quer perguntar o buggle algo similar a:

note: type: Content of: <pre>
en: if it's raining, take an umbrella;
    if not, and if it's a hot day, take a bottle of water;
    if not and if it's July 4th, take an American flag
pt: se está a chover, leve um guarda-chuva;
    se não e se está quente, leve uma garrafa de água;
    se não e se hoje é 4 de Julho, leve uma bandeira dos estados unidos

note: type: Content of: <p>
en: The trap is that we want at most one of these actions to be taken. That is to say, if it's raining a very hot July 4th, we don't want the buggle to get outside with an umbrella, some water and a flag, but simply with an umbrella. The following code is thus WRONG.
pt: A armadilha é que queremos que pelo menos uma destas ações sejam feitas. É como dizer, se está a chover num 4 de Julho quente, não queremos que o buggle vá para fora com um guarda-chuva, água e um bandeira, mas simplesmente com um guarda-chuva. O código seguinte está, então, ERRADO.

note: type: Content of: <pre>
en: [!scala|c|java]if (rainy())
        takeUmbrella();
    if (hot())
        takeWater();
    if (todayIsJuly4th())
        takeFlag();[/!][!python]if rainy():
        takeUmbrella()
    if hot():
        takeWater()
    if todayIsJuly4th():
        takeFlag()[/!]
pt: [!scala|c|java]if (chuvoso())
        pegueGuarda-Chuva();
    if (quente())
        pegueAgua();
    if (hoje4Julho())
        pegueBandeira();[/!][!python]if aChover():
        pegueGuarda-Chuva()
    if quente():
        pegueAgua()
    if hoje4Julho():
        pegueBandeira()[/!]

note: type: Content of: <p>
en: Indeed, since the conditions are evaluated one after the other, there is a risk that you go to the July 4th march on a rainy day. Instead, we should use something like this to ensure that once we found a true condition, we won't evaluate the next ones.
pt: Na verdade, já que as condições são calculadas uma depois da outra, existe um risco de que vá sair no die 4 de Julho num dia chuvoso. Na verdade, devemos usar algo como isto para garantir que uma vez que encontremos a condição verdadeira, não passemos às próximas.

note: type: Content of: <pre>
en: [!java|scala|c]if (rainy()) {
        takeUmbrella();
    } else {
        if (hotDay()) {
            takeWater();
        } else {
            if (todayIsJuly4th()) {
                takeFlag();
            }
        }
    }[/!][!python]if rainy():
        takeUmbrella()
    else:
        if hotDay():
            takeWater()
        else:
            if todayIsJuly4th():
                takeFlag()[/!]
pt: [!java|scala|c]if (chuvoso()) {
        levarGuardaChuva();
    } else {
        if (diaQuente()) {
            levarAgua();
        } else {
            if (jogoDaCopa()) {
                levarBandeira();
            }
        }
    }[/!][!python]if chuvoso():
        levarGuardaChuva()
    else:
        if diaQuente():
            levarAgua()
        else:
            if jogoDaCopa():
                levarBandeira()[/!]

note: type: Content of: <p>
en: Unfortunately, such a cascade of conditionals is quite difficult to read. It is better to [!java|scala|c]omit the curly braces for the <tt>else</tt> statements. Some languages even introduce a specific construct for these <tt>else if</tt>, but not [!thelang].[/!] [!python]change the sub-blocks using the <code>elif</code> keyword to mark explicitly these "else if" branches.[/!]
pt: Infelizmente, tal cascata de condicionais é bastante difícil de ler. É melhor [!java|scala|c]omitir as chaves para as assertivas <tt>else</tt>. Algumas linguagens até mesmo introduzem uma construção específica para estes <tt>else if</tt>, mas não [!thelang].[/!] [!python]mudar os sub-blocos a usar a palavra-chave <code>elif</code> para marcar explicitamente estes ramos "else if".[/!]

note: type: Content of: <pre>
en: [!c|java|scala]if (rainy()) { 
        takeUmbrella();
    } else if (hotDay()) {
        takeWater();
    } else if (todayIsJuly4th()) {
        takeFlag();
    }[/!][!python]if rainy():
        takeUmbrella()
    elif hotDay():
        takeWater()
    elif todayIsJuly4th():
        takeFlag()[/!]
pt: [!c|java|scala]if (chuvoso()) { 
        levarGuardaChuva();
    } else if (diaQuente()) {
        levarAgua();
    } else if (jogoDaCopa()) {
        levarBandeira();
    }[/!][!python]if chuvoso():
        levarGuardaChuva()
    elif diaQuente():
        levarAgua()
    elif jogoDaCopa():
        levarBandeira()[/!]

note: type: Content of: <h3>
en: Graffiti in the Buggle World
pt: Grafitagem no mundo dos Buggles

note: type: Content of: <p>
en: Buggles can tag graffitis on the ground of their world. For that, they use the four following methods:
pt: Os buggles podem grafitar no chão do mundo deles. Para isto, use os quatro métodos seguintes:

note: type: Content of: <ul><li>
en: <code>[!c]int[/!][!java]boolean[/!] isOverMessage()[!scala]:Boolean[/!]</code>: returns <code>[!c]1[/!][!java|scala]true[/!][!python]True[/!]</code> if and only if there is a message on the ground.
pt: <code>[!c]int[/!][!java]boolean[/!] isOverMessage()[!scala]:Boolean[/!]</code>: returns <code>[!c]1[/!][!java|scala]true[/!][!python]True[/!]</code> se e somente se existe uma mensagem no chão.

note: type: Content of: <ul><li>
en: <code>[!c]char*[/!][!java]String[/!] readMessage()[!scala]: String[/!]</code>: returns the message written on the ground (or an empty string if nothing is written).
pt: <code>[!c]char*[/!][!java]String[/!] readMessage()[!scala]: String[/!]</code>: retorna a mensagem lida no chão (ou uma cadeia vazia se não há nada escrito).

note: type: Content of: <ul><li>
en: <code>[!java|c]void[/!] writeMessage([!c]char*[/!][!java]String [/!]msg[!scala]: String[/!])</code>: writes the specified message down on the ground. If there is already a message on the ground, the new content is added at the end of the existing message.
pt: <code>[!java|c]void[/!] escreverMensagem([!c]char*[/!][!java]String [/!]msg[!scala]: String[/!])</code>: escreve a mensagem especificada no chão. Se já existe uma mensagem no chão, a nova é adicionada no final da mensagem existente.

note: type: Content of: <ul><li>
en: <code>[!java|c]void [/!]clearMessage()</code>: clears what is written on the ground.
pt: <code>[!java|c]void [/!]clearMessage()</code>: limpa o que está escrito no chão.

note: type: Content of: outside any tag (error?)
en: The goal is then to organize a BDR game between the buggles by teaching them to move according to the instructions written on the ground. These instructions are messages written on the ground, with the following signification:
pt: O objetivo é então organizar um jogo de BDR entre os buggles a ensinar eles a se mover de acordo com as instruções escritas no chão. Estas instruções são mensagens escritas no chão, com o seguinte significado:

note: type: Content of: <table><tr><td>
en: Message
pt: Mensagem

note: type: Content of: <table><tr><td>
en: What to do
pt: O que fazer

note: type: Content of: <table><tr><td>
en: Mnemonic
pt: Mnemônico

note: type: Content of: <table><tr><td>
en: Turn right and move one step forward
pt: Vire a direita (R de right) e mova um passo a frente

note: type: Content of: <table><tr><td>
en: Right
pt: Direita

note: type: Content of: <table><tr><td>
en: Turn left and move one step forward
pt: Vire a esquerda e mova um passo a frente

note: type: Content of: <table><tr><td>
en: Left
pt: Esquerda

note: type: Content of: <table><tr><td>
en: Turn back (U-turn) and move one step forward
pt: Vire para trás (meia-volta) e mova um passo a frente

note: type: Content of: <table><tr><td>
en: Inverse
pt: Inversa

note: type: Content of: <table><tr><td>
en: Move one step forward
pt: Mova um passo a frente

note: type: Content of: <table><tr><td>
en: First letter of the alphabet
pt: Primeira letra do alfabeto

note: type: Content of: <table><tr><td>
en: Move two steps forward
pt: Mova dois passos a frente

note: type: Content of: <table><tr><td>
en: Second letter of the alphabet
pt: Segunda letra do alfabeto

note: type: Content of: <table><tr><td>
en: Move three steps forward
pt: Mova três passos a frente

note: type: Content of: <table><tr><td>
en: Third letter of the alphabet
pt: Terceira letra do alfabeto

note: type: Content of: <table><tr><td>
en: Move one step backward
pt: Mova um passo para trás

note: type: Content of: <table><tr><td>
en: One letter before the end of the alphabet
pt: última letra do alfabeto

note: type: Content of: <table><tr><td>
en: Move two steps backward
pt: Mova dois passos para trás

note: type: Content of: <table><tr><td>
en: Two letters before the end of the alphabet
pt: penúltima letra do alfabeto

note: type: Content of: <table><tr><td>
en: Move three steps backward
pt: Mova três passos para trás

note: type: Content of: <table><tr><td>
en: Three letters before the end of the alphabet
pt: Antepenúltima letra do alfabeto

note: type: Content of: <table><tr><td>
en: <i>(anything else)</i>
pt: <i>(qualquer outra coisa)</i>

note: type: Content of: <table><tr><td>
en: Stop dancing.
pt: Parar de dançar.

note: type: Content of: <h3>
en: Indications
pt: Indicações

note: type: Content of: outside any tag (error?)
en: This exercise may seem a bit complex at the first glance, but it comes down to summarizing the information of the table in a sequence of conditionals.
pt: Este exercício pode parecer um pouco complexo à primeira vista, mas ele vem a resumir a informação na tabela numa sequência de condicionais.

note: type: Content of: <p>
en: You have to keep dancing as long as there is some dancing steps to do, i.e., as long as we are in a cell which content is described in the table.  The easier for that is to use a boolean variable (<code>finished</code>)  as termination condition to a <code>while</code> loop.  It should be initialized to <code>[!c]0[/!][!java|scala]false[/!][!python]False[/!]</code>, and switched to <code>[!c]1[/!][!java|scala]true[/!][!python]True[/!]</code> as soon as the buggle find a cell with a value not described in the table.  Thus, the loop will stop and the program will terminate.
pt: Tem que se manter a dançar enquanto houverem passos de dança para fazer, p.ex., enquanto estivermos numa célula cujo conteúdo esteja contido na tabela. a forma mais fácil de fazer isto é a usar uma variável booleana (<code>terminou</code>) como condição de término para o loop <code>while</code>. Ela deve ser iniciada como <code>[!c]0[/!][!java|scala]false[/!][!python]False[/!]</code> e trocada para <code>[!c]1[/!][!java|scala]true[/!][!python]True[/!]</code> assim que o buggle encontre uma célula com um valor não descrito na tabela. Assim, o loop pára e o programa termina.

note: type: Content of: <p>
en: Another subtlety is that detecting if strings are equals is a bit annoying in [!thelang].  So, we use the <code>char getIndication[!c]Bdr[/!]()</code> instead of <code>[!java]String[/!][!c]char*[/!] readMessage()</code>.  This method, only known by the buggles of this exercise, returns the first char of the message written on the ground (or ' ' -- the space char -- if nothing is written down). It enables to work with chars instead of strings, that is much simpler in [!thelang].
pt: Outro detalhe é que detetar se cadeias são iguais é um pouco chato em Java. Então, usamos o <code>char getIndication[!c]Bdr[/!]()</code> ao invés do <code>[!java]String[/!][!c]char*[/!] readMessage()</code>. Este método, conhecido apenas pelos buggles deste exercício, retorna o primeiro caractere da mensagem escrita no chão (ou ' ' -- o caractere para espaço -- se não tem nada escrito). Ele ativa que se trabalhe com caracteres ao invés de cadeias, que é muito mais simples em [!thelang].

note: type: Content of: <h3>
en: Tips and Hints
pt: Dicas

note: type: Content of: outside any tag (error?)
en: If you fail to understand why the buggle does not execute the expected steps, try adding <code>brushDown()</code> in your method. This asks the buggle to put down a brush leaving a trail when it moves. It should help you understanding its trajectory, but do not forget to remove this call when you want to test whether your code is a valid solution to the exercise: you are asked to let the buggle dance, not to vandalize the dance floor.
pt: Se não entendeu por que o buggle não fez os passos esperados, tente adicionar <code>brushDown()</code> no seu método. Isto pede ao buggle para abaixar um pincel a deixar um rastro por onde passar. Isto pode ajudá-lo a entender a trajetória dele, mas não se esqueça de remover esta chamada quando quiser testar se o seu código é uma solução válida para o exercício: pode fazer o buggle dançar, mas não pichar a pista de dança.

note: type: Content of: <p>
en: When your program finally works, move on to the next exercise.
pt: Quando seu programa finalmente funcionar, vá ao próximo exercício.

note: type: Content of: <p>
en: BDR is cool, but it's a bit chaotic. First, the buggles giggle in any directions, and then the code you had to write to let them move is rather difficult to read. Here is a new BDR world where the buggle will dance a gentle circle. We will benefit this tranquillity to clean up a bit our code thanks to the new constructs we will introduce.
pt: BDR é legal, mas um pouco caótico. Primeiro, os buggles balançam em todas as direções, o que faz com que o código que tenha que escrever para fazê-los se mover seja um pouco difícil de ler. Apresentamos agora um novo mundo DBR onde os buggles dançam num suave círculo. Vamos aproveitar esta tranquilidade para limpar um pouco nosso código graças a novas construções que vamos introduzir.

note: type: Content of: <h3>
en: [!java|c]<code>switch</code> conditionals[/!][!scala]Pattern matching[/!]
pt: [!java|c]condicionais <code>switch</code>[/!][!scala]busca de padrões[/!]

note: type: Content of: <p>
en: The hardest part of previous code is certainly the conditional cascading. Somewhere in your code, you certainly had something similar to:
pt: A parte mais difícil do código anterior é comn certeza a cascata de condicionais. Em algum ponto do seu código, certamente tem algo como isto:

note: type: Content of: <pre>
en: if ([!java|c]getIndication() == 'R'[/!][!scala]readMessage() == "R"[/!]) {
      right();
      [!c]stepForward()[/!][!java|scala]forward()[/!];
    } else if ([!java|c]getIndication() == 'L'[/!][!scala]readMessage() == "L"[/!]) {
      left();
      [!c]stepForward()[/!][!java|scala]forward()[/!];
    } else if ([!java|c]getIndication() == 'I'[/!][!scala]readMessage() == "I"[/!]) {
      back();
      [!c]stepForward()[/!][!java|scala]forward()[/!];
    <span class="comment">/* other else if */</span>
    } else {
      finished = [!c]1[/!][!java|scala]true[/!];
    }
pt: if ([!java|c]getIndicação() == 'R'[/!][!scala]lerMensagem() == "R"[/!]) {
      right();
      [!c]stepForward()[/!][!java|scala]forward()[/!];
    } else if ([!java|c]getIndicação() == 'L'[/!][!scala]lerMensagem() == "L"[/!]) {
      left();
      [!c]stepForward()[/!][!java|scala]forward()[/!];
    } else if ([!java|c]getIndicação() == 'I'[/!][!scala]lerMensagem() == "I"[/!]) {
      back();
      [!c]stepForward()[/!][!java|scala]forward()[/!];
    <span class="comment">/* other else if */</span>
    } else {
      terminou = [!c]1[/!][!java|scala]true[/!];
    }

note: type: Content of: <p>
en: When you review this code, it may not be clear at the first glance that it is simply a choice with 4 branches depending on the value of [!java|c]getIndication()[/!][!scala]readMessage()[/!].  To improve this, we will use a [!java|c]<code>switch</code> construct, which Java syntax is the following:[/!] [!scala] pattern matching, which is a very powerful construct that greatly generalizes the <code>if</code>. It is arguably one of the major advantages of Scala when compared to languages such as Java or python.  It is not new either, as other languages such as OCaml or Haskell offer this feature since long, but still.  It's really cool![/!]
pt: Quando revisa este código, não fica claro à primeira vista que é simplesmente a escolha entre quatro ramos a depender do valor de [!java|c]getIndicação()[/!][!scala]lerMensagem()[/!]. Para melhorar ele, vamos usar uma construção [!java|c]<code>switch</code>, que na sintaxe de Java é o seguinte:[/!] [!scala] de busca de padrões, que é bastante poderosa e generaliza muito o <code>if</code>. É com certeza uma das maiores vantagens de Scala quando comparada com linguagens como Java ou python. E nem é tão nova assim, já que outras linguagens como OCaml e Haskell já tem esta funcionalidade há muito tempo. É bem fixe![/!]

note: type: Content of: <p>
en: Observe that each branch of a <tt>switch</tt> must be ended by a <code>break</code>. If you forget this, the machine keeps going and execute the next branch in the list after the branch it jumped to. There is even some <b>rare</b> cases where this behavior reveals helpful.
pt: Observe que cada ramo de um <tt>switch</tt> deve terminar com um <code>break</code>. se esquecer dele, a máquina continua e executa o próximo ramo na lista depois do ramo para o qual pulou. Existem na verdade uns <b>raros</b> casos onde este comportamento é útil.

note: type: Content of: <p>
en: It is then possible to rewrite previous BDR code in a cleaner way using the <tt>switch</tt> construct:
pt: É então possível reescrever o código do BDR anterior numa forma mais clara a usar a construção <tt>switch</tt>:

note: type: Content of: <pre>
en: switch (getIndication()) {
      case 'R':
        right(); 
        [!c]stepForward()[/!][!java]forward()[/!]; 
        break;
      case 'L':
        left();
        [!c]stepForward()[/!][!java]forward()[/!]; 
        break;
      case 'I':
        back();
        [!c]stepForward()[/!][!java]forward()[/!];
        break;
      default: 
        return;
    }
pt: switch (getIndicação()) {
      case 'R':
        right(); 
        [!c]stepForward()[/!][!java]forward()[/!]; 
        break;
      case 'L':
        left();
        [!c]stepForward()[/!][!java]forward()[/!]; 
        break;
      case 'I':
        back();
        [!c]stepForward()[/!][!java]forward()[/!];
        break;
      default: 
        return;
    }

note: type: Content of: <pre>
en: <i>expression</i> <b>match</b> {
      <b>case</b> <i>possible value</i> <b>=></b> instructions
      <b>case</b> <i>other value</i>     <b>=></b> other instructions
      <b>case</b> <i>another value</i> <b>=></b> yet another instructions
      <b>case _                 =></b> default instructions
    }
pt: <i>expressão</i> <b>match</b> {
      <b>case</b> <i>um valor possível</i> <b>=></b> instruções
      <b>case</b> <i>um outro valor</i>     <b>=></b> outras instruções
      <b>case</b> <i>mais outro valor</i> <b>=></b> e outras instruções
      <b>case _                 =></b> instruções padrão
    }

note: type: Content of: <p>
en: The expression provided before the keyword <code>match</code>, and then the branches are evaluated one after the other until we find one which value provided between <code>case</code> and <code>=&gt</code> is equal to the expression's value.  The <code>_</code> symbol acts as a wildcard, so the <code>_</code> branch <i>always</i> matches.  Here is an example where a variable <code>name</code> is matched.
pt: A espressão fornecida antes da palavra-chave <code>match</code> e os ramos seguintes são avaliados um após o outro até encontrarmos um cujo valor fornecido entre <code>case</code> e <code>=&gt</code> seja igual ao valor da expressão. O símbolo <code>_</code> age como um coringa, logo o ramo <code>_</code> <i>sempre</i> casa. Aqui está um exemplo de onde uma variável <code>name</code> casa.

note: type: Content of: <pre>
en: name match {
      case "Martin" => println("Hello Martin, how are you?")
      case "Gerald" => println("Hey Gerald! How are you doing?")
      case _            => println("Welcome stranger.")
    }
pt: name match {
      case "Martin" => println("Oi Martin, como vai?")
      case "Gerald" => println("Oi Gerald! como está?")
      case _            => println("Olá estranho.")
    }

note: type: Content of: <p>
en: It is possible to have more than one instruction per branch, and merge branches when the values are separated by a | symbol.
pt: é possível ter mais que uma instrução por ramo e mesclar ramos quando os valores são separados por um símbolo | .

note: type: Content of: <pre>
en: name match {
      case "Martin" | "Gerald" => println("Hello "+name+", how are you?"); openTheDoor()
      case _                            => println("Hello stranger. Please do not pass."); lockTheDoor()
    }
pt: name match {
      case "Martin" | "Gerald" => println("Oi "+name+", como está?"); openTheDoor()
      case _                            => println("Oi estranho. Favor não passar."); lockTheDoor()
    }

note: type: Content of: <p>
en: You can even add guards to your branches. These are extra conditions that must be respected for the branch to get applied. This is handy if you want match on value ranges, as follows.
pt: Sempre pode adicionar guardas aos seus ramos. São condições adicionais que devem ser respeitadas para que o ramo seja aplicado. São úteis se quiser corresponder com intervalos de valores, como a seguir.

note: type: Content of: <pre>
en: age match {
      case i if i&lt;10 => println("Hey kid!")
      case i if i&lt;20 => println("Hey dude!")
      case i if i&lt;30 => println("Hello young man")
      case _           => println("Hello Sir")
    }
pt: age match {
      case i if i&lt;10 => println("Oi menino!")
      case i if i&lt;20 => println("Oi cara!")
      case i if i&lt;30 => println("Oi, meu caro")
      case _           => println("Oi senhor")
    }

note: type: Content of: <p>
en: Note that there is no need to check whether the value is higher than 10 on the second line because the first matching branch is used. So, if the second branch gets evaluated, then the first one did not match.
pt: Observe que não há necessidade de verificar se o valor é maior que 10 na segunda linha por que o primeiro ramo "foi verificado". Então, se o segundo ramo está a ser verificado, o primeiro não aprovou.

note: type: Content of: <p>
en: Finally, it is possible also to match several variables in one shoot!
pt: Finalmente, é possível também aprovar várias variáveis de uma vez!

note: type: Content of: <pre>
en: (x,y) match {
     case (0,0) => println("that's the origin")
     case (_,0) => println("On the ordinate")
     case (0,_) => println("On the abscissa")
     case (_,_) => println("Some random point")
    }
pt: (x,y) match {
     case (0,0) => println("Esta é a origem")
     case (_,0) => println("nas ordenadas")
     case (0,_) => println("nas abscissas")
     case (_,_) => println("algum ponto qualquer")
    }

note: type: Content of: <p>
en: I told you that scala's pattern matching is very powerful! I actually love this feature!
pt: Disse que reconhecimentod e padrões em scala é muito poderoso! Adoro esta funcionalidade!

note: type: Content of: <p>
en: [!java|scala|c]Apply the improvement we just saw to rewrite your buggle code with the following dance steps. [/!] [!python]Let's teach a new dance step to the buggles. It is slightly more complex but actually better looking. Beside of that, that's the same old story.[/!] Note that we can now move up to 6 cells in one dance step.
pt: [!java|scala|c]"Aplique" a melhoria que acabamos de ver para reescrever o seu código do buggle com os seguintes passos de dança. [/!] [!python]Vamos ensinar um novo passo de dança aos buggles. É um pouco mais complexo mas na verdade vai ficar mais legal. Apesar disto, é a mesma história de sempre.[/!] Observe que nósagora vamos subir seis células num passo de dança.

note: type: Content of: <table><tr><td>
en: Turn back and move one step forward
pt: Vire e dê um passo para frente

note: type: Content of: <table><tr><td>
en: Move four cells forward
pt: Mova quantro passos para frente

note: type: Content of: <table><tr><td>
en: Move five cells forward
pt: Mova cinco passos para frente

note: type: Content of: <table><tr><td>
en: Move six cells forward
pt: Mova seis passos para frente

note: type: Content of: <table><tr><td>
en: Move four cells backward
pt: Mova quatro passos para trás

note: type: Content of: <table><tr><td>
en: Move five cells backward
pt: Mova cinco passos para trás

note: type: Content of: <table><tr><td>
en: Move six cells backward
pt: Mova seis passos para trás

note: type: Content of: <p>
en: When you program works again, proceed to next exercise.
pt: Quando seu programa funcionar de novo, vá ao próximo exercício.

note: type: Content of: <p>
en: We will now teach the buggle to explore its world. Its initial position is the bottom left corner, and it should visit any cells up to the top (coloring the ground on its path. The main loop of your code is something like:
pt: Agora vamos ensinar o buggle a explorar o mundo dele. A posição inicial dele é o canto inferior esquerdo e deve visitar todas as células até o topo (a colorir o chão onde passa. O loop principal do seu código é algo assim:

note: type: Content of: <pre>
en:  move brush down
     while we did not reach the final position
       move like a snake
pt:  abaixe o pincel
     enquanto não chegar na posição final
       se mova como uma cobra

note: type: Content of: <p>
en: We thus have to write two specific methods: The first one returns a boolean indicating whether we are on a final position while the second moves one snake step forward.
pt: Então temos que escrever dois métodos específicos: o primeiro retorna um booleano a indicar se estamos numa posição final enquanto o segundo um "snake step" para frente.

note: type: Content of: <p>
en: We reached the final position if and only if both conditions are true:
pt: Chegamos na posição final se e apenas se ambas as condições são verdadeiras:

note: type: Content of: <ul><li>
en: We are facing a wall
pt: Estamos de frente para uma parede

note: type: Content of: <ul><li>
en: There is a wall on the north of the buggle. So, if the buggle is facing east, you should check whether there is a wall on the left, and if the buggle is facing west, you should check on the right side.
pt: Existe uma parede no norte do buggle. Então, se o buggle está a olhar para o leste, deve verificar se existe uma parede à esquerda e se o buggle está a olhar para o oeste, deve verificar do lado direito.

note: type: Content of: <ul><li>
en: We can get the current heading of the buggle using the <code>getDirection()</code>, and we know whether it looks east using <code>getDirection() == [!scala|python|java]Direction.[/!]EAST</code> (WEST for west).
pt: Podemos obter a direção atual do buggle a usar o <code>getDirection()</code> e sabemos se ele está a apontar para o leste a usar <code>getDirection() == [!scala|python|java]Direção.[/!]LESTE</code> (OESTE para oeste).

note: type: Content of: <ul><li>
en: To check, nothing magical: you have to turn the buggle and check whether it is facing a wall afterward.
pt: Para verificar, não tem mágica: tem que virar o buggle e verificar em seguida se está a olhar para uma parede.

note: type: Content of: <p>
en: Then, a snake step can be achieved by moving one step forward if we are not facing a wall, and moving to the upper line else (i.e., if you look to the west facing a wall, you have to turn right, forward and turn right).
pt: Então, um passo de cobra pode ser conseguido a mover um passo para a frente se não estivermos de cara para a parede e a mover para a linha acima caso contrário (p.ex., se olha para o oeste e está de cara para uma parede, tem que virar a direita, andar e virar a direita).

note: type: Content of: <p>
en: Hint: the main loop of your code must continue while the testing function returns false. There is two ways of writing it:
pt: Dica: o loop principal do seu código deve continuar enquanto a função de teste retorna false. Existem duas formas de fazer isto:

note: type: Content of: <p>
en: [!python]You may prefer to write it as:[/!] [!java|scala|c]Since the exclamation mark (!) denotes the boolean negation in [!thelang], you may write it as:[/!]
pt: [!python]Pode preferir escrever como:[/!] [!java|scala|c]Já que a marca de exclamação (!) denota a negação booleana em [!thelang], pode escrever como:[/!]

note: type: Content of: <p>
en: The goal of this serie of exercises is to let the buggle traverse its world. It must number the cells it walks on to show its traversal order.
pt: O objetivo desta série de exercícios é fazer o buggle percorrer o mundo dele. Deve numerar as células por onde passa para mostrar a ordem do caminho.

note: type: Content of: <p>
en: The main loop of your code should be something like:
pt: O loop principal do seu código deve ser algo como:

note: type: Content of: <pre>
en:  while we are not on the final position
       go to the next position
       label the cell with its number
pt:  enquanto não estiver na posição final
       vá à próxima posição
       rotule a célula com um número

note: type: Content of: <p>
en: In contrary to the exercises we saw so far, we won't use the <code>forward()</code>, <code>backward()</code> and similar methods. Instead, we will compute the coordinate of the next buggle position and use the <code>setPos(x, y)</code> method to <i>teleport</i> the buggle directly to this position. For example, <code>setPos(3, 5)</code> teleports the buggle to the cell where x=3 and y=5.
pt: Ao contrário dos exercícios que vimos até agora, não vamos usar os métodos <code>forward()</code>, <code>backward()</code> e similares. Ao invés disto, vamos calcular as coordenadas da próxima posição de buggle e usar o método <code>setPos(x, y)</code> para <i>teletransportar</i> o buggle diretamente para esta posição. Por exemplo, <code>setPos(3, 5)</code> teletransporta o buggle à célula onde x=3 e y=5.

note: type: Content of: <p>
en: Your first task is thus to write a boolean function indicating whether the buggle reached the final position or not, ie if it reached the bottom right corner of the world. For this, you can use <code>getWorldWidth()</code> and <code>getWorldHeight()</code> which return respectively the world's width and height. Your test is about comparing the buggle's current position (that you can access with <code>getX()</code> and <code>getY()</code>) to the world dimensions.
pt: A sua primeira tarefa é escrever uma função booleana a indicar se o buggle alcançou a posição final ou não, ou seja, se alcançou o canto inferior direito do mundo. Para isto, pode usar <code>getWorldWidth()</code> e <code>getWorldHeight()</code> que retornam respetivamente a largura e altura do mundo. O seu teste deve comparar a posição atual do buggle (que pode acessar com <code>getX()</code> e <code>getY()</code>) com as dimensões do mundo.

note: type: Content of: <p>
en: Beware, the first line and column are numbered 0 and not 1, and the point (0,0)  is on the top left corner. This may seem surprising, but it is very often so in Computer Science.
pt: Cuidado, a primeira linha e coluna são numeradas com 0 e não com 1 e o ponto (0,0) fica no canto superior esquerdo. Isto pode parecer estranho, mas é bem comum em ciência da computação.

note: type: Content of: <p>
en: Then, you have to write the code to reach the next position. In this exercise, you have to traverse the world row after row. So, if you are at the bottom of a row, you have to move to the top of next row. Else, you have to move to the cell below.
pt: Então, tem que escrever o código para alcançar a próxima posição. Neste exercício, tem que percorrer o mundo linha após linha. Logo, se está no fundo de uma linha, tem que mover ao topo da próxima, caso contrário tem que mover à célula abaixo.

note: type: Content of: <p>
en: At this point, you can launch your program to check that the buggle correctly traverse the world in the expected order, and that it stops when it has to. Use the <b>stop</b> button if the buggle does not stop correctly.
pt: Neste ponto, pode lançar o seu programa para verificar se o buggle percorre corretamente o mundo na ordem esperada e que pára quando tem que parar. Use oo botão <b>stop</b> se o buggle não parar corretamente.

note: type: Content of: <p>
en: It is now time to write down the cell numbers. For that, you will need a counter initialiser to zero at the beginning of your code, and incremented by one at each step (for example with <code>counter += 1;</code>).  Then, you have to use <code>writeMessage()</code> to write the value on the ground.
pt: Agora é hora de escrever os números das células. Para isto, vai precisar de um contador a iniciar em zero no começo do seu código e incrementar de um em cada passo (por exemplo com <code>counter += 1;</code>).  Então, terá que usar <code>writeMessage()</code> para escrever o valor no chão.

note: type: Content of: <p>
en: You probably need to write the first [!java|scala|c]or last [/!]value out of the main loop [!java|scala|c], depending on whether you prefer to use a <code>while</code> or a <code>do/while</code> one[/!].
pt: Provavelmente vai precisar escrever o primeiro [!java|scala|c]ou último [/!]valor fora do loop principal [!java|scala|c], a depender se prefere usar um <code>while</code> ou um <code>do/while</code>[/!].

note: type: Content of: outside any tag (error?)
en: You once again have to let the buggle traverse the world numbering the cells on its way, but the goal of this exercise is to write a line traversal. Most of the code you wrote for previous exercise remains usable here. Simply, the method computing the coordinates of the next buggle position has to be correctly updated: if you are at the right of a line, you have to go to the beginning of the next one. If not, you have to go to the right cell.
pt: Mais uma vez terá que deixar o buggle percorrer o mundo a numerar as células no caminho, mas o objetivo do exercício é escrever uma linha transversal. A maioria do código que escreveu para exercícios anteriores continua útil aqui. Simplesmente, o método a calcular as coordenadas da próxima posição do buggle tem que ser atualizado corretamente: se estiver a direita de uma linha, terá que ir ao começo da próxima. Senão, terá que ir à célula da direita.

note: type: Content of: <p>
en: This time, you are asked to traverse the world one diagonal after the other. Have a look at the objective world for more details on the requested traversal order.
pt: Agora é para atravessar o mundo uma diagonal depois da outra. Dê uma olhada no mundo objetivo para maiores detalhes quanto à ordem a percorrer pedida.

note: type: Content of: <p>
en: You may find useful to use an integer variable <code>diag</code> storing the number of the diagonal you are traversing.
pt: Pode ser útil usar uma variável inteira <code>diag</code> a guardar o número da diagonal que está a atravessar.

note: type: Content of: outside any tag (error?)
en: This time, you have to zigzag on the way up. Have a look at the objective world for more details on the requested traversal order.
pt: Desta vez, vai ter que fazer um zigzag no caminho para cima. Dê uma olhada no mundo objetivo para mais detalhes da ordem a percorrer pedida.

note: type: Content of: <h2>
en: Lost in the Moria
pt: Perdido em Moria

note: type: Content of: <p>
en: You buggles got stuck in the mines of Moria! Some rocks are blocking the exit, and you will have to clear your way to the exit. Well of course these are only baggles and you could simply walk away, but it will be easier to program the buggles so that they move those "rocks" than convincing them to walk away without solving the problem. Dwarfs are sometimes really stubborns...
pt: Os seus buggles ficaram presos nas minas de Moria! Algumas pedras estão a bloquear a saída e terá que limpar o seu caminho para a saída. Bem, é claro que são apenas baggles e pode simplesmente sair a andar, mas será mais fácil programar os buggles de forma que mova estas "pedras" do que convencer-los que ele pode sair a andar facilmente sem resolver o problema. Anões podem ser bem teimosos...

note: type: Content of: <p>
en: So, you have to find the first baggle blocking the exit (simply walk to the east until you are over a baggle), take it and move it back to the other side of the tunnel (walk to the west while you are not over a baggle, and then move back one step to the east and drop your baggle), and iterate until you find the exit (that is, the wall to the east side). Afterward, move out as in the objective world. That's only a few more steps away.
pt: Bem, tem que encontrar o primeiro baggle a bloquear a saída (simplemente ande para o leste até que esteja sobre um baggle), leve-o e mova para o outro lado do túnel (ande para o oeste enquanto ainda não estiver sobre um baggle e depois mova-se de volta um passo para o leste e solte o seu baggle) e repita até encontrar a saída (ou seja, a parede com o muro para o lado leste). Depois disto, mova-se para fora como no mundo objetivo. São só mais uns passos.

note: type: Content of: <p>
en: To make things worse, you have to write a program that works for every buggle, even if writing a specific program for each of them would be easier. It seems that using <code>while</code> loops is the only solution to move the buggles correctly.
pt: Para piorar ainda mais as coisas, tem que escrever um programa que funcione para qualquer buggle, mesmo se escrever um programa específico para cada um deles for mais fácil. Parece que usar loops <code>while</code> é a única solução para mover os buggles corretamente.

note: type: Content of: <p>
en: Once you manage to escape this trap, you can move forward to the next exercise.  This exercise is a bit more complex, so you can also leave it for now and come back later if you don't get it right now.
pt: Quando conseguir escapar desta armadilha, poderá avançar para o próximo exercício.  Este exercício é um pouco mais complexo, então também pode esperar e voltar mais tarde se não o conseguir agora mesmo.

note: type: Content of: <h3>
en: The turmites
pt: Os turmites

note: type: Content of: <p>
en: This set of activities lets you play with Langton's ants, that are 2D turing machines. They constitute very simple application problems, achievable by beginners, and open the door to an amazing world.
pt: Este conjunto de atividades é para brincar com formigas de Langton, que são máquinas de Turing 2D. Elas constituem problemas bem simples, bons para iniciantes e abrem as portas para um mundo fantástico.

note: type: Content of: <p>
en: This mechanism were invented in 1986 by Chris Langton, and later generalized in several ways (as we shall see in the next exercises). It was proven that Turmites and Turing machines are of equal power: An ant's trajectory can be used to compute any boolean circuit, and thus that an ant is capable of universal computation. Put simply, any possible computation can be achieved using a turmite as a computing device. Yet another subject of fascination...
pt: Este mecanismo foi inventado em 1986 por Chris Langton e depois generalizado em várias formas (como veremos nos próximos exercícios). Foi provado que Turmites e máquinas de Turing têm o mesmo poder: Uma trajetória de formiga pode ser usada para calcular qualquer circuito booleano e logo uma formiga é capaz de qualquer cálculo universal. a resumir, qualquer cálculo possível pode ser alcançado a usar uma turmite como aparelho computacional. Ainda outro assunto fascinante...

note: type: Content of: <p>
en: Multicolor Langton's ants were discovered in 1995 by Propp et Al. Another funny fact is that the ants which name is a list of consecutive pair of identical letters (LL and RR) produce symmetric patterns. This fact was even formally proved.
pt: formigas de Langton multicoloridas foram descobertas em 1995 por Propp et Al. Outro fato divertido é que as formigas cujos nomes é uma lista de pares consecutivos de letras idênticas (LL e RR) produzem padrões simétricos. Este fato foi até mesmo provado formalmente.

note: type: Content of: <p>
en: Check the corresponding wikipedia web page, of which this exercise is inspired, for further details.
pt: Verifique a página da wikipédia correspondente, na qual este exercício é inspirado, para maiores detalhes.

note: type: Content of: <h3>
en: What can I do to improve this PLM universe?
pt: O que posso fazer para melhorar este universo do PLM?

note: type: Content of: <p>
en: As usual, there are several things that could be done in the code of this universe to improve it:
pt: Como sempre, existem várias coisas que podem ser feitas no código deste universo para melhorá-lo:

note: type: Content of: <ul><li>
en: We are probably missing some good exercises. The turmite creator exercise is a bit harsh: we could introduce the patterns in a more friendly manner.
pt: Alguns bons exercícios estão provavelmente a faltar. O exercício de criador de turmite é um pouco pé-duro: podemos introduzir os padrões de uma forma mais amigável.

note: type: Content of: <ul><li>
en: We may want to write an exercise on the busy beaver, maybe?
pt: Quem sabe não escrevemos um exercício sobre os "busy beavers"?

note: type: Content of: <p>
en: Discover the Langton's ants, that are 2D turing machines.
pt: Descubra as formigas de Langton, que são máquinas de Turing 2D.

note: type: Content of: <p>
en: These activities are very simple application problems, achievable by beginners, and open the door to an amazing world.
pt: Estas atividades são problemas bem simples, bons para iniciantes e abrema a porta para um mundo fantástico.

note: type: Content of: <h2>
en: Langton's ant
pt: formiga de Langton

note: type: Content of: <p>
en: In this exercise, you will turn your buggle into a <i>Langton's ant</i>. These artificial little animals are very interesting because they are given simple rules that depend only on their local environment, and after a period of apparent chaotic behavior, a general pattern <i>emerges</i>.
pt: Neste exercício, vai transformar o seu buggle numa <i>formiga de Langton</i>. Estes pequenos animais artificiais são bastante interessantes por que eles recebem regras simples que dependem apenas do seu ambiente local e depois de um período de aparente comportamento caótico, um modelo geral <i>surge</i>.

note: type: Content of: <p>
en: The rules are absolutely trivial: to compute what the next step should be, you should check the current color of the ground (using <code>getGroundColor()</code>). If it's white, change it to black, turn right and move forward by one cell. If the ground is currently black, change it to white, turn left and move forward by one cell.
pt: As regras são absolutamente triviais: para calcular qual o próximo passo, verifique a cor atual do chão (a usar <code>getGroundColor()</code>). Se for branco, mude para preto, vire à direita e mova uma célula. Se for preto mude para branco, vire a esquerda e ande uma célula.

note: type: Content of: <p>
en: It's hard to come up with simpler rules isn't it? Well, let's go and code it now. You have to complete the <code>step()</code> method, which encodes the behavior of the ant at each step. You will probably use the <code>getGroundColor()</code> method to retrieve the color of the cell on which the ant is currently.  Colors of interest are simply named <code>Color.black</code> and <code>Color.white</code>.
pt: Difícil encontrar regras mais simples, não é? Bem, vamos em frente codificar isto agora. Precisa completar o método <code>step()</code>, que codifica o comportamento da formiga em cada passo. Vai provavelmente usar o método <code>getGroundColor()</code> para recuperar a cor da célula na qual a formiga está no momento. Cores úteis são nomeadas simplesmente de <code>Cor.preto</code> e <code>Cor.branco</code>.

note: type: Content of: <p>
en: To compare colors, you cannot use the equal signs (==), because these things are not scalar values but objects. Instead, you need to write something like the following:
pt: Para comparar cores, não pode usar o símbolo de igualdade (==), pois estas coisas não são valores escalares, mas objetos. Ao invés disto, precisa escrever algo como o seguinte:

note: type: Content of: <pre>
en: Color c /* = some initialization */;
    if (c.equals(Color.black)) {
      /* that's equal */
    } else {
      /* that was not equal */
    }
pt: Cor c /* = alguma inicialização */;
    if (c.equals(Cor.preto)) {
      /* é igual */
    } else {
      /* não é igual */
    }

note: type: Content of: <p>
en: Changing the ground color is not difficult, but a bit long: you have to change the brush color of your buggle, set the brush down (to mark the current cell -- with <code>brushDown()</code>), and set the brush back up (with <code>brushUp()</code>) to avoid further issues when the buggle will move. You are naturally free of organizing your code the way you want, but you may want to write a <code>setGroundColor(color)</code> method to factorize things a bit.
pt: Mudar a cor do chão não é difícil, mas meio demorado: tem que mudar a cor do pincel do seu buggle, baixar o pincel (para marcar a célula atual -- com <code>brushDown()</code>) e levantar o pincel de novo (com <code>brushUp()</code>) para evitar problemas quando o buggle se mexer. É, naturalmente, livre para organizar o seu código da forma que quiser, mas deve querer escrever um método <code>setGroundColor(color)</code> para separar um pouco as coisas.

note: type: Content of: <p>
en: As you can see from the execution of this exercise, the interest in this algorithm is that after about 10000 steps of relative chaotic behavior, the ant start building a regular pattern. This emergence of a regular pattern from the chaos is rather fascinating, isn't it? Move on to the next exercise to see more of them.
pt: Como pode ver da execução deste exercício, o interessante neste algoritmo é que depois de uns 10000 passos de comportamento relativamente caótico, a formiga começa a construir um modelo regular. O surgimento deste modelo regular em meio ao caos é bastante fascinante, não acha? Mova para o próximo exercício para ver mais disto.

note: type: Content of: <h2>
en: Multicolor Langton's ant
pt: formiga de Langton multicolorida

note: type: Content of: <p>
en: There is several ways to extend the concept of Langton's ant. In this exercise, we explore first one, using more than two colors. It remains very similar to the base case: the behavior at each step still depends on the ground color, but you have more than 2 possibilities. It allows to have more than one kind of ant, depending on what you decide to do for each color. For example, the ant LRL takes 3 colors. It turns left on the first color, right on the second one and left on the third color. According to this definition, the basic ant is a RL (since it turns right on white cells and left on black ones).
pt: Existem várias formas de extender o conceito de formiga de Langton. Neste exercício, vamos explorar a primeira, a usar mais que duas cores. Ela se mantem muito similar ao caso base: o comportamento em cada passo ainda depende da cor do chão, mas tem mais que duas possibilidades. Pode ter mais que um tipo de formiga, a depender do que decide fazer para cada cor. Por exemplo, a formiga LRL recebe 3 cores. Ela vira a esquerda na primiera cor, a direita na segunda e a esquerda na terceira. De acordo com esta definição, a formiga básica é uma RL (já que ela vira a direita em células brancas e a esquerda em pretas).

note: type: Content of: <p>
en: Some of these ants draw fascinating patterns (switch the world to see them): LLRR build a symmetric figure resembling loosely to a ball, LRRRRRLLR draws a square, LLRRRLRLRLLR draws a convoluted regular pattern after a period of seemingly chaotic behavior, and RRLLLRLLLRRR seems to fill a hour glass...
pt: Algumas destas formigas desenham padrões fascinantes (alterne o mundo para vê-los): LLRR constrói uma figura simétrica semelhante a uma bola, LRRRRRLLR desenha um quadrado, LLRRRLRLRLLR desenha um padrão regular convolucionado depois de um período de aparente caos e RRLLLRLLLRRR parece preencher uma ampulheta...

note: type: Content of: <p>
en: Changing your buggle into a generic Langton's ant is not very complicated, although it is not completely trivial. As previously, you have to write a <code>step</code> function. But this time, it receives two arrays as parameters.  The first one defines the rules to follow depending on the ground color while the second one gives the sequence of colors to use. For example, the basic ant would have [!java]<code>{'R', 'L'}</code> and <code>{Color.white, Color.black}</code>[/!] [!python]<code>['R', 'L']</code> and <code>[Color.white, Color.black]</code>[/!] [!scala]<code>Array('R', 'L')</code> and <code>Array(Color.white, Color.black)</code>[/!] as arguments.
pt: Transformar o seu buggle numa formiga de Langton genérica não é muito complicado, embora não seja totalmente trivial. Como anteriormente, tem que escrever uma função <code>step</code>. Mas desta vez, ela recebe duas arrays como parâmetros. A primeira define as regras para seguir a depender da cor do chão enquanto a segunda dá a sequência de cores a usar. Por exemplo, a formiga básica deve ter [!java]<code>{'R', 'L'}</code> e <code>{Cor.branco, Cor.preto}</code>[/!] [!python]<code>['R', 'L']</code> e <code>[Cor.branco, Cor.preto]</code>[/!] [!scala]<code>Array('R', 'L')</code> e <code>Array(Cor.branco, Cor.preto)</code>[/!] como argumentos.

note: type: Content of: <p>
en: At each step, you thus have to apply the following pseudo-code:
pt: Em cada passo, deve então ter que aplicar o seguinte pseudo-código:

note: type: Content of: <ul><li>
en: Find the position of the ground color in the color sequence;
pt: Encontre a posição da cor do chão na sequência de cores;

note: type: Content of: <ul><li>
en: Turn left or right depending on the content of the rule array at that position;
pt: Vire a esquerda ou direita a depender do conteúdo da array de regras nesta posição;

note: type: Content of: <ul><li>
en: Mark the current ground with the next color in the sequence (the last color being followed by the first one);
pt: Marque o chão com a próxima cor na sequência (a cor seguinte à última é a primeira);

note: type: Content of: <ul><li>
en: Move forward by one step.
pt: ande um passo para frente.

note: type: Content of: <p>
en: You now should have enough information to succeed.
pt: Agora tem informação o suficiente para conseguir.

note: type: Content of: <p>
en: This exercise explores a new way to extend the concept of Langton's ant. Now, the behavior of the ant not only depends on the color on the ground, but also on its internal state (represented by an integer value). The idea of changing the ant into such an automata naturally comes from the Turing machine concept. This explains the name of these new animals, which is a portemanteau of <i>Turing</i> and <i>Termite</i> (if you don't know what a Turing machine is, you should run to wikipedia, because it is simply impossible to be a real computer scientist before that).
pt: Este exercício explora uma nova forma de extender o conceito de formiga de Langton. Agora, o comportamento da formiga não depende apenas da cor no chão, mas também do estado interno dela (representado por um valor inteiro). A ideia de transformar a formiga num autômato vem naturalmente do conceito de máquina de Turing. Isto explica o nome destes novos animais, que é um amálgama de <i>Turing</i> e <i>Termite</i> (se não sabe o que uma máquina de Turing é, vá à wikipédia, por que é impossível ser um cientista da computação de verdade sem conhecê-la).

note: type: Content of: <p>
en: Once again, you just have to write the <code>step()</code> method, in charge of doing one turmite's step. Once again, you should first find the rank of the current's cell ground color in the color sequence. But this time, the <code>rule</code> data depends both on the current color and the current state.  <code>rule</code> actually contains 3 information in each situation: the color to write, the move to do, and the next state value. For example, [!java|python]rule[1][0][/!][!scala]rule(1)(0)[/!] contains the informations to use when <code>state==1</code> and <code>color==0</code>.  In other worlds, you can retrieve the information relative to your current situation by using <code>[!java|python]rule[state][currentColor][/!][!scala]rule(state)(currentColor)[/!]</code>.
pt: Novamente, tem que simplesmente escrever o método <code>step()</code>, encarregado de fazer o turmite dar um passo. Novamente, deve primeiro encontrar o rank da cor do chão da célula atual na sequência de cores. Mas agora, os dados de <code>rule</code> (regras) dependem tanto da cor atual quanto do estado atual. A <code>rule</code> na verdade contém 3 informações em cada situação: a cor que a escreve, o movimento a fazer e o valor do próximo estado. Por exemplo, [!java|python]rule[1][0][/!][!scala]rule(1)(0)[/!] contém as informações para usar quando <code>state==1</code> e <code>color==0</code>. Em outros mundos, pode recuperar a informação relativa à sua situação atual a usar <code>[!java|python]rule[state][currentColor][/!][!scala]rule(state)(currentColor)[/!]</code>.

note: type: Content of: <p>
en: Each such information set contains 3 values. The first one is the rank of the color to write on the ground. The second is the move to do, with the following notation: 0=stop, 1=noturn, 2=left, 4=u-turn, 8=right. Note that if the command is stop, you shouldn't even move forward on that step (but you shouldn't stop your program either: the next steps can do something else in a future state). Finally, the third integer is the next <code>state</code> value to go into after this iteration.
pt: Cada um destes conjuntos de informações contém 3 valores. O primeiro é o rank da cor para escrever no chão. O segundo é o movimento para fazer, com a seguinte notação: 0=stop, 1=noturn, 2=left, 4=u-turn, 8=right. Observe que se o comando é stop, não se pode mover nem para a frente neste passo (mas também não pode parar o programa: os próximos passos podem fazer algo mais num estado futuro). Finalmente, o terceiro inteiro é o próximo valor do <code>state</code> a ir dentro da próxima iteração.

note: type: Content of: <p>
en: Since these arbitrary notations are somehow difficult to remember, you should define a set of constants that you should use instead of the direct numerical values.  Their names could be NOTURN, LEFT, RIGHT and so on.  [!scala]Just declare them using the keyword <code>val</code> instead of <code>var</code>.  You should always use <code>val</code> instead of <code>var</code> when possible anyway.[/!] [!java]The modifiers <code>final static</code> before their type is the way to mark variables as constant in Java.  You should write for example <code>static final int NOTURN=1;</code> Sorry for the complexity of this notation. [/!] [!python]By convention, such constant variables are written in upper case in python.  Technically, you can still modify them, but that would be a very bad idea.[/!] You should write them out of any method so that they are globally visible.
pt: Uma vez que estas notações arbitrárias são de certa forma difíceis de lembrar, deve definir um conjunto de constantes que deve usar no lugar dos valores numéricos diretos. Os nomes deles podem ser NOTURN, LEFT, RIGHT etc. [!scala]Simplesmente declare-as a usar keyword <code>val</code> no lugar de <code>var</code>.  Deve sempre usar <code>val</code> no lugar de <code>var</code> quando possível de qualquer forma.[/!] [!java]Os modificadores <code>final static</code> antes do tipo dele é a forma de marcar variáveis como constantes em Java. Deve escrever, por exemplo, <code>static final int NOTURN=1;</code> Desculpe pela complesxidade desta notação. [/!] [!python]Por convenção, tais variáveis constantes são escritas em maiúsculas no python.  Tecnicamente, ainda pode modificá-las, mas isto é uma má ideia.[/!] Deve escrevê-las fora de qualquer método para que elas se tornem visíveis globalmente.

note: type: Content of: <p>
en: Using such constants greatly help making the code easier to read. Compare the next two code chunks:
pt: Usar tais constantes ajuda em muito a fazer o código mais legível. Compare os dois blocos de código a seguir:

note: type: Content of: <p>
en: This is much more easier to read (although longer) than the following:
pt: Isto é muito mais fácil de se ler (embora seja mais longo) do que o seguinte:

note: type: Content of: <p>
en: Finally, you probably want to write a <code>elif</code> branch for the <code>STOP</code> condition too. Having a <code>else</code> branch displaying an error message such as "unknown case" is a good practice: it makes your assumptions about your code more explicit, and you will get an error message if they fall short. When doing so, the next problem is that you have nothing to do in the <code>STOP</code> case, but python do not allows you to write empty <code>elif</code> branches. You should use the <code>pass</code> instruction as a placeholder: it says python that you have a branch here, and that it does not contain anything.
pt: Finalmente, provavelmente vai escrever um ramo <code>elif</code> para a condição <code>STOP</code> também. Ter um ramo <code>else</code> a mostrar uma mensagem de erro tal como "unknown case" é uma boa prática: faz as suas suposições sobre o seu código mais explícitas e tem uma mensagem de erro se elas falharem. Quando fizer isto, o próximo problema vai ser que não tem nada para fazer no caso do <code>STOP</code>, mas python não permite que escreva ramos <code>elif</code> vazios. Deve usar a instrução <code>pass</code> como substituto, que diz ao python que tem um ramo aqui e que não faz nada.

note: type: Content of: <p>
en: You should probably use a [!java]switch case[/!][!scala]pattern matching[/!] construct to keep your code readable.  If you can't remember what it is, check <a href="plm://lessons.welcome/bdr.BDR2">this exercise</a>.
pt: Provavelmente deve usar uma construção [!java]switch case[/!][!scala]pattern matching[/!] para manter o seu código legível. Se não se lembra o que isto é, veja <a href="plm://lessons.welcome/bdr.BDR2">este exercício</a>.

note: type: Content of: <h2>
en: Bibliographical notes
pt: Notas bibliográficas

note: type: Content of: <p>
en: According to wikipedia, turmites were invented independently by the end of the eighties. It has been shown that turmites in general are exactly equivalent in power to one-dimensional Turing machines with an infinite tape, as either can simulate the other. This means that absolutely any program that you can think of could theoretically be computed on this device...
pt: De acordo com a wikipédia, os turmites foram inventados independentemente no final dos anos oitenta. Foi provado que turmites em geral são exatamente equivalentes em capacidade a máquinas de turing uni-dimensionais com uma fita infinita, pois um pode simular o outro. Isto significa que qualquer programa que possa conceber pode teoricamente ser executado neste aparelho...

note: type: Content of: <h2>
en: Creating Turmites
pt: Criar Turmites

note: type: Content of: <p>
en: This exercise allows you to build your own turmites. To pass the exercise, you should simply write a <code>init()</code> method which initializes the <code>rule</code> to use the following transitions table (from wikipedia), set the buggle initial position at (8;33), and ask for 8342 steps.
pt: Este exercício permite que construa os seus próprios turmites. Para passar neste exercício, deve simplesmente escrever um método <code>init()</code> que inicializa a <code>rule</code> para usar a seguintes tabela de transições (da wikipédia), configure a posição inicial em (8;33) e peça por 8342 passos.

note: type: Content of: <table><tr><th>
en: Current color
pt: Cor atual

note: type: Content of: <table><tr><th>
en: Write color
pt: Escrever cor

note: type: Content of: <table><tr><th>
en: Next state
pt: Próximo estado

note: type: Content of: <table><tr><th>
en: Current state
pt: Estado atual

note: type: Content of: <p>
en: where the direction to turn is one of <b>L</b> (90° left), <b>R</b> (90° right), <b>N</b> (no turn) and <b>U</b> (180° U-turn).
pt: Onde a direção para virar é <b>L</b> (90° à esquerda), <b>R</b> (90° à direita), <b>N</b> (não vira) e <b>U</b> (meia-volta).

note: type: Content of: <h2>
en: Going further
pt: Ir mais longe

note: type: Content of: <p>
en: This exercise is naturally an excuse to let you experiment with your own turmites.  Feel free to change the transition table and the amount of steps to experiment by yourself. To that extend, you may find the Ed Pegg Jr's library useful. If you find new interesting patterns, send them per email so that we can integrate them to this list!
pt: Este exercício é naturalmente uma desculpa para deixá-lo experimentar com os seus próprios turmites. Sinta-se à vontade para mudar a tabela de transições e a quantidade de passos por conta própria. Nesta altura, pode se interessar pela biblioteca de Pegg Jr. Se encontrar novos padrões interessantes, envie-os por email para que eles possam integrar a lista!

note: type: Content of: <p>
en: In addition, wikipedia is desperately missing some good looking colorful turmites: only black and white ones are depicted.  You should consider submitting your creations directly to the free encyclopedia.
pt: Adicionalmente, a wikipédia está a precisar desesperadamente de alguns turmites coloridos bem apresentáveis: apenas os preto e branco estão descritos. Deveria considerar a possibilidade de enviar as suas criações diretamente à enciclopédia livre.

note: type: Content of: <p>
en: Here are some 2-color turmites, extracted from http://demonstrations.wolfram.com/Turmites/ [!python|scala]They are not written using the [!thelang] syntax, but converting them should be easy.[/!]
pt: Aqui estão alguns turmites de 2 cores, extraídos de http://demonstrations.wolfram.com/Turmites/ [!python|scala]Eles não foram escritos a usar o sintaxe de [!thelang], mas convertê-los não deve ser difícil.[/!]

note: type: Content of: <pre>
en: {{{1, RIGHT , 0}, {0, LEFT  , 0}}}  # 1: Langton's ant
    {{{1, RIGHT , 0}, {0, NOTURN, 0}}}  # 2: binary counter
    {{{0, LEFT  , 1}, {1, RIGHT , 1}}, {{1, NOTURN, 0}, {1, NOTURN, 1}}} # 3: (filled triangle)
    {{{0, NOTURN, 1}, {0, LEFT  , 1}}, {{1, RIGHT , 0}, {0, NOTURN, 1}}} # 4: spiral in a box
    {{{0, RIGHT , 1}, {0, LEFT  , 0}}, {{1, LEFT  , 1}, {0, RIGHT , 0}}} # 5: stripe-filled spiral
    {{{0, RIGHT , 1}, {0, LEFT  , 0}}, {{1, LEFT  , 1}, {1, NOTURN, 0}}} # 6: stepped pyramid
    {{{0, RIGHT , 1}, {0, NOTURN, 1}}, {{1, RIGHT , 1}, {1, LEFT  , 0}}} # 7: contoured island
    {{{0, RIGHT , 1}, {0, RIGHT , 1}}, {{1, NOTURN, 0}, {0, RIGHT , 1}}} # 8: woven placemat
    {{{0, RIGHT , 1}, {1, RIGHT , 1}}, {{1, LEFT  , 1}, {1, LEFT  , 0}}} # 9: snowflake-ish
    {{{1, LEFT  , 0}, {0, NOTURN, 1}}, {{0, LEFT  , 0}, {0, LEFT  , 1}}} # 10: slow city builder
    {{{1, LEFT  , 0}, {1, RIGHT , 1}}, {{0, RIGHT , 0}, {0, LEFT  , 1}}} # 11: framed computer art
    {{{1, LEFT  , 0}, {1, RIGHT , 1}}, {{0, RIGHT , 1}, {1, LEFT  , 0}}} # 12: balloon bursting (makes a spreading highway)
    {{{1, LEFT  , 1}, {0, LEFT  , 0}}, {{1, NOTURN, 0}, {0, NOTURN, 0}}} # 13: makes a horizontal highway
    {{{1, LEFT  , 1}, {0, LEFT  , 0}}, {{1, RIGHT , 1}, {1, RIGHT , 0}}} # 14: makes a 45 degree highway
    {{{1, LEFT  , 1}, {0, LEFT  , 1}}, {{1, RIGHT , 1}, {0, LEFT  , 0}}} # 15: makes a 45 degree highway
    {{{1, LEFT  , 1}, {0, NOTURN, 0}}, {{1, NOTURN, 0}, {1, RIGHT , 0}}} # 16: spiral in a filled box
    {{{1, LEFT  , 1}, {0, RIGHT , 0}}, {{0, LEFT  , 0}, {0, LEFT  , 0}}} # 17: glaciers
    {{{1, LEFT  , 1}, {1, LEFT  , 1}}, {{1, RIGHT , 1}, {0, NOTURN, 0}}} # 18: golden rectangle!
    {{{1, LEFT  , 1}, {1, RIGHT , 0}}, {{0, LEFT  , 0}, {0, LEFT  , 0}}} # 19: fizzy spill
    {{{1, LEFT  , 1}, {1, RIGHT , 1}}, {{1, NOTURN, 0}, {0, NOTURN, 1}}} # 20: nested cabinets
    {{{1, NOTURN, 1}, {0, LEFT  , 1}}, {{1, RIGHT , 0}, {1, NOTURN, 1}}} # 21: (cross)
    {{{1, NOTURN, 1}, {0, NOTURN, 0}}, {{0, RIGHT , 0}, {1, LEFT  , 0}}} # 22: saw-tipped growth
    {{{1, NOTURN, 1}, {0, NOTURN, 1}}, {{1, RIGHT , 1}, {0, NOTURN, 0}}} # 23: curves in blocks growth
    {{{1, NOTURN, 1}, {0, RIGHT , 0}}, {{0, LEFT  , 0}, {0, LEFT  , 0}}} # 24: textured growth
    {{{1, NOTURN, 1}, {0, RIGHT , 1}}, {{1, LEFT  , 0}, {1, RIGHT , 0}}} # 25: (diamond growth)
    {{{1, NOTURN, 1}, {1, LEFT  , 0}}, {{1, RIGHT , 1}, {0, NOTURN, 0}}} # 26: coiled rope
    {{{1, RIGHT , 0}, {0, LEFT  , 1}}, {{1, LEFT  , 0}, {0, NOTURN, 1}}} # 27: (growth)
    {{{1, RIGHT , 0}, {0, LEFT  , 1}}, {{1, LEFT  , 0}, {0, RIGHT , 1}}} # 28: (square spiral)
    {{{1, RIGHT , 0}, {1, RIGHT , 1}}, {{0, NOTURN, 0}, {0, NOTURN, 1}}} # 29: loopy growth with holes
    {{{1, RIGHT , 1}, {0, LEFT  , 1}}, {{1, NOTURN, 0}, {0, NOTURN, 0}}} # 30: Lanton's Ant drawn with squares
    {{{1, RIGHT , 1}, {0, RIGHT , 0}}, {{0, LEFT  , 1}, {1, LEFT  , 0}}} # 31: growth with curves and blocks
    {{{1, RIGHT , 1}, {0, RIGHT , 0}}, {{0, NOTURN, 0}, {1, RIGHT , 1}}} # 32: distracted spiral builder
    {{{1, RIGHT , 1}, {0, RIGHT , 1}}, {{1, NOTURN, 0}, {1, NOTURN, 1}}} # 33: cauliflower stalk (45 deg highway)
    {{{1, RIGHT , 1}, {1, LEFT  , 1}}, {{1, RIGHT , 1}, {0, RIGHT , 0}}} # 34: worm trails (eventually turns cyclic!)
    {{{1, RIGHT , 1}, {1, NOTURN, 0}}, {{1, NOTURN, 0}, {0, NOTURN, 1}}} # 35: eventually makes a two-way highway!
    {{{1, RIGHT , 1}, {1, RIGHT , 0}}, {{0, NOTURN, 0}, {0, NOTURN, 0}}} # 36: almost symmetric mould bloom
    {{{1, RIGHT , 1}, {1, RIGHT , 0}}, {{0, RIGHT , 0}, {1, NOTURN, 1}}} # 37: makes a 1 in 2 gradient highway
    {{{1, RIGHT , 1}, {1, RIGHT , 1}}, {{1, LEFT  , 1}, {0, RIGHT , 0}}} # 38: immediately makes a 1 in 3 highway
    {{{0, RIGHT , 1}, {1, RIGHT , 1}}, {{0, LEFT  , 2}, {0, LEFT  , 0}}, {{1, RIGHT , 2}, {1, LEFT  , 0}}} # 39: squares and diagonals growth
    {{{1, LEFT  , 1}, {0, NOTURN, 0}}, {{0, RIGHT , 2}, {1, LEFT  , 0}}, {{1, RIGHT , 1}, {1, NOTURN, 0}}} # 40: streak at approx. an 8.1 in 1 gradient
    {{{1, LEFT  , 1}, {0, NOTURN, 2}}, {{0, RIGHT , 2}, {1, NOTURN, 1}}, {{1, RIGHT , 1}, {1, NOTURN, 0}}} # 41: streak at approx. a 1.14 in 1 gradient
    {{{1, LEFT  , 1}, {1, LEFT  , 1}}, {{1, NOTURN, 0}, {0, NOTURN, 2}}, {{0, LEFT  , 1}, {1, NOTURN, 1}}} # 42: maze-like growth
    {{{1, LEFT  , 2}, {0, RIGHT , 0}}, {{1, LEFT  , 0}, {0, RIGHT , 0}}, {{0, LEFT  , 0}, {0, LEFT  , 1}}} # 43: growth by cornices 
    {{{1, RIGHT , 0}, {0, RIGHT , 2}}, {{0, LEFT  , 0}, {0, RIGHT , 0}}, {{0, NOTURN, 1}, {1, LEFT  , 0}}} # 44: makes a 1 in 7 highway
    {{{1, RIGHT , 1}, {0, LEFT  , 0}}, {{1, RIGHT , 2}, {0, NOTURN, 0}}, {{1, LEFT  , 0}, {0, LEFT  , 0}}} # 45: makes a 4 in 1 highway
pt: {{{1, RIGHT , 0}, {0, LEFT  , 0}}}  # 1: formiga de Langton
    {{{1, RIGHT , 0}, {0, NOTURN, 0}}}  # 2: contador binário
    {{{0, LEFT  , 1}, {1, RIGHT , 1}}, {{1, NOTURN, 0}, {1, NOTURN, 1}}} # 3: (triâgulo preenchido)
    {{{0, NOTURN, 1}, {0, LEFT  , 1}}, {{1, RIGHT , 0}, {0, NOTURN, 1}}} # 4: espiral numa caixa
    {{{0, RIGHT , 1}, {0, LEFT  , 0}}, {{1, LEFT  , 1}, {0, RIGHT , 0}}} # 5: espiral stripe-filled
    {{{0, RIGHT , 1}, {0, LEFT  , 0}}, {{1, LEFT  , 1}, {1, NOTURN, 0}}} # 6: pirâmide inclinada
    {{{0, RIGHT , 1}, {0, NOTURN, 1}}, {{1, RIGHT , 1}, {1, LEFT  , 0}}} # 7: ilha contoured
    {{{0, RIGHT , 1}, {0, RIGHT , 1}}, {{1, NOTURN, 0}, {0, RIGHT , 1}}} # 8: woven placemat
    {{{0, RIGHT , 1}, {1, RIGHT , 1}}, {{1, LEFT  , 1}, {1, LEFT  , 0}}} # 9: floco de neve
    {{{1, LEFT  , 0}, {0, NOTURN, 1}}, {{0, LEFT  , 0}, {0, LEFT  , 1}}} # 10: construtor de cidades lento
    {{{1, LEFT  , 0}, {1, RIGHT , 1}}, {{0, RIGHT , 0}, {0, LEFT  , 1}}} # 11: framed computer art
    {{{1, LEFT  , 0}, {1, RIGHT , 1}}, {{0, RIGHT , 1}, {1, LEFT  , 0}}} # 12: balloon bursting (makes a spreading highway)
    {{{1, LEFT  , 1}, {0, LEFT  , 0}}, {{1, NOTURN, 0}, {0, NOTURN, 0}}} # 13: makes a horizontal highway
    {{{1, LEFT  , 1}, {0, LEFT  , 0}}, {{1, RIGHT , 1}, {1, RIGHT , 0}}} # 14: makes a 45 degree highway
    {{{1, LEFT  , 1}, {0, LEFT  , 1}}, {{1, RIGHT , 1}, {0, LEFT  , 0}}} # 15: makes a 45 degree highway
    {{{1, LEFT  , 1}, {0, NOTURN, 0}}, {{1, NOTURN, 0}, {1, RIGHT , 0}}} # 16: spiral in a filled box
    {{{1, LEFT  , 1}, {0, RIGHT , 0}}, {{0, LEFT  , 0}, {0, LEFT  , 0}}} # 17: glaciers
    {{{1, LEFT  , 1}, {1, LEFT  , 1}}, {{1, RIGHT , 1}, {0, NOTURN, 0}}} # 18: golden rectangle!
    {{{1, LEFT  , 1}, {1, RIGHT , 0}}, {{0, LEFT  , 0}, {0, LEFT  , 0}}} # 19: fizzy spill
    {{{1, LEFT  , 1}, {1, RIGHT , 1}}, {{1, NOTURN, 0}, {0, NOTURN, 1}}} # 20: nested cabinets
    {{{1, NOTURN, 1}, {0, LEFT  , 1}}, {{1, RIGHT , 0}, {1, NOTURN, 1}}} # 21: (cross)
    {{{1, NOTURN, 1}, {0, NOTURN, 0}}, {{0, RIGHT , 0}, {1, LEFT  , 0}}} # 22: saw-tipped growth
    {{{1, NOTURN, 1}, {0, NOTURN, 1}}, {{1, RIGHT , 1}, {0, NOTURN, 0}}} # 23: curves in blocks growth
    {{{1, NOTURN, 1}, {0, RIGHT , 0}}, {{0, LEFT  , 0}, {0, LEFT  , 0}}} # 24: textured growth
    {{{1, NOTURN, 1}, {0, RIGHT , 1}}, {{1, LEFT  , 0}, {1, RIGHT , 0}}} # 25: (diamond growth)
    {{{1, NOTURN, 1}, {1, LEFT  , 0}}, {{1, RIGHT , 1}, {0, NOTURN, 0}}} # 26: coiled rope
    {{{1, RIGHT , 0}, {0, LEFT  , 1}}, {{1, LEFT  , 0}, {0, NOTURN, 1}}} # 27: (growth)
    {{{1, RIGHT , 0}, {0, LEFT  , 1}}, {{1, LEFT  , 0}, {0, RIGHT , 1}}} # 28: (square spiral)
    {{{1, RIGHT , 0}, {1, RIGHT , 1}}, {{0, NOTURN, 0}, {0, NOTURN, 1}}} # 29: loopy growth with holes
    {{{1, RIGHT , 1}, {0, LEFT  , 1}}, {{1, NOTURN, 0}, {0, NOTURN, 0}}} # 30: Lanton's Ant drawn with squares
    {{{1, RIGHT , 1}, {0, RIGHT , 0}}, {{0, LEFT  , 1}, {1, LEFT  , 0}}} # 31: growth with curves and blocks
    {{{1, RIGHT , 1}, {0, RIGHT , 0}}, {{0, NOTURN, 0}, {1, RIGHT , 1}}} # 32: distracted spiral builder
    {{{1, RIGHT , 1}, {0, RIGHT , 1}}, {{1, NOTURN, 0}, {1, NOTURN, 1}}} # 33: cauliflower stalk (45 deg highway)
    {{{1, RIGHT , 1}, {1, LEFT  , 1}}, {{1, RIGHT , 1}, {0, RIGHT , 0}}} # 34: worm trails (eventually turns cyclic!)
    {{{1, RIGHT , 1}, {1, NOTURN, 0}}, {{1, NOTURN, 0}, {0, NOTURN, 1}}} # 35: eventually makes a two-way highway!
    {{{1, RIGHT , 1}, {1, RIGHT , 0}}, {{0, NOTURN, 0}, {0, NOTURN, 0}}} # 36: almost symmetric mould bloom
    {{{1, RIGHT , 1}, {1, RIGHT , 0}}, {{0, RIGHT , 0}, {1, NOTURN, 1}}} # 37: makes a 1 in 2 gradient highway
    {{{1, RIGHT , 1}, {1, RIGHT , 1}}, {{1, LEFT  , 1}, {0, RIGHT , 0}}} # 38: immediately makes a 1 in 3 highway
    {{{0, RIGHT , 1}, {1, RIGHT , 1}}, {{0, LEFT  , 2}, {0, LEFT  , 0}}, {{1, RIGHT , 2}, {1, LEFT  , 0}}} # 39: squares and diagonals growth
    {{{1, LEFT  , 1}, {0, NOTURN, 0}}, {{0, RIGHT , 2}, {1, LEFT  , 0}}, {{1, RIGHT , 1}, {1, NOTURN, 0}}} # 40: streak at approx. an 8.1 in 1 gradient
    {{{1, LEFT  , 1}, {0, NOTURN, 2}}, {{0, RIGHT , 2}, {1, NOTURN, 1}}, {{1, RIGHT , 1}, {1, NOTURN, 0}}} # 41: streak at approx. a 1.14 in 1 gradient
    {{{1, LEFT  , 1}, {1, LEFT  , 1}}, {{1, NOTURN, 0}, {0, NOTURN, 2}}, {{0, LEFT  , 1}, {1, NOTURN, 1}}} # 42: maze-like growth
    {{{1, LEFT  , 2}, {0, RIGHT , 0}}, {{1, LEFT  , 0}, {0, RIGHT , 0}}, {{0, LEFT  , 0}, {0, LEFT  , 1}}} # 43: growth by cornices 
    {{{1, RIGHT , 0}, {0, RIGHT , 2}}, {{0, LEFT  , 0}, {0, RIGHT , 0}}, {{0, NOTURN, 1}, {1, LEFT  , 0}}} # 44: makes a 1 in 7 highway
    {{{1, RIGHT , 1}, {0, LEFT  , 0}}, {{1, RIGHT , 2}, {0, NOTURN, 0}}, {{1, LEFT  , 0}, {0, LEFT  , 0}}} # 45: makes a 4 in 1 highway

note: type: Content of: <p>
en: Langton's ants may not share the expressiveness power of the turmites, but they remain fascinating too. You can experiment with them using the initLangton() method, provided in your template, that allows to build a Turmite transition table from a Langton's ant name. Tiny changes in the ant may result huge changes. For example, "RRL" does not seem to lead to any constructed pattern, even after a million steps, but "RLL" starts building a very simple highway pattern after less than 100 steps!
pt: Formigas de Langton podem não compartilhar do poder de expressão dos turmites, mas ainda assim são fascinantes. Pode experimentar elas a usar o método initLangton(), fornecido no seu template, que permite construir uma tabela de transição do nome da formiga de Langton. Pequenas mudanças na formiga podem resultar em grandes mudanças. Por exemplo, "RRL" parece não levar a nenhum padrão, mesmo após um milhão de passos, mas "RLL" começa a construir um padrão de estrada muito simples depois de menos de 100 passos!

note: type: Content of: <p>
en: Quite a lot of Langton's ants build highways: RL, of course, but also RLRLRLLRLR (about 2500 steps).  The chaotic behavior of ants before the highway can be very short (as with RLL that only need 100 steps to converge) or very long, as with LLLLLLRRLRRR which seems chaotic for more than 500,000 steps before build the highway or even RRLLLRRRLRRR which needs 1170000 to start converging. Some are narrow, and others are very large, such as RRLRLLRLRR (200,000 steps). This ant is also notable since it is somehow squarish even before the highway start where most others do not show anything notable before their highway.
pt: Muitas das formigas de Langton constróem estradas: RL, claro, mas também RLRLRLLRLR (em cerca de 2500 passos). O comportamento caótico das formigas antes da estrada pode ser bastante curto (como no caso RLL que precisa de apenas 100 passos para convergir) ou muito longo, como LLLLLLRRLRRR que parece caótico até mais de 500.000 de passos antes de contruir a estrada, ou até mesmo RRLLLRRRLRRR que precisa de 1.170.000 para começar a convergir. Umas são estreitas e outras bem largas, como em RRLRLLRLRR (200,000 passos). Esta formiga é também notável pois é meio quadrada mesmo antes da estrada começar, enquanto que as outras não exibem nada de especial antes da estrada.

note: type: Content of: <p><p><p>
en: Some ants fill solid sectors, such as RRLLLRLLLRRR (16,000 steps), RRLLLRLLLRRR (30,000 steps), RRLLLRRRRRLR (125,000 steps) or RRLRLLRRRRRR (20,000 steps). Some even fill the whole space (RRLRR after 3000 steps). Some of my personal favorite ones are the ones where the ant seem to be bouncing within a box that gets bigger on each bump, such as LRRRRRLLR (30,000 steps). LRRRRLLLRRR is even more impressing since the bounces within the box are regular and since it converges more rapidly to its stable behavior (15,000 steps are enough).
pt: Algumas formiga preenchem setores sólidos, como RRLLLRLLLRRR(16,000 passos), RRLLLRLLLRRR (30,000 passos), RRLLLRRRRRLR (125,000 passos) ou RRLRLLRRRRRR (20,000 passos). Algumas preenchem até mesmo todo o plano (RRLRR depois de 3000 passos). algumas das minhas favoritas são aquelas onde as formigas parecem ricochetear desntro de uma caixa que vai a ficar maior em cada batida, como LRRRRRLLR (30,000 passos). LRRRRLLLRRR é ainda mais impressionante pois as ricocheteadas dantro da caixa são regulares e também por que ela converge mais rapidamente o comportamento estável dele (15,000 passos são suficientes).

note: type: Content of: <p><p><p>
en: Finally, some ants are just build artistic patterns. You should check this video for some beautiful ones: http://www.youtube.com/watch?v=1X-gtr4pEBU. If you want to convert them into your code, you have to shift them by one: For example, the one depicted at 3:42 is not RRLRLRLLRL, but RLRLRLLRLR (the first visible move should be read as last one).
pt: Finalmente, algumas formigas fazem padrões simplesmente artísticos. Pode verificar este vídeo com alguns deles: http://www.youtube.com/watch?v=1X-gtr4pEBU. Se quiser convertê-los em código, tem que transladar um caractere: por exemplo, aquele descrito no minuto 3:42 não será RRLRLRLLRL, mas sim RLRLRLLRLR (o primeiro movimento visível deve ser lido como o último).

note: type: Content of: <p><p><p>
en: As you can see by exploring the above set of turmites, they are usually not as colorful as the ants, but this may be because very few colors suffice to exhibit complex behaviors. For example, there is a specific class of turmites called <i>busy beavers</i> which are turmites that write a lot of things before stopping (busy beavers are usually classical turing machines, but the idea fits perfectly to turmites too). There is a sort of international competition where people strive to find the turmite that covers the biggest area before stopping. The web page is here: http://code.google.com/p/ruletablerepository/wiki/TwoDimensionalTuringMachines
pt: Como pode ver ao explorar o conjunto de turmites acima, elas não são tão coloridas quanto as formigas, mas isto pode ser por que poucas cores são o suficientes para exibir comportamentos complexos. Por exemplo, existe uma classe específica de turmites chamada <i>busy beavers</i> que são turmites que escrevem várias coisas antes de parar (busy beavers normalmente são máquinas de turing clássicas, mas a ideia encaixa perfeitamente em turmites também). Existe um tipode competição internacional onde as pessoas tentam encontrar o turmite que cobre a maior área antes de parar. A página é esta: http://code.google.com/p/ruletablerepository/wiki/TwoDimensionalTuringMachines

note: type: Content of: <h1>
en: Turmite universe
pt: Universo dos Turmites

note: type: Content of: <p>
en: This universe is very similar to the buggle one, but you will probably not use all buggles methods.  So, this page only recap the buggle methods that you will use.
pt: Este universo é bastante similar ao dos buggles, mas provavelmente não vai usar nenhum método dos buggles. Então, esta página apenas repacitula os métodos do buggle que vai usar.

note: type: Content of: <table><tr><td>
en: [!java|c]void [/!][!c]stepForward()[/!][!java|python|scala]forward()[/!] or [!java|c]void [/!]forward([!java|c]int [/!]steps[!scala]:Int[/!])
pt: [!java|c]void [/!][!c]stepForward()[/!][!java|python|scala]forward()[/!] ou [!java|c]void [/!]forward([!java|c]int [/!]passos[!scala]:Int[/!])

note: type: Content of: <table><tr><td>
en: [!java|c]void [/!][!c]stepBackward()[/!][!java|python|scala]backward()[/!] or [!java|c]void [/!]backward([!java|c]int [/!]steps[!scala]:Int[/!])
pt: [!java|c]void [/!][!c]stepBackward()[/!][!java|python|scala]back()[/!] ou [!java|c]void [/!]backward([!java|c]int [/!]steps[!scala]:Int[/!])

note: type: Content of: <h1>
en: Sorting World
pt: Mundo da ordenação

note: type: Content of: outside any tag (error?)
en: This world provides tools to experiment with the sorting algorithms. It can be used in two different ways: the first one is naturally to write the required sorting algorithms. But it is also possible to simply use the demo mode of each exercise to observe the behavior of sorting algorithms. It helps understanding the differences between each of them.
pt: Este mundo fornece ferramentas para experimentar com algoritmos de ordenação. Pode ser usado de duas formas diferentes: a primeira é naturalmente para escrever os algoritmos de ordenação necessários. Mas também é possível simplesmente usar o modo de demonstração de cada exercício para observar o comportamento de algoritmos de ordenação. Isto ajuda a entender as diferenças entre cada um deles.

note: type: Content of: <h2>
en: Methods available to sorting algorithms
pt: Métodos disponíveis para algoritmos de ordenação

note: type: Content of: <table><tr><td>
en: <b>Method</b>
pt: <b>Método</b>

note: type: Content of: <table><tr><td>
en: <b>Action</b>
pt: <b>Ação</b>

note: type: Content of: <table><tr><td>
en: <b>Cost</b>
pt: <b>Custo</b>

note: type: Content of: <table><tr><td>
en: Returns the amount of values in the array
pt: Retorna a quantidade de valores na array

note: type: Content of: <table><tr><td>
en: none
pt: nenhum

note: type: Content of: <table><tr><td>
en: [!java]boolean [/!][!c]int [/!]isSmaller([!java|c]int [/!]i[!scala]:Int[/!], [!java|c]int [/!]j[!scala]:Int[/!]) [!scala]:Boolean[/!]
pt: [!java]boolean [/!][!c]int [/!]éMenor([!java|c]int [/!]i[!scala]:Int[/!], [!java|c]int [/!]j[!scala]:Int[/!]) [!scala]:Boolean[/!]

note: type: Content of: <table><tr><td>
en: Returns true if the content of cell i is strictly smaller than the one of cell j
pt: Retorna true se o conteúdo da célula i é estritamente menor que o da célula j

note: type: Content of: <table><tr><td>
en: two reads
pt: duas leituras

note: type: Content of: <table><tr><td>
en: [!java]boolean [/!][!c]int [/!]isSmallerThan([!java|c]int [/!]i[!scala]:Int[/!], [!java|c]int [/!]value[!scala]:Int[/!])[!scala] :Boolean[/!]
pt: [!java]boolean [/!][!c]int [/!]éMenorQue([!java|c]int [/!]i[!scala]:Int[/!], [!java|c]int [/!]value[!scala]:Int[/!])[!scala] :Boolean[/!]

note: type: Content of: <table><tr><td>
en: Returns true if the content of cell i is strictly smaller than the <code>value</code>
pt: Retorna true se o conteúdo da célula i é estritamente menor que <code>valor</code>

note: type: Content of: <table><tr><td>
en: one read
pt: uma leitura

note: type: Content of: <table><tr><td>
en: [!java|c]void [/!]swap([!java|c]int [/!]i[!scala]:Int[/!], [!java|c]int [/!]j[!scala]:Int[/!])
pt: [!java|c]void [/!]alternar([!java|c]int [/!]i[!scala]:Int[/!], [!java|c]int [/!]j[!scala]:Int[/!])

note: type: Content of: <table><tr><td>
en: Swaps the content of cell i and the one of cell j
pt: Alterna ("swap") o conteúdo da célula i com o da célula j

note: type: Content of: <table><tr><td>
en: two reads, two writes
pt: duas escritas, duas leituras

note: type: Content of: <table><tr><td>
en: [!java|c]void [/!]copy([!java|c]int [/!]from[!scala]:Int[/!], [!java|c]int [/!]to[!scala]:Int[/!])
pt: [!java|c]void [/!]copia([!java|c]int [/!]de[!scala]:Int[/!], [!java|c]int [/!]para[!scala]:Int[/!])

note: type: Content of: <table><tr><td>
en: Copy the content of cell 'from' into the cell 'to'
pt: Copia o conteúdo da célula 'de' para a célula 'para'

note: type: Content of: <table><tr><td>
en: one read, one write
pt: uma leitura, uuma escrita

note: type: Content of: <table><tr><td>
en: [!java|c]int [/!]getValue([!java|c]int [/!]idx[!scala]:Int[/!])
pt: [!java|c]int [/!]getValor([!java|c]int [/!]idx[!scala]:Int[/!])

note: type: Content of: <table><tr><td>
en: Returns the value of cell idx
pt: Retorna o valor da célula idx

note: type: Content of: <table><tr><td>
en: [!java|c]void [/!]setValue([!java|c]int [/!]idx[!scala]:Int[/!], [!java|c]int [/!]value[!scala]:Int[/!])
pt: [!java|c]void [/!]setValor([!java|c]int [/!]idx[!scala]:Int[/!], [!java|c]int [/!]valor[!scala]:Int[/!])

note: type: Content of: <table><tr><td>
en: Sets cell 'idx' to the <code>value</code>
pt: Coloca na célula 'idx' o <code>valor</code>

note: type: Content of: <table><tr><td>
en: one write
pt: uma escrita

note: type: Content of: outside any tag (error?)
en: Returns whether the current world is selected in the graphical interface.
pt: Retorna true se o mundo atual está selecionado na interface gráfica.

note: type: Content of: <h2>
en: History view
pt: Visão do histórico

note: type: Content of: <p>
en: It is not enough to sort the array to pass the exercises. Your solution must strictly follow the expected behavior of each exercise. This is enforced by checking that your algorithm needs the same amount of read and write operations to sort the array. When they don't match, understanding the difference between your code and the expected solution can reveal very difficult.
pt: É suficiente ordenar a array para resolver os exercícios. A sua solução deve seguir estritamente o comportamento esperado em cada exercício. Isto é reforçado a verificar que o seu algoritmo precisa da mesma quantidade de operações de leitura e escrita para ordenar a array. Quando estas quantidades não coincidem, compreender a diferença entre o seu código e a solução esperada pode se mostrar bem difícil.

note: type: Content of: <p>
en: To help in this process, it is possible to graphically explore the history of your sorting algorithm. Switch to the Objective view and use the contextual menu (right click) to switch from the view of the current state to the view of its history.
pt: Para ajudar neste processo, é possível explorar graficamente o histórico do algoritmo de ordenação. Alternar à visão Objetivo e usar o menu de contexto (clique com botão direito) para alternar da visão do estado atual à visão do histórico.

note: type: Content of: <p>
en: The history view is a bit hairly at the first glance, but actually rather simple: The time flows from left to right on this graph, and each row is a cell of your array. The curved lines that go navigate between rows represent a given data value. When two lines cross, this means that two values were swapped at this time stamp; A line fork represent a value copy; When a value is magenta and followed by an interrogation mark (?), it was read using getValue(); If the value is red and followed with an exclamation point (!), it was written using setValue().
pt: A visão do histórico é um pouco bagunçada à primeira vista, mas na verdade é bem simples: o tempo anda da esquerda para a direita neste gráfico e cada linha é uma célula da sua array. As linhas curvas que navegam entre linhas representam um certo valor de um dado. Quando duas linhas se cruzam, significa que dois valores foram alternados agora; uma bifurcação numa linha representa uma cópia de valor; quando um valor é magenta e seguido de uma interrogação (?), foi lido a usar getValue(); Se o valor é vermelho e seguido de uma exclamação (!), foi escrito com setValor().

note: type: Content of: <p>
en: This view, inspired from Aldo Cortesi, reveals very helpful understand the inner behavior of sorting algorithms.
pt: Esta visão, inspirada por Aldo Cortesi, se mostra muito útil para entender o comportamento interno de algoritmos de ordenação.

note: type: Content of: <h3>
en: Sorting Algorithms
pt: Algoritmos de Ordenação

note: type: Content of: outside any tag (error?)
en: This lesson allows to experiment with some classical sorting algorithms (and some less common variant of them). The goal is two fold: you can first better understand the idea of these algorithms by writing them yourself. But even if you don't code the algorithms, you can use the demo mode to organize "races" between these algorithms to experiment in practice what the different asymptotical complexity mean.
pt: Esta lição permite a experimentação com alguns algoritmos de ordenação clássicos (e algumas variações menos comuns deles). E temos um duplo objetivo: pode primeiro compreender melhor a ideia destes algoritmos a escrever eles por si só. Mas mesmo se não codificar os algoritmos, pode usar o modo de demonstração para organizar "corridas" entre os algoritmos para experimentar na prática o que significam diferentes complexidades assintóticas.

note: type: Content of: <p>
en: More exercises are planned for the future, on recursive sorting algorithms (such as QuickSort and MergeSort) or using other microworlds to apply these algorithms to other contexts.
pt: Mais exercícios estão previstos para o futuro, sobre os algoritmos de ordenação recursivos (como o QuickSort e o MergeSort) ou a usar outros micromundos para aplicar estes algoritmos a outros contextos.

note: type: Content of: <ul><li>
en: Other graphical representations could be proposed, such as the ones presented at <a href="http://sorting.at/">http://sorting.at/</a>.
pt: Outras representações gráficas podem ser propostas, como aquelas apresentadas em <a href="http://sorting.at/">http://sorting.at/</a>.

note: type: Content of: <p>
en: This lesson allows to experiment with some classical sorting algorithms (and some less common variant of them :)
pt: Esta lição permite a experimentação com alguns algotimos de ordenação clássicos (e algumas variantes menos comuns deles :)

note: type: Content of: <p>
en: You are supposed to master the bases of programming to take this lesson.
pt: Para fazer esta lição deve dominar as bases da programação.

note: type: Content of: <p>
en: Welcome to the sorting universe. It allows you to experiment with the existing sorting algorithms. The list of buildins that you can use in your algorithms is available in the world reference documentation ("Help"-&gt;"About this world").
pt: Bem-vindo ao universo da ordenação. Ele permite que experimente os algoritmos de ordenação existentes. A lista de "buildins" que pode usar nos seus algoritmos está disponível na documentação de referência do mundo ("Ajuda"-&gt;"Sobre este mundo").

note: type: Content of: <p>
en: It is not enough to sort the array to pass the exercises. Your solution must strictly follow the expected behavior of each exercise. This is enforced by checking that your algorithm needs the same amount of read and write operations to sort the array.
pt: Não é suficiente ordenar a array para passar nos exercícios. A sua solução deve seguir estritamente o comportamento esperado em cada exercício. Isto é reforçado a verificar que o seu algoritmo precisa da mesma quantidade de operações de escrita e leitura para ordenar a array.

note: type: Content of: <p>
en: When your algorithm diverges from the expectation, understanding the difference between your code and the expected solution can reveal very difficult. To help in this process, it is posible to graphically explore the history of your sorting algorithm. Switch to the Objective view and use the contextual menu (right click)  to switch from the the view of the current state to the view of its history.
pt: Quando seu algoritmo divergge das expectativas, entender a diferença entre o seu código e a solução esperada pode ser muito difícil. Para ajudar neste processo, é possível explorar graficamente a história do seu algoritmo de ordenação. Alterne à visão Objetivo e use o menu contextual (clique com o botão direito) para alternar da visão do estado atual para a visão do histórico dele.

note: type: Content of: <h2>
en: First attempt at BubbleSort
pt: Primeira tentativa no BubbleSort

note: type: Content of: <p>
en: This first sorting algorithm is the most simple one: Bubble sort consists in progressively moving up the smaller elements of the array, as if they were air bubbles moving up to the surface of a liquid. The algorithm traverse the array, and compare any pair of adjacent elements. If two adjacent elements are wrongly sorted, they are swapped. Once the array was completely traversed, the operation starts again from the beginning. When no elements were sorted after a full traversal, it means that the array is completely sorted: the algorithm can stop.  Bubble sort is studied because of its simplicity, but it is almost never used in practice because of its bad performance (O(n^2) on average).
pt: O primeiro algoritmo de ordenação é o mais simples: Bubble sort consiste em progressivamente mover o menor elemento da array, como se fossem bolhas de ar a subir à superfície de um líquido. O algoritmo percorre a array e compara qualquer par de elementos adjacentes. Se dois elementos adjacentes estiverem fora de ordem, eles são alternados. Quando a array estiver completamente percorrida, a operação começa de novo do começo. Quando nenhum elemento for ordenado após uma passagem completa, significa que a array está completamente ordenada: e o algoritmo pode parar.  Bubble sort é estudado por causa da simplicidade dele, mas quase nunca é usado na prática por causa do baixo desempenho dele (O(n^2) em média).

note: type: Attribute 'alt' of: <div>
en: Show Tip (Pseudo-code)
pt: Mostrar Dica (Pseudo-código)

note: type: Content of: <div><p>
en: The pseudo-code of the BubbleSort algorithm is the following:
pt: O pseudo-código do algoritmo BubbleSort é o seguinte:

note: type: Content of: <div><pre>
en: do: 
            For each i in [0,len-2]
              If cells i and i+1 must be swapped, do it
    while we swapped something during last traversal
pt: faça: 
            Para cada i em [0,len-2]
              Se a célula i e i+1 devem ser alternadas, alterne
    enquanto algo foi alternado na última passagem

note: type: Content of: <p>
en: If you look carefully at the behavior of BubbleSort, a first easy optimization appears: after one traversal, the last element of the array must be the biggest of all since the traversal moved it up like a bubble to its position. More generally, after N traversal, we know that the N last elements of the array are already sorted. It is thus not necessary to compare them again during the subsequent traversals. For now, we will have as many traversal as there is in the array.
pt: Se olhar atentamente ao comportamento do BubbleSort, uma primeira e fácil otimização aparece: depois de uma travesia, o último elemento da array é o maior de todos, pois a travessia moveu-o para cima como uma bolha à posição dele. Mais geralmente, depois de N travessias, sabemos que os últimos N elementos da array já estão ordenados. Portanto, não é necessário compará-los de novo durante travessias subsequentes. Por agora, vamos ter tantas travessias quantos elementos na array.

note: type: Content of: <div><p>
en: The pseudo-code of the BubbleSort2 algorithm is the following:
pt: O pseudo-código do algoritmo BubbleSort2 é o seguinte:

note: type: Content of: <div><pre>
en: For all i in [len-2,0] (traversing from biggest to smallest)
           For all j in [0, i]
              If cells j and j+1 must be swapped, do it
pt: Para todo i em [len-2,0] (a percorrer do maior ao menor)
           Para todo j em [0, i]
              Se células j e j+1 devem ser trocadas, troque

note: type: Content of: <p>
en: When we run this algorithm, it is quite disappointing to see that it runs approximately at the same speed than the basic version of BubbleSort. This is a graphical effect only since only value changes are graphically represented. Since this variation avoids some useless comparisons, it does exactly the same amount of swaps that the basic version. It is thus quite logical that the graphical interface draws this version at the same pace than the base version. But the statistics on the amount of reads show that we saved about the fourth of the amount of reads, which is not bad.
pt: Quando rodamos este algoritmo, desaponta bastante ver que executa cerca de na mesma velocidade que a versão básica do BubbleSort. Isto é um elemento gráfico apenas já que apenas mudanças de valores são representadas graficamente. Como esta variação evita algumas comparações inúteis, ela faz a mesma quantidade de trocas que a versão básica. É, portanto, bastante lógico que a interface gráfica desenhe esta versão no mesmo ritmo que a versão básica. Mas as estatísticas da quantidade de leituras mostram que economizamos cerca de um quarto das leituras, o que não é nada mal.

note: type: Content of: <p>
en: From the asymptotic complexity point of view, there is absolutely no difference: this variation is still in O(n^2) on average (our gain is only on the constant term, ignored when computing the asymptotic complexity).
pt: Do ponto de vista da complexidade asimtótica, não existe nenhuma diferença: Esta variação ainda é O(n^2) no caso médio (nosso ganho é apenas no termo constante, ignorado quando se está a calcular a complexidade asimtótica).

note: type: Content of: <p>
en: Let's now reintroduce the little optimization we removed at previous step: if a traversal does not swap any element, it means that the array is already sorted. In that case, we want to stop the whole sorting process.
pt: Vamos agora reintroduzir a pequena otimização que fizemos no passo anterior: se uma passagem não troca nenhum elemento, significa que a array já está ordenada. Neste caso, vamos parar todo o processo de ordenação.

note: type: Content of: <p>
en: [!java|python|c]For that, simply use the <code>break</code> keyword, which breaks the current loop.  Beware, if you have several nested loops, this will apply to the internal one.[/!] [!scala]For that, simply quit the current function by calling <code>return</code> with no associated value.[/!]
pt: [!java|python|c]Para isto, simplesmente use a palavra-chave <code>break</code>, que interrompe o loop atual. Cuidado, se tem vários loops aninhados, isto só vai ter efeito no mais interno.[/!] [!scala]Para isto, simplesmente saia da função atual a chamar <code>return</code> sem nenhum valor associado.[/!]

note: type: Attribute 'alt' of: <div>
en: If you want, this tip shows the pseudo-code.
pt: Se quiser, esta dica mostra o pseudo-código.

note: type: Content of: <div><pre>
en: For all i in [len-2,0] (traversing from biggest to smallest)
           For all j in [0, i]
              If cells j and j+1 must be swapped, do it
           If traversal on j did not swap anything, break the for loop
pt: para todo i em [len-2,0] (a percorrer do maior ao menor)
           Para todo j em [0, i]
              Se células j e j+1 devem ser trocadas, troque
           Se ao percorrer j não fez nenhuma troca, pare o loop

note: type: Content of: <p>
en: This optimization is even more disappointing: it only provide a gain of a few percents on the amount of reads over BubbleSort2.
pt: Esta otimização é ainda mais desapontadora: ela só dá um ganho de alguns porcento sobre o BubbleSort2 no total de leituras.

note: type: Content of: <p>
en: To improve further the BubbleSort algorithm, we need to look closer its behavior. One can notice that big elements are moved very quickly in position while small ones move very slowly to their destination. They are thus traditionally referred to as "rabbits" and "turtles" respectively for big fast values and small slow ones.
pt: Para melhorar ainda mais o algoritmo BubbleSort, precisamos ver comportamente dele bem de perto. Pode perceber que os elementos grandes se movem bem rápido enquanto os pequenos se movem lentamente para os destinos dele. Eles são então tradicionalmente chamados de "coelhos" e "tartarugas" respectivamente para valores grandes e rápidos e valores pequenos e lentos.

note: type: Content of: <p>
en: To help the turtles moving faster, the cocktail sort traverse alternatively the array from right to left and from left to right. Here is the pseudo-code:
pt: Para ajudar as tartarugas a se mover rápido, o cocktail sort percorre alternativamente a array da direita para a esquerda e da esquerda para a direita. Aqui está o pseudo-código:

note: type: Content of: <p>
en: One can see that cocktail sort achieves exactly the same amount of swaps than the bubble sort, but improves slightly on read amount. It is however still worse than BubbleSort2 to that extend.
pt: Podemos perceber que cocktail sort alcança a mesma quantidade de trocas que o bubble sort, mas melhora levemente na quantidade de leituras. Entretanto, é ainda pior que o BubbleSort2 neste assunto.

note: type: Content of: <p>
en: We will now apply to CocktailSort the same optimization than BubbleSort2 did to BubbleSort. We must remember the limits of the array part not being sorted yet, and traverse it alternatively from left to right and from right to left:
pt: Vamos agora aplicar ao CocktailSort a mesma otimização que o BubbleSort2 faz no BubbleSort. Devemos lembrar que os limites da parte do array que não está ordenada ainda e percorrer ela alternativamente da esquerda para a direita e da diretia para a esquerda:

note: type: Content of: <h1>
en: CocktailSort (take 3)
pt: CocktailSort (3o tempo)

note: type: Content of: <p>
en: Even if the asymptotic complexity of CocktailSort2 is the same than the one of BubbleSort, it seem to perform better in practice. It is even possible to improve a bit further by stopping it if the first traversal didn't found anything to swap, without achieving the downwards traversal. Likewise, we can stop if the upward traversal found something to swap, but not the downwards one.
pt: Mesmo se a complexidade assintótica de CocktailSort2 for a mesma do BubbleSort, que parece melhor, na prática. É até mesmo possível melhorar um pouco mais a pará-lo na primeira rodada que não encontrar nada para alternar, se realizar a rodada para baixo. Da mesma forma, podemos parar se a rodada para cima encontrar algo para alternar, mas a rodada para baixo não.

note: type: Content of: <p>
en: This sorting algorithm is quite simple to understand and write, even if it is not as efficient as possible. Its asymptotic complexity is in O(n2), but it is more efficient in practice (linear in best case, ie when the array is already sorted, and N2/4 on average).
pt: Este algoritmo de ordenação é muito simples de entender e escrever, mesmo se não for o mais eficiente possível. A complexidade assintótica dela é O(n2), mas é mais eficiente, na prática (linear no melhor caso, p.ex. quando a array já está ordenada e N2/4 no caso médio).

note: type: Content of: <p>
en: The idea is to traverse all elements of the array, and to insert each of them into its proper position in the already sorted part of the array. When we look at an element x, the situation is the following: any elements to the left of the array are already sorted, and we have to insert x at its position in the array.
pt: A ideia é percorrer todos os elementos da array e inserir cada um deles na posição correta dele numa parte já ordenada da array. Quando olhamos num elemento x, a situação é a seguinte: qualquer elemento da esquerda da array já está ordenado e temos que inserir x na posição dele na array.

note: type: Content of: <p>
en: Once this is done, the situation is the following:
pt: Uma vez isto feito, a situação é a seguinte:

note: type: Content of: <p>
en: The pseudo-code of this algorithm is thus the following:
pt: O pseudo-código deste algoritmo é então o seguinte:

note: type: Content of: <p>
en: Naturally, you should use a loop to write the big permutation within the given loop. Writing it this way would be really ... counter-productive.
pt: Naturalmente, deve usar um loop para escrever a grande permutação dentro do loop. Escrever ela desta forma deve ser na verdade ... improdutivo.

note: type: Content of: <p>
en: If you've always wondered what computer science researchers do nowadays, here is part of the answer: They improve fundamental algorithms so that others can write efficient programs.
pt: Se já se perguntou o que cientistas da computação fazem nos dias de hoje, aqui está uma parte da resposta: Eles melhoram algoritmos fundamentais para que outras pessoas possam escrever programas eficientes.

note: type: Content of: <h2>
en: Other variation of insertion sort
pt: Outra variação do insertion sort

note: type: Content of: <p>
en: TreeSort builds a binary search tree to sort them. It leads to a O(n log(n))  on average, but O(n^2) in worst cases. We won't study this algorithm here since understanding its behavior requires to know what a binary tree is, what is beyond our present goals.
pt: TreeSort constrói uma árvore de busca binária para ordená-la. Consegue O(n log(n)) no caso médio, mas O(n^2) nos piores casos. Não vamos estudar este algoritmo aqui, pois para entendê-lo temos que entender o que uma árvore binária é, o que está além dos nossos objetivos atuais.

note: type: Content of: <p>
en: There is other variations over the insertion sort, such as PatienceSort which builds piles of values and sort each pile afterward. This algorithm presents a 0(n log(n)) timing worst case and a 0(n) space complexity. LibrarySort (proposed in 2004) also trades a bit space in exchange for time since it provide a time complexity of O(n log(n)) but needs to store some more data.
pt: Existem variações do insertion sort, tais como o PatienceSort que constrói pilhas de valores e ordena cada pilha depois. Este algoritmo apresenta um tempo 0(n log(n)) no pior caso e uma complexidade de espaço de 0(n). LibrarySort (proposto em 2004) também troca um pouco de espaço por tempo já que tem uma complexidade de tempo de O(n log(n)) mas precisa armazenar um pouco mais de dados.

note: type: Content of: <p>
en: Wikipedia provides a detailled description of all these algorithms we cannot present here because of time constraints.
pt: A Wikipédia fornece uma descrição detalhada de cada um destes algoritmos que não apresentamos aqui devido a limitações de tempo.

note: type: Content of: outside any tag (error?)
en: This algorithm is named after its author, Donald Shell, who published it in 1959. It can be seen as an application of the CombSort idea (let elements having a long path to travel take shortcuts) to the insertion sort (CombSort is a variation of BubbleSort). Instead of comparing adjacent values during the insertion sort, it compares values separated by a bigger gap. The bigger the gap, the faster the elements are moved to their final destination, but also the less precise is this move. It is thus mandatory to apply the algorithm with a serie of decreasing gaps. At the last step, when the gap is one, InsertionSort is used, but onto an array which is almost already sorted by previous steps.
pt: Este algoritmo é batizado em homenagem ao autor dele, Donald Shell, que o publicou em 1959. Seja uma aplicação da ideia do CombSort (faz com que elementos que tem um longo caminho tomarem atalhos) ao insertion sort (CombSort é uma variação do BubbleSort). Ao invés de comparar valores adjacentes durante o insertion sort, compara valores separados por um intervalo maior. Quanto maior o intervalo, mais rápido os elementos se movem ao destino deles, mas também menos preciso fica o movimento. É, portanto, essencial que o algoritmo vá a ser aplicado numa série de intervalos cada vez menor. No último passo, quando o intervalo for 1, o InsertionSort será usado, mas numa array que estará praticamente ordenada pelos passos anteriores.

note: type: Content of: <p>
en: Donald Shell propose <code>len/2</code> as initial value of the gap, and then to divide it by 2 at each step. The pseudo-code is thus the following:
pt: Donald Shell propôs <code>len/2</code> como o valor inicial do intervalo e ir a dividir por 2 a cada passo. O pseudo-código é o seguinte:

note: type: Content of: <p><p>
en: Just like in CombSort, the sequence of values taken by the gap is crucial for Shell sort performance. In some rare pathological cases, the sequence we used above can lead to a O(n^2) performance. Other sequences were proposed: the Hibbard's increments of 2k − 1 lead to a complexity of O(n^(3/2)) in worst cases. Pratt's increments 2^i3^j lead to a O(nlog(n)log(n) performance in worst cases. The existance of a sequence leading to a O(n log(n)) was precluded by Poonen, Plaxton, and Suel. Thanks to this performance, ShellSort is a valid candidate for array of several hundred thousands when correctly implemented.
pt: Assim como no CombSort, a sequência de valores levados pelo intervalo é crucial para o desempenho do Shell sort. Em alguns casos patológicos raros, a sequência que usamos pode levar a um desempenho O(n^2). Outras sequências foram propostas: os incrementos de Hibbard de 2k − 1 levam a uma complexidade de O(n^(3/2)) em casos ruins. Incrementos de Pratt 2^i3^j levam a um desempenho de O(nlog(n)log(n) nos piores casos. A existência de uma sequência a levar a O(n log(n)) foi excluída por Poonen, Plaxton e Suel. Graças a este desempenho, ShellSort é um candidato válido para arrays de várias centenas de milhares quando corretamente implementado.

note: type: Content of: <p><p>
en: In our case, the array are ways too small to benefit of these optimizations. If you ever need to do so, take as initial gap the biggest value of the targeted serie still smaller than the array size, and then use decreasing values of the serie.
pt: No nosso caso, a array é pequena demais para se beneficiar destas otimizações. Se ainda assim quiser, tome o intervalo inicial como o maior valor da série alvo ainda menor que o tamanho do array e depois use valores decrescentes da série.

note: type: Content of: <p><p>
en: Interestingly enough, determining the best gap sequence for shell sort turns into a research issue of our century in computer science. For example, an article of 2001 introduces the following sequence, which seems to be optimal in practice for arrays of size up to 10^5: {1, 4, 10, 23, 57, 132, 301, 701, 1750} (Marcin Ciura, Best Increments for the Average Case of Shellsort, 13th International Symposium on Fundamentals of Computation Theory, LNCS 2001; Vol. 2138).
pt: Um fato interessante: Determinar a melhor sequência de intervalos para o shell sort se tornou um tema de pesquisa de nosso século em ciência da computação. Por exemplo, um artigo de 2001 introduz a seguinte sequência, que parece ser a melhor na prática para arrays de tamanho até 10^5: {1, 4, 10, 23, 57, 132, 301, 701, 1750} (Marcin Ciura, Best Increments for the Average Case of Shellsort, 13th International Symposium on Fundamentals of Computation Theory, LNCS 2001; Vol. 2138).

note: type: Content of: outside any tag (error?)
en: In this exercise we will implement another classical algorithm: selection sort.
pt: Neste exercício vamos implementar outro algoritmo clássico: selection sort.

note: type: Content of: <p>
en: The idea is simply to select for each cell of the array the smallest value from the part not already sorted. Thus for the first cell, it takes the smallest value over the whole array. For the second one, it takes the second smallest value, which is the smallest value from the cell not already sorted. You of course don't have to sort the last cell of the array, that is already sorted when you consider it.
pt: A ideia é simplesmente selecionar para cada célula da array o menor valor da parte ainda não ordenada. Então para a primeira célula, levamos o menor valor da array toda. Para a segunda, precisamos do segundo menor valor, que é o menor valor das células ainda não ordenadas.

note: type: Content of: <p><p>
en: More generally, for the cell N, it looks the cell M in [N;len] containing the smallest possible value of the interval. Then, it swaps the content of cell N with the one of cell M.
pt: De forma mais geral, para a célula N, procura a célula M em [N;len] a conter o menor valor possível do intervalo. Então, alterna o conteúdo da célula N com o da célula M.

note: type: Content of: <p><p><h2>
en: Existing variations
pt: Variações existentes

note: type: Content of: <p><p>
en: Another classical algorithm which idea is based on the selection of good elements is HeapSort, but it uses a heap data structure which we did not see yet. Simply remember that HeapSort provides a O(n log n) performance in worst case, which is why it is a very interesting algorithm in practice.
pt: Outro algoritmo clássico cuja ideia é baseada na seleção de bons elementos é o HeapSort, mas usa uma estrutura de dados heap que ainda não vimos. Simplesmente lembre-se que o HeapSort fornece um desempenho O(n log n) no pior caso, que é o motivo para ser bem interessante, na prática.

note: type: Content of: <p>
en: We saw that CocktailSort improve a bit for turtles (i.e. small values near to the end of the array), but it is still possible to achieve better. ComboSort comes down to providing them a short cut: instead of comparing adjacent values, we compare values separated by a gap bigger than 1. That way, turtles will traverse <i>gap</i> cells at each traversal. Naturally, we have to apply the algorithm with decreasing gaps, and finish with <i>gap=1</i> to ensure that the array is correctly sorted afterward. Choosing the right gap and how to decrease it is a difficult question, but in practice, dividing it by 1.3 after each traversal leads to good performance. Here is the corresponding pseudo-code:
pt: Vimos que CocktailSort melhora um pouco as coisas para as tartarugas (p.ex. pequenos valores próximos do fim da array), mas ainda é possível fazer melhor. ComboSort vem-les fornecer um atalho: ao invés de comparar valores adjacentes, comparamos valores separados por um intervalo ("gap") maior que 1. Desta forma, as tartarugas vão percorrer <i>gap</i> células em cada passagem. Naturalmente, temos que aplicar o algoritmo com distâncias decrescentes e terminar com <i>gap=1</i> para garantir que a array está corretamente ordenada ao final. Escolher a distância correta e como diminuí-la é uma questão difícil, mas na prática, dividir por 1.3 depois de cada passagem leva a uma boa performance. Aqui está o pseudo-código correspondente:

note: type: Content of: <p>
en: One tricky part is that we want to divide gap, that is an integer (of type Int), by 1.3, that is a Double.  The type system of scala won't let us do this, because such discrepancy usually denotes a programmer error.  As this is not an error this time, we have to convert gap to Double for the time of the operation, and then convert the result back to Int to store it into gap. This should be written this way:
pt: Um detalhe perigoso é que temos que dividir o intervalo, que é um inteiro (ou do tipo Int), por 1.3, que é um Double. O sistema de tipos do scala não nos deixa fazer isto, por que tal discrepância normalmente significa um erro de programação. Como isto não é um erro neste caso, vamos ter que converter o intervalo para Double para o momento da operação e depois converter o resultado de volta para Int para armazená-lo no intervalo. Isto deve ser escrito desta forma:

note: type: Content of: <p>
en: This is rather verbose, but actually, this notation is not very complex. And remember that the type checker is your friend. It's picky and sometimes annoying (as on this one), but it often catches weird bugs that would have been a pain to debug if not catch by the type checker. And since the Scala's authors are pragmatic, the previous expression can be simplified:
pt: Isto é meio exagerado, mas, na verdade, esta notação não é muito complexa. E lembre-se que o verificador de sintaxe é o seu amigo. Ás vezes é chato e irritante (como neste caso), mas frequentemente apanha bugs esquisitos que seriam trabalhosos para depurar se não fosse o verificador de sintaxe. E como os autores do Scala são pragmáticos, a expressão anterior pode ser simplificada:

note: type: Content of: <p>
en: <code>toDouble</code> and <code>toInt</code> are just shortcuts for the corresponding expressions <code>asInstanceOf[Double]</code> and <code>asInstanceOf[Int]</code>. It's not very generic, but it's very handy.
pt: <code>toDouble</code> e <code>toInt</code> são apenas atalhos para as expressões correspondentes <code>asInstanceOf[Double]</code> e <code>asInstanceOf[Int]</code>. Não é muito genérico, mas é bem prático.

note: type: Content of: <p>
en: This algorithm was invented by Wlodek Dobosiewicz in 1980, and later rediscovered and popularized by Stephen Lacey and Richard Box, who described it in Byte Magazine in April 1991.
pt: Este algoritmo foi inventado por Wlodek Dobosiewicz em 1980 e depois redescoberto e popularizado por Stephen Lacey e Richard Box, que o descreveram na Byte Magazine em Abril de 1991.

note: type: Content of: <p>
en: The authors of this algorithm observed that the performance is increased if we make sure that the last values of the gap are (11, 8, 6, 4, 3, 2, 1)  rather than (9, 6, 4, 3, 2, 1) or (10, 7, 5, 3, 2, 1). Rework the code of CombSort to ensure just after the gap update that if it is 9 or 10, we should use 11 instead.
pt: Os autores deste algoritmo observaram que o desempenho é aumentado se nos certificarmos que os últimos valores do intervalo são (11, 8, 6, 4, 3, 2, 1) ao invés de (9, 6, 4, 3, 2, 1) ou (10, 7, 5, 3, 2, 1). Retrabalhe o código do CombSort para garantir que apenas depois da atualização do intervalo que se for 9 ou 10, devemos usar 11.

note: type: Content of: <p>
en: The Gnome sort is similar to insertion sort, but the elements are moved in position by a serie of swaps just like in bubble sort. It is named after the supposed behavior of garden gnomes when they sort flower pots. Here is a description of the algorithm by its author:
pt: O Gnome sort é similar ao insertion sort, mas os elementos são movidos de poisção por uma série de trocas que se parecem com o bubble sort. O nome veio do suposto comportamento que gnomos de jardim tem quando ordenam vasos de flores. Aqui está uma descrição do algoritmo pelo autor dele:

note: type: Content of: <p>
en: Gnome Sort is based on the technique used by the standard Dutch Garden Gnome (Du.: tuinkabouter). Here is how a garden gnome sorts a line of flower pots. Basically, he looks at the flower pot next to him and the one immediately after ; if they are in the right order he steps one pot forward, otherwise he swaps them and steps one pot backwards. Boundary conditions: if there is no previous pot, he steps forwards; if there is no pot next to him, he is done.  <i>—Dick Grune</i>
pt: Gnome Sort é baseado na técnica usada pelo gnomo de jardim holandês padrão (em holandês: tuinkabouter). Aqui está como um gnomo de jardim ordena uma fileira de potes de flores. Basicamente, procura pelo pote de flor próximo e o anterior; se estão na ordem correta vai para a frente em direção ao próximo pote, caso contrário troca os potes e vai para trás. Condições de contorno: se não existe um pote anterior,  vai para a frente; se não existe um pote próximo, termina.  <i>—Dick Grune</i>

note: type: Content of: <h1>
en: The Dutch Flag Problem
pt: O problema da bandeira holandesa

note: type: Content of: <p>
en: This problem was first proposed by E.W Dijkstra in 1976 (in the chapter 14 of his book "A Discipline of Programming").  It is a very classical variation of the sorting algorithms since then. It is sometimes useful in real life, but it became famous for its pedagogical properties: its complexity is not trivial, but not complex either.  It can easily be formally proven, but it's not absolutely trivial either.
pt: Este problema foi proposto primeiro por E.W Dijkstra em 1976 (no capítulo 14 do livro dele "A Discipline of Programming"). É uma variação clássica de algoritmos de ordenação desde então. Às vezes é útil na realidade, mas se tornou famosos pelas propriedades pedagógicas dele: a complexidade não é trivial, mas não é muito complexo. Pode ser provados formalmente com facilidade, mas não é de forma alguma trivial.

note: type: Content of: <ul><li>
en: A temporal view could be welcomed.
pt: Uma visão temporal pode ser bem-vinda.

note: type: Content of: <ul><li>
en: Other exercises, for example with 2 colors only or with more than 3 colors, could generalize the proposed approach.
pt: Outros exercícios, por exemplo com 2 cores apenas ou com mais de 3 cores, podem generalizar a abordagem proposta.

note: type: Content of: <ul><li>
en: This problem could be solved recursively.
pt: Este problema pode ser resolvido recursivamente.

note: type: Content of: <p>
en: This is a classical sorting problem, constituting a variation over the insertion sort.
pt: Este é um problema de ordenação clássico, a constituir uma variação do insertion sort.

note: type: Content of: <p>
en: Your work is to sort all the colors of the Dutch flag, and the only provided primitive is to exchange two given lines.  In addition, you should not create any additional variables (but a few indices).
pt: O seu trabalho é ordenar todas as cores da bandeira holandesa e a única primitiva fornecida é trocar duas linhas dadas. Adicionalmente, não deve criar quaisquer variáveis adicionais (exceto alguns índices).

note: type: Content of: <p>
en: If you think carefully, this can be done in linear time, where you sort a line at each iteration of the loop.  You may want to check again the <a href="plm://lessons.sort.basic/insertion.AlgInsertionSort">insertion sort</a>, of which the Dutch Flag sort is a variation. The main difference is that you have 3 insertion points, not only one...
pt: Se pensar bem, pode ser feito em tempo linear, ondeordena uma linha a cada iteração do loop. Pode dar mais uma olhada no <a href="plm://lessons.sort.basic/insertion.AlgInsertionSort">insertion sort</a>, do qual o Dutch Flag sort é uma variação. A principal diferença é que tem 3 pontos de inserção e não apenas um...

note: type: Attribute 'alt' of: <div>
en: I need an hint to start
pt: Preciso de uma dica para começar

note: type: Content of: <div>
en: Do a traversal over your data, saving 3 indices:
pt: Atravesse os seus dados, a guardar 3 índices:

note: type: Content of: <div><ul><li>
en: <code>afterBlue</code> is initialized to 0. Make sure that every cell below <code>afterBlue</code> is filled with blue elements.
pt: <code>afterBlue</code> é iniciado como 0. Certifique-se de que cada célula abaixo de <code>afterBlue</code> é preenchida com elementos azuis.

note: type: Content of: <div><ul><li>
en: <code>whiteRed</code> is initialized to size-1. Make sure that every cell after <code>whiteRed</code> is filled with red elements.
pt: <code>whiteRed</code> é iniciado como size-1. Certifique-se de que cada célula depois de <code>whiteRed</code> é preenchida com elementos vermelhos.

note: type: Content of: <div><ul><li>
en: <code>beforeWhite</code> is initialized to size-1. Make sure that every cell after <code>beforeWhite</code> and before <code>whiteRed</code> is filled with white elements.
pt: <code>beforeWhite</code> é iniciado com size-1. Certifiqeu-se de que cada célula depois de <code>beforeWhite</code> e antes de <code>whiteRed</code> é preenchida com elementos brancos.

note: type: Content of: <div>
en: Note that the unsorted cells are always between <code>afterBlue</code> and <code>beforeWhite</code>.
pt: Observe que as células não-ordenadas ficam sempre entre <code>afterBlue</code> e <code>beforeWhite</code>.

note: type: Content of: <div>
en: At each step of your traversal, check the color of the cell at <code>afterBlue</code> and do the required exchanges.  The loop ending condition is when <code>afterBlue</code> becomes larger than <code>beforeWhite</code>.
pt: Em cada passo da sua travessia, verifique a cor da célula em <code>afterBlue</code> e faça as mudanças necessárias. A condição de fim de loop é quando <code>afterBlue</code> se torna maior que <code>beforeWhite</code>.

note: type: Content of: <h2>
en: Provided values
pt: Valores fornecidos

note: type: Content of: <p>
en: The colors are represented through the following constants: BLUE, WHITE and RED.  You can use them directly in your code.
pt: As cores são representadas através das seguintes constantes: BLUE, WHITE e RED. Pode usá-las diretamente no seu código.

note: type: Content of: <h2>
en: Provided functions
pt: Funções fornecidas

note: type: Content of: <p>
en: This world is very simple, with only 5 provided functions.
pt: Este mundo é bem simples, com apenas 5 funções fornecidas.

note: type: Content of: <pre>
en: [!java|c]void [/!]swap([!java|c]int [/!]x[!scala]:Int[/!], [!java|c]int [/!]y[!scala]:Int[/!])
pt: [!java|c]void [/!]alterna([!java|c]int [/!]x[!scala]:Int[/!], [!java|c]int [/!]y[!scala]:Int[/!])

note: type: Content of: outside any tag (error?)
en: Swap the lines number <code>x</code> and <code>y</code>.
pt: Troca as linhas de número <code>x</code> com a de número <code>y</code>.

note: type: Content of: outside any tag (error?)
en: Returns the amount of lines on this flag.
pt: Retorna a quantidade de linhas desta bandeira.

note: type: Content of: <pre>
en: [!java|c]int [/!]getColor([!java|c]int [/!]line[!scala]:Int[/!])  [!scala]:Int[/!]
pt: [!java|c]int [/!]getCor([!java|c]int [/!]linha[!scala]:Int[/!])  [!scala]:Int[/!]

note: type: Content of: outside any tag (error?)
en: Returns the color of the given line.
pt: Retorna a cor da linha dada.

note: type: Content of: outside any tag (error?)
en: Returns whether the flag is sorted.
pt: Retorna true se a bandeira estiver ordenada.

note: type: Content of: outside any tag (error?)
en: Returns whether the current world is selected in the interface.
pt: Retorna true se o mundo atual estiver selecionado na interface.

note: type: Content of: <p>
en: This universe is very simple, with only five functions provided.
pt: Este universo é bastante simples, com apenas cinco funções fornecidas.

note: type: Content of: outside any tag (error?)
en: Returns the size of the stack, that is the amount of pancakes it contains.
pt: Retorna o tamanho da pilha, ou seja, a quantidade de panquecas nela.

note: type: Content of: <pre>
en: [!java|c]int [/!]getPancakeRadius([!java|c]int [/!]rank[!scala]:Int[/!])  [!scala]:Int[/!]
pt: [!java|c]int [/!]getRaioPanqueca([!java|c]int [/!]rank[!scala]:Int[/!])  [!scala]:Int[/!]

note: type: Content of: outside any tag (error?)
en: Returns the radius of the pancake passed as argument, with the rank of the top-most pancake being 0.
pt: Retorna o raio da panqueca passado como argumento, com o rank da panqueca mais acima a ser 0.

note: type: Content of: <pre>
en: [!java]boolean [/!][!c]int [/!]isPancakeUpsideDown([!java|c]int [/!]rank[!scala]:Int[/!])   [!scala]:Boolean[/!]
pt: [!java]boolean [/!][!c]int [/!]panquecaDeCabeçaPraBaixo([!java|c]int [/!]rank[!scala]:Int[/!])   [!scala]:Boolean[/!]

note: type: Content of: outside any tag (error?)
en: Returns whether the pancake passed as argument upside-down, that is, if its burned side is on top. As usual, the top-most pancake is of rank 0.
pt: Retorna se a panqueca passada como argumento está de cabeça para baixo, ou seja, se o lado queimado está para cima. Como sempre, a panqueca mais acima é a de rank 0.

note: type: Content of: outside any tag (error?)
en: Flips the <code>amount</code> first pancakes composing the stack, from the top of it.
pt: Vira as primeiras <code>amount</code> panquecas que compõe a pilha, do topo dela.

note: type: Content of: outside any tag (error?)
en: Returns whether the pancake stack is correctly sorted.
pt: Retorna true se a pilha de panquecas estiver corretamente ordenada.

note: type: Content of: <h1>
en: Pancake Sorting
pt: Ordenação da panqueca

note: type: Content of: <p>
en: This activity is inspired by a problem first introduced in 1975 by Harry Dweighter in the American Mathematical Monthly. The question is not only to sort the pancakes, but to determine <code>f(n)</code> the <i>minimal</i> amount of flips mandated to sort any stack of size <code>n</code>.
pt: Esta atividade é inspirada por um problema introduzido pela primeira vez em 1975 por Harry Dweighter no American Mathematical Monthly. A pergunta não é apenas ordenar panquecas, mas determinar <code>f(n)</code> a quantidade <i>minima</i> de viradas necessárias para ordenar qualquer pilha de tamanho <code>n</code>.

note: type: Content of: <p>
en: This problem is now famous because Bill Gates authored (with C. Papadimitriou) his only scientific publication in 1979 on this topic, providing a faster algorithm and proving that <code>17n/16 ≤ f(n) ≤ (5n+5)/3</code>.  This was the only publication of Bill Gates before he invented Windows and became rich.
pt: Este problema é agora famoso por que Bill Gates escreveu (com C. Papadimitriou) a única publicação científica dele em 1979 neste tópico, a fornecer um algoritmo mais rápido e a provar que <code>17n/16 ≤ f(n) ≤ (5n+5)/3</code>.  Este foi a única publicação de Bill Gates antes dele inventar o Windows e ficar rico.

note: type: Content of: <p>
en: Then, David X. Cohen, the inventor of the Futurama comics with many mathematical references, introduced the variant with burnt pancakes and studied its complexity with Manuel Blum in 1993.
pt: Então, David X. Cohen, o inventor dos quadrinhos Futurama com muitas referências matemáticas, introduziu a variante com panquecas queimadas e estudou a complexidade dele com Manuel Blum em 1993.

note: type: Content of: <p>
en: An article of 2011 (by L. Bulteau, G. Fertin and I. Rusu) proved that determining the minimal amount of flips to sort the stack is a NP-complete problem. Naturally, the stack sorting problem is not NP-complete since it can be solved in 2n-3 steps with the naive algorithm and (5n+5)/3 steps with the Gates algorithm.  That's determining the minimal amount of steps that is NP.
pt: Um artigo de 2011 (por L. Bulteau, G. Fertin e I. Rusu) provou que determinar a quantidade mínima de voltas para ordenar a pilha é um problema NP-completo. Naturalmente, o problema de ordenação da pilha não é NP-completo já que pode ser resolvido em 2n-3 passos com o algoritmo ingénuo e (5n+5)/3 passos com o algoritmo Gates.  Isso é determinar a quantidade mínima de passos que é NP.

note: type: Content of: <p>
en: Further information can be found on the wikipedia page, as usual.
pt: Mais informações encontram-se na página da wikipédia, como sempre.

note: type: Content of: <p>
en: This activity is also integrated to CSIRL (my repository of <i>free</i> unplugged activities to introduce computer science, available at http://www.loria.fr/~quinson/Mediation/SMN/), and it may be interesting to run the unplugged activities before implementing these algorithms in PLM.
pt: Esta atividade também é integrada ao CSIRL (o meu repositório de atividades offline <i>livres</i> para introdução de ciência da computação, disponível em http://www.loria.fr/~quinson/Mediation/SMN/) e pode ser interessante executar as atividades offline antes de implementar estes algoritmos no PLM.

note: type: Content of: <ul><li>
en: A temporal view similar to the sorting universe could be helpful
pt: Uma visão temporal similar ao universo da ordenação pode ser útil

note: type: Content of: <ul><li>
en: Other exercises, for example on the Roti sorting, with a pile of Roti that have to touch the grill on each face (see http://en.wikipedia.org/wiki/Pancake_sorting#The_identical_pancake_stack).
pt: Outros exercícios, por exemplo sobre Roti sorting, com uma pilha de Roti que tem que tocar a grelha em ambos os lados (see http://en.wikipedia.org/wiki/Pancake_sorting#The_identical_pancake_stack).

note: type: Content of: <h3>
en: The pancake problem
pt: O problema da panqueca

note: type: Content of: <p>
en: Help the poor psychorigid pancakes' chef to sort its pancake stack!
pt: Ajude o pobre chef das panquecas psychorigid a ordenar a pilha de panquecas dele!

note: type: Content of: <p>
en: This funny problem leads to algorithms that are somewhat more challenging to implement. You are supposed to master the bases of programming and some sorting algorithms to take this lesson.
pt: Este problema divertido leva a algoritmos que são de certa forma mais desafiadores de implmentar. Espera-se que domine as bases da programação e de algoritmos de ordenação para fazer esta lição.

note: type: Content of: <p>
en: The pancake sorting problem is a simple puzzle where you have a set of pancakes, each of differing size. The chef cooking the pancake is a bit psychorigid: he hates when the pancakes are not correctly sorted on the plate. He loves when they are correctly ordered, with the small ones over the larger ones. As every pancake maker, he masters the pancake flipping with his spatula. He can flip the pancake on top of the stack, or even several pancakes at once. The thing is that he has only one plate and the table is too dirty to place pancakes on it, even temporary. The only allowed operation is to flip some pancakes that are on top of the stack.
pt: O problema da ordenação da panqueca é um quebra-cabeças simples onde tem um conjunto de panquecas, cada uma de tamanhos diferentes. O cozinheiro que cozinha as panquecas é um pouco psicorígido: odeia quando as panquecas não estão corretamente ordenadas no prato. Adora quando elas estão corretamente ordenadas, com as pequenas sobre as grandes. Como todo fazedor de panquecas, é mestre em virar a panqueca com a espátula. Ele pode virar a panqueca do topo da pilha, ou até mesmo várias panquecas de uma vez. O problema é que tem apenas um prato e a mesa está muito suja para pôr as panquecas nela, mesmo temporariamente. A única operação permitida é virar algumas panquecas que estão no topo da pilha.

note: type: Content of: <p>
en: Your work is to help this poor guy sorting his stack by flipping the pancakes. Each pancake is defined by its radius and rank within the stack, with the top-most pancake is at rank 0, and the one below at rank 1.
pt: O seu trabalho é ajudar este pobre coitado a ordenar a pilha dele a virar as panquecas. Cada panqueca é definida pelo raio e rank dentro da pilha, onde a panqueca de cima está com rank 0 e a próxima com rank 1.

note: type: Content of: <p>
en: Note that you can play physically with pieces of paper or wood at first to get the grasp on this problem. This is even one of the activities that I use in my CS-IRL (computer science in real life) project to introduce the concept of algorithm to absolute beginners that wonder about our science. More information at http://www.loria.fr/~quinson/Mediation/SMN/ (in French).
pt: Observe que pode brincar primeiro fisicamente com pedaços de papel ou madeira para ter a ideia do problema. Esta é inclusive uma das atividades que uso no meu projeto CS-IRL (computer science in real life - ciência da computação na vida real) para introduzir o conceito de algoritmo para completos iniciantes que querem saber da nossa ciência. Mais informações em http://www.loria.fr/~quinson/Mediation/SMN/ (em francês).

note: type: Attribute 'alt' of: <p><div>
en: I don't get it. I need some help.
pt: Não compreendi. preciso de ajuda.

note: type: Content of: <p><div>
en: You should try to first move the largest pancake to the bottom, and then the largest but one pancake on top of it, and then the one just smaller on top, and so on.
pt: Deve tentar primeiro mover a maior panqueca para o fundo e depois a segunda maior para cima dela e depois a menor para o topo e assim por diante.

note: type: Attribute 'alt' of: <p><p><div>
en: The first tip was not enough. I need another one.
pt: A primeira dica não foi suficiente. Preciso de outra.

note: type: Content of: <p><div>
en: So first, you need to move the largest pancake at the bottom of the stack.
pt: Logo, em primeiro lugar precisa mover a maior panqueca para o fundo da pilha.

note: type: Content of: <p><div>
en: Can you imagine a situation in which you can easily bring this damn large pancake to the bottom?
pt: Pode imaginar uma situação onde possa facilmente trazer esta panqueca super-grande para o fundo?

note: type: Content of: <p><div>
en: How could you reach this situation from the current one?
pt: Como pode atingir esta situação a partir da atual?

note: type: Content of: <p>
en: This problem is similar to the previous: you have to sort the pancakes, the smallest at the top and the biggest at the bottom, except you can only flip them to sort.
pt: Este problema é similar ao anterior: tem que ordenar as panquecas, a menor no topo e a maior embaixo, mas só pode virar-las para ordená-las.

note: type: Content of: <p>
en: The purpose here is to sort them using the bubble algorithm, where one pancake is moved to the bottom until it encounters a bigger one. In graphical representations, it looks like a bubble takes the element and move them through the pile. This is where its name comes from.
pt: O objetivo aqui é ordená-los a usar o algoritmo da bolha (bubble), onde uma panqueca é movida ao fundo até encontrar uma maior que ela. Em representações gráficas, parece que uma bolha ocupa o lugar do elemento e move-o através da pilha. É daí que saiu o nome do algoritmo.

note: type: Content of: <p>
en: Now, using pancakes makes it a little more difficult to write, because you have to find a way to swap only two pancakes at a time.
pt: Agora, a usar panquecas torna as coisas um pouco mais difíceis de escrever, pois tem que encontrar uma forma de alternar apenas duas panquecas por vez.

note: type: Content of: <p><div>
en: The bubble algorithm consists in browsing the whole pile from top to bottom, and making a comparision between two pancakes. Each time the top pancake is bigger than the one below, you have to swap them, then compare the bigger pancake you just swapped with one below, and so on. You have to browse through the entire pile until no swap has occurred, in which case the pile is sorted.
pt: O Algoritmo da bolha consiste em navegar a pilha completa de cima para baixo e a fazer uma comparação entre duas panquecas. Cada vez que a panqueca de cima é maior que a de baixo, tem que alterná-las, então comparar a panqueca maior que acabou de alternar com a de baixo dela e por aí vai. Tem que navegar através de toda a pilha até que nenhuma troca ocorra e neste caso, a pilha estará ordenada.

note: type: Content of: <p><p><div>
en: If you don't understand the basic bubble sorting algorithm, you should try the exercises within the “Sorting algorithms” lesson. If you do, but can't figure a way to swap only two pancakes at a time, think of a situation where only two pancakes are swapped at a time, and find a way to reach that situation.
pt: Se não entende o algoritmo básico bubble sort, tente os exercícios da lição Algoritmos de Ordenação. Se consegue, mas não imagina uma forma de alternar apenas duas panquecas por vez, pense na situação onde apenas duas panquecas são alternadas por vez e encontre uma forma de chegar nesta situação.

note: type: Content of: <h1>
en: Burned Pancakes
pt: Panquecas queimadas

note: type: Content of: <p>
en: Hard blow for the chef! The pancakes got burnt on one side! There is no way he can deliver a stack of pancakes with visibly burnt pancakes! You've got to help him ensuring that no pancake is upside-down while sorting his stack.
pt: Hard blow for the chef! As panquecas queimaram de um lado! Não há forma de entregar uma pilha de panquecas com paquecas visivelmente queimadas! Tem que ajudá-lo a ter certeza de que nenhuma panqueca está de cabeça pra baixo enquanto ordena esta pilha.

note: type: Content of: <h1>
en: Faster Pancake Sorting
pt: Ondenação de Panqueca Rápida

note: type: Content of: <p>
en: Unlike others sorting problem, the expensive operation is not the comparison of values, but the flipping of pancakes. In this exercise, we will explore another algorithm that attempt to reduce the amount of stack flipping. The funny side is that this algorithm was first introduced by Bill Gates, before invented Windows.
pt: Ao contrário de outros problemas de ordenação, a operação cara não é a comparação de valores, mas virar as panquecas. Neste exercício, vamos explorar outro algoritmo que tenta reduzir a quantidade de viradas da pilha. O engraçado é que este algoritmo mostrado primeiro por Bill Gates, antes de inventar o Windows.

note: type: Content of: <p>
en: The basic idea is to grow sequences of sorted pancakes, not necessarily starting from the bottom.  We say that a sequence of ordered pancakes constitute a <b>block</b> while a pancake that is not part of a block is said to be <b>free</b>. The algorithm then considers the topmost pancake (of radius <code>t</code>) and search for the <code>t+1</code> or <code>t-1</code> pancakes (the considered neighbor is noted <code>t+o</code>). Eight cases may happen:
pt: A ideia básica é aumentar as sequências de panquecas ordenadas, não necessariamente a começar do fundo. Dizemos que uma sequência de panquecas ordenadas constitui um <b>bloco</b> enquanto uma panqueca que não é parte de um bloco é dita <b>livre</b>. O algoritmo então considera o panqueca mais de cima (de raio <code>t</code>) e busca pelas panquecas <code>t+1</code> ou <code>t-1</code> (a vizinhança considerada é <code>t+o</code>). Oito casos podem acontecer:

note: type: Content of: <ul><li>
en: <b>Case a</b>: Both <code>t</code> and <code>t+o</code> are free. They are then merged in one flip.
pt: <b>Caso a</b>: tanto <code>t</code> quanto <code>t+o</code> são livres. elas são então juntadas numa virada.

note: type: Content of: <ul><li>
en: <b>Case b</b>: <code>t</code> is free, and <code>t+o</code> is the first of a block. They are merged in one flip.
pt: <b>Caso b</b>: <code>t</code> é livre e <code>t+o</code> é o primeiro de um bloco. Eles são juntados numa virada.

note: type: Content of: <ul><li>
en: <b>Case c</b>: <code>t</code> is free but both <code>t-1</code> and <code>t+1</code> are the last elements of blocks.  Both blocks and <code>t</code> are merged all together in 4 flips.  Beware, if either <code>t-1</code> or <code>t+1</code> does not exist (because <code>t</code> is 0 or max), only two flips are mandated.
pt: <b>Caso c</b>: <code>t</code> é livre mas tanto <code>t-1</code> quanto <code>t+1</code> são últimos elementos de blocos. Os blocos e <code>t</code> são mesclados juntos em 4 viradas. Cuidado, se <code>t-1</code> ou <code>t+1</code> não existir (pois <code>t</code> é 0 ou max), apenas duas viradas são obrigatórias.

note: type: Content of: <ul><li>
en: <b>Case d</b>: <code>t</code> is in a block but <code>t+o</code> is free. They are merged in one flip.
pt: <b>Caso d</b>: <code>t</code> está num bloco mas <code>t+o</code> é livre. Eles são mesclados numa virada.

note: type: Content of: <ul><li>
en: <b>Case e</b>: <code>t</code> is in a block and <code>t+o</code> is the first element of a block. They are merged in one flip.
pt: <b>Caso e</b>: <code>t</code> está num bloco e <code>t+o</code> é o primeiro elemento de um bloco. Eles são mesclados numa virada.

note: type: Content of: <ul><li>
en: <b>Case f</b>: <code>t</code> is in a block and <code>t+o</code> is the last element of another block.  They are merged in 3 flips as follows.
pt: <b>Caso f</b>: <code>t</code> está num bloco e <code>t+o</code> é o último elemento de outro bloco. Eles são mesclados em 3 viradas como segue.

note: type: Content of: <ul><li>
en: <b>Case g</b>: <code>t</code> is in a block of length k+1 (the last element is <code>t+ko</code>), <code>t+(k+1)o</code> is either free or the last element of another block. Both blocks are merged in 2 flips:
pt: <b>Caso g</b>: <code>t</code> está num bloco de comprimento k+1 (o último elemento é <code>t+ko</code>), <code>t+(k+1)o</code> é tanto livre ou o último elemento é outro bloco. Ambos os blocos são mesclados em 2 viradas:

note: type: Content of: <ul><li>
en: <b>Case h</b>: <code>t</code> is in a block of length k+1 (the last element is <code>t+ko</code>), <code>t+(k+1)o</code> is the first element of another block (the difference with case g is that <code>t+(k+1)o</code> is now the <i>first</i> element of its block). Both blocks are merged in 2 flips:
pt: <b>Caso h</b>: <code>t</code> está num bloco de comprimento k+1 (o último elemento é <code>t+ko</code>), <code>t+(k+1)o</code> é o primeiro elemento de outro bloco (a diferença com o caso g é que <code>t+(k+1)o</code> é agora o <i>primeiro</i> elemento do bloco dele). Ambos os blocos são mesclados em 2 viradas:

note: type: Content of: <ul><li>
en: <b>Case i</b>: <code>t</code> is in a block of length <code>n</code> (this block contains all pancakes).  If <code>t</code> is not 1, the whole stack is fliped. The algorithm then stops.
pt: <b>Caso i</b>: <code>t</code> está num bloco de comprimento <code>n</code> (este bloco contém todas as panquecas). Se <code>t</code> não for 1, a pilha toda destá virada. O algoritmo então pára.

note: type: Content of: <p>
en: Each iteration increases the size of the blocks, so the algorithm eventually halts in all cases. A finer analysis would show that it takes at most <code>(5n+5)/3</code> steps to sort the stack. That's better than the naïve algorithm, that requires 2n-3 steps.
pt: Cada iteração aumenta o tamanho dos blocos, então o algoritmo eventualmente pára em todos os casos. Uma análise mais aprofundada mostrará que leva no máximo <code>(5n+5)/3</code> passos para ordenar a pilha. O que é melhor que o algoritmo simplório, que precisa de 2n-3 passos.

note: type: Content of: <h2>
en: Your turn
pt: É a sua vez

note: type: Content of: <p>
en: You now have almost enough information to implement this algorithm on your own. We just have to remove the last remaining ambiguities to ensure that you implement exactly the same algorithm that the correction. If several cases apply to your situation, then you should use the first given one. For example, if both cases a and b apply (e.g., with <code>t-1</code> on case <b>a</b> and <code>t+1</code> on case <b>b</b>), then you should apply the flips of case <b>a</b>. If a given case applies for both <code>t+1</code> and <code>t-1</code>, then you should apply it to <code>t+1</code>.
pt: Agora tem quase toda a informação necessária para implementar este algoritmo por si só. Temos apenas que remover as últimas ambiguidades para garantir que implemente o mesmo algoritmo que a correção. Se vários casos se aplicam à sua situação, deve usar o primeiro que foi dado. Por exemplo, se tanto o caso a quanto o caso b se aplicam (e.g., com <code>t-1</code> no <b>a</b> e <code>t+1</code> no caso <b>b</b>), deve aplicar as viradas do caso <b>a</b>. Se um dado caso se aplica tanto para <code>t+1</code> quanto para <code>t-1</code>, então deve aplicá-lo a <code>t+1</code>.

note: type: Content of: <p>
en: Note that it is somehow harder than the other exercises we did so far, so don't be surprised if you need more time to achieve this.  But do not give up hope, you can do it!
pt: Observe que este é de certa forma mais difícil que os outros exercícios que fizemos até agora, logo não se surpreenda se precisar de mais tempo para terminar. Mas não desista, pode conseguir!

note: type: Attribute 'alt' of: <p><div>
en: Well, I need some help to start.
pt: Bem, preciso de ajuda para começar.

note: type: Content of: <p><div>
en: First write some helper functions such as <code>isFirst()</code> or <code>isFree()</code>. This will simplify your main algorithm afterward, that can be written very similarly to the explication above with a bunch of if conditions. Factorizing code this way often helps making your code more readable.
pt: Primeiro escreva algumas funções auxiliares tais como <code>isFirst()</code> ou <code>isFree()</code>. Isto vai simplificar o seu algoritmo principal, que vai poder ser escrito de forma muito similar à explicação acima com um conjunto de condições if. Fatorizar o código desta forma às vezes ajuda a tornar o seu código mais legível.

note: type: Attribute 'alt' of: <p><div>
en: My code keeps failing and I don't know how to debug it.
pt: O meu código continua a falhar e não sei como depurar-lo.

note: type: Content of: <p><div>
en: To debug one world after the other and avoid that the messages of all worlds get intermixed, you can write your debug function only if the method <code>isSelected()</code> returns true. It will be so only for the entity that is currently selected in the graphical interface, that is probably the world you are currently debugging. This will help breaking the difficulty in parts by debugging the situation one after the other.
pt: Para depurar um mundo depois do outro e evitar que as mensagens de todos os mundos fiquem misturadas, pode escrever a sua função de depuração apenas se o método <code>isSelected()</code> retorna true. Isto acontecerá apenas para a entidade que estiver selecionada na interface gráfica, que é provavelmente o mundo que está a depurar no momento. Isto vai ajudar a dividir a dificuldade em partes e a depurar a situção uma após a outra.

note: type: Content of: <p><div>
en: In particular, it may help to print textually the state of the world each time you enter the main loop.
pt: Em particular, escrever textualmente o estado do mundo cada vez que entrar no loop principal pode ajudar.

note: type: Content of: <p>
en: The Gates' algorithm that we saw in the previous exercise quickly sort a stack of unburned pancakes by increasing the size of the blocks of sorted pancakes. This is much faster that the naive algorithm which moves at each step the largest pancake to the bottom of still unsorted pancakes. Gates' algorithm manages to sort a stack of <i>n</i> pancakes in less than <i>(5n + 5)/3</i> steps in the worst case, while the naive algorithm requires at most <i>2n</i> steps. Gates is thus about one third faster in the worst case.
pt: O algoritmo de Gates que vimos no exercício anterior ordena rapidamente uma pilha de panquecas que não estão queimadas a aumentar o tamanho dos blocos de panquecas já ordenadas. Isto é muito mais rápido que o algoritmo que move em cada passo a panqueca maior para o fundo das panquecas ainda não ordenadas. O algoritmo de Gates ordena uma pilha de <i>n</i> panquecas em menos que <i>(5n + 5)/3</i> passos no pior caso, enquanto que o algoritmo simplório precisa de no máximo <i>2n</i> passos. Gates é então cerca de 3 vezes mais rápido no pior caso.

note: type: Content of: <p>
en: In this exercise, we will explore an adaptation of the same idea to burnt pancakes. This was first published by David X. Cohen and Manuel Blum. David Cohen co-founded a few years later the Futurama TV show full of mathematical jokes. Definitively, interesting people studied that little pancake problem...
pt: Neste exercício, vamos explorar uma adaptação da mesma ideia das panquecas queimadas. Isto foi publicado primeiramente por David X. Cohen e Manuel Blum. David Cohen co-fundou uns anos depois a série de TV Futurama, cheia de piadas matemáticas. Definitivamente, pessoas interessantes estudaram este singelo problema da panqueca...

note: type: Content of: <p>
en: The Cohen's algorithm is slightly easier than the Gates' one since it distinguishes less cases:
pt: O algoritmo de Cohen é um pouco mais fácil que o algoritmo de Gates já que ele distingue menos casos:

note: type: Content of: <p>
en: <b>Case 1:</b> At least one pancake is rightside up in the stack. Let <i>p</i> be the largest such pancake.  Note that <i>p + 1</i> must therefore be upside down, unless <i>p = n</i> (in which case there is no <i>p + 1</i> pancake).
pt: <b>Caso 1:</b> pelo menos uma panqueca está de cabeça para cima na pilha. Seja <i>p</i> a maior destas panquecas. Observe que <i>p + 1</i> deve portanto estar de cabeça para baixo, a menos que <i>p = n</i> (e neste caso não existe a panqueca <i>p + 1</i>).

note: type: Content of: <ul><li>
en: <b>Case 1.a:</b> <i>p+1</i> is lower in the stack than <i>p</i>.
pt: <b>Caso 1.a:</b> <i>p+1</i> é menor que <i>p</i> na pilha.

note: type: Content of: <ul><li>
en: <b>Case 1.b:</b> <i>p+1</i> is higher in the stack than <i>p</i>.
pt: <b>Caso 1.b:</b> <i>p+1</i> é maior que <i>p</i> na pilha.

note: type: Content of: <ul><li>
en: <b>Case 1.c:</b> There is no <i>p+1</i> because <i>p</i> is the largest pancake in stack, that is because <i>p = n</i>.  If pancake <i>p</i> is already in position, there is nothing to do. If not, you can move it to the bottom of the stack in 2 flips:
pt: <b>Caso 1.c:</b> Não existe <i>p+1</i> pois <i>p</i> é a maior panqueca da pilha, isto por que <i>p = n</i>.  Se a panqueca <i>p</i> já estiver na posição, não há nada a fazer. Se não, pode movê-la para o fundo da pilha em duas viradas:

note: type: Content of: <ul><li>
en: <b>The trick is that the pancake <i>p</i> should never be considered again.</b> Otherwise, you will consider that pancake again and again since it's rightside up, and since that's the largest pancake. To leave that pancake alone, you should keep track of the stack size that is still to be sorted. Any traversal of the stack must then only consider these pancakes, leaving alone the ones that are already in position at the bottom of the stack.
pt: <b>O truque é que a panqueca <i>p</i> nunca deve ser considerada de novo.</b> caso contrário, vai considerar ela de novo e de novo pois ela está de cabeça pra cima e já que é a maior panqueca. Para desconsiderar-la, deve se lembrar do tamanho da pilha que ainda está para ser ordenada. Qualquer travessia da pilha deve então considerar apenas estas panquecas, não a mexer nas que já estão posicionadas no fundo da pilha.

note: type: Content of: <p>
en: <b>Case 2:</b> All pancakes are downside. Again, we distinguish two sub-cases.
pt: <b>Caso 2:</b> Todas as panquecas estão de cabeça para baixo. De novo, distinguimos dois sub-casos.

note: type: Content of: <ul><li>
en: <b>Case 2.a:</b> There is at least one <i>p</i> for which <i>p+1</i> is higher than <i>p</i> (if there is several such <i>p</i>, take the largest one).
pt: <b>Caso 2.a:</b> Existe pelo menos um <i>p</i> para o qual <i>p+1</i> é maior que <i>p</i> (se existem vários destes <i>p</i>, pegue o maior).

note: type: Content of: <ul><li>
en: <b>Case 2.b:</b> Any pancake <i>p</i> is lower than pancake <i>p+1</i>. In that case, we must have that setting:
pt: <b>Caso 2.b:</b> Qualquer panqueca <i>p</i> é menor que a panqueca <i>p+1</i>. Neste caso, devemos ter a seguinte configuração:

note: type: Content of: <p>
en: As you can see, we achieve one join in 2 flips in the cases 1 or 2.a. Since we need to achieve n joins to sort the stack, we can sort the stack in <i>2n</i> steps if case 2.b does not occurs.
pt: Como pode ver, alcançamos um "join" em duas viradas nos casos 1 ou 2.a. Já que precisamos alcançar n junções para ordenar a pilha, podemos ordenar a pilha em <i>2n</i> passos se o caso 2.b não ocorrer.

note: type: Content of: <p>
en: That case 2.b requires a very different handling as it is obviously not possible to achieve a join in only 2 flips.  But fortunately, we can leverage the very specific setting of the stack in that case to provide the following algorithm.  It sorts a stack in that exact configuration after exactly <i>2n</i> steps.
pt: Este caso 2.b necessita um tratamento particular já que é obviamente impossível juntar duas panquecas em apenas duas viradas. Mas por sorte, uma única configuração bem específica da pilha cai neste caso da figura. Podemos então utilizar o algoritmo seguinte, conhecido por tirar vantagem desta configuração. Este algoritmo ordena toda a pilha em exatamente <i>2n</i> passos.

note: type: Content of: <pre>
en: Repeat n times
        Flip the whole stack of n pancakes
        Flip the top (n-1) pancakes
pt: Repita n vezes
        vire a pilha toda de n panquecas
        Vire as (n-1) panquecas mais de cima

note: type: Content of: <p>
en: It may sound somehow magic, but it actually works, as depicted on an example below.
pt: Pode parecer mágica, mas funciona de verdade, como é mostrado no exemplo abaixo.

note: type: Content of: <p>
en: So, all in all, the Cohen algorithm manages to sort the stack of burnt pancakes in <i>2n</i> steps in all cases.  Quite a win over the naive algorithm for burnt pancakes that requires <i>3n</i> steps.
pt: Portanto, em todo caso, o algoritmo de Cohen trata de ordenar a pilha de panquecas queimadas em <i>2n</i> passos em todos os casos. Uma vitória sobre o algoritmo simplório para panquecas queimadas que precisa de <i>3n</i> passos.

note: type: Attribute 'alt' of: <p><div>
en: I cannot get it right.
pt: Não entendi direito.

note: type: Content of: <p><div>
en: Don't worry. This exercise is very difficult, so it's ok if it does not work right away for you.  Add some relevant logging to your code to understand where it stop performing correctly.  Make sure to use the method <code>isSelected()</code> so that your logs only appears in the currently displayed world. In particular, it may help to print textually the state of the world each time you enter the main loop.
pt: Não se preocupe. Este exercício é muito difícil, então tudo bem se não conseguir de primeira. Adicione alguns logs relevantes ao seu código para entender onde parou de funcionar corretamente. Certifique-se de usar o método <code>isSelected()</code> de forma que os seus logs apenas apareçam no mundo que estiver a ser exibido no momento. Em particular, pode ajudar se imprimir textualmente o estado do mundo cada vez que adentrar no loop principal.

note: type: Content of: <h1>
en: The Rainbow Baseball Game
pt: O jogo do basebal multicores

note: type: Content of: <p>
en: This activity is inspired from the orange game, from the "Computer Science Unplugged" activities repository.  It was however heavily since then, first for the CSIRL (my repository of <i>free</i> unplugged activities to introduce computer science, available at http://www.loria.fr/~quinson/Mediation/SMN/) and now for PLM.
pt: Esta atividade é inspirada do jogo orange, do repositório de atividades "Computer Science Unplugged".  Foi entretanto profundamente alterada, primeiro para o CSIRL (o meu repositório de atividades unplugged <i>livres</i> para introduzir a ciência da computação, disponível em http://www.loria.fr/~quinson/Mediation/SMN/) e agora para o PLM.

note: type: Content of: <p>
en: In the literature, the generalized form of this problem is known as the pebble motion problem (the bases can be connected by any kind of graph, and the affinity of pebbles with bases may be different). Another variant of this problem is the well known 15-puzzle, with one player per base, and a two dimensional square grid. Much more information about these problems can be found on wikipedia, as usual.
pt: Na literatura, a forma geral deste problema é conhecida como o "Pebble motion problem" (as bases podem ser conectadas por qualquer tipo de grafo e a afinidade das "pebbles" com bases pode ser diferente). Outra variante deste problema é o famoso jogo do 15, com um jogador por base e um tabuleiro quadrado bidimensional. Mais informações sobre estes problemas encontram-se na wikipédia em inglês, como sempre.

note: type: Content of: <h3>
en: How do you know that the naive algorithm won't loop on that initial situation?
pt: Como sabe que o algoritmo simplório não vai entrar em loop nesta situação inicial?

note: type: Content of: <p>
en: Well, we simply tested all possible situations to see when this algorithm loops and when it finds the correct solution. We found that it works for all situations where no player is at home (there is 84 such situations for 4 bases, once you take the symmetries into account). It obviously works for some situations that do not respect this criteria (such as all situations it encounters from one of those 84 boards to the final state), but that's another story. Having such a criteria allows us to generate pseudo-random initial situations for the first exercise for which the algorithm we propose is guarenteed to work.
pt: Bem, simplesmente testamos todas as situações possíveis para ver quando este algoritmo entra em loop e quando acha a solução correta. Verificamos que funciona em todas as situações onde nenhum jogador está na casa dele (existem 84 situações destas para 4 bases, a considerar as simetrias). Obviamente funciona para algumas situações que não respeitam este critério (como todas as situações que encontra desde uma dessas 84 bases até ao estado final), mas isto é outra história. Dado tal critério podemos gerar situações iniciais pseudo-aleatórias para o primeiro exercício para o qual o algoritmo que propomos com certeza funciona.

note: type: Content of: <p>
en: We also explored bigger instances of the problem, and unfortunately, we have no such criteria for them.  With 5 bases, the algorithm wrongly loops for 24 of the 1824 possible boards where no player is home (that's 1.31%).  With 6 bases, it fails on 1251 of the 58860 such boards (2.12%). With 7 bases, it fails for 84444 out of 2633940 (that's 3.2%). I am still looking for a criteria ensuring that the algorithm won't loop. If you discover one, please report it. Ideally, it would be simple to enforce manually so that we can use it during our unplugged activities.
pt: Também exploramos instâncias maiores do problema e infelizmente, não temos tal critério para elas. Com 5 bases, o algoritmo entra em loop de forma errada para 24 dos 1824 possíveis tabuleiros onde nenhum jogador está na casa dele (que dá 1.31%).  Com 6 bases, falha em 1251 dos 58860 tabuleiros (2.12%). Com 7 bases, falha em 84444 dos 2633940 (3.2%). Ainda estou à procura dum critério que garanta que o algoritmo não vai entrar em loop. Se descobrir um, por favor avise. Idealmente, deve ser simples garantir manualmente de forma que possamos usá-lo durante as nossas atividades "unplugged".

note: type: Content of: <ul><li>
en: Other graphical representations could be proposed, such as a linear one (for the existing exercises) or other ones (such as a grid or a tree, if an exercise on this kind of graph proves interesting).
pt: Outras representações gráficas podem ser propostas, tais como uma linear (para os exercícios existentes) ou outros (como um grid ou uma árvore, se um exercício neste tipo de grafo se mostrar interessante).

note: type: Content of: <ul><li>
en: Other exercises on other algorithms on this variant, or on other variants such as the 15-puzzle.
pt: Outros exercícios em outros algoritmos desta variante, ou em outras variantes como o jogo do 15.

note: type: Content of: <h3>
en: Rainbow baseball
pt: basebal multicores

note: type: Content of: <p>
en: This is another funny variation on the sorting problem, adapting the main sorting algorithms on an unusual context.
pt: Este é outra variação divertida do problema da ordenação, a adaptar os pricipais algoritmos de ordenação num contexto inusitado.

note: type: Content of: <p>
en: The colors are represented by integers, between <code>0</code> and <code>amount of bases -1</code>.  The hole is represented by the special value <code>-1</code>.  The color of each base is its rank. So base <code>1</code> is of color <code>1</code>.  In the graphical interface, the base <code>0</code> is the dark blue one while the base <code>1</code> is the fuscia one.
pt: As cores são representadas por inteiros, entre <code>0</code> e <code>quantidade de bases -1</code>.  O espaço vazio é representado por um valor especial <code>-1</code>. A cor de cada base é o rank dela. Logo, a base <code>1</code> é de cor <code>1</code>. Na interface gráfica, a base <code>0</code> é a azul escura enquanto que a base <code>1</code> é a fuscia.

note: type: Content of: <p>
en: Once every players on the field are in their home base, the hole should be in the last base, that is of rank <code>getBasesAmount()-1</code>.
pt: Uma vez que todos os jogadores no campo estejam nas bases deles, o espaço vazio deve estar na última base, ou seja, a de rank <code>getBasesAmount()-1</code>.

note: type: Content of: <h2>
en: Functions to retrieve the world's dimensions
pt: FFunções para recuperar as dimensões do mundo

note: type: Content of: outside any tag (error?)
en: Returns the amount of bases on this field.
pt: Retorna a quantidade de bases neste campo.

note: type: Content of: outside any tag (error?)
en: Returns the amount of player's positions per base on this field.
pt: Retorna a quantidade de posições de jogadores por base neste campo.

note: type: Content of: <h2>
en: Functions to retrieve the world's state
pt: Funções para recuperar o estado do mundo

note: type: Content of: outside any tag (error?)
en: Returns the base in which the hole is located.
pt: Retorna a base na qual o espaço vazio está localizado.

note: type: Content of: outside any tag (error?)
en: Returns the hole position within its base
pt: Retorna a posição do espaço vazio na base dela

note: type: Content of: <pre>
en: [!java|c]int [/!]getPlayerColor([!java|c]int [/!]base[!scala]:Int[/!], [!java|c]int [/!]position[!scala]:Int[/!])  [!scala]:Int[/!]
pt: [!java|c]int [/!]getCorDoJogador([!java|c]int [/!]base[!scala]:Int[/!], [!java|c]int [/!]posição[!scala]:Int[/!])  [!scala]:Int[/!]

note: type: Content of: outside any tag (error?)
en: Returns the color of the player at a given location.
pt: Retorna a cor do jogador numa dada posição.

note: type: Content of: outside any tag (error?)
en: Returns whether all players of the field are at home.
pt: Retorna se todos os jogadores em campo estão nos "home" deles.

note: type: Content of: <pre>
en: [!java]boolean [/!][!c]int [/!]isBaseSorted([!java|c]int [/!]base)  [!scala]:Boolean[/!]
pt: [!java]boolean [/!][!c]int [/!]baseEstáOrdenada([!java|c]int [/!]base)  [!scala]:Boolean[/!]

note: type: Content of: outside any tag (error?)
en: Returns whether all players of a given base are at home.
pt: Retorna se todos os jogadores de uma dada base estão em "home".

note: type: Content of: <h2>
en: Functions to change the world
pt: Funções para mudar o mundo

note: type: Content of: <pre>
en: [!java|c]void [/!]move([!java|c]int [/!]base[!scala]:Int[/!], [!java|c]int [/!]position[!scala]:Int[/!])
pt: [!java|c]void [/!]mover([!java|c]int [/!]base[!scala]:Int[/!], [!java|c]int [/!]posição[!scala]:Int[/!])

note: type: Content of: outside any tag (error?)
en: Moves a given player into the hole. This throws an IllegalArgumentException if the specified player is not near the hole (at most one base away).
pt: Move um dado jogador para um espaço vazio. Vai levantar uma IllegalArgumentException se o jogador especificado não estiver próximo do espaço vazio (no máximo a uma base de distância).

note: type: Content of: <h1>
en: Naive Rainbow Baseball
pt: Basebal do arco-íris simples

note: type: Content of: <p>
en: Today, the buggles decided to play a baseball game, but they are rather out of luck, actually.  First, kinda forgot the rules, and ... well ... they cannot find the ball and bats again.  So they decided to "adapt a bit" the rules. As the are no ball, the buggles can only running around the field, what they do happily: for a while, all attending buggle run at full speed in all directions around the field.
pt: Hoje os buggles decidiram jogar um jogo de basebal, mas eles estão sem muita sorte, na verdade. Primeiro, eles esqueceram-se das regras e... bem... eles não acharam as bolas e tacos de novo. Então eles decidiram adaptar um pouco as regras. Como eles não são bolas, tudo que podem fazer é correr ao redor do campo, o que fazem felizes da vida: Por um período, todos os buggles correram na máxima velocidade em todas as direções pelo campo.

note: type: Content of: <p>
en: But after a few collisions, they decide to invent new rules to organize a bit the game: They make one team per base and two players per team. One of the teams has only one player so that its base has an empty location. Then, the players are dispatched randomly around the bases, and the game for them is to reach their home base. The whole game stops when all players are home.  There is no winning team: either all players win, or they all lose. Actually, this game is very different from the original baseball. The only rule that remains is that you can only run around the field, from one base to the next one, without crossing middle of the field.
pt: Mas depois de algumas colisões eles decidiram inventar novas regras para organizar o jogo um pouco: eles fizeram um time por base e dois jogadores por time. Um dos times tem apenas um jogador de forma que a base deles tem uma vaga. Então, os jogadores são despachados aleatoriamente entre as bases e o jogo deles é encontrar a base de origem deles. O jogo como um todo para quando todos os jogadores estão nas bases de origem delws. Não existe um time vencedor: ou todo mundo ganha ou todo mundo perde. Na verdade, este jogo é muito diferente do baseball original. A única regra que sobrou é que só pode correr ao redor do campo, de uma base à próxima, sem cruzar o meio do campo.

note: type: Content of: <p>
en: Now, they are asking you to help them deciding who and when should move so that each player returns to its base. Only one buggle can move at each round, from its position to the empty spot.  The maximal distance that a buggle can cover in one round is of one base.
pt: Agora, eles estão a pedir-lhe que lhes ajude a decidir quem se deve mover de forma que cada jogador retorne à sua base de origem. Apenas um buggle pode se mover por rodada, da posição dele para um espaço vazio. A distância máxima que um buggle pode percorrer numa rodada é de uma base.

note: type: Content of: <p>
en: So, at each round, the empty spot is on one base (say <code>B</code>), and you should decide which buggle enters that empty spot. There is four candidates (two from base <code>B-1</code> and two from base <code>B+1</code>). Actually, there is a fifth candidate since the buggle that is on the same base than the empty spot can change its position, but that's not really helping.
pt: Logo, em cada turno, o espaço vazio fica numa base (digamos <code>B</code>) e deve decidir que buggle vai entrar neste espaço vazio. Existem quatro candidatos (dois de base <code>B-1</code> e dois da base <code>B+1</code>). Na verdade, existe um quinto candidato pois o buggle que está na mesma base que o espaço vazio pode mudar de posição, mas isto não ajuda muito.

note: type: Content of: <h3>
en: The Naïve algorithm
pt: O algoritmo simplório

note: type: Content of: <p>
en: In this exercise, we will first explore a very simple algorithm. To decide which of the four candidate buggles should enter the empty spot, we first restrict ourselves and decide that buggles can only turn clockwise. Then, from the two remaining candidates, we pick the one that has the largest distance to cover to reach its base (turning clockwise). Click on the demo button: this works rather well in practice.
pt: Neste exercício, vamos primeiramente explorar um algoritmo muito simples. Para decidir qual dos quatro buggles candidatos deve entrar no espaço vazio, vamos primeiro nos restringir e decidir que os buggles só podem andar no sentido horário. Então, dos dois candidatos restantes, escolhemos o que tem a maior distância a percorrer para alcançar a base deles (no sentido horário). Clique no botão demo: isto funciona melhor, na prática.

note: type: Content of: <p>
en: It's hard to find a simpler algorithm for this problem: While it's not sorted, search for the base containing the candidate buggles: if the hole is in base <code>B</code>, it's the base <code>B+1</code>, modulo the amount of bases. Then, compute the distance that each buggle of that base still has to run to reach its base (0 if it's already home). Once you found the buggle that should enter the empty spot, just use the <code>move</code> method on it, and iterate.
pt: É difícil encontrar um algoritmo simples para este problema: Como não está ordenado, busque pela base a conter os buggles candidatos: se o vazio estiver na base <code>B</code>, será a base <code>B+1</code>, módulo a quantidade de bases. Então, calcule a distância que cada buggle daquela base ainda tem que andar para atingir a própria base (0 se já estiver na própria base). Uma vez que encontra o buggle que deve entrar no vazio, simplesmente use o método <code>move</code> nele e itere.

note: type: Content of: <p>
en: The main difficulty should be to get the few equations right: determining the base next to the hole should be easy, but determining the distance that a player has to cover may reveal a bit more challenging. Don't hesitate to draw pictures on a paper to cover all possible cases. It should not be that difficult either: there is not that many cases after all.
pt: A principal dificuldade deve ser obter corretamente as poucas equações: determinar a base próxima do espaço vazio deve ser fácil, mas determinar a distância que um jogador tem que cobrir pode se revelar um pouco desafiadora. Não hesite em desenhar esboços num papel para cobrir todas as possibilidades. Não vai ser tão difícil no final das contas: não existem tantos casos assim.

note: type: Content of: <p>
en: The previous algorithm is very pleasant: it's rather simple and rather fast to implement, but unfortunately, it is also rather wrong! In some cases, it never stops, which is obviously bad. If you don't believe it, just copy paste your previous code, and hit the run button. The first world of this exercise is one of these unfortunate situations that drives our previous algorithm crazy.
pt: O algoritmo anterior é muito agradável: é muito simples e muito rápido de implementar, mas infelizmente, é também bastante errado! Em alguns casos, nunca para, o que é obviamente ruim. Se não acredita, simplesmente copie e cole o seu código anterior e aperte no botão executar. O primeiro mundo deste exercício é uma destas situações infelizes que deixam endoidar o algoritmo anterior.

note: type: Content of: <p>
en: So we have to find another algorithm, preferably one that works in all cases.
pt: Portanto temos que encontrar outro algoritmo, preferencialmente um que funcione em todos os casos.

note: type: Content of: <p>
en: For that, the best solution is to start from a well known algorithm instead of trying to invent a new one from scratch as we just did. When you think a bit about this problem, this can is very similar to a sorting problem: Just make sure that the players are sorted by their colors and you're set. And while we are at it, let's generalize the game to allow more that 4 bases.
pt: Para isto, a melhor solução é começar de um algoritmo bem conhecido ao invés de tentar inventar um novo do zero como fizemos. Quando pensa um pouco sobre este problema, ele pode ser muito similar a um problema de ordenação: apenas se certifique de que todos os jogadores estão ordenados pelas cores deles. E enquanto fazemos isto, vamos generalizar o jogo para poder ter mais de 4 bases.

note: type: Content of: <p>
en: Let's adapt the selection sort to our situation. The big lines of the algorithm is then "for each base, select the players that should occupy this base and make sure that they come to their position". This way, we will grow an sorted area where all players are already sorted (and never changed) while the unsorted area shrinks.
pt: Vamos adaptar o selection sort para nossa situação. As linhas grandes do algoritmo se tornam "para cada base, selecione os jogadores que devem ocupar esta base e garanta que eles venham às posições deles". Desta forma, vamos aumentar uma área ordenada onde todos os jogadores já estão ordenados (e nunca deixam de estar) enquanto a área não-ordenada se reduz.

note: type: Content of: <p>
en: Selecting the player should be no problem; Do not hesitate to define some methods such as <code>findPlayer()</code> or <code>findPlayerBase()</code>. This will ensure that your code remains understandable.
pt: Selecionar o jogador não deve ser um problema; Não hesite para definir alguns métodos como <code>findPlayer()</code> ou <code>findPlayerBase()</code>. Isto vai garantir que o seu código permaneça entendível.

note: type: Content of: <p>
en: The most problematic aspect is to move the selected players into position. For that, you have to move the hole to the position where the player is, and then move both the player and the hole to the base that is next to the player's goal (probably in a loop), and finally put the player in the right position of its target base.
pt: O aspeto mais problemático é mover os jogadores selecionados para as posições deles. Para isto, tem que mover o espaço vazio à posição onde o jogador está e depois mover ambos os jogadores e o espaço vazio à base que estiver próxima do objetivo do jogador (provavelmente com um loop) e finalmente pôr o jogador na posição correta da base favorita dele.

note: type: Content of: <p>
en: As often in programming, the devil is in the details: there is a bunch of corner cases that you should detect and deal with correctly, such as the cases where the player is already in the base (but not in the position that you would like), or when the hole is on the right of the player (probably when you sort the first base). But you will find and hunt these while debugging your code.
pt: Como é comum em programação, o diabo esconde-se nos detalhes: existe um conjunto de casos particulares que deve detetar e lidar corretamente, como os casos onde o jogador já está na base (mas não na posição que gostaria), ou quando o buraco está à direita do jogador (provavelmente quando ordena a primeira base). Mas vai caçar tais coisas enquanto depurar o seu código.

note: type: Content of: <p>
en: The good point of adapting the selection sort to the baseball problem is that we know that it works (provided that our adaptation is correct). That's much better than the first naive algorithm, that was unable to converge to the solution in some situations. But actually, the selection sort is not perfect either as it requires a lot of swaps: we have to bring the hole to the selected player and then both the player and hole in position, and more. We can do better.
pt: O aspeto bom de adaptar o selection sort para o problema do basebol é que sabemos que isto funciona (desde que a nossa adaptação esteja correta). O que é muito melhor que o nosso primeiro e simplório algoritmo, que é incapaz de convergir à solução em algumas situações. Mas, na verdade, o selection sort também não é perfeito, pois requer muitas trocas: temos que trazer o espaço vazio para e jogador selecionado e então levar o jogador e o espaço vazio à posição e mais. Podemos fazer melhor.

note: type: Content of: <p>
en: For example, each player can run quite a long way from its initial position to its target solution.  Instead, it may be more interesting to split the field in two parts: one on the left where all players are sorted relatively to each others, and one on the right where the players are still at their initial positions. Then, at each iteration, we take the player at the border between the sorted and unsorted areas (that is, the left-most player of the unsorted area) and move it to the left (within the sorted area) until it reaches its position (that is, until the position where it's bigger that its left neighbor). This would at least reduce the travel of players to the sorted area as we use the first one on the border.
pt: Por exemplo, cada jogador pode correr por uma longa distância da posição inicial dele para o objetivo. Portanto, pode ser mais interessante dividir o campo em duas partes: uma à esquerda onde todos os jogadores estejam ordenados relativamente uns aos outros e outra à direita onde os jogadores ainda estejam nas posições iniciais deles. Então, em cada iteração, escolhemos o jogador na fronteira entre as áreas ordenada e não ordenada (ou sejam o jogador mais à esquerda da parte não ordenada) e moveremo-lo para a esquerda (dentro da parte ordenada) até que alcance a posição dele (ou seja, até a posição onde seja maior que o vizinho dele da esquerda). Isto pode, pelo menos, reduzir o trajeto dos jogadores à área ordenada já que usamos o mais perto da fronteira.

note: type: Content of: <p>
en: Actually, that's exactly what an insertion sort would do: maintain a sorted area on the left, and put iteratively the player on the border to its position within the sorted area. This is good, as we know that our algorithm is not inherently flawed since we adapt a well known one.
pt: Na verdade, é exatamente isto que o insertion sort deve fazer: manter uma área ordenada na esquerda e pôr iterativamente o jogador na fronteira com esta posição dentro da área ordenada. Isto é bom, já que sabemos que nosso algoritmo não é inerentemente "flawed" pois adaptamos um algoritmo bem conhecido.

note: type: Content of: <p>
en: The easiest to adapt the insertion sort to the baseball problem is to consider all positions as adjacent and forget about bases. For that, we define the methods <code>getColor[!c]Insert[/!](pos)</code>, <code>move[!c]Insert[/!](pos)</code> and <code>getHole[!c]Insert[/!]()</code> that all use a unique integer to designate a given position. These functions simply convert between the way to specify a position and then call the usual functions to interact with the world. If you have an <code>index</code> and want to convert it into a <code>base,pos</code>, then <code>base=index/2</code> and <code>pos=index%2</code>. To compute the reverse, <code>index=base*2+pos</code> (this works because <code>getPositionsAmount()</code> always returns 2).
pt: O mais fácil de adaptar o insertion sort ao problema do basebol é considerar todas as posições como adjacentes e esquecer-se das bases. Para isto, definimos os métodos <code>getColor[!c]Insert[/!](pos)</code>, <code>move[!c]Insert[/!](pos)</code> e <code>getHole[!c]Insert[/!]()</code> que usam, todos, um único inteiro para designar uma dada posição. Estas funções simplesmente convertem a forma de especificar uma posição para em seguida chamar as funções usuais para interagir com o mundo. Se tem um <code>index</code> e quer convertê-lo a <code>base,pos</code>, para então a <code>base=index/2</code> e <code>pos=index%2</code>. Para calcular o reverso, <code>index=base*2+pos</code> (isto funciona, pois <code>getPositionsAmount()</code> sempre retorna 2).

note: type: Content of: <p>
en: For the algorithm itself, you should first move the hole to the position 1. The position 0 is considered to be the sorted area (of size 1 for now) while the area above 2 is the unsorted area.  Then comes an iteration to sort each element of the unsorted area. Since this iteration is a bit complex, you should think of its loop invariant, that is, the condition that is true before and after the loop and which explains that the loop fulfills its goal. Here, the loop invariant is twofold: First, the hole is between the sorted area and the unsorted area, and then, the every elements of the sorted area are ... well sorted relatively to their neighbors.
pt: Para o algoritmo em si, deve primeiro mover o espaço vazio à posição 1. A posição 0 é considerada como a área ordenada (de tamanho 1 por enquanto) enquanto que a área acima de 2 é a área não-ordenada. Então fazemos uma iteração para ordenar cada elemento da área não-ordenada. Já que esta iteração é um pouco complexa, deve pensar no invariante dela do loop, ou seja, a condição que é verdadeira antes e depois do loop e que explica que o loop satisfaz o objetivo dele. Aqui, o invariante do loop é duplo: Primeiro, o espaço vazio está entre a área ordenada e a não-ordenada is between the sorted area and the unsorted area, and then, the every elements of the sorted area are ... well sorted relatively to their neighbors.

note: type: Content of: <p>
en: Then, the loop body to sort an element should first descend the hole and the elements within the sorted area until the element is larger than the element before in the sorted area (2 moves per position to travel), and then move the hole back to its position between the sorted and unsorted areas (1 move per position).
pt: Então, o corpo do loop para ordenar um elemento deve primeiro empurrar para baixo o espaço vazio e os elementos dentro da área ordenada até que o elemento seja maior que o elemento que está depois na área ordenada (2 movimentos por posição para se mover) e então mover o espaço vazio de volta para sua posição entre as áreas ordenadas e não-ordenadas (1 movimento por posição).

note: type: Content of: <p>
en: Once you insert the last element within the sorted area, your whole set is sorted and you're done.  I preserve the surprise of the border cases that will require some little adjustments to your algorithm to make it work properly :)
pt: Uma vez que insira o último elemento dentro da área ordenada, o seu conjunto como um todo estará ordenado e terá terminado. Vou deixar como surpresa os casos da fronteira que vão precisar de alguns pequenos ajustes no seu algoritmo para funcionar corretamente :)

note: type: Content of: <p>
en: Crap, we adapted the insertion sort because our selection sort required too much moves to get the selected players to their position, but the insertion sort requires an inordinate amount of changes to get the border elements to their position within the sorted area without mixing the already sorted elements. At the end of the day, our selection variant was more efficient with at most <code>3*amountOfBase</code> moves to sort one element (1 to get the hole alongside with the player, and 2 to get the hole+player in position) while our insertion variant requires at most <code>3*amountOfPlayers</code> to sort one element (2 to descend the hole and player in position, 1 to get the hole back to its position). That's twice as bad as there is two players per base. It may be possible to improve the insertion sort by moving by more than one element when descending, but it seems uneasy (at least, while not mixing the already sorted elements) and it would probably only ensure that our insertion variant becomes as efficient as our selection variant, not dramatically better.
pt: Puxa, adaptamos o insertion sort por que o selection sort precisava de muitos movimentos para pôr os jogadores selecionados nas posições deles, mas o insertion sort necessita de uma quantidade estúpida de mudanças para alcançar os elementos de fronteira para as posições deles dentro da área ordenada sem bagunçar os elementos já ordenados. No final, a nossa variante "selection" era mais eficiente com pelo menos <code>3*amountOfBase</code> movimentos para ordenar um elemento (1 para alcançar o espaço vazio ao lado do jogador e 2 para pôr o espaço vazio e o jogador em posição) enquanto a nossa variante "insertion" precisa de no máximo <code>3*amountOfPlayers</code> para ordenar um elemento (2 para descer o espaço vazio e o jogador na posição, 1 para trazer o espaço vazio de volta para a posição dele). Isto é duas vezes pior que ter dois jogadores por base. Pode ser possível melhorar o insertion sort a mover mais que um elemento enquanto desce, mas parece difícil (pelo menos, enquanto não misturar os elementos já ordenados) e provavelmente isto apenas vai garantir que a nossa variante "insertion" se torne tão eficiente como a nossa variante "selection", não dramaticamente melhor.

note: type: Content of: <p>
en: If we cannot make the sort faster, we can make it easier. If you think about it, it seems rather natural to adapt the bubble sort to this problem: the hole becomes the bubble that moves up and down, sorting a bit the array during each traversal. The big lines are simply: "while it's not sorted, move the hole down to base 0 (moving the biggest player of each base at each step) and then back to the maximal base (moving the smallest player of each base)". After a while, <code>isSorted()</code> will return true and your algorithm will stop.
pt: Se não pudermos tornar o ordenamento mais rápido, podemos torná-lo mais fácil. Se pensar a respeito, parece natural adaptar a ordenação bolha para este problema: o buraco se torna a bolha que se move para cima e para baixo, a ordenar um pouco o array a cada passagem. As linhas grandes são simples: "enquanto (while) não estiver ordenado, mova o buraco para baixo até a base 0 (a mover o maior jogador de cada base em cada passo) e então de volta à base maximal (a mover o menor jogador de cada base)". Depois de algum tempo, <code>isSorted()</code> vai retornar true e o seu algoritmo vai parar.

note: type: Content of: <p>
en: This is so easy that we introduce another variant of the problem, with more than two players per base.  But actually, that shouldn't block you very long, should it?
pt: Isto é tão fácil que vamos introduzir outra variante do problema, com mais de dois jogadores por base. Mas isto não vai te segurar por muito tempo, né?

note: type: Content of: <p>
en: Surprisingly, the bubble sort variant requires ways less moves than the other variants. This is astonishing because usually, the bubble sort performs much worse than the others sorts, but it comes from the very good match between its big lines and the baseball universe. It actually happens rather often that a pleasantly written algorithm performs very decently. But this is not an universal rule either, as demonstrated by the naive algorithm of the first exercise, that was nice, simple and wrong ;)
pt: Surpreendentemente, a variante bubble sort precisa de menos movimentos que as outras variantes. Isto é fantástico, por que normalmente, o bubble sort é muito pior que os outros algoritmos, mas isto é graças à boa combinação entre as linhas grandes deles e o universo do basebol. E, na verdade, acontece bastante de um algoritmo escrito de forma agradável executa de forma bem decente. Mas isto não é uma regra universal, como foi demonstrado pelo algoritmo simplório do primeiro exercício, que era legal, simples e errado ;)

note: type: Content of: <h1>
en: The universe of turtles
pt: O universo das tartarugas

note: type: Content of: <p>
en: This is an adaptation of LOGO for the Programmer's Learning Machine.
pt: Esta é uma adaptação do LOGO para o Programmer's Learning Machine.

note: type: Content of: <p>
en: It is directly inspired from the work of the mathematician Seymour Papert in the 60's. Inspired from the swiss psycholog Jean Piaget, he came up with a learning method called LOGO to teach programming to young childs. The world is full of turtles which leave a painting where they go and which respond to simple orders.
pt: É diretamente inspirado no trabalho do matemático Seymour Papert nos anos 60. Inspirado no psicólogo suíço Jean Piaget, apresentou um método de ensino chamado LOGO para ensinar programação para crianças pequenas. O mundo é cheio de tartarugas que deixam um rastro de tinta por onde passam e que obedecem a comandos simples.

note: type: Content of: <h2>
en: Functions to move the turtle
pt: Funções para mover a tartaruga

note: type: Content of: <pre>
en: [!java|c]void [/!]forward([!java|c]double [/!]steps[!scala]:Double[/!])
    [!java|c]void [/!]backward([!java|c]double [/!]steps[!scala]:Double[/!])
pt: [!java|c]void [/!]avançar([!java|c]double [/!]passos[!scala]:Double[/!])
    [!java|c]void [/!]recuar([!java|c]double [/!]passos[!scala]:Double[/!])

note: type: Content of: outside any tag (error?)
en: Moves forward or backward of the requested amount of steps.
pt: Move para frente e para trás na quantidade de passos pedidos.

note: type: Content of: <pre>
en: [!java|c]void [/!]right([!java|c]double [/!]angle[!scala]:Double[/!])
    [!java|c]void [/!]left([!java|c]double [/!]angle[!scala]:Double[/!])
pt: [!java|c]void [/!]direita([!java|c]double [/!]ângulo[!scala]:Double[/!])
    [!java|c]void [/!]esquerda([!java|c]double [/!]ângulo[!scala]:Double[/!])

note: type: Content of: outside any tag (error?)
en: Turns left or right of the given angle (in degrees).
pt: Vira à esquerda ou à direita um dado ângulo (em graus).

note: type: Content of: outside any tag (error?)
en: Returns the current position of the turtle.  Note that the point (0,0) is on the top left corner, as it is often the case in Computer Science.
pt: Retorna a posição atual da tartaruga. Observe que o ponto (0,0) está no canto superior esquerdo, como é comum na ciência da computação.

note: type: Content of: outside any tag (error?)
en: Teleports the turtle to a new position (without leaving any trace).
pt: Teletransporta a tartaruga para uma nova posição (sem deixar rastros).

note: type: Content of: <pre>
en: [!java|c]void [/!]moveTo([!java|c]double [/!]x[!scala]:Double[/!], [!java|c]double [/!]y[!scala]:Double[/!])
pt: [!java|c]void [/!]moverPara([!java|c]double [/!]x[!scala]:Double[/!], [!java|c]double [/!]y[!scala]:Double[/!])

note: type: Content of: outside any tag (error?)
en: Moves the turtle to a new position.
pt: Move a tartaruga para uma nova posição.

note: type: Content of: <pre>
en: [!java|c]void [/!]circle([!java|c]double [/!]radius[!scala]:Double[/!])
pt: [!java|c]void [/!]círculo([!java|c]double [/!]raio[!scala]:Double[/!])

note: type: Content of: outside any tag (error?)
en: Draw a circle of the specified radius centered on the turtle.
pt: Desenha um círculo de raio especificado com o centro na tartaruga.

note: type: Content of: outside any tag (error?)
en: Hides the turtle.
pt: Esconde a tartaruga.

note: type: Content of: outside any tag (error?)
en: Shows the turtle back.
pt: Mostra novamente a tartaruga.

note: type: Content of: outside any tag (error?)
en: Returns whether the turtle is currently visible.
pt: Retorna se a tartaruga é visível ou não.

note: type: Content of: outside any tag (error?)
en: Removes any trail on the sheet.
pt: Remove todos os rastros do papel.

note: type: Content of: outside any tag (error?)
en: Returns the current heading of the turtle (in degrees).
pt: Retorna a direção atual da tartaruga (em graus).

note: type: Content of: <pre>
en: [!java|c]void [/!]setHeading([!java|c]double [/!]angle[!scala]:Double[/!])
pt: [!java|c]void [/!]setDireção([!java|c]double [/!]ângulo[!scala]:Double[/!])

note: type: Content of: outside any tag (error?)
en: Sets a new heading to the turtle (in degrees).
pt: Ajusta uma nova direção para a tartaruga (em graus).

note: type: Content of: <h2>
en: Functions about the pen
pt: Funções da caneta

note: type: Content of: outside any tag (error?)
en: Moves the pen up (turtles have pens, not brushes as buggles). The turtle will not leave any trace during its subsequent moves.
pt: Levanta a caneta (tartarugas têm canetas, não pinceis, como os buggles). A tartaruga não vai deixar nenhum rastro durante os seus passos seguintes.

note: type: Content of: outside any tag (error?)
en: Moves the pen down. The turtle will leave a trace during its subsequent moves.
pt: Abaixa a caneta. A tartaruga vai deixar um rastro nos próximos movimentos.

note: type: Content of: outside any tag (error?)
en: Returns the current pen position as a boolean.
pt: Retorna a posição atual da caneta como um booleano.

note: type: Content of: outside any tag (error?)
en: Returns the current pen color.
pt: Retorna a cor atual da caneta.

note: type: Content of: <pre>
en: [!java|c]void [/!]setColor([!java|c]Color [/!]color[!scala]:Color[/!])
pt: [!java|c]void [/!]setCor([!java|c]Cor [/!]cor[!scala]:Cor[/!])

note: type: Content of: outside any tag (error?)
en: Changes the pen color.
pt: Muda a cor da caneta.

note: type: Content of: <h2>
en: Other functions
pt: Outras funções

note: type: Content of: outside any tag (error?)
en: Returns whether the current turtle is selected in the graphical interface.
pt: Retorna se a tartaruga atual está selecionada na interface gráfica.

note: type: Content of: <p>
en: Since its inception in the 60's, the LOGO turtle fascinates by its ability to draw nice figures on computer.  This lesson allows you to explore some of the classical figures, and draw your own.
pt: Desde a concepção dela nos anos 60, a tartaruga do LOGO fascinou pela habilidade dela de desenhar belas figuras no computador. Este lição permite que explore algumas das figuras clássicas e desenhe as suas próprias.

note: type: Content of: <p>
en: The language's syntax is absolutely not presented, but if you know a bit of it or if someone tells you, you can take these exercises even if you are an absolute beginner in programming.
pt: A sintaxe da linguagem é não vai ser apresentada, mas se conhece um pouco ou se alguém lhe mostrar, pode tentar estes exercícios mesmo a ser um completo iniciante em programação.

note: type: Content of: <p>
en: Please send us your best contributions so that they get added to this gallery to inspire the next ones.
pt: Por favor mande-nos as suas melhores contribuições para que sejam adicionadas a esta galeria para inspirar os próximos utilizadores.

note: type: Content of: <ul><li>
en: Other exercises should be added. A whole lot of exercises are available from <a href="http://neoparaiso.com/logo/#sect4">http://neoparaiso.com/logo/#sect4</a> or from <a href="http://billkerr2.blogspot.fr/2009/08/40-maths-shapes-challenges.html.">http://billkerr2.blogspot.fr/2009/08/40-maths-shapes-challenges.html</a>.
pt: Outros exercícios devem ser adicionados. Um conjunto completo de exercícios está disponível em <a href="http://neoparaiso.com/logo/#sect4">http://neoparaiso.com/logo/#sect4</a> ou em <a href="http://billkerr2.blogspot.fr/2009/08/40-maths-shapes-challenges.html.">http://billkerr2.blogspot.fr/2009/08/40-maths-shapes-challenges.html</a>.

note: type: Content of: <ul><li>
en: Missing: the built-ins arc() and arcTo(), that draw an arc, either w/o moving or by moving to the end of the arc.
pt: A faltar: os built-ins arc() e arcTo(), que desenham um arco, tanto a mover ou sem mover para o final do arco.

note: type: Content of: <p>
en: Draw beautiful figures with the Logo turtle, and learn programming while playing.
pt: Desenhe belas figuras com a tartaruga do Logo e aprenda a programar enquanto brinca.

note: type: Content of: <p>
en: You should know the basic syntax of the programming language you will choose, but no exhaustive programming practice is required to take this lesson.
pt: Deve saber a sintaxe básica da linguagem de programação que escolher, mas técnicas avançadas de programação não são necessárias para fazer esta lição.

note: type: Content of: <p>
en: This world allows you to experiment with the recursive lists, as they were first introduced in Lisp. It is very similar to the BatWorld, but you are supposed to write recursive functions working on [!python|java]recursive strings. Since [!thelang] does not provide such a construct natively, the ConsWorld defines recursive lists of type <code>RecList</code>.[/!] [!scala]lists of integers (<code>List[Int]</code>).[/!]
pt: Este mundo permite que experimente com listas recursivas, pois foi introduzido primeiro em Lisp. É muito similar ao BatWorld, mas deve escrever funções recursivas que funcionem em [!python|java]cadeias recursivas. Desde que [!thelang] não fornece tal contrução nativamente, o ConsWorld define listas recursivas do tipo <code>RecList</code>.[/!] [!scala]listas de inteiros (<code>List[Int]</code>).[/!]

note: type: Content of: <p>
en: Any given such list is either the empty list (noted <code>[!scala]Nil[/!][!java]null[/!][!python]None[/!]</code>), or an integer followed by a list. If a list is not empty, you can retrieve its first integer with <code>list.head</code> and the list containing its other parameters with <code>list.tail</code>. Of course, the empty list has no head nor the tail, so trying to access these elements will result in an (unpleasant) error message.
pt: Qualquer lista dada é ou a lista vazia (noted <code>[!scala]Nil[/!][!java]null[/!][!python]None[/!]</code>), ou um inteiro seguido de uma lista. Se uma lista não é vazia, pode recuperar o primeiro inteiro dela com <code>list.head</code> e a lista a conter os demais parâmetros com <code>list.tail</code>. Obviamente, a lista vazia não tem head nem tail, portanto, tentar acessar estes elementos vai resultar numa mensagem de erro (desagradável).

note: type: Content of: <p>
en: To build your own list, you need to concatenate a head and a tail as follows: [!java|python]<code>cons(head, tail)</code>[/!] [!scala]<code>head::tail</code> Note that <code>::</code> is a generic operator in Scala to build lists.[/!]
pt: Para construir a sua própria lista, precisa concatenar um head e um tail como segue: [!java|python]<code>cons(head, tail)</code>[/!] [!scala]<code>head::tail</code> Observe que <code>::</code> é um operador genérico em Scala para construir listas.[/!]

note: type: Content of: <p>
en: So, in summary, you can solve every exercises of this lesson with the following constructs.
pt: Logo, a resumir, pode resolver cada exercício desta lição com as seguintes construções.

note: type: Content of: <ul><li>
en: <b>The empty list:</b>
pt: <b>A lista vazia:</b>

note: type: Content of: <ul><li>
en: <b>Get the first element of <code>l</code></b>
pt: <b>Obtém o primeiro elemento de <code>l</code></b>

note: type: Content of: <ul><li>
en: <b>Get the rest of the list</b>, when the first element is removed:
pt: <b>Obtém o resto da lista</b>, quando o primeiro elemento é removido:

note: type: Content of: <ul><li>
en: <b>Build a list</b> from a <code>value</code> and a <code>list</code>: [!java|python]
pt: <b>Constrói uma lista</b> a partir de um <code>valor</code> e uma <code>lista</code>: [!java|python]

note: type: Content of: <h1>
en: Recursive Lists
pt: Listas Recursivas

note: type: Content of: <p>
en: This lesson contains a bunch of classical exercises on recursive lists.  It is certainly not the most pleasant lesson to do, but I think that it is the easiest of the PLM lessons dealing with recursion.
pt: Esta lição contém um monte de exercícios clássicos com listas recursivas. Com certeza não é a lição mais agradável para fazer, mas das lições do PLM que lidam com recursão, acho esta a mais fácil.

note: type: Content of: <ul><li>
en: New exercises could be proposed, such as http://webloria.loria.fr/~quinson/Teaching/TOP/02-td-recursivite-enonce.pdf If you know some others, please report them as an issue.
pt: Novos exercícios podem ser propostos, como http://webloria.loria.fr/~quinson/Teaching/TOP/02-td-recursivite-enonce.pdf. Se conhecer outros, por favor abra uma "issue" para relatar.

note: type: Content of: <ul><li>
en: It would be interesting to check the asymptotic complexity of the student's code, but that does not sound easy to do. In Python and Java (where we provide a hand-made RecList class), we could count the amount of cons per exercise, but it won't be easy to relate this to the right BatTest. For Scala, it sounds even more difficult as we use the classical :: operators of the language. That will be difficult to override to add a counting mechanism. Another solution would be to ensure that the call stack does not pass a given threshold, but that sounds very difficult too. Any idea is welcome.
pt: Pode ser interessante verificar a complexidade assintótica do código do estudante, mas isto não parece fácil de fazer. Em Python e Java (onde fornecemos uma classe RecList feita à mão), podemos contar a quantidade de cons por exercício, mas não é fácil relacionar isto ao BatTest correto. Para Scala, parece ainda mais difícil, pois usamos os operadores :: clássicos da linguagem. Vai ser difícil fazer uma sobreposição ("override") para adicionar um mecanismo de contagem. Outra solução seria garantir que a pilha de chamadas não passe de um dado limiar, mas parece muito difícil de fazer também. Quaisquer ideias são bem-vindas.

note: type: Content of: <h1>
en: Length
pt: Comprimento

note: type: Content of: outside any tag (error?)
en: Given a [!scala]List[Int][/!][!java|python]recursive list[/!], return its length[!scala] (without using its <code>size</code> method, of course)[/!].  [!java|python]
pt: Dada uma [!scala]Lista[Int][/!][!java|python]lista recursiva[/!], retorna o comprimento dele[!scala] (sem usar o método <code>size</code> dele, claro)[/!].  [!java|python]

note: type: Content of: <p>
en: [!python]Be careful, you are not supposed to use the Python lists, but the specific type defined in this exercise. [/!] Please refer to the world's documentation for more information about recursive lists.
pt: [!python]Cuidado, não pode usar listas de Python, mas sim o tipo específico definido neste exercício. [/!] favor ver a documentação do mundo para mais informações a respeito de listas recursivas.

note: type: Content of: <p>
en: Your solution should be linear in time.
pt: A sua solução deve ser linear no tempo.

note: type: Content of: outside any tag (error?)
en: Given a [!scala]List[Int][/!][!java|python]recursive list[/!] and an integer, return true if the given integer is one of the elements of the list, or false if it cannot be found.
pt: Dada uma [!scala]List[Int][/!][!java|python]recursive list[/!] e um inteiro, retorna true se o dado inteiro é um dos elementos desta lista, ou false se não for encontrado.

note: type: Content of: outside any tag (error?)
en: Given a [!scala]List[Int][/!][!java|python]recursive list[/!] and an integer, return the amount of occurrences of the given integer in the list. If the integer is not a member of the list, the function should thus return 0.
pt: Dada uma [!scala]List[Int][/!][!java|python]recursive list[/!] e um inteiro, retorna a quantidade de ocorrências de um dado inteiro na lista. Se o inteiro não for um membro da lista, a função deve retornar 0.

note: type: Content of: outside any tag (error?)
en: Given a [!scala]List[Int][/!][!java|python]recursive list[/!], return its last element.  You can assume that the list is not empty.
pt: Dada uma [!scala]List[Int][/!][!java|python]recursive list[/!], retorna o último elemento dela. Pode assumir que a lista não é vazia.

note: type: Content of: outside any tag (error?)
en: Given a [!scala]List[Int][/!][!java|python]recursive list[/!], return the smallest of its values.  You will probably need an extra function, even if you can assume that the list is not empty.
pt: Dada uma [!scala]List[Int][/!][!java|python]recursive list[/!], retorna o menor dos seus valores. Vai precisar provavelmente de uma função adicional, mesmo se puder assumir que a lista é não vazia.

note: type: Content of: outside any tag (error?)
en: Given a [!scala]List[Int][/!][!java|python]recursive list[/!], return whether its elements form an increasing sequence (i.e., if the elements are sorted from the smallest to the largest one).
pt: Dada uma [!scala]List[Int][/!][!java|python]recursive list[/!], retorna se os elementos dela estão em ordem crescente (p.ex., se os elementos são ordenados do menor ao maior).

note: type: Content of: outside any tag (error?)
en: Given a [!scala]List[Int][/!][!java|python]recursive list[/!], return the list containing every elements but the last one.  You can assume that the list is not empty.
pt: Dada uma [!scala]List[Int][/!][!java|python]recursive list[/!], retorna a lista a conter todos os elementos exceto o último. Pode assumir que a lista é não vazia.

note: type: Content of: outside any tag (error?)
en: Given a [!scala]List[Int][/!][!java|python]recursive list[/!], return a new list containing all elements of your parameter incremented by one.
pt: Dada uma [!scala]List[Int][/!][!java|python]recursive list[/!], retorne uma nova lista a conter todos os elementos do seu parâmetro incrementados de um.

note: type: Content of: outside any tag (error?)
en: Given a [!scala]List[Int][/!][!java|python]recursive list[/!] <code>L</code>and an integer, return a new list containing all elements of <code>L</code> that are not equal to the value received as parameter.
pt: Dada uma [!scala]List[Int][/!][!java|python]recursive list[/!] <code>L</code> e um inteiro, retorna uma nova lista a conter todos os elementos de <code>L</code> que não são iguais ao valor recebido como parâmetro.

note: type: Content of: outside any tag (error?)
en: Given a [!scala]List[Int][/!][!java|python]recursive list[/!] and an integer <code>N</code>, return the <code>N</code>th element of the list.
pt: Dada uma [!scala]List[Int][/!][!java|python]recursive list[/!] e um inteiro <code>N</code>, retorna o <code>N</code>-ésimo elemento da lista.

note: type: Content of: <p>
en: You can assume that the list is long enough, i.e. that there is at least <code>N</code> elements.  Your solution should be linear in time.
pt: Pode assumir que a lista é longa o suficiente, p.ex. que existe pelo menos <code>N</code> elementos. A sua solução deve ser linear no tempo.

note: type: Content of: outside any tag (error?)
en: Given a [!scala]List[Int][/!][!java|python]recursive list[/!] and an integer <code>N</code>, return the list constituted of the first <code>N</code> elements. You can assume that the list is long enough, i.e. that there is at least <code>N</code> elements.
pt: Dada uma [!scala]List[Int][/!][!java|python]recursive list[/!] e um inteiro <code>N</code>, retorna a lista constituída dos primeiros <code>N</code> elementos. Pode assumir que a lista é longa o suficiente, p.ex. que existem pelo menos <code>N</code> elementos.

note: type: Content of: outside any tag (error?)
en: Given a [!scala]List[Int][/!][!java|python]recursive list[/!] and an integer <code>N</code>, return the list with only the <code>N</code> last elements.
pt: Dada uma [!scala]List[Int][/!][!java|python]recursive list[/!] e um inteiro <code>N</code>, retorna a lista com apenas os últimos <code>N</code> elementos.

note: type: Content of: <p>
en: Your solution should be linear in time, but you will probably need to define several functions to achieve that complexity.
pt: A sua solução deve ser linear no tempo, mas provavelmente precisa definir várias funções para alcançar esta complexidade.

note: type: Attribute 'alt' of: <div>
en: I cannot do it in linear time
pt: Não posso fazer isto em tempo linear

note: type: Content of: <div>
en: The trick is to compute only once (and beforehand) how many elements you should keep.
pt: O segredo é calcular apenas uma vez (e previamente) quantos elementos deve guardar.

note: type: Content of: outside any tag (error?)
en: Given a [!scala]List[Int][/!][!java|python]recursive list[/!] and an integer <code>N</code>, return the list without the <code>N</code> first elements.
pt: Dada uma [!scala]List[Int][/!][!java|python]recursive list[/!] e um inteiro <code>N</code>, retorne a lista sem os primeiros <code>N</code> elementos.

note: type: Content of: outside any tag (error?)
en: Given a [!scala]List[Int][/!][!java|python]recursive list[/!] and an integer <code>N</code>, return the list without the <code>N</code> last elements.
pt: Dada uma [!scala]List[Int][/!][!java|python]recursive list[/!] e um inteiro <code>N</code>, retorna a lista sem os últimos <code>N</code> elementos.

note: type: Content of: outside any tag (error?)
en: Given a [!scala]List[Int][/!][!java|python]recursive list[/!], return a new list with all elements in reverse order.
pt: Dada uma [!scala]List[Int][/!][!java|python]recursive list[/!], retorna uma nova lista com todos os elementos em ordem inversa.

note: type: Content of: <p>
en: This function is very important and you should not pass that challenge.  Your solution should be linear in time, with the help of helper functions.
pt: Esta função é muito importante e não deve pular este desafio. Sua solução deve ser linear no tempo, com a ajuda de funções auxiliares.

note: type: Content of: <div>
en: You need an helper function in which the result is accumulated (built) at each step.
pt: Precisa de uma função auxiliar na qual o resultado é acumulado (construído) em cada passo.

note: type: Content of: outside any tag (error?)
en: Given two [!scala]List[Int][/!][!java|python]recursive list[/!] <code>l1</code> and <code>l2</code>, return a new list with all elements of <code>l1</code> followed by the elements of <code>l2</code>.
pt: Dadas duas [!scala]List[Int][/!][!java|python]recursive list[/!] <code>l1</code> e <code>l2</code>, retorna uma nova lista com todos os elementos de <code>l1</code> seguidos de todos os elementos de <code>l2</code>.

note: type: Content of: <div>
en: You need to modify <code>l1</code> beforehand so that the computations at each step of the recursion are in constant time.
pt: Precisa modificar <code>l1</code> antes de forma que os cálculos em cada passo da recursão sejam em tempo constante.

note: type: Content of: outside any tag (error?)
en: Given a [!scala]List[Int][/!][!java|python]recursive list[/!], return true if any two elements of the list are different (ie, if no element appears more than once in the list).
pt: Dada uma [!scala]List[Int][/!][!java|python]recursive list[/!], retorne true se quaisquer dois elementos da lista são diferentes (ie, se nenhum elemento aparece mais de uma vez na lista).

note: type: Content of: <p>
en: The simplest solution is in O(n²), meaning that it runs in quadratic time.  You will probably have to define one extra function for that.  Another much more complex solution runs in O(n log(n)).
pt: A solução mais simples é em O(n²), o que significa que executa em tempo quadrático. Provavelmente terá que definir uma função adicional para isto. Outra solução muito mais complexa executa em O(n log(n)).

note: type: Content of: <h1>
en: Recursive algorithms
pt: Algoritmos recursivos

note: type: Content of: outside any tag (error?)
en: This lesson allows to experiment with recursive algorithms.
pt: Esta lição permite que se experimente com algoritmos recursivos.

note: type: Content of: <p>
en: If you need more recursive algorithms, an exercise on recursive sorting algorithms (in particular QuickSort and MergeSort) is planned in the future within the sorting lesson.
pt: Se precisa de mais algoritmos recursivos, um exercício em algoritmos de ordenação recursivos (em particular QuickSort e MergeSort) está planejado no futuro dentro da lição de ordenação.

note: type: Content of: <h3>
en: What can I do to improve this lesson?
pt: O que ru posso fazer para melhorar esta lição?

note: type: Content of: <p>
en: As usual, there are several things that could be done in this lesson to improve it further:
pt: Como sempre, existem várias coisas que podem ser feitas nesta lição para melhorar ela ainda mais:

note: type: Content of: <ul><li>
en: The Sierpinski triangle can be drawn using a simpler L-system. See http://jpvallon.free.fr/recursivite.html
pt: O triângulo de Sierpinski pode ser desenhado a usar um L-system mais simples. Veja em http://jpvallon.free.fr/recursivite.html

note: type: Content of: <ul><li>
en: The arrowhead curve is also interesting: http://www.mathcurve.com/fractals/sierpinski/sierpinskitriangle.shtml
pt: A curva "arrowhead" também é interessante: http://www.mathcurve.com/fractals/sierpinski/sierpinskitriangle.shtml

note: type: Content of: <ul><li>
en: The dragon curve could be explained as a L-system: http://ecademy.agnesscott.edu/~lriddle/ifs/heighway/heighway.htm
pt: A curva do dragão pode ser explicada como um L-system: http://ecademy.agnesscott.edu/~lriddle/ifs/heighway/heighway.htm

note: type: Content of: <ul><li>
en: The dragon2 curve is called the twin dragon: http://ecademy.agnesscott.edu/~lriddle/ifs/heighway/twindragon.htm
pt: A curva do dragão2 é chamada de "twin dragon": http://ecademy.agnesscott.edu/~lriddle/ifs/heighway/twindragon.htm

note: type: Content of: <ul><li>
en: The space filling curves could be added (Peano, Hildebert, etc).  See: http://teachout1.net/village/fill.html
pt: As curvas de preenchimento de spaço podem ser adicionadas (Peano, Hildebert, etc).  Veja: http://teachout1.net/village/fill.html

note: type: Content of: <ul><li>
en: We could do another exercise on embeeded polygons: http://www.inrialpes.fr/helix/people/genoud/ENSJAVA/tds/sujets/dessinsReccursifs/actionsrecursives.html
pt: Podemos fazer outro exercício em polígonos "embeeded": http://www.inrialpes.fr/helix/people/genoud/ENSJAVA/tds/sujets/dessinsReccursifs/actionsrecursives.html

note: type: Content of: <h3>
en: Bases of recursion
pt: As bases da recursão

note: type: Content of: <p>
en: Discover the recursive way of thinking by drawing trees and other figures with the Logo turtle.
pt: Descobrir a forma recursiva de pensar a desenhar árvores e outras figuras com a tartaruga do Logo.

note: type: Content of: <h2>
en: The small cousines of Buggles
pt: Os primos menores dos buggles

note: type: Content of: <p>
en: Today, we will meet the small cousines of the buggles: the turtles. In fact, turtles are much olders than the buggles. They were invented in the 70's by a scientific from MIT called Seymour Papert to help teaching programming, and the buggles are a variation on the idea invented by Lyn Turbak from Wellesley College later.
pt: Hoje vamos conhecer os primos menores dos buggles: as tartarugas. Na verdade, as tartarugas são muito mais velhas que os buggles. Elas foram inventadas nos anos 70 por um cientista do MIT chamado Seymour Papert para ajudar no ensino de programação e os buggles são uma variação da idéia seguinte de Lyn Turbak do Wellesley College.

note: type: Content of: <p>
en: Turtles are thus a bit like buggles, but smaller. Just like buggles, you can order them to move forward, to turn, to move backward, etc. Just like buggles, they leave a line on their path when they move (but the line is much smaller).
pt: Tartarugas então, são meio parecidas com buggles, mas menores. Como os buggles, pode mandar que elas se movam para a frente, virem, se movam para trás, etc. Como os buggles, elas deixam uma linha no caminho por onde passam (mas a linha é muito menor).

note: type: Content of: <p>
en: The main difference is that where buggles can only move of right angles, turtles can move of any arbitrary angles specified by a real number (a double). This gives them much more liberty in their movings. The buggles can do several other tricks, like reading and writting messages, picking or dropping objects, and there is sometimes walls in their worlds (but all this is completely above the capacities of turtles).
pt: A principal diferença é que enquanto os buggles podem se mover apenas em ângulos retos, as tartarugas podem se mover em qualquer ângulo especificado por um número real (um double). Isto dá-lhes muito mais liberdade nos movimentos deles. Já os buggles podem fazer vários outros truques, como ler e escrever mensagens, apanhar e soltar objetos e às vezes lidar com paredes existentes nos mundos (mas isto está totalmente além da capacidade das tartarugas).

note: type: Content of: <p>
en: From a practical point of view, most of the methods you knew about buggles still work with turtles, with some minor adaptations. In particular, the <code>forward()</code> method takes the amount of steps to do not as an integer, but as a [!python]point number[/!][!java|scala|c]double[/!] (see "About this world" for more details).
pt: De um ponto de vista prático, a maioria dos métodos que conhece sobre buggles ainda funciona com tartarugas, com pequenas adaptações. Em particular, o método <code>forward()</code> leva a quantidade de passos a dar não como inteiro, mas como [!python]point number[/!][!java|scala|c]double[/!] (veja "Sobre este mundo" para maiores detalhes).

note: type: Content of: <h3>
en: Doubles? But what is it?
pt: Doubles? Mas o que é isto?

note: type: Content of: outside any tag (error?)
en: It's simply a point number. Example:
pt: é simplesmente um número com vírgula. Por exemplo:

note: type: Content of: <pre>
en: double x = 3.72;
    x + 1.234 // Value = 4.954
    x + 2. // Value = 5.72 (2. means 2.0)
    x + 2 // [!java|c]Value = 5.72 (2 automatically converted to 2.0)[/!][!scala]Type error (+ operator don't mix Double and Int); manual conversion mandatory[/!]
    x * 2. // Value = 7.44 
    x / 2. // Value = 1.86 
    [!java|c](int) x[/!][!scala]x.asInstanceOf[Int][/!] // Value = 1 (“casting to int”, converted to integer by truncating)
    Math.round(x) // Value = 2 (1.86 rounded to nearest integer)
    Math.floor(x) // Value = 1 (1.86 rounded toward minus infinity)
    Math.floor(-5.12) // Value = -6 (rounded toward minus infinity)
    Math.ceiling(x) // Value = 2 (1.86 rounded toward plus infinity)
    Math.ceiling(-5.12) // Value = -5 (rounded toward plus infinity)
    [!java|c](double) 17[/!][!scala]17.asInstanceOf[Double][/!] // Value = 17.0 (“casted to double”, converted to double)
pt: double x = 3.72;
    x + 1.234 // Valor = 4.954
    x + 2. // Valor = 5.72 (2. significa 2.0)
    x + 2 // [!java|c]Value = 5.72 (2 convertido automaticamente em 2.0)[/!][!scala]Erro de tipo (o operador + não mistura Double e Int); é obrigatória a conversão manual[/!]
    x * 2. // Valor = 7.44 
    x / 2. // Valor = 1.86 
    [!java|c](int) x[/!][!scala]x.asInstanceOf[Int][/!] // Valor = 1 (“a fazer cast para int”, convertido para integer a truncar)
    Math.round(x) // Valor = 2 (1.86 arredondado ao inteiro mais próximo)
    Math.floor(x) // Valor = 1 (1.86 rounded toward minus infinity)
    Math.floor(-5.12) // Valor = -6 (rounded toward minus infinity)
    Math.ceiling(x) // Valor = 2 (1.86 rounded toward plus infinity)
    Math.ceiling(-5.12) // Valor = -5 (rounded toward plus infinity)
    [!java|c](double) 17[/!][!scala]17.asInstanceOf[Double][/!] // Valor = 17.0 (“feito cast para double”, convertido para double)

note: type: Content of: <p>
en: Even if this is the first exercise on the recursivity lesson, the code you have to write is not recursive. The goal is to get familiar with the turtle world before getting on serious matter.
pt: Mesmo este a ser o primeiro exercício da lição de recursividade, o código que tem que escrever não é recursivo. O objetivo é se familiarizar com o mundo da tartaruga antes da coisa começar a ficar séria.

note: type: Content of: <p>
en: You must reproduce a simple geometrical painting constituted of four 100 steps long squares (see the objective world for more details). It is obviously a good idea to write a method to draw a square, and then use it in your code.
pt: Deve reproduzir uma pintura geometricamente simples de quatro quadrados de comprimento de 100 passos (veja o mundo objetivo para mais detalhes). É obviamente uma boa ideia escrever um método para desenhar um quadrado e então usá-lo no nosso código.

note: type: Content of: <h2>
en: Fractal of polygons
pt: Fractal de polígonos

note: type: Content of: outside any tag (error?)
en: The fractal we will now draw is formed of a polygon, with little polygons on each corner. The prototype of the method drawing it is the following:
pt: O fractal que vamos desenhar agora é formado de um polígono, com pequenos polígonos em cada canto. O protótipo do método que vai desenhá-lo é o seguinte:

note: type: Content of: <pre>
en: [!java|c]void [/!]polygonFractal ([!java|c]int [/!]levels[!scala]:Int[/!], [!java|c]int [/!]sides[!scala]:Int[/!], [!java|c]double [/!]length[!scala]:Double[/!], [!java|c]double [/!]shrink[!scala]:Double[/!])
pt: [!java|c]void [/!]fractalDoPolígono ([!java|c]int [/!]níveis[!scala]:Int[/!], [!java|c]int [/!]lados[!scala]:Int[/!], [!java|c]double [/!]comprimento[!scala]:Double[/!], [!java|c]double [/!]shrink[!scala]:Double[/!])

note: type: Content of: <p>
en: Have a look at each world's objective view to understand how to write the function.
pt: Dê uma olhada em cada visão de mundo objetivo para entender como escrever a função.

note: type: Content of: <h2>
en: Snow flake
pt: Floco de neve

note: type: Content of: outside any tag (error?)
en: We will now draw snow flakes using the Koch fractal. A fractal is a geometric pattern repeated at every scale.
pt: Vamos agora desenhar flocos de neve a usar o Koch fractal. Um fractal é um padrão geométrico repetido em cada escala.

note: type: Content of: <p>
en: The general form is a triangle, with each side given by several recursive calls. Your work is only to write the code of the <code>snowSide</code> method so that it draws one side of the triangle. To make it easier, each sides are represented in a specific color. Just draw the red things (without changing your pen color), and the other colors will be drawn automatically.
pt: A forma geral é um triângulo, com cada lado dado por várias chamadas recursivas. O seu trabalho é apenas escrever o código do método <code>snowSide</code> de forma que desenhe um lado do triângulo. Para facilitar, cada um dos lados é representado numa cor específica. Simplesmente desenhe as coisas vermelhas (sem mudar a cor da sua caneta) e as outras cores serão desenhadas automaticamente.

note: type: Content of: <p>
en: Observe the drawing in each world's objective to understand the pattern's logic, and then reproduce it. At level 0, the Koch curve is just a straight line.  At level 1, the curve is divided in three thirds, and the middle part is replaced by the two sides of an equilateral triangle of the same length as the segment being removed.  At level 2, the process is repeated, whith each segments split in three parts and the middle part being replaced by the two sides of an equilateral triangle.
pt: Observe o desenho em cada um dos mundos objetivo para entender a lógica do padrão e então reproduza ele. No nível 0, a curva de Koch é apenas uma linha reta. No nível 1, a curva é dividida em três terços e a parte média é substituída pelos dois lados de um triângulo equilátero do mesmo comprimento do segmento a ser removido. No nível 2, o processo é repetido, com cada um dos segmentos dividido em três partes e a parte do meio a ser substituída pelos dois lados de um triângulo equilátero.

note: type: Content of: <p>
en: The pseudo-code of the general case is the following:
pt: O pseudo-código do caso geral é o seguinte:

note: type: Content of: <pre>
en:   Draw recursively a smaller segment
      Turn 60 degrees to the left
      Draw recursively a smaller segment  
      Turn 120 degrees to the right
      Draw recursively a smaller segment
      Turn 60 degrees to the left
      Draw recursively a smaller segment
pt:   Desenhe recursivamente um segmento menor
      Gire 60 graus para a esquerda
      Desenhe recursivamente um segmento menor
      Gire 120 graus para a direita
      Desenhe recursivamente um segmento menor
      Gire 60 graus para a esquerda
      Desenhe recursivamente um segmento menor

note: type: Content of: <p>
en: As you can see, the function forward() is not called from the recursive case, only in the base case when there is no recursive call.
pt: Como pode ver, a função forward() não é chamada no caso recursivo, apenas no caso base quando não existe chamada recursiva.

note: type: Attribute 'alt' of: <p><div>
en: Too much letters. Please picture it.
pt: Muitas letras. Favor "picture it".

note: type: Content of: <p><div><p>
en: Here are the results of the first levels of recursion.
pt: Aqui estão os resultados dos primeiro níveis da recursão.

note: type: Content of: <p>
en: You must write the <code>snowSide()</code> method, which is recursive but <b>do not call snowFlake from snowSide</b>, or you will get very strange and unexpected behaviors.
pt: Deve escrever o método <code>snowSide()</code>, que é recursivo mas <b>não chame snowFlake de dentro de snowSide</b>, ou vão acontecer resultados estranhos e inesperados.

note: type: Content of: <p>
en: This exercise is a variation over the snow flake that we saw previously.  The main difference is that we are growing little squares instead of triangles on the sides of the figure.
pt: Este exercício é uma variação sobre o snow flake que vimos previamente. A principal diferença é que vamos fazer crescer pequenos quadrados ao invés de triângulos nos lados da figura.

note: type: Attribute 'alt' of: <p><div>
en: I don't see it, sorry. Please picture it.
pt: Desculpe, não vi isto. Favor "picture it".

note: type: Content of: <p>
en: As previously, your <code>squareSide</code> function should only draw one side of the figure, and the template will call it for all sides automatically (with one color per side).
pt: Como anteriormente, a sua função <code>squareSide</code> deve apenas desenhar um lado da figura e o modelo vai chamar ela para todos os lados automaticamente (com uma cor por lado).

note: type: Content of: <p>
en: Here comes yet another variation of the Koch curve. This time, we grow little pentagons (ie, polygons with five sides each). I'm sure you get it now.
pt: Aqui vai outra variação da curva de Koch. desta vez, vamos crescer pequenos pentágonos (ie, polígonos com cinco lados cada). Tenho certeza que agora compreendeu.

note: type: Content of: <p>
en: Another difference with earlier is that the length is not divided by three at each step anymore, but multiplied by 0.4. The curve looks better this way :)
pt: Outra diferença com o anterior é que o comprimento não é mais dividido por três em cada passo, mas multiplicado por 0.4. A curva parece melhor desta forma :)

note: type: Content of: <p>
en: We draw only one side in this exercise so your code will be called only once this time.
pt: Desenhamos apenas um lado neste exercício de forma que o seu código vai ser chamado apenas uma vez agora.

note: type: Content of: <p>
en: This time, we will draw the curve that is known as the (6, 0.14)-Koch curve. This means that you have to grow 6-sided polygons on the segments, and that the length should be multiplied by 0.14 at each recursion level.
pt: Agora vamos desenhar a curva conhecida por curva (6, 0.14)-Koch. Isto significa que tem que crescer polígonos de 6 lados nos segmentos e que o comprimento deve ser multiplicado por 0.14 em cada nível de recursão.

note: type: Content of: <p>
en: For the record, the original Koch curve is the (3, 1/3)-Koch curve, the Snow square would be (4,1/3)-Koch curve while the Snow pentagon is also called the (5, 0.4)-Koch curve. If you want, you can switch to the creative mode in the menu and explore freely other Koch curves. Just change the initial call to hexaKoch to what you want.
pt: Para que conste, a curva de Koch original é a curva (3, 1/3)-Koch, a Snow square será a curva (4,1/3)-Koch enquanto a Snow pentagon é também chamada de curva (5, 0.4)-Koch. Se quiser, pode mudar ao modo criativo no menu e explorar livremente outras curvas de Koch. Simplesmente mude a chamada inicial de hexaKoch para o que quiser.

note: type: Content of: <p>
en: For further reference, please see <a href="http://ecademy.agnesscott.edu/~lriddle/ifs/kcurve/kcurve.htm">http://ecademy.agnesscott.edu/~lriddle/ifs/kcurve/kcurve.htm</a>.
pt: Para mais referências, favor ler <a href="http://ecademy.agnesscott.edu/~lriddle/ifs/kcurve/kcurve.htm">http://ecademy.agnesscott.edu/~lriddle/ifs/kcurve/kcurve.htm</a>.

note: type: Content of: <h2>
en: Fractal Crab
pt: Carangueijo Fractal

note: type: Content of: <p>
en: The Crab curve is not exactly a Koch curve, but that's still a fractal and it's built rather similarly.  This time, we grow square triangle on the side of the figure: the angle is 45 degrees, and the length is divided by [!java|scala]Math.sqrt(2)[/!][!python]math.sqrt(2)[/!][!c]sqrt(2);[/!] at each step.
pt: A curva do carangueijo não é exatamente uma curva de Koch, mas ainda é um fractal e e construída de forma similar. Desta vez, vamos crescer um triângulo retângulo na lateral da figura: o ângulo é de 45 graus e o comprimento é dividido por [!java|scala]Math.sqrt(2)[/!][!python]math.sqrt(2)[/!][!c]sqrt(2);[/!] em cada passo.

note: type: Content of: <p>
en: Check the figures produced by the first steps of recursion to understand the pattern.
pt: Verifique as figuras produzidas pelos primeiros passos da recursão para entender o padrão.

note: type: Content of: <h3>
en: Bibliographical note
pt: nota bibliográfica

note: type: Content of: <p>
en: This curve, also called the Lévy C curve was invented in 1938 by the French mathematician Paul Lévy.  As usual, the wikipedia page is very instructive, and the page provide very good additions: <a href="http://www.mathcurve.com/fractals/c/c.shtml">http://www.mathcurve.com/fractals/c/c.shtml</a>.
pt: Esta curva, também chamada de curva C de Lévy foi inventada em 1938 pelo matemático francês Paul Lévy in 1938. Como sempre, a página da wikipédia é bem instrutiva, além de fornecer ótimos extras: <a href="http://www.mathcurve.com/fractals/c/c.shtml">http://www.mathcurve.com/fractals/c/c.shtml</a>.

note: type: Content of: <h2>
en: Trees
pt: Árvores

note: type: Content of: <p>
en: We will now draw trees. For that, we will write a method using double recursion following this prototype
pt: Vamos agora construir árvores. Para isto, vamos escrever um método a usar recursão dupla a seguir este protótipo

note: type: Content of: <pre>
en: [!java|c]void [/!]tree([!java|c]int [/!]steps[!scala]:Int[/!], [!java|c]double [/!]length[!scala]:Double[/!], [!java|c]double [/!]angle[!scala]:Double[/!], [!java|c]double [/!]shrink[!scala]:Double[/!])
pt: [!java|c]void [/!]árvore([!java|c]int [/!]passos[!scala]:Int[/!], [!java|c]double [/!]comprimento[!scala]:Double[/!], [!java|c]double [/!]ângulo[!scala]:Double[/!], [!java|c]double [/!]shrink[!scala]:Double[/!])

note: type: Content of: <p>
en: To draw a tree of four levels, you have to draw a trunk of the given length, turn right of the given angle, draw a tree of level 3, turn left twice of the given angle, draw another tree of level 3, and come back to your initial location. Don't forget to come back to the initial location!
pt: Para desenhar uma árvore de quatro níveis, deve desenhar um tronco do comprimento dado, virar à direita num ângulo dado, desenhar uma árvore de nível 3, virar a esquerda duas vezes no ângulo dado, desenhar outra árvore de nível 3 e voltar à posição inicial. Não se esqueça de voltar à posição inicial!

note: type: Content of: <p><p><p>
en: If a tree's trunk is of length 'len', the trunk of the next level tree will be of length 'len*shrink'.
pt: Se um tronco da árvore é de comprimento 'len', o tronco da árvore no próximo nível será de comprimento 'len*shrink'.

note: type: Content of: <p><p><p><p><p>
en: At the end, here is the pseudo-code of the general case (you should add the base case yourself):
pt: Finalmente, aqui está o pseudo-código do caso geral (deve adicionar o caso base por si só):

note: type: Content of: <p><p><p><p><pre>
en:   Move forward of the desired length
      Draw (recursively) the right subtree
      Draw (recursively) the left subtree
      Move back to your initial position
pt:   Mova para a frente no comprimento desejado
      Desenhe (recursivamente) a sub-árvore da direita
      Desenhe (recursivamente) a sub-árvore da esquerda
      Mova para trás para a posição inicial

note: type: Content of: <p><p><p><p><p>
en: Don't forget to add the base case to your code, or your buggle will enter an infinite loop.  Then, drawing the right subtree comes down to turn right and then draw the subtree.
pt: Não se esqueça de adicionar o caso base ao seu código, ou o seu buggle vai entrar num loop infinito. Então, desenhar a sub-árvore da direita é virar a direita e desenhar a sub-árvore.

note: type: Content of: <p><p><p><p><p>
en: As you can see, each recursion level is represented by a distinctive color. For that, you have to call the <code>current(step)</code>, passing the current recursion level as a parameter. This will pick the right color for you.  Don't erase your great colors when you move back to your initial location.
pt: Como pode ver, cada nível de recursão é representado por uma cor diferente. Para isto, tem que chamar o <code>current(step)</code>, passar o nível de recursão atual como parâmetro. Isto vai escolher a cor certa para si. Não apague as suas belas cores quando se mover de volta para sua posição inicial.

note: type: Content of: <p><p><p><p><p>
en: If you get your function wrong, this can easily become hairly to debug as your errors will appear at each level of the recursion, completely changing the drawing.  For debugging purpose, you can use the <code>subtree()</code> that will draw a correct subtree. This function is then very similar to the one you are trying to write. The only difference is that <code>subtree()</code> only draws in black. So, you can use it instead of a recursive call to debug your code, but you have to change for a proper recursive call to your own code (once it works)  to get the colors right, and pass the exercise.
pt: Se a função foi feita errada, pode rapidamente ficar muito difícil de depurar, pois, os erros vão aparecer em cada nível da recursão, a mudar completamente o desenho. Por questões de depuração, pode usar o <code>subtree()</code> que vai desenhar uma sub-árvore corretamente. Esta função é, portanto muito similar àquela que está a tentar escrever. A única diferença é que <code>subtree()</code> apenas desenha em preto. Logo, pode usar ela no lugar da chamada recursiva para depurar o seu código, mas vai ter que mudar para uma chamada recursiva adequada no seu próprio código (uma vez que funcione) para obter as cores certas e passar no exercício.

note: type: Content of: <h2>
en: Sierpinski's Triangle
pt: Triângulo de Sierpinski

note: type: Content of: <p>
en: The fractal we will now draw is formed of a big triangle inside which several smaller triangles are embedded. The prototype of the function to draw it is the following:
pt: O fractal que vamos desenhar é formado de um grande triângulo dentro do qual há vários pequenos triângulos. O protótipo da função que desenha isto é o seguinte:

note: type: Content of: <pre>
en: [!java|c]void [/!]sierpinski([!java|c]int [/!]level[!scala]:Int[/!], [!java|c]double [/!]length[!scala]:Double[/!])
pt: [!java|c]void [/!]sierpinski([!java|c]int [/!]nível[!scala]:Int[/!], [!java|c]double [/!]comprimento[!scala]:Double[/!])

note: type: Content of: <p>
en: Have a look at each world's objective view to understand how to write the function.  To draw one side of the triangle, draw a smaller recursive triangle (halve the length) and move forward by the requested length.  Globally, you have to draw 3 such sides and turn by 120 between each side.
pt: Dê uma olhada em cada uma das visões do mundo objetivo para entender como escrever a função. Para desenhar um lado do triângulo, desenhe um triângulo recursivo menor (metade do comprimento) e mova para a frente a distancia desejada. Globalmente, tem que desenhar 3 destes lados e girar 120 graus a cada lado.

note: type: Content of: <h2>
en: Spirals
pt: Espirais

note: type: Content of: outside any tag (error?)
en: We will now draw our first recursive function with the turtle. The goal is to draw different kind of spirals with the same function, which prototype is the following:
pt: Vamos agora desenhar nossa primeira função recursiva com a tartaruga. O objetivo é desenhar diferentes tipos de espirais com a mesma função, cujo protótipo é o seguinte:

note: type: Content of: <pre>
en: [!java|c]void [/!]spiral([!java|c]int [/!]steps[!scala]:Int[/!], [!java|c]int [/!]angle[!scala]:Int[/!], [!java|c]int [/!]length[!scala]:Int[/!], [!java|c]int [/!]increment[!scala]:Int[/!])
pt: [!java|c]void [/!]espiral([!java|c]int [/!]passos[!scala]:Int[/!], [!java|c]int [/!]ângulo[!scala]:Int[/!], [!java|c]int [/!]comprimento[!scala]:Int[/!], [!java|c]int [/!]incremento[!scala]:Int[/!])

note: type: Content of: outside any tag (error?)
en: To help you understanding how to write it, here is an example of how the parameters change during one specific call:
pt: Para ajudar a entender como escrever isto, aqui está um exemplo de como os parâmetros mudam durante uma chamada específica:

note: type: Content of: <pre>
en: spiral(5, 90, 0, 3);
      forward(0);
      left(90);
      spiral(4,90,3,3);
        forward(3);
        left(90);
        spiral(3,90,6,3);
          forward(6);
          left(90);
          spiral(2,90,9,3);
            forward(9);
            left(90);
            spiral(1,90,12,3);
              forward(12);
              left(90);
              spiral(0,90,12,3);
pt: espiral(5, 90, 0, 3);
      avançar(0);
      esquerda(90);
      espiral(4,90,3,3);
        avançar(3);
        esquerda(90);
        espiral(3,90,6,3);
          avançar(6);
          esquerda(90);
          espiral(2,90,9,3);
            avançar(9);
            esquerda(90);
            espiral(1,90,12,3);
              avançar(12);
              esquerda(90);
              espiral(0,90,12,3);

note: type: Content of: outside any tag (error?)
en: Note that you only have to write the function, not the initial call.  Each world will provide a specific set of initial parameters (use the combobox to switch to other worlds). For example, the "Square Pyramid" world will call your function as follows:
pt: Note que só tem de escrever a função, não a chamada inicial.  Cada mundo irá fornecer um conjunto específico de parâmetros iniciais (use a combobox para mudar para outros mundos). Por exemplo, o mundo "Pirâmide Quadrada" irá chamar a sua função da seguinte forma:

note: type: Content of: <h2>
en: Drawing spirals
pt: Desenhar espirais

note: type: Content of: <p>
en: This exercise is not really an exercise in that sense that you just have to click on the Execute button to get the reward: All the needed code is already provided. Instead, you can here explore the possibilities of the code you just wrote by changing the parameters of the call to the <code>spiral</code> function. You can move on to the next exercise if you are short on time, and come back later to play around.
pt: Este exercício não é realmente um exercício pois tem que simplesmente clicar no botão Executar para ter uma recompensa: todo o código necessário já está pronto. Na verdade, pode explorar as possibilidades do código que acabou de escrever a mudar os parâmetros da chamada da função <code>spiral</code>. Pode mover ao próximo exercício se estiver com pressa e voltar depois para experimentar este.

note: type: Content of: <p>
en: Here are some of the figures that you can produce with your <code>Spiral</code> function, provided that you come with the right parameters. You can switch to the creative mode (from the Exercise menu)  to disable the world comparison when you explore with these spirals.
pt: Aqui estão algumas figuras que pode produzir com a sua função <code>Spiral</code>, dado que passe os parâmetros certos. Pode mudar ao modo criativo (do menu Exercício) para desativar a comparação de mundos quando estiver a explorar com estas espirais.

note: type: Content of: <p>
en: If you discover a cool figure, don't forget to send your parameters (menu Help/feedback) so that we can add it to the list!
pt: Se descobrir uma figura legal, não se esqueça de enviar os seus parâmetros (menu Ajuda/"Dizer o que achou") para que possamos adicionar a esta lista!

note: type: Content of: <h2>
en: Dragon curve (1)
pt: Curva do Dragão (1)

note: type: Content of: <p>
en: The dragon curve is a classical example of recursive method.
pt: A curva do dragão é um exemplo clássico de método recursivo.

note: type: Content of: <p>
en: The definition of this curve is the following:
pt: A definição desta curva é a seguinte:

note: type: Content of: <p>
en: the dragon curve of order 1 is a vector between to arbitrary points P and Q,
pt: A curva do dragão de ordem 1 é um vetor entre dois pontos P e Q arbitrários,

note: type: Content of: <p>
en: the dragon curve of order n is the dragon curve of order n-1 between P and R, followed by the same curve of order n-1 between Q and R, where PRQ is an isosceles triangle with angle R being a right angle, and R being at the right of the PQ vector. Thus, if P and Q coordinates are (x, y)  and (z, t), the coordinate (u, v) of R are given by:
pt: A curva do dragão de ordem n é a curva do dragão de ordem n-1 entre P e R, seguida da mesma curva de ordem n-1 entre Q e R, onde PRQ é um triângulo isósceles com o ângulo em R a ser um ângulo reto e R situado a direita do vetor PQ. Logo, se as coordenadas P e Q são (x, y) e (z, t), as coordenadas (u, v) de R são dadas por:

note: type: Content of: <p>
en: The prototype of the method drawing the curve is the following:
pt: O protótipo do método a desenhar a curva é o seguinte:

note: type: Content of: <pre>
en: [!java|c]void [/!]dragon([!java|c]int [/!]order[!scala]:Int[/!], [!java|c]double [/!]x[!scala]:Double[/!], [!java|c]double [/!]y[!scala]:Double[/!], [!java|c]double [/!]z[!scala]:Double[/!], [!java|c]double [/!]t[!scala]:Double[/!])
pt: [!java|c]void [/!]dragão([!java|c]int [/!]ordem[!scala]:Int[/!], [!java|c]double [/!]x[!scala]:Double[/!], [!java|c]double [/!]y[!scala]:Double[/!], [!java|c]double [/!]z[!scala]:Double[/!], [!java|c]double [/!]t[!scala]:Double[/!])

note: type: Content of: <p>
en: You should use the method <code>setPos(x,y)</code> to put your turtle at coordinates (x,y) and the method <code>moveTo(z,t)</code> to draw a line between the turtle position and the point(z,t).
pt: Deve usar o método <code>setPos(x,y)</code> para pôr a sua tartaruga nas coordenadas (x,y) e o método <code>moveTo(z,t)</code> para desenhar uma linha entre a posição da tartaruga e o ponto (z,t).

note: type: Content of: <h2>
en: The dragon curve (2)
pt: A curva do dragão (2)

note: type: Content of: <p>
en: Previous solution induce that the turtle teleports to other location, or at the very least, that it moves its pen up during the drawing. Indeed, the end of the drawing of the first recursive call does not match the beginning of the second recursive call. That is why we had to use the method <code>setPos()</code>
pt: A solução anterior "induz" que a tartaruga se teleporta para outro local, ou pelo menos, que ela levanta a caneta durante o desenho. Na verdade, o final do desenho da primeira chamada recursiva não coincide com o começo da segunda chamada recursiva. É por isto que temos que usar o método <code>setPos()</code>

note: type: Content of: <p>
en: In this lesson, you will write a recursive method allowing to draw the dragon curve without taking the pen up. For that, we need another recursive method drawing the mirror side of the curve.
pt: Nesta lição, vai escrever um método recursivo que permita desenhar a curva do dragão sem levantar a caneta. Para isto, precisamos de outro método recursivo que desenhe o lado espelhado da curva.

note: type: Content of: <p>
en: The method <code>dragon()</code> is then recursively defined using itself and <code>dragonReverse()</code>. Likewise, the method <code>dragonReverse()</code> is defined recursively using itself and <code>dragon()</code>. This is thus an example of <i>mutual recursion</i>.
pt: O método <code>dragon()</code> é então definido recursivamente a usá-lo próprio e <code>dragonReverse()</code>. Da mesma forma, o método <code>dragonReverse()</code> é definido recursivamente a usá-lo próprio e <code>dragon()</code>. Este é, portanto, um exemplo de <i>recursão mútua</i>.

note: type: Content of: <p>
en: The prototype of the <code>dragon()</code> method remains unchanged from previous exercise:
pt: O protótipo do método <code>dragon()</code> é o mesmo do exercício anterior:

note: type: Content of: <p>
en: The new point's coordinate (u, v) introduced by the <code>dragon()</code> are:
pt: A coordenada do novo ponto (u, v) introduzida pelo <code>dragon()</code> é:

note: type: Content of: <p>
en: The prototype of the method <code>dragonReverse</code> is similar:
pt: O protótipo do método <code>dragonReverse</code> é similar:

note: type: Content of: <pre>
en: [!java|c]void [/!]dragonReverse([!java|c]int [/!]order[!scala]:Int[/!], [!java|c]double [/!]x[!scala]:Double[/!], [!java|c]double [/!]y[!scala]:Double[/!], [!java|c]double [/!]z[!scala]:Double[/!], [!java|c]double [/!]t[!scala]:Double[/!])
pt: [!java|c]void [/!]inverterDragão([!java|c]int [/!]order[!scala]:Int[/!], [!java|c]double [/!]x[!scala]:Double[/!], [!java|c]double [/!]y[!scala]:Double[/!], [!java|c]double [/!]z[!scala]:Double[/!], [!java|c]double [/!]t[!scala]:Double[/!])

note: type: Content of: <p>
en: The new point's coordinate (u, v) introduced by the <code>dragonReverse()</code> are:
pt: A coordenada do novo ponto (u, v) introduzida pelo <code>dragonReverse()</code> é:

note: type: Content of: <p>
en: To make the work of each method recursiv more visible, the line painted by the <code>dragon()</code> must be red (<code>Color.red</code>) while the line painted by the <code>dragonReverse()</code> must be blue (<code>Color.blue</code>).
pt: Para deixar o trabalho de cada um dos dois métodos recursivos mais visíveis, a linha pintada pelo <code>dragon()</code> deve ser vermelha (<code>Color.red</code>) enquanto a linha pintada pelo <code>dragonReverse()</code> deve ser azul(<code>Color.blue</code>).

note: type: Content of: <h3>
en: Hanoi towers
pt: Torres de Hanoi

note: type: Content of: <p>
en: Here comes the super classical exercise on recursion along with some variations. If you have any other nice variations, please submit them.  At some point, someone should also probably contribute these variations to wikipedia, as only the base problem is nicely described there.
pt: Aqui está o exercício super-clássico sobre recursão junto com algumas variações. Se tiver quaisquer outras variações legais, favor envie elas. Em algum momento, alguém deve enviar estas variações também à wikipédia, pois por enquanto apenas o problema básico é descrito lá.

note: type: Content of: <p>
en: The Interleaved and Split variations come from the following article: "Exploring Recursion with Variations on the Towers of Hanoi", Daniel W. Palmer. Available at http://www.ccscjournal.willmitchell.info/Vol12-96/No2a/Daniel%20W%20Palmer.pdf
pt: As variações intercalada e separada vêm do seguinte artigo: "Exploring Recursion with Variations on the Towers of Hanoi", Daniel W. Palmer. Available at http://www.ccscjournal.willmitchell.info/Vol12-96/No2a/Daniel%20W%20Palmer.pdf

note: type: Content of: <p>
en: The Linear Hanoi is briefly discussed in the article presenting the Linear Twin Towers of Hanoi: "The Linear Twin Towers of Hanoi Problem", Steven Minsker (ACM SIGCSE Bulletin Volume 39 Issue 4, December 2007). This article can only be accessed through the paywall of the editor, sorry.
pt: Hanoi linear é discutida rapidamente na artigo a apresentar as Torres Gêmeas Lineares de Hanoi: "The Linear Twin Towers of Hanoi Problem", Steven Minsker (ACM SIGCSE Bulletin Volume 39 Issue 4, December 2007). Este artigo só pode ser acessado através da via paga do editor, desculpe.

note: type: Content of: <p>
en: The 3-colors Towers of Hanoi problem was presented on this web page: http://www.cut-the-knot.org/recurrence/TricolorHanoiAuto.shtml
pt: O problema das Torres de Hanoi de 3 cores foi apresentado nesta página: http://www.cut-the-knot.org/recurrence/TricolorHanoiAuto.shtml

note: type: Content of: <p>
en: The Cyclic Towers of Hanoi was proposed by M.D. Atkinson in an article of 1981 titled "The cyclic towers of Hanoi" (Information Processing Letters, Volume 13:3).  The article is available at http://www.cs.otago.ac.nz/staffpriv/mike/Papers/Hanoi/CyclicHanoi.pdf.
pt: As Torres de hanoi cíclicas foram propostas por M.D. Atkinson num artigo de 1981 intitulado "The cyclic towers of Hanoi" (Information Processing Letters, Volume 13:3). O artigo está disponível em http://www.cs.otago.ac.nz/staffpriv/mike/Papers/Hanoi/CyclicHanoi.pdf.

note: type: Content of: <p>
en: Here comes the super classical exercise on recursion.
pt: Aqui está o exercício super-clássico de recursão.

note: type: Content of: <p>
en: This is an application exercise of recursion, that you should master to take this lesson.
pt: Este é um exercício de aplicação em recursão, que deve dominar para fazer esta lição.

note: type: Content of: <h2>
en: Tower of Hanoi
pt: Torre de Hanoi

note: type: Content of: <p>
en: The Tower of Hanoi or Towers of Hanoi, also called the Tower of Brahma or Towers of Brahma, is a mathematical game or puzzle. It consists of three pegs, and a number of disks of different sizes which can slide onto any peg. The puzzle starts with the disks in a neat stack in ascending order of size on one peg, the smallest at the top, thus forming a pyramid.
pt: A Torre de Hanoi (ou Torres de Hanoi), também conhecida como Torre de Brahma (ou Torres de Brahma), é um quebra-cabeça ou jogo matemático. Consiste de três varas e uma quantidade de discos de tamanhos diferentes que podem encaixar em qualquer das varas. O jogo começa com os discos todos numa vara ordenados em ordem crescente, o menor em cima, a formar uma pirâmide.

note: type: Content of: outside any tag (error?)
en: The objective of the puzzle is to move the entire stack to another peg, obeying the following rules:
pt: O objetivo do jogo é mover a pilha completa para outra vara, a obedecer as seguintes regras:

note: type: Content of: <ul><li>
en: Only one disk may be moved at a time.
pt: Apenas um disco pode ser movido por vez.

note: type: Content of: <ul><li>
en: Each move consists of taking the upper disk from one of the pegs and sliding it onto another peg, on top of the other disks that may already be present on that peg.
pt: Cada movimento consiste em tirar o disco de cima de uma vara e colocá-lo em outra vara, no topo dos discos que já estiverem presentes.

note: type: Content of: <ul><li>
en: No disk may be placed on top of a smaller disk.
pt: Nenhum disco pode ser posto sobre um disco menor.

note: type: Content of: outside any tag (error?)
en: Write the core of the method: <code>[!java|c]void [/!]hanoi[!c]Rec[/!]([!java|c]int [/!]height[!scala]:Int[/!], [!java|c]int [/!]src[!scala]:Int[/!], [!java|c]int [/!]other[!scala]:Int[/!],[!java|c]int [/!]dst[!scala]:Int[/!])</code>
pt: Escreva o núcleo do método: <code>[!java|c]void [/!]hanoi[!c]Rec[/!]([!java|c]int [/!]height[!scala]:Int[/!], [!java|c]int [/!]src[!scala]:Int[/!], [!java|c]int [/!]other[!scala]:Int[/!],[!java|c]int [/!]dst[!scala]:Int[/!])</code>

note: type: Content of: <p>
en: This method will recursively solve the presented problem. The first parameter named <code>height</code> is the height of the tower to move; The second parameter <code>src</code> is the index of the initial tower, the third parameter <code>other</code> is the index of the unused peg while the fourth parameter <code>dst</code> is the index of the expected final tower.
pt: Este método vai, recursivamente, resolve o problema apresentado. O primeiro parâmetro chamado <code>height</code> é a altura da torre a mover; o segundo parâmetro <code>src</code> é o índice da torre inicial, o terceiro parâmetro <code>other</code> é o índica da vara não utilizada enquanto que o quarto parâmetro <code>dst</code> é o índice da torre final experada.

note: type: Content of: <p>
en: A key to solving this puzzle is to recognize that it can be solved by breaking the problem down into a collection of smaller problems and further breaking those problems down into even smaller problems until a solution is reached.
pt: O segredo para resolver este enigma é reconhecer que pode ser dividido em problemas menores e este em problemas menores até que uma solução é encontrada.

note: type: Attribute 'alt' of: <div>
en: I don't get it, please give me some extra indications
pt: Ainda não captei, por favor me dê mais orientações

note: type: Content of: <div>
en: Here is the pseudo-code of the solution:
pt: Aqui está um pseudo-código da solução:

note: type: Content of: <div><ul><li>
en: label the pegs A, B, C (these labels may move at different steps)
pt: Rotule as varas como A, B, C (estes rótulos pode se mover com diferentes passos)

note: type: Content of: <div><ul><li>
en: let n be the total number of discs (the height of the initial tower)
pt: Seja n a quantidade total de discos (A altura da torre inicial)

note: type: Content of: <div><ul><li>
en: number the discs from 1 (smallest, topmost) to n (largest, bottommost)
pt: quantidade de discos a partir de 1 (menor, mais alto) até n (maior, mais baixo)

note: type: Content of: <div>
en: To move n discs from peg A to peg C:
pt: Para mover n discos da vara A para a vara C:

note: type: Content of: <div><ul><li>
en: move n−1 discs from A to B. This leaves disc number n alone on peg A
pt: mova n−1 discos de A para B. Isto deixa o disco n sozinho na vara A

note: type: Content of: <div><ul><li>
en: move disc number n from A to C
pt: Mova o disco de número n de A para C

note: type: Content of: <div><ul><li>
en: move n−1 discs from B to C so they sit on disc number n
pt: Mova n−1 discos de B para C de forma que eles fiquem sobre o disco de número n

note: type: Content of: <h2>
en: Interleaved Towers of Hanoi
pt: Torres de Hanoi Intercaladas

note: type: Content of: <p>
en: In this classical variation of the Towers of Hanoi, you are given 4 pegs with 2 stacks, one white and one black. You should mix the two stacks as depicted in the Objective world.  As previously, you cannot move a disk on a smaller disk.
pt: Nesta variação clássica das Torres de Hanoi tem 4 varas com duas pilhas, uma branca e outra preta. Deve misturar as duas pilhas como descrito no mundo objetivo. Como antes, não pode mover um disco para cima de um disco menor.

note: type: Content of: <p>
en: You will probably need to reuse the <code>hanoi()</code> method that you wrote in the previous exercise.
pt: Provavelmente vai precisar reutilizar o método <code>hanoi()</code> que escreveu no exercício anterior.

note: type: Attribute 'alt' of: <div>
en: Please show me an intermediate step
pt: Favor me mostra um passo intermediário

note: type: Content of: <div>
en: If your initial situation is as follows:
pt: Se a sua situação é a seguinte:

note: type: Content of: <div>
en: then you have the following situation right before the main recursive call:
pt: Então tem a seguinte situação exatamente antes da chamada recursiva principal:

note: type: Content of: <h2>
en: Split Towers of Hanoi
pt: Torres de hanoi Separadas

note: type: Content of: <p>
en: Given one interleaved stack (e.g. resulting from the previous exercise), you should build two separate stacks.  In other words, your code should revert the operations done to solve the previous exercise.
pt: Dada uma pilha intercalada (e.g. o resultado do exercício anterior), deve construir duas pilhas separadas. Em outras palavras, o seu código deve reverter as operações feitas para resolver o exercício anterior.

note: type: Content of: <p>
en: You will need an extra function that can move an interleaved stack of n pairs of disks, without changing the relative positions of disks of the same size.
pt: Vai precisar de uma função adicional que mova uma pilha intercalada de n pares de discos, sem mudar as posições relativas dos discos de mesmo tamanho.

note: type: Content of: <p>
en: Surprisingly, our solution to split the towers generates much more moves than our solution to interleave them. As both problems are symmetric, this should not be.
pt: Surpreendentemente, a nossa solução de dividir (split) as torres gera muito mais movimentos que a solução de intercalá-las. Como os problemas são simétricos, isto não deveria acontecer.

note: type: Content of: <br><table><tr><td>
en: Disks amount
pt: Quantidade de discos

note: type: Content of: <br><table><tr><td>
en: Interleaved
pt: Intercalada

note: type: Content of: <br><table><tr><td>
en: 5 pairs
pt: 5 pares

note: type: Content of: <br><table><tr><td>
en: 62 moves
pt: 62 movimentos

note: type: Content of: <br><table><tr><td>
en: 88 moves
pt: 88 movimentos

note: type: Content of: <br><table><tr><td>
en: 6 pairs
pt: 6 pares

note: type: Content of: <br><table><tr><td>
en: 126 moves
pt: 126 movimentos

note: type: Content of: <br><table><tr><td>
en: 183 moves
pt: 183 movimentos

note: type: Content of: <br><table><tr><td>
en: 7 pairs
pt: 7 pares

note: type: Content of: <br><table><tr><td>
en: 254 moves
pt: 254 movimentos

note: type: Content of: <br><table><tr><td>
en: 374 moves
pt: 374 movimentos

note: type: Content of: <p>
en: Can you make the split tower as efficient as the interleaved one?
pt: Consegue deixar o "split" tão eficiente quanto o intercalada?

note: type: Attribute 'alt' of: <div>
en: I need a starter hint
pt: Preciso de uma dica de principiante

note: type: Content of: <div>
en: The source of discrepancy is an inefficient problem decomposition.  Satisfied that it merely worked, we looked no futher for a better solution.  Keeping the disks of the interleaved tower in the correct order during every move is unnecessary.  In fact, we can avoid moving the interleaved tower at all.  A better problem decomposition splits the pair of disks into two colored towers as they are removed from the interleaved tower.
pt: A fonte de discrepância é uma decomposição ineficiente do problema. Satisfeitos com o fato dele simplesmente funcionar, não procuramos mais por uma solução melhor. Manter os discos da torre intercalada na ordem correta durante cada movimento é desnecessário. De fato, podemos evitar completamente mover a torre intercalada. Uma decomposição melhor do problema divide o par de discos em duas torres coloridas à medida em que eles são removidos da torre intercalada.

note: type: Attribute 'alt' of: <br><br><div>
en: The starter hint was not enough
pt: A dica de principiante não foi suficiente

note: type: Content of: <br><br><div>
en: If someone could split the (n-1) pairs of disks beforehand, could you split the remaining pair?
pt: Se alguém puder dividir os (n-1) pares de discos previamente, poderia dividir o par restante?

note: type: Attribute 'alt' of: <br><br><br><br><div>
en: You need to be more explicit
pt: Precisa ser mais explícito

note: type: Content of: <br><br><br><br><div><ul><li>
en: First split the first (n-1) pairs of disks from the interleaved stack into a white tower and a black tower (calling recursively your main function).
pt: Primeiro divida os primeiros (n-1) pares de discos da pilha intercalada em uma torre branca e uma torre preta (a chamar recursivamente a sua função principal).

note: type: Content of: <br><br><br><br><div><ul><li>
en: Then move the large white disk on its target pole.
pt: Então mova o disco branco grande para sua vara objetivo.

note: type: Content of: <br><br><br><br><div><ul><li>
en: Then move the (n-1) smaller white disks on top of the large one.
pt: Então mova os (n-1) discos brancos menores ao topo do maior.

note: type: Content of: <br><br><br><br><div><ul><li>
en: Then move the large black disk on its target pole.
pt: Então mova o disco preto grande para sua vara objetivo.

note: type: Content of: <br><br><br><br><div><ul><li>
en: Then move the smaller black disks in position.
pt: Então mova os discos pretos pequenos para a posição.

note: type: Content of: <p>
en: Again, our previous solution is working, but it is far from being optimal.  When moving the towers, we use the algorithm for 3 pegs even if we have 4 pegs.  Of course, movements to the last peg are restricted since it contains the other stack, but we can always store the smallest disk on top of the other stack before moving our stack.
pt: Novamente, nossas soluções anteriores funcionam, mas estão longe de serem ótimas. Quando movemos as torres, usamos o algoritmo de 3 varas mesmo quando temos 4 varas. Obviamente, movimentos para a última vara são restritos pois ela contém a outra pilha, mas podemos sempre armazenar o menor disco no topo da outra pilha antes de mover nossa pilha.

note: type: Content of: <p>
en: For that, we need to devise a new function <code>hanoi_fast(height, src, free, full, dst)</code> that moves the stack from <code>src</code> to <code>dst</code> using <code>free</code>, but storing the smallest disk onto <code>full</code> beforehand.
pt: Para isto, precisamos criar uma função <code>hanoi_fast(height, src, free, full, dst)</code> que move a pilha de <code>src</code> para <code>dst</code> a usar <code>free</code>, mas a armazenar o menor disco em <code>full</code> antes.

note: type: Attribute 'alt' of: <div>
en: I'm lost
pt: Estou perdido

note: type: Content of: <div>
en: The <code>hanoi_fast(height, src, free, full, dst)</code> function is not recursive.  It moves the first disk and then call the regular <code>hanoi()</code> function.
pt: A função <code>hanoi_fast(height, src, free, full, dst)</code> não é recursiva. Ela move o primeiro disco e então chama a função regular <code>hanoi()</code>.

note: type: Content of: <br><p>
en: This change greatly improve the performance, as you can see below. Of course, this trick could also be used for the interleaved algorithm, leading as expected to the exact same performance.
pt: Esta mudança melhora enormemente a eficiência, como pode ver abaixo. Obviamente, este truque também pode ser usado para o algoritmo intercalado, a levar, como esperado, a exatamente a mesma eficiência.

note: type: Content of: <br><table><tr><td>
en: 46 moves
pt: 46 movimentos

note: type: Content of: <br><table><tr><td>
en: 82 moves
pt: 82 movimentos

note: type: Content of: <br><table><tr><td>
en: 150 moves
pt: 150 movimentos

note: type: Content of: <br><p>
en: As a conclusion, most of us are satisfied with a working solution and we easily overlook possibilities to improve the problem decomposition. <b>You</b> should not do that ;)
pt: Como uma conclusão, a maioria das pessoas se satisfaz com uma solução que funcione e rapidamente ignora possibilidades para melhorar a decomposição do problema. <b>Você</b> não deve fazer isto ;)

note: type: Content of: <p>
en: This is a classical variation over the Towers of Hanoi where some moves are forbidden.  Specifically, disks cannot move directly between the left-most and the right-most pegs.  The middle peg must be involved in every moves.
pt: Esta é uma variação clássica das Torres de Hanoi onde alguns movimentos são proibidos. Especificamente, os disco não podem ser movidos diretamente da vara mais à esquerda para a vara mais a direita. A vara do meio deve ser envolvida em cada movimento.

note: type: Content of: <p>
en: Beside of that extra complexity, the problem remains unchanged: you are requested to move the whole stack of disks from one extremity peg to the other one. You can only move one disk at a time, and a bigger disk cannot be placed over a smaller one.
pt: Apesar desta complexidade, o problema permanece o mesmo: tem que mover toda a pilha de discos da vara numa extremidade para a vara na outra extremidade. Só pode mover um disco por vez e um disco não pode ficar sobre outro menor.

note: type: Content of: <p>
en: As with the classical version, it is much easier to produce a recursive solution, and you are absolutely able to devise this solution if you think hard enough about it.
pt: Como na versão clássica, é muito fácil produzir uma solução recursiva e é totalmente capaz de "devise" esta solução se pensar com atenção nela.

note: type: Attribute 'alt' of: <div>
en: I tried, but I don't get it
pt: Tentei, mas não consegui

note: type: Content of: <div>
en: The standard recursive algorithm for classical Hanoi is of complexity <i>2^n-1</i> where the standard recursive algorithm for this variation is of complexity <i>3^n-1</i>.
pt: O algortimo recursivo padrão para as torres de Hanoi clássicas é de complexidade <i>2^n-1</i> enquanto que o algoritmo recursivo padrão para esta variação é de complexidade <i>3^n-1</i>.

note: type: Attribute 'alt' of: <div>
en: That first tip was not enough
pt: A primeira dica não foi suficiente

note: type: Content of: <div>
en: The standard recursive algorithm for classical Hanoi involves two recursive calls sandwiching one movement of the largest disk, the standard recursive algorithm for Linear Hanoi involves three recursive calls sandwiched around two movements of the same disk.
pt: A algoritmo recursivo padrão para as torres de Hanoi clássicas envolve duas chamadas recursivas a sanduichar um movimento do disco maior, O algoritmo recursivo padrão para Hanoi Linear envolve três chamadas recursivas a sanduichar dois movimentos do mesmo disco.

note: type: Content of: <h2>
en: Linear Twin Towers of Hanoi
pt: Torres gêmeas de Hanoi Lineares

note: type: Content of: <p>
en: This is a mix between both the Split and Interleaved problems, and the linear problem.  We are given two stacks of disks, on three pegs. We are expected to swap the stacks' position while respecting the classical Hanoi movement restrictions (one disk at a time, and no large disk over smaller disks) and the linear movement restriction (no direct exchange between the left-most and right-most pegs).
pt: Esta é uma mistura entre os problemas "Split", Intercalado e linear. Temos duas pilhas de discos, em três varas. Devemos trocar a posição das pilhas a respeitar as restrições clássicas de movimento (um disco por vez, disco grande não pode ficar sobre disco pequeno) e a restrição do movimento linear (proibido mudança diretamente da vara mais à esquerda para a vara mais à direita).

note: type: Content of: <p>
en: You will use three recursive functions:
pt: Vai usar três funções recursivas:

note: type: Content of: <ul><li>
en: <b>moveDouble(k,from, to)</b>: moves an interleaved stack of k pairs of disks, without changing the relative positions of disks of the same size. As in the Split Hanoi problem, an interleaved stack alternates white and black disks of each sizes. This function is not completely new: you wrote a version with 4 pegs (but using only 3 of them) for the first version of the Split Hanoi problem.
pt: <b>moveDouble(k,from, to)</b>: move uma pilha intercalada de k pares de discos, sem mudar as posições relativas dos discos de mesmo tamanho. Como no problema de hanoi "Split", uma pilha intercalada alterna discos brancos e pretos de cada tamanho. Esta função não é completamente nova: escreveu uma versão com 4 varas (mas a usar apenas 3 delas) para a primeira versão do problema de hanoi "split".

note: type: Content of: <ul><li>
en: <b>gather(k)</b>: from the initial split situation, build on peg #2 an interleaved stack of k pairs of disks. You may parametrize your function so that it can be used to gather the disk on any peg passed as parameter, but in practice, your function will only be used to gather on the last peg.
pt: <b>gather(k)</b>: da situação inicial do caso "separado", constrói na vara #2 uma pilha intercalada de k pares de discos. Pode parametrizar a sua função de forma que ela possa ser usada para obter o disco de qualquer vara passado como parâmetro, mas, na prática, a sua função vai apenas ser usada para obter na última vara.

note: type: Content of: <ul><li>
en: <b>scatter(k)</b>: from a situation where k pairs of disks are interleaved on peg #0, split it down by moving the white disks to peg #1 and black ones to peg #2.
pt: <b>scatter(k)</b>: de uma situação onde k pares de discos são intercalados na vara #0, separe eles a mover os discos brancos para a vara #1 e os pretos para a vara #2.

note: type: Content of: <p>
en: In <code>gather()</code>, the recursive call comes before two calls to <code>moveDouble()</code> while in <code>scatter()</code>, the calls to <code>moveDouble()</code> come before the recursive call.  The main function that you should write is not recursive, but simply gather almost all disks, moves directly the remaining disks, and then scatters back the small disks.
pt: Em <code>gather()</code>, a chamada recursiva vem antes das duas chamadas a <code>moveDouble()</code> enquanto em <code>scatter()</code>, as chamadas para <code>moveDouble()</code> vem depois da chamada recursiva. A função principal que deve escrever não é recursiva, mas simplesmente obtém quase todos os discos, move os discos restantes diretamente e então espalha ("scatters") de volta os discos menores.

note: type: Content of: <p>
en: The linearity naturally induces some extra complexity as you have to decompose every move between pegs 0 and 2. I am still confident in your ability to overcome the challenge :)
pt: A linearidade naturalmente induz alguma complexidade adicional, pois tem que decompor cada movimento entre as varas 0 e 2. Ainda estou confiante na sua capacidade de vencer este desafio :)

note: type: Content of: <p>
en: Note that the requested algorithm was proved optimal for that problem, so you don't need to fiddle the performance this time.
pt: Observe que foi provado que o algoritmo requerido é ótimo para este problema, então não precisa mexer no desempenho desta vez.

note: type: Content of: <h2>
en: Tricolor Hanoi: stack move
pt: Hanoi de tricolor: movimentação de pilhas

note: type: Content of: <p>
en: In this set of exercises, we will devise an algorithm for the Tricolor Hanoi problem.  There will be 3 stacks on 3 pegs, each stack of a differing color, and the problem is to exchange the stacks' positions under the classical move rules (one disk at a time, and no bigger disk over smaller disk).
pt: Neste conjunto de exercícios, vamos "devise" um algoritmo para o problema de Hanoi Tricolor. Vão existir 3 pilhas em 3 varas, cada pilha de uma cor diferente e o problema é alternar a posição das pilhas seguindo as regras clássicas do movimento (um disco por vez, disco grande não pode ficar sobre disco pequeno).

note: type: Content of: <p>
en: As in previous exercises, our solution will use three functions:
pt: Como nos exercícios anteriores, nossa solução vai usar três funções:

note: type: Content of: <ul><li>
en: <code>move3(n, src, mid, dst)</code>: moves a stack of interleaved disks, ie a stack of (n*3) disks of alternating colors from peg <code>src</code> to peg <code>dst</code>.
pt: <code>move3(n, src, mid, dst)</code>: move uma pilha de discos intercalados, p.ex. uma pilha de (n*3) discos de cores alternadas de uma vara <code>src</code> para uma vara <code>dst</code>.

note: type: Content of: <ul><li>
en: <code>gather()</code>: builds an interleaved stack from the regular split ones.
pt: <code>gather()</code>: constrói uma pilha intercalada a partir de três pilhas "split".

note: type: Content of: <ul><li>
en: <code>scatter()</code>: splits an interleaved stack into several regular ones.
pt: <code>scatter()</code>: separa uma pilha intercalada em três pilhas normais.

note: type: Content of: <p>
en: The goal of this first exercise in the series is to devise the <code>move3()</code> function.  This starter task should not block you for too long, actually. It is ok if your function changes the order of the bottom triplet of disks, but it must preserve the order of the other triplets.
pt: O objetivo deste primeiro exercício na série é "devise" a função <code>move3()</code>. Esta tarefa inicial não o deve segurar muito, na verdade. Tudo bem se a sua função muda a ordem do trio de discos mais no fundo, mas ela deve preservar a ordem dos outros trios.

note: type: Content of: <p>
en: It is now time to write the second function required by the Tricolor Hanoi problem.  <code>gather()</code> builds an interleaved stack from the regular split ones. This function takes four arguments, the last one being the target peg where the interleaved stack must be assembled.  As you can see in the examples, the colors of must be in the same order for each triplet of disks.
pt: Agora é a hora de escrever a segunda função necessária para o problema de Hanoi Tricolor. <code>gather()</code> constrói uma pilha intercalada a partir de pilhas "split". Esta função recebe quatro argumentos, o último a ser a vara de destino onde a pilha intercalada deve ser montada. Como pode ver nos exemplos, as cores devem estar na mesma ordem para cada trio de discos.

note: type: Content of: <p>
en: That function actually uses the <code>move3()</code> that you wrote just before. Simply copy/paste your code over to reuse it. If you're lost, please refer to the Interleaved Hanoi exercise. Gathering 3 stacks on 3 pegs is rather similar to gathering 2 stacks on 4 pegs. You can find that exercise <a href="plm://lessons.recursion.hanoi/InterleavedHanoi">here</a>.
pt: Esta função, na verdade, usa o <code>move3()</code> que escreveu agora a pouco. Simplesmente copie-e-cole o seu código e reuse-o. Se estiver perdido, favor olhe o exercício Hanoi Intercalada. Obter 3 pilhas em 3 varas é muito similar a obter 2 pilhas em 4 varas. Pode encontrar este exercício <a href="plm://lessons.recursion.hanoi/InterleavedHanoi">aqui</a>.

note: type: Content of: <h2>
en: Tricolor Hanoi: the Final
pt: Hanoi Tricolor: o Final

note: type: Content of: <p>
en: We are almost ready to write the whole tricolor algorithm. We just need the <code>scatter()</code> function, very inspired from the first one that we wrote for the <a href="plm://lessons.recursion.hanoi/SplitHanoi1">Split Hanoi problem</a>. Assuming that your interleaved stack is placed on the <code>mid</code> peg, spread the disks over all pegs. Make sure to use <code>move3()</code> an even amount of time at each recursive level to ensure that the bottom disks are in the correct order.
pt: Estamos quase prontos para escrever o algoritmo tricolor. Precisamos apenas da função <code>scatter()</code>, bastante inspirada na primeira que escrevemos para o <a href="plm://lessons.recursion.hanoi/SplitHanoi1">problema de Hanoi Separado</a>. A assumir que a sua pilha intercalada esteja na vara do <code>meio</code>, espalhe os discos por todas as varas. Certifique-se de usar <code>move3()</code> uma quantidade par de vezes em cada nível recursivo para garantir que os discos de baixo estejam na ordem correta.

note: type: Content of: <p>
en: As you can see, the initial situation is not the one expected by <code>scatter()</code>. You first have to apply <code>gather()</code> and <code>move3()</code> (twice to get the bottom triplet in the right order). These few steps plus the new <code>scatter()</code> function are enough to entirely solve the Tricolor Hanoi problem.
pt: Como pode ver, a situação inicial não é a esperada por <code>scatter()</code>. Primeiro tem que aplicar <code>gather()</code> e <code>move3()</code> (duas vezes para pôr o trio do fundo na ordem correta). Estes poucos passos mais a nova função <code>scatter()</code> são o suficiente para resolver inteiramente o problema de Hanoi Tricolor.

note: type: Content of: <h2>
en: Cyclic Towers of Hanoi
pt: Torres de Hanoi cíclicas

note: type: Content of: <p>
en: This variation of the Towers of Hanoi is very similar to the regular problem: you are given one stack of disks and three pegs, and you cannot move a larger disk over a smaller one.  The change is that you can only move disks clockwise: 0->1 or 1->2 or 2->0, but never in the other direction.
pt: Esta variação das torres de Hanoi é muito similar ao problema normal: recebe uma pilha de discos e três varas e não pode mover um disco maior sobre um menor. A diferença é que só pode mover discos no sentido horário: 0->1 ou 1->2 ou 2->0, mas nunca na outra direção.

note: type: Content of: <p>
en: Obviously, the movements are not symmetric anymore. Moves from A to B are now very different from moves to B to A.  As a result, you need two recursive functions depending on whether you are moving the stack clockwise or counterclockwise.
pt: Obviamente, os movimentos não são simétricos de forma alguma. Movimentos de A para B são agora muito diferentes de movimentos de B para A. Como resultado, precisa de duas funções recursivas a depender de estar a mover a pilha no sentido horário ou anti-horário.

note: type: Content of: <p>
en: That being said, the problem decomposition is very similar to the classical Hanoi. The twist is that each function call the other one, constituting a nice example of mutual recursion.
pt: Dito isto, a decomposição do problema é muito similar ao Hanoi clássico. A diferença é que cada função chama a outra, a constituir um bom exemplo de recursão mútua.

note: type: Content of: <h2>
en: Iterative Towers of Hanoi
pt: Torres de Hanoi Iterativas

note: type: Content of: <p>
en: In this last exercise of the series, we will implement an iterative algorithm for the base problem of the Towers of Hanoi (one stack, 3 pegs, no extra movement restriction).
pt: Neste último exercício da série, vamos implementar um algoritmo iterativo para o problema básico das Torres de hanoi (uma pilha, 3 varas, sem restrição de movimento adicional).

note: type: Content of: <p>
en: This algorithm is actually very simple: On odd moves, the smallest disk is moved in a given direction (either increasing 0-&gt;1-&gt;2-&gt;0 or decreasing 2-&lt;1-&lt;0-&lt;2) while on even moves, the only possible move that does not imply the smallest disk is made. You stop as soon as the stack is rebuilt on another location.
pt: Na verdade, este algoritmo é bastante simples: em movimentos ímpares, o disco menor é movido numa dada direção (tanto a aumentar 0-&gt;1-&gt;2-&gt;0 ou a diminuir 2-&lt;1-&lt;0-&lt;2) enquanto em movimentos pares, o único movimento possível que não usa o disco menor é feito. Pare assim que a pilha é reconstruída na outra localização.

note: type: Content of: <p>
en: The function that you now need to write takes two parameters: the initial position of the smallest disk (i.e., the peg initially containing the stack) and a boolean indicating whether the smallest disk should move in the increasing order or not.
pt: A função que precisa escrever agora tem dois parâmetros: a posição inicial do disco menor (p.ex., a vara inicialmente a conter a pilha) e um booleano a indicar se o disco menor deve mover na ordem de aumento ou não.

note: type: Content of: <p>
en: The simplicity of this algorithm is actually almost deceiving. One could wonder on the interest of the recursive algorithms when such a simple iterative algorithm exists. My personal feeling is that this solution is nice to execute, but almost impossible to devise in the first place (I even suspect that the authors built this iterative solution from observations of the recursive execution)...
pt: A simplicidade deste algoritmo é, na verdade, enganosa. Podemos pensar sobre o interesse em algoritmos recursivos quando algoritmos iterativos tão simples existem. A minha impressão é que esta solução é boa de executar, mas quase impossível de ser concebida desde o princípio (suspeito que os autores construíram esta solução iterativa da observação da execução da solução recursiva)...

note: type: Content of: <p>
en: Predicting the effect of this function is also difficult: When the small disk moves in the increasing order, the stack is reconstructed on the right peg with 5 disks but on the left with 6 disks.
pt: Prever o efeito desta função também é difícil: quando o pequeno disco move na ordem crescente, a pilha é reconstruída na cavilha direita com 5 discos, mas na esquerda com 6 discos.

note: type: Content of: <p>
en: An interesting question is whether such simple iterative algorithms exist for the other variation of the problem. Some were given in the literature (e.g. for the cyclic variation). I would happily integrate your solutions to the PLM, especially if you can hint (without spoiling) the solution to guide the next ones.
pt: Uma questão interessante é se tais algoritmos simples existem para a outra variante do problema. Alguns estão na literatura (p.ex. para a variante cíclica). Integraria as suas soluções no PLM com alegria, especialmente se puder dar uma dica (sem estragar a surpresa) da solução para guiar as outras pessoas.

note: type: Content of: <p>
en: This world implements the ultra-classical Hanoi problem. You are asked to move the disk pile from the stick where they are to the target stick (given as second parameter in the world's name -- number 1 for the default world). There is some extra constraint: you can only move one disk at a time, and you cannot move a big disk over a smaller one.
pt: Este mundo implementa o problema ultra clássico das torres de Hanói. Deve mover a pilha de discos da pilha onde eles estão para outra pilha (dado um segundo parâmetro no nome do mundo -- número 1 para o mundo predefinido). Existem algumas restrições adicionais: pode mover apenas um disco por vez e não pode pôr um disco sobre um menor.

note: type: Content of: <p>
en: Only 4 functions are provided:
pt: Apenas 4 funções são fornecidas:

note: type: Content of: <pre>
en: [!java|c]void [/!]move([!java|c]int [/!]src, [!java|c]int [/!]dst)
pt: [!java|c]void [/!]mover([!java|c]int [/!]src, [!java|c]int [/!]dst)

note: type: Content of: outside any tag (error?)
en: Moves one disk from the stick <code>src</code> onto the stick <code>dst</code>. If you try to do an invalid move (like laying a disk over a smaller one), an IllegalArgumentException is thrown.
pt: Move um disco da vara <code>src</code> para a vara <code>dst</code>. Se tentar fazer um movimento inválido (como pôr um disco sobre outro menor), uma IllegalArgumentException é lançada.

note: type: Content of: <pre>
en: [!java|c]int [/!]getSlotSize([!java|c]int [/!]slot)[!scala]:Int[/!]
pt: [!java|c]int [/!]getTamanhoSlot([!java|c]int [/!]slot)[!scala]:Int[/!]

note: type: Content of: outside any tag (error?)
en: Returns the amount of disks placed on the specified slot. This is mainly used to initialize the recursion and set the amount of recursive call to execute.
pt: Retorna a quantidade de discos postos num ponto específico. É usado principalmente para inicializar a recursão e ajustar a quantidade de chamadas recursivas para executar.

note: type: Content of: outside any tag (error?)
en: Returns the radius of the top-most disk of the specified slot.
pt: Retorna o raio do disco no topo da vara especificada.

note: type: Content of: <h3>
en: Labyrinths
pt: Labirintos

note: type: Content of: <p>
en: This lesson proposes several exercises about labyrinths in the buggle world.
pt: Esta lição propõe vários exercícios sobre labirintos no mundo dos buggles.

note: type: Content of: <h2>
en: The crazy mouse
pt: O rato doido

note: type: Content of: <p>
en: The day of your buggle starts badly. Out of luck, it got trapped into a maze. Help it finding its path out of there.
pt: O dia do seu buggle começou ruim. Com falta de sorte, ficou preso num labirinto. Ajude-o a encontrar o caminho para a saída.

note: type: Content of: <p>
en: The exit is represented by a baggle and you need to pick this baggle in order to exit the maze.
pt: A saída é representada por um baggle e precisa apanhar este baggle para sair do labirinto.

note: type: Content of: <p>
en: Since the maze is so small, we can write the dumbest possible algorithm to do so. It relies on randomness and proves quite inefficient.
pt: Como o labirinto é muito pequeno, vamos escrever o algoritmo mais bobo possível. É aleatório e vai mostrar-se bem ineficiente.

note: type: Content of: <p>
en: While the buggle didn't find the path to the escape, it must proceed the following way: pick a random integer between 0 and 2 by using the provided <code>random3()</code> method and make one of the following actions: moving forward if possible, turn left or turn right.
pt: Enquanto o buggle não encontra o caminho para a saída, deve fazer o seguinte: escolher um número inteiro entre 0 e 2 a usar o método <code>random3()</code> fornecido e fazer uma das seguintes ações: andar em frente se for possível, virar à esquerda ou virar à direita.

note: type: Content of: <p>
en: You don't believe that it could work? Well, give it a try, you will see...  Don't forget to pick up the baggle once you've reached it.
pt: Julga que isto não vai funcionar? Bem, experimente e verá... Não se esqueça de apanhar o baggle quando lhe chegar.

note: type: Content of: <h2>
en: Following the walls
pt: Seguir as paredes

note: type: Content of: <p>
en: This time, the maze is a bit more complicated. Random won't be enough, we ough to be smart!
pt: Agora, o labirinto é um pouco mais complicado. Aleatoriedade pode não ser suficiente, devemos ser espertos!

note: type: Content of: <p>
en: The good news is that this maze is simpler that it seems at the first glance: every wall are connected to each other. To get out of this kind of maze, the buggle only have to follow a wall (the one on its left or the one on its right, it doesn't matter).  While keeping a paw on the wall, the buggle must move forward until it finds the maze exit and this biscuit it loves so much.
pt: A boa notícia é que este labirinto é mais simples do que pode parecer à primeira vista: todas as paredes são conectadas às outras. Para sair deste tipo de labirinto, o buggle tem que simplesmente seguir uma parede (a que fica à esquerda ou à direita dele, não importa). Enquanto manter uma pata na parede, o buggle deve mover para a frente até encontrar a saída do labirinto e o biscoito que tanto gosta.

note: type: Content of: <p>
en: This works here because there is no island of isolated walls, so our buggle cannot loop around for ever without encountering its baggle.
pt: Isto funciona aqui porque não existem ilhas ou paredes isoladas, pois o nosso buggle não vai entrar num loop para sempre sem encontrar o baggle dele.

note: type: Content of: outside any tag (error?)
en: The goal of this exercise is to write an algorithm allowing the buggle to get out of this maze.
pt: O objetivo deste exercício é escrever um algoritmo que permita que o buggle saia do labirinto.

note: type: Content of: <p>
en: As said earlier, it does not matter whether you decide to follow the left wall or the right one. Simply, the demo follows the left one, so you should do the same in your solution to ease the comparison of your solution and the demo.
pt: Como dito anteriormente, não importa se decide seguir a parede à esquerda ou à direita. Simplesmente, a demonstração segue a da esquerda, logo deve fazer o mesmo na sua solução para facilitar a comparação da sua solução e da demonstração.

note: type: Content of: <p>
en: Write a method <code>keepHandOnSideWall()</code> which lets the buggle move one step forward while keeping the paw on the wall of the selected side. You must ensure that the buggle always keep the paw on the wall, but also that it won't crash into a wall. You can check the tip for more info on this, but only do so if you're stuck. Try to do it without the tip first.
pt: Escreva um método <code>keepHandOnSideWall()</code> que faz o buggle andar uma casa para a frente enquanto mantém a pata na parede do lado selecionado. Deve garantir que o buggle sempre mantenha a pata na parede, mas também que não bata numa parede. Pode controlar a dica para mais informações, mas faça-o apenas se estiver perdido. Tente primeiro fazer sem a dica.

note: type: Content of: <p>
en: Then, write the whole algorithm to traverse the maze step by step (using <code>keepHandOnSideWall()</code>) until it finds the biscuit and the exit. Don't forget to pick the baggle up once you've found it.
pt: Depois escreva o algoritmo inteiro para percorrer o labirinto passo a passo (a usar <code>keepHandOnSideWall()</code>) até encontrar o biscoito e a saída. Não se esqueça de apanhar o baggle quando o encontrar.

note: type: Attribute 'alt' of: <div>
en: I'm lost, please give me some extra indications
pt: Estou perdido, dê-me orientações adicionais

note: type: Content of: <div><p>
en: When your buggle has a wall on the left, there is three situations to consider, depending on the surrounding walls. The following table depicts each initial situation, and where you should let your buggle end after one step.
pt: Quando o seu buggle tem uma parede à esquerda, existem três situações a considerar, dependente das paredes à volta. A tabela a seguir explica cada situação inicial e onde deve deixar o seu buggle parar depois de cada passo.

note: type: Content of: <div><table><tr><td>
en: Case 1
pt: Caso 1

note: type: Content of: <div><table><tr><td>
en: Case 2
pt: Caso 2

note: type: Content of: <div><table><tr><td>
en: Case 3
pt: Caso 3

note: type: Content of: <div><table><tr><td>
en: Initial situation
pt: Situação inicial

note: type: Content of: <div><table><tr><td>
en: Where is the next step
pt: Onde é o próximo passo

note: type: Content of: <div><p>
en: If you do a <code>right()</code> in any case at the end of your function, it's possible to write it in 3 lines with a <code>while</code> loop.
pt: Se faz um <code>right()</code> em qualquer caso no final da sua função, é possível escreve-la com 3 linhas com um loop <code>while</code>.

note: type: Content of: <h2>
en: Pledge algorithm
pt: Algoritmo de Pledge

note: type: Content of: <p>
en: Once again, you thought that your algorithm were good enough to escape the maze, and once again, you buggle is now in a maze where your previous algorithm fails. Just give it a try: copy/paste your code and hit the "Run" button and see your creation fail. The trap is shaped like an upper case "G". The buggle enters the trap and follows the inner border. At some point, it finds the north direction free, run into that direction, and falls again in the trap.
pt: Novamente, pensou que o seu algoritmo era bom o suficiente para escapar do labirinto e novamente, o seu buggle está agora num labirinto onde o seu algoritmo anterior falhou. Dê-lhe uma hipótese: copie-e-cole o seu código e aperte o botão "Executar" e veja a sua criação falhar. A armadilha é no formato de um "G" maiúsculo. O buggle entra na armadilha e segue a borda interior. Num determinado momento, encontra a direção norte livre, vai nesta direção e cai de novo na armadilha.

note: type: Content of: <p>
en: The Pledge's algorithm (named after Jon Pledge of Exeter) can solve this maze.
pt: O algoritmo de Pledge (em homenagem a Jon Pledge of Exeter) pode resolver este labirinto.

note: type: Content of: <p>
en: This algorithm is a modification of the previous one thought to avoid obstacles. It randomly picks a heading and let the buggle move in that direction. When it encounters an obstacle, a paw (for example the left one)  is kept on the wall following the obstacle while counting the turns. When the buggle is back to its original heading and when the sum of the turns is 0, the buggle leaves the obstacle and continues keeping its original heading.
pt: Este algoritmo é uma modificação do anterior para evitar obstáculos. Escolhe aleatoriamente uma direção e deixe o buggle ir nesta direção. Quando encontra um obstáculo, uma pata (por exemplo, a da esquerda) é mantida na parede a seguir o obstáculo enquanto conta as curvas. Quando o buggle está de volta à direção original dele e a soma das curvas deu 0, o buggle deixa o obstáculo e continua a manter a direção original dele.

note: type: Content of: <p>
en: Note that the use of "total turning" rather than just the "current direction" allows the algorithm to avoid G-shapped traps. If one proceeds left into the trap, one gets turned around a full 360 degrees by the walls. As we said before, the naive "current direction" algorithm gets into a limit cycle as it leaves the lower rightmost wall heading left and runs into the curved section on the left again.
pt: Observe que o uso de "total turning" ao invés de simplesmente o "current direction" permite que o algoritmo evite armadilhas no formato G. Se alguém escolhe a esquerda para dentro da armadilha acaba a girar 260 graus pelas paredes. Como dissemos antes, o algoritmo simplório "current direction" entra num ciclo limitado à medida que deixa a parede mais à direita a apontar para a esquerda e anda para a secção curvada na esquerda de novo.

note: type: Content of: <p>
en: The Pledge's algorithm does not leave the rightmost wall due to the total turning not being zero at that point. It follows the wall all the way around, finally leaving it heading left on the bottom outside
pt: O algoritmo de Pledge não deixa a parede mais à direita devido ao total de curvas não ser zero neste ponto. Segue a parede na volta toda, a deixa-o finalmente a apontar para a esquerda no "fundo exterior"

note: type: Content of: <p>
en: <a name="Objective"/>You now have to modify your solution to implement the Pledge algorithm to escape this maze.
pt: <a name="Objective"/>Agora tem que modificar a sua solução para implementar o algoritmo de Pledge para escapar deste labirinto.

note: type: Content of: <p>
en: Change your <code>keepHandOnSideWall()</code> method to count the amount of turns done by the buggle (+1 when it turns left, and -1 when it turns right). This counting may require the addition of an <code>angleSum</code> integer value in your program.
pt: Mude o seu método <code>keepHandOnSideWall()</code> para contar a quantidade de curvas feitas pelo buggle (+1 quando gira para a esquerda e -1 quando gira para a direita). Esta contagem pode necessitar a adição de um valor inteiro <code>angleSum</code> no seu programa.

note: type: Content of: <p>
en: Write a boolean method <code>isDirectionFree(dir)</code> indicating if the provided direction is free, ie, if you can move in that direction (Note that the demo uses the NORTH direction for that).  You can retrieve the current direction of the buggle using the method <code>getDirection()</code>. You can change your direction (without moving) using <code>setDirection(dir)</code>. Don't forget to store the previous direction of your buggle (in a dedicated variable) before checking if your favorite direction is free in order to restore your state afterward.
pt: Escreva um método booleano <code>isDirectionFree(dir)</code> a indicar se a direção dada está livre, ou seja, se pode mover naquela direção (Observe que a demonstração usa a direção NORTH para isto). Pode recuperar a direção atual do buggle a usar o método <code>getDirection()</code>. Pode mudar a sua direção (sem se mover) a usar <code>setDirection(dir)</code>. Não se esqueça de guardar a direção anterior do seu buggle (numa variável exclusiva) antes de verificar se a sua direção favorita está livre para depois recuperar o seu estado.

note: type: Content of: <p>
en: You may have to change the rest of your code also, but these changes should remain limited.
pt: Também pode ter que mudar o resto do seu código, mas estas mudanças podiam ser poucas.

note: type: Content of: <p>
en: Don't forget that if you have a method modifying a global variable (such as angleSum), you should ensure that it declares this variable as global. Without it, the method creates a new variable of the same name, and the global never gets modified.
pt: Não se esqueça que se tem um método que modifica uma variável global (como angleSum), deve garantir que declara esta variável como global. Sem ele, o método cria uma variável de mesmo nome e a global nunca é modificada.

note: type: Attribute 'alt' of: <div>
en: Show an additional tip
pt: Mostre uma dica adicional

note: type: Content of: <div>
en: You should set your direction to your favorite one (NORTH is advised). Then, you should write the algorithm main loop. In other words, while your buggle did not find its biscuit, you have to move forward until next obstacle in the favorite direction. Then, put a paw on a wall (using <code>keepHandOnSideWall()</code>) while the sum of turns is not null and the favorite direction is not free. Do that until you find your baggle.
pt: Deve ajustar a sua direção para a sua favorita (NORTH é a recomendada). Então, deve escrever o loop principal algoritmo. Em outras palavras, enquanto o seu buggle não encontra o biscoito dele, tem que mover para a frente até ao próximo obstáculo na sua direção favorita. Então, ponha uma pata na parede (a usar <code>keepHandOnSideWall()</code>) enquanto a soma de curvas não for null (nula) e a direção favorita não estiver livre. Faça-o até que encontre o seu baggle.

note: type: Content of: <h2>
en: Lost between islands
pt: Perdido entre ilhas

note: type: Content of: <p>
en: You thought that your algorithm was enough to escape mazes? Well, not every mazes...
pt: Julga que o seu algoritmo é suficiente para escapar de labirintos? Bem, não de todos...

note: type: Content of: <p>
en: The <i>wall follower algorithm</i> we used so far only works if the entry and the exit are placed near to walls connected to the external wall. But if the buggle begins in the middle of the maze, it may exist wall sections disconnected from the external wall.
pt: O <i>algoritmo de seguir paredes</i> que usamos até agora só funciona se a entrada e a saída estão próximas de paredes conectadas ao muro externo. Mas se o buggle começa na metade do labirinto, podem existir sessões de paredes desconectadas da parede externa.

note: type: Content of: <p><p>
en: That is why the previous strategy would let the buggle round around for ever. Indeed, the maze you should now escape from contains islands, and the buggle does not start along one of the external walls. Just give it a try if you want: copy your code over, push the run button and see your previous solution failing miserabily.
pt: É por isto que a estratégia anterior pode deixar o buggle a dar voltas para sempre. Na verdade, o labirinto do qual deve escapar agora contém ilhas e o buggle não começa próximo de um dos muros externos. Experimente se quiser: copie o seu código aqui, aperte o botão executar e veja a sua solução anterior falhar vergonhosamente.

note: type: Content of: <p><p>
en: The method of following a wall is still good and allow to escape very efficiently some sections of the maze, so we do not want to remove it entierely. Instead, we want to stop following the wall under some conditions. Notice that the baggle lays near to the external border of the maze. So, we want to reach the border and then follow that wall. We need for example to search for the north wall before following it to the baggle.
pt: O método de seguir uma parede ainda é bom e permite escapar com muita eficiência de algumas secções do labirinto, por isso não precisamos removê-lo inteiramente. Ao invés disto, queremos parar de seguir a parede sob certas condições. Observe que o baggle fica próximo da borda externa do labirinto. Queremos chegar à borda e então seguir aquela parede. Precisamos, por exemplo, procurar a parede norte antes de segui-la até ao baggle.

note: type: Content of: <p><p><p>
en: To find the north wall, you simply run to the north as long as it's possible, and when facing an obstacle, you avoid it (using previous method).
pt: Para encontrar a parede do norte, simplesmente ande para o norte enquanto for possível e quando encontrar um obstáculo, deve desviar dele (a usar o método anterior).

note: type: Attribute 'alt' of: <p><p><div>
en: I'm lost now, please give me some extra indications
pt: Estou perdido agora, por favor dê-me algumas orientações adicionais

note: type: Content of: <p><p><div>
en: Our new run() method will consist in two modes: our buggle will alternate between the "north runner mode" and the "left follower mode". You begin in "north runner mode", and switch to "left follower" when you have a wall at the north (do not forget to make sure you have a wall at your left before switching to "left follower" mode). You switch to "north runner" as soon as your buggle is facing north and is not in front of a wall during its trip around its left wall. The easiest way to write such a state machine is something like
pt: O nosso novo método run() consistirá de dois modos: o nosso buggle vai alternar entre o "modo de andar para o norte" e o "modo de seguir à esquerda". Começa no "modo de andar para o norte" e alternar para "seguir à esquerda" quando tiver uma parede ao norte (não se esqueça de garantir que tem uma parede à sua esquerda antes de alternar para o modo "seguir a esquerda"). Alterna para "andar para o norte" assim que o seu buggle estiver a olhar para o norte e não estiver em frente de um muro durante a sua viagem ao redor do muro à esquerda dele. O mais fácil de escrever tal máquina de estado é algo como

note: type: Content of: <p><p><div><pre>
en: [!scala]var state=0;
    state match  {
      case 0 => // North runner
         ...
         state = 1;
      case 1 => // Left follower
         ...
         state = 0;
      case _ => println("This case should not happen. Please fix me")
    }[/!][!java|c]int state=0;
    switch (state) {
      case 0: // North runner
         ...
         state = 1;
         break;
      case 1: // Left follower
         ...
         state = 0;
         break;
    }[/!][!python]northRunner = True
    if northRunner:
         ...
         northRunner = False
    else: # left follower
         ...
         northRunner = True[/!]
pt: [!scala]var state=0;
    state match  {
      case 0 => // para o norte
         ...
         state = 1;
      case 1 => // seguir a esquerda
         ...
         state = 0;
      case _ => println("Isto não deveria acontecer. Favor me conserte")
    }[/!][!java|c]int state=0;
    switch (state) {
      case 0: // para o norte
         ...
         state = 1;
         break;
      case 1: // seguir a esquerda
         ...
         state = 0;
         break;
    }[/!][!python]northRunner = True
    if northRunner:
         ...
         northRunner = False
    else: # left follower
         ...
         northRunner = True[/!]

note: type: Content of: <p><p><div>
en: Don't forget the default case (matching _), or scala will issue an error since your matching would be incomplete.[/!]
pt: Não se esqueça do caso default (matching _), ou scala irá dar um erro já que o seu "matching" vai estar incompleto.[/!]

note: type: Content of: <p><p><p>
en: Don't forget to let the buggle pick the baggle at the end of your code.
pt: Não se esqueça de deixar o buggle apanhar o baggle no final do código.

note: type: Content of: <p><p><p>
en: You're up. That should be enough for you to figure out how to escape this maze, but if not, you can always request for the tip. But you do not need any more help, do you?
pt: Tudo pronto. Isto deve ser o suficiente para descobrir como sair deste labirinto e se não for o caso, sempre pode pedir uma dica. Mas não vai precisar, correto?

note: type: Content of: <h2>
en: Basic Shortest Path algorithm
pt: Algoritmo básico do caminho mais curto

note: type: Content of: <p>
en: To conclude with this introductory lesson to maze solving algorithms, we will investigate another way to find the exit. The buggle in this lesson is a special buggle: he is a jedi. He can feel the Force. This means he is able to feel his environment.
pt: Para concluir com esta lição introdutória em algoritmos de resolução de labirintos, vamos investigar outra forma de encontrar a saída. O buggle nesta lição é um buggle especial: é um jedi. Pode sentir a Força. Isto significa que pode sentir o ambiente.

note: type: Content of: <p>
en: Without even leaving his position, he can retrieve information about the world he is leaving in, with the following functions:
pt: Sem nem sequer sair da posição dele, pode recuperar informações sobre o mundo que está a viver, com as seguintes funções:

note: type: Content of: <ul><li>
en: <code>getWorldWidth()</code> gives the width of its world.
pt: <code>getWorldWidth()</code> da a largura ("width") do mundo.

note: type: Content of: <ul><li>
en: <code>getWorldHeight()</code> gives the height of its world.
pt: <code>getWorldHeight()</code> da a altura ("height") do mundo.

note: type: Content of: <ul><li>
en: <code>hasTopWall(x,y)</code> tells whether the cell (x,y) of this world has a wall on top.
pt: <code>hasTopWall(x,y)</code> diz se a célula (x,y) deste mundo tem uma parede no topo.

note: type: Content of: <ul><li>
en: <code>hasLeftWall(x,y)</code> tells whether the cell (x,y) of this world has a wall on the left.
pt: <code>hasLeftWall(x,y)</code> diz se a célula (x,y) deste mundo tem uma parede na esquerda.

note: type: Content of: <ul><li>
en: <code>hasBaggle(x,y)</code> tells whether the cell (x,y) of this world has a baggle.
pt: <code>hasBaggle(x,y)</code> diz se a célula (x,y) deste mundo tem um baggle.

note: type: Content of: <ul><li>
en: <code>setIndication(x,y,i)</code> adds the integer indication <code>i</code> to the cell (x,y).
pt: <code>setIndication(x,y,i)</code> adiciona a indicação inteira <code>i</code> à célula (x,y).

note: type: Content of: <ul><li>
en: <code>getIndication(x,y,i)</code> retrieves the integer indication of the cell (x,y) (or 9999 if there is no indication).
pt: <code>getIndication(x,y,i)</code> obtém a indicação inteira da célula (x,y) (ou 9999 se não houver indicação).

note: type: Content of: <p>
en: It has to be noted that it is not possible to build a wall on the bottom edge or on the right edge of a cell.  Therefore when such wall exists, it means it was built on a sibling cells -- as a top (respectively left) wall on the cell that is located below (respectively at the right of) the current cell.
pt: Note que não é possível construir uma parede na borda de baixo ou na borda à direita de uma célula. Portanto, se tal parede existe, significa que foi construído nas células vizinhas -- como uma parede na borda de cima (respetivamente da esquerda) da célula que é localizada abaixo (respetivamente à direita) da célula atual.

note: type: Content of: <p>
en: Your buggle should first write the distance to the exit on each cell (or at least the useful ones).
pt: O seu buggle deve primeiro escrever a distância à saída em cada célula (ou pelo menos nas células úteis).

note: type: Content of: <p>
en: For that, find the exit and write 0 there.  Then, write 1 on every neighboring cells that is not separated from the exit with a wall.  And then mark every cells from which you can reach the exit in 2 steps, and iterate for all cells until all cells are marked.
pt: Para isto, encontre a saída e escreva 0 lá. Então, escreva 1 em cada célula vizinha que não esteja separada da saída por uma parede. E depois marque cada célula a partir da qual possa alcançar a saída em 2 passos e itere para todas as células até que todas as células estejam marcadas.

note: type: Content of: <p>
en: Once the cells are marked, get your jedi buggle to follow the shortest path.  Basically the buggle has only to walk on each case with the lesser distance from the exit. You can use the method <code>setDirection(direction)</code> to make your buggle look at the specific direction such as <code>[!scala|java|python]Direction.[/!]NORTH</code> or <code>[!scala|java|python]Direction.[/!]EAST</code>.
pt: Uma vez que as células estejam marcadas, faça o seu buggle jedi percorrer a caminho mais curto. Basicamente o buggle tem apenas que andar em cada caso com a menor distância à saída. Pode usar o método <code>setDirection(direction)</code> para fazer o seu buggle virar para a direção específica como <code>[!scala|java|python]Direction.[/!]NORTH</code> ou <code>[!scala|java|python]Direction.[/!]EAST</code>.

note: type: Attribute 'alt' of: <div>
en: I'm lost now. Please give me some extra indications.
pt: Estou perdido agora. Por favor, dê-me algumas indicações adicionais.

note: type: Content of: <div>
en: Use the Force, Luke!
pt: Usa a Força, Luke!

note: type: Content of: <h2>
en: Finding the walls to follow
pt: Encontrar as paredes para seguir

note: type: Content of: <p>
en: This is exactly the same maze than before, but the buggle does not start at the same location. In particular, it does not have any wall to its left at the beginning.
pt: Este é o mesmo labirinto que o anterior, mas o buggle não inicia na mesma localização. Em particular, não existe nenhuma parede à esquerda dele no início.

note: type: Content of: <p>
en: As a result, the method you wrote for the previous exercise probably don't work for this one. If you use it here with no modification, your buggle probably start looping over the four free cells around its start position (if that's not the case, well, you didn't really stick to the mission on previous exercise. Feel lucky and proceed to the next :)
pt: O resultado é que o método que escreveu para o exercício anterior provavelmente não vai funcionar neste agora. Se usá-lo aqui sem modificações, o seu buggle provavelmente vai iniciar a percorrer as quatro células ao redor do ponto inicial (se este não é o caso, bem, é porque não fez o exercício anterior completamente. Sinta-se sortudo e vá para o próximo exercício :)

note: type: Content of: <p>
en: This is because your <code>keepHandOnSideWall()</code> method has an implicit <b>pre-condition</b>: it works well if and only if the buggle has a wall to its left when you call it. Such pre-condition are very heavily used when programming. Specifying them explicitly helps understanding the code written by other, and they even allow sometimes to prove that the code works correctly.
pt: Isto é porque o seu método <code>keepHandOnSideWall()</code> tem uma <b>pré-condição</b> implícita: funciona bem apenas se o buggle tem uma parede à esquerda quando o chama. Tais pré-condições são muito usadas em programação. Especificá-las explicitamente ajuda a entender o código escrito por outros e até servem, às vezes, para provar que o código funciona corretamente.

note: type: Content of: <p>
en: Fixing the problem should be very easy. Simply make sure that the pre-condition of <code>keepHandOnSideWall()</code> is verified before calling it. For that, update your code to first look for a wall on its left before the big <code>while</code> loop.
pt: Consertar o problema deve ser bem fácil. Simplesmente garanta que a pré-condição de <code>keepHandOnSideWall()</code> seja verificada antes de chamá-lo. Para isto, atualize o seu código para primeiro olhar a uma parede à sua esquerda antes do loop <code>while</code> maior.

note: type: Content of: outside any tag (error?)
en: This universe introduces a little programming puzzle which can somehow be used to introduce programmation to non-reading kids since it is programmed graphically.  The goal of each board is to light up all the lights. Your robot understands the following orders:
pt: Este universo introduz um pequeno quebra-cabeças de programação que pode num sentido ser usado para introduzir programação a crianças que não sabem ler desde ser programado graficamente. O objetivo de cada tabuleiro é ligar todas as luzes. O seu robô entende as seguintes ordens:

note: type: Content of: <table><tr><td>
en: <b>Move forward</b>
pt: <b>Mover para frente</b>

note: type: Content of: <table><tr><td>
en: Cannot be done if the destination cell is of another height than source cell
pt: Não pode ser feito se a célula de destino é de outra altura que a célula de origem

note: type: Content of: <table><tr><td>
en: <b>Jump forward</b>
pt: <b>Pular pra frente</b>

note: type: Content of: <table><tr><td>
en: Can only be done if the destination cell is one step higher than source cell, or if destination is lower than source. Cannot be used for plain moves.
pt: Só pode ser feito se a célula de destino está um passo mais alto que a célula de origem, ou se o destino é mais baixo que a origem. Não pode ser usado para movimentos normais.

note: type: Content of: <table><tr><td>
en: <b>Turn left</b>.
pt: <b>Virar à esquerda</b>.

note: type: Content of: <table><tr><td>
en: <b>Turn right</b>.
pt: <b>Virar à direita</b>.

note: type: Content of: <table><tr><td>
en: <b>Switch the light</b>.
pt: <b>trocar a luz</b>.

note: type: Content of: <table><tr><td>
en: Turn it on if it was off, and off if it was on. No effect if the cell does not contain any light.
pt: Liga-a se estiver desligada e desliga-a se estiver ligada. Sem efeito se a célula não contém nenhuma luz.

note: type: Content of: <table><tr><td>
en: <b>Call function 1</b>.
pt: <b>Chamar função 1</b>.

note: type: Content of: <table><tr><td>
en: <b>Call function 2</b>.
pt: <b>Chamar função 2</b>.

note: type: Content of: <p>
en: Please note that this world is not completely suited to small kids since the main difficulty comes from the fact that your are highly limited in the amount of instructions you can give to your robot. Advanced levels thus require to write sound functions, and are often above the capacities of small kids.
pt: Por favor observe que este mundo não é completamente adequado para crianças pequenas uma vez que a principal dificuldade vem do fato de que a quantidade de instruções é muito limitada. Níveis avançados então necessitam que algumas funções de sons são escritas e estão acima das capacidades de crianças pequenas.

note: type: Content of: <p>
en: This game is heavily inspirated from a flash game of the same name, which can for example be played on kongregate.com. It was written by Danny Yaroslavski (Coolio-Niato), the original idea being of Matt Chase.
pt: Este jogo é fortemente inspirado dum jogo de flash com o mesmo nome, que pode, por exemplo, ser jogado em kongregate.com. Foi escrito por Danny Yaroslavski (Coolio-Niato) e a ideia original é de Matt Chase.

note: type: Content of: outside any tag (error?)
en: This lesson introduces a little programming puzzle inspired from a flash game.
pt: Esta lição introduz um pequeno quebra-cabeças de programação inspirado num jogo em flash.

note: type: Content of: <p>
en: See the <i>About this world</i> dialog for more details.
pt: Veja o diálogo <i>Sobre este mundo</i> para mais detalhes.

note: type: Content of: <p>
en: This lesson constitutes a little brain teaser for programmers. You have to instruct your robot to turn off all lights. The trick is that you program your robot graphically, and that you are limited in the amount of instructions.
pt: Esta lição constitui um pequeno "brain teaser" para programadores. Tem que instruir o seu robô a desligar todas as luzes. O truque é que programa o seu robô graficamente e tem uma quantidade limitada de instruções.

note: type: Content of: <p>
en: No previous experience is expected to take this lesson.
pt: Espera-se experiência prévia para fazer esta lição.

note: type: Content of: <h1>
en: Welcome
pt: Bem-vindo

note: type: Content of: <p>
en: Welcome to the lightbot world. This is merely a programmer puzzle rather than a real lesson (although some use it to teach programming).  The robot is not programmed in Java, but rather graphically. You can see the existing orders in the documentation using the <i>About this world</i> menu.
pt: Bem-vindo ao mundo lightbot. Este é apenas um quebra-cabeça para programadores ao invés de uma lição real (embora algumas pessoas usem isto para ensinar programação). O robô não é programado em Java, mas sim graficamente. Pode ver as ordens existentes na documentação a usar o menu <i>Sobre este mundo</i>.

note: type: Content of: <p><</p><p>
en: The goal of each board is simply to switch on every lights of the board using your little robot.
pt: O objetivo de cada tabuleiro é simplesmente ligar todas as luzes do tabuleiro a usar o seu pequeno robô.

note: type: Content of: <p><</p><p>
en: This is a introduction exercise, which should be solvable by only moving forward and switching the light, using respectively
pt: Este é um exercício introdutório, que pode ser resolvido simplesmente a mover em frente e a apertar o interruptor, a usar respetivamente

note: type: Content of: <p>
en: and
pt: e

note: type: Content of: <h1>
en: Turn around
pt: Virar

note: type: Content of: <p>
en: Now, you probably need to turn in addition (using
pt: Agora, provavelmente precisa virar adicionalmente (a usar

note: type: Content of: <h1>
en: Jump
pt: Pular

note: type: Content of: <p>
en: You can also jump using
pt: Também pode pular a usar

note: type: Content of: <p>
en: to pass obstacles. You can either jump one level up or any amount of levels down, but you cannot jump to go on a cell of the same height.
pt: para passar obstáculos. Pode tanto pular um nível ou qualquer quantidade de níveis para baixo, mas não pode pular para uma célula da mesma altura.

note: type: Content of: <h1>
en: Stairs
pt: Degraus

note: type: Content of: <p>
en: Can you pass these stairs?
pt: Pode passar estes degraus?

note: type: Content of: <h1>
en: Higher
pt: Mais alto

note: type: Content of: <p>
en: Let's go higher
pt: Vamos mais alto

note: type: Content of: <p>
en: You can use
pt: Pode usar

note: type: Content of: <p>
en: to call respectively the first and second functions. Define their code in their own tab.
pt: chamar respetivamente as primeira e segunda funções. Defina o código na própria guia dele.

note: type: Content of: <p><p>
en: This is great if you get out of space in your main function
pt: Isto é muito bom se ficar sem espaço na sua função principal

note: type: Content of: <h1>
en: Repetitive tasks
pt: Tarefas repetitivas

note: type: Content of: <p>
en: Functions are also of great use for repetitive tasks
pt: Funções também são muitos úteis para tarefas repetitivas

note: type: Content of: <h1>
en: Calling functions from functions
pt: Chamar funções de dentro de funções

note: type: Content of: <p>
en: It is perfectly okay to call a function from within a function!
pt: Não tem nada de errado em chamar uma função de dentro de uma função!

note: type: Content of: <h1>
en: Castle
pt: Castelo

note: type: Content of: <p>
en: You're getting good at this...
pt: Está a ficar bom nisto...

note: type: Content of: <h1>
en: Wall
pt: Parede

note: type: Content of: <p>
en: Ready to climb the wall?
pt: Preparado para subir a parede?

note: type: Content of: <h1>
en: Sea
pt: Mar

note: type: Content of: <p>
en: You now have to surf these waves of lamps.
pt: Agora vai ter que surfar neste mar de lâmpadas.

note: type: Content of: <h1>
en: Escher Castle
pt: Castelo de Escher

note: type: Content of: <p>
en: This one aint easy.
pt: Este não é fácil.

note: type: Content of: <h1>
en: Close to 10
pt: Próximo de 10

note: type: Content of: <p>
en: Given 2 int values, return whichever value is nearest to the value 10, or return 0 in the event of a tie.  [!java|scala]Note that Math.abs(n) returns the absolute value of a number.[/!] [!python]Note that math.fabs(n) returns the absolute value of a number.  This function can only be used if you imported the math module.[/!]
pt: Dados dois valores int, retorne o valor que for mais próximo do 10 ou retorne 0 no caso de um empate.  [!java|scala]Note que Math.abs(n) retorna o valor absoluto de um número.[/!] [!python]Note que math.fabs(n) retorna o valor absoluto de um número.  Esta função só pode ser usada se importar o módulo math.[/!]

note: type: Content of: <h1>
en: Count Teen
pt: Contar Adolescentes

note: type: Content of: <p>
en: We'll say that a number is "teen" if it is in the range 13..19 inclusive. Given 4 int values, return the amount of teen ones.
pt: Diremos que um número é "adolescente" se estiver no intervalo 13..19 inclusive. Dados 4 valores int, retorne a quantidade de adolescentes.

note: type: Content of: <h1>
en: Diff 21
pt: Diferença 21

note: type: Content of: outside any tag (error?)
en: Given an int n, return the absolute difference between n and 21, except return double the absolute difference if n is over 21.
pt: Dado um int n, retorne a diferença absoluta entre n e 21, exceto que retorna a diferença absoluta, se n for maior que 21.

note: type: Content of: <h1>
en: Has Teen
pt: Tem Adolescente

note: type: Content of: outside any tag (error?)
en: We'll say that a number is "teen" if it is in the range 13..19 inclusive. Given 3 int values, return true if 1 or more of them are teen.
pt: Diremos que um número é "adolescente" se está entre 13..19 inclusive. dados 3 valores int, retorne true se 1 ou mais deles são adolescentes.

note: type: Content of: <h1>
en: Icy Hot
pt: Frio Quente

note: type: Content of: outside any tag (error?)
en: Given two temperatures, return true if one is less than 0 and the other is greater than 100.
pt: Dadas duas temperaturas, retorne true se uma é menor que 0 e a outra é maior que 100.

note: type: Content of: outside any tag (error?)
en: Given 2 int values, return true if either of them is in the range 10..20 inclusive.
pt: Dados 2 valores int, retorne true se qualquer um deles estiver no intervalo 10..20 inclusive.

note: type: Content of: outside any tag (error?)
en: Given 2 int values, return true if they are both in the range 30..40 inclusive, or they are both in the range 40..50 inclusive.
pt: Dados 2 valores int, retorne true se estão ambos no intervalo 30..40 inclusive, ou se eles estão ambos no intervalo 40..50 inclusive.

note: type: Content of: <h1>
en: LastDigit
pt: Último Dígito

note: type: Content of: outside any tag (error?)
en: Given two non-negative int values, return true if they have the same last digit, such as with 27 and 57. Note that the % "mod" operator computes remainders, so 17 % 10 is 7.
pt: Dados dois valores int não negativos, retorne true se têm o mesmo dígito final, como com 27 e 57. Note que o operador % "mod" calcula os restos, pois 17 % 10 é 7.

note: type: Content of: <p>
en: This exercise was converted to PLM from the excellent exercising site http://javabat.com/
pt: Este exercício foi convertido para o PLM do excelente sítio de exercícios http://javabat.com/

note: type: Content of: outside any tag (error?)
en: We'll say that a number is "teen" if it is in the range 13..19 inclusive. Given 2 int values, return true if one or the other is teen, but not both.
pt: Diremos que um número é "adolescente" se está no intervalo entre 13..19 inclusive. Dados 2 valores, retorne true se um ou o outro é adolescente, mas não ambos.

note: type: Content of: <p>
en: Boolean operations are one of the very basic task in programming.  As long as you cannot write a not so simple boolean test under the minute, you probably will have a very bad time writing a real program.
pt: Operações booleanas são algumas das mais básicas tarefas na programação. Enquanto não puder escrever um teste booleano não muito simples em menos de um minuto, provavelmente terá dificuldades em escrever programas no mundo real.

note: type: Content of: <p>
en: That is why this lesson provides you a bunch of such exercises, so that you can get trained in this.
pt: É por isto que esta lição fornece vários exercícios deste tipo, de forma que fique treinado nisto.

note: type: Content of: outside any tag (error?)
en: Given 2 ints, a and b, return true if one of them is 10 or if their sum is 10.
pt: Dados 2 inteiros, a e b, retorne true se um deles é 10 ou se a a soma deles é 10.

note: type: Content of: <p>
en: Given 2 positive int values, return the larger value that is in the range 10..20 inclusive, or return 0 if neither is in that range.
pt: Dados 2 valores int positivos, retorne o maior valor que está no intervalo 10..20 inclusive, ou retorne 0 se nenhum dos dois estiver neste intervalo.

note: type: Content of: <p>
en: Note that Math.max(Int,Int):Int and Math.min(Int,Int):Int return the maximum and minimum of two integers
pt: Observe que Math.max(Int,Int):Int e Math.min(Int,Int):Int retornam o máximo e o mínimo de dois inteiros

note: type: Content of: outside any tag (error?)
en: We have two monkeys, a and b, and the parameters aSmile and bSmile indicate if each is smiling.  We are in trouble if they are both smiling or if neither of them is smiling.  Return true if we are in trouble.
pt: Temos dois macacos, a e b, e os parâmetros aSmile e bSmile indicam se cada um está a sorrir. Teremos problemas se os dois estiverem a sorrir ou nenhum deles estiver a sorrir. Retorne true se estivermos com problemas.

note: type: Content of: <p>
en: Given an int n, return true if it is within 10 of 100 or 200.  [!java|scala]Note that Math.abs(n) returns the absolute value of a number.[/!] [!python]Note that math.fabs(n) returns the absolute value of a number.  This function can only be used if you imported the math module.[/!]
pt: Dado um int n, retorna true se estiver entre 10 a 100 ou 200. [!java|scala]Note que Math.abs(n) retorna o valor absoluto de um número.[/!] [!python]Note que math.fabs(n) retorna o valor absoluto de um número. Esta função só pode ser usada se importar o módulo math.[/!]

note: type: Content of: outside any tag (error?)
en: We have a loud talking parrot. The "hour" parameter is the current hour time in the range 0..23. We are in trouble if the parrot is talking and the hour is before 7 or after 20. Return true if we are in trouble.
pt: Temos um papagaio que fala alto. O parâmetro "hora" é a hora atual no intervalo 0..23. Estamos com problemas se o papagaio fala e a hora for antes de 7 ou depois de 20. Retorne true se estivermos com problemas.

note: type: Content of: <h1>
en: Positive Negative
pt: Positivo Negativo

note: type: Content of: outside any tag (error?)
en: Given 2 int values, return true if one is negative and one is positive. Unless negative is true, then they both must be negative.
pt: Dados 2 valores int, retorne true se um é negativo e o outro é positivo. A menos que o negativo seja true, neste caso ambos devem ser negativos.

note: type: Content of: outside any tag (error?)
en: The parameter weekday is true if it is a weekday, and the parameter vacation is true if we are on vacation. We sleep in if it is not a weekday or we're on vacation. Return true if we sleep in.
pt: O parâmetro dia da semana é true se estivermos num dia de semana e o parâmetro vacation (férias) é true se estivermos de férias. Dormimos de manhã se não for dia de semana ou se estivermos de férias. Retorne true se dormimos de manhã.

note: type: Content of: <h1>
en: Sum Double
pt: Soma dupla

note: type: Content of: outside any tag (error?)
en: Given two int values, return their sum. Unless the two values are the same, then return double their sum.
pt: Dados dois valores int, retorne a soma deles. A menos que dois valores sejam os mesmos, neste caso retorne o dobro da soma dele.

note: type: Content of: <h1>
en: AlarmClock
pt: Despertador

note: type: Content of: outside any tag (error?)
en: Given a day of the week encoded as 0=Sun, 1=Mon, 2=Tue, ...6=Sat, and a boolean indicating if we are on vacation, return a string of the form "7:00" indicating when the alarm clock should ring. Weekdays, the alarm should be "7:00" and on the weekend it should be "10:00". Unless we are on vacation -- then on weekdays it should be "10:00" and weekends it should be "off".
pt: Dado o dia da semana, codificado da seguinte forma: 0=Domingo, 1=Segunda, 2=Terça, ... 6=Sábado e um booleano férias a indicar se estamos de férias, retorne uma cadeia de caracteres da forma "7:00" que indica a que horas devemos tocar o despertador. Nos dias da semana, devemos acordar às 7h e nos finais de semana às 10h. Durante as férias, devemos acordar às 10h e nos finais de semana desligar o despertador.

note: type: Content of: <h1>
en: AnswerCell
pt: secretária eletrônica

note: type: Content of: outside any tag (error?)
en: Your cell phone rings. Return true if you should answer it. Normally you answer, except in the morning you only answer if it is your mom calling. In all cases, if you are asleep, you do not answer.
pt: O seu telemóvel toca. Retorne true se deve atender. Normalmente responde, exceto de manhã, quando só a sua mãe lhe liga. De qualquer forma, se estiver a dormir, não responde.

note: type: Content of: <h1>
en: BlueTicket
pt: bilhete azul

note: type: Content of: outside any tag (error?)
en: You have a blue lottery ticket, with ints a, b, and c on it. This makes three pairs, which we'll call ab, bc, and ac. Consider the sum of the numbers in each pair. If any pair sums to exactly 10, the result is 10.  Otherwise if the ab sum is exactly 10 more than either bc or ac sums, the result is 5. Otherwise the result is 0.
pt: Tem um bilhete de loteria azul, com os inteiros a, b e c. Eles fazem três pares que chamaremos de ab, bc e ac. Considere a soma dos números de cada par. Se a soma de um dos pares vale exatamente 10, o resultado é 10. Senão, se a soma ab vale exatamente 10 mais que bc ou ac, o resultado é 5. Senão, o resultado é 0.

note: type: Content of: <h1>
en: CaughtSpeeding
pt: Radar de velocidade

note: type: Content of: outside any tag (error?)
en: You are driving a little too fast, and a police officer stops you. Write code to compute the result, encoded as an int value: 0=no ticket, 1=small ticket, 2=big ticket. If speed is 60 or less, the result is 0. If speed is between 61 and 80 inclusive, the result is 1. If speed is 81 or more, the result is 2. Unless it is your birthday -- on that day, your speed can be 5 higher in all cases.
pt: Está a conduzir um pouco rápido demais e um guarda o para. Escreva o código para calcular o resultado, codificado na forma de um inteiro: 0=sem multa, 1=multa leve, 2=multa pesada. Se a velocidade é inferior a 60, o resultado é 0. Se a velocidade está entre 61 e 80 (inclusive), o resultado é 1. Se a velocidade é 81 ou maior, o resultado é 2. Estes casos são para dias que não são o seu aniversário. No seu dia de aniversário a sua velocidade pode ser 5 maior em todos os casos.

note: type: Content of: <h1>
en: CigarParty
pt: Festa dos charutos

note: type: Content of: outside any tag (error?)
en: When squirrels get together for a party, they like to have cigars. A squirrel party is successful when the number of cigars is between 40 and 60, inclusive. Unless it is the weekend, in which case there is no upper bound on the number of cigars. Return true if the party was successful.
pt: Quando os esquilos fazem uma festa, eles gostam de ter charutos. Uma festa de esquilos é boa quando a quantidade de charutos está entre 40 e 60 (inclusive). A menos que seja finais de semana, onde não há limite superior para a quantidade de charutos. Retorne true se a festa foi um sucesso.

note: type: Content of: <h1>
en: DateFashion
pt: Encontro elegante

note: type: Content of: outside any tag (error?)
en: You and your date are trying to get a table at a restaurant. The parameter "you" is the stylishness of your clothes, in the range 0..10, and "date" is the stylishness of your date's clothes. The result getting the table is encoded as an int value with 0=no, 1=maybe, 2=yes. If either of you is very stylish, 8 or more, then the result is 2 (yes). With the exception that if either of you has style of 2 or less, then the result is 0 (no). Otherwise the result is 1 (maybe).
pt: Você e o seu par estão a tentar conseguir uma mesa no restaurante. O parâmetro "you" (você) é o nível de elegância das suas roupas, no intervalo 0..10 e "date" (par) é o nível de elegância do seu par. O resultado da tentativa de obter uma mesa é codificado como um valor inteiro com 0=no (não), 1=maybe (talvez), 2=yes (sim). Se um de vocês está muito elegante, 8 ou mais, o resultado é 2 (yes). Com uma exceção: se um dos dois tem um estilo de 2 ou menos o resultado é 0 (no). Caso contrário o resultado é 1 (maybe).

note: type: Content of: <p>
en: According to Wikipedia, Fizz buzz is a group word game for children to teach them about division.  Players take turns to count incrementally, replacing any number divisible by three with the word "Fizz", and any number divisible by five with the word "Buzz". Any number that is divisible by both three and five is replaced with the string "Fizz Buzz".
pt: De acordo com a Wikipedia, Fizz buzz é um jogo de "group word" para crianças para ensinar divisão.  Os jogadores jogam em turnos numéricos que vão a aumentar, a substituir qualquer número divisível por três com a palavra "Fizz" e qualquer número divisível por cinco com a palavra "Buzz". Qualquer número que é divisível tanto por 3 quanto por 5 é substituído pela cadeia "Fizz Buzz".

note: type: Content of: <p>
en: Unchanged numbers are simply returned as a string.  [!java|scala]The easiest for that is to use that [!thelang] idiomatic: <code>""+a</code>[/!] [!python]The function <code>str(a)</code> changes an integer <code>a</code> into a string.[/!]
pt: números que não são substituídos são simplesmente retornados como uma cadeia  [!java|scala]O eito mais fácil é usar esta construção em [!thelang]: <code>""+a</code>[/!] [!python]A função <code>str(a)</code> transforma um inteiro <code>a</code> numa cadeia.[/!]

note: type: Content of: <h1>
en: GreenTicket
pt: bilhete verde

note: type: Content of: outside any tag (error?)
en: You have a green lottery ticket, with ints a, b, and c on it. If the numbers are all different from each other, the result is 0. If all of the numbers are the same, the result is 20. If two of the numbers are the same, the result is 10.
pt: Tem um bilhete de loteria verde, com os inteiros a, b e c inscritos nele. Se os números são todos diferentes uns dos outros, o resultado é 0. Se todos os números são idênticos, o resultado é 20. Se dois dos números são os mesmos, o resultado é 10.

note: type: Content of: <h1>
en: In1To10
pt: De 1 a 10

note: type: Content of: outside any tag (error?)
en: Given a number n, return true if n is in the range 1..10, inclusive. Unless "outsideMode" is true, in which case return true if the number is less or equal to 1, or greater or equal to 10.
pt: Seja um número n, retorne true se n está no intervalo [1..10]. Exceto se "outsideMode" é true e neste caso retorne true se o número é menor ou igual a 1, ou maior ou igual a 10.

note: type: Content of: <h1>
en: InOrderEqual
pt: Em ordem crescente

note: type: Content of: outside any tag (error?)
en: Given three ints, a b c, return true if they are in strict increasing order, such as 2 5 11, or 5 6 7, but not 6 5 7 or 5 5 7. However, with the exception that if "equalOk" is true, equality is allowed, such as 5 5 7 or 5 5 5.
pt: Dados três inteiros, a b c, retorne true se estão em ordem estritamente crescente, como 2 5 11, ou 5 6 7, mas não 6 5 7 ou 5 5 7. Entretanto, com a exceção de se "equalOk" for true, igualdade é permitida, como 5 5 7 ou 5 5 5.

note: type: Content of: <h1>
en: InOrder
pt: Na ordem

note: type: Content of: outside any tag (error?)
en: Given three ints, a b c, return true if b is greater than a, and c is greater than b. However, with the exception that if "bOk" is true, b does not need to be greater than a.
pt: Dados três inteiros, a b c, retorne true se b é maior que a, e c é maior que b. Entretanto, com a exceção que se "bOk" é true, b não precisa ser maior que a.

note: type: Content of: <h1>
en: LastDigit 2
pt: Último dígito 2

note: type: Content of: outside any tag (error?)
en: Given three ints, a b c, return true if two or more of them have the same rightmost digit. The ints are non-negative. Note: the % "mod" operator computes the remainder, e.g. 17 % 10 is 7.
pt: Dados três inteiros, a b c, retorne true se dois ou mais deles têm o mesmo último dígito. Os inteiros são não negativos. Nota: o operador % "mod" calcula o resto, p.ex. 17 % 10 é 7.

note: type: Content of: <h1>
en: LessBy10
pt: Menor por 10

note: type: Content of: outside any tag (error?)
en: Given three ints, a b c, return true if one of them is 10 or more less than one of the others.
pt: Dados três inteiros, a b c, retorne true se um deles é 10 ou menor que um dos outros.

note: type: Content of: <h1>
en: Boolean (even more) fun
pt: (mais) diversão com booleanos

note: type: Content of: <p>
en: A very good introduction to this type is available here: http://codingbat.com/doc/java-if-boolean-logic.html
pt: Uma ótima introdução a este tipo está disponível em: http://codingbat.com/doc/java-if-boolean-logic.html

note: type: Content of: outside any tag (error?)
en: Given two int values, return whichever value is larger. However if the two values have the same remainder when divided by 5, then the return the smaller value. However, in all cases, if the two values are the same, return 0.  Note: the % "mod" operator computes the remainder, e.g. 7 % 5 is 2.
pt: Sejam dois valores inteiros, retorne o maior dos dois. Entretanto, se os dois valores possuem o mesmo resto quando divididos por 5, retorne o menor dos dois. Entretanto, em todo caso, se os dois valores forem iguais, retorne 0. Nota: o operador % "mod" calcula o resto, p.ex. 7 % 5 é 2.

note: type: Content of: <h1>
en: NearTen
pt: Próximo de dez

note: type: Content of: outside any tag (error?)
en: Given a non-negative number "num", return true if num is within 2 of a multiple of 10. Note: (a % b) is the remainder of dividing a by b, so (7 % 5) is 2.
pt: Dado um inteiro positivo "num", retorne true se num estiver dentro de 2 de um múltiplo de 10. Nota: ( a % b ) é o resto da divisão de a por b, assim (7 % 5) é 2.

note: type: Content of: <h1>
en: RedTicket
pt: Bilhete vermelho

note: type: Content of: outside any tag (error?)
en: You have a red lottery ticket showing ints a, b, and c, each of which is 0, 1, or 2. If they are all the value 2, the result is 10. Otherwise if they are all the same, the result is 5. Otherwise so long as both b and c are different from a, the result is 1. Otherwise the result is 0.
pt: Tem um bilhete de loteria vermelho com três inteiros a, b e c. Cada um com o valor 0, 1, ou 2. Se todos têm o valor 2, o resultado é 10. Senão, se eles são iguais, o resultado é 5. Senão, e se b e c são diferentes de a, o resultado é 1. Senão, o resultado é 0.

note: type: Content of: <h1>
en: ShareDigit
pt: dígitos compartilhados

note: type: Content of: outside any tag (error?)
en: Given two ints, each in the range 10..99, return true if there is a digit that appears in both numbers, such as the 2 in 12 and 23. (Note: division, e.g. n/10, gives the left digit while the % "mod" n%10 gives the right digit.)
pt: Dados dois inteiros, cada um no intervalo 10..99, retorne true se existe um dígito que aparece nos dois números, como 2 em 12 e 23. (Nota: divisão, p.ex. n/10, retorna o dígito à esquerda e % "mod" n%10 retorna o dígito a direita.)

note: type: Content of: <h1>
en: SortaSum
pt: Soma de inteiros

note: type: Content of: outside any tag (error?)
en: Given 2 ints, a and b, return their sum. However, sums in the range 10..19 inclusive, are forbidden, so in that case just return 20.
pt: Dados 2 inteiros, a e b, retorne a soma deles. Entretanto, somas no intervalo 10..19 inclusive, são proibidas. Neste caso, simplesmente retorne 20.

note: type: Content of: <h1>
en: SquirrelPlay
pt: Jogo do Esquilo

note: type: Content of: outside any tag (error?)
en: The squirrels in Palo Alto spend most of the day playing. In particular, they play if the temperature is between 60 and 90 (inclusive). Unless it is summer, then the upper limit is 100 instead of 90. Given an int temperature and a boolean isSummer, return true if the squirrels play and false otherwise.
pt: Os esquilos em Palo Alto passam a maior parte do dia a jogar. Em particular, eles jogam se a temperatura está entre 60 e 90 °F (inclusive). A menos que seja verão e neste caso o limite superior é de 100 ao invés de 90. Seja uma temperatura inteira e um isSummer (éVerão) booleano. Retorne true se eles jogam e false caso contrário.

note: type: Content of: <h1>
en: TeaParty
pt: Festa do chá

note: type: Content of: outside any tag (error?)
en: We are having a party with amounts of tea and candy. Return the int outcome of the party encoded as 0=bad, 1=good, or 2=great. A party is good (1) if both tea and candy are at least 5. However, if either tea or candy is at least double the amount of the other one, the party is great (2).  However, in all cases, if either tea or candy is less than 5, the party is always bad (0).
pt: Estamos a ter uma festa com chá e doces. Retorne o resultado inteiro da festa codificado como 0=ruim, 1=bom, ou 2=excelente. Uma festa é boa (1) se o chá e os doces são pelo menos 5. Entretanto, se tanto os doces como o chá forem pelo menos o dobro do outro, a festa é excelente (2). Entretanto, em todo caso, se tanto o chá quanto os doces forem menos que 5, a festa é sempre ruim (0).

note: type: Content of: <h1>
en: TeenSum
pt: Soma de adolescentes

note: type: Content of: outside any tag (error?)
en: Given 2 ints, a and b, return their sum. However, "teen" values in the range 13..19 inclusive, are extra lucky. So if either value is a teen, just return 19.
pt: Dados dois números inteiros (a e b), retorne a soma deles. Entretanto, os valores adolescentes no intervalo 13..19 são particularmente sortudos. Portanto, se um dos números for um adolescente, retorne simplesmente 19.

note: type: Content of: <h1>
en: TwoAsOne
pt: Dois como um

note: type: Content of: outside any tag (error?)
en: Given three ints, a b c, return true if it is possible to add two of the ints to get the third.
pt: Dados três inteiros a, b e c, retorne true se é possível adicionar dois deles e o resultado ser o terceiro.

note: type: Content of: <h1>
en: WithoutDoubles
pt: Sem dobros

note: type: Content of: outside any tag (error?)
en: Return the sum of two 6-sided dice rolls, each in the range 1..6. However, if noDoubles is true, if the two dice show the same value, increment one die to the next value, wrapping around to 1 if its value was 6.
pt: Retorne a soma das rolagens de dois dados de 6 lados. Entretanto, se noDoubles é true e os dois dados derem o mesmo valor, incremente um dos dados para o valor seguinte, e volte a 1 se o valor for 6.

note: type: Content of: <h1>
en: String fun
pt: Diversão com cadeias

note: type: Content of: <p>
en: Strings are the simplest of the complex data types :) They provide several operations, such as getting the length of the string, or a substring of it.
pt: Cadeias são os mais simples dos tipos de dados complexos :) Elas fornecem diferentes operações, como obter o tamanho da cadeia ou uma sub-cadeia.

note: type: Content of: <p>
en: A very good introduction to this type is available here: http://codingbat.com/doc/java-string-introduction.html
pt: Uma introdução muito boa a este tipo encontra-se em: http://codingbat.com/doc/java-string-introduction.html

note: type: Content of: <h3>
en: Small exercises about strings
pt: Pequenos exercícios com cadeias

note: type: Content of: <p>
en: These are some training exercises around strings. But unfortunately, its integration within PLM is still ongoing.
pt: Aqui estão alguns exercícios sobre cadeias. Mas infelizmente, a integração dele no PLM ainda está a ser construída.

note: type: Content of: <p>
en: Please be patient with us.
pt: Por favor seja paciente conosco.

note: type: Content of: <h1>
en: AltPairs
pt: Pares alternados

note: type: Content of: outside any tag (error?)
en: Given a string, return a string made of the chars at indexes 0,1, 4,5, 8,9 ... so "kittens" yields "kien".
pt: Dada uma cadeia, retorne outra cadeia feita com os caracteres de índices 0,1, 4,5, 8,9 ... por exemplo "kittens" retorna "kien".

note: type: Content of: outside any tag (error?)
en: Given a string and a non-negative int n, we'll say that the front of the string is the first 3 chars, or whatever is there if the string is less than length 3. Return n copies of the front;
pt: Seja uma cadeia e um inteiro n. Definiremos o começo de uma cadeia como os três primeiros caracteres dela, ou toda se o comprimento dela é menor que 3. Retorne n cópias do começo de uma cadeia;

note: type: Content of: <h1>
en: Last2
pt: Último2

note: type: Content of: <p>
en: Given a string, return the amount of times that the two last letters appear as a substring of the string. So "hixxxhi" yields 1 (we won't count the end substring) while "aaaNaa" yields 2 (substrings may overlap).
pt: Dada uma cadeia retorne a quantidade de vezes que os dois últimos dígitos aparecem como uma sub-cadeia. Assim, "hixxxhi" retorna 1 (não contamos a última sub-cadeia) enquanto "aaaNaa" retorna 2 (as ocorrências podem sobrepor-se parcialmente).

note: type: Content of: outside any tag (error?)
en: Given a string, return a new string made of every other char starting with the first, so "Hello" yields "Hlo".
pt: Dada uma cadeia, retorne uma nova cadeia formada a escolher um caractere sim, outro não, a começar com o primeiro. Assim, "Primeiro" torna-se "Pier".

note: type: Content of: <h1>
en: StringMatch
pt: Comparação de cadeia

note: type: Content of: outside any tag (error?)
en: Given 2 strings, a and b, return the number of the positions where they contain the same length 2 substring. So "xxcaazz" and "xxbaaz" yields 3, since the "xx", "aa", and "az" substrings appear in the same place in both strings.
pt: Sejam duas cadeia a e b, retorne a quantidade de posições onde elas contêm a mesma subcadeia de tamanho 2. Assim, "xxcaazz" e "xxbaaz" retornam 3, pois as subcadeias "xx", "aa" e "az" aparecem nas mesmas posições nas duas cadeias.

note: type: Content of: <h1>
en: StringSplosion
pt: Explosão de cadeias

note: type: Content of: outside any tag (error?)
en: Given a non-empty string like "Code" return a string like "CCoCodCode".
pt: Dada uma cadeia não vazia como "Code" retorna uma cadeia como "CCoCodCode".

note: type: Content of: <h1>
en: StringTimes
pt: Multiplicação de cadeias

note: type: Content of: outside any tag (error?)
en: Given a string and a non-negative int n, return a larger string that is n copies of the original string.
pt: Dada uma cadeia e um inteiro positivo retorna uma cadeia mais comprida que consiste em n cópias da cadeia original.

note: type: Content of: outside any tag (error?)
en: Given a string, return a version where all the "x" have been removed. Except an "x" at the very start or end should not be removed.
pt: Dada uma cadeia, retorne uma versão onde todos os "x" são removidos. Exceto os "x" no começo e no final que devem permanecer.

note: type: Content of: outside any tag (error?)
en: Suppose the string "yak" is unlucky. Given a string, return a version where all the "yak" are removed, but the "a" can be any char. The "yak" strings will not overlap.
pt: A string "yak" não tem sorte. Dada uma cadeia, retorna uma versão onde todas as "yak" são removidas (qualquer que seja o caractere no lugar do 'a'). As diferentes cadeias "yak" não se sobrepõem.

note: type: Content of: <h2>
en: Lunar Lander
pt: Módulo lunar

note: type: Content of: <p>
en: In this lesson you pilot a lunar landing module in increasingly complex situations.
pt: Nesta lição vai pilotar um módulo lunar em situações de complexidade crescente.

note: type: Content of: <p>
en: At each step of the simulation, the player issues a command controlling how much the angle and thrust of the lander should change
pt: A cada passo da simulação, o jogador envia um comando a controlar quanto o ângulo e a potência do módulo devem mudar

note: type: Content of: <p>
en: Ideas concerning the progression of exercises:
pt: Ideias a respeito da progressão dos exercícios:

note: type: Content of: <ul><li>
en: A lander in vertical position above flat ground, the player can only control thrust (done)
pt: Um módulo em posição vertical sobre solo plano, o jogador só controla a potência (feito)

note: type: Content of: <ul><li>
en: A lander in vertical position not above flat ground, the player control thrust and angle (done)
pt: Um módulo em posição vertical sobre solo inclinado, o jogador controla potência e ângulo (feito)

note: type: Content of: <ul><li>
en: A lander with difficult angle and speed not above flat ground, the player control thrust and angle
pt: Um módulo com ângulo ruim e rápido sobre solo inclinado, o jogador controla potência e ângulo

note: type: Content of: <ul><li>
en: A lander with difficult angle and speed not above flat ground, with difficult ground, the player control thrust and angle
pt: Um módulo com ângulo difícil e rápido sobre superfície inclinada, com solo difícil, o jogador controla potência e ângulo

note: type: Content of: <ul><li>
en: Same with wind?
pt: O mesmo com vento?

note: type: Content of: <p>
en: This lesson assumes some basic programming and physics skills.
pt: Esta lição assume algum conhecimento de física e programação básica.

note: type: Content of: <p>
en: In this universe you pilot a lunar lander. At each simulation step you're given the lander's position, speed, angle and thrust and must issue a command adjusting its angle and thrust.
pt: Pilota um módulo lunar neste universo. A cada passo da simulação recebe a posição, velocidade, ângulo e potência do módulo e deve enviar um comando a ajustar o ângulo e a potência.

note: type: Content of: outside any tag (error?)
en: Get the X and Y position of the lander.
pt: Obter (Get) as posições X e Y do módulo.

note: type: Content of: outside any tag (error?)
en: Get the horizontal and vertical speed of the lander.
pt: Obter a velocidade horizontal e vertical do módulo.

note: type: Content of: outside any tag (error?)
en: Get or set the angle of the lander.
pt: Obter ou ajustar o ângulo do módulo.

note: type: Content of: outside any tag (error?)
en: An angle of 0° denotes a vertical position where the "head" of the lander points up.  This is the angle you must land with. A positive angle denotes a left-leaning lander, a negative angle a right-leaning one. You cannot lean more than by ±90°, and the angle can vary by at most ±5° in one step.
pt: Um ângulo de 0° denota uma posição vertical onde a "cabeça" do módulo aponta para cima. É o ângulo com que deve pousar. Um ângulo positivo denota a inclinação para a esquerda, um ângulo negativo denota inclinação para a direita. Não pode inclinar mais que ±90° e o ângulo pode sofrer uma variação de no máximo ±5° a cada passo.

note: type: Content of: outside any tag (error?)
en: Get or set the thrust of the lander.
pt: Obter ou ajustar a potência do módulo.

note: type: Content of: outside any tag (error?)
en: You can only increment or decrement the thrust by 1 between two simulation steps, so if the current thrust is 2 and you ask for 4, you'll only get 3 in the next step. If you ask for less than 0 (resp. more than 4), everything will be as if you had asked for 0 (resp. 4).
pt: Só pode aumentar ou diminuir a potência de 1 a cada passo. pois se a potência atual é 2 e pede 4, ela vai mudar para 3 no próximo passo. Se pedir menos que 0 (ou, respetivamente, mais que 4), vai ser como se tivesse pedido 0 (ou, respetivamente, 4).

note: type: Content of: outside any tag (error?)
en: Get the remaining fuel in the lander.  At each step of the simulation the lander consumes as many fuel units as the current thrust. Once you run out of fuel you're in free fall so beware!
pt: Obter o combustível restante no módulo.  A cada passo da simulação o módulo consome tantas unidades de combustível como a potência atual. Uma vez que fique sem combustível entra em queda livre. Portanto, cuidado!

note: type: Content of: outside any tag (error?)
en: Get the vertices of the ground's profile from left to right.  [!java|scala]You can retrieve the X and Y coordinates of each point with the corresponding methods of your point: <code>p.x()</code> and <code>p.y()</code>.[/!] [!python]Each point is an array of two integers denoting respectively the X and Y coordinates of that point.[/!]
pt: Obter os vértices do perfil do solo da esquerda para a direita.  [!java|scala]Pode recuperar as coordenadas X e Y de cada ponto com os métodos correspondentes do seu ponto: <code>p.x()</code> e <code>p.y()</code>.[/!] [!python]Cada ponto é uma array de dois inteiros a denotar respetivamente as coordenadas X e Y de cada ponto.[/!]

note: type: Content of: <p>
en: Congratulations! You won a (one-way) trip to Mars in a cereal box. NASA was kind enough to donate the Lunar Excursion Module for this mission, so that's what you'll be flying.
pt: Parabéns! Ganhou uma viagem (só de ida) para Marte numa caixa de cereais. A NASA é orgulhosa em doar o módulo da excursão lunar para esta missão e é o que vai pilotar.

note: type: Content of: <p>
en: Before you take off, you must go through some basic landing simulation. You shouldn't have to fly the lander if all goes as planned but, as they say, "better safe than sorry".
pt: Antes de pousar, vai realizar algumas simulações de pouso. Não tem que pilotar o módulo se tudo for como planeado, mas, como dizem, "é melhor prevenir que remediar".

note: type: Content of: <p>
en: Your mission is to <b>land the lander with a vertical speed of at most 10 m/s.</b> There are two ways you can influence the lander's course: by adjusting its angle or by adjusting its thrust. In this simulation we only care about adjusting the thrust, expressed in m/s².
pt: A sua missão é <b>pousar o módulo com a velocidade vertical máxima de 10 m/s.</b> Existem duas formas de influenciar o curso do módulo: a ajustar o ângulo dele ou a ajustar a potência dele. Nesta simulação vamos nos preocupar apenas a ajustar a potência, expressa em m/s².

note: type: Content of: <p>
en: The [!python]<code>step()</code> function[/!][!scala|java|c]code[/!] that you should write now will be called every 0.1 second during the simulation. Make sure that your code does not last too long, with no while loop! It should only set the desired thrust of the next simulation step, by calling <code>[!java]void [/!]setDesiredThrust([!java]int [/!]desiredThrust[!scala]:Integer[/!])</code> where <code>desiredThrust</code> is some integer between 0 and 4 (that is, a thrust between 0 m/s² and 4 m/s²). You can only increment or decrement the thrust by 1 between two simulation steps, so if the current thrust is 2 and you ask for 4, you'll only get 3 in the next step. If you ask for less than 0 (resp. more than 4), everything will be as if you had asked for 0 (resp. 4).
pt: [!scala|java|c]O código[/!] [!python] da função <code>step()</code> [/!], que vai escrever, agora vai ser chamada a cada 0,1 segundos durante a simulação. Certifique-se que o seu código não demora muito para executar, sem usar o loop while! Apenas deve ajustar a potência desejada para o próximo passo da simulação, a chamar <code>[!java]void [/!]setDesiredThrust([!java]int [/!]desiredThrust[!scala]:Integer[/!])</code> onde <code>desiredThrust</code> é algum inteiro entre 0 e 4 (ou seja, uma potência entre 0 m/s² e 4 m/s²). Só pode aumentar ou diminuir a potência por 1 entre dois passos da simulação. Portanto, se a potência atual é 2 e pede 4, vai conseguir apenas 3 no próximo passo. Se pede por menos que 0 (ou, respetivamente, mais que 4), vai ser como se tivesse pedido 0 (ou, respetivamente, 4).

note: type: Content of: <p>
en: In order to take informed decisions, you can query the lander's state. In this simulation you'll probably be interested in its vertical position: <code>[!java]double [/!]getY()[!scala]:Double[/!]</code>, and its vertical speed: <code>[!java]double [/!]getSpeedY()[!scala]:Double[/!]</code>. You can also ask for the thrust via <code>[!java]int [/!]getThrust()[!scala]:Integer[/!]</code> in case you don't remember what you asked for. Remember that Mars' gravity is 3.711 m/s², it might come in handy.
pt: Para tomar decisões informadas, pode consultar o estado do módulo. Nesta simulação provavelmente vai estar interessado na posição vertical: <code>[!java]double [/!]getY()[!scala]:Double[/!]</code> e na velocidade vertical: <code>[!java]double [/!]getSpeedY()[!scala]:Double[/!]</code>. Também pode pedir a potência com <code>[!java]int [/!]getThrust()[!scala]:Integer[/!]</code> caso não se lembre o que pediu. Lembre-se que a gravidade de Marte é 3,711 m/s². Isto pode ser útil.

note: type: Content of: <p>
en: One last thing: the lander is pretty small so you don't have much fuel. At each step of the simulation the lander consumes as many fuel units as the current thrust. Once you run out of fuel you're in free fall so beware! You can consult the remaining amount of available fuel units using <code>[!java]int [/!]getFuel()[!scala]:Integer[/!]</code>.
pt: Uma última coisa: o módulo é bem pequeno, logo não tem muito combustível. Em cada passo da simulação o módulo consome tantas unidades de combustível quanto a potência atual. Uma vez que fique sem combustível vai cair em queda livre, portanto cuidado! Pode consultar a quantidade de unidades de combustível restante a usar <code>[!java]int [/!]getFuel()[!scala]:Integer[/!]</code>.

note: type: Content of: <h2>
en: Locate a Landing Zone
pt: Localizar uma área de pouso

note: type: Content of: <p>
en: After 200 days of traveling space and eating cereals you finally reach Mars. Time to land at last!
pt: Depois de 200 dias a viajar no espaço e a comer cereais finalmente chegou ao Marte. Hora de pousar, finalmente!

note: type: Content of: <p>
en: The lander is on autopilot and all you have to do is look around and tell it where to land. The lander must <b>land on a flat zone</b> if you want to remain in one piece. You indicate the lander where to land by modifying the <code>getLandingZone</code> function so that it returns a [!java|scala]<code>Segment</code> representing the zone of your choice.
pt: O módulo está no piloto-automático e tudo que tem que fazer é dar uma olhada e dizer ao módulo onde pousar. O módulo deve <b>pousar numa área plana</b> se quiser ficar inteiro. Indica ao módulo onde pousar a modificar a função <code>getLandingZone</code> de forma que retorne um [!java|scala]<code>Segment</code> a representar a área da sua escolha.

note: type: Content of: <p><p>
en: A segment is composed of two <code>Point</code>s, each of them composed of two <code>double</code>s. A segment is built via the <code>Segment([!java]Point [/!]start[!scala]:Point[/!], [!java]Point [/!]end[!scala]:Point[/!])</code> constructor.  A point is built via the <code>Point([!java]double [/!]x[!scala]:Double[/!], [!java]double [/!]y[!scala]:Double[/!])</code> constructor. A point's coordinates are accessible via its <code>[!java]double [/!]x()[!scala]:Double[/!]</code> and <code>[!java]double [/!]y()[!scala]:Double[/!]</code> methods.
pt: Um segmento é composto de dois <code>Ponto</code>s, cada um deles composto de dois <code>double</code>s. Um segmento é construído com o construtor <code>Segment([!java]Point [/!]start[!scala]:Point[/!], [!java]Point [/!]end[!scala]:Point[/!])</code>. Um ponto é construído com o construtor <code>Point([!java]double [/!]x[!scala]:Double[/!], [!java]double [/!]y[!scala]:Double[/!])</code>. As coordenadas de um ponto são acessíveis através dos métodos <code>[!java]double [/!]x()[!scala]:Double[/!]</code> e <code>[!java]double [/!]y()[!scala]:Double[/!]</code> dele.

note: type: Content of: <p>
en: [/!] [!python]tuple of two X coordinates representing the zone of your choice.[/!]
pt: [/!] [!python]tupla de duas coordenadas X a representar a área escolhida.[/!]

note: type: Content of: <p><p>
en: In order to determine which zone to return, you'll need to call <code>[!java]List&lt;Point&gt; [/!]getGround()[!scala]List[Point][/!]</code>, which returns the vertices of the ground's profile as a list of [!java|scala]<code>Point</code>[/!] [!python]tuples (x,y)[/!].
pt: Para determinar para qual área retornar, precisa chamar <code>[!java]List&lt;Point&gt; [/!]getGround()[!scala]List[Point][/!]</code>, que retorna os vértices do perfil do solo como uma lista de [!python]tuples (x,y)[/!] [!java|scala]<code>Point</code>s[/!].

note: type: Content of: <p><p>
en: One more thing: your function should return a valid flat zone in any kind of situation, not just for the currently visualized one. That's because it will be not only tested against that world, but also against the one we had in the previous exercise. As usual, you can see the other existing worlds with the appropriate combobox.
pt: Mais um detalhe: a sua função deve retornar uma área plana válida em qualquer situação, não apenas para a atualmente vista. Isto é porque não vai ser testado apenas neste mundo, mas também naquele do exercício anterior. Como sempre, pode ver os outros mundos existentes com a combobox apropriada.

note: type: Content of: <p><p>
en: Have a safe landing! Don't forget to put on your space suit on your way out.
pt: Tenha um bom pouso! Não se esqueça de vestir seu traje espacial quando for sair.

note: type: Content of: <h1>
en: Fly the Lander!
pt: Pilote o módulo!

note: type: Content of: <p>
en: After 30 days of staring at rocks and eating cereals you decide it's time to go explore other parts of the planet.
pt: Depois de 30 dias a olhar a rochas e a comer cereais decide que é hora de explorar outras partes do planeta.

note: type: Content of: <p>
en: You fly for a while and suddenly realize you're almost out of fuel.  Unfortunately you're in a delicate situation and the autopilot is helpless.  You will have to pilot the lander yourself. Your mission is to <b>land the lander on a flat zone with a vertical speed less than 10 m/s, an horizontal speed less than 5 m/s and an angle of 0°.</b>
pt: Voa por um tempo e repentinamente repara que está quase sem combustível. Infelizmente, está numa situação delicada e o piloto automático é inútil.  Você mesmo terá que pilotar o módulo. A sua missão é <b>pousar o módulo numa área plana com uma velocidade vertical menor que 10 m/s, uma velocidade horizontal menor que 5 m/s e um ângulo de 0°.</b>

note: type: Content of: <p>
en: You must define two functions: <code>[!java]void [/!]initialize()</code> and <code>[!java]void [/!]step()</code>. <code>initialize()</code> is called once just after you press "Run". You can use it to chose some flat zone. As before, <code>step()</code> is called every 0.1 second and is used for adjusting the lander's thrust and angle. As in the first exercise the lander's thrust is adjusted via <code>[!java]void [/!]setDesiredThrust([!java]int [/!]desiredThrust[!scala]:Integer[/!])</code>.  But you can also control its angle via <code>[!java]void [/!]setDesiredAngle([!java]double [/!]desiredAngle[!scala]:Double[/!])</code>.  An angle of 0° denotes a vertical position where the "head" of the lander points up.  This is the angle you must land with. A positive angle denotes a left-leaning lander, a negative angle a right-leaning one. You cannot lean more than by ±90°, and the angle can vary by at most ±5° in one step.
pt: Precisa definir duas funções: <code>[!java]void [/!]initialize()</code> e <code>[!java]void[/!]step()</code>. <code>initialize()</code> é chamada uma única vez depois de apertar "Executar". Pode usá-lo para escolher uma área plana. Como antes, <code>step()</code> é chamado a cada 0,1 segundos e é usada para ajustar a potência e ângulo do módulo. Como no primeiro exercício, a potência do módulo é ajustada através de <code>[!java]void [/!]setDesiredThrust([!java]int [/!]desiredThrust[!scala]:Integer[/!])</code>.  Mas também pode controlar o ângulo dele através de <code>[!java]void [/!]setDesiredAngle([!java]double [/!]desiredAngle[!scala]:Double[/!])</code>.  Um ângulo de 0° denota uma posição vertical onde a "cabeça" do módulo  aponta para cima. Este é o ângulo com o qual deve pousar. Um ângulo positivo denota um módulo inclinado para a esquerda, um ângulo negativo um inclinado para a direita. Não pode inclinar mais que ±90° e o ângulo pode mudar por no máximo ±5° em cada passo.

note: type: Content of: <p>
en: As in the previous exercise, <code>[!java]List&lt;Point&gt; [/!]getGround()[!scala]:List[Point][/!]</code> returns the vertices of the ground's profile from left to right.  Please refer to the documentation (Help/About this world) for a reference manual of your lunar lander.
pt: Como no exercício anterior, <code>[!java]List&lt;Point&gt; [/!]getGround()[!scala]:List[Point][/!]</code> retorna os vértices do perfil do solo da esquerda para a direita. Favor consulte a documentação (Ajuda/Sobre este mundo) para um manual de referência do módulo lunar.

note: type: Content of: <p>
en: As before, your program must safely land the lander in all the situations encountered so far in addition to this new one.
pt: Como antes, o seu programa deve pousar o módulo com segurança em todas as situações encontradas além desta nova.

note: type: Content of: <p>
en: Good luck, try not to crash!
pt: Boa sorte, tente não cair!

note: type: Content of: <h2>
en: The PLM Main Window
pt: A Janela Principal do PLM

note: type: Content of: outside any tag (error?)
en: The PLM working environment should be self-explanatory, in particular with the tool tips appearing when your mouse is over the elements.  Here is a little explanation of the components in case you fail to understand something. The main window is made of 5 main components:
pt: O ambiente de trabalho do PLM é auto-explicativo, principalmente com as dicas que aparecem quando o mouse passa sobre elementos. Aqui está uma breve explicação dos componentes caso não entenda algo. A janela principal é composta de 5 componentes principais:

note: type: Content of: <ul><li>
en: <b>The menu:</b> Placed on top of the window, it gives you access to some advanced commands such as exiting the program, and some other that we will detail later.
pt: <b>O menu:</b> posto na parte de cima da janela, dá-lhe acesso a alguns comandos avançados, como sair do programa e alguns outros que falaremos mais tarde.

note: type: Content of: <ul><li>
en: <b>The tool bar:</b> Placed just below the menu, it gives you access to the four main commands:
pt: <b>A barra de ferramentas:</b> Posta logo abaixo do menu, ela te dá acesso aos quatro comandos principais:

note: type: Content of: <ul><li><ul><li>
en: The <b>Start</b> button, which begins the compilation and execution of the code you may have typed in the editor. At the end of the execution, it verifies whether you reach the situation constituting the objective of the exercise or not. If yes, you gain access to the next exercise using the <b>Exercise</b> menu. If not, you need to rework your code.
pt: O botão <b>início</b>, que começa a compilação e a execução do código que digitou no editor. No final da execução, verifica se alcançou uma situação que constitui o objetivo do exercício ou não. Se sim, ganha acesso ao próximo exercício a usar o menu <b>Exercício</b>. Se não, vai precisar refazer o seu código.

note: type: Content of: <ul><li><ul><li>
en: The <b>Stop</b> button allows you to interupt the execution of your code, what may reveal useful if you encounter an <i>infinite loop</i>.
pt: O botão <b>Parar</b> sempre serve para interromper a execução do seu código, o que pode ser útil se entrar num <i>loop infinito</i>.

note: type: Content of: <ul><li><ul><li>
en: The <b>Reset</b> button can be used to reset the world into its initial state.
pt: O botão <b>Reset</b> pode ser usado para reconfigurar o mundo para o estado inicial.

note: type: Content of: <ul><li><ul><li>
en: The <b>Demo</b> button shows you the execution of the expected solution. During its execution, you may want to switch the seen world to see the different expected solutions.
pt: O botão <b>Demo</b> mostra a execução da solução esperada. Durante a execução pode alternar o mundo visto para ver as diferentes soluções esperadas.

note: type: Content of: <ul><li><ul><li>
en: Please note that there is often several ways of achieving the awaited solution, and that the one presented during the demo is not more or less correct than the others. You are completely free to not follow strictly the process shown by the demo, as long as your final solution matches the exercise expectations.
pt: Note que às vezes existem várias maneiras de alcançar a solução esperada e que aquela apresentada durante a demonstração não é mais ou menos certa que as outras. É completamente livre para não seguir estritamente o processo mostrado pela demonstração, desde que a sua solução final atinja o que exercício pede.

note: type: Content of: <ul><li>
en: <b>Mission and editor tabs:</b> this is were you read this very text. This area contains several tabs to which you can access by clicking on their name on the top left. The first tab (which is always named <b>Mission</b>)  contains a presentation of the current exercise. To solve an exercise, you need to write your code in the other tabs. For example, you can now clic on the <b>Source Code</b> tab to see the actual source. If it is empty, that's because you did not write any code yet.
pt: <b>Guias de missão e editor:</b> é onde está a ler este texto. Esta área contém várias abas as quais pode acessar a clicar no nome deles no canto superior esquerdo. A primeira guia (que se chama sempre <b>Missão</b>) contém uma apresentação do exercício atual. Para resolver um exercício, precisa escrever o seu código nas outras guias. Por exemplo, pode agora clicar na guia <b>Código Fonte</b> para ver o código real. Se estiver vazia, é por que ainda não escreveu nenhum código.

note: type: Content of: <ul><li>
en: <b>The console:</b> Placed under the tabs, this is where any messages of the application will appear. This area is initially empty and white.
pt: <b>O console:</b> localizado abaixo das abas, é onde aparece qualquer mensagem da aplicação. Esta área inicialmente é vazia e branca.

note: type: Content of: <ul><li>
en: <b>World view</b> Placed on the right of the tabs, it is constituted of five elements:
pt: <b>Visão do mundo</b> localizada à direita das abas, é constituída de cinco elementos:

note: type: Content of: <ul><li><ul><li>
en: A scrolling menu allows to choose the world. Indeed, the program you write may be executed in several worlds to test it in differing conditions. This menu allows you to choose the world you want to see. Note that this scrolling menu is hidden if there is only one world in your exercise.
pt: Um menu rolante serve para escolher o mundo. Na verdade, o programa que escreveu pode ser executado em vários mundos para testá-lo em diferentes condições. Este menu é para escolher o mundo que quer ver. Observe que este menu rolante fica oculto se houver apenas um mundo no seu exercício.

note: type: Content of: <ul><li><ul><li>
en: A slider placed right bellow allows to choose the animation speed of the world. More precisely, it allows to choose the delay (in milliseconds) that the buggles must wait after each action to allow you to see what they are doing.
pt: Um "slider" posto logo abaixo serve para escolher a velocidade da animação do mundo. Mais precisamente, permite escolher o atraso (em milisegundos) que os buggles devem esperar depois de cada ação para permitir que veja o que eles estão a fazer.

note: type: Content of: <ul><li><ul><li>
en: A tab <b>World</b> represents the view of the world currently selected (from the scrolling menu). This view is thus constitued of a grid forming the several cells of the world, as well as several <i>buggles</i> awaiting for your orders.
pt: Uma guia <b>Mundo</b> representa a visão de mundo atualmente selecionada (de menu rolante). Esta visão é então constituída de uma grade a formar várias células do mundo, assim como vários "<i>buggles</i>" a esperar as suas ordens.

note: type: Content of: <ul><li><ul><li>
en: An <b>Objective</b> tab displaying the world as it must be by the end of the exercise.
pt: Uma guia <b>Objetivo</b> a mostrar o mundo como deveria ser no final do exercício.

note: type: Content of: <ul><li><ul><li>
en: <b>The interactive controls</b>. Placed under the world view, these buttons allows you to interactively control the buggles. This way, you can try to <i>manually</i> bring your buggle to the scenario objective before writting the needed code in the editor.
pt: <b>Os controles interativos</b>. Localizados abaixo da Visão do mundo, estes botões servem para controlar interativamente os buggles. Desta forma, pode tentar trazer <i>manualmente</i> o seu buggle ao objetivo do cenário antes de escrever o código necessário no editor.

note: type: Content of: <ul><li><ul><li><ul><li>
en: A scrolling menu allows to select the buggle you want to control.
pt: Um menu rolante serve para selecionar o "buggle" que quer controlar.

note: type: Content of: <ul><li><ul><li><ul><li>
en: The <b>Forward</b> button let your buggle do one step forward.
pt: O botão <b>Avançar</b> faz o seu "buggle" dar um passo à frente.

note: type: Content of: <ul><li><ul><li><ul><li>
en: The <b>Backward</b> button let it do one step backward.
pt: O botão <b>Recuar</b> fá-lo dar um passo para trás.

note: type: Content of: <ul><li><ul><li><ul><li>
en: The <b>Turn left</b> button ask your buggle to turn of 90° to its left.
pt: O botão <b>Virar à esquerda</b> manda o seu "buggle" virar 90° à esquerda.

note: type: Content of: <ul><li><ul><li><ul><li>
en: The <b>Turn right</b> button asks the buggle to turn to the right (isn't this amazing?).
pt: O botão <b>Virar à direita</b> manda o seu "buggle" virar à direita (surpreendente, né?).

note: type: Content of: <ul><li><ul><li><ul><li>
en: The <b>Mark</b> button requests your buggle to leave a mark behind it when it goes.
pt: O botão <b>Marcar</b> pede que o seu "buggle" deixe uma marca atrás dele depois que sair.
