tri et selection en langage awk

Version imprimable

Voir 40 message(s) de cette discussion en une page

05/01/2010, 19h35
étoile de mer
un ami a essayé cette commande et ca marché nikel mais chez moi ca genere une erreur
Code:

1 2 awk -F"(" '{printf "%s|%f\n", $0,substr($2,1,length($2)-1)}' monFicher | awk -F"-->" '{printf "%s|%s\n",$0, $1}' | sort -t"|" -k3 -k2.rn
peut etre parceque je suis sous linux et lui sous unix
il affiche cette erreur

Citation:

sort: adresse relative du caractère est zéro: invalid field specification `2.0rn'
06/01/2010, 09h14
noooop

Ah s'il on peut utiliser sort....alors ce n'est plus du tri en awk 8O !
06/01/2010, 15h18
jmelyn
Bonjour,

Étoile de mer, l'énoncé de ton problème est pour le moins absconse. Je vais donc essayer d'en faire un résumé, tu me diras si je me trompe et le cas échéant, où.

Il existe un fichier de la forme suivante:
Code:

1 2 3 4 5 insister->to put -3.553851e-05 insister->to vote -7.547198e-06 insister->to respect -1.091798e-05 joindre->to join -2.994884e-06 joindre->to alter 2.090002e-06
Il faut le trier suivant la première colonne puis suivant la troisième (qui est numérique, en notation scientifique). La solution doit utiliser la commande awk. Est-ce bien cela? Je suppose que le caractère de séparation des colonnes est l'espace, c'est-à-dire que le premier champ de la première ligne est: "insister->to", le second "put" et le troisième "-3.553851e-05".

Le big problème ici est de mélanger les tris alphabétique (première colonne) et le tri numérique (troisième colonne) le tout dans une seule commande de tri. La commande sort s'en sort (hé hé!) en partie mais n'est pas capable de mixer la manière de trier.

Salut.

Pour se fichier là, j'avais trouvé un moyen :

- calcul des valeurs en notation scientifique
- tri à bulle dans l'ordre décroissant des valeurs (stockage des lignes du fichier en fonction de cet ordre dans un tableau).
- enregistrement dans un fichier intermédiaire et triage avec :

Code:

1
2
cat fichierIntermédiaire | grep joindre > fichierSortie
cat fichierIntermédiaire | grep insister >> fichierSortie

Au final j'avais ce code un peut lourd :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
#!/bin/bash
 
if [ $# -lt 2 ]
then
    printf "Saisir fichier d'entrée : "
    read fichierEnt
    printf "Saisir fichier de sortie : "
    read fichierSort
else
    fichierEnt=$1
    fichierSort=$2
fi
 
fichierInt=fichier_int
 
ExPow ()
{
    exp=$(echo "(1*2.718281828459)" | bc) 
    value=1
    x=$1
    if [ $x -lt 0 ]
    then
        x2=$(echo $x | awk 'BEGIN{FS="-"} {print $2}')
    else
        x2=$x
    fi
 
    for (( i=1 ; i<=x2 ; i++ ))
    do
        value=$(echo "$value*$exp" | bc -l)
    done
    if [ $x -lt 0 ]
    then
        value=$(echo "1/$value" | bc -l)
    fi
}
k=0
 
cat $fichierEnt | while true
do
    read ligne
    if [ "$ligne" = "" ]
    then
        # tri à bulle
        for (( m=0 ; m<k ; m++ ))
        do
            let k2=$k-$m
            for (( n=0 ; n<k2 ; n++ ))
            do
                comp=$(echo "${tab[n]} < ${tab[m]}" | bc)
                if [ $comp -eq 1 ]
                then
                    tampon1=${tab[m]}
                    tampon2=${tab2[m]}
 
                    tab[m]=${tab[n]}
                    tab2[m]=${tab2[n]}
 
                    tab[n]=$tampon
                    tab2[n]=$tampon2
                fi
            done
            l=0
            until [ $k -eq 0 ] || [ $l -eq 100 ]
            do
                let k=$k-1
                echo ${tab2[k]} >> $fichierInt
                let l=$l+1
            done
 
        done
        exit
    else
        set -- $ligne
        x=$(echo $3 | awk 'BEGIN{FS="e"} {print $2}')
        value2=$(echo $3 | awk 'BEGIN{FS="e"} {print $1}')
        x=$(echo $x | bc -l)
        ExPow $x
        tab[k]=$(echo "$value*$value2" | bc -l)
        tab2[k]=$(echo $ligne)
        let k=$k+1    
    fi
done
 
cat $fichierInt | grep insister > $fichierSort
cat $fichierInt | grep joindre >> $fichierSort
rm $fichierInt

Mais cela fonctionnait parfaitement jusqu'au moment ou Étoile de mer me dit que le format de fichier à changé et est comme ceci :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
a du-->expanding(1.223293e-02)
a du-->genetically(1.223293e-02)
a du-->barriers(3.153879e-02)
a du-->oil(1.223293e-02)
a du-->shape(1.223293e-02)
a du-->contained(1.223293e-02)
a du-->analysis(1.223293e-02)
a du-->person(1.223293e-02)
a du-->demands(3.153879e-02)
a du-->code(1.223293e-02)
a du-->agree(3.153879e-02)
a du-->broadcasting(1.223293e-02)
a du-->procurement(1.223293e-02)

Et qu'il faut toujours trier dans l'ordre décroissant puis en fonction des termes de la ligne en précisant que le fichier peut faire 3GO et que les premiers termes sont inconnus :aie:. J'ai pas eu le temps de me pencher sur le problème de plus près ...

Bonsoir ok.Idriss,

Tu as effectivement passé beaucoup de temps sur ce problème flou et fluctuant. Sans indication précise, l'on peut se perdre en conjectures. Mais le problème est intéressant, à tout le moins. Alors imaginons une simplification de l'énoncé afin de trouver une solution satisfaisante:

Supposons que le fichier d'entrée soit formaté comme suit:
Code:

1 2 3 4 Z 3.3333E-05 B -2.9876E-06 A -3.5790E-06 B -1.2345E-06
Il faut que le fichier de sortie soit trié comme suit:
Code:

1 2 3 4 A -3.5790E-06 B -1.2345E-06 B -2.9876E-06 Z 3.3333E-05
Le tri des lignes est d'abord effectué sur le premier champ (A, B...) par ordre alphabétique croissant, et puis s'il y a plusieurs lettres identiques, les lignes sont triées sur le second champ par ordre numérique décroissant (pour la lettre B: -1...E-06, -2...E-06).

Voici le code qui fait les deux tris, en passant pour chaque ligne par un fichier intermédiaire:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 LC_ALL="C" rm -f file_tmp file_out sort -k 1,1 file_in | awk ' { print $0 >> "file_tmp"; close("file_tmp") if ($1 != prev) { system("sort -n -k 2,2 file_tmp >> file_out; rm file_tmp") } prev = $1 } END {system("[ -e file_tmp ] && sort -n -k 2,2 file_tmp >> file_out")}'
Pour être sûr que la commande sort fonctionne correctement, LC_ALL est forcé à "C"; ainsi, pas de problème avec le point au lieu de la virgule et autres joyeusetés.

Bonjour,

Une erreur aux limites s'est subrepticement glissée dans mon code. Mea culpa. Voici la correction. Si vous en repérez d'autres, faites m'en part!
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 LC_ALL="C" rm -f file_tmp file_out sort -k 1,1 file_in | awk ' function appendFile() { system("if [ -e file_tmp ]; then sort -n -k 2,2 file_tmp >> file_out; rm file_tmp; fi") } { if ($1 != prev) {appendFile()} print $0 >> "file_tmp"; close("file_tmp") prev = $1 } END {appendFile()}'
Maintenant la logique est plus claire (enfin j'espère!).

11/01/2010, 18h48
étoile de mer

Merci Jimelyn,
le travail a été rendu et j'etais obligé de le faire en C :roll:
Merci
11/01/2010, 19h00
ok.Idriss

Citation:

Envoyé par étoile de mer

j'etais obligé de le faire en C :roll:

C'est peut être pas plus mal ;) ...

Voir 40 message(s) de cette discussion en une page