O que há por trás ds desafios

A seguir daremos uma olhada no que há por trás dos desafios no ToonTalk. Você está imaginando como está aprendendo programação de computadores enquanto se diverte? Dê uma olhada nas explicações de cada desafio e você se surpreenderá com o quanto aprendeu ou pode aprender enquanto está jogando ToonTalk.


Nível 1- Números (geralmente potências de 2)

Desafio n°1 - Márcio precisa de uma caixa com um 1 e um 2 dentro. Isto introduz as caixas do ToonTalk que servem para guardar coisas. Os cientistas da computação as chamam estruturas de dados. As caixas quase se parecem com o que eles chamam bancos de dados, vetores e "tuples". Os números são um exemplo do que os cientistas da computação chamam tipos de dados atômicos. Para resolver esse desafio você precisa descobrir como colocar coisas em caixas (ou seja, como inicializar elementos de um vetor).

Desafio n°2 - Márcio precisa de um 4. Este desafio introduz Bambam, o ratinho, que faz cálculos aritméticos e outras operações básicas. Através da solução desse desafio você descobrirá como expressar a adição de dois números.

Desafio n°3 - Márcio precisa de uma caixa com um 8, um 16 e um 32 dentro. Este introduz um modo de combinar caixas para fazer caixas maiores. Ele também ilustra como expressar a adição de um número que está em uma caixa. Na terminologia da ciência da computação você aprende comoconcatenar vetores e como operar um elemento de uma estrutura de dados.

Desafio  n°4 - Márcio precisa de um número maior que 1.000. Este desafio introduz a Varinha Mágica do ToonTalk, que é usada para copiar os objetos do ToonTalk. Como todas as ferramentas do ToonTalk, a varinha pode ser utilizada como parte de um programa e como uma ferramenta no interior do ambiente de programação. Este desafio é matematicamente interessante já que se baseia em repetidas multiplicações para crescer de 1 até 1.024 em apenas 10 passos. Ele é, intencionalmente, um pouco tedioso, para proporcionar a motivação para automatizar tarefas como essa última.

Desafio n°5 - Márcio precisa de um zero. Este desafio introduz Asper, o aspirador. Asper é uma ferramenta utilizada para remover coisas. O zero está enterrado sob coisas que apenas Asper pode remover.

Desafio n°6 - Márcio precisa de - 1. Para resolver esse desafio o jogador precisa adivinhar (ou receber pistas de Márcio) que o botão no nariz de Asper pode ser alterado pressionando-o. Esta utilização dos botões para alterar o comportamento das ferramentas é utilizada por toda parte no ToonTalk. Um jogador observador pode perceber que esta utilização de Asper para sugar coisas e depois cuspi-las corresponde bastante a recortar e colar em muitas interfaces baseadas em janelas (windows).

Desafio n°7 - Márcio precisa de um grupo de números em branco. Este desafio introduz grupos de números em branco que são usados em desafios posteriores. Um grupo de números em branco é uma forma de expressar o tipo de uma estrutura de dados. Neste caso, ele indica alguns dados cujo tipo é o número.

Desafio n°8 - Márcio precisa de uma caixa com dois zeros. Treinando o robô neste desafio, você estará construindo seu primeiro programa. O programa construído é equivalente a um programa de texto como este:

while (sizeOf(box) = 1 and box[0] = 1) do

box := concat(box, copy(box));< /p>< /p>< /p>< /p>< /p>< /p>

endwhile;

O motivo que permite que mesmo crianças pequenas possam construir esse programa sem ajuda é que o desafio restringe o universo de forma que a busca que o jogador precisa fazer para encontrar a solução não é muito grande. Aqui a memória do robô é limitada para lembrar apenas dois passos, e o robô já tem a Varinha Mágica.

Desafio n°9 - Márcio precisa de um número maior que um bilhão. A solução deste desafio se baseia na experiência da solução dos problemas 4, 7 e 8. Para resolver este desafio você precisa treinar um robô para fazer o que você fez manualmente no desafio n°4. Durante o desafio n°4 você teve de repetir uma seqüência de ações dez vezes. Aqui você simplesmente treina o robô para realizar uma seqüência e ele irá fazê-la pelas 30 vezes necessárias. De forma a conseguir que o robô trabalhe repetidamente, você precisa aprender a como tornar o robô menos preocupado acerca do tipo de caixa em que irá trabalhar. No jargão da ciência da computação isto se chama relaxamento do predicado da condicional. O programa de texto equivalente ao robô treinado nesse desafio é:

repeat 30

if (sizeOf(box) = 1 and isNumber(box[0])) then< /p >< /p >< /p >< /p >< /p >< /p >

Box[0] := box[0] + copy(box[0]);< /p>< /p>< /p>< /p>< /p>< /p>

endif;

Desafio n°10 - Márcio precisa de uma caixa dentro da caixa. Para resolver esse desafio, você precisa colocar uma caixa dentro de uma caixa dentro de uma caixa. Isto é o que os cientistas da computação chamam de uma estrutura de dados recursiva, desde que os elementos da estrutura podem ser do mesmo tipo que toda a estrutura. Se você colocar uma das caixas no buraco errado, então Márcio o informará que os elementos precisam estar no lugar correto. Isto porque a caixa é uma coleção indexada ordenada.

Desafio n°11 - Márcio precisa de uma caixa com 3 zeros. Como o desafio n°2, você precisa conectar (concatenar) duas caixas (vetores). Aqui você descobrirá que as caixas não podem ser conectadas quando elas são parte de outra caixa. Você descobre que as caixas podem ser removidas, conectadas, e então colocadas de volta. Uma solução corresponde ao fragmento de código:

temp1 := box[0];

temp2 := box[1];

temp1 := concat(temp1,temp2);

box[1] := temp1;

Desafio n°12 - Márcio precisa de uma caixa com 6 zeros. Este desafio se assemelha ao n°11. A operação de conectar as caixas é repetida três vezes. Isto serve para prepará-lo para o próximo desafio no qual um robô precisa ser treinado para repetidamente conectar caixas.

Desafio n°13 - Márcio precisa de uma caixa com 10 zeros. Na solução deste desafio, você treinará um robô para aumentar repetidamente uma caixa. Isto introduz uma técnica de programação habitualmente usada quando se incrementa a criação de uma estrutura de dados. O robô treinado corresponde ao programa de texto:

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;< /p>< /p>< /p>< /p>< /p>< /p>

endif;

O robô neste desafio pode se lembrar de até 20 passos, mas o desafio pode ser resolvido com apenas quatro.

Desafio n°14 - Márcio precisa de uma caixa contendo 1, 2, 4, 8, 16 e 32. A resolução desse desafio envolve o aumento repetido de uma caixa com números que são o dobro do número anterior.

Desafio n°15 - Márcio precisa de uma caixa contendo 1, 2, 4, 8, 16 e assim por diante até atingir 1.073.741.824. A solução desse problema se baseia nos desafios n°9, n°13 e n°14. Ele é um bom exemplo de como alguém freqüentemente precisa combinar diferentes técnicas de programação para atingir um objetivo. Aqui está o equivalente programa de texto:

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;< /p>< /p>< /p>< /p>< /p>< /p>

endif;

Desafio n°16 - Márcio precisa do ano em que você nasceu. As potências de 2 são o conjunto básico dos inteiros positivos. Em outras palavras, qualquer número inteiro pode ser expresso como a soma de números que são potência de 2 e nenhum número na soma ocorre mais de uma vez. Daí a ausência da Varinha Mágica neste desafio.

Desafio n°17 - Márcio precisa do ano em que você nasceu em binário. Você precisa fazer exatamente a mesma coisa que ele ou ela fizeram quando resolveram o desafio n°17. Este pode ser na verdade um desafio muito mais fácil que o n°16. O truque é perceber que sempre que precisar de um 1, encontre o número com o 1 naquela posição.

Desafios n°18, n°19 e n°20 - Intencionalmente deixados em branco.


Nível 2 - Letras e Palavras

Desafio n°21 - Márcio precisa de uma caixa com A, B e C. Este desafio introduz grupos de texto (um novo tipo de dados). Ao solucioná-lo, você irá descobrir o que faz a operação de adição quando aplicada às letras

Desafio n°22 - Márcio precisa de uma caixa com A, B, C, D, E e F. este desafio é similar ao desafio n°14, mas a mesma técnica é aplicada agora às letras, ao invés de números.

Desafio n°23 - Márcio precisa de uma caixa com A, B, C, e assim por diante até Z. Este desafio se baseia nos desafios n°15 e n°22. Como no n°15, você precisa treinar um robô para dar um passo, de tal forma que quando ele o tiver feito estará pronto para dar o próximo passo. O programa de texto 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;< /p>< /p>< /p>< /p>< /p>< /p>

endif;

Desafio n°24 - Márcio precisa de uma caixa com a, b, c, e assim por diante até z. Este desafio é trivial porque o robô que foi treinado no desafio anterior pode criar a caixa que aqui é necessária. Tudo o que o robô necessita é receber uma caixa diferente para começar. Um robô é o que é chamado pelos cientistas da computação de uma procedura . E esta procedura tem um argumento - a caixa que é dada para o robô. Um aspecto muito importante de uma procedura é que ela pode ser reutilizada pela transmissão de diferentes argumentos.

Desafio n°25 - Márcio precisa de uma caixa com um alfabeto que é pequeno o bastante para que seja visto todo de uma só vez. Este desafio introduz uma nova ferramenta – Soprana, a bomba de bicicleta. Soprana muda o tamanho das coisas. Isto é útil em "Free Play" ( Jogo Livre) para gerenciar o estado real da tela. É também um meio simples e direto de alterar o tamanho das ilustrações.

Desafio n°26 - Márcio precisa de uma caixa com um ponto final, ponto de interrogação e vírgula. Este desafio ilustra que os grupos de texto não são limitados às letras do alfabeto, mas também incluem a pontuação. As letras, pontuação e símbolos especiais ( como o $) são chamados de caracteres na maioria das linguagens de programação. Este desafio também ilustra dramaticamente que o tamanho dos objetos no ToonTalk não influencia em como eles se comportam ( sua semântica).

Desafio n°27 - Márcio precisa que a caixa com a pontuação seja grande o bastante para que veja seu conteúdo. Este desafio introduz uma tecla de atalho – neste caso, um meio de criar um som para chamar Pumpy para saltar em sua mão. As teclas de atalho são comuns em muitas espécies diferentes de interfaces do usuário.

Desafio n°28 - Márcio precisa da palavra "Start" (Início). Este desafio apresenta o que os cientistas da computação denominam strings – ou seja, seqüências de caracteres. Para resolver esse desafio você precisa descobrir que as letras e "strings" podem ser concatenados para formar "strings" (seqüências) maiores.

Desafio n°29 e n°30 - Intencionalmente deixados em branco.


Nível 3 - Matemática do Tempo

Desafio n°31 - Márcio precisa de uma caixa com o seu aniversário. Para resolver este desafio, você precisa descobrir que o teclado pode ser utilizado para alterar o valor de "strings" e números. Isto é uma espécie de manipulação direta de dados.

Desafio n°32 - Márcio quer saber o número de minutos de um dia. Este desafio ilustra que a adição repetida é multiplicação. O programa de texto equivalente é :

repeat 24

if (sizeOf(box) = 2 and isNumber(box[0]) and isNumber(box[1])) then

box[1] := box[1] + copy(box[0]);< /p>< /p>< /p>< /p>< /p>< /p>

endif;

Desafio n°33 - Márcio quer saber o número de segundos em uma hora. O robô do desafio n°32 é reutilizado aqui, pois a única diferença é quantas vezes as instruções devem ser repetidas.

Desafio n°34 - Márcio precisa de uma caixa que exiba um conjunto de escalas que mostre que dois números são o mesmo. Este desafio introduz escalas que são um meio de expressar comparações numéricas. Ele também introduz o uso de números negativos para a subtração.

Desafio n°35 - Márcio precisa de outra caixa com uma escala mostrando que dois números são o mesmo. Este desafio difere do anterior, porque agora um robô está fazendo o trabalho. O que é importante notar aqui é que o robô pára quando a escala não é mais graduada à esquerda. Este exemplo mostra como utilizar um predicado de comparação em uma condicional. Desde que o robô possui uma varinha com mágica ilimitada, ele pára apenas quando a caixa não mais se identifica com a caixa em seu balão de pensamento. Isso é o que os cientistas da computação chamam de um "while loop". O equivalente de texto é:

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]);< /p>< /p>< /p>< /p>< /p>< /p>

endwhile;

The expression "box[1] = '>' " is unusual. In this case it is equivalent to the more common "box[0] > box[2]", since the scale is always displaying the relationship between its neighboring data.

Desafio n°36 - Márcio precisa de uma caixa com 24 zeros. Este desafio combina o n°13 e o n°35. Ele mostra como utilizar um "while loop" com uma expressão em linguagem de computação. Esta é uma técnica importante para repetir alguma coisa um número de vezes quando você não sabe quantas vezes será necessário repeti-la até que o programa rode.

Os cientistas da computação analisam programas para encontrar constantes. Existem relações que se mantêm depois de cada ciclo. Aqui é uma constante que o primeiro buraco da caixa é um número que é o tamanho (isto é, o número de buracos) da caixa no sexto buraco. O equivalente de texto do robô é :

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]);< /p>< /p>< /p>< /p>< /p>< /p>

endwhile;

ou equivalentemente:

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;< /p>< /p>< /p>< /p>< /p>< /p>

endfor;

endif;

Desafio n°37 - Márcio quer saber quantas horas existem em um ano. Este é similar ao desafio n°32, exceto que agora você está treinando um robô geralmente mais útil. Isto é porque o robô computa o produto dos dois primeiros números e o mantém no sexto buraco. A constante neste programa é que o número no sexto buraco é o produto dos números no primeiro e quarto buracos. O robô pára quando os números no segundo e no quarto buraco são os mesmos. O equivalente de texto disso é:

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]);< /p>< /p>< /p>< /p>< /p>< /p>

endwhile;

Desafio n°38 - Márcio quer saber quantos segundos há em um dia. Para resolver esse desafio, você utiliza o robô treinado no desafio anterior para multiplicar 60 vezes 24, resultando em 1.440. O jogador então utiliza o robô novamente para multiplicar 60 vezes 1.440. Isto pode ser feito colocando o 60 tanto no primeiro como no segundo buraco e o 1.440 no outro. O robô irá computar o produto corretamente em qualquer um dos casos, mas ele será muito mais rápido se o 1.440 estiver no primeiro buraco. Isto acontece porque o robô multiplica através da adição repetida do primeiro número. A quantidade de trabalho que o robô precisa fazer é proporcional ao número no segundo buraco. Em terminologia da ciência da computação, nós dizemos que a complexidade do programa é linear com o segundo argumento.

Desafio n°39 - Márcio quer saber quantos segundos há em um ano. Como no desafio anterior, este utiliza repetidamente o robô treinado no desafio n°37 para computar 365x24x60x60.

Desafio n°40 - Intencionalmente deixado em branco.


Nível 4 - Computando o Tempo

Desafio n°41 - Márcio precisa dos dias da semana. Este desafio introduz os Pombos e seus ninhos. Para um cientista da computação um pombo e seu ninho é um canal de comunicação. Um pombo é o direito ou capacidade para enviar mensagens em um canal e seu ninho o direito de receber mensagens naquele canal. Este exemplo também ilustra que as mensagens no ToonTalk são enfileiradas de um modo primeira a chegar, primeira a sair.

Desafio n°42 - Márcio precisa de uma caixa com um ninho com inteiros começando de 2. O robô treinado para resolver este desafio é o que os cientistas da computação chamam um gerador. Aqui o robô gera um fluxo de inteiros. Este gerador é um gerador infinito, desde que ele não pára. O equivalente de texto desse robô é :

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]);< /p>< /p>< /p>< /p>< /p>< /p>

endwhile;

Desafio n°43 - Márcio precisa da soma dos números no ninho. Aqui você treina um robô para ser um consumidor. Muitos programas orientados para fluxos envolvem consumidores e geradores.

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;

Desafio n°44 - Márcio precisa de uma caixa com três números que não se alteram. Aqui, você é apresentado aos sensores. Um sensor é atualizado a cada ciclo, e portanto exibe o valor mais recente daquilo que está aferindo. O que um sensor está aferindo pretende-se que seja um mistério até o desafio n°48. Este desafio ensina a técnica de programação do ToonTalk de "congelar um sensor", descendo-o a zero.

Desafio n°45 - Maty precisa de uma caixa com um ninho cheio de números que não se alteram. Este desafio combina os desafios n°42 e n°44 para produzir um fluxo de valores de sensor. O equivalente de texto é:

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;

Desafio n°46 - Márcio quer saber a soma dos números no ninho. O robô treinado no desafio n°43 trabalhará bem com este fluxo de números.

Desafio n°47 - Márcio quer o número que resulta da espera por 8 segundos. Here you run the robot from puzzle #43 and the robot from puzzle #45 in parallel, in other words, at the same time.

Para resolver este desafio, você precisa gerar um novo processo carregando o caminhão com um robô e uma caixa. Este é o método favorito de rodar programas em paralelo – fazendo-o em uma única casa é mais difícil de controlar e se confunde rapidamente. Aqui você aprende que o sensor mede o número de milissegundos desde o último ciclo do ToonTalk. Portanto a soma dos números mede quanto tempo passou. Se você deixou por exatamente 8 segundos no desafio n°47, o número seria 8.000. Aqui, se você esperou por exatamente 14 segundos o número seria 14.000. A razão pela qual você deve estar fora do ângulo de visão é que os pombos baixam vagarosamente para seu benefício, portanto você pode observá-los. Os pombos lentos interferem aqui com a medição do tempo precisamente.

Desafio n°49 - Márcio quer que você se livre da outra casa. Para resolver este desafio você precisa descobrir como terminar um processo.

Desafio n°50 - Márcio quer o resultado depois de esperar 10 segundos. Desta vez você precisa treinar um único robô para fazer o que os robôs nos desafios n°47 e n°48 fizeram.Os programadores freqüentemente fazem um programa especial que faz o mesmo que uma combinação de dois programas gerais. Eles o fazem pois o computadores necessitam dar menos passos para rodar o programa especial. Aqui os processos gerador e consumidor podem ser combinados em um processo mais rápido e muito mais simples. O equivalente de texto é:

while (sizeOf(box) = 2 and isNumber(box[1]) and isNumber(box[2])) do

box[1] := box[1] + copy(box[0]);< /p>< /p>< /p>< /p>< /p>< /p>

endwhile;

Desafio n°51 - Márcio precisa da caixa depois de três segundos que o cronômetro foi desligado. Este desafio combina os desafios n°35 e n°50 para medir o tempo até que alguma comparação não seja mais verdadeira. Aqui está a forma de texto:

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();< /p>< /p>< /p>< /p>< /p>< /p>

endwhile;

Desafio n°52 - Márcio precisa de - 10. Este desafio ilustra o uso repetido de -1 para o decremento de um contador. É igualmente válido ver esta atividade como a adição de um número negativo ou a subtração de um positivo. O equivalente de texto é:

while (sizeOf(box) = 3 and isNumber(box[0]) and isNumber(box[1])) do

box[0] := box[0] + copy(box[1]);< /p>< /p>< /p>< /p>< /p>< /p>

endwhile;

Desafio n°53 - Márcio quer a palavra secreta. Este desafio introduz equipes de robôs. Quando uma caixa é dada a um robô, e essa caixa não combina com a caixa no balão de pensamento do robô, então o robô deixará a caixa para o próximo robô da equipe, se houver um. Em procedimentos de linguagens de programação, isso corresponde ao que os cientistas da computação chamam de instruções se- então. Em linguagens de programação orientadas para objetos, uma equipe corresponde ao comportamento de um objeto, onde cada robô corresponde a um método. Na lógica de linguagens de programação, uma equipe corresponde a um predicado, e cada robô a uma condicional. A equipe construída neste desafio é equivalente ao seguinte programa de texto de 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;

Desafio n°54 - Márcio quer um despertador. Aqui o robô treinado para o desafio n°51 é uitlizado junto àquele treinado aqui para implementar uma mensagem enviada com o atraso de um número de segundos. O programa de texto 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 você não zerar a escala no balão de pensamento do novo robô, então nós não funcionaremos no caso raro onde box [1] = box[3]. A probabilidade de que isto ocorra é de 1 fora da duração média do ciclo cuja ordem varia entre 10 e 100 dependendo da velocidade do computador envolvido.

Desafio n°55, n°56, n°57, n°58, n°59, e n°60. Intencionalmente deixados em branco.


Nível 5 - Construindo um Relógio

Desafio n°61 - Márcio quer um número que se mantém crescente. A solução deste desafio é a mesma do desafio n°50. Aqui, entretanto, o número que se altera tem uma propriedade especial, de tal forma que as mudanças nele se exibem também em outro número. Isto é o que os cientistas da computação chamam de estado comum. Sabe-se que o estado comum causa problemas em programas concorrentes. No ToonTalk, entretanto, os controles remotos funcionam apenas no interior de uma casa isolada, sendo pois esses problemas evitados.

Desafio n°62 - Márcio quer que o número aumente em 1.000 a cada segundo. A solução deste desafio exige que se coloque o robô e a caixa atrás do número. Muitos sistemas de desenvolvimento de softwares proporcionam objetos na interface com o usuário que podem ter programas associados com eles. no ToonTalk, você pode colocar robôs atrás das ilustrações para dar a elas qualquer comportamento que você programe. A razão pela qual a solução deste desafio mantém corretamente o tempo, enquanto a solução do desafio anterior não o fazia, é que no desafio prévio o robô ia devagar, de forma que você podia observá-lo.

Desafio n°63 - Márcio quer um número que aumente em 1 a cada segundo. A solução para este desafio se baseia nas técnicas de programação utilizadas no nível n°4. Uma das constantes deste robô é que o número do terceiro buraco deve ser 1 menos mil vezes o número do quarto buraco. Outra constante é que o quarto número será 1/1000 do valor do primeiro número. A forma de texto desse robô é:

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;

Desafio n°64 - Márcio quer um número que aumente em 1 a cada minuto. Este desafio reutiliza o robô do desafio anterior. Os números não se alteraram de tal forma que o robô assegura que o quarto número é 1/60 do primeiro número.

Desafio n°65 - Márcio precisa de uma caixa com contadores de horas, minutos e segundos. Construir o contador de horas é o mesmo que construir o contador de minutos no desafio anterior.

Desafio n°66 - Márcio quer que o contador de segundos volte para 0 quando alcançar 60. Depois que o robô calcular o primeiro número haverá o resto depois de dividir o que havia por 60. A computação do resto da divisão é implementada pela subtração repetida. É digno de nota que este processo está rodando em paralelo com o processo construído anteriormente, que faz com que o número seja 1/1000 do contador de milissegundos. O robô é 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]);< /p>< /p>< /p>< /p>< /p>< /p>

endwhile;

Desafio n°67 - Márcio quer que o contador de minutos volte a zero quando atingir 60. A solução para este problema requer que se perceba que o mesmo robô do desafio anterior é necessário aqui e que você pode utilizar a Varinha Mágica para copiar o robô exigido.

Desafio n°68 - Márcio quer que o contador de horas volte a zero quando atingir 24. A solução para este desafio é a mesma do anterior, e adicionalmente você deve alterar os números de forma que o robô se comporte corretamente. Este problema testa sua compreensão dos dois desafios anteriores.

Desafio n°69 - Márcio quer que o relógio digital mostre a hora certa. Para resolver este desafio, você simplesmente inicializa os valores dos contadores para a hora atual.

Desafio n°70 - Márcio quer um relógio digital de bela aparência. Muitos softwares modernos não apenas precisam computar corretamente, mas também devem exibir informações para os usuários de uma forma atraente e efetiva. Aqui, você precisa fazer que o relógio pareça mais atraente.

Desafio n°71 - Márcio quer uma caixa mostrando a hora de seu nascimento. Isto é necessário para o próximo desafio.

Desafio n°72 - Márcio deseja saber quantos segundos até que você tenha um número redondo de milhões de segundos de idade. Aqui, você deve baixar o número mostrando sua idade em segundos até zero para congelar o número. Se você tentar subtrair com o contador, então o número continuará a crescer, mesmo quando for negativo. Negligenciar esse procedimento afetará a resposta em apenas poucos segundos.

Desafio n°73 - Márcio quer saber quantos minutos até que você tenha um número redondo de milhões de segundos de idade. Este desafio ilustra como o ToonTalk, como a maioria das linguagens de programação, pode realizar a divisão de forma primitiva. Uma vez que o computador principal estava quebrado antes você não podia multiplicar e dividir números e tinha de programar essas operações utilizando adição e subtração.

Desafio n°74 - Márcio quer saber quantos dias até que você tenha um número redondo de milhões de segundos de idade. Aqui, você precisa classificar a operação de divisão, em vez de utilizar uma pré-definida.

Se você chegou ao final do jogo de desafio, você deve ter aprendido o suficiente para construir uma ampla variedade de programas em "Free Play". Você pode aprender mais observando alguns dos filmes exemplonstrativos ("Vide exemplos"). Por favor, compartilhe o que você construiu com os outros.