[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
RES: [shell-script] "Bizarrices" com Arrays.
|
From: |
Julio Cezar Neves - DATAPREVRJ |
|
Subject: |
RES: [shell-script] "Bizarrices" com Arrays. |
|
Date: |
Thu, 30 Dec 2004 18:53:28 -0300 |
Grande Tchê,
nos fragmentos de código que vc trocou com o Aurélio, vi um trecho do jogo
da velha que desenvolvi sem otimizá-lo (foi só para estudar arrays). Como
até hoje não o conclui, estou novamente colocando-o na lista para ver se
algum dos nossos colegas desenvolve a rotina do operador iniciar o jogo,
pois no meu prg sempre quem começa é o computador.
====================================>8CorteAqui8<===========================
=================
#!/bin/ksh
#
#######################################################
# JOGO DA VELHA #
# DUVIDO QUE VOCE CONSIGA GANHAR! #
#-----------------------------------------------------#
# TIC TAC TOE #
# I WON'T GIVE YOU A CHANCE. YOU'LL NEVER WIN! #
#######################################################
# #
# Leia: Programacao Shell - Linux #
# Autor: Julio Cezar Neves #
# Editora: Brasport #
# ISBN: 85-7452-076-4 #
# #
#######################################################
# Para qualquer duvida ou esclarecimento sobre este #
# programa estou as ordens em address@hidden #
#-----------------------------------------------------#
# Any doubt about this program you can find me at #
# address@hidden #
#######################################################
# Se voce estiver sob o bash, troque a 1a. linha por #
# #!/bin/bash #
#-----------------------------------------------------#
# If you are running bash change the 1st. line for #
# #!/bin/bash #
#######################################################
# Este foi um meio divertido que encontrei para #
# testar a compatibilidade no uso de arrays entre o #
# bash e o ksh. Se alguem quiser desenvolver a rotina #
# em que o adversario comeca jogando, sinta-se a #
# vontade, porem nao esqueca de mandar-me o modulo #
# para incorpora-lo ao meu. #
#-----------------------------------------------------#
# This program was developed as a funny way to test #
# the compatibility between arrays in ksh and bash. #
# Feel free for develop the module that the opponent #
# start playing, but don't forget to send me the new #
# routine because I'll attach it at this one. #
#######################################################
#
Ganhei=0
Empate=0
Bold=`tput bold`
OBold=`tput sgr0`
Cols=`tput cols`
if [ $Cols -lt 80 -o `tput lines` -lt 25 ]
then
clear
echo "O tamanho minimo da janela deve ser 25 linhas e 80 colunas"
exit 2
read lixo
fi
Col0=`expr \( $Cols - 46 \) / 2`
Eng=`echo "To play in english use: $Bold\`basename $0\`$OBold -e (default
language is portuguese)"`
# Ingles ou Portugues? English or Portuguese?
if [ "$1" = -e ]
then
StrIni[1]=" 1 2 3"
StrIni[2]="1 | | +---------+----------+"
StrIni[3]=" ---+---+--- | Ties | Wins |"
StrIni[4]="2 | | +---------+----------+"
StrIni[5]=" ---+---+--- | | |"
StrIni[6]="3 | | +---------+----------+"
StrGan="I W O N !!!"
StrEmp="T I E"
StrLe="Now it's our time to play (RowColumn):"
StrEr1="At this position already has a -> "
StrEr2="Write row and column together. I.E. 13 means row 1 and
column 3"
StrFim="Do you want to continue?"
else
StrIni[1]=" 1 2 3"
StrIni[2]="1 | | +---------+----------+"
StrIni[3]=" ---+---+--- | Empates | Vitorias |"
StrIni[4]="2 | | +---------+----------+"
StrIni[5]=" ---+---+--- | | |"
StrIni[6]="3 | | +---------+----------+"
StrGan="G A N H E I !!!"
StrEmp="E M P A T E"
StrLe="Informe a sua jogada (LinhaColuna):"
StrEr1="Nesta posicao ja existe um -> "
StrEr2="Informe Linha e Coluna juntos. Ex: 13 = Linha 1 e Coluna 3"
StrFim="Deseja continuar?"
fi
Escrever ()
{
ColIni=`expr \( $Cols - length "$2" \) / 2`
tput cup $1 $ColIni
echo "$2"
}
Iniciar ()
{
Jogo=
for i in 1 2 3
do
for j in 1 2 3
do
P[$i$j]=
done
done
clear
for i in 1 2 3 4 5 6
do
tput cup `expr 11 + $i` $Col0
echo "${StrIni[i]}"
done
Seg=`date "+%S"`
case `expr $Seg % 5` in
0) Jogo=11 ; Saida=1 ;;
1) Jogo=13 ; Saida=2 ;;
2) Jogo=31 ; Saida=3 ;;
3) Jogo=33 ; Saida=4 ;;
*) Jogo=22 ; Saida=5 ;;
esac
tput cup 16 `expr $Col0 + 29`
echo $Bold$Empate
tput cup 16 `expr $Col0 + 40`
echo $Ganhei$OBold
}
Jogar ()
{
P[$1]=$2
Lin=`echo $1 | cut -c1`
Col=`echo $1 | cut -c2`
Lin=`expr \( $Lin - 1 \) \* 2 + 13`
Col=`expr \( $Col - 1 \) \* 4 + 3 + $Col0`
tput cup $Lin $Col
echo $2
}
Placar ()
{
tput bold
if [ $1 = E ]
then
Empate=$((Empate+1))
tput cup 22 $Col0
echo "$StrEmp"
tput cup 16 `expr $Col0 + 29` # Escrevendo Placar
echo $Empate
else
Ganhei=$((Ganhei+1))
tput cup 22 $Col0
echo "$StrGan"
tput cup 16 `expr $Col0 + 40` # Escrevendo Placar
echo $Ganhei
case $2 in
L) for j in 1 2 3
do
Jogar $i$j X
done
;;
C) for j in 1 2 3
do
Jogar $j$i X
done
;;
D1) for i in 11 22 33
do
Jogar $i X
done
;;
*) for i in 13 22 31
do
Jogar $i X
done
esac
fi
tput sgr0
}
# Cuidado com o chefe! WARNING! The boss is near you!
trap "clear ; exit" 0 2 3
# Jogando Playing
while true
do
Iniciar
if [ "$1" != "-e" ]
then
# tput cup 3 23
Escrever 3 "$Eng"
fi
Jogar $Jogo X
Vez=0
while true
do
if [ $Vez -eq 4 ]
then
Placar E
break
fi
tput cup 21 $Col0
echo "$StrLe"
tput cup 21 `expr $Col0 + 1 + length "$StrLe"`
tput el
tput cup 21 `expr $Col0 + 1 + length "$StrLe"`
read Jogo
case $Jogo in
[1-3][1-3]) if [ ${P[$Jogo]} ]
then
tput cup 22 $Col0
echo -n "$Bold$StrEr1${P[$Jogo]}
<-$OBold"
read Jogo
tput cup 22 $ColIni
tput el
tput cup 21 `expr $Col0 + 1 + length
"$StrLe"`
tput el
continue
fi
Jogar $Jogo O
Vez=$((Vez+1))
;;
*) tput cup 22 $Col0
echo -n "$Bold$StrEr2$OBold"
read Jogo
tput cup 22 $Col0
tput el
tput cup 21 `expr $Col0 + 1 + length
"$StrLe"`
tput el
continue
esac
for i in 1 2 3
do
LX[i]=0 ; CX[i]=0 ; LO[i]=0 ; CO[i]=0 ; DX[i]=0 ;
DO[i]=0
done
for i in 1 2 3
do
for j in 1 2 3
do
[ "${P[$i$j]}" = X ] &&
LX[i]=$((${LX[$i]}+1))
[ "${P[$i$j]}" = O ] &&
LO[i]=$((${LO[$i]}+1))
[ "${P[$j$i]}" = X ] &&
CX[i]=$((${CX[$i]}+1))
[ "${P[$j$i]}" = O ] &&
CO[i]=$((${CO[$i]}+1))
done
done
for i in 11 22 33
do
[ "${P[$i]}" = X ] && DX[1]=$((${DX[1]}+1))
[ "${P[$i]}" = O ] && DO[1]=$((${DO[1]}+1))
done
for i in 13 22 31
do
[ "${P[$i]}" = X ] && DX[2]=$((${DX[2]}+1))
[ "${P[$i]}" = O ] && DO[2]=$((${DO[2]}+1))
done
# Pra ganhar I wanna win!
for i in 1 2 3
do
LAlinhadas[i]=$((${LX[i]}-${LO[i]}))
CAlinhadas[i]=$((${CX[i]}-${CO[i]}))
DAlinhadas[i]=$((${DX[i]}-${DO[i]}))
if [ ${LAlinhadas[i]} -eq 2 ]
then
for j in 1 2 3
do
[ ${P[$i$j]} ] && continue
Jogo=$i$j
Jogar $Jogo X
Placar G L
break 3
done
fi
if [ ${CAlinhadas[i]} -eq 2 ]
then
for j in 1 2 3
do
[ ${P[$j$i]} ] && continue
Jogo=$j$i
Jogar $Jogo X
Placar G C
break 3
done
fi
done
if [ ${DAlinhadas[1]} -eq 2 ]
then
for i in 11 22 33
do
[ ${P[$i]} ] && continue
Jogo=$i
Jogar $Jogo X
Placar G D1
break 2
done
fi
if [ ${DAlinhadas[2]} -eq 2 ]
then
for i in 13 22 31
do
[ ${P[$i]} ] && continue
Jogo=$i
Jogar $Jogo X
Placar G D2
break 2
done
fi
# Pra nao perder I don't wanna lose
for i in 1 2 3
do
if [ ${LAlinhadas[i]} -eq -2 ]
then
for j in 1 2 3
do
[ ${P[$i$j]} ] && continue
Jogo=$i$j
Jogar $Jogo X
continue 3
done
fi
if [ ${CAlinhadas[i]} -eq -2 ]
then
for j in 1 2 3
do
[ ${P[$j$i]} ] && continue
Jogo=$j$i
Jogar $Jogo X
continue 3
done
fi
done
if [ ${DAlinhadas[1]} -eq -2 ]
then
for i in 11 22 33
do
[ ${P[$i]} ] && continue
Jogo=$i
Jogar $Jogo X
continue 2
done
fi
if [ ${DAlinhadas[2]} -eq -2 ]
then
for i in 13 22 31
do
[ ${P[$i]} ] && continue
Jogo=$i
Jogar $Jogo X
continue 2
done
fi
# Ao ataque! Let's attack!
case $Vez in
1) case $Saida in
1) [ ${P[33]} ] && Jogo=13 ||
Jogo=33 ;;
2) [ ${P[31]} ] && Jogo=33 ||
Jogo=31 ;;
3) [ ${P[13]} ] && Jogo=11 ||
Jogo=13 ;;
4) [ ${P[11]} ] && Jogo=31 ||
Jogo=11 ;;
*) if [ ${P[11]} ]
then
Jogo=33
elif [ ${P[33]} ]
then
Jogo=11
elif [ ${P[13]} ]
then
Jogo=31
else
Jogo=13
fi
esac ;;
*) [ $P{[22]} ] &&
{
Jogo=
for i in 1 3
do
for j in 1 3
do
[ ${P[$i$j]} ] &&
{
[ ${P[$j$i]}
] && continue ||
{
Jogo=$j$i
break 2
}
} ||
{
Jogo=$i$j
break 2
}
done
done
[ "$Jogo" ] &&
{
Jogar $Jogo X
continue
}
for i in 1 2 3
do
for j in 1 2 3
do
[ "${P[$i$j]}" ] &&
continue
Jogo=$i$j
break 2
done
done
} || Jogo=22
esac
Jogar $Jogo X
done
tput cup 23 $Col0
echo "$StrFim"
tput cup 23 `expr $Col0 + length "$StrFim" + 1`
read a
[ `echo $a | tr n N` = N ] && exit
done
====================================>8CorteAqui8<===========================
=================
[ ]s,
Julio
:wq
| -----Mensagem original-----
| De: Rodolfo Villanova
| [mailto:address@hidden]
| Enviada em: quinta-feira, 30 de dezembro de 2004 18:04
| Para: address@hidden
| Assunto: RES: [shell-script] "Bizarrices" com Arrays.
|
|
|
| Amigos,
|
| A propósito do tema, em abril do ano passado andei "viajando"
| justamente
| sobre esse assunto, quando tão bem me contestou o grande (e
| "verde") Aurélio
| Jargas.
|
| Espero que essa sequencia de mensagens contribua de alguma forma para
| enriquecer e despertar a busca do conhecimento aos novos
| experimentadores de
| criação de shell-scripts.
|
| Forte abraço a todos,
| Rodolfo Villanova
|
| 8<-------------------------------------------------------->8
| > -----Mensagem original-----
| > De: Rodolfo Villanova
| > [mailto:address@hidden]
| > Enviada em: terça-feira, 22 de abril de 2003 18:11
| > Para: address@hidden
| > Assunto: RES: [shell-script] shell ou nao shell, eis a questao
| >
| >
| > É isso aí, Aurélio!
| >
| > Nada como a experimentação para vislumbrar novos horizontes.
| > Concordo "ipsis literis" em relação aos conceitos sobre matrizes
| > que expuseste aqui na lista.
| > Mas como em computação esses conceitos nem sempre se aplicam de
| > forma ortodoxa, resolvi testar alguns limites.
| >
| > Andei fuçando de novo no que tu NÃO chamas de matriz e no que eu
| > chamaria princípio de matriz e cheguei a algumas conclusões:
| >
| > 1. Pode-se dimensionar isso que tu não chamas mas eu chamaria de
| > matriz em 11x14 (linhas: [0-10]; colunas: [0-23] - o que,
| > convenhamos, é bastante limitado e acompanha o limite de vetor no
| > shell-script). O problema central reside em armazenar e recuperar
| > nessa "coisa" que eu chamaria de matriz os dados que eu quiser.
| >
| > 2. Como essa "joça" de matriz não se comporta como uma matriz
| > normal se comportaria em qualquer outra linguagem computacional
| > (M[x;y]), então só posso concluir que só é possível acessá-la
| > decentemente na forma vetorial V[264] - forma, aliás, como os
| > computadores processam matrizes).
| >
| > 3. O "cheese" da "questã", nesse caso, é a forma matricial como
| > indexo os valores contidos nesse vetor, onde alguns valores se
| > sobrepõe por não existirem índexadores específicos para esse fim.
| >
| > 4. Finalizando, apesar de o shell-script não oferecer recursos de
| > tratamento matricial, provei (nem que seja para meu próprio ego!)
| > que esse tipo de tratamento pode ser simulado sobre a dimensão de
| > vetor de uma forma limitada; não existir a forma normalmente
| > prevista de indexação matricial, mas se tentarmos simulá-la e
| > tentarmos utilizá-la de forma ampla, alguns valores armazenados
| > nesse vetor acabam se sobrepondo em determinados intervalos,
| > inutilizando alguns dados alí armazenados.
| >
| > 5. Chega desse assunto que eu já enjoei!
| >
| > ------------------
| > for i in 1 2 3 4 5
| > do
| > echo "ABRAÇO \c"
| > done
| > ------------------
| >
| > Rodolfo Villanova
| >
| >
| > -----Mensagem original-----
| > De: aurelio [mailto:address@hidden]
| > Enviada em: terça-feira, 22 de abril de 2003 16:43
| > Para: address@hidden
| > Assunto: Re: [shell-script] shell ou nao shell, eis a questao
| >
| >
| > oi rodolfo,
| >
| > --- Rodolfo Villanova escreveu:
| > > Realmente há a limitação de só ser possível incluir até
| 10x10 no que
| > > normalmente eu chamaria de "matriz".
| > >
| > > Se o que segue abaixo não reproduz o princípio de matriz,
| então nunca
| > > entendi ou já esqueci qual o conceito de matrizes (o que vem a
| > > reforçar um antigo ódio à matemática, mesmo! %P)
| >
| > calma, seguir segue :), só que com a limitação do 10x10.
| > se o bash suportasse matrizes "de verdade", não haveria este
| > limite, pois ele deixaria você colocar um array dentro de
| > outro array.
| >
| >
| > > Meu script de teste:
| >
| > seu script funciona, mas se o bash suportasse matrizes
| > de verdade, na atribuição dos valores, ao invés do
| >
| > > P[$i$j]=$k
| >
| > você faria
| >
| > P[$i][$j]=$k
| >
| > e na hora de pegar o resultado:
| >
| > > echo "${P[$i$j]} \t\c"
| >
| > ficaria:
| >
| > echo "${P[$i][$j]} \t\c"
| >
| >
| > a grande diferença de se ter os dois [] separados é que
| > você pode por qualquer número dentro de cada um deles,
| > então se você quiser ter uma matriz de 99x99, bastaria
| > defini-la e usar o ${matriz[99][99]} para pegar o valor.
| >
| > mas isso não rola no bash, pois não dá pra colocar um array
| > dentro uma pasição qualquer de um array já existente.
| >
| > aliás, você de repente pode fazer um
| >
| > matriz[9999]='bla'
| >
| > e depois se virar nos 'for' da vida, mas fica um troço meio,
| > digamos, porco :)
| >
| > só pra exemplificar, um trechinho de código em python
| > (mas poderia ser qualquer outra linguagem) que demonstra
| > como criar e obter valores de uma matriz usando os colchetes:
| >
| > >>> matriz = [ [], [], [] ]
| > >>> matriz[0] = [0,1,2,3,4,5]
| > >>> matriz[1] = [6,7,8]
| > >>> matriz[2] = [9,10,11,12]
| > >>> matriz[1]
| > [6, 7, 8]
| > >>> matriz[1][1]
| > 7
| >
| > em shell:
| >
| > # matriz[0]=(0,1,2,3,4,5)
| > bash: matriz[0]: cannot assign list to array member
| >
| >
| > isso é exatamente o que o shell não suporta, você poder
| > colocar um array dentro de um array, formando uma matriz
| > de arrays, com 'linhas' e 'colunas'.
| >
| > ficou claro ou baguncei mais ainda? :)
| >
| >
| > > -----Mensagem original-----
| > > De: aurelio [mailto:address@hidden]
| > >
| > > > > for i in 1 2 3
| > > > > do
| > > > > for j in 1 2 3
| > > > > do
| > > > > [ "${P[$i$j]}" = X ] && LX[i]=$((${LX[$i]}+1))
| > > > > [ "${P[$i$j]}" = O ] && LO[i]=$((${LO[$i]}+1))
| > > > > [ "${P[$j$i]}" = X ] && CX[i]=$((${CX[$i]}+1))
| > > > > [ "${P[$j$i]}" = O ] && CO[i]=$((${CO[$i]}+1))
| > > > > done
| > > > > done
| > >
| > > ok, isso funciona, mas não deixa de ser um array
| > > unidimensional, com apenas uma "linha" e várias
| > > "colunas".
| > > um array assim como eu o conheço, deve ter linhas e colunas.
| > > tipo assim:
| > >
| > > array[0] = (1 2 3 4 5) # linha 1
| > > array[1] = (1 2 3 4 5) # linha 2
| > > ...
| > > array[N] = (...) # linha N
| > >
| > > pra depois você acessar como:
| > > array[linha][coluna]
| > >
| > > até onde eu vi, em shell não dá pra fazer matrizes com
| > > linhas e colunas:
| > >
| > > > > > mas uma pergunta... dá pra trabalhar com matriz em shell?
| > > > > também não sei, vamos ver:
| > > > > # a[0]=(1 2 3 4)
| > > > > bash: a[0]: cannot assign list to array member
| > > > > Resposta: não &:)
| > >
| > > mas usando a técnica do trecho do script do julio se pode
| > > "simular" uma matriz com linhas e colunas se usar as
| > > dezenas como linhas e as unidades como colunas.
| > >
| > > mas isso te limita a uma matriz de tamanho máximo de
| > > 10 linhas e 10 colunas (array[99]).
| > =====
| 8<-------------------------------------------------------->8
|
| > -----Mensagem original-----
| > De: Andreyev Dias de Melo [mailto:address@hidden]
| > Enviada em: quinta-feira, 30 de dezembro de 2004 15:19
| > Para: address@hidden
| > Assunto: Re: [shell-script] "Bizarrices" com Arrays.
| >
| >
| >
| > On Wed, 29 Dec 2004 16:39:07 -0200, Gentil de Bortoli Júnior
| > <address@hidden> wrote:
| > > Pessoal, agora é minha vez de pedir um help para tentar entender
| > > algumas coisas que estão acontecendo.
| > >
| > > Eu estou escrevendo um script que faz algumas
| brincadeiras com arrays.
| > > Algo não saiu como eu queria e comecei a fazer testes.
| > >
| > > A primeira dúvida é essa:
| > >
| > > [gentil@gentil:~]$ variavel[11111]="Bla Bla"
| > > [gentil@gentil:~]$ variavel[aaaaa]="Bla Bla"
| > > [gentil@gentil:~]$ variavel[aa111]="Bla Bla"
| > > [gentil@gentil:~]$ variavel[11aaa]="Bla Bla"
| > > bash: 11aaa: value too great for base (error token is "11aaa")
| > > [gentil@gentil:~]$
| > >
| > > ##### Ou seja, por que quando eu tentei definir a chave
| do meu array
| > > com a string "11aaa" eu obtive o erro acima?
| > >
| > > A segunda dúvida é a seguinte:
| > >
| > > [gentil@gentil:~]$ variavel[11_111]="Bla Bla"
| > > bash: 11_111: value too great for base (error token is "11_111")
| > > [gentil@gentil:~]$
| >
| > Pô Gentil, cada dúvida hein?! Não achei muita coisa no
| google e no man
| > do bash, mas talvez possamos divagar sobre isso enquanto
| nossos gurus
| > não nos acodem! :-D
| >
| > No man do bash diz: "Arrays are indexed using integers and are
| > zero-based.". Talvez indices com coisas não númericas sejam
| > considerados como em bases diferentes da decimal, como octal ou
| > hexadecimal, aí as strings que passamos podem ser muito grandes para
| > serem indices nestas bases...
| >
| > > Obtive o erro acima. Então mudei e fiz algo assim:
| > >
| > > [gentil@gentil:~]$ variavel[11^111]="Bla Bla"
| > > [gentil@gentil:~]$ echo ${variavel[11^111]}
| > > Bla Bla
| > > [gentil@gentil:~]$
| > >
| > > Parece que funcionou, certo? Mas aí, fui fazer mais um
| teste, vejam:
| > >
| > > [gentil@gentil:~]$ variavel[11^111]=6
| > > [gentil@gentil:~]$ variavel[11^222]=7
| > > [gentil@gentil:~]$ echo ${variavel[11^111]}
| > > 6
| >
| > Parece que ele não tem problemas com ^, cada variável:
| >
| > $ echo ${variavel[@]}
| > 6 7
| >
| > O tamanho do array:
| >
| > $ echo ${#variavel[*]}
| > 2
| >
| > > Ok, isso funcionou como o esperado mas... o que acontece aqui?
| > >
| > > [gentil@gentil:~]$ variavel[1916^AAAA]=6
| > > [gentil@gentil:~]$ variavel[1916^YYYY]=5
| > > [gentil@gentil:~]$ echo ${variavel[1916^AAAA]}
| > > 5
| > > [gentil@gentil:~]$
| > >
| > > Ou seja, pedi o valor de uma variável e recebi o valor da outra.
| >
| > Acho que vc sobrescreveu sua variável:
| >
| > $ variavel[1916^AAAA]=6
| > $ variavel[1916^YYYY]=5
| > $ echo ${#variavel[*]}
| > 1
| > $ echo ${#variavel[@]}
| > 1
| >
| > > E nesse último exemplo, volta a funcionar:
| > >
| > > [gentil@gentil:~]$ variavel[1111^YYYY]=5
| > > [gentil@gentil:~]$ variavel[2222^AAAA]=6
| > > [gentil@gentil:~]$ echo ${variavel[1111^YYYY]}
| > > 5
| > > [gentil@gentil:~]$
| >
| > Mas agora a parte antes do ^ mudou... Hmmm, acho que ele
| não lê o que
| > vem depois do circunflexo se isto não for númerico...
| >
| > $ variavel[1111^YYYY]=5
| > $ echo ${variavel[1111]}
| > 5
| >
| > > Desculpem o e-mail grande e chato mas... não estou
| sacando o que está
| > > acontecendo.
| >
| > Que isso, vc colheu bons exemplos. HIH!
| > []s
| > --
| > Andreyev
| >
| >
| >
| ---------------------------------------------------------------------
| > Esta lista não admite a abordagem de outras liguagens de
| > programação, como perl, C etc. Quem insistir em não seguir esta
| > regra será moderado sem prévio aviso.
| >
| ---------------------------------------------------------------------
| > Sair da lista: address@hidden
| >
| ---------------------------------------------------------------------
| > Esta lista é moderada de acordo com o previsto em
| http://www.listas-discussao.cjb.net
| ---------------------------------------------------------------------
|
| Links do Yahoo! Grupos
|
|
|
|
|
|
|
|
|
|
|
| ---------------------------------------------------------------------
| Esta lista não admite a abordagem de outras liguagens de
| programação, como perl, C etc. Quem insistir em não seguir
| esta regra será moderado sem prévio aviso.
| ---------------------------------------------------------------------
| Sair da lista: address@hidden
| ---------------------------------------------------------------------
| Esta lista é moderada de acordo com o previsto em
http://www.listas-discussao.cjb.net
---------------------------------------------------------------------
Links do Yahoo! Grupos
- RES: [shell-script] "Bizarrices" com Arrays.,
Julio Cezar Neves - DATAPREVRJ <=