Módulo Random

Fala comigo, varão de guerra! Aqui a gente tem que simular um jogo de pedra, papel, tesoura. Por algum motivo a gente vai ter que usar números em vez de strings pra checar qual a jogada do usuário. Por que o professor fez isso?! Não sei.

Mas enfim… Apesar de não estar escrito no enunciado, eu gostaria de começar escrevendo pro usuário as instruções do jogo.

Pronto! Antes mesmo de o jogo começar, vai ser exibido na tela essa instrução. Aí, a gente pode perguntar qual a jogada do usuário! Pra isso, vamos usar a função input() e converter a entrada pra inteiro, assim:

E pronto! Agora a gente tem, na variável “usuario”, a jogada do cara. Precisamos criar uma jogada aleatória pra máquina, e é isso que vamos fazer agora.

Olha, a jogada da máquina precisa ser aleatória. Mas, pra gente acessar as funções aleatórias, precisamos antes importar esse módulo lá no início do programa, lembra?

E agora a gente pode usar a função randint pra definir a jogada da máquina de forma aleatória.

Show! Já temos a jogada da máquina. Seria justo exibir pro usuário qual foi a jogada da máquina, então vamos usar um print() pra isso.

E pronto! Só falta a gente descobrir quem venceu, né?!

Olha, pra gente descobrir quem venceu, a gente vai precisar usar alguns if. Primeiro, vamos checar o empate, que é o caso mais fácil de identificar.

E agora a gente precisaria pensar nas combinações necessárias pra vencer o jogo, mas a gente não vai. Porque, se não empatou, a gente só tem duas opções: ou perder ou vencer. Então, a gente pode fazer uma lista mapeando qual jogada vence de qual. Pra isso, vou criar uma lista chamada jogo:

Repara que eu criei uma lista com os valores 2,0,1, nessa ordem. Cara, deixa eu te mostrar como tá a relação entre os índices da lista e os valores que a gente colocou ali.

Reparou que, dessa forma, o número que tá no índice é justamente a jogada que vence o valor? 0 (pedra) vence 2 (tesoura), 1 (papel) vence 0 (pedra) e 2 (tesoura) vence 1 (papel). Assim, a gente consegue com vem mais facilidade verificar quem venceu o jogo.

A lista jogo retorna quem perde pra aquela jogada. Então, jogo[usuario] retorna quem perde pro usuário. Se jogo[usuario] for igual a “maquina”, então a máquina perdeu. Se não, a máquina venceu, sacou?! Malandramente, evitamos várias linhas de código!

E por enquanto é isso, maninho! Te vejo no próximo (NÃO PULA O PRÓXIMO EXERCÍCIO). Valeuuu!

Coe, shinobi! Bora fazer um joguinho onde é o usuário que precisa acertar o número gerado aleatoriamente pelo programa. E o enunciado exige que as repetições sejam feitas usando recursão, o que nos obriga a programar o jogo dentro de uma função.

Então vamos começar definindo a função do nosso jogo que eu, criativamente, vou chamar de “jogo”.

Nossa função recebe quantas tentativas o usuário ainda tem e, se for maior do que 0, precisamos perguntar um número!

E, com o número em mãos, precisamos exibir 1, -1 ou 0, dependendo das condições impostas no enunciado.

Cara, o enunciado tá falando pra, em caso de acerto, exibir 0. Caso o chute seja menor, 1 e -1 caso o chute seja maior. Pra implementar essa lógica, vamos usar algumas estruturas condicionais.

E pronto! O programa já vai dar a resposta da primeira jogada. Mas esse jogo tem que se repetir 20 vezes, e com recursão. Por isso, depois do else a gente pode adicionar uma chamada recursiva, descontando uma tentativa...

Repara que a resposta continua sendo a mesma do início do jogo, ok?! Por isso passamos ela adiante sem alterações. Mas o enunciado também diz que, quando acerta, precisamos exibir o número de tentativas usadas. A gente pode fazer isso subtraindo o número total de tentativas pelo número que ainda restam. Tipo assim:

E pronto! Só falta a gente chamar essa função no nosso programa, né?!

Olha, pra gente começar o jogo que tá dentro da função, precisamos chamar a função no nosso programa. Porém, a resposta da partida tem que ser gerada de forma aleatória entre 0 e 1024, assim como dito no enunciado. Pra trabalhar com funções aleatórias, a gente tem que importar o módulo random no início do nosso arquivo, tá?

E aí, com o módulo random importado e a função do jogo devidamente declarada, a gente pode chamar com a resposta aleatória e com o número máximo de tentativas, que é 20:

E pronto, agora falta só mais um detalhe… Quando o usuário acerta, a gente não precisa mais continuar o jogo, temos que parar o loop. Mas acontece que não tem um “break” em repetições com recursão.

Mas dá uma segurada, porque a recursão tem o caso base, e ela só continua a repetição enquanto o caso base não é atingido. Pra gente parar imediatamente uma recursão, a gente só precisa forçar um caso base! Se liga na treta:

Olha! Depois de acertar, definimos “tentativa” pra 1. Aí, na chamada recursiva vai ser passada tentativa-1=0. Com isso, o loop vai terminar, porque na próxima repetição a tentativa não vai ser maior que 0.

E assim a gente finalizou a questão! Valeuuu!

E aí, vingador!!! Bora resolver esse exercício na força do ódio?!

A ideia é perguntar pro usuário nomes de times pro campeonato até que seja dita a palavra “fim”. Então a gente não sabe quantos times vão ser… Nessa situação, é uma boa ideia a gente usar uma lista pra armazenar o nomes dos times e uma estrutura de repetição while. Tipo assim:

E pronto! Assim, o programa vai perguntar e adicionar na lista os nomes dos times… Agora, fora do laço de repetição, precisamos checar se um número par de times foi adicionado. E pra isso a gente pode verificar se o resto da divisão por dois da quantidade de times na lista é igual a zero. Se liga:

E já vamos preencher com uma mensagem caso seja ímpar…

E pronto! Só falta a gente ordenar o campeonato agora...

Mas como a gente poderia fazer pra ordenar aleatoriamente o campeonato?!

Primeiramente, vamos precisar importar o módulo random pra ter acesso a algumas funções de aleatoriedade. Segundamente, a gente até poderia ir pegando itens aleatórios da lista,m as tem uma forma mais fácil! Vamos usar o random.shuffle().

Essa função recebe e EDITA uma lista, ordenando-a de forma aleatória. Aí, a gente pode dizer que os times jogaram com o time do lado, já que estão embaralhados… hahaha saca só

Enquanto tiver times na lista, a gente exibe uma partida entre os dois primeiros, afinal, eles foram escolhidos aleatoriamente pra ser os primeiros… E depois, a gente atualiza a lista pra deletar esses dois primeiros que usamos, sacou?!

E pronto! Finalizamos o exercício. Te espero no próximo, tá? Valeuuu

Fala comigo, meu compatriota! Nessa aqui a gente junta uns conhecimentos de laços de repetição com o módulo random e tira de letra! Vem comigo que te mostro como resolver essa parada!

A gente precisa perguntar pro usuário uma palavra e tentar fazer nosso programa adivinhar ela. Então bora perguntar com a função input().

Começamos bem! hehehe mas como a gente sabe que vai precisar usar o módulo random em algum lugar, bora adiantando as coisas já importando o módulo no início do código.

Show! E, pra armazenar os acertos da máquina, bora fazer uma lista com “_” do mesmo tamanho da palavra:

Pronto! Agora que já temos tudo certo, bora começar os trabalhos de adivinhação.

Primeiramente, o enunciado diz que o computador pode tentar até o dobro de letras do tamanho da palavra. Então, vamos fazer um laço de repetição que se repita 2 * len(palavra) vezes! Se liga nesse for:

Irado! Agora a gente quer chutar uma letra do alfabeto… Vou usar a função choice(), mas também poderia ter escolhido usar qualquer outra que tenha o mesmo resultado, ok?!

Criei uma variável pra armazenar todo o alfabeto e depois, dentro do loop, disse que o chute da máquina tem que ser um dos itens do alfabeto (ou seja, alguma letra). Agora, a gente tem que verificar se essa letra existe na palavra e, se existir, a gente substitui na lista “tentativa”.

Viu? Se a letra existir, a gente substitui na lista na mesma posição que a letra se encontra na string “palavra”, e depois tira essa letra da string. A gente repete isso até não ter mais aquela letra na string! Assim, o programa consegue abranger todas as letras repetidas, sacou? Agora, a gente pode exibir a tentativa no formato que foi especificado no enunciado.

Pronto! Com o print dessa forma, vai ser exibida a tentativa exatamente como no exemplo do professor… Só falta a gente dizer, no fim, se a máquina venceu ou não.

Pra verificar se a máquina acertou tudo, a gente só precisa verificar, depois do loop, se sobrou algum “_” sem ser preenchido na lista “tentantiva”. Se sobrou, então a máquina perdeu, caso contrário, venceu!

E assim, a gente finaliza o exercício! hehehe até o próximo, doido! Nós se vê por aí!

E ai, meu padrin! Bora resolver essa questão doida.

E pra começar, a gente pode perguntar o nome do aluno. Mas a gente não sabe quantos nomes serão digitados e, por isso, é uma boa ideia colocar os nomes numa lista! Assim, podemos perguntar indefinidamente… Então vamos criar uma lista e um laço de repetição indefinido, que é feito com o while.

Pronto! Com essa estrutura, o programa já pergunta os nomes até a gente digitar “fim”...

Agora, a gente precisa escolher um dos nomes aleatoriamente. Bom, a primeira coisa que precisamos fazer pra ter acesso às funções aleatórias é importar o módulo random, certo?

E agora, depois do while, a gente precisa escolher um aluno aleatoriamente. Existe uma função do módulo random que faz exatamente o processo de selecionar um item numa lista. Você lembra qual é?! É a choice(), pô! Vem comigo:

Depois dessa linha, a variável “selecionado” vai armazenar os nome de um aluno escolhido aleatoriamente. Agora, a gente só precisa exibir.

Pô, pra exibir o nome do azarado selecionado, a gente vai usar a função mais famosa de todas: print(). E também vamos usar formatação de string pra ficar mais bonitinho, ok?! Se liga em como a gente pode fazer:

E pronto! Assim, o programa vai sortear e exibir o nome do primeiro aluno a apresentar o trabalho, e a gente finalizou mais um exercício! Te vejo no próximo, ok? Valeuuu!

E aí, chefia! Essa aqui tá pedindo um montão de coisa! OMG

Mas vamo lá, a gente precisa criar uma função, chamada geraExibe(), que gera e exibe 30 sublistas… hmmm. Bora começar com a definição da função!

E se liga que o enunciado especifica que a gente precisa usar a função choice() do módulo random… Pra gente ter acesso a essa função, vamos precisar importar o módulo. E a gente faz isso nas primeiras linhas do código, lembra? Tipo assim:

Aí sim! Vamo começar a pensar no que tem que ter dentro da nossa função...

Cara, a gente precisa gerar uma lista com 30 sublistas dentro! Olha, a gente até poderia escrever as 30 sublistas na mão, mas eu sugiro que a gente use um laço de repetição (e é isso que seu professor espera) hahaha. Então, bora criar um for:

Nesse código que se repete a gente quer acrescentar um item a uma lista (que eu chamei de lista, porque não sou muito criativo nem nada), assim como tá escrito no enunciado. Então, vamos gerar as sublistas com os dados aleatórios! Mas como a gente poderia usar a função choice() pra fazer isso?!

Olha, talvez você não lembre, mas a função choice recebe uma lista (ou string) e retorna um elemento dessa lista! A gente poderia fazer mais fácil com outras funções do módulo random, mas o enunciado especifica que a gente tem que usar o choice. Então, vamos criar strings com os dados que a gente precisa.

e pronto! Agora, a gente precisa do código que gera a senha e o usuário...

Pra gerar o usuário, a gente vai usar a função randint do módulo random…

E agora precisamos criar a senha com as especificações que o enunciado deu e, obrigatoriamente, usando a função choice() do módulo random.

Tipo assim! Reparou que a gente tá fazendo várias concatenações, ne? Na primeira linha ali a gente cria a variável senha com uma letra aleatória, usando a função choice(). E, em cada linha seguinte, a gente adiciona um caractere a mais, deixando no formato que o enunciado pediu! E agora só falta a gente juntar esse usuário e senha na lista que a gente criou pra retornar…

Pronto! Até aqui, foi… Mas o nome da função é geraExibe, e isso nos lembra que precisamos exibir essa lista gerada no fim do loop! hahaha além de retornar a lista que a gente gerou, é claro…

Pronto! Terminamos a primeira etapa, mas agora o enunciado também diz algo sobre um função de busca… Bora dar uma olhada nessa parada!

Mano, o formato da lista gerada pela função que a gente acabou de criar é +/- assim:

E o próximo passo da questão é escrever uma outra função, chamada busca, capaz de pesquisar por usuário e retornar o índice da sublista que contém esse usuário! Então, bora começar nossa função:

Nossa função recebe uma lista gerada e o usuário que estamos procurando… E pra gente descobrir o índice, a gente pode checar uma sublista por vez verificando se o usuário da sublista é igual ao usuário recebido e, se for, retornar o índice dessa sublista, sacou? Tipo assim:

A gente percorre toda a lista e retorna o index que tem o mesmo usuario que o parâmetro recebido, mas se a gente não achar nada no loop, então a gente retorna -1 como uma forma de dizer que não encontramos… Agora, vamos fazer o corpo do programa, testando as duas funções.

Aqui, o que a gente precisa fazer é criar uma lista com a função geraExibe(). Depois, perguntar um usuário com a função input(). Bora fazer isso!

Show! Agora, nossa missão é verificar se na nossa lista tem esse usuário. Se tiver a gente exibe a senha correspondente, e se não tiver a gente diz que não tem.

Pra isso, vamos precisar de um if.

Repara que eu usei uma formatação de string ali pra informar a senha correspondente ao usuário digitado, viu? E assim a gente finaliza a questão! heheh te vejo na próxima, ok?! É nóss

Coe, meu padrin! Questão de prova da PUC que nos obriga a usar o módulo random pra simular um jogo de par ou ímpar…

Bom, mas pelo menos é uma questão tranquila e da pra gente marcar esse ponto! Pô, tá escrito que a gente precisa fazer 11 repetições do jogo. E, a cada repetição, a gente tem que contar quem ganohu. Então, bora começar criando as variáveis que a gente vai precisar...

Mas, cara, se a gente sabe que vai precisar usar o módulo random, bora já importar ele de cara...

Tu lembrou que é legal sempre importar os módulos nas primeiras linhas, né?? Tu é brabo!

Agora, bora criar o nosso laço de repetição que vai fazer nosso código do par-ou-ímpar se repetir 11 vezes… Pra isso, vamos usar o while de forma que, a cada loop, o contador seja incrementado em uma unidade:

Pronto! Agora precisamos pensar no código do jogo… Bom, cada um dos jogadores coloca um número entre 0 e 10, contando com esses, né? Esses são os eventos que a gente vai simular com o módulo random.

Pronto! Mas qual dos dois venceu?!

A gente vai descobrir isso usando um if!

A gente pode somar as jogadas e verificar se o resultado é par ou ímpar… Se liga que o enunciado tá dizendo que Luiz escolheu par e Fernando, ímpar. Aí a gente só precisa contar os pontos dependendo de quem ganhou! Se liga só

Pronto! hehehhe falta checar quem venceu no fim...

Depois das 11 jogadas, precisamos checar qual dos dois jogadores é o vencedor, e pra isso a gente pode usar um if fora do laço de repetição! Saca só:

Repara que não tem como ter um empate, porque foram 11 jogadas. Com um número ímpar de jogadas, não tem como empatar, tá?! Show! O enunciado tá mandando a gente anunciar o vencedor e o número de pontos deste… Vamos fazer isso então!

Pra anunciar o vencedor, a gente pode usar a função print. E, juntamente com o nome, anunciar quantos pontos esse jogador fez. Então bora usar formatação de string pra juntar o nome com a quantidade de pontos, okay?!

Viu? Dessa forma, a gente concluiu nosso exercício! hehehe

Te vejo no próximo, tá? Valeuuu

Coe, irmão! Essa questãozinha veio na maldade...

Mas relaxa que a gente vai conseguir! Primeiro, como a gente sabe que vai precisar usar o módulo random, a gente já pode começar importando ele.

Agora sim, um décimo a gente já garantiu! hehehhe bora buscar o resto dos nossos pontos… Tá escrito que a gente precisa perguntar a dimensão da matriz pro usuário, então bora perguntar usando a função input, já convertido pra inteiro, já que a dimensão de uma matriz é um número inteiro, ok?

Show! Com esse dado em mãos, a gente pode preparar a nossa estrutura de repetição! O enunciado tá falando pra gente fazer 3 mapas. Então bora fazer um for…

Agora a gente tem que pensar numa forma de fazer um mapa único de acordo com os critérios do enunciado.

O nosso mapa é uma lista, então a cada loop a gente precisa criar uma nova lista e preencher ela aleatoriamente. Depois de preencher, a gente salva esse novo mapa como uma sublista de uma lista de mapas que vamos criar do lado de fora dor for! Tipo assim:

E, como sempre, a gente pode preencher esse mapa aleatoriamente de várias formas diferentes. Eu vou optar por preencher com todos os itens que o mapa vai ter e depois embaralhar com o método random.shuffle(). Então bora lá:

Pronto… A gente criou um mapa com a quantidade de B sendo o número de itens - a dimensão dividida por dois. Depois a gente preencheu o resto com T, assim como foi especificado no enunciado. Agora, vamos ter uma lista sempre nesse formato:

Obs: no exemplo é uma matriz quadrada de dimensão 3. Mas o mesmo padrão se repetiria independentemente do tamanho. Porém, a ideia era a nossa matriz ser aleatória, né? Então, vamos embaralhar de forma aleatória essa lista usando o método random.shuffle().

E pronto! Essa lista vai estar ordenada de forma aleatória a partir dessa linha. Porém, não basta ser aleatório, mas tem que seguir o critério do enunciado: não pode ter nenhum “T” no mesmo lugar dos outros mapas já criados… Então a gente só precisa embaralhar até atingir esse critério. Mas como vamos saber se já tem outro mapa um “T” no mesmo lugar?!

Bora criar uma função pra isso!

A gente pode iterar por todos os mapas procurando por um que tenha um “T” no mesmo lugar e, se tiver, então a gente pode embaralhar de novo. Essa função pode ser definida por:

Nessa função, a gente tá iterando por cada um dos mapas existentes na variável i e depois iterando, ao mesmo tempo, entre todos os elementos de “i” e “mapa”. Se encontrarmos algum que tenha na mesma posição, itens iguais a T, então aquele mapa já existe e temos que embaralhar de novo. Vamos usar nossa função num while então!

E pronto! Dessa forma, o mapa vai ser embaralhado até que atinja os critérios do enunciado e, assim que atingir, vai ser adicionado à lista “mapas”.

Mas ainda precisamos de uma função pra exibir essa lista no formato que tá no enunciado, então segura aí!

Pra gente exibir nossos mapa, a gente pode fazer uma função separada com esse propósito! A ideia é a cada linha a gente adiciona um elemento da coluna, e exibir linha por linha dessa forma. No fim, a gente usa um print() vazio só pra pular uma linha no terminal e ficar tudo mais bonitinho...

Repara que eu chamei essa função lá no finalzinho do nosso loop principal. Assim, a cada vez que a gente criar um novo mapa, a gente já exibe ele direto no terminal.

E é isso! Acabamos por aqui hehhe valeuuu!