Existe-t-il un moyen d’obtenir les valeurs min, max, médiane et moyenne d’une liste de nombres dans une seule commande?

J'ai une liste de numéros dans un fichier, un par ligne. Comment puis-je obtenir les valeurs minimale, maximale, médiane et moyenne ? Je veux utiliser les résultats dans un script bash.

Bien que ma situation immédiate concerne les nombres entiers, une solution pour les nombres à virgule flottante serait utile en bout de ligne, mais une méthode de nombre entier simple convient parfaitement.

Vous pouvez utiliser le langage de programmation R .

Voici un script rapide et sale:

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

Notez le "stdin"dans scanlequel se trouve un nom de fichier spécial à lire à partir d’une entrée standard (c’est-à-dire à partir de pipes ou de redirections).

Vous pouvez maintenant rediriger vos données sur stdin vers le script R:

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

Fonctionne également pour les points flottants:

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

Si vous ne voulez pas écrire de fichier de script R, vous pouvez appeler une vraie ligne (avec un saut de ligne uniquement pour la lisibilité) dans la ligne de commande en utilisant 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

Lisez les manuels R fins sur http://cran.r-project.org/manuals.html .

Malheureusement, la référence complète est uniquement disponible en PDF. Une autre façon de lire la référence consiste à saisir ?topicnamel'invite d'une session interactive R.

Pour être complet: il existe une commande R qui affiche toutes les valeurs souhaitées et plus encore. Malheureusement, dans un format convivial, difficile à analyser par programmation.

> 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 

En fait, je garde un petit programme awk pour donner la somme, le nombre de données, le minimum de données, le maximum de données, la moyenne et la médiane d'une seule colonne de données numériques (y compris les nombres négatifs):

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

Le script ci-dessus lit à partir de stdin et imprime les colonnes de sortie séparées par des tabulations sur une seule ligne.

Avec GNU datamash :

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

Min, max et average sont assez faciles à obtenir avec 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

Le calcul de la médiane est un peu plus délicat, car vous devez trier les nombres et les stocker tous en mémoire pendant un moment ou les lire deux fois (première fois à les compter, deuxième - pour obtenir la valeur médiane). Voici un exemple qui stocke tous les nombres en mémoire:

% 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 fonctionne bien pour ce genre de chose:

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

Le minimum:

jq -s min

Maximum:

jq -s max

Médian:

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

Moyenne:

jq -s add/length

Dans jql' option -s( --slurp), un tableau est créé pour les lignes d'entrée après l'analyse de chaque ligne sous forme de code JSON ou sous forme de nombre dans ce cas.

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]};

Et une doublure (longue) en Perl, y compris la médiane:

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

Les options spéciales utilisées sont:

• -0777 : lit le fichier entier en une fois au lieu de ligne par ligne
• -a : autosplit dans le tableau @F

Une version de script plus lisible de la même chose serait:

#!/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 vous voulez des nombres décimaux, remplacez-les %dpar quelque chose comme %.2f.

Simple-r est la réponse:

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

Il utilise l'environnement R pour simplifier l'analyse statistique.

Juste pour avoir une variété d’options présentées sur cette page, voici encore deux façons:

1: octave

• GNU Octave est un langage interprété de haut niveau, principalement destiné aux calculs numériques. Il fournit des fonctionnalités pour la résolution numérique de problèmes linéaires et non linéaires, ainsi que pour la réalisation d’autres expériences numériques.

Voici un exemple rapide d'octave.

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 + outils à usage unique .

Pour que bash puisse gérer les nombres à virgule flottante, ce script utilise numprocesset numaveragedepuis le package num-utils.

PS J'ai également examiné de manière raisonnable bc, mais pour ce travail particulier, il n'offre rien de plus que ce qu'il awkpropose. C'est (comme le dit le 'c' dans 'bc') une calculatrice - une calculatrice qui nécessite beaucoup de programmation comme awket ce 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 

Je seconderai le choix de R de Lesmana et offrirai mon premier programme de R. Il lit un numéro par ligne sur l'entrée standard et écrit quatre nombres (min, max, moyenne, médiane) séparés par des espaces sur la sortie standard.

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

Le dessous sort/ awktandem le fait:

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

(il calcule la médiane comme moyenne des deux valeurs centrales si le nombre de valeurs est pair)

En prenant exemple sur le code de Bruce, voici une implémentation plus efficace qui ne conserve pas l'intégralité des données en mémoire. Comme indiqué dans la question, cela suppose que le fichier d'entrée a (au plus) un nombre par ligne. Il compte les lignes du fichier d'entrée contenant un numéro de qualification et transmet le compte à la awkcommande avec (précédent) les données triées. Ainsi, par exemple, si le fichier contient

6.0
4.2
8.3
9.5
1.7

alors l'entrée awkest en fait

5
1.7
4.2
6.0
8.3
9.5

Ensuite, le awkscript capture le nombre de données dans le NR==1bloc de code et enregistre la valeur médiane (ou les deux valeurs médianes, dont la moyenne est calculée pour obtenir la médiane) lorsqu'il les voit.

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

Le numest un petit awkemballage qui fait exactement cela et plus, par exemple

$ 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

cela vous évite de réinventer la roue dans l'awk ultra-portable. Les documents sont donnés ci-dessus, et le lien direct ici (voir aussi la page GitHub ).

Avec 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/pythonseule solution - pas de preuve d'entrée vide!

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 vous êtes plus intéressé par l'utilité que par la fraîcheur ou l'intelligence, le perlchoix est plus facile que awk. En gros, ce sera sur chaque * nix avec un comportement cohérent, et est facile et gratuit à installer sur Windows. Je pense que c'est aussi moins crypté que awk, et il y aura quelques modules de statistiques que vous pourriez utiliser si vous vouliez une maison de transition entre l'écrire vous-même et quelque chose comme R. Mon assez peu testé (en fait je sais qu'il a des bugs mais qu'il fonctionne pour mes besoins ) le perlscript a pris environ une minute pour écrire, et je suppose que la seule partie cryptique serait le while(<>), qui est le raccourci très utile, ce qui signifie prendre le (s) fichier (s) passé (s) en tant qu'argument de ligne de commande, lire une ligne à la fois et mettre cette ligne dans la variable spéciale$_. Donc, vous pouvez mettre cela dans un fichier nommé count.pl et l'exécuter en tant que perl count.pl myfile. En dehors de cela, il devrait être douloureusement évident de savoir ce qui se passe.

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