Mas em fim, para saber o tamanho do maior arquivo da pasta atual:
$ ls -l | awk '{print $5 }' | sort -n | tail -1
Para Saber os 10 maiores da pasta em ordem crescente:
$ ls -l | awk '{print $5 }' | sort -n | tail -10
Para saber os tamanho dos 10 maiores arquivos do sistema em ordem crescente:
$ls -lRa | awk '{print $5 }' | sort -n | tail -10
Para o maior do sistema:
Explicando a linha de comando acima:
$ls - lRa retorna todas as pastas e arquivos do sistema Sendo a primeira coluna as permissões em (wxr d) ( o modo do arquivo ) se é diretório (pasta) ou não (d) a segunda coluna é o número de ligações para o arquivo , a terceira coluna é o nome do proprietário do arquivo, a quarta é o nome do grupo ao qual o arquivo pertence, a quinta é o tamanho do arquivo em bytes, a sexta é o rótulo de tempo e a sétima é a outra parte do rótulo de tempo e a oitava é nome do arquivo
Como deseja-se saber apenas qual é o tamanho do maior arquivo seleciona-se a coluna 5, para isso utiliza-se do comando awk o {pint $5} é para selecionar apenas a coluna de tamanho, feito isso, ordena-se de maneira numérica (-n) com o comando sort
como precisa-se filtrar ainda mais a busca manda mostrar apenas os últimas 10 tamanhos com o comando tail
Se fosse mostrar os 10 menores arquivos utilizaria-se do head -10
de maneira que a linha de comando para mostrar o tamanho dos 1000 menores arquivos do sitema ficaria:
$ls -lRa | awk '{print $5 }' | sort -n | head -1000
Mas se você quer saber o nome dos 10 maiores arquivos, bem como o tamanho utilize:
$ls -lRa | awk '{print $5 $8 }' | sort -n | tail -10
Pra quem não sabe, na verdade awk é uma linguagem de programação:
para mais detalhes acesse:
http://www.inf.pucrs.br/~manssour/AWK/index.html
A linha abaixo é mais interessante:
$ ls -lRa | awk '{print $5"\t"$8"\t"$1"\t"$2"\t"$3"\t"$4"\t"$6"\t"$7 }' | sort -n |more| tail -100
Essa linha mostra os 100 maiores arquivos em ordem crescente ...
Após a dica do Professor Rafael Obelheiro ( de como encontrar os 5 processos que mais "consomem CPU e memória ..."):
"dica é ordenar os processos por consumo de CPU/memória:
$ ps axuwww | sort -k 3 -n # CPU
$ ps axuwww | sort -k 4 -n # memória
Você pode usar o tail para pegar as últimas N linhas da saída,
e cut/awk para selecionar os campos que interessam."
Cheguei as seguintes linhas de comando úteis, para ordenar os 50 processos que mais "consomem CPU e memória":
CPU:
ps axuwww | sort -k 4 -n |more| tail -5 |awk '{print$3"%CPU \t"$4"%MEM \t Command: "$11" \t"$12"\t PID:"$2"\t USER: "$1"\t STAT: "$8"\t Start: "$9"\t Time: "$10"\t VSZ: "$5"\t RSS: "$6"\t TTY: "$7 }'
Memória:
ps axuwww | sort -k 3 -n |more| tail -5 |awk '{print$3"%CPU \t"$4"%MEM \t Command: "$11" \t"$12"\t PID:"$2"\t USER: "$1"\t STAT: "$8"\t Start: "$9"\t Time: "$10"\t VSZ: "$5"\t RSS: "$6"\t TTY: "$7 }'
Já aproveitando ...
Para se realizar operações matemáticas:
$ echo $((1+2))
3
note que $() é para apresentar um comando qualquer e dentro de $() tem (), isso é para chamar o interpretador de operações aritméticas ...
Não é atoa que para fazer um simples incremento tenha que fazer na shell:
j12=$(($j12+1));
Outro detalhe interessante é o usar o if, normalmente usar o comando test
if test $k3 -eq $j12;
then k3=$(($k3+3));# echo -e " $j12 -eq $k3 \n k3=$k3 j12=$j12\n k é igual a j12 \n \n";
if test $k3 -gt 1;
then j12a=$(($j12a+1)); echo -e " zip FotosLivros.$j12a.zip $file2 $file2b $file2c ... \n ";
zip FotosLivros.$j12a.zip $file2 $file2b $file2c;
fi;
fi;
finalizar com fi
colocar o then se tiver else colocar o else também ...!
O test serve para testar operações aritméticas, comparações e por ai vai ...!
Outra coisinha interessante é o sed
$ echo "danilo matias o cara"|sed 's/a/4/g'
d4nilo m4ti4s o c4r4
s é para dizer que é stream substitui todos os a's por 4 o g é para dizer que são todas as ocorrências ...
Como usar o sed com um arquivo com muitas coisas para substituir ...:
$sed -f SaidaParaSed2HTML2 ArquivoAcolocarOsAcentos.html >> ArquivoComOsAcentosEmHTML.html
Ode o arquivo SaidaParaSed2HTML2. contém:
s/Á/\Á/g
s/á/\á/g
s/Â/\Â/g
s/â/\â/g
s/À/\À/g
s/à/\à/g
s/Å/\Å/g
s/å/\å/g
s/Ã/\Ã/g
s/ã/\ã/
s/Ä/\Ä/g
s/ä/\ä/g
s/Æ/\Æ/g
s/æ/\æ/g
s/É/\É/g
s/é/\é/g
s/Ê/\Ê/g
s/ê/\ê/g
s/È/\Egrave;/g
s/è/\è/g
s/Ë/\Ë/g
s/ë/\ë/g
s/Ð/\Ð/g
s/ð/\ð/g
s/Í/\Í/g
s/í/\í/g
s/Î/\Î/g
s/î/\î/g
s/Ì/\Ì/g
s/ì/\ì/g
s/Ï/\Ï/g
s/ï/\ï/g
s/Ó/\Ó/g
s/ó/\ó/g
s/Ô/\Ô/g
s/ô/\ô/g
s/Ò/\Ò/g
s/ò/\ò/g
s/Ø/\Ø/g
s/ø/\ø/g
s/Õ/\Õ/g
s/õ/\õ/g
s/Ö/\Ö/g
s/ö/\ö/g
s/Ú/\Ú/g
s/ú/\ú/g
s/Û/\Û/g
s/û/\û/g
s/Ù/\Ù/g
s/ù/\ù/g
s/Ü/\Ü/g
s/ü/\ü/g
s/Ç/\Ç/g
s/ç/\ç/g
s/Ñ/\Ñ/g
s/ñ/\ñ/g
s/®/\®/g
s/©/\©/g
s/Ý/\Ý/g
s/ý/\ý/g
s/Þ/\Þ/g
s/þ/\þ/g
s/ß/\ß/g
o \& é para o & não ser reconhecido como um comando & do linux
Linha de comando para tirar todas as linhas do arquivo:
teste.txt e salvar no arquivo temp.txt:
| $ | tr '\n' ' ' < teste.txt > temp.txt |
http://marofeiros.vilabol.uol.com.br/huffman.htm
Algoritmo de Huffman
A compressão pelo algoritmo de Huffman reduz o tamanho do codigo usado para representar os símbolos de um alfabeto. Símbolos do alfabeto que ocorrem frequentemente são atribuidos por codigos mais curtos. A estratégia geral é permitir ao tamanho do codigo variar de caracter para caracter e de assegurar que o codigo utilizado seja menor.
A compressão de Huffman é feita através da construção de uma árvore binaria usando um simples conjunto de exemplo. Isso é feito arranjando os símbolos do alfabeto em ordem decrescente de probabilidade. Então repetidamente adicionando duas menores probabilidades e reorganizando. Este processo se repete até a soma das probabilidades dos dois últimos símbolos ser igual a 1. Uma vez que este processo seja feito, uma árvore binaria de Huffman é possível ser gerada.
Se não for obtido uma probabilidade de 1 nos dois últimos símbolos, provavelmente existe um erro no processo.
Essa probabilidade de 1 que forma o último símbolo, é a raiz da árvore binária. Os códigos resultantes são formados traçando a árvore a partir da raiz até os últimos ramos de código depois de assumir os 0s e 1s as sub-divisões.
Um exemplo passo-a-passo da consntrução de uma árvore binária de Huffman é mostrada abaixo:
Dados um conjunto de símbolos com uma lista de relativas probabilidades de ocorrência com uma mensagem.
m0 m1 m2 m3 m4
0.10 0.36 0.15 0.2 0.19
(1) Liste os símbolos em ordem decrescente de probabilidade.
m1 m3 m4 m2 m0
0.36 0.20 0.19 0.15 0.10
(2) Pegue os dois símbolos com a menor probabilidade. De ao símbolo combinado, um novo nome.
m2 m0
0.15 0.10
Combina formando:
A
0.25
(3) A nova lista obtida eh mostrada abaixo. Repetindo o passo anterior nos dará um novo símbolo para as próximas duas possibilidades mais baixas.
m1 A m3 m4
0.36 0.25 0.20 0.19
m3 m4
0.20 0.19
Combina formando:
B
0.39
(4) Uma nova lista é obtida. Repetindo o passo anterior nos dará um novo símbolo para as próximas duas possibilidades mais baixas.
B m1 A
0.39 0.36 0.25
m1 A
0.36 0.25
Combina formando:
C
0.61
(5)Finalmente há apenas um par faltando e nós simplesmente os combinamos e nomeamos como um novo símbolo.
B C
0.39 0.61
Combina formando
D
1.0
(6) Tendo terminado estes passos nós temos:
(7)Agora, uma árvore de Huffman pode ser construída, 0s e 1s são atribuídos para as subdivisões.
(8)Os códigos resultantes são formados traçando a árvore desde a raiz até o fim dos códigos.
Símbolos Probabilidades Códigos
m0 0.10 011
m1 0.36 00
m2 0.15 010
m3 0.20 10
m4 0.19 11
Note que a compressão é arquivada alocando símbolos de ocorrências frequentes com códigos menores.
Nenhum comentário:
Postar um comentário