Escrever números, datas, horas e outros por extenso
Publicado por Elias Bernabé Turchiello (última atualização em 21/05/2012)
[ Hits: 20.289 ]
Homepage: www.turchiellows.xpg.com.br
Download numeros-por-extenso-texto.sh
Este script escreve por extenso valores numéricos, monetários (moeda brasileira), datas, (levando em consideração anos bissextos), horas, meses do ano e os dias da semana.
Funciona em modo texto devolvendo o resultado na tela do terminal, o qual pode muito bem ser redirecionado com > ou >>
Ex.:
PARA VALORES NUMÉRICOS: (decimais com vírgula)
./numeros-por-extenso-texto.sh -n 123,42
cento e vinte e três vírgula quarenta e dois
PARA VALORES MONETÁRIOS (em reais): (decimais com vírgula)
./numeros-por-extenso-texto.sh -V 99,12
noventa e nove reais com doze centavos
PARA VALORES DE DATAS:
./numeros-por-extenso-texto.sh -D 01/04/1978
primeiro de abril do ano um mil e novecentos e setenta e oito
PARA VALORES DE HORAS:
./numeros-por-extenso-texto.sh -H 00:15:09
zero hora com quinze minutos e nove segundos
PARA OS MESES DO ANO: (1-12)
./numeros-por-extenso-texto.sh -m 9
setembro
PARA OS DIAS DA SEMANA: (1-7)
./numeros-por-extenso-texto.sh -s 4
quarta-feira
#!/bin/bash
# numeros-por-extenso-texto.sh
#-------------------------------------------------------------------------------------
# Versão 1.0 : Elias Bernabé Turchiello - 29/04/2012 : Escreve por extenso um número passado como parâmetro, dando o seu resultado em valor monetário (reais e centavos). Não faz verificação nenhuma e não solicita correção do valor digitado. Desenvolvido para ser chamado silenciosamente por outros scripts e simplesmente devolver a resposta
# Versão 1.1 : Elias Bernabé Turchiello - 12/05/2012 : Passa a escrever valores numéricos, datas, horas, meses e dias da semana
# Versão 1.2 : Elias Bernabé Turchiello - 14/05/2012 : Separado a parte de ajuda em um case a parte que trata somente o primeiro parâmetro. Se nenhum parâmetro for passado simplesmente não faz nada.
#-------------------------------------------------------------------------------------
# Elias Bernabé Turchiello
# Home: www.turchiellows.xpg.com.br
#-------------------------------------------------------------------------------------
# Criando a variável de ajuda sobre a descrição do script:
Ajuda="
[`basename $0`]
* USO : `basename $0` [OPÇÃO] [PARÂMETRO]
* Escreve por extenso valores numéricos, monetários, datas, horas, mêses e os
dias da semana
* Desenvolvido em Kurumin NG e otimizado para sistemas Debian e derivados
* Funciona em modo texto para ser executado diretamente no terminal ou
chamado a partir de outro script qualquer
* Aceita números com até duas casas decimais separadas obrigatoriamente por vírgula
* A separação das unidade de milhar pode ou não ser feita por um ponto Ex.: 110.000
"
# Criando a variável de ajuda sobre as opções do script:
Opcoes="
[OPÇÕES]
-h --help -mostra esta tela de ajuda e sai
-v --versao -mostra a versão, data de criação, o autor, as mudanças da versão e sai
-e --exemplo -mostra exemplos de como executar este script e sai
-d --depende -mostra a lista de dependências do script e sai
-n --numero -escreve por extenso números cardinais
-V --valor -escreve por extenso valores de moedas em Reais (moeda brasileira)
-D --data -escreve por extenso valores de tadas no formato dd/mm/yyyy
-H --hora -escreve por extenso valores de horas no formato hh:mm:ss
-s --semana -escreve por extenso o dia da semana numerado de 1-7 (1=domingo)
-m --mes -escreve por extenso o mês do ano numerado de 1-12 (1=janeiro)
"
# Criando a variável de ajuda com exemplos de execução do script:
Exemplos="
PARA VALORES NUMÉRICOS: (decimais com vírgula)
./`basename $0` -n 123,42
cento e vinte e três vírgula quarenta e dois
PARA VALORES MONETÁRIOS (em reais): (decimais com vírgula)
./`basename $0` -V 99,12
noventa e nove reais com dize centavos
PARA VALORES DE DATAS:
./`basename $0` -D 01/04/1978
primeiro de abril do ano um mil e novecentos e setenta e oito
PARA VALORES DE HORAS:
./`basename $0` -H 00:15:09
zero hora com quinze minutos e nove segundos
PARA OS MESES DO ANO: (1-12)
./`basename $0` -m 9
setembro
PARA OS DIAS DA SEMANA: (1-7)
./`basename $0` -s 4
quarta-feira
"
#-------------------------------------------------------------------------------------
# Preparando a variável IFS para ler nomes com espaços:
Ifsvelho="$IFS"
IFS='
'
#-------------------------------------------------------------------------------------
# Preparando as funções para a leitura de unidade, dezena e centena:
# Função para ler somente unidades até 9:
Unidade () {
# Coletando o número da unidade:
Unidade=`cat /tmp/valor-$$ | cut -c$1`
# Processando:
case $Unidade in
1) echo -n "um" >> /tmp/resultado-$$ ;;
2) echo -n "dois" >> /tmp/resultado-$$ ;;
3) echo -n "três" >> /tmp/resultado-$$ ;;
4) echo -n "quatro" >> /tmp/resultado-$$ ;;
5) echo -n "cinco" >> /tmp/resultado-$$ ;;
6) echo -n "seis" >> /tmp/resultado-$$ ;;
7) echo -n "sete" >> /tmp/resultado-$$ ;;
8) echo -n "oito" >> /tmp/resultado-$$ ;;
9) echo -n "nove" >> /tmp/resultado-$$ ;;
esac
}
# Função para ler as unidades de datas. O dia 1 deve ser identificado como primerio:
UnidadeData () {
# Coletando o número da unidade:
Unidade=`cat /tmp/valor-$$ | cut -c$1`
# Processando:
case $Unidade in
1) echo -n "primeiro" >> /tmp/resultado-$$ ;;
2) echo -n "dois" >> /tmp/resultado-$$ ;;
3) echo -n "três" >> /tmp/resultado-$$ ;;
4) echo -n "quatro" >> /tmp/resultado-$$ ;;
5) echo -n "cinco" >> /tmp/resultado-$$ ;;
6) echo -n "seis" >> /tmp/resultado-$$ ;;
7) echo -n "sete" >> /tmp/resultado-$$ ;;
8) echo -n "oito" >> /tmp/resultado-$$ ;;
9) echo -n "nove" >> /tmp/resultado-$$ ;;
esac
}
# Função para ler as unidades de horas. Deve ler o valor zero para a zero hora:
UnidadeHora () {
# Coletando o número da unidade:
Unidade=`cat /tmp/valor-$$ | cut -c$1`
# Processando:
case $Unidade in
0) echo -n "zero" >> /tmp/resultado-$$ ;;
1) echo -n "uma" >> /tmp/resultado-$$ ;;
2) echo -n "duas" >> /tmp/resultado-$$ ;;
3) echo -n "três" >> /tmp/resultado-$$ ;;
4) echo -n "quatro" >> /tmp/resultado-$$ ;;
5) echo -n "cinco" >> /tmp/resultado-$$ ;;
6) echo -n "seis" >> /tmp/resultado-$$ ;;
7) echo -n "sete" >> /tmp/resultado-$$ ;;
8) echo -n "oito" >> /tmp/resultado-$$ ;;
9) echo -n "nove" >> /tmp/resultado-$$ ;;
esac
}
# Função para ler dezena até 99:
Dezena () {
# Coletando o número da dezena:
Dezena=`cat /tmp/valor-$$ | cut -c$1`
# Coletando o número da unidade:
Unidade=`cat /tmp/valor-$$ | cut -c$2`
case $Dezena in
0) case $Dezena$Unidade in
0) echo -n "0" > /dev/null ;;
0*) Unidade $2 >> /tmp/resultado-$$ ;;
esac ;;
1) case $Dezena$Unidade in
10) echo -n "déz" >> /tmp/resultado-$$ ;;
11) echo -n "onze" >> /tmp/resultado-$$ ;;
12) echo -n "doze" >> /tmp/resultado-$$ ;;
13) echo -n "treze" >> /tmp/resultado-$$ ;;
14) echo -n "catorze" >> /tmp/resultado-$$ ;;
15) echo -n "quinze" >> /tmp/resultado-$$ ;;
16) echo -n "dezeseis" >> /tmp/resultado-$$ ;;
17) echo -n "dezesete" >> /tmp/resultado-$$ ;;
18) echo -n "dezoito" >> /tmp/resultado-$$ ;;
19) echo -n "dezenove" >> /tmp/resultado-$$ ;;
esac ;;
2) case $Dezena$Unidade in
20) echo -n "vinte" >> /tmp/resultado-$$ ;;
2*) echo -n "vinte e " >> /tmp/resultado-$$ ; Unidade $2 >> /tmp/resultado-$$ ;;
esac ;;
3) case $Dezena$Unidade in
30) echo -n "trinta" >> /tmp/resultado-$$ ;;
3*) echo -n "trinta e " >> /tmp/resultado-$$ ; Unidade $2 >> /tmp/resultado-$$ ;;
esac ;;
4) case $Dezena$Unidade in
40) echo -n "quarenta" >> /tmp/resultado-$$ ;;
4*) echo -n "quarenta e " >> /tmp/resultado-$$ ; Unidade $2 >> /tmp/resultado-$$ ;;
esac ;;
5) case $Dezena$Unidade in
50) echo -n "cinquenta" >> /tmp/resultado-$$ ;;
5*) echo -n "cinquenta e " >> /tmp/resultado-$$ ; Unidade $2 >> /tmp/resultado-$$ ;;
esac ;;
6) case $Dezena$Unidade in
60) echo -n "sessenta" >> /tmp/resultado-$$ ;;
6*) echo -n "sessenta e " >> /tmp/resultado-$$ ; Unidade $2 >> /tmp/resultado-$$ ;;
esac ;;
7) case $Dezena$Unidade in
70) echo -n "setenta" >> /tmp/resultado-$$ ;;
7*) echo -n "setenta e " >> /tmp/resultado-$$ ; Unidade $2 >> /tmp/resultado-$$ ;;
esac ;;
8) case $Dezena$Unidade in
80) echo -n "oitenta" >> /tmp/resultado-$$ ;;
8*) echo -n "oitenta e " >> /tmp/resultado-$$ ; Unidade $2 >> /tmp/resultado-$$ ;;
esac ;;
9) case $Dezena$Unidade in
90) echo -n "noventa" >> /tmp/resultado-$$ ;;
9*) echo -n "noventa e " >> /tmp/resultado-$$ ; Unidade $2 >> /tmp/resultado-$$ ;;
esac ;;
esac
}
# Função para ler as dezenas de datas:
DezenaData () {
# Coletando o número da dezena:
Dezena=`cat /tmp/valor-$$ | cut -c$1`
# Coletando o número da unidade:
Unidade=`cat /tmp/valor-$$ | cut -c$2`
case $Dezena in
0) case $Dezena$Unidade in
0) echo -n "0" > /dev/null ;;
0*) UnidadeData $2 >> /tmp/resultado-$$ ;;
esac ;;
1) case $Dezena$Unidade in
10) echo -n "déz" >> /tmp/resultado-$$ ;;
11) echo -n "onze" >> /tmp/resultado-$$ ;;
12) echo -n "doze" >> /tmp/resultado-$$ ;;
13) echo -n "treze" >> /tmp/resultado-$$ ;;
14) echo -n "catorze" >> /tmp/resultado-$$ ;;
15) echo -n "quinze" >> /tmp/resultado-$$ ;;
16) echo -n "dezeseis" >> /tmp/resultado-$$ ;;
17) echo -n "dezesete" >> /tmp/resultado-$$ ;;
18) echo -n "dezoito" >> /tmp/resultado-$$ ;;
19) echo -n "dezenove" >> /tmp/resultado-$$ ;;
esac ;;
2) case $Dezena$Unidade in
20) echo -n "vinte" >> /tmp/resultado-$$ ;;
2*) echo -n "vinte e " >> /tmp/resultado-$$ ; Unidade $2 >> /tmp/resultado-$$ ;;
esac ;;
3) case $Dezena$Unidade in
30) echo -n "trinta" >> /tmp/resultado-$$ ;;
3*) echo -n "trinta e " >> /tmp/resultado-$$ ; Unidade $2 >> /tmp/resultado-$$ ;;
esac ;;
4) case $Dezena$Unidade in
40) echo -n "quarenta" >> /tmp/resultado-$$ ;;
4*) echo -n "quarenta e " >> /tmp/resultado-$$ ; Unidade $2 >> /tmp/resultado-$$ ;;
esac ;;
5) case $Dezena$Unidade in
50) echo -n "cinquenta" >> /tmp/resultado-$$ ;;
5*) echo -n "cinquenta e " >> /tmp/resultado-$$ ; Unidade $2 >> /tmp/resultado-$$ ;;
esac ;;
6) case $Dezena$Unidade in
60) echo -n "sessenta" >> /tmp/resultado-$$ ;;
6*) echo -n "sessenta e " >> /tmp/resultado-$$ ; Unidade $2 >> /tmp/resultado-$$ ;;
esac ;;
7) case $Dezena$Unidade in
70) echo -n "setenta" >> /tmp/resultado-$$ ;;
7*) echo -n "setenta e " >> /tmp/resultado-$$ ; Unidade $2 >> /tmp/resultado-$$ ;;
esac ;;
8) case $Dezena$Unidade in
80) echo -n "oitenta" >> /tmp/resultado-$$ ;;
8*) echo -n "oitenta e " >> /tmp/resultado-$$ ; Unidade $2 >> /tmp/resultado-$$ ;;
esac ;;
9) case $Dezena$Unidade in
90) echo -n "noventa" >> /tmp/resultado-$$ ;;
9*) echo -n "noventa e " >> /tmp/resultado-$$ ; Unidade $2 >> /tmp/resultado-$$ ;;
esac ;;
esac
}
# Função para ler as dezenas de horas. A meia noite deve escrever zero hora:
DezenaHora () {
# Coletando o número da dezena:
Dezena=`cat /tmp/valor-$$ | cut -c$1`
# Coletando o número da unidade:
Unidade=`cat /tmp/valor-$$ | cut -c$2`
case $Dezena in
0) case $Dezena$Unidade in
0) echo -n "zero" >> /tmp/resultado-$$ ;;
0*) UnidadeHora $2 >> /tmp/resultado-$$ ;;
esac ;;
1) case $Dezena$Unidade in
10) echo -n "déz" >> /tmp/resultado-$$ ;;
11) echo -n "onze" >> /tmp/resultado-$$ ;;
12) echo -n "doze" >> /tmp/resultado-$$ ;;
13) echo -n "treze" >> /tmp/resultado-$$ ;;
14) echo -n "catorze" >> /tmp/resultado-$$ ;;
15) echo -n "quinze" >> /tmp/resultado-$$ ;;
16) echo -n "dezeseis" >> /tmp/resultado-$$ ;;
17) echo -n "dezesete" >> /tmp/resultado-$$ ;;
18) echo -n "dezoito" >> /tmp/resultado-$$ ;;
19) echo -n "dezenove" >> /tmp/resultado-$$ ;;
esac ;;
2) case $Dezena$Unidade in
20) echo -n "vinte" >> /tmp/resultado-$$ ;;
2*) echo -n "vinte e " >> /tmp/resultado-$$ ; UnidadeHora $2 >> /tmp/resultado-$$ ;;
esac ;;
3) case $Dezena$Unidade in
30) echo -n "trinta" >> /tmp/resultado-$$ ;;
3*) echo -n "trinta e " >> /tmp/resultado-$$ ; UnidadeHora $2 >> /tmp/resultado-$$ ;;
esac ;;
4) case $Dezena$Unidade in
40) echo -n "quarenta" >> /tmp/resultado-$$ ;;
4*) echo -n "quarenta e " >> /tmp/resultado-$$ ; UnidadeHora $2 >> /tmp/resultado-$$ ;;
esac ;;
5) case $Dezena$Unidade in
50) echo -n "cinquenta" >> /tmp/resultado-$$ ;;
5*) echo -n "cinquenta e " >> /tmp/resultado-$$ ; UnidadeHora $2 >> /tmp/resultado-$$ ;;
esac ;;
6) case $Dezena$Unidade in
60) echo -n "sessenta" >> /tmp/resultado-$$ ;;
6*) echo -n "sessenta e " >> /tmp/resultado-$$ ; UnidadeHora $2 >> /tmp/resultado-$$ ;;
esac ;;
7) case $Dezena$Unidade in
70) echo -n "setenta" >> /tmp/resultado-$$ ;;
7*) echo -n "setenta e " >> /tmp/resultado-$$ ; UnidadeHora $2 >> /tmp/resultado-$$ ;;
esac ;;
8) case $Dezena$Unidade in
80) echo -n "oitenta" >> /tmp/resultado-$$ ;;
8*) echo -n "oitenta e " >> /tmp/resultado-$$ ; UnidadeHora $2 >> /tmp/resultado-$$ ;;
esac ;;
9) case $Dezena$Unidade in
90) echo -n "noventa" >> /tmp/resultado-$$ ;;
9*) echo -n "noventa e " >> /tmp/resultado-$$ ; UnidadeHora $2 >> /tmp/resultado-$$ ;;
esac ;;
esac
}
# Função para ler até 999:
Centena () {
# Coletando o número da centena:
Centena=`cat /tmp/valor-$$ | cut -c$1`
# Coletando o número da dezena:
Dezena=`cat /tmp/valor-$$ | cut -c$2`
# Coletando o número da unidade:
Unidade=`cat /tmp/valor-$$ | cut -c$3`
case $Centena in
0) case $Centena$Dezena$Unidade in
0) echo -n "0" > /dev/null ;;
0*) Dezena $2 $3 >> /tmp/resultado-$$ ;;
esac ;;
1) case $Centena$Dezena$Unidade in
100) echo -n "cem" >> /tmp/resultado-$$ ;;
1*) echo -n "cento e " >> /tmp/resultado-$$ ; Dezena $2 $3 >> /tmp/resultado-$$ ;;
esac ;;
2)case $Centena$Dezena$Unidade in
200) echo -n "duzentos" >> /tmp/resultado-$$ ;;
2*) echo -n "duzentos e " >> /tmp/resultado-$$ ; Dezena $2 $3 >> /tmp/resultado-$$ ;;
esac ;;
3) case $Centena$Dezena$Unidade in
300) echo -n "trezentos" >> /tmp/resultado-$$ ;;
3*) echo -n "trezentos e " >> /tmp/resultado-$$ ; Dezena $2 $3 >> /tmp/resultado-$$ ;;
esac ;;
4) case $Centena$Dezena$Unidade in
400) echo -n "quatrocentos" >> /tmp/resultado-$$ ;;
4*) echo -n "quatrocentos e " >> /tmp/resultado-$$ ; Dezena $2 $3 >> /tmp/resultado-$$ ;;
esac ;;
5) case $Centena$Dezena$Unidade in
500) echo -n "quinhentos" >> /tmp/resultado-$$ ;;
5*) echo -n "quinhentos e " >> /tmp/resultado-$$ ; Dezena $2 $3 >> /tmp/resultado-$$ ;;
esac ;;
6) case $Centena$Dezena$Unidade in
600) echo -n "seiscentos" >> /tmp/resultado-$$ ;;
6*) echo -n "seiscentos e " >> /tmp/resultado-$$ ; Dezena $2 $3 >> /tmp/resultado-$$ ;;
esac ;;
7) case $Centena$Dezena$Unidade in
700) echo -n "setecentos" >> /tmp/resultado-$$ ;;
7*) echo -n "setecentos e " >> /tmp/resultado-$$ ; Dezena $2 $3 >> /tmp/resultado-$$ ;;
esac ;;
8) case $Centena$Dezena$Unidade in
800) echo -n "oitocentos" >> /tmp/resultado-$$ ;;
8*) echo -n "oitocentos e " >> /tmp/resultado-$$ ; Dezena $2 $3 >> /tmp/resultado-$$ ;;
esac ;;
9) case $Centena$Dezena$Unidade in
900) echo -n "novecentos" >> /tmp/resultado-$$ ;;
9*) echo -n "novecentos e " >> /tmp/resultado-$$ ; Dezena $2 $3 >> /tmp/resultado-$$ ;;
esac ;;
esac
}
# Função para inserir as concordâncias nominais após os valores numéricos lidos em cada unidade, dezena ou centena.
# NOTE - Deve ser chamada sempre após a leitura da unidade, dezena ou centena, nunca antes da leitura.
ConcordanciaCentenaNumerica () {
# Deve receber como parâmetro a posição da centena que está sendo lida:
case $1 in
1) case $ValorCentena in
1) echo -n "" >>/tmp/resultado-$$ ;;
*) echo -n "" >>/tmp/resultado-$$ ;;
esac ;;
2) case $ValorCentena in
000) echo -n " de " >>/tmp/resultado-$$ ;;
*) echo -n " mil e " >>/tmp/resultado-$$ ;;
esac ;;
3) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " milhão, " >>/tmp/resultado-$$ ;;
*) echo -n " milhões, " >>/tmp/resultado-$$ ;;
esac ;;
4) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " bilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " bilhões, " >>/tmp/resultado-$$ ;;
esac ;;
5) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " trilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " trilhões, " >>/tmp/resultado-$$ ;;
esac ;;
6) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " quadrilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " quadrilhões, " >>/tmp/resultado-$$ ;;
esac ;;
7) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " quintilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " quintilhões, " >>/tmp/resultado-$$ ;;
esac ;;
8) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " sextilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " sextilhões, " >>/tmp/resultado-$$ ;;
esac ;;
9) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " setilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " setilhões, " >>/tmp/resultado-$$ ;;
esac ;;
10) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " octilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " octilhões, " >>/tmp/resultado-$$ ;;
esac ;;
11) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " nonilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " nonilhões, " >>/tmp/resultado-$$ ;;
esac ;;
12) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " decilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " decilhões, " >>/tmp/resultado-$$ ;;
esac ;;
13) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " undecilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " undecilhões, " >>/tmp/resultado-$$ ;;
esac ;;
14) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " duodecilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " duodecilhões, " >>/tmp/resultado-$$ ;;
esac ;;
15) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " tredecilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " tredecilhões, " >>/tmp/resultado-$$ ;;
esac ;;
16) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " quatordecilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " quatordecilhões, " >>/tmp/resultado-$$ ;;
esac ;;
17) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " quindecilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " quindecilhões, " >>/tmp/resultado-$$ ;;
esac ;;
18) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " sexdecilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " sexdecilhões, " >>/tmp/resultado-$$ ;;
esac ;;
19) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " setedecilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " setedecilhões, " >>/tmp/resultado-$$ ;;
esac ;;
20) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " octodecilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " octodecilhões, " >>/tmp/resultado-$$ ;;
esac ;;
21) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " novedecilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " novedecilhões, " >>/tmp/resultado-$$ ;;
esac ;;
21) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " vigesilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " vigesilhões, " >>/tmp/resultado-$$ ;;
esac ;;
esac
}
# Função para inserir as concordâncias nominais após os valores monetários lidos em cada unidade, dezena ou centena.
# NOTE - Deve ser chamada sempre após a leitura da unidade, dezena ou centena, nunca antes da leitura.
ConcordanciaCentenaMonetaria () {
# Deve receber como parâmetro a posição da centena que está sendo lida:
case $1 in
1) case $ValorCentena in
1) echo -n " real " >>/tmp/resultado-$$ ;;
*) echo -n " reais " >>/tmp/resultado-$$ ;;
esac ;;
2) case $ValorCentena in
000) echo -n " de " >>/tmp/resultado-$$ ;;
*) echo -n " mil e " >>/tmp/resultado-$$ ;;
esac ;;
3) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " milhão, " >>/tmp/resultado-$$ ;;
*) echo -n " milhões, " >>/tmp/resultado-$$ ;;
esac ;;
4) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " bilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " bilhões, " >>/tmp/resultado-$$ ;;
esac ;;
5) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " trilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " trilhões, " >>/tmp/resultado-$$ ;;
esac ;;
6) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " quadrilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " quadrilhões, " >>/tmp/resultado-$$ ;;
esac ;;
7) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " quintilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " quintilhões, " >>/tmp/resultado-$$ ;;
esac ;;
8) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " sextilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " sextilhões, " >>/tmp/resultado-$$ ;;
esac ;;
9) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " setilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " setilhões, " >>/tmp/resultado-$$ ;;
esac ;;
10) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " octilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " octilhões, " >>/tmp/resultado-$$ ;;
esac ;;
11) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " nonilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " nonilhões, " >>/tmp/resultado-$$ ;;
esac ;;
12) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " decilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " decilhões, " >>/tmp/resultado-$$ ;;
esac ;;
13) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " undecilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " undecilhões, " >>/tmp/resultado-$$ ;;
esac ;;
14) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " duodecilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " duodecilhões, " >>/tmp/resultado-$$ ;;
esac ;;
15) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " tredecilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " tredecilhões, " >>/tmp/resultado-$$ ;;
esac ;;
16) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " quatordecilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " quatordecilhões, " >>/tmp/resultado-$$ ;;
esac ;;
17) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " quindecilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " quindecilhões, " >>/tmp/resultado-$$ ;;
esac ;;
18) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " sexdecilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " sexdecilhões, " >>/tmp/resultado-$$ ;;
esac ;;
19) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " setedecilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " setedecilhões, " >>/tmp/resultado-$$ ;;
esac ;;
20) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " octodecilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " octodecilhões, " >>/tmp/resultado-$$ ;;
esac ;;
21) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " novedecilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " novedecilhões, " >>/tmp/resultado-$$ ;;
esac ;;
21) case $ValorCentena in
000) echo -n "" > /dev/null ;;
1) echo -n " vigesilhão, " >>/tmp/resultado-$$ ;;
*) echo -n " vigesilhões, " >>/tmp/resultado-$$ ;;
esac ;;
esac
}
# Função para ler os meses do ano:
Meses () {
# O número do mês deve ser passado por parâmetro em $1
case $1 in
1|01) echo -n "Janeiro" >> /tmp/resultado-$$ ;;
2|02) echo -n "fevereiro" >> /tmp/resultado-$$ ;;
3|03) echo -n "março" >> /tmp/resultado-$$ ;;
4|04) echo -n "abril" >> /tmp/resultado-$$ ;;
5|05) echo -n "maio" >> /tmp/resultado-$$ ;;
6|06) echo -n "junho" >> /tmp/resultado-$$ ;;
7|07) echo -n "julho" >> /tmp/resultado-$$ ;;
8|08) echo -n "agosto" >> /tmp/resultado-$$ ;;
9|09) echo -n "setembro" >> /tmp/resultado-$$ ;;
10) echo -n "outubro" >> /tmp/resultado-$$ ;;
11) echo -n "novembro" >> /tmp/resultado-$$ ;;
12) echo -n "dezembro" >> /tmp/resultado-$$ ;;
*) echo "ERRO [ $2 ] parâmetro incorreto para meses do ano (1-12)" > /tmp/resultado-$$ ;;
esac
}
# Função que mostra o resultado na tela depois que os valores foram lidos:
MostraResultado () {
# Exibindo o resultado:
Resultado=`cat /tmp/resultado-$$`
echo "$Resultado"
}
# Função que remove todos os arquivos temporários criados durante a execução do script:
RemoveTemporarios () {
# Removendo os arquivos temporários:
rm -Rf /tmp/*-$$
}
#-------------------------------------------------------------------------------------
# Tratando somene as opções de ajuda:
case $1 in
#-------------------------------------------------------------------------------------
# Mostra a ajuda geral e sai do script:
-h|--help)
clear
echo "$Ajuda $Opcoes"
echo
exit 0 ;;
#-------------------------------------------------------------------------------------
# Mostra a versão atual do script e sai:
-v|--versao)
clear
echo " [`basename $0`]"
echo
# Buscando a versão:
grep '^# Versão ' "$0" | tail -1 | cut -d : -f 1 | tr -d \#
# Buscando o autor e a data:
grep '^# Versão ' "$0" | tail -1 | cut -d : -f 2 | tr -d \#
echo
# Buscando a descrição da versão:
grep '^# Versão ' "$0" | tail -1 | cut -d : -f 3 | tr -d \#
echo
exit 0 ;;
#-------------------------------------------------------------------------------------
# Mostra exemplos de execução do script e sai:
-e|--exemplo)
clear
echo " [`basename $0`]"
echo
echo " Voce pode executar este script das seguntes formas:"
echo "$Exemplos"
echo
exit 0 ;;
#-------------------------------------------------------------------------------------
# Lista todas as dependências do script e verifica quais estão faltando. Após sai:
-d|--depende)
clear
echo " [`basename $0`]"
echo
# Aqui está a lista de dependências do script:
Dependencias="
cat
tac
seq
grep
mv
cut
sed
wc
bc
tee
rm
"
# Exibindo a lista de dependências:
echo " =============================================================="
echo " Este script posui as seguintes dependências:"
echo " $Dependencias"
echo " =============================================================="
echo " Verificando se todas as dependênicas estão satisfeitas:"
echo
# Retornando o IFS normal para o for poder trabalhar com espaços como delimitadores de string:
IFS="$Ifsvelho"
for x in "$Dependencias" ; do
# Verificando se a dependência está instalada:
which $x >&2> /dev/null
if [ $? = 0 ]; then
touch /tmp/depende-$$
else
echo "$x" >> /tmp/depende-$$
fi
done
# Modificando novamente o IFS para ler nomes com espaços:
IFS='
'
# Caso foi encontrado alguma dependência faltando no sistema, coloca-se elas em uma variável e se da a mensagem final antes de sair do script:
Depende=`cat /tmp/depende-$$`
if [ ! -z $Depende ]; then
echo " ÔÔPss!"
echo " Foram ecnontradas as seguintes dependências em seu sistema:"
echo " $Depende"
echo " Caso o script não consiga resolvê-las, instalá-las manualmente"
echo
rm -Rf /tmp/*-$$
else
echo " OK"
echo " Todas as dependências necessárias foram satisfeitas"
echo
rm -Rf /tmp/*-$$
fi
exit 0 ;;
#-------------------------------------------------------------------------------------
# Aqui ele simplismente ignora a opção e passa a diante entrando no while de processamento, pois todas as opções a baixo são as opções de leitura de números. Se ele sair aqui ele nunca irá processar nada a não ser as opções de ajuda:
-n|--numero) echo "" > /dev/null ;;
-V|--valor) echo "" > /dev/null ;;
-D|--data) echo "" > /dev/null ;;
-H|--hora) echo "" > /dev/null ;;
-s|--semana) echo "" > /dev/null ;;
-m|--mes) echo "" > /dev/null ;;
#-------------------------------------------------------------------------------------
# Caso seja passado uma opção desconhecida, da a mensagem de erro e sai:
*)
if test -n "$1" ; then # Ou if [ -n "$1" ]; then
clear
echo "Opção inválida [ $1 ]"
echo "Utilize as seguntes opções $Opcoes"
echo
exit 1
fi ;;
esac
# Fazendo a leitura dos dados de acordo com as opções passadas:
# Se o usuário não passou a opção e o parâmetro necessário para o processamento, simplesmente não faz nada:
while [ -n "$1" ] && [ -n "$2" ] ; do
case "$1" in
#-------------------------------------------------------------------------------------
-n|--numero)
# Preparando o número a ser escrito por extenso:
echo $2 > /tmp/valor-$$
# Verificando se o usuário digitou algo:
grep [0123456789] /tmp/valor-$$ > /dev/null
[ $? != 0 ] && echo "ERRO = Nenhum número encontrado para processar" > /tmp/resultado-$$
# Verificando se o usuário digitou letras:
grep -i [abcdefghijlmnopqrstuvxzywk] /tmp/valor-$$ > /dev/null
[ $? = 0 ] && echo "ERRO = Número inválido, possui letras" > /tmp/resultado-$$
# Apagando todos os zeros que por ventura o usuário tenha digitado a esquerda e que não possuem valor. Ex.: 000010,32
cat /tmp/valor-$$ | sed 's/^0\+//g' > /tmp/sem-zeros-esquerda-$$
mv /tmp/sem-zeros-esquerda-$$ /tmp/valor-$$
# Iniciando a leitura dos números:
# Verificando se tem vírgula, se tiver pega só o que está após a vírgula e processa:
grep "\," /tmp/valor-$$ > /dev/null
# Caso o número digitado tenha vírgula:
if [ $? = 0 ] ; then
# Pegando somente as casas decimais para guardar para ser processado depois:
CasasDecimais=`cat /tmp/valor-$$ | cut -d',' -f2`
# Pegando os números inteiros sem os pontos para processar agora:
Numero=`cat /tmp/valor-$$ | sed 's/\.//g' | cut -d',' -f1`
# Colocando somente os números inteiros no arquivo de /tmp/valor-$$:
echo "$Numero" > /tmp/valor-$$
# Contando os caracteres dos números inteiros:
Caracteres=`cat /tmp/valor-$$ | wc -c`
CaracteresReal=$((Caracteres - 1))
# Se a quantidade de caracteres for maior do que três então divide em blocos de três:
if [ "$CaracteresReal" -ge 4 ] ; then
# Zerando a contágem dos arquivos temporários de referência:
CentenaInteiros="0"
# Dividindo de três em três para fazer a leiutura:
while [ "$CaracteresReal" -ge 3 ] ; do
# Contando a centena de inteiros:
CentenaInteiros=$((CentenaInteiros + 1))
# Diminuindo 3 caracteres do total e marcando no nome de um arquivo temporário só como referência:
CaracteresReal=$(echo "$CaracteresReal - 3" | bc | tee /tmp/centena-$CentenaInteiros-$$)
done
# Contando quantas centena inteiras de três dígitos temos para ler:
CentenasInteiraALer=`ls -1 /tmp/centena-*-$$ | wc -l`
# Caso tenha sobrado algo, inicie a leitura por aqui:
[ "$CaracteresReal" != "0" ] && {
# Definindo qual será o caracter final da dezena, como sobraram no máximo 2 caracteres então o caractere inicial é 1 e o final é igual ao número de caracteres que sobrou dentro da variável CaracteresReal:
CaracterFinal=$CaracteresReal
# Pegando somente os dígitos que sobraram na última centena:
ValorCentena=`echo $Numero | cut -c1-$CaracterFinal`
# Colocando o valor da centena no arquivo /tmp/valor-$$ pois as funções de leitura só trabalham em cima desse arquivo:
echo "$ValorCentena" > /tmp/valor-$$
# Chamando a função corespondente para leitura:
case $CaracteresReal in
1) Unidade 1 ;;
2) Dezena 1 2 ;;
3) Centena 1 2 3 ;;
esac
# Encontrando a posição da centena para inserir a concordância correta:
PosicaoCentena=$((CentenasInteiraALer + 1))
# Inserindo a concordância:
ConcordanciaCentenaNumerica $PosicaoCentena >> /tmp/resultado-$$
#Definindo o caracter inicial para a próxima centena:
CaracterInicial=$((CaracterFinal + 1))
}
# Fazendo a leitura das outras centenas de 3 dígitos cada. Aqui é preciso inverter a sequência gerada pelo seq, pois é com base nela que a função ConcordanciaCentena trabalha:
for x in `seq 1 $CentenasInteiraALer | tac` ; do
# Definindo o caractere inicial caso não tenha sobrado nada na separação por centenas:
[ "$CaracterInicial" ] || CaracterInicial="1"
# Definindo o caracter final para esta centena que está sendo processada:
CaracterFinal=$((CaracterInicial + 2))
# Coletando os caracteres para serem lidos:
ValorCentena=`echo $Numero | cut -c$CaracterInicial-$CaracterFinal`
# Colocando o valor da centena no arquivo /tmp/valor-$$ pois as funções de leitura só trabalham em cima desse arquivo:
echo "$ValorCentena" > /tmp/valor-$$
# Como aqui dentro do for todas as centenas terão 3 dígitos, basta chamar a função Centena com seus parâmetros necessários:
Centena 1 2 3
# Inserindo a concordância de acordo com a sequência gerada pelo seq e invertida pelo tac:
ConcordanciaCentenaNumerica $x # >> /tmp/resultado-$$
#Definindo o caracter inicial para a próxima centena:
CaracterInicial=$((CaracterFinal + 1))
done
else
# Caso o número a ser lido tenha no máximo 3 caracteres então não foi preciso divií-lo de 3 em 3 no processo acima. Então agora basta chamando a função corespondente de acordo com a quantidade real de caracteres que o número possui:
case $CaracteresReal in
1) Unidade 1 ; ConcordanciaCentenaNumerica 1 ;;
2) Dezena 1 2 ; ConcordanciaCentenaNumerica 1 ;;
3) Centena 1 2 3 ; ConcordanciaCentenaNumerica 1 ;;
esac
fi
# Feito a leitura de todas as centenas dos números inteiros e já inserido suas respectivas concordâncias, agora é hora de ler as casas decimais pois o número possuia uma vírgula.
# Se o valor das casas decimais for 00 não deve executar a leitura:
[ "$CasasDecimais" != "00" ] && {
# Contando quantos caracteres possui a casa decimal:
CaracterDecimal=`echo "$CasasDecimais" | wc -c`
CaracterDecimalReal=$((CaracterDecimal - 1))
# Se o valor das casas decimais só tiver um único dígito (ex.: 14,3), então complete com zero:
[ $CaracterDecimalReal -lt 2 ] && CasasDecimais=`echo $CasasDecimais{FONTE}`
# Colocando somente as casas decimais no arquivo de /tmp/valor-$$ pois as funções de leitura só trabalham em cima desse arquivo:
echo "$CasasDecimais" > /tmp/valor-$$
# Inserindo a concordância entre os números inteiros e as casas decimais no arquivo de resultado:
echo -n " vígula " >>/tmp/resultado-$$
# Fazendo a leitura do valor das casas decimais. Como será lido somente dois dígitos, então basta chamar a função Dezena com seus parâmetros necessários:
Dezena 1 2
}
# Caso o número digitado não tenha vírgula:
else
# Eliminando os pontos separadores de milhar caso o usuário os tenha digitado:
Numero=`cat /tmp/valor-$$ | sed 's/\.//g'`
# Colocando somente os números inteiros no arquivo de /tmp/valor-$$ pois as funções de leitura só trabalham em cima desse arquivo:
echo "$Numero" > /tmp/valor-$$
# Contando quantos caracteres compões o número:
Caracteres=`cat /tmp/valor-$$ | wc -c`
# Diminuindo o caracter de espaço ou nova linha que é inserido automaticamente quando se redireciona algo para um arquivo de texto:
CaracteresReal=$((Caracteres - 1))
# Se a quantidade de caracteres for maior do que três então divide em blocos de três:
if [ "$CaracteresReal" -ge 4 ] ; then
# Zerando a contágem das centenas dos números inteiros:
CentenaInteiros="0"
# Dividindo de três em três para fazer a leiutura:
while [ "$CaracteresReal" -ge 3 ] ; do
# Contando a centena de inteiros:
CentenaInteiros=$((CentenaInteiros + 1))
# Diminuindo 3 caracteres do total e marcando em um arquivo temporário:
CaracteresReal=$(echo "$CaracteresReal - 3" | bc | tee /tmp/centena-$CentenaInteiros-$$)
done
# Contando quantas centena inteiras de três dígitos temos para ler:
CentenasInteiraALer=`ls -1 /tmp/centena-*-$$ | wc -l`
# Caso tenha sobrado algo, inicie a leitura por aqui:
[ "$CaracteresReal" != "0" ] && {
# Definindo qual será o caracter final da dezena, como sobraram no máximo 2 caracteres então o caractere inicial é 1 o o final é igual ao número de caracteres que sobrou:
CaracterFinal=$CaracteresReal
# Pegando somente os dígitos que sobraram na última centena:
ValorCentena=`echo $Numero | cut -c1-$CaracterFinal`
# Colocando o valor da centena no arquivo /tmp/valor-$$:
echo "$ValorCentena" > /tmp/valor-$$
# Chamando a função corespondente para leitura:
case $CaracteresReal in
1) Unidade 1 ;;
2) Dezena 1 2 ;;
3) Centena 1 2 3 ;;
esac
# Encontrando a posição da centena para inserir a concordância:
PosicaoCentena=$((CentenasInteiraALer + 1))
# Inserindo a concordância:
ConcordanciaCentenaNumerica $PosicaoCentena >> /tmp/resultado-$$
#Definindo o caracter inicial para a próxima centena:
CaracterInicial=$((CaracterFinal + 1))
}
# Fazendo a leitura das outras centenas de 3 dígitos cada. Aqui é preciso inverter a sequência gerada pelo seq, pois é com base nela que a função ConcordanciaCentena trabalha:
for x in `seq 1 $CentenasInteiraALer | tac` ; do
# Definindo o caractere inicial caso não tenha sobrado nada na separação por centenas:
[ "$CaracterInicial" ] || CaracterInicial="1"
# Definindo o caracter final para esta centena que está sendo processada:
CaracterFinal=$((CaracterInicial + 2))
# Coletando os caracteres para serem lidos:
ValorCentena=`echo $Numero | cut -c$CaracterInicial-$CaracterFinal`
# Colocando o valor da centena no arquivo /tmp/valor-$$:
echo "$ValorCentena" > /tmp/valor-$$
# Chamando a função corespondente para leitura:
Centena 1 2 3
# Inserindo a concordância:
ConcordanciaCentenaNumerica $x # >> /tmp/resultado-$$
#Definindo o caracter inicial para a próxima centena:
CaracterInicial=$((CaracterFinal + 1))
done
else
# Caso o número a ser lido tenha no máximo 3 caracteres então não foi preciso dividí-lo de 3 em 3 no processo acima. Então agora basta chamando a função corespondente de acordo com a quantidade real de caracteres que o número possui:
# Coletando o valor da centena para servir de referência para a função ConcordanciaCentena:
ValorCentena=`cat /tmp/valor-$$`
# Aqui é preciso analizar quantos caracteres tem (unidade, dezena ou centena), chamar a função corespondente para fazer a leitura do número, e depois chamar a função ConcordanciaCentena para inserir a concordância final:
case $CaracteresReal in
1) Unidade 1 ; ConcordanciaCentenaNumerica 1 ;;
2) Dezena 1 2 ; ConcordanciaCentenaNumerica 1 ;;
3) Centena 1 2 3 ; ConcordanciaCentenaNumerica 1 ;;
esac
fi
fi
# Exibindo o resultado:
MostraResultado ;;
#-------------------------------------------------------------------------------------
-V|--valor)
# Preparando o número a ser escrito por extenso:
echo $2 > /tmp/valor-$$
# Verificando se o usuário digitou algo:
grep [0123456789] /tmp/valor-$$ > /dev/null
[ $? != 0 ] && echo "ERRO = Nenhum número encontrado para processar" > /tmp/resultado-$$
# Verificando se o usuário digitou letras:
grep -i [abcdefghijlmnopqrstuvxzywk] /tmp/valor-$$ > /dev/null
[ $? = 0 ] && echo "ERRO = Número inválido, possui letras" > /tmp/resultado-$$
# Apagando todos os zeros que por ventura o usuário tenha digitado a esquerda e que não possuem valor. Ex.: 000010,32
cat /tmp/valor-$$ | sed 's/^0\+//g' > /tmp/sem-zeros-esquerda-$$
mv /tmp/sem-zeros-esquerda-$$ /tmp/valor-$$
# Iniciando a leitura dos números:
# Verificando se tem vírgula, se tiver pega só o que está após a vírgula e processa:
grep "\," /tmp/valor-$$ > /dev/null
# Caso o número digitado tenha vírgula:
if [ $? = 0 ] ; then
# Pegando somente as casas decimais para guardar para ser processado depois:
CasasDecimais=`cat /tmp/valor-$$ | cut -d',' -f2`
# Pegando os números inteiros sem os pontos para processar agora:
Numero=`cat /tmp/valor-$$ | sed 's/\.//g' | cut -d',' -f1`
# Colocando somente os números inteiros no arquivo de /tmp/valor-$$:
echo "$Numero" > /tmp/valor-$$
# Contando os caracteres dos números inteiros:
Caracteres=`cat /tmp/valor-$$ | wc -c`
CaracteresReal=$((Caracteres - 1))
# Se a quantidade de caracteres for maior do que três então divide em blocos de três:
if [ "$CaracteresReal" -ge 4 ] ; then
# Zerando a contágem dos arquivos temporários de referência:
CentenaInteiros="0"
# Dividindo de três em três para fazer a leiutura:
while [ "$CaracteresReal" -ge 3 ] ; do
# Contando a centena de inteiros:
CentenaInteiros=$((CentenaInteiros + 1))
# Diminuindo 3 caracteres do total e marcando no nome de um arquivo temporário só como referência:
CaracteresReal=$(echo "$CaracteresReal - 3" | bc | tee /tmp/centena-$CentenaInteiros-$$)
done
# Contando quantas centena inteiras de três dígitos temos para ler:
CentenasInteiraALer=`ls -1 /tmp/centena-*-$$ | wc -l`
# Caso tenha sobrado algo, inicie a leitura por aqui:
[ "$CaracteresReal" != "0" ] && {
# Definindo qual será o caracter final da dezena, como sobraram no máximo 2 caracteres então o caractere inicial é 1 e o final é igual ao número de caracteres que sobrou dentro da variável CaracteresReal:
CaracterFinal=$CaracteresReal
# Pegando somente os dígitos que sobraram na última centena:
ValorCentena=`echo $Numero | cut -c1-$CaracterFinal`
# Colocando o valor da centena no arquivo /tmp/valor-$$ pois as funções de leitura só trabalham em cima desse arquivo:
echo "$ValorCentena" > /tmp/valor-$$
# Chamando a função corespondente para leitura:
case $CaracteresReal in
1) Unidade 1 ;;
2) Dezena 1 2 ;;
3) Centena 1 2 3 ;;
esac
# Encontrando a posição da centena para inserir a concordância correta:
PosicaoCentena=$((CentenasInteiraALer + 1))
# Inserindo a concordância:
ConcordanciaCentenaMonetaria $PosicaoCentena >> /tmp/resultado-$$
#Definindo o caracter inicial para a próxima centena:
CaracterInicial=$((CaracterFinal + 1))
}
# Fazendo a leitura das outras centenas de 3 dígitos cada. Aqui é preciso inverter a sequência gerada pelo seq, pois é com base nela que a função ConcordanciaCentena trabalha:
for x in `seq 1 $CentenasInteiraALer | tac` ; do
# Definindo o caractere inicial caso não tenha sobrado nada na separação por centenas:
[ "$CaracterInicial" ] || CaracterInicial="1"
# Definindo o caracter final para esta centena que está sendo processada:
CaracterFinal=$((CaracterInicial + 2))
# Coletando os caracteres para serem lidos:
ValorCentena=`echo $Numero | cut -c$CaracterInicial-$CaracterFinal`
# Colocando o valor da centena no arquivo /tmp/valor-$$ pois as funções de leitura só trabalham em cima desse arquivo:
echo "$ValorCentena" > /tmp/valor-$$
# Como aqui dentro do for todas as centenas terão 3 dígitos, basta chamar a função Centena com seus parâmetros necessários:
Centena 1 2 3
# Inserindo a concordância de acordo com a sequência gerada pelo seq e invertida pelo tac:
ConcordanciaCentenaMonetaria $x # >> /tmp/resultado-$$
#Definindo o caracter inicial para a próxima centena:
CaracterInicial=$((CaracterFinal + 1))
done
else
# Caso o número a ser lido tenha no máximo 3 caracteres então não foi preciso divií-lo de 3 em 3 no processo acima. Então agora basta chamando a função corespondente de acordo com a quantidade real de caracteres que o número possui:
case $CaracteresReal in
1) Unidade 1 ; ConcordanciaCentenaMonetaria 1 ;;
2) Dezena 1 2 ; ConcordanciaCentenaMonetaria 1 ;;
3) Centena 1 2 3 ; ConcordanciaCentenaMonetaria 1 ;;
esac
fi
# Feito a leitura de todas as centenas dos números inteiros e já inserido suas respectivas concordâncias, agora é hora de ler as casas decimais pois o número possuia uma vírgula.
# Se o valor das casas decimais for 00 não deve executar a leitura:
[ "$CasasDecimais" != "00" ] && {
# Contando quantos caracteres possui a casa decimal:
CaracterDecimal=`echo "$CasasDecimais" | wc -c`
CaracterDecimalReal=$((CaracterDecimal - 1))
# Se o valor das casas decimais só tiver um único dígito (ex.: 14,3), então complete com zero:
[ $CaracterDecimalReal -lt 2 ] && CasasDecimais=`echo $CasasDecimais{FONTE}`
# Colocando somente as casas decimais no arquivo de /tmp/valor-$$ pois as funções de leitura só trabalham em cima desse arquivo:
echo "$CasasDecimais" > /tmp/valor-$$
# Inserindo a concordância entre os números inteiros e as casas decimais no arquivo de resultado:
echo -n "com " >>/tmp/resultado-$$
# Fazendo a leitura do valor das casas decimais. Como será lido somente dois dígitos, então basta chamar a função Dezena com seus parâmetros necessários:
Dezena 1 2
# Inserindo a finalização de concordância:
echo -n " centavos" >>/tmp/resultado-$$
}
# Caso o número digitado não tenha vírgula:
else
# Eliminando os pontos separadores de milhar caso o usuário os tenha digitado:
Numero=`cat /tmp/valor-$$ | sed 's/\.//g'`
# Colocando somente os números inteiros no arquivo de /tmp/valor-$$ pois as funções de leitura só trabalham em cima desse arquivo:
echo "$Numero" > /tmp/valor-$$
# Contando quantos caracteres compões o número:
Caracteres=`cat /tmp/valor-$$ | wc -c`
# Diminuindo o caracter de espaço ou nova linha que é inserido automaticamente quando se redireciona algo para um arquivo de texto:
CaracteresReal=$((Caracteres - 1))
# Se a quantidade de caracteres for maior do que três então divide em blocos de três:
if [ "$CaracteresReal" -ge 4 ] ; then
# Zerando a contágem das centenas dos números inteiros:
CentenaInteiros="0"
# Dividindo de três em três para fazer a leiutura:
while [ "$CaracteresReal" -ge 3 ] ; do
# Contando a centena de inteiros:
CentenaInteiros=$((CentenaInteiros + 1))
# Diminuindo 3 caracteres do total e marcando em um arquivo temporário:
CaracteresReal=$(echo "$CaracteresReal - 3" | bc | tee /tmp/centena-$CentenaInteiros-$$)
done
# Contando quantas centena inteiras de três dígitos temos para ler:
CentenasInteiraALer=`ls -1 /tmp/centena-*-$$ | wc -l`
# Caso tenha sobrado algo, inicie a leitura por aqui:
[ "$CaracteresReal" != "0" ] && {
# Definindo qual será o caracter final da dezena, como sobraram no máximo 2 caracteres então o caractere inicial é 1 o o final é igual ao número de caracteres que sobrou:
CaracterFinal=$CaracteresReal
# Pegando somente os dígitos que sobraram na última centena:
ValorCentena=`echo $Numero | cut -c1-$CaracterFinal`
# Colocando o valor da centena no arquivo /tmp/valor-$$:
echo "$ValorCentena" > /tmp/valor-$$
# Chamando a função corespondente para leitura:
case $CaracteresReal in
1) Unidade 1 ;;
2) Dezena 1 2 ;;
3) Centena 1 2 3 ;;
esac
# Encontrando a posição da centena para inserir a concordância:
PosicaoCentena=$((CentenasInteiraALer + 1))
# Inserindo a concordância:
ConcordanciaCentenaMonetaria $PosicaoCentena >> /tmp/resultado-$$
#Definindo o caracter inicial para a próxima centena:
CaracterInicial=$((CaracterFinal + 1))
}
# Fazendo a leitura das outras centenas de 3 dígitos cada. Aqui é preciso inverter a sequência gerada pelo seq, pois é com base nela que a função ConcordanciaCentena trabalha:
for x in `seq 1 $CentenasInteiraALer | tac` ; do
# Definindo o caractere inicial caso não tenha sobrado nada na separação por centenas:
[ "$CaracterInicial" ] || CaracterInicial="1"
# Definindo o caracter final para esta centena que está sendo processada:
CaracterFinal=$((CaracterInicial + 2))
# Coletando os caracteres para serem lidos:
ValorCentena=`echo $Numero | cut -c$CaracterInicial-$CaracterFinal`
# Colocando o valor da centena no arquivo /tmp/valor-$$:
echo "$ValorCentena" > /tmp/valor-$$
# Chamando a função corespondente para leitura:
Centena 1 2 3
# Inserindo a concordância:
ConcordanciaCentenaMonetaria $x # >> /tmp/resultado-$$
#Definindo o caracter inicial para a próxima centena:
CaracterInicial=$((CaracterFinal + 1))
done
else
# Caso o número a ser lido tenha no máximo 3 caracteres então não foi preciso dividí-lo de 3 em 3 no processo acima. Então agora basta chamando a função corespondente de acordo com a quantidade real de caracteres que o número possui:
# Coletando o valor da centena para servir de referência para a função ConcordanciaCentena:
ValorCentena=`cat /tmp/valor-$$`
# Aqui é preciso analizar quantos caracteres tem (unidade, dezena ou centena), chamar a função corespondente para fazer a leitura do número, e depois chamar a função ConcordanciaCentena para inserir a concordância final:
case $CaracteresReal in
1) Unidade 1 ; ConcordanciaCentenaMonetaria 1 ;;
2) Dezena 1 2 ; ConcordanciaCentenaMonetaria 1 ;;
3) Centena 1 2 3 ; ConcordanciaCentenaMonetaria 1 ;;
esac
fi
fi
# Exibindo o resultado:
MostraResultado ;;
#-------------------------------------------------------------------------------------
-D|--data)
# Separando as partes de dia, mês e ano:
Dia=`echo $2 | cut -d'/' -f1`
Mes=`echo $2 | cut -d'/' -f2`
Ano=`echo $2 | cut -d'/' -f3`
# Verificando o mês inforamdo não maior do que 12:
[ $Mes -gt 12 ] && { echo "ERRO, UM ANO SÓ TEM 12 MÊSES" ; RemoveTemporarios ; exit 1 ; }
# Verificando se o ano é ou não bissexto:
if(( ("$Ano"%400)=="0")) || (( ("$Ano"%4=="0")&&("$Ano"%100!="0") )); then
# É bisexto:
Bissexto=1
else
# Não é bisexto:
Bissexto=0
fi
# Verificando o dia informado na data de acordo com a quantidade de dias do mês:
# Janeiro:
[ "$Mes" = "01" -a "$Dia" -gt 31 ] && { echo "ERRO, JANEIRO SÓ TEM 31 DIAS" ; RemoveTemporarios ; exit 1 ; }
# Fevereiro:
case $Bissexto in
0) [ "$Mes" = "02" -a "$Dia" -gt 28 ] && { echo "ERRO, FEVEREIRO EM ANOS NÃO BISEXTO SÓ TEM 28 DIAS" ; RemoveTemporarios ; exit 1 ; } ;;
1) [ "$Mes" = "02" -a "$Dia" -gt 29 ] && { echo "ERRO, FEVEREIRO EM ANOS BISEXTOS SÓ TEM 29 DIAS" ; RemoveTemporarios ; exit 1 ; } ;;
esac
# Março:
[ "$Mes" = "03" -a "$Dia" -gt 31 ] && { echo "ERRO, MARÇO SÓ TEM 31 DIAS" ; RemoveTemporarios ; exit 1 ; }
# Abril:
[ "$Mes" = "04" -a "$Dia" -gt 30 ] && { echo "ERRO, ABRIL SÓ TEM 30 DIAS" ; RemoveTemporarios ; exit 1 ; }
# Maio:
[ "$Mes" = "05" -a "$Dia" -gt 31 ] && { echo "ERRO, MAIO SÓ TEM 31 DIAS" ; RemoveTemporarios ; exit 1 ; }
# Junho:
[ "$Mes" = "06" -a "$Dia" -gt 30 ] && { echo "ERRO, JUNHO SÓ TEM 30 DIAS" ; RemoveTemporarios ; exit 1 ; }
# Julho:
[ "$Mes" = "07" -a "$Dia" -gt 31 ] && { echo "ERRO, JULHO SÓ TEM 31 DIAS" ; RemoveTemporarios ; exit 1 ; }
# Agosto:
[ "$Mes" = "08" -a "$Dia" -gt 31 ] && { echo "ERRO, AGOSTO SÓ TEM 31 DIAS" ; RemoveTemporarios ; exit 1 ; }
# Setembro:
[ "$Mes" = "09" -a "$Dia" -gt 30 ] && { echo "ERRO, SETEMBRO SÓ TEM 30 DIAS" ; RemoveTemporarios ; exit 1 ; }
# Outubro:
[ "$Mes" = "10" -a "$Dia" -gt 31 ] && { echo "ERRO, OUTUBRO SÓ TEM 31 DIAS" ; RemoveTemporarios ; exit 1 ; }
# Novembro:
[ "$Mes" = "11" -a "$Dia" -gt 30 ] && { echo "ERRO, NOVEMBRO SÓ TEM 30 DIAS" ; RemoveTemporarios ; exit 1 ; }
# Dezembro:
[ "$Mes" = "12" -a "$Dia" -gt 31 ] && { echo "ERRO, DEZEMBRO SÓ TEM 31 DIAS" ; RemoveTemporarios ; exit 1 ; }
# Fazendo a leitura do dia:
echo $Dia > /tmp/valor-$$
DezenaData 1 2
# Inserindo a concordância:
echo -n " de " >> /tmp/resultado-$$
# Fazendo a leitura do mês:
Meses $Mes
# Inserindo a concordância:
echo -n " do ano " >> /tmp/resultado-$$
# Fazendo a leitura do ano:
echo $Ano | sed 's/[0]\+/0/g' > /tmp/valor-$$
# Contando quantos caracteres compões o número:
Caracteres=`cat /tmp/valor-$$ | wc -c`
# Diminuindo o caracter de espaço ou nova linha que é inserido automaticamente quando se redireciona algo para um arquivo de texto:
CaracteresReal=$((Caracteres - 1))
# Se a quantidade de caracteres for maior do que três então divide em blocos de três:
if [ "$CaracteresReal" -ge 4 ] ; then
# Zerando a contágem das centenas dos números inteiros:
CentenaInteiros="0"
# Dividindo de três em três para fazer a leiutura:
while [ "$CaracteresReal" -ge 3 ] ; do
# Contando a centena de inteiros:
CentenaInteiros=$((CentenaInteiros + 1))
# Diminuindo 3 caracteres do total e marcando em um arquivo temporário:
CaracteresReal=$(echo "$CaracteresReal - 3" | bc | tee /tmp/centena-$CentenaInteiros-$$)
done
# Contando quantas centena inteiras de três dígitos temos para ler:
CentenasInteiraALer=`ls -1 /tmp/centena-*-$$ | wc -l`
# Caso tenha sobrado algo, inicie a leitura por aqui:
[ "$CaracteresReal" != "0" ] && {
# Definindo qual será o caracter final da dezena, como sobraram no máximo 2 caracteres então o caractere inicial é 1 o o final é igual ao número de caracteres que sobrou:
CaracterFinal=$CaracteresReal
# Pegando somente os dígitos que sobraram na última centena:
ValorCentena=`echo $Ano | cut -c1-$CaracterFinal`
# Colocando o valor da centena no arquivo /tmp/valor-$$:
echo "$ValorCentena" > /tmp/valor-$$
# Chamando a função corespondente para leitura:
case $CaracteresReal in
1) Unidade 1 ;;
2) Dezena 1 2 ;;
3) Centena 1 2 3 ;;
esac
# Encontrando a posição da centena para inserir a concordância:
PosicaoCentena=$((CentenasInteiraALer + 1))
# Inserindo a concordância:
ConcordanciaCentenaNumerica $PosicaoCentena >> /tmp/resultado-$$
#Definindo o caracter inicial para a próxima centena:
CaracterInicial=$((CaracterFinal + 1))
}
# Fazendo a leitura das outras centenas de 3 dígitos cada. Aqui é preciso inverter a sequência gerada pelo seq, pois é com base nela que a função ConcordanciaCentena trabalha:
for x in `seq 1 $CentenasInteiraALer | tac` ; do
# Definindo o caractere inicial caso não tenha sobrado nada na separação por centenas:
[ "$CaracterInicial" ] || CaracterInicial="1"
# Definindo o caracter final para esta centena que está sendo processada:
CaracterFinal=$((CaracterInicial + 2))
# Coletando os caracteres para serem lidos:
ValorCentena=`echo $Ano | cut -c$CaracterInicial-$CaracterFinal`
# Colocando o valor da centena no arquivo /tmp/valor-$$:
echo "$ValorCentena" > /tmp/valor-$$
# Chamando a função corespondente para leitura:
Centena 1 2 3
# Inserindo a concordância:
# NOTE Mudar para concordancia de números não monetários
ConcordanciaCentenaNumerica $x # >> /tmp/resultado-$$
#Definindo o caracter inicial para a próxima centena:
CaracterInicial=$((CaracterFinal + 1))
done
else
# Caso o número a ser lido tenha no máximo 3 caracteres então não foi preciso dividí-lo de 3 em 3 no processo acima. Então agora basta chamando a função corespondente de acordo com a quantidade real de caracteres que o número possui:
case $CaracteresReal in
1) Unidade 1 ;;
2) Dezena 1 2 ;;
3) Centena 1 2 3 ;;
esac
fi
# Exibindo o resultado:
MostraResultado ;;
#-------------------------------------------------------------------------------------
-H|--hora)
# Separando as partes de hora, minutos, e segundos:
Hora="`echo $2 | cut -d':' -f1`"
Minutos="`echo $2 | cut -d':' -f2`"
Segundos="`echo $2 | cut -d':' -f3`"
# Verificando se foi digitado letras na hora, se foi, remove os arquivos temporários e para tudo:
echo "$Hora" | grep -i [abcdefghijlmnopqrstuvxzywkç] > /dev/null && { echo "HORA INCORRETA, POSSUI LETRAS" ; RemoveTemporarios ; break ; }
# Verificando se foi digitado letras nos minutos, se foi, remove os arquivos temporários e para tudo:
echo "$Minutos" | grep -i [abcdefghijlmnopqrstuvxzywkç] > /dev/null && { echo "MINUTOS INCORRETOS, POSSUEM LETRAS" ; RemoveTemporarios ; break ; }
# Verificando se foi digitado letras nos segundo, se foi, remove o s arquivos temporários e para tudo:
echo "$Segundos" | grep -i [abcdefghijlmnopqrstuvxzywkç] > /dev/null && { echo "SEGUNDOS INCORRETOS, POSSUEM LETRAS" ; RemoveTemporarios ; break ; }
# Verificando se foi digitado mais de dois números para cada campo de hora/minuto/segundos:
# Hora:
[ `echo $Hora | wc -c` -gt 3 ] && { echo "HORA INCORRETA, POSSUI MUITOS NÚMEROS" ; RemoveTemporarios ; break ; }
# Minutos:
[ `echo $Minutos | wc -c` -gt 3 ] && { echo "MINUTOS INCORRETO, POSSUI MUITOS NÚMEROS" ; RemoveTemporarios ; break ; }
# Segundos:
[ `echo $Segundos | wc -c` -gt 3 ] && { echo "SEGUNDOS INCORRETOS, POSSUI MUITOS NÚMEROS" ; RemoveTemporarios ; break ; }
# Fazendo a verificação se a hora informada não é maior do que 23 e fazendo a leitura da hora:
if [ "$Hora" -le 23 ] ; then
# Inserindo a hora no arquivo /tmp/valor-$$ e retirando os zeros repetidos a esquerda:
echo $Hora | sed 's/[0]\+/0/g' > /tmp/valor-$$
# Lendo a hora:
DezenaHora 1 2
# Inserindo a concordância:
if [ "$Minutos" = "00" ] && [ "$Segundos" = "00" ] ; then
case $Hora in
00|01) echo -n " hora" >> /tmp/resultado-$$ ;;
*) echo -n " horas" >> /tmp/resultado-$$ ;;
esac
else
case $Hora in
00|01) echo -n " hora com " >> /tmp/resultado-$$ ;;
*) echo -n " horas com " >> /tmp/resultado-$$ ;;
esac
fi
else
# Da a mensagem de erro:
echo "ERRO NAS HORAS, O DIA SÓ TEM 24 HORAS"
# Remove todos os arquivos temporários:
RemoveTemporarios
# Para a execução do script:
break
fi
# Fazendo a verificação se os minutos informados não são maiores do que 59 e fazendo a leitura dos minutos:
if [ "$Minutos" -le 59 ] ; then
# Inserindo os minutos no arquivo /tmp/valor-$$ e retirando os zeros repetidos a esquerda:
echo $Minutos | sed 's/[0]\+/0/g' > /tmp/valor-$$
# Lendo a hora:
Dezena 1 2
# Inserindo a concordância:
if [ "$Segundos" = "00" ] ; then
case $Minutos in
00|01) echo -n " minuto" >> /tmp/resultado-$$ ;;
*) echo -n " minutos" >> /tmp/resultado-$$ ;;
esac
else
case $Minutos in
00|01) echo -n " minuto e " >> /tmp/resultado-$$ ;;
*) echo -n " minutos e " >> /tmp/resultado-$$ ;;
esac
fi
else
# Da a mensagem de erro:
echo "ERRO NOS MINUTOS, UMA HORA SÓ TEM 60 MINUTOS"
# Remove os arquivos temporários:
RemoveTemporarios
# Para a execução do script:
break
fi
# Fazendo a verificação se os segundos informados não são maiores do que 59 e fazendo a leitura dos segundos:
if [ "$Segundos" -le 59 ] ; then
# Inserindo os segundos no arquivo /tmp/valor-$$:
echo $Segundos | sed 's/[0]\+/0/g' > /tmp/valor-$$
# Lendo a hora:
Dezena 1 2
# Inserindo a concordância:
case $Segundos in
0|00) echo -n "" >> /dev/null ;;
1|01) echo -n " segundo" >> /tmp/resultado-$$ ;;
*) echo -n " segundos" >> /tmp/resultado-$$ ;;
esac
else
# Da a mensagem de erro:
echo "ERRO NOS SEGUNDOS, UM MINUTO SÓ TEM 60 SEGUNDOS"
# Remove os arquivos temporários:
RemoveTemporarios
# Para a execução do script:
break
fi
# Exibindo o resultado:
MostraResultado ;;
#-------------------------------------------------------------------------------------
-o|--ordem)
# Preparando o número a ser escrito por extenso:
echo $2 > /tmp/valor-$$
# Verificando se o usuário digitou algo:
grep [0123456789] /tmp/valor-$$ > /dev/null
[ $? != 0 ] && echo "ERRO = Nenhum número encontrado para processar" > /tmp/resultado-$$
# Verificando se o usuário digitou letras:
grep -i [abcdefghijlmnopqrstuvxzywk] /tmp/valor-$$ > /dev/null
[ $? = 0 ] && echo "ERRO = Número inválido, possui letras" > /tmp/resultado-$$
# Apagando todos os zeros que por ventura o usuário tenha digitado a esquerda e que não possuem valor. Ex.: 000010,32
cat /tmp/valor-$$ | sed 's/^0\+//g' > /tmp/sem-zeros-esquerda-$$
mv /tmp/sem-zeros-esquerda-$$ /tmp/valor-$$
DezenaOrdemMacho 1 2
# Exibindo o resultado:
MostraResultado ;;
#-------------------------------------------------------------------------------------
-s|--semana)
case $2 in
1) echo "domingo" > /tmp/resultado-$$ ;;
2) echo "segunda-feira" > /tmp/resultado-$$ ;;
3) echo "terça-feira" > /tmp/resultado-$$ ;;
4) echo "quarta-feira" > /tmp/resultado-$$ ;;
5) echo "quinta-feira" > /tmp/resultado-$$ ;;
6) echo "sexta-feira" > /tmp/resultado-$$ ;;
7) echo "sábado" > /tmp/resultado-$$ ;;
*) echo "ERRO [ $2 ] UMA SEMANA SÓ TEM 7 DIAS (1-7)" > /tmp/resultado-$$ ;;
esac
# Exibindo o resultado:
MostraResultado ;;
esac
#-------------------------------------------------------------------------------------
# Faz a fila de opções andar dois passos, pois cada opção necessita de seu parâmetro que deve ser processado juntamento com a opção chamada.
shift 2
done
#-------------------------------------------------------------------------------------
# Removendo os arquivos temporários:
RemoveTemporarios
Scripts recomendados
Efetua uma busca na rede por IPs(hosts) ativos
Comentários
Patrocínio
Site hospedado pelo provedor RedeHost.
Destaques
Artigos
Como extrair chaves TOTP 2FA a partir de QRCODE (Google Authenticator)
Linux em 2025: Segurança prática para o usuário
Desktop Linux em alta: novos apps, distros e privacidade marcam o sábado
IA chega ao desktop e impulsiona produtividade no mundo Linux
Novos apps de produtividade, avanços em IA e distros em ebulição agitam o universo Linux
Dicas
Como instalar o repositório do DBeaver no Ubuntu
Como instalar o Plex Media Server no Ubuntu
Digitando underscore com "shift" + "barra de espaços"
Como ativar a lixeira e recuperar aquivos deletados em um servidor Linux
Como mudar o nome de dispositivos Bluetooth via linha de comando
Tópicos
dpkg: erro: gatilho de arquivo duplicado chamado pelo arquivo de nome (6)
Instalação não está resolvendo as dependencias (2)
Captação de áudio no zorin linux começa a diminuir com o tempo (5)
Alternativas ao Multilogin para gerenciamento de múltiplas contas/prof... (0)
Top 10 do mês
-
Xerxes
1° lugar - 96.800 pts -
Fábio Berbert de Paula
2° lugar - 75.424 pts -
Alberto Federman Neto.
3° lugar - 23.811 pts -
edps
4° lugar - 21.843 pts -
Mauricio Ferrari
5° lugar - 21.336 pts -
Buckminster
6° lugar - 20.962 pts -
Alessandro de Oliveira Faria (A.K.A. CABELO)
7° lugar - 20.806 pts -
Andre (pinduvoz)
8° lugar - 18.212 pts -
Daniel Lara Souza
9° lugar - 17.619 pts -
Juliao Junior
10° lugar - 14.873 pts
Scripts
A maior comunidade GNU/Linux da América Latina! Artigos, dicas, tutoriais, fórum, scripts e muito mais. Ideal para quem busca auto-ajuda.
Site hospedado por:
