Discussion :

[Celano]

Bonjour

Je passe le permis poids lourd. Le jour de l'examen, on nous posera 10 questions.
Pour travailler, on nous a donné 20 tableaux de 10 lignes, soit 200 questions en tout.
Chaque ligne correspond à un thème qui doit être abordé.

Question Série 1 – Thème 1	Question Série 2 – Thème 1	Question Série 3 – Thème 1
Question Série 1 – Thème 2	Question Série 2 – Thème 2	Question Série 3 – Thème 2
Question Série 1 – Thème 3	Question Série 2 – Thème 3	Question Série 3 – Thème 3
Question Série 1 – Thème 4	Question Série 2 – Thème 4	Question Série 3 – Thème 4
Question Série 1 – Thème 5	Question Série 2 – Thème 5	Question Série 3 – Thème 5
Question Série 1 – Thème 6	Question Série 2 – Thème 6	Question Série 3 – Thème 6
Question Série 1 – Thème 7	Question Série 2 – Thème 7	Question Série 3 – Thème 7
Question Série 1 – Thème 8	Question Série 2 – Thème 8	Question Série 3 – Thème 8
Question Série 1 – Thème 9	Question Série 2 – Thème 9	Question Série 3 – Thème 9
Question Série 1 – Thème 10	Question Série 2 – Thème 10	Question Série 3 – Thème 10

Le jour de l'examen, ils vont piocher une question par thème parmi les 20 séries de façon aléatoire.

Pour m'entraîner, je veux copier les questions dans un tableur.csv: 20 colonnes et 10 lignes.
J'aimerais réorganiser les lignes de façon aléatoire: chaque question ne peut être déplacée que de gauche à droite dans le tableau mais ne peut pas changer de rang (thème 3 reste en ligne 3 par exemple).

Voilà le résultat que je veux. Quant au moyen pour y parvenir...
Je ne vois pas comment commencer mes recherches pour le moment

Celano

[Flodelarab]

Bonjour

La commande sort trie un fichier mais elle peut aussi le mélanger.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
$ cat <<FDF >routier.txt
> 1
> 2
> 3
> 4
> 5
> 6
> 7
> 8
> 9
> 10
> FDF
$ sort -nr routier.txt
10
9
8
7
6
5
4
3
2
1
$ sort -R routier.txt
6
1
10
7
3
9
2
5
8
4
$ sort -R routier.txt
4
3
8
6
10
2
9
1
7
5
$ sort -R routier.txt
3
9
5
7
8
1
10
4
6
2

Une fois que tu as un ordre, tu peux utiliser awk qui désigne chaque champ de la ligne par son rang.
Exemple: $5 est le 5ème champ.
Il devient facile pour toi de mélanger.

Tu peux transmettre ton fichier d'entrée et ton fichier d'ordre à awk pour créer un fichier de sortie.

Quel est le format des données du fichier d'entrée ?

[Celano]

Merci Flo

Donc si je comprends bien, il faut un fichier ordre.txt qui comprenne ceci?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
$1
$2
$3
$4
$5
$6
$7
$8
$9
$10

Ce qui permettrait de piocher les bonnes lignes dans les fichiers aléatoires?

[Flodelarab]

Je pensais plus à un truc comme ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
$ awk '(FNR==NR){a[NR]=$1;next;} {for (i=1;i<=NF;i++) printf $a[i]" ";print "";}' <(echo -e "1\n2\n3"|sort -R) <(echo A B C;echo D E F)                                                                                                                                                                       
A C B
D F E
$ awk '(FNR==NR){a[NR]=$1;next;} {for (i=1;i<=NF;i++) printf $a[i]" ";print "";}' <(echo -e "1\n2\n3"|sort -R) <(echo A B C;echo D E F)
B C A
E F D

Pas de panique. Quelques explications:

• <( ) est une substitution de processus pour considérer la sortie comme un fichier. Le premier est le fichier d'ordre et le second ton fichier de questions.
• (FNR==NR){blablabla1;next;} { blablabla2;} est une structure classique. La première accolade ne s'applique qu'à ton premier fichier. Les autres accolades (ici, une) s'appliquent aux autres fichiers.
• a[] est un tableau pour retenir l'ordre.
• $x désigne le champ x. Donc $3 désigne le 3ème, $(n+1) désigne le n+1ème, et $a[i] désigne le champ de rang fourni par le i-ème élément du tableau a.
• printf, c'est juste pour éviter le retour à la ligne. Une autre façon de faire peut être:
  

  Code :

  Sélectionner tout - Visualiser dans une fenêtre à part

  1
  2
  3
  $ awk '(FNR==NR){a[NR]=$1;next;} {print $a[1],$a[2],$a[3];}' <(echo -e "1\n2\n3"|sort -R) <(echo A B C;echo D E F)
  C B A
  F E D

  Peut-être plus élégant. À voir.

[Celano]

Je vais prendre une aspirine!
Non, je rigole. Je vais prendre le temps de comprendre le code. Je te remercie!

[Celano]

Merci Flo de détailler aussi précisément tes explications.

J'y vois un peu plus clair. J'ai fait quelques bidouillages pour comprendre ce que ça change.
Grâce à ton exemple, j'arrive à mélanger les questions d'un fichier. Mais j'aimerais piocher une question de rang 1, puis 2 puis 3... jusqu'à 10, chacune piochée au hasard dans un fichier parmi les 20 fichiers de 10 questions. Il faudrait donc que je rajoute un

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

$ sort -R

dans la façon de choisir les fichiers. Et là je ne vois pas encore. Mais je continue à creuser

[Celano]

J'essaye de m'expliquer un peu mieux.

Dans un premier temps, je liste mes 20 fichiers en les triant de façon aléatoire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
$ awk '(FNR==NR){a[NR]=$1;next;} {print $a[1],$a[2],$a[3],$a[4],$a[5],$a[6],$a[7],$a[8],$a[9],$a[10],$a[11],$a[12],$a[13],$a[14],$a[15],$a[16],$a[17],$a[18],$a[19],$a[20]}' <(echo -e "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20"|sort -R) <(echo $(ls *.txt))
QE-16.txt QE-01.txt QE-10.txt QE-18.txt QE-05.txt QE-03.txt QE-02.txt QE-11.txt QE-20.txt QE-15.txt QE-04.txt QE-07.txt QE-08.txt QE-19.txt QE-17.txt QE-13.txt QE-14.txt QE-09.txt QE-06.txt QE-12.txt

Chaque fichier contient 10 lignes maxi.
En fonction du résultat précédent, j'aimerais piocher la ligne 1 du fichier QE-16.txt, la 2 de QE-01.txt, la 3 de QE-10.txt et ainsi de suite jusqu'à la question 10.

Et c'est justement là que je bloque...

[Celano]

J'aime mieux quand ça revient à la ligne.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
$ awk '(FNR==NR){a[NR]=$1;next;} {for (i=1;i<=NF;i++) print $a[i]" ";print "";}' <(echo -e "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20"|sort -R) <(echo $(ls *.txt))
QE-11.txt 
QE-19.txt 
QE-05.txt 
QE-04.txt 
QE-06.txt 
QE-07.txt 
QE-01.txt 
QE-08.txt 
QE-12.txt 
QE-20.txt 
QE-18.txt 
QE-15.txt 
QE-10.txt 
QE-09.txt 
QE-14.txt 
QE-16.txt 
QE-03.txt 
QE-13.txt 
QE-17.txt 
QE-02.txt

Du coup, il faudrait mettre un tube après

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

<(echo $(ls *.txt)) | awk ???

, mais quoi?

[Celano]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
$ awk '(FNR==NR){a[NR]=$1;next;} {for (i=1;i<=NF;i++) print $a[i]" ";print "";}' <(echo -e "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20"|sort -R) <(echo $(ls *.txt)) | cat $(awk '{print $1}')
Série08-Question01
Série08-Question02
Série08-Question03
Série08-Question04
Série08-Question05
Série08-Question06
Série08-Question07
Série08-Question08
Série08-Question09
Série08-Question10
Série06-Question01
Série06-Question02
Série06-Question03
Série06-Question04
Série06-Question05
Série06-Question06
Série06-Question07
Série06-Question08
Série06-Question09
Série06-Question10
Série10-Question01
Série10-Question02
Série10-Question03
Série10-Question04
Série10-Question05
Série10-Question06
Série10-Question07
Série10-Question08
Série10-Question09
Série10-Question10
Série18-Question01
Série18-Question02
Série18-Question03
Série18-Question04
Série18-Question05
Série18-Question06
Série18-Question07
Série18-Question08
Série18-Question09
Série18-Question10
Série02-Question01
Série02-Question02
Série02-Question03
Série02-Question04
Série02-Question05
Série02-Question06
Série02-Question07
Série02-Question08
Série02-Question09
Série02-Question10
Série11-Question01
Série11-Question02
Série11-Question03
Série11-Question04
Série11-Question05
Série11-Question06
Série11-Question07
Série11-Question08
Série11-Question09
Série11-Question10
Série05-Question01
Série05-Question02
Série05-Question03
Série05-Question04
Série05-Question05
Série05-Question06
Série05-Question07
Série05-Question08
Série05-Question09
Série05-Question10
Série13-Question01
Série13-Question02
Série13-Question03
Série13-Question04
Série13-Question05
Série13-Question06
Série13-Question07
Série13-Question08
Série13-Question09
Série13-Question10
Série20-Question01
Série20-Question02
Série20-Question03
Série20-Question04
Série20-Question05
Série20-Question06
Série20-Question07
Série20-Question08
Série20-Question09
Série20-Question10
Série17-Question01
Série17-Question02
Série17-Question03
Série17-Question04
Série17-Question05
Série17-Question06
Série17-Question07
Série17-Question08
Série17-Question09
Série17-Question10
Série15-Question01
Série15-Question02
Série15-Question03
Série15-Question04
Série15-Question05
Série15-Question06
Série15-Question07
Série15-Question08
Série15-Question09
Série15-Question10
Série03-Question01
Série03-Question02
Série03-Question03
Série03-Question04
Série03-Question05
Série03-Question06
Série03-Question07
Série03-Question08
Série03-Question09
Série03-Question10
Série14-Question01
Série14-Question02
Série14-Question03
Série14-Question04
Série14-Question05
Série14-Question06
Série14-Question07
Série14-Question08
Série14-Question09
Série14-Question10
Série01-Question01
Série01-Question02
Série01-Question03
Série01-Question04
Série01-Question05
Série01-Question06
Série01-Question07
Série01-Question08
Série01-Question09
Série01-Question10
Série09-Question01
Série09-Question02
Série09-Question03
Série09-Question04
Série09-Question05
Série09-Question06
Série09-Question07
Série09-Question08
Série09-Question09
Série09-Question10
Série16-Question01
Série16-Question02
Série16-Question03
Série16-Question04
Série16-Question05
Série16-Question06
Série16-Question07
Série16-Question08
Série16-Question09
Série16-Question10
Série12-Question01
Série12-Question02
Série12-Question03
Série12-Question04
Série12-Question05
Série12-Question06
Série12-Question07
Série12-Question08
Série12-Question09
Série12-Question10
Série04-Question01
Série04-Question02
Série04-Question03
Série04-Question04
Série04-Question05
Série04-Question06
Série04-Question07
Série04-Question08
Série04-Question09
Série04-Question10
Série19-Question01
Série19-Question02
Série19-Question03
Série19-Question04
Série19-Question05
Série19-Question06
Série19-Question07
Série19-Question08
Série19-Question09
Série19-Question10
Série07-Question01
Série07-Question02
Série07-Question03
Série07-Question04
Série07-Question05
Série07-Question06
Série07-Question07
Série07-Question08
Série07-Question09
Série07-Question10

Je n'arrive pas à extraire uniquement la ligne qui m'intéresse...

• Série08-Question01
• Série06-Question02
• Série10-Question03
• Série18-Question04
• Série02-Question05
• Série11-Question06
• Série05-Question07
• Série13-Question08
• etc...

[Flodelarab]

La question est différente de celle de départ.

Si tu as vraiment des fichiers nommés comme cela, tu peux faire ce qui suit.


D'abord je crée un jeu de données factices:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

for ((i=1;i<21;i++)); do b=$(printf "%02i\n" $i); for ((j=1;j<11;j++));do echo "F$b-Q$j";done >"QE-$b.txt";done

Les fichiers s'appellent, par exemple, QE-05.txt et ils ont tous 10 lignes du type "F05-Q10".


Ensuite, il suffit d'alimenter une boucle while avec le fichier d'ordre.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
$ ligne=1; while read ordre; do cible=$(printf "QE-%02i.txt" ${ordre});sed -n "${ligne}p" ${cible};ligne=$((ligne+1));done < <(for ((i=1;i<21;i++));do echo $i;done |sort -R|sed '10q')
F17-Q1
F09-Q2
F01-Q3
F08-Q4
F14-Q5
F03-Q6
F07-Q7
F15-Q8
F11-Q9
F13-Q10
$ ligne=1; while read ordre; do cible=$(printf "QE-%02i.txt" ${ordre});sed -n "${ligne}p" ${cible};ligne=$((ligne+1));done < <(for ((i=1;i<21;i++));do echo $i;done |sort -R|sed '10q')
F14-Q1
F01-Q2
F18-Q3
F10-Q4
F08-Q5
F07-Q6
F12-Q7
F03-Q8
F05-Q9
F04-Q10

Avec une boucle for on crée un fichier de 20 lignes que l'on mélange, et on ne garde que les 10 premières.
Avec ce résultat, on alimente la boucle while qui lira ligne à ligne. Attention ! L'espace entre les < < est important.
Il suffit de reconstituer le nom de fichier et de ne prendre qu'une ligne avec sed.

[Celano]

Merci Flo. Je suis scotché!

Merci beaucoup pour ces belles explications bien détaillées