groupement optimisé de séquence pour table de taille n

Version imprimable

Bonjour,

J'ai un ensemble de noeuds :

Code:

1
2
3
4
5
6
 
<x:row type='1'/>        1 élément @type='1'
<x:row type='2'/>        pour x éléments @type='2'
<x:row type='empty'/>        et 1 élément @type='empty'
 
etc. cela se répète y fois.

Je cherche à placer un maximum d'ensemble de noeuds du type 1, 2 et empty dans un tableau de n lignes :

Code:

1
2
3
4
5
6
 
<x:table nombreDeLignes="n">
<x:row type='1'/>        1 élément @type='1'
<x:row type='2'/>        pour x éléments @type='2'
<x:row type='empty'/>        et 1 élément @type='empty'
</x:table>

En vous remerciant de votre aide :)

01/03/2011, 17h34
thelvin

Un maximum ? C'est-à-dire, chaque répétition de l'ensemble montré doit se retrouver encadré de

Code:

<x:table nombreDeLignes="n">...</x:table>

?
Autrement dit, il y aurait y éléments <x:table> ?

Si c'est le cas, c'est un de ces cas chiants.
Une manière de le voir est de faire un Muench, dont le match porte sur <x:row> et le use porte sur un generate-id() du <x:row type="1"> qui commence la séquence.
Pas évident mais ça se fait.

Attention toutefois, j'ai déjà essayé de faire ce genre de trucs avec le moteur XSLT de base de Java, et il y a une anomalie quand on se sert de generate-id() dans le use, du coup ça ne marche pas.
Avec Saxon ça passe très bien.
01/03/2011, 22h56
Erwy

tu pourrais donner un exemple plus parlant parce que je ne comprends pas du tout le problème :(

Voici un exemple plus concret :

Mon ensemble de noeuds :

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
 
<!-- Premier sous-ensemble composé de 4 éléments -->
<x:row type='1'/>        
<x:row type='2'/>        
<x:row type='2'/> 
<x:row type='empty'/>    
 
<!-- Deuxième sous-ensemble composé de 3 éléments -->
<x:row type='1'/>        
<x:row type='2'/>        
<x:row type='empty'/>  
 
<!-- Troisième sous-ensemble composé de 6 éléments -->
<x:row type='1'/>        
<x:row type='2'/>        
<x:row type='2'/> 
<x:row type='2'/>        
<x:row type='2'/> 
<x:row type='empty'/>  
 
<!-- Quatrième sous-ensemble composé de 5 éléments -->
<x:row type='1'/>        
<x:row type='2'/>        
<x:row type='2'/> 
<x:row type='2'/>        
<x:row type='empty'/>

Et voici le résultat que je doit obtenir :

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
 
<!-- Dans ce premier tableau, je peux insérer les deux premiers sous-ensembles de noeuds, mais pas le troisième sous-ensemble. 
En effet, le premier sous-ensemble comprend 4 éléments et on a 4 <= 7, 
pour le deuxième ensemble de noeuds, on a 4 + 3 <= 7,
mais pour le troisième sous-ensemble, on a 4 + 3 + 6 > 7. -->
<x:table nombreDeLignes="7">
<x:row type='1'/>        
<x:row type='2'/>        
<x:row type='2'/> 
<x:row type='empty'/>        
<x:row type='1'/>        
<x:row type='2'/>        
<x:row type='empty'/>  
</x:table>
 
<!-- Dans ce deuxième tableau, je ne peux insérer que 
le troisième sous-ensemble de noeuds puisque 6 <= 7 
et que le quatrième sous-ensemble est trop grand 
puisque on a 6 + 5 > 7 -->
<x:table nombreDeLignes="7">
<x:row type='1'/>        
<x:row type='2'/>        
<x:row type='2'/> 
<x:row type='2'/>        
<x:row type='2'/> 
<x:row type='empty'/>  
</x:table>
 
<!-- Finalement, j'insère le quatrième sous-ensemble de noeuds dans un dernier tableau puisqu'il ne pouvait être contenu dans le tableau précédant -->
<x:table nombreDeLignes="7">
<x:row type='1'/>        
<x:row type='2'/>        
<x:row type='2'/> 
<x:row type='2'/>        
<x:row type='empty'/>  
</x:table>

J'ai bien entendu penser à Muench, mais sans avoir pu trouver de résultat !

02/03/2011, 09h47
Erwy

tes regroupements sont traités de façon séquentielle ou "optimisé" (minimum de table par exemple) ?

Pas du tout du muench là en tout cas, même pas sur que les clés nous servent à quelque chose
02/03/2011, 09h59
polymorphisme

Je dois obtenir un minimum de tableau, dit d'une autre façon, je dois mettre un maximum de sous-ensembles par tableau :)
02/03/2011, 10h06
Erwy

L'approche séquentielle est faisable en xslt 1.0, l'approche optimisé me paraît très douteuse.
02/03/2011, 11h19
Erwy

Bon après quelques tests ça me semble faisable et on a bien besoin des clés (en tout cas tel que je l'écris).

Commence à me faire vieux :triste:

Va me falloir un peu de temps pour écrire l'exemple par contre.

Bon après une petite pause déjeuner pour alimenter mon cerveau fatigué j'ai une solution à proposer :aie:

Il y a sans doute mieux et il faudrait mieux la tester sur plus de cas mais je n'ai pas trop le temps (détail, j'ai remplacé tes x:row par row, plus simple pour travailler)

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
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
	<xsl:output method="xml" version="1.0" encoding="UTF-8" indent="yes"/>
	<xsl:key name="group" match="row[@type!=1]" use="generate-id(preceding-sibling::*[@type=1][position()=1])"/>
	<xsl:variable name="ligne" select="7"/>
	<xsl:variable name="taille_min_group" select="3"/>
	<xsl:template match="test">
		<test>
			<xsl:call-template name="ajout">
				<xsl:with-param name="liste" select="/*/row[@type=1]"/>
				<xsl:with-param name="taille" select="$ligne"/>
			</xsl:call-template>
		</test>
	</xsl:template>
	<xsl:template name="ajout">
		<xsl:param name="liste"/>
		<xsl:param name="taille"/>
		<xsl:param name="table"/>
		<xsl:param name="taillePrec" select="0"/>
		<xsl:choose>
			<xsl:when test="$liste[1]">
				<xsl:choose>
					<xsl:when test="$liste[(count(key('group',generate-id(.)))+1)=$taille]">
						<xsl:variable name="noeud">
							<xsl:copy-of select="$table"/>
							<xsl:for-each select="($liste[(count(key('group',generate-id(.)))+1)=$taille])[1]">
								<xsl:copy-of select=".|key('group',generate-id(.))"/>
							</xsl:for-each>
						</xsl:variable>
						<xsl:choose>
							<xsl:when test="($taille + $taillePrec + $taille_min_group) &lt; ($ligne +1)">
								<xsl:call-template name="ajout">
									<xsl:with-param name="liste" select="$liste[generate-id(.)!=generate-id(($liste[(count(key('group',generate-id(.)))+1)=$taille])[1])]"/>
									<xsl:with-param name="taille" select="$ligne - ($taille + $taillePrec)"/>
									<xsl:with-param name="taillePrec" select="($taille + $taillePrec)"/>
									<xsl:with-param name="table" select="$noeud"/>
								</xsl:call-template>
							</xsl:when>
							<xsl:otherwise>
								<table>
									<xsl:copy-of select="$noeud"/>
								</table>
								<xsl:call-template name="ajout">
							<xsl:with-param name="liste" select="$liste[generate-id(.)!=generate-id(($liste[(count(key('group',generate-id(.)))+1)=$taille])[1])]"/>
							<xsl:with-param name="taille" select="$taille"/>
							<xsl:with-param name="taillePrec" select="0"/>
						</xsl:call-template>
								</xsl:otherwise>	
						</xsl:choose>
 
					</xsl:when>
					<xsl:otherwise>
						<xsl:call-template name="ajout">
							<xsl:with-param name="liste" select="$liste"/>
							<xsl:with-param name="taille" select="$taille - 1"/>
							<xsl:with-param name="taillePrec" select="$taillePrec"/>
							<xsl:with-param name="table" select="$table"/>
						</xsl:call-template>
					</xsl:otherwise>
				</xsl:choose>
			</xsl:when>
			<xsl:otherwise>
				<xsl:if test="$table">
					<table>
						<xsl:copy-of select="$table"/>
					</table>
				</xsl:if>
			</xsl:otherwise>
		</xsl:choose>
	</xsl:template>
</xsl:stylesheet>

02/03/2011, 23h01
polymorphisme

Bonjour Erwy,

tu t'est donné bien de la peine, tu m'aurais expliquer le principe j'aurais déjà été bien content :). Merci beaucoup.

Ceci étant, je vais tester cela dès demain à l'aide mon petit jeu de fichiers XML.
02/03/2011, 23h14
Erwy

Citation:

Envoyé par polymorphisme

tu t'est donné bien de la peine, tu m'aurais expliquer le principe j'aurais déjà été bien content :).

Je n'étais pas sûr de la validité du principe avant de le tester, ce qui l'aurait rendu ardu à expliquer :aie:
Puis ce n'est pas souvent qu'il y a un problème rigolo sur ce forum, bien le droit de m'amuser un peu :mouarf:
03/03/2011, 10h17
Loceka

J'ai pas vraiment regardé la solution (mon parseur mental de XSL est un peu mort ce matin) mais je ne pensais même pas qu'il puisse y avoir une solution en XSL. Bravo Erwy ! :hola:
03/03/2011, 10h48
Erwy

Merci.:D

Un détail que j'ai oublié, je n'ai pas fait de tri au départ sur les groupes qui sont plus grand que la table, si ce n'est pas fait mon algo plante .

A faire donc dans le premier appel au template nommé
03/03/2011, 10h51
polymorphisme

Bonjour,

j'avais noté en effet cela car c'est un cas que je rencontre.
03/03/2011, 11h03
Erwy

Citation:

Envoyé par polymorphisme

c'est un cas que je rencontre.

Tu le traite comment : en l'ignorant ou le casant quand même dans une table avec des lignes supplémentaires ?