classer une liste avec dates en liste avec périodes

**concombre_masqué** · 19/02/2010, 10h16

Bonjour,
Je ne sais pas si je poste au bon endroit. J'ai une liste de données qui a l'aspect suivant:
personne - activité - durée - jours - date
X - ACT1 - 7,35 - 1 - 02/06/2009
X - ACT1 - 7,35 - 1 - 03/06/2009
X - ACT1 - 7,35 - 1 - 04/06/2009
X - ACT1 - 7,35 - 1 - 27/07/2009
X - ACT2 - 7,35 - 1 - 30/11/2009
Y - ACT1 - 7,35 - 1 - 02/06/2009
Y - ACT1 - 7,35 - 1 - 03/06/2009

Je veux le transformer en une liste avec l'aspect suivant
personne - activité - durée - jours - période
X - ACT1 - 22,05 - 3 - du 02/06/2009 au 04/06/2009
X - ACT1 - 7,35 - 1 - du 27/07/2009 au 27/07/2009
X - ACT2 - 7,35 - 1 - du 30/11/2009 au 30/11/2009
Y - ACT1 - 14,70 - 2 - du 02/06/2009 au 03/06/2009

Comment faire cela de la manière la plus simple/efficace possible ???

Merci !

**Jimmy_** · 19/02/2010, 11h21

Voici l'idée générale :

Dans un premier temps il te faut trier ton tableau,
par personne, activité et date.

Ensuite tu parcours ta liste à l'aide de 3 boucles imbriquées.
Après c'est des ruptures classique sur ces trois critères pour réaliser tes cumuls et tes periodes.
Tu obtients un algo de complexité linéaire très rapide.

**concombre_masqué** · 19/02/2010, 11h34

Merci pour ta réponse.

Aurais-tu un exemple concret ? j'ai un peu de mal avec les ruptures.

Merci beaucoup

**Jimmy_** · 19/02/2010, 13h41

Voici un exemple à super grosses mailles en java sur 2 niveaux : personne et activité

Je te laisse implementer le 3eme sur les dates, mais le principe est le même.

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
 
 
public class Rupture {
 
	static String MaListe[][] ={ 
		{"X","ACT1","7.35","1","02/04/2009"},
		{"X","ACT1","7.35","1","03/06/2009"},
		{"X","ACT1","7.35","1","04/06/2009"},
		{"X","ACT1","7.35","1","27/07/2009"},
		{"X","ACT2","7.35","1","30/11/2009"},
		{"Y","ACT1","7.35","1","02/06/2009"},
		{"Y","ACT1","7.35","1","03/06/2009"}	
	};
 
 
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int max = MaListe.length;
		int i = 0;
		float cumul = 0;
 
		// initialisation
		String personne_c = MaListe[0][0]; 
		String activite_c = MaListe[0][1];
		String personne_p = MaListe[0][0]; 
		String activite_p = MaListe[0][1];
 
		while ((personne_c == personne_p)&&(i<max))
		{
			while ((personne_c == personne_p)&&(activite_c == activite_p))
			{
				personne_p = MaListe[i][0]; 
				activite_p = MaListe[i][1];
 
				cumul += Float.valueOf(MaListe[i][2]);	
				i++;
				if (i == max) break;
 
				personne_c = MaListe[i][0]; 
				activite_c = MaListe[i][1];
			}
 
			System.out.print("Ligne : " + personne_p + " " + activite_p + " : " + cumul + "\n");
			cumul = 0;
			personne_p = personne_c; 
			activite_p = activite_c;
 
		}
 
		System.out.print("Fin.");
 
 
	}
 
}

**eyquem** · 19/02/2010, 13h58

Bonjour,

Intéressant problème. Je l’ai codé en 1h14, montre en main, pour voir, avec Python. Je pensais mettre moins de temps quand même.

Ce n’est peut être pas très pédagogique de donner un code tout fait. Mais je pense que tu n’utilises pas Python et tu auras ainsi à faire ton propre code. Et comme Python est quasiment du pseudo-code, dit on, et que je ne sais pas trop quelles sont les notions et les conventions de présentation en algorithmique, je livre ma soluce qui pourra peut être t’intéresser.

Le principe de mon programme est de constituer un dictionnaire clés-valeurs dont chauqe élément est une liste rassemblant les lignes de la liste de départ qui aient en commun:
personne - activité - mois
D’aprés ce que tu as écrit, les périodes sont les mois.

Le code nu:

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
#personne - activité - durée - jours - date
li = ['Xerxes - ACT1 - 7,35 - 1 - 05/06/2009', #
      'Xerxes - ACT1 - 7,35 - 1 - 18/06/2009', # max pour 06/2009
      'Jo - ACT1 - 8,00 - 1 - 29/03/2005',
      'Xerxes - ACT1 - 7,35 - 1 - 04/06/2009', #
      'Xerxes - ACT1 - 7,35 - 1 - 27/07/2009',
      'Jo - ACT2 - 13,00 - 1 - 23/12/2000',
      'Xerxes - ACT2 - 7,35 - 1 - 30/11/2009',
      'Yves - ACT1 - 7,35 - 1 - 02/06/2009',
      'Jo - ACT1 - 4,00 - 1 - 03/03/2005',
      'Xerxes - ACT1 - 5,00 - 1 - 09/06/2009',
      'Yves - ACT1 - 7,35 - 1 - 03/06/2009',
      'Jo - ACT3 - 2,00 - 1 - 01/01/2001',
      'Xerxes - ACT1 - 3,00 - 1 - 02/06/2009'] # min pour 06/2009
 
from collections import defaultdict
d = defaultdict(list)
 
for u in li:
    x = u.rsplit(' - ',3) 
    d[x[0] + x[3][3:]].append( ( x[3],float(x[1].replace(',','.')),int(x[2])) )
 
for u,li in d.iteritems():
    li.sort()
    jours = sum( elem[2] for elem in li)
    duree = sum( elem[1] for elem in li)
    print u[0:-7] + ' - ' + str(duree) + ' - ' + str(jours)\
          + ' - du ' + li[0][0] + ' au ' + li[-1][0]

Résultat

Xerxes - ACT1 - 30.05 - 5 - du 02/06/2009 au 18/06/2009
Xerxes - ACT1 - 7.35 - 1 - du 27/07/2009 au 27/07/2009
Xerxes - ACT2 - 7.35 - 1 - du 30/11/2009 au 30/11/2009
Jo - ACT2 - 13.0 - 1 - du 23/12/2000 au 23/12/2000
Jo - ACT1 - 12.0 - 2 - du 03/03/2005 au 29/03/2005
Jo - ACT3 - 2.0 - 1 - du 01/01/2001 au 01/01/2001
Yves - ACT1 - 14.7 - 2 - du 02/06/2009 au 03/06/2009

Le code expliqué:

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
#personne - activité - durée - jours - date
li = ['Xerxes - ACT1 - 7,35 - 1 - 05/06/2009', #
      'Xerxes - ACT1 - 7,35 - 1 - 18/06/2009', # max
      'Jo - ACT1 - 8,00 - 1 - 29/03/2005',
      'Xerxes - ACT1 - 7,35 - 1 - 04/06/2009', #
      'Xerxes - ACT1 - 7,35 - 1 - 27/07/2009',
      'Jo - ACT2 - 13,00 - 1 - 23/12/2000',
      'Xerxes - ACT2 - 7,35 - 1 - 30/11/2009',
      'Yves - ACT1 - 7,35 - 1 - 02/06/2009',
      'Jo - ACT1 - 4,00 - 1 - 03/03/2005',
      'Xerxes - ACT1 - 5,00 - 1 - 09/06/2009',
      'Yves - ACT1 - 7,35 - 1 - 03/06/2009',
      'Jo - ACT3 - 2,00 - 1 - 01/01/2001',
      'Xerxes - ACT1 - 3,00 - 1 - 02/06/2009'] # min
 
from collections import defaultdict
d = defaultdict(list)
 
print "Construction d'un dictionnaire avec les clés suivantes:\n"
for u in li:
    x = u.rsplit(' - ',3) 
    print 'x[0] + x[3][3:] =',x[0] + u[-7:]
    d[x[0] + x[3][3:]].append( ( x[3],float(x[1].replace(',','.')),int(x[2])) )
 
print '\n=====================================================\nExploitation du dictionnaire'
for u,li in d.iteritems():
    print '\n----------------------------------------\nkey         = ',u
    print 'value(list) = li =',li
    li.sort()
    print '\nTri de la liste li: li.sort()'
    print 'liste triee :\n' + '\n'.join(map(repr,li))
    print 'plus ancienne date : li[0][0] =',li[0][0]
    print 'plus recente date  : li[-1][0]',li[-1][0]
    jours = sum( elem[2] for elem in li)
    print 'jours =',jours
    duree = sum( elem[1] for elem in li)
    print 'duree =',duree
    print u[0:-7] + ' - ' + str(duree) + ' - ' + str(jours)\
          + ' - du ' + li[0][0] + ' au ' + li[-1][0]

>>>
Construction d'un dictionnaire avec les clés suivantes:

x[0] + x[3][3:] = Xerxes - ACT106/2009
x[0] + x[3][3:] = Xerxes - ACT106/2009
x[0] + x[3][3:] = Jo - ACT103/2005
x[0] + x[3][3:] = Xerxes - ACT106/2009
x[0] + x[3][3:] = Xerxes - ACT107/2009
x[0] + x[3][3:] = Jo - ACT212/2000
x[0] + x[3][3:] = Xerxes - ACT211/2009
x[0] + x[3][3:] = Yves - ACT106/2009
x[0] + x[3][3:] = Jo - ACT103/2005
x[0] + x[3][3:] = Xerxes - ACT106/2009
x[0] + x[3][3:] = Yves - ACT106/2009
x[0] + x[3][3:] = Jo - ACT301/2001
x[0] + x[3][3:] = Xerxes - ACT106/2009

=====================================================
Exploitation du dictionnaire

----------------------------------------
key = Xerxes - ACT106/2009
value(list) = li = [('05/06/2009', 7.3499999999999996, 1), ('18/06/2009', 7.3499999999999996, 1), ('04/06/2009', 7.3499999999999996, 1), ('09/06/2009', 5.0, 1), ('02/06/2009', 3.0, 1)]

Tri de la liste li: li.sort()
liste triee :
('02/06/2009', 3.0, 1)
('04/06/2009', 7.3499999999999996, 1)
('05/06/2009', 7.3499999999999996, 1)
('09/06/2009', 5.0, 1)
('18/06/2009', 7.3499999999999996, 1)
plus ancienne date : li[0][0] = 02/06/2009
plus recente date : li[-1][0] 18/06/2009
jours = 5
duree = 30.05
Xerxes - ACT1 - 30.05 - 5 - du 02/06/2009 au 18/06/2009

----------------------------------------
key = Xerxes - ACT107/2009
value(list) = li = [('27/07/2009', 7.3499999999999996, 1)]

Tri de la liste li: li.sort()
liste triee :
('27/07/2009', 7.3499999999999996, 1)
plus ancienne date : li[0][0] = 27/07/2009
plus recente date : li[-1][0] 27/07/2009
jours = 1
duree = 7.35
Xerxes - ACT1 - 7.35 - 1 - du 27/07/2009 au 27/07/2009

----------------------------------------
key = Xerxes - ACT211/2009
value(list) = li = [('30/11/2009', 7.3499999999999996, 1)]

Tri de la liste li: li.sort()
liste triee :
('30/11/2009', 7.3499999999999996, 1)
plus ancienne date : li[0][0] = 30/11/2009
plus recente date : li[-1][0] 30/11/2009
jours = 1
duree = 7.35
Xerxes - ACT2 - 7.35 - 1 - du 30/11/2009 au 30/11/2009

----------------------------------------
key = Jo - ACT212/2000
value(list) = li = [('23/12/2000', 13.0, 1)]

Tri de la liste li: li.sort()
liste triee :
('23/12/2000', 13.0, 1)
plus ancienne date : li[0][0] = 23/12/2000
plus recente date : li[-1][0] 23/12/2000
jours = 1
duree = 13.0
Jo - ACT2 - 13.0 - 1 - du 23/12/2000 au 23/12/2000

----------------------------------------
key = Jo - ACT103/2005
value(list) = li = [('29/03/2005', 8.0, 1), ('03/03/2005', 4.0, 1)]

Tri de la liste li: li.sort()
liste triee :
('03/03/2005', 4.0, 1)
('29/03/2005', 8.0, 1)
plus ancienne date : li[0][0] = 03/03/2005
plus recente date : li[-1][0] 29/03/2005
jours = 2
duree = 12.0
Jo - ACT1 - 12.0 - 2 - du 03/03/2005 au 29/03/2005

----------------------------------------
key = Jo - ACT301/2001
value(list) = li = [('01/01/2001', 2.0, 1)]

Tri de la liste li: li.sort()
liste triee :
('01/01/2001', 2.0, 1)
plus ancienne date : li[0][0] = 01/01/2001
plus recente date : li[-1][0] 01/01/2001
jours = 1
duree = 2.0
Jo - ACT3 - 2.0 - 1 - du 01/01/2001 au 01/01/2001

----------------------------------------
key = Yves - ACT106/2009
value(list) = li = [('02/06/2009', 7.3499999999999996, 1), ('03/06/2009', 7.3499999999999996, 1)]

Tri de la liste li: li.sort()
liste triee :
('02/06/2009', 7.3499999999999996, 1)
('03/06/2009', 7.3499999999999996, 1)
plus ancienne date : li[0][0] = 02/06/2009
plus recente date : li[-1][0] 03/06/2009
jours = 2
duree = 14.7
Yves - ACT1 - 14.7 - 2 - du 02/06/2009 au 03/06/2009
>>>

**concombre_masqué** · 19/02/2010, 14h45

Merci infiniment !

Effectivement c'est un pb qui a l'air simple mais qui ne l'est pas forcément...

Enfin je me suis bien pris la tête avec...

classer une liste avec dates en liste avec périodes

Algorithmes et structures de données

Vue hybride

Discussions similaires

Partager

Partager