Existe uma maneira de obter o mínimo, máximo, mediana e média de uma lista de números em um único comando?

Eu tenho uma lista de números em um arquivo, um por linha. Como obtenho os valores mínimo, máximo, mediano e médio ? Eu quero usar os resultados em um script bash.

Embora minha situação imediata seja para números inteiros, uma solução para números de ponto flutuante seria útil na linha, mas um método inteiro simples é bom.

Você pode usar a linguagem de programação R .

Aqui está um script R rápido e sujo:

#! /usr/bin/env Rscript
d<-scan("stdin", quiet=TRUE)
cat(min(d), max(d), median(d), mean(d), sep="\n")

Observe o nome do arquivo "stdin"em scanque é especial para ler da entrada padrão (que significa de pipes ou redirecionamentos).

Agora você pode redirecionar seus dados sobre stdin para o script R:

$ cat datafile
1
2
4
$ ./mmmm.r < datafile
1
4
2
2.333333

Também funciona para pontos flutuantes:

$ cat datafile2
1.1
2.2
4.4
$ ./mmmm.r < datafile2
1.1
4.4
2.2
2.566667

Se você não quiser escrever um arquivo de script R, poderá chamar uma linha única (com quebra de linha apenas para facilitar a leitura) na linha de comando usando Rscript:

$ Rscript -e 'd<-scan("stdin", quiet=TRUE)' \
          -e 'cat(min(d), max(d), median(d), mean(d), sep="\n")' < datafile
1
4
2
2.333333

Leia os bons manuais do R em http://cran.r-project.org/manuals.html .

Infelizmente, a referência completa está disponível apenas em PDF. Outra maneira de ler a referência é digitando ?topicnameo prompt de uma sessão R interativa.

Para completar: existe um comando R que gera todos os valores que você deseja e muito mais. Infelizmente, em um formato amigável para humanos, difícil de analisar de forma programática.

> summary(c(1,2,4))
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
  1.000   1.500   2.000   2.333   3.000   4.000 

Na verdade, eu mantenho um pequeno programa awk para fornecer a soma, contagem de dados, dado mínimo, número máximo, média e mediana de uma única coluna de dados numéricos (incluindo números negativos):

#!/bin/sh
sort -n | awk '
  BEGIN {
    c = 0;
    sum = 0;
  }
  $1 ~ /^(\-)?[0-9]*(\.[0-9]*)?$/ {
    a[c++] = $1;
    sum += $1;
  }
  END {
    ave = sum / c;
    if( (c % 2) == 1 ) {
      median = a[ int(c/2) ];
    } else {
      median = ( a[c/2] + a[c/2-1] ) / 2;
    }
    OFS="\t";
    print sum, c, ave, median, a[0], a[c-1];
  }
'

O script acima lê de stdin e imprime colunas de saída separadas por tabulação em uma única linha.

Com o GNU datamash :

$ printf '1\n2\n4\n' | datamash max 1 min 1 mean 1 median 1
4   1   2.3333333333333 2

Mín, max e média são muito fáceis de obter com o awk:

% echo -e '6\n2\n4\n3\n1' | awk 'NR == 1 { max=$1; min=$1; sum=0 }
   { if ($1>max) max=$1; if ($1<min) min=$1; sum+=$1;}
   END {printf "Min: %d\tMax: %d\tAverage: %f\n", min, max, sum/NR}'
Min: 1  Max: 6  Average: 3,200000

O cálculo da mediana é um pouco mais complicado, pois você precisa classificar os números e armazená-los todos na memória por um tempo ou lê-los duas vezes (primeira vez para contá-los, segundo - para obter valor mediano). Aqui está um exemplo que armazena todos os números na memória:

% echo -e '6\n2\n4\n3\n1' | sort -n | awk '{arr[NR]=$1}
   END { if (NR%2==1) print arr[(NR+1)/2]; else print (arr[NR/2]+arr[NR/2+1])/2}' 
3

pythonpy funciona bem para esse tipo de coisa:

cat file.txt | py --ji -l 'min(l), max(l), numpy.median(l), numpy.mean(l)'

Mínimo:

jq -s min

Máximo:

jq -s max

Mediana:

sort -n|awk '{a[NR]=$0}END{print(NR%2==1)?a[int(NR/2)+1]:(a[NR/2]+a[NR/2+1])/2}'

Média:

jq -s add/length

Em jqa -s( --slurpopção) cria uma matriz para as linhas de entrada depois de analisar cada linha como JSON, ou como um número, neste caso.

nums=$(<file.txt); 
list=(`for n in $nums; do printf "%015.06f\n" $n; done | sort -n`); 
echo min ${list[0]}; 
echo max ${list[${#list[*]}-1]}; 
echo median ${list[${#list[*]}/2]};

E um liner único (longo) do Perl, incluindo a mediana:

cat numbers.txt \
| perl -M'List::Util qw(sum max min)' -MPOSIX -0777 -a -ne 'printf "%-7s : %d\n"x4, "Min", min(@F), "Max", max(@F), "Average", sum(@F)/@F,  "Median", sum( (sort {$a<=>$b} @F)[ int( $#F/2 ), ceil( $#F/2 ) ] )/2;'

As opções especiais usadas são:

• -0777 : leia o arquivo inteiro de uma só vez em vez de linha por linha
• -a : divisão automática na matriz @F

Uma versão de script mais legível da mesma coisa seria:

#!/usr/bin/perl

use List::Util qw(sum max min);
use POSIX;

@F=<>;

printf "%-7s : %d\n" x 4,
    "Min", min(@F),
    "Max", max(@F),
    "Average", sum(@F)/@F,
    "Median", sum( (sort {$a<=>$b} @F)[ int( $#F/2 ), ceil( $#F/2 ) ] )/2;

Se você quiser decimais, substitua %dpor algo como %.2f.

Simple-r é a resposta:

r summary file.txt
r -e 'min(d); max(d); median(d); mean(d)' file.txt

Ele usa o ambiente R para simplificar a análise estatística.

Apenas para apresentar uma variedade de opções nesta página, aqui estão mais duas maneiras:

1: oitava

• O GNU Octave é uma linguagem interpretada de alto nível, destinada principalmente a cálculos numéricos. Ele fornece recursos para a solução numérica de problemas lineares e não lineares e para realizar outras experiências numéricas.

Aqui está um exemplo rápido de oitava.

octave -q --eval 'A=1:10;
  printf ("# %f\t%f\t%f\t%f\n", min(A), max(A), median(A), mean(A));'  
# 1.000000        10.000000       5.500000        5.500000

2: bash + ferramentas de uso único .

Para o bash manipular números de ponto flutuante, esse script usa numprocesse numaveragefrom package num-utils.

PS. Também tive uma visão razoável bc, mas para esse trabalho em particular, ele não oferece nada além do que awkfaz. É (como o 'c' em 'bc' afirma) uma calculadora - uma calculadora que requer muita programação awke esse script bash ...

arr=($(sort -n "LIST" |tee >(numaverage 2>/dev/null >stats.avg) ))
cnt=${#arr[@]}; ((cnt==0)) && { echo -e "0\t0\t0\t0\t0"; exit; }
mid=$((cnt/2)); 
if [[ ${cnt#${cnt%?}} == [02468] ]] 
   then med=$( echo -n "${arr[mid-1]}" |numprocess /+${arr[mid]},%2/ )
   else med=${arr[mid]}; 
fi     #  count   min       max           median        average
echo -ne "$cnt\t${arr[0]}\t${arr[cnt-1]}\t$med\t"; cat stats.avg 

Vou escolher a segunda opção para R de lesmana e oferecer meu primeiro programa de R. Ele lê um número por linha na entrada padrão e grava quatro números (min, max, média, mediana) separados por espaços na saída padrão.

#!/usr/bin/env Rscript
a <- scan(file("stdin"), c(0), quiet=TRUE);
cat(min(a), max(a), mean(a), median(a), "\n");

O abaixo sort/ awktandem faz isso:

sort -n | awk '{a[i++]=$0;s+=$0}END{print a[0],a[i-1],(a[int(i/2)]+a[int((i-1)/2)])/2,s/i}'

(calcula mediana como média dos dois valores centrais se a contagem de valores for par)

Tomando dicas do código de Bruce, aqui está uma implementação mais eficiente que não mantém todos os dados na memória. Conforme declarado na pergunta, ele assume que o arquivo de entrada possui (no máximo) um número por linha. Ele conta as linhas no arquivo de entrada que contêm um número qualificado e passa a contagem para o awkcomando junto com (precedendo) os dados classificados. Então, por exemplo, se o arquivo contiver

6.0
4.2
8.3
9.5
1.7

então a entrada para awké realmente

5
1.7
4.2
6.0
8.3
9.5

Em seguida, o awkscript captura a contagem de dados no NR==1bloco de código e salva o valor do meio (ou os dois valores do meio, que são calculados para gerar a mediana) quando os vê.

FILENAME="Salaries.csv"

(awk 'BEGIN {c=0} $1 ~ /^[-0-9]*(\.[0-9]*)?$/ {c=c+1;} END {print c;}' "$FILENAME"; \
        sort -n "$FILENAME") | awk '
  BEGIN {
    c = 0
    sum = 0
    med1_loc = 0
    med2_loc = 0
    med1_val = 0
    med2_val = 0
    min = 0
    max = 0
  }

  NR==1 {
    LINES = $1
    # We check whether numlines is even or odd so that we keep only
    # the locations in the array where the median might be.
    if (LINES%2==0) {med1_loc = LINES/2-1; med2_loc = med1_loc+1;}
    if (LINES%2!=0) {med1_loc = med2_loc = (LINES-1)/2;}
  }

  $1 ~ /^[-0-9]*(\.[0-9]*)?$/  &&  NR!=1 {
    # setting min value
    if (c==0) {min = $1;}
    # middle two values in array
    if (c==med1_loc) {med1_val = $1;}
    if (c==med2_loc) {med2_val = $1;}
    c++
    sum += $1
    max = $1
  }
  END {
    ave = sum / c
    median = (med1_val + med2_val ) / 2
    print "sum:" sum
    print "count:" c
    print "mean:" ave
    print "median:" median
    print "min:" min
    print "max:" max
  }
'

O numé um awkinvólucro minúsculo que faz exatamente isso e muito mais, por exemplo

$ echo "1 2 3 4 5 6 7 8 9" | num max
9
$ echo "1 2 3 4 5 6 7 8 9" | num min max median mean
..and so on

evita que você reinvente a roda no awk ultra-portátil. Os documentos são fornecidos acima e o link direto aqui (consulte também a página do GitHub ).

Com perl:

$ printf '%s\n' 1 2 4 |
   perl -MList::Util=min,max -MStatistics::Basic=mean,median -w -le '
     chomp(@l = <>); print for min(@l), max(@l), mean(@l), median(@l)'
1
4
2.33
2

cat/pythonúnica solução - não prova de entrada vazia!

cat data |  python3 -c "import fileinput as FI,statistics as STAT; i = [int(l) for l in FI.input()]; print('min:', min(i), ' max: ', max(i), ' avg: ', STAT.mean(i), ' median: ', STAT.median(i))"

Se você está mais interessado em utilidade do que em ser legal ou inteligente, então perlé uma escolha mais fácil do que awk. Em geral, ele estará em todos os * nix com comportamento consistente e é fácil e gratuito para instalar no Windows. Eu acho que também é menos enigmático do que awk, e haverá alguns módulos de estatísticas que você poderia usar se quisesse uma casa intermediária entre escrevê-lo e algo como R. ) perldemorou cerca de um minuto para escrever, e eu acho que a única parte enigmática seria a while(<>), que é a abreviação muito útil, ou seja, pegar os arquivos passados ​​como argumentos de linha de comando, ler uma linha de cada vez e colocar essa linha na variável especial$_. Então você pode colocar isso em um arquivo chamado count.pl e executá-lo como perl count.pl myfile. Além disso, deve ser dolorosamente óbvio o que está acontecendo.

$max = 0;
while (<>) {
 $sum = $sum + $_;
 $max = $_ if ($_ > $max);
 $count++;
}
$avg=$sum/$count;
print "$count numbers total=$sum max=$max mean=$avg\n";

function median()
{
    declare -a nums=($(cat))
    printf '%s\n' "${nums[@]}" | sort -n | tail -n $((${#nums[@]} / 2 + 1)) | head -n 1
}