O que se aprende enquanto se jogam os puzzles? Vamos espreitar por detrás de cada puzzle e perceber o que se aprende ou pode aprender sobre computação, enquanto nos divertimos.
Nível 1 - Números (principalmente potências de 2)
Puzzle 1 – o ET precisa de uma caixa que tenha dentro um 1 e um 2. Este puzzle introduz as caixas do ToonTalk que servem para guardar coisas. Os engenheiros informáticos chamam-lhes estruturas de dados. As caixas relacionam-se com conceitos como arrays, vectores e tuplos. Os números são um exemplo do que os cientistas denominam de tipos de dados atómicos. Para resolver este puzzle, precisas de tentar perceber como podes pôr coisas numa caixa (isto é, como inicializar os elementos de um vector).
Puzzle 2 – o ET precisa de um 4. Este puzzle introduz o Marretas (o rato) que faz aritmética e outras operações básicas. Ao resolver este puzzle, vais descobrir como expressar a soma de dois números.
Puzzle 3 – o ET precisa de uma caixa com 8, 16 e 32. Introduz-se uma maneira de combinar caixas para fazer caixas maiores. Também ilustra a forma de expressar a adição de um número que está numa caixa. Na terminologia da ciência dos computadores, aprende-se a concatenar vectores e a operar num elemento de uma estrutura de dados.
Puzzle 4 – o ET precisa de um número que seja maior que 1000. Este puzzle apresenta a varinha mágica do ToonTalk que é utilizada para copiar objectos do ToonTalk. Como todas as ferramentas do ToonTalk, a varinha mágica pode ser usada como parte de um programa e como ferramenta de um ambiente de programação. Este puzzle é interessante a nível da matemática, uma vez que se baseia na repetição da duplicação de números que crescem de 1 a 1024, em apenas 10 passos. É intencionalmente um pouco enfadonho, para permitir uma motivação para mais tarde realizar de forma automática tarefas como esta .
Puzzle 5 – o ET precisa de um zero. Este puzzle introduz o Limpopó, o aspirador. O Limpopó é uma ferramenta para aspirar coisas. O zero está por baixo de muitas coisas que só o Limpopó consegue remover.
Puzzle 6 – o ET precisa de –1. Para resolver este puzzle, o jogador precisa de adivinhar (ou receber palpites do ET) que o botão que está no nariz do Limpopó pode mudar, clicando nele. Este uso de botões que mudam o comportamento das ferramentas é muito utilizado no ToonTalk. Um jogador atento vai reparar que o Limpopó serve para aspirar coisas e para, mais tarde, as cuspir. Isto corresponde (muito de perto) às operações cortar e colar de muitos interfaces baseados no windows.
Puzzle 7 – o ET precisa de um bloco de números vazio. Este puzzle introduz os blocos de números vazios que serão utilizados noutros puzzles. Um bloco de números vazio é uma forma de expressar o tipo de estrutura de dados. Neste caso, indica os dados cujo tipo é número.
Puzzle 8 – o ET precisa de uma caixa com dois zeros. Ao treinares o robot neste puzzle, estás a construir o teu primeiro programa. O programa construído é equivalente ao programa textual que se segue:
while (sizeOf(box) = 1 and box[0] = 1) dobox := concat(box, copy(box));
endwhile;
A razão pela qual até crianças pequenas conseguem construir este programa sem ajuda é que o puzzle restringe o mundo, de tal forma que a informação necessária para que um jogador encontre a solução não é muita. Aqui a memória do robot está limitada: ele apenas se lembra de dois passos e já tem uma varinha mágica.
Puzzle 9 – o ET precisa de um número maior do que um bilião. A solução para este puzzle baseia-se na experiência da resolução dos puzzles 4, 7 e 8. Para resolver este puzzle, precisas de treinar um robot para fazer o que fizeste manualmente no puzzle 4. No puzzle 4, tiveste de repetir uma sequência de acções 10 vezes. Aqui vais simplesmente treinar o robot para fazer uma sequência e ele repetirá isso 30 vezes. Para que o robot trabalhe repetidamente, precisas de aprender a pôr o robot menos confuso acerca do tipo de caixa com que ele trabalha. O programa textual equivalente ao robot treinado neste puzzle é:
repeat 30
if (sizeOf(box) = 1 and isNumber(box[0])) then
Box[0] := box[0] + copy(box[0]);
endif;
Puzzle 10 - o ET precisa de uma caixa dentro de outra caixa. Para resolver este puzzle, precisas de colocar uma caixa dentro de outra caixa. Se colocares uma das caixas no buraco errado, o ET informa-te que o elemento tem de estar no local correcto.
Puzzle 11 - o ET precisa de uma caixa com três zeros. Tal como no puzzle 2, precisas de juntar 2 caixas. Aqui irás descobrir que não podes juntar caixas quando elas fazem parte de outra caixa. Vais descobrir também que as caixas podem ser removidas, juntas e colocadas no sítio onde estavam. Uma solução corresponde ao seguinte fragmento de código:
temp1 := box[0];
temp2 := box[1];
temp1 := concat(temp1,temp2);
box[1] := temp1;
Puzzle 12 - o ET precisa de uma caixa com seis zeros. Este puzzle é parecido com o puzzle 11. A operação de juntar caixas é repetida 3 vezes. Isto é para te preparar para o puzzle seguinte, no qual um robot é treinado para juntar caixas repetidamente.
Puzzle 13 - o ET precisa de de uma caixa com dez zeros. Ao resolver este puzzle, treinas o robot para reutilizar uma caixa. Isto introduz uma técnica de programação muito usada quando se cria uma estrutura de dados de forma incremental. O robot treinado corresponde ao seguinte programa textual:
repeat 4
if (sizeOf(box) = 2 and sizeOf(box[0]) = 1 and box[0][0] = 0) then
temp1 := copy(box[0]);
temp1 := concat(temp1,box[1]);
box[1] := temp;
endif;
Neste puzzle, o robot consegue lembrar-se até 20 passos, mas o puzzle pode ser resolvido apenas com 4.
Puzzle 14 - o ET precisa de uma caixa com 1, 2, 4, 8, 16 e 32. Resolver este puzzle requer reutilizar repetidamente uma caixa cujos números são o dobro do número anterior.
Puzzle 15 - o ET precisa de uma caixa com 1, 2, 4, 8, 16 e por aí fora até 1.073.741.824. A resolução deste puzzle baseia-se nos puzzles 9, 13 e 14. É um bom exemplo de como é preciso, muitas vezes, combinar diferentes técnicas de programação para alcançar determinado objectivo. Aqui está o equivalente programa textual:
repeat 30
if (sizeOf(box) = 2 and sizeOf(box[0]) = 1 and isNumber(box[0][0])) then
box[0][0] := box[0][0] + copy(box[0][0]);
temp1 := copy(box[0]);
temp2 := box[1];
temp2 := concat(temp2,temp1);
box[1] := temp2;
endif;
Puzzle 16 - o ET precisa do dia em que nasceste. As potências de 2 são a base dos inteiros positivos. Por outras palavras, qualquer número pode ser expresso como sendo a soma de números que são potência de 2 e nenhum número (nessa soma) aparece mais do que uma vez. Acrescente-se a falta da varinha mágica neste puzzle.
Puzzle 17 - o ET precisa do ano em que nasceste em binário. Precisas de fazer exactamente o mesmo que no puzzle 16 (até de uma forma mais fácil). O truque está em reparares que onde precisas de um 1, tens de procurar um número que tenha um 1 nessa posição.
Puzzles 18, 19 e 20 - Foram intencionalmente deixados em branco.
Nível 2 - Letras e Palavras
Puzzle 21 - o ET precisa de uma caixa com A, B e C. Este puzzle introduz os blocos de texto (um novo tipo de dados). Ao resolver este puzzle, vais descobrir como a adição opera com letras.
Puzzle 22 - o ET precisa de uma caixa com A, B, C, D, E e F. Este puzzle é semelhante ao puzzle 14, só que a mesma técnica é agora aplicada a letras e não a números.
Puzzle 23 - o ET precisa de uma caixa com A, B, C e por aí fora até Z. Este puzzle baseia-se nos puzzles 15 e 22. Tal como no puzzle 15, precisas de treinar um robot para fazer um passo, de tal forma que ao acabar um tarefa está pronto para o passo seguinte. O programa textual equivalente é:
repeat 20
if (sizeOf(box) = 3 and box[0] = 1 and sizeOf(box[1]) = 1 and isText(box[1][0])) then
temp1 := copy(box[1]);
box[1][0] := box[1][0] + copy(box[0]);
temp2 := box[2];
temp2 := concat(temp2,temp1);
box[2] := temp2;
endif;
Puzzle 24 - o ET precisa de uma caixa com a, b, c e por aí fora até z. Este puzzle é trivial, uma vez que o robot treinado no puzzle anterior pode criar a caixa que é precisa aqui. Tudo o que o robot precisa é que lhe dês uma caixa diferente para ele começar. Um robot é o que os cientistas dos computadores chamam procedimento. E este procedimento tem um parâmetro - a caixa que é dada ao robot. Um aspecto muito importante de um procedimento é que ele pode ser reutilizado, fornecendo-lhe parâmetros diferentes.
Puzzle 25 - o ET precisa de uma caixa com o alfabeto que é de tal modo pequeno que se consegue ver todo de uma só vez. Este puzzle introduz uma nova ferramenta: a Artolas - a bomba de bicicleta. A Artolas muda o tamanho das coisas. Isto é útil para no modo 'Brincar', lidar com o tamanho real do ecrã. É também uma forma fácil e directa para alterar o tamanho das imagens.
Puzzle 26 - o ET precisa de uma caixa com um ponto final, um ponto de interrogação e uma vírgula. Este puzzle mostra que os blocos de texto não estão limitados às letras do alfabeto, incluindo também pontuação. As letras, a pontuação e os símbolos especiais (como $) são chamados caracteres na maior parte das linguagens de programação. Este puzzle ilustra também que o tamanho dos objectos no ToonTalk não influencia o seu comportamento (ou semântica).
Puzzle 27 - o ET precisa de uma caixa com a pontuação que deverá ser grande o suficiente para o seu conteúdo ser visível. Este puzzle introduz o conceito de tecla de atalho - neste caso, é uma forma de criar um som que chama pela Artolas para ela vir logo para a tua mão. As teclas de atalho são comuns em muitos tipos diferentes de interfaces com o utilizador.
Puzzle 28 - o ET precisa da palavra "iniciar". Este puzzle introduz as chamadas strings - isto é, sequências de caracteres. Para resolver este puzzle, precisas de descobrir que as letras e as strings podem ser concatenadas para formarem strings maiores.
Puzzles 29 e 30 - Estes puzzles foram deixados em branco intencionalmente.
Nível 3 - Matemática do Tempo
Puzzle 31 - o ET precisa de uma caixa com o teu aniversário. Para resolver este puzzle, precisas de descobrir que o teclado pode ser usado para alterar os valores das strings e dos números. Este é um tipo de manipulação directa de dados.
Puzzle 32 - o ET quer saber o número de minutos de um dia. Este puzzle ilustra que a adição repetida corresponde à multiplicação. O programa textual é:
repeat 24
if (sizeOf(box) = 2 and isNumber(box[0]) and isNumber(box[1])) then
box[1] := box[1] + copy(box[0]);
endif;
Puzzle 33 - o ET quer saber o número de segundos numa hora. O robot do puzzle 32 é reutilizado aqui. A única diferença está no número de vezes que as instruções deverão ser repetidas.
Puzzle 34 - o ET precisa de uma caixa que apresente um conjunto de balanças que mostre que dois números são iguais. Este puzzle introduz as balanças, que são uma maneira de expressar comparações numéricas. Introduz também o uso de números negativos para a subtracção.
Puzzle 35 - o ET precisa de outra caixa com uma balança que mostre que dois números são iguais. Este puzzle é diferente do anterior, porque agora é um robot que vai fazer o trabalho. O que é importante notares aqui é que o robot pára, quando a balança deixa de estar desiquilibrada para a esquerda. Como o robot tem a varinha mágica com magia ilimitada, ele só pára quando a caixa deixar de ser igual à que ele tem no seu balão de pensamento. O programa textual equivalente é:
while (sizeof(box) = 4 and box[1] = '>' and isNumber(box[0]) and isNumber(box[2]) and isNumber(box[3])) then
box[2] := box[2] + copy(box[3]);
endwhile;
A expressão "box[1] = '>'" não é muito usual. Neste caso, é equivalente à expressão mais comum "box[0] > box[2]", uma vez que a balança apresenta sempre a relação entre os dados vizinhos.
Puzzle 36 - o ET precisa de uma caixa com 24 zeros. Este puzzle combina os puzzles 13 e 35. Mostra como se pode utilizar o while loop como uma expressão for. Esta é uma técnica importante para repetir alguma coisa determinado número de vezes, sem se saber quantas vezes é preciso repeti-la antes do programa começar.
Os engenheiros informáticos analisam os programas para encontrarem invariantes. Estas são relações que permanecem depois de cada ciclo. Aqui o que é invariante é o facto do primeiro buraco da caixa ser um número cujo tamanho (isto é, o número de buracos) é o da caixa no sexto buraco. O programa textual equivalente ao robot é:
while (sizeof(box) = 6 and box[1] = '<' and isNumber(box[0]) and isNumber(box[2]) and isNumber(box[3])) do
temp1 := copy(box[4]);
temp2 := box[5];
temp2 := concat(temp2,temp1);
box[5] := temp2;
box[0] := box[0] + copy(box[3]);
endwhile;
ou:
if (sizeof(box) = 6 and box[1] = '<' and isNumber(box[0]) and isNumber(box[2]) and isNumber(box[3])) then
for (; box[0] < box[2]; box[0] := box[0] + copy(box[3])) do
temp1 := copy(box[4]);
temp2 := box[5];
temp2 := concat(temp2,temp1);
box[5] := temp2;
endfor;
endif;
Puzzle 37 - o ET quer saber quantas horas há num ano. Este é parecido com o puzzle 32, com a excepção de que aqui estás a treinar um robot com um uso mais generalizado. E isto porque o robot efectua o produto dos 2 primeiros números e mantém isso no sexto buraco. A diferença neste programa é o número do sexto buraco que é o produto dos números do primeiro e do quarto buracos. O robot pára quando os números do segundo e do quarto buracos forem iguais. O programa textual equivalente é:
while (sizeof(box) = 6 and box[1] > box[3] and isNumber(box[0]) and isNumber(box[1]) and isNumber(box[3]) and isNumber(box[4]) and isNumber(box[5])) do
box[5] := box[5] + copy(box[0]);
box[3] := box[3] + copy(box[4]);
endwhile;
Puzzle 38 - o ET quer saber quantos segundos há num dia. Para resolver este programa, usa o robot treinado no puzzle anterior para multiplicar 60 por 24 (que dá 1440). O jogador utiliza outra vez o robot para multiplicar 60 por 1440. Isto pode ser feito pondo o 60 no primeiro ou no segundo buraco e o 1440 no outro. O robot fará o produto correctamente, mas será muito mais rápido se o 1440 estiver no primeiro buraco. Isto acontece porque o robot multiplica através da adição repetitiva do primeiro número. O montante de trabalho que o robot deve fazer é proporcional ao número do segundo buraco. Na terminologia da ciência computacional, dizemos que a complexidade do programa é linear com o segundo argumento.
Puzzle 39 - o ET quer saber quantos segundos existem num ano. Tal como o puzzle anterior, este usa repetidamente o robot treinado no puzzle 37 para fazer 365x24x60x60.
Puzzle 40 - Este puzzle foi intencionalmente deixado em branco..
Nível 4 - Calcular o Tempo
Puzzle 41 - o ET precisa dos dias da semana. Este puzzle introduz os pássaros e os seus ninhos. Para um engenheiro informático, um pássaro e o seu ninho são um canal de comunicação. Um pássaro é o direito ou a capacidade de enviar mensagens para um canal e o seu ninho é o direito de receber mensagens nesse canal. Este exemplo ilustra também que as mensagens no ToonTalk estão organizadas numa fila do tipo primeiro a entrar, primeiro a sair (first in first out).
Puzzle 42 - o ET precisa de uma caixa com um ninho que tenha os números inteiros a começar do 2. O robot treinado para resolver este puzzle é o que os cientistas dos computadores chamam de gerador. Aqui o robot gera um conjunto de inteiros. Este gerador é um gerador infinito, pois não pára. O programa textual equivalente é:
while (sizeOf(box) = 3 and isNumber(box[0]) and isNumber(box[1]) and isSendCapability(box[2])) do
transmit(box[2],copy(box[0])); // transmit a copy of box[0] on the channel of box[2]
box[0] := box[0]+copy(box[1]);
endwhile;
Puzzle 43 - o ET precisa da soma dos números que estão no ninho. Aqui vais treinar o robot para ser um consumidor. Muitos programas orientados a streams envolvem consumidores e geradores. Este puzzle ilustra a forma de receber mensagens. A programação textual é:
while (sizeOf(box) = 2 and isNumber(peek(box[0])) and isNumber(box[1])) do
// we "peek" at the communication channel in box[0] to see if a number is there
box[1] := box[1] + receive(box[0]);
// "receive" removes the top element in the queue and returns it
endwhile;
Puzzle 44 - o ET precisa de uma caixa com 3 números que não estão a mudar. Introduzem-se os sensores. Um sensor é actualizado em cada ciclo, por isso mostra o valor mais recente daquilo que está a controlar. O que este sensor está a controlar é suposto ser um mistério até ao puzzle 48. Este puzzle ensina uma técnica de programação do ToonTalk: "congelar um sensor", colocando-o a zero.
Puzzle 45 - o ET precisa de uma caixa com um ninho cheio de números que não mudem. Este puzzle combina os puzzles 42 e 44 para produzir uma stream de valores para os sensores. O equivalente em programação é:
while (sizeOf(box) = 3 and isNumber(box[0]) and isSendCapability(box[1]) and box[2] = 0) do
temp1 := copy(box[2]);
temp1 := temp1 + copy(box[0]);
transmit(box[1],temp1);
endwhile;
Puzzle 46 - o ET quer saber a soma dos números do ninho. O robot treinado no puzzle 43 funciona perfeitamente com esta stream de números.
Puzzle 47 - o ET quer o número que resulta da espera durante 8 segundos. Aqui utilizas o robot do puzzle 43 em paralelo com o robot do puzzle 45, ou por outras palavras, usas os dois robots ao mesmo tempo.
Puzzle 48 - o ET quer o número que resulta da espera durante 14 segundos. Para resolver este puzzle, precisas de lançar um novo processo, pegando no camião com um robot e uma caixa. Este é o método preferível para correr programas em paralelo - fazendo isso apenas com uma casa, é mais difícil de controlar e fica confuso mais depressa. Aqui vais aprender que o sensor mede o número de milisegundos desde o último ciclo do ToonTalk. A soma dos números mede quanto tempo passou. Se, no puzzle 47, saíres da casa por precisamente 8 segundos, o número que obténs é 8.000. Aqui se saíres por exactamente 14 segundos, o número deverá ser 14.000. A razão pela qual tens de sair da casa é que os pássaros, quando estão a ser observados, trabalham mais devagar (para que tu possas ver melhor o que fazem). Os pássaros lentos interferem aqui com a medida correcta do tempo.
Puzzle 49 - o ET quer que destruas a casa. Para resolveres este puzzle, precisas de descobrir como podes terminar um processo.
Puzzle 50 - o ET quer os resultados de esperar 10 segundos. Desta vez, precisas de treinar um só robot para fazer o que os robots dos puzzles 47 e 48 conseguiram. Os programadores fazem, muitas vezes, programas especiais que fazem o mesmo que a combinação de dois programas normais. Eles fazem isto porque o computador precisa de menos passos para correr o programa especial. Aqui os processos do gerador e do consumidor podem ser combinados num processo muito mais simples e rápido. A programação equivalente é:
while (sizeOf(box) = 2 and isNumber(box[1]) and isNumber(box[2])) do
box[1] := box[1] + copy(box[0]);
endwhile;
Puzzle 51 - o Et precisa da caixa 3 segundos depois do contador ter sido iniciado. Este puzzle combina os puzzles 35 e 50 para medir o tempo, até uma comparação deixar de ser verdadeira. A razão pela qual a caixa tem 6 buracos em vez de 4 será explicada mais tarde. Aqui está a forma textual:
while (sizeOf(box) = 6 and isNumber(box[0]) and isNumber(box[1]) and isNumber(box[3])and box[1] < box[3]) do
box[3] := box[3] + milliseconds_since_last_cycle();
endwhile;
Puzzle 52 - o Et precisa de -10. Este puzzle ilustra o uso repetido de -1 para decrementar um contador. É equivalente somar um número negativo ou subtrair um número positivo. A programação equivalente é:
while (sizeOf(box) = 3 and isNumber(box[0]) and isNumber(box[1])) do
box[0] := box[0] + copy(box[1]);
endwhile;
Puzzle 53 - o Et quer a palavra secreta. Este puzzle introduz equipas de robots. Quando uma caixa é dada a um robot e não é igual à que ele tem no seu balão de pensamento, este robot deixa a caixa para o robot seguinte da equipa (se houver). Em linguagens de programação procedimentais, isto corresponde à instrução se-então-senão. Em linguagens de programação orientadas a objectos, uma equipa corresponde ao comportamento de um objecto, e os robots correspondem a métodos. Em linguagens de programação lógicas, uma equipa corresponde a um predicado e cada robot a uma cláusula. A equipa construída neste puzzle é equivalente ao seguinte procedimento:
procedure team(Box box)
if (sizeOf(box) = 3 and box[0] = 0 and box[1] = -1 and box[2] = 'a') then
run_secret_procedure(box);
team(box);
else if (sizeOf(box) = 3 and isNumber(box[0]) and isNumber(box[1])) then
box[0] := box[0] + copy(box[1]);
team(box);
endif;
endprocedure;
Puzzle 54 - o ET quer um despertador. Aqui o robot treinado para o puzzle 51 é utilizado ao mesmo tempo que o que vais treinar neste puzzle. Este robot vai ser treinado para criar uma mensagem e enviá-la uns segundos mais tarde. A programação equivalente é:
procedure team(Box box)
if (sizeOf(box) = 6 and isNumber(box[0]) and isNumber(box[1]) and isNumber(box[3])and box[1] < box[3]) then
box[3] := box[3] + milliseconds_since_last_cycle();
team(box);
else if (sizeOf(box) = 6 and isNumber(box[0]) and isNumber(box[1]) and isNumber(box[3]) and isSendCapability(box[4]) and isText(box[5])) then
transmit(box[4],box[5]);
team(box);
endif;
endprocedure;
Se não aspirares a balança do balão de pensamento do novo robot, não estarás a trabalhar no caso raro de caixa[1] = caixa[3]. A probabilidade de isto acontecer é 1 na duração média do ciclo (que vai de 10 a 100, dependendo da velocidade do computador)
Puzzles 55, 56, 57, 58, 59 e 60 - Estes puzzles foram intencionalmente deixados em branco.
Nível 5 - Construir um relógio
Puzzle 61 - o Et quer um número que continue a aumentar. A solução para este puzzle é a mesma que para o puzzle 50. Mas aqui o número que irá mudar tem uma propriedade especial: as suas mudanças influenciam também o outro número. Isto é o que os engenheiros informáticos chamam de partilha de estados. A partilha de estados é conhecida por causar problemas em programas concorrentes. No ToonTalk, os controlos remotos trabalham apenas numa casa, para que esses problemas sejam evitados.
Puzzle 62 - o ET quer um número que aumente 1.000 em cada segundo. Para resolver este puzzle, é preciso pôr o robot e a sua caixa nas costas do número. Muitos sistemas de desenvolvimento de software proporcionam objectos para o interface com o utilizador que possuem programas associados. No ToonTalk, podes pôr os robots nas costas das imagens para lhes dares um comportamento que programares. A razão pela qual a solução deste puzzle mantém as horas correctamente (enquanto que a solução anterior não o fazia) é que o robot, no puzzle anterior, fazia as coisas mais devagar, para que tu o pudesses observar.
Puzzle 63 - o ET quer um número que aumente 1 em cada segundo. A solução para este puzzle baseia-se nas técnicas de programação usadas no nível 4. Uma das invariantes deste robot é que o número do terceiro buraco deve ser menos 1 que 1.000 vezes o número do quarto buraco. Outra invariante é que o quarto número será 1/1000 do valor do primeiro número. A forma textual deste robot é:
while (sizeof(box) = 6 and box[0] > box[2] and isNumber(box[0]) and isNumber(box[2]) and isNumber(box[3]) and isNumber(box[4]) and isNumber(box[5])) do
box[2] := box[2] + copy(box[5]);
box[3] := box[3] + copy(box[4]);
update_display(box[3]); // update the display to show the new value of box[3]
endwhile;
Puzzle 64 - o ET quer um número que aumente 1 em cada minuto. Este puzzle volta a usar o robot do puzzle anterior. Os números foram modificados, para que o robot assegure que o quarto número é 1/60 do primeiro número.
Puzzle 65 - o ET precisa de uma caixa com relógios com horas, minutos e segundos. Construir o relógio das horas é o mesmo que construir o relógio dos minutos no puzzle anterior.
Puzzle 66 - o ET quer que o relógio dos segundos volte a 0 quando chegar a 60. Depois do robot começar, o primeiro número será o resto da divisão do que lá estava por 60. O cálculo do resto de uma divisão é realizado por uma subtracção repetida. Vale a pena notar que este processo está a decorrer em paralelo com o processo construído anteriormente (que fazia com o número fosse 1/1000 do relógio de milisegundos). Este robot é equivalente a:
while (sizeOf(box) = 4 and box[0] > box[2] and isNumber(box[0]) and isNumber(box[2]) and isNumber(box[3]) do
box[0] := box[0] + copy(box[3]);
endwhile;
Puzzle 67 - o ET quer que o relógio dos minutos volte a 0 quando chegar a 60. Para solucionares este puzzle, tens de perceber que precisas do mesmo robot do puzzle anterior e que podes usar a varinha mágica para o copiar.
Puzzle 68 - o ET quer que o relógio das horas volte a 0 quando chegar a 24. A solução para este puzzle é igual à do anterior. Adicionalmente precisas de mudar os números, para que o robot se comporte correctamente. Isto permite testar a tua compreensão dos dois puzzles anteriores.
Puzzle 69 - o ET quer que o relógio digital mostre as horas certas. Para resolver este puzzle, apenas precisas de inicializar os valores dos vários contadores (horas, minutos e segundos) com a hora certa.
Puzzle 70 - o ET quer um relógio digital mais bonito. O software mais moderno precisa não só de fazer cálculos correctamente, mas também deve mostrar informação aos utilizadores de uma forma apelativa e efectiva. Aqui, precisas de fazer com que o relógio pareça mais atractivo.
Puzzle 71 - o ET quer uma caixa que mostre as horas a que nasceste. Isto é preciso para o puzzle seguinte.
Puzzle 72 - o ET quer saber quantos segundos faltam para que tu tenhas um número arredondado de milhões de segundos de idade. Deves largar o número que mostra a tua idade em segundos em cima do zero, para congelar esse número. Se tentares subtrair com o contador, o número continua a aumentar, mesmo quando é negativo. Deixares que isso aconteça irá afectar a resposta nalguns segundos.
Puzzle 73 - o ET quer saber quantos minutos faltam para que tu tenhas um número arredondado de milhões de segundos de idade. Este puzzle ilustra como o ToonTalk, tal como a maior parte das linguagens de programação, pode fazer a divisão de forma primitiva. Uma vez que o computador da nave se estragou, não pudeste multiplicar ou dividir números directamente e tiveste que programar essas operações só com a adição e subtracção.
Puzzle 74 - o ET quer saber quantos dias faltam para que tu tenhas um número arredondado de milhões de segundos de idade. Aqui, precisas de escrever a operação divisão, em vez de usares uma já definida.
Se chegaste ao fim dos puzzles, já deves ter aprendido o suficiente para construíres uma grande variedade de programas no 'Brincar'. Podes aprender mais, observando os Exemplos ('Demos'). Partilha o que fizeste com outros.
principal | procura | compra | manual | notícias | informação | perguntas | apoio | downloads | imprensa | contactos