Simulação: a tartaruga e a lebre. Nesse problema, você recriará um dos momentos realmente importantes da história, a saber, a corrida clássica entre a tartaruga e a lebre. Você usará a geração de números aleatórios para desenvolver uma simulação desse evento memorável. Nossos competidores começam a corrida no ‘quadrado 1’ de 70 quadrados. Cada quadrado representa uma posição possível ao longo do curso a ser percorrido. A linha de chegada fica no quadrado 70. O primeiro concorrente a alcançar ou passar do quadrado 70 é recompensado com um balde de cenouras e alface. O trajeto é percorrido por uma montanha escorregadia, de modo que, ocasionalmente, os concorrentes perdem o contato com o chão. Há um relógio que apresenta o tempo em os segundos. A cada segundo indicado pelo relógio, seu programa deverá
ajustar a posição dos animais de acordo com as regras da Figura 7.31. Use variáveis para acompanhar as posições dos animais (ou seja, os números de posição vão de 1 a 70). O jogo
deve começar com os dois animais na posição 1 (ou seja, ‘na linha de partida’). Se um animal escorregar antes do quadrado 1, mova-o de volta para o quadrado 1. Gere as porcentagens na tabela anterior produzindo um inteiro aleatório, i, na faixa de 1 ≤ i ≤ 10. No caso da tartaruga, execute um ‘caminha rapidamente’ quando 1 ≤ i ≤ 5, um ‘escorrega’ quando 6 ≤ i ≤ 7, ou um ‘caminha lentamente’ quando 8 ≤ i ≤ 10. Use uma técnica semelhante para mover a lebre.
Comece a corrida imprimindo BANG !!!!!
E LÁ VÃO ELES !!!!! Depois, para cada segundo marcado pelo relógio (ou seja, cada repetição de um loop), imprima uma linha de 70 posições mostrando a letra T na posição da tartaruga e a letra L na posição da lebre. Ocasionalmente, os competidores acabarão no mesmo quadrado. Nesse caso, a tartaruga morderá a lebre e seu programa deverá imprimir AI!!! a partir dessa posição. Todas as posições de impressão diferentes de T, de L, ou do AI!!! (no caso de um empate) devem estar em branco. Depois que cada linha for impressa, verifique se um dos animais alcançou ou passou o quadrado 70. Nesse caso, imprima o vencedor e termine a simulação. Se a tartaruga vencer, imprima TARTARUGA VENCE!!! É ISSO AÍ!!! Se a lebre vencer, imprima Lembre vence. Marmelada. Se os dois animais vencerem na mesma batida do relógio, você pode favorecer a tartaruga (a ‘pobre coitada’) ou pode querer imprimir É um empate.
Se nenhum animal vencer, realize o loop novamente para simular a próxima batida do relógio. Quando estiver pronto para executar seu programa, monte um grupo de fãs para assistir a corrida. Você ficará surpreso ao ver como eles se mostrarão interessados!
Passo 1
Beleza pessoal, espero que todos estejam bem e prontos para mais uma resolução de C. Iremos fazer uma resolução bem grande, então é importante estar com o seu compilador aberto para acompanhar corretamente e não se perder. Vamos nessa!!!

Agora que temos uma ideia de como nosso programa deve funcionar em geral, podemos começar a nos aprofundar na implementação. Antes de começarmos a escrever nossa função principal, vamos incluir alguns arquivos de cabeçalho que vamos precisar mais tarde (time.h), e vamos definir uma constante para a posição final.
Há algumas coisas que devemos acompanhar (o que significa, algumas variáveis que precisaremos para isso):
posição da lebre
posição da tartaruga
uma bandeira que é falsa, desde que não tenhamos um vencedor
Então, vamos iniciar nossa função principal declarando essas variáveis, iniciando a corrida e exibindo o estado inicial. Além disso, precisaremos iniciar o gerador de números aleatórios, pois precisaremos dele mais tarde:

Já sabemos que, para exibir o estado atual, precisaremos das posições atuais dos concorrentes. Assim, podemos escrever o protótipo para esta função:
void displayCurrentState(int harePosition, int tortoisePosition);
Agora, podemos continuar com nossa função principal e escrever as funções mais tarde, ou podemos escrever essa função imediatamente. Isso é totalmente até sua preferência. Vamos escrever esta função primeiro, pois já temos tudo o que precisamos para fazê-lo.
Passo 2
Devemos ter uma ideia clara de como será nossa corrida antes de começarmos com a implementação. Digamos que queremos obter algo assim para algum estado:
-----------------------------
H
T
-----------------------------
Onde H representa a posição atual da lebre e T representa a posição atual da tartaruga. Devemos ter 70 traços (um para cada posição até a linha de chegada). Além disso, devemos saber que sempre que a lebre e a tartaruga chegarem à mesma posição, devemos exibir OUCH!!!. Agora que sabemos o que queremos obter, podemos escrever a função:

Agora, podemos retornar à nossa função principal. Podemos iniciar nosso loop while e executá-lo enquanto o vencedor do sinalizador estiver definido como zero. Dentro do loop while, movemos a lebre e a tartaruga.

Nossas funções de movimento gerarão primeiro um número aleatório entre 1 e 10 e, em seguida, com base nesse número, retornarão um número de quadrados que o animal passa nesse movimento. Assim, os protótipos podem ficar assim:

Passo 3
A função para o movimento da tartaruga será semelhante:

Infelizmente, temos muitos números mágicos nessas funções, então definiremos algumas constantes no início deste arquivo para que essas funções pareçam um pouco mais transparentes
#define SLEEP 0
#define BIG_HOP 9
#define BIG_SLIP -12
#define SMALL_HOP 1
#define SMALL_SLIP -2
#define FAST_PLOD 3
#define SLIP -6
#define SLOW_PLOD 1

Mais uma vez, voltamos à nossa função principal. Saímos na parte em que mudamos a posição de nossos competidores. Agora, lembre-se que suas posições nunca devem ser menores que 0, vamos garantir que seja o caso:

A função sleep(1) pausa o programa por 1 segundo, para que possamos observar como a corrida progride. Há apenas mais uma função para escrever agora:
int checkWinner(int harePosition, int tortoisePosition);
Vamos escrever o checkWinner:

Primeiro, verificamos se eles chegaram à linha de chegada ao mesmo tempo. Se for o caso, é um empate, e retornamos o valor diferente de 0, o que indica que a corrida acabou. Se não houver empate, verificamos separadamente para a lebre e a tartaruga se cruzaram a linha de chegada. Se nenhum deles cruzou a linha de chegada ainda, retornamos 0, o que significa que o loop while será executado novamente.
Resposta
Ver o desenvolvimento!!!