¿Hay alguna manera de obtener el mínimo, el máximo, la mediana y el promedio de una lista de números en un solo comando?

Tengo una lista de números en un archivo, uno por línea. ¿Cómo puedo obtener los valores mínimo, máximo, mediano y promedio ? Quiero usar los resultados en un script bash.

Aunque mi situación inmediata es para enteros, una solución para números de punto flotante sería útil en el futuro, pero un método entero simple está bien.

Puede utilizar el lenguaje de programación R .

Aquí hay un script R rápido y sucio:

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

Tenga "stdin"en cuenta scanque hay un nombre de archivo especial para leer desde la entrada estándar (es decir, desde tuberías o redirecciones).

Ahora puede redirigir sus datos sobre stdin al script R:

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

También funciona para puntos flotantes:

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

Si no desea escribir un archivo de secuencia de comandos R, puede invocar una línea única verdadera (con salto de línea solo para facilitar la lectura) en la línea 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

Lea los excelentes manuales de R en http://cran.r-project.org/manuals.html .

Lamentablemente, la referencia completa solo está disponible en PDF. Otra forma de leer la referencia es escribiendo ?topicnameel aviso de una sesión interactiva de R.

Para completar: hay un comando R que genera todos los valores que desea y más. Desafortunadamente, en un formato amigable para los humanos que es difícil de analizar mediante programación.

> 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 

De hecho, mantengo un pequeño programa awk para dar la suma, el recuento de datos, el dato mínimo, el dato máximo, la media y la mediana de una sola columna de datos numéricos (incluidos los 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];
  }
'

El script anterior lee de stdin e imprime columnas de salida separadas por tabuladores en una sola línea.

Con GNU datamash :

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

Mínimo, máximo y promedio son bastante fáciles de obtener con 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

Calcular la mediana es un poco más complicado, ya que necesita ordenar los números y almacenarlos en la memoria por un tiempo o leerlos dos veces (la primera vez para contarlos, la segunda, para obtener el valor de la mediana). Aquí hay un ejemplo que almacena todos los números en la memoria:

% 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 bien para este tipo de cosas:

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}'

Promedio:

jq -s add/length

En jqla opción -s( --slurp) crea una matriz para las líneas de entrada después de analizar cada línea como JSON, o como un número en este 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]};

Y un revestimiento Perl one- (largo), que incluye la 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;'

Las opciones especiales utilizadas son:

• -0777 : lea todo el archivo a la vez en lugar de línea por línea
• -a : autosplit en la matriz @F

Una versión de script más legible de lo mismo sería:

#!/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;

Si desea decimales, reemplácelos %dcon algo como %.2f.

Simple-r es la respuesta:

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

Utiliza el entorno R para simplificar el análisis estadístico.

Solo por el hecho de tener una variedad de opciones presentadas en esta página, aquí hay dos formas más:

1: octava

• GNU Octave es un lenguaje interpretado de alto nivel, destinado principalmente a cálculos numéricos. Proporciona capacidades para la solución numérica de problemas lineales y no lineales, y para realizar otros experimentos numéricos.

Aquí hay un ejemplo rápido de octava.

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 + herramientas de un solo propósito .

Para que bash maneje números de punto flotante, este script usa numprocessy numaveragedesde el paquete num-utils.

PD. También he tenido una visión razonable bc, pero para este trabajo en particular, no ofrece nada más allá de lo que awkofrece. Es (como dice la 'c' en 'bc') una calculadora, una calculadora que requiere mucha programación awky este 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 

Voy a la segunda opción de Lesmana de R y ofrecer mi primer programa de I. Lee un número por línea en la entrada estándar y escribe cuatro números (mínimo, máximo, promedio, mediano) separados por espacios en la salida estándar.

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

El siguiente sort/ awktándem lo hace:

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 la mediana como media de los dos valores centrales si el recuento de valores es par)

Tomando señales del código de Bruce, aquí hay una implementación más eficiente que no mantiene todos los datos en la memoria. Como se indicó en la pregunta, se supone que el archivo de entrada tiene (como máximo) un número por línea. Cuenta las líneas en el archivo de entrada que contienen un número calificado y pasa la cuenta al awkcomando junto con (antes) los datos ordenados. Entonces, por ejemplo, si el archivo contiene

6.0
4.2
8.3
9.5
1.7

entonces la entrada a awkes en realidad

5
1.7
4.2
6.0
8.3
9.5

Luego, el awkscript captura el recuento de datos en el NR==1bloque de código y guarda el valor medio (o los dos valores medios, que se promedian para obtener la mediana) cuando los ve.

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
  }
'

El numes un pequeño awkcontenedor que hace exactamente esto y más, por ejemplo

$ 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

le evita reinventar la rueda en el awk ultraportátil. Los documentos se proporcionan arriba y el enlace directo aquí (consulte también la página de GitHub ).

Con 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 solución: ¡ no es una prueba de entrada vacía!

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))"

Si está más interesado en la utilidad en lugar de ser genial o inteligente, entonces perles una opción más fácil que awk. En general, estará en cada * nix con un comportamiento constante, y es fácil y gratuito de instalar en Windows. Creo que también es menos críptico que awkeso, y habrá algunos módulos de estadísticas que podrías usar si quisieras un punto intermedio entre escribirlo tú mismo y algo como R. Mi bastante no probado (de hecho, sé que tiene errores pero funciona para mis propósitos ) el perlguión tardó aproximadamente un minuto en escribirse, y supongo que la única parte críptica sería while(<>), que es la taquigrafía muy útil, lo que significa tomar los archivos pasados ​​como argumentos de línea de comandos, leer una línea a la vez y poner esa línea en la variable especial$_. Entonces podría poner esto en un archivo llamado count.pl y ejecutarlo como perl count.pl myfile. Aparte de eso, debería ser dolorosamente obvio lo que está sucediendo.

$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
}