(Brincando com Aleatoriadade) Tarot Randomico [Shell Script]

(Brincando com Aleatoriadade) Tarot Randomico

Publicado por Samuka (última atualização em 08/05/2012)

[ Hits: 7.269 ]

Download taro-simples.sh

0 0

Denuncie Favoritos Indicar

Fala Galera,

Sou velho por aqui, mas novo de contribuições.

Como sou APAIXONADO por ShellScripts !

Vou postar minha singela contribuição, falando de aleatoriedade
em um singelo exemplo pratico (Puxando Cartas de Tarot)

Futuramente crio um artigo, para ficar fácil nos troubleshoots
do Scripteiros de Plantão na "Pesquisas Google".

/* Me empolguei assistindo Touch! resolvi estudar probabilidades em Bash.
*
* Eu Sei, é nerdisse e loucura, Mas é ótimo para treinar aplicações
* de probabilidade em bash, e futuramente usar em programas complexos!
*/

Abraço,
Samuka

Esconder código-fonte

#!/bin/bash
#
# Desenvolvido por: Samuel Maciel Sampaio [2012.05.01]
# Contato: <samukasmk@gmail.com>
# Aka: SamukaSmk

# Script: Taro (Aleatório)
# Objetivo: Treinar aplicações de probabilidade em bash e futuramente
#           usar em programas complexos, em um singelo exemplo pratico
#           (Puxando Cartas de Tarot).

# <Definições>
# Total de Cartas: 22 `${#CARTAS[*]}`






##### Função (Define_CartasNoMonte) :
##### - Define As 22 Cartas do Tarot (Arcano Maior), dentro do Array: ${Define_CartasNoMonte}

function Define_CartasNoMonte () {

   CARTAS=("0. O Louco" "1. O Mago" "2. A Papisa" "3. A Imperatriz" "4. O Imperador" "5. O Papa" "6. Enamorado" "7. O Carro" "8. A Justiça" "9. O Eremita" "10. As Rodas da Fortuna" "11. A Força" "12. O Pendurado" "13. A Morte" "14. Temperança" "15. O Diabo" "16. A Torre" "17. A Estrela" "18. A Lua" "19. O Sol" "20. O Julgamento" "21. O Mundo")

}
Define_CartasNoMonte





##### Função (Puxa_CartaNoMonte) que:
#####  - Conta a quantidade de objetos do Array: ${Define_CartasNoMonte}
#####  - Define um Valor Aleatório, (Dentro do Range proposto, com a quantidade
#####    de cartas contadas do Array ${Define_CartasNoMonte}.

function Puxa_CartaNoMonte () {
  echo ${CARTAS[ $(( $RANDOM % ${#CARTAS[*]} )) ]}
}



##### Função (Coloca_CartasNaMesa) 

##### Estudei um pouquim, e escolhi o método [Tiragem em Cruz]

##### Como a sequencia de `Tiragem de Cartas em Cruz` é sempre:

#####      [3º]
##### [1º] [5º] [2º]
#####      [4º]

##### Para não alterar a sequencia das cartas entre a probabilidade.
#####  - Pego estaticamente os valores em variaveis (uma-a-uma) Carta_1, Carta_2, ...
#####  - Printo na Tela Em Forma de Cruz. 

function Coloca_CartasNaMesa () {

   echo "Mentalize Tranquilamente Seu Nome Completo Por 5 vezes..."
   echo "Em seguida, aperte qualque tecla, para puxar as cartas na mesa."

   Carta_1=`Puxa_CartaNoMonte`
   Carta_2=`Puxa_CartaNoMonte`
   Carta_3=`Puxa_CartaNoMonte`
   Carta_4=`Puxa_CartaNoMonte`
   Carta_5=`Puxa_CartaNoMonte`

   read Nada

   echo -e "\t\t[$Carta_3]"
   echo -e "[$Carta_1]\t[$Carta_5]\t[$Carta_2]"
   echo -e "\t\t[$Carta_4]"

   echo "Observação: Conceito meramente explicativo, á aplicações de probabilidades !"
   echo "Ate Mais !"
   echo "SamukaSmk"

}


# Por enquanto é Só!
# Grande Abraço,
# SamukaSmk

Scripts recomendados

Firewall iptables

Script para monitoramento de processos em execução no sistema

Display números digital no terminal

Estranho

Cria usuario no linux e no samba

Comentários

[1] Comentário enviado por removido em 09/05/2012 - 04:35h

Dois comentários:

1º A variável interna $RANDOM gera aleatórios de 0 a 32767, então o espaço de probabilidade não é uniforme.
Para 22 cartas, os restos da divisão por 22 (cartas) se repetem de 0 até 21.
É que 32767 dividido por 22 dá **quociente** 1489 e dá resto 9.
Prá completar a carreira, precisava ir até 32779, mas não dá porque o gerador de aleatórios do bash não deixa.
Daí fica com um conjunto de números de 10 até 21 a menos aparecendo na probabilidade.
Isso para ser bem rigiroroso.

2º Não sei se caberia fazer um algoritmo para embaralhamento. Existem vários algoritmos para misturar elementos de vetores.
Mas especificamente seria um algoritmo que imitasse exatamente o que ocorre com uma baralho quando se embaralham as cartas.
Lembro-me agora de três coisas que ocorrem com as cartas:
- picando-as, embaralhamento normal onde grupos de cartas alteram de ordem;
- infiltramento, quando as cartas de um grupo entram uma a uma na sequência das de outro grupo;
- corte: quando se corta ou se pede a alguém para tirar uma parte das cartas duas ou três vezes.

Como a 1ª citação é mais rigorosa, a solução que pensei foi:

CARTA = ($RANDOM * "número de cartas") / 32767

Ainda não é perfeito mas corrige esse trecho que fica sem preencher.

****ADD****

Correção por encontrar palavra trocada.

0 0

[2] Comentário enviado por nickmarinho em 09/05/2012 - 08:24h

Achei fantástico esse .sh mas mais louco ainda é o comentário acima.

Babei lendo essa explicação !

\o/ parabéns Listeiro.

0 0

[3] Comentário enviado por samukasmk em 09/05/2012 - 10:35h

Listeiro,

Belo cometário !

Para os seguidores do famoso "Pé da letra" foi realmente construtivo !
é uma pena eu não ter conhecimento o suficiente de matemática para debater teti-a-teti.

O claro objetivo de postar esse script a comunidade foi uma singela e prática demonstração
aos nossos companheiros de como trabalhar com números e gera-los de forma dinâmica,
independente da técnica, ou até mesmo se é mais ou menos eficaz diante das formulas
matemáticas de aleatoriedade (como a questão que foi brilhantemente levantada por você)

Acima de tudo, sou grato pela atenção e compreensão !
Samuka

0 0

[4] Comentário enviado por removido em 14/05/2012 - 12:48h

Valeu pessoal!

Eu pensei em fazer uma coisa parecida uma vez, mas escaneando imagens.

Colocando umas dez cartas por vez no scanner com cuidado prá render.

Cada escaneado ficou pesando "chumbo", digamos assim.

Daí desisti por hora. tinha muita mão-de-obra no Gimp.

O script está ótimo e se de repente você quiser seguir essa "viagem" que eu escrevi aí em cima, fice feito dica.

O melhor é que Shell deixa com certas liberdades que outras linguagens não dão.

0 0