Parcours tableau avec sous-tableaux

Version imprimable

Bonjour,

J'aimerais parcourir un tableau qui m'est donné sous la forme suivante par un programme PL/SQL :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 [["9226 mesure ECOOL f",0, ["9227 mesure ECOOL f",0, ["9240 TD62 - Tracés au sol f"], ["10872 mesure ECOOL t",0, ["10873 mesure ECOOL t"] ], ], ["9228 TD68 f",0, ["9241 TD68 - Tracés au sol t"], ["10905 mesure ECOOL t",0, ["10906 mesure ECOOL t"] ] ] ]]
Ce tableau représente un arbre, les éléments suivi d'un 0 étant les noeuds.

J'aimerais retirer tous les éléments qui se terminent par ' f' (en enlevant en plus le 0 si c'est un noeud).

Par exemple avec le tableau ci-dessus je pense qu'on devrais obtenir ceci :
Code:

1 2 3 4 5 6 7 8 9 [ ["10872 mesure ECOOL t",0, ["10873 mesure ECOOL t"] ], ["9241 TD68 - Tracés au sol t"], ["10905 mesure ECOOL t",0, ["10906 mesure ECOOL t"] ] ]
J'ai essayer diverses choses, notamment en fonctions récursives mais j'ai vraiment du mal, une petite aide serait la bienvenue :)

Merci.

21/06/2010, 19h58
supersnail

Bonjour,

Peux-tu nous montrer ce que tu as essayé?
21/06/2010, 20h14
Yann39

Salut,

J'ai laissé tout le code au bureau. :aie:
Je poste ça demain matin à la première heure.

Mais SpaceFrog m'a fait un truc pas mal juste après sur le chat, ça fonctionne presque, ya juste 2/3 trucs que je n'arrive pas à règler.

On vois ça demain !

Merci ;)

Le code ®SpaceFrog un poil modifié :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 function recur(arr){ this.k=0; for(elt in arr){ if (typeof arr[this.k] == "string") { if (/ f$/.test(arr[this.k])){ alert(arr[this.k]); arr.splice(this.k,1); /*if (arr[this.k] == 0) arr.splice(this.k,1);*/ } } else { new recur(arr[this.k]); } this.k++; } }
Le code en commentaire c'est pour enlever le 0 qui suit si c'est un noeud.

Le alert m'affiche bien un à un tous les éléments finissant par ' f', donc il devrait bien les retirer mais apparement le splice ne fonctionne pas comme je pense...

Le tableau avant traitement :

Code:

9226 mesure ECOOL f,0,9227 mesure ECOOL f,0,9240 TD62 - Tracés au sol f,10872 mesure ECOOL t,0,10873 mesure ECOOL t,9228 TD68 f,0,9241 TD68 - Tracés au sol t,10905 mesure ECOOL t,0,10906 mesure ECOOL t

Le tableau après traitement :

Code:

0,0,,10872 mesure ECOOL t,0,10873 mesure ECOOL t,0,9241 TD68 - Tracés au sol t,10905 mesure ECOOL t,0,10906 mesure ECOOL t

D'ailleurs lorsque j'affiche les tableaux remarquez que je perd la hiérarchie, il affiche juste les éléments séparés par des virgules.

Bon je dois vraiment être bête, je ne m'en sort pas :?

un fichier de test :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
var gReturn = '[["9226 mesure ECOOL f",0,["9227 mesure ECOOL f",0,["9240 TD62 - Tracés au sol f"],["10872 mesure ECOOL t",0,["10873 mesure ECOOL t"]],],["9228 TD68 f",0,["9241 TD68 - Tracés au sol t"],["10905 mesure ECOOL t",0,["10906 mesure ECOOL t"]]]]]';
var TREE_ITEMS = eval(gReturn);
alert(TREE_ITEMS);
recur(TREE_ITEMS);
alert(TREE_ITEMS);
 
function recur(arr){
	for(var k=0;k<arr.length;k++){
		if (typeof arr[k] == "string") { 		
			if (arr[k].substr(arr[k].length-2,2) == ' f') {
				arr.splice(k,1);
				/*if (arr[k] == 0) {
					arr.splice(k,1);
				}*/
			}
		}
		else {
			new recur(arr[k]); 
		}
	}
}

A l'aide d'une fonction var_dump pour afficher le tableau (merci supersnail ;)) j'obtient :

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
Array => [
    0: Array => [    
        0: Other: 0
        1: Array => [        
            0: Other: 0
            1: Array => [            
            ]
            2: Array => [            
                0: String: "10872 mesure ECOOL t"
                1: Other: 0
                2: Array => [                
                    0: String: "10873 mesure ECOOL t"
                ]
            ]
        ]
        2: Array => [        
            0: Other: 0
            1: Array => [            
                0: String: "9241 TD68 - Tracés au sol t"
            ]
            2: Array => [            
                0: String: "10905 mesure ECOOL t"
                1: Other: 0
                2: Array => [                
                    0: String: "10906 mesure ECOOL t"
                ]
            ]
        ]
    ]
]

Ce qui est normal (les valeurs finissant par f sont bien supprimées), il faut juste que je supprime les tableaux vides, mais comment faire ? => trouvé

Par contre si je décommente le if dans la fonction (pour supprimer le 0), j'obtiens :

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
Array => [
    0: Array => [    
        0: Array => [        
            0: String: "9227 mesure ECOOL f"
            1: Other: 0
            2: Array => [            
                0: String: "9240 TD62 - Tracés au sol f"
            ]
            3: Array => [            
                0: String: "10872 mesure ECOOL t"
                1: Other: 0
                2: Array => [                
                    0: String: "10873 mesure ECOOL t"
                ]
            ]
        ]
        1: Array => [        
            0: Array => [            
                0: String: "9241 TD68 - Tracés au sol t"
            ]
            1: Array => [            
                0: String: "10905 mesure ECOOL t"
                1: Other: 0
                2: Array => [                
                    0: String: "10906 mesure ECOOL t"
                ]
            ]
        ]
    ]
]

Donc là ca fait n'importe quoi, il reste des valeurs finissant par f, même si les 0 correspondant aux 2 valeurs qui n'apparaissent pas sont bien supprimés.

Si vous avez une idée. Merci.

EDIT : OK j'arrive à supprimer les tableaux vides en ajoutant simplement ceci à la fonction après l'appel récursif :

Code:

1
2
3
if (arr[k].length == 0) {
	arr.splice(k,1);
}

Ca y est, en ajoutant

Code:

k--;

dans le

Code:

if (arr[k] == 0)

ça semble fonctionner, ne me demandez pas pourquoi :aie:

Mais dans tous les cas mon script qui construit correctement l'arbre lorsqu'il n'est pas filtré, n'arrive pas à le construire après ce traitement. La structure obtenue doit être mauvaise (sûrement à cause des array imbriqués), par exemple maintenant j'obtiens ça :

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
Array => [
    0: Array => [    
        0: Array => [        
            0: Array => [            
                0: String: "10872 mesure ECOOL t"
                1: Other: 0
                2: Array => [                
                    0: String: "10873 mesure ECOOL t"
                ]
            ]
        ]
        1: Array => [        
            0: Array => [            
                0: String: "9241 TD68 - Tracés au sol t"
            ]
            1: Array => [            
                0: String: "10905 mesure ECOOL t"
                1: Other: 0
                2: Array => [                
                    0: String: "10906 mesure ECOOL t"
                ]
            ]
        ]
    ]
]

Il y a des array inutiles, je pense que c'est la cause.

Bref j'y reviendrai plus tard quand j'aurai plus de temps car là il faut que j'avance sur d'autres choses. Merci à ceux qui m'ont aidé (SpaceFrog et supersnail).

à+ !

23/06/2010, 11h31
supersnail

Bonjour,

Tu peux nous montrer le code modifié s'il te plaît?

Salut,

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
var gReturn = '[["9226 mesure ECOOL f",0,["9227 mesure ECOOL f",0,["9240 TD62 - Tracés au sol f"],["10872 mesure ECOOL t",0,["10873 mesure ECOOL t"]],],["9228 TD68 f",0,["9241 TD68 - Tracés au sol t"],["10905 mesure ECOOL t",0,["10906 mesure ECOOL t"]]]]]';
var TREE_ITEMS = eval(gReturn);
alert(TREE_ITEMS);
recur(TREE_ITEMS);
alert(TREE_ITEMS);
 
function recur(arr){
	for(var k=0;k<arr.length;k++){
		if (typeof arr[k] == "string") { 		
			if (/ f$/.test(arr[k])) {
				arr.splice(k,1);
				if (arr[k] == 0) 
					arr.splice(k--,1);
			}
		}
		else {
			new recur(arr[k]); 
			if (arr[k].length == 0) 
				arr.splice(k,1);
		}
	}
}

Ca fonctionne parfaitement, il reste juste des array en trop (inutiles), c'est ce que mon script qui construit l'arbre semble ne pas aimer.

EDIT :

Par exemple la sortie obtenue :

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
Array => [
    0: Array => [    
        0: Array => [        
            0: Array => [            
                0: String: "10872 mesure ECOOL t"
                1: Other: 0
                2: Array => [                
                    0: String: "10873 mesure ECOOL t"
                ]
            ]
        ]
        1: Array => [        
            0: Array => [            
                0: String: "9241 TD68 - Tracés au sol t"
            ]
            1: Array => [            
                0: String: "10905 mesure ECOOL t"
                1: Other: 0
                2: Array => [                
                    0: String: "10906 mesure ECOOL t"
                ]
            ]
        ]
    ]
]

correspond à :

Code:

'[[[["10872 mesure ECOOL t",0,["10873 mesure ECOOL t"]]],[["9241 TD68 - Tracés au sol t"],["10905 mesure ECOOL t",0,["10906 mesure ECOOL t"]]]]]'

Alors qu'il faudrait que ça retourne :

Code:

'[["10872 mesure ECOOL t",0,["10873 mesure ECOOL t"]],["9241 TD68 - Traces au sol t"],["10905 mesure ECOOL t",0,["10906 mesure ECOOL t"]]]'

J'ai testé manuellement et c'est bien ça le problème apparement.

23/06/2010, 11h51
supersnail
Essaie peut-être de faire ceci:
Code:

1 2 3 4 5 6 7 8 9 if (typeof arr[k] == "string") { if (/ f$/.test(arr[k])) { if (arr[k+1] == 0) arr.splice(k+1,1); arr.splice(k,1); } }
En gros, si le tableau se finit par un "f", je regarde si l'élément suivant est un zéro. Si c'est le cas je le supprime, avant de supprimer l'élément actuel.

Bref: essaie ça,et dis-moi si ça marche ;)
23/06/2010, 11h59
Yann39

J'ai reglé le problème des 0, mon code fonctionne (et le tient aussi sûrement!) ;)

Il me reste plus qu'a supprimer ces tableaux en trop.
23/06/2010, 12h36
devyan

Bonjour,

J'ai un doute quand à la méthode utilisée pour "nettoyer" l'arbre...

En effet, si j'ai bien compris, la suppression d'un noeud n'entraîne pas la disparition de ses enfants mais ils deviennent enfants du père du noeud supprimé.

Il faudrait donc créer l'arbre "réponse" lors du parcours de l'arbre initial.

devyan
23/06/2010, 13h54
Yann39

Oui voilà c'est ça.

C'est en fait un filtrage d'arbre, n'importe quelle valeur peut être supprimée, et il faut que l'arbre reste "constructible".

Tu veux dire recréer un tableau au fur et à mesure du parcours, avec des push(), etc... ? Je trouve ça plus compliqué moi non, dans le cas d'un tableau simple d'accord, mais là c'est récursif, c'est pour ça que je n'y arrive pas d'ailleurs :aie: je ne suis pas fait pour la recurtivi... récurvisit... tu vois ! :mrgreen:
23/06/2010, 17h09
devyan

Citation:

Envoyé par Yann39

Oui voilà c'est ça.

C'est en fait un filtrage d'arbre, n'importe quelle valeur peut être supprimée, et il faut que l'arbre reste "constructible".

Tu veux dire recréer un tableau au fur et à mesure du parcours, avec des push(), etc... ? Je trouve ça plus compliqué moi non, dans le cas d'un tableau simple d'accord, mais là c'est récursif, c'est pour ça que je n'y arrive pas d'ailleurs :aie: je ne suis pas fait pour la recurtivi... récurvisit... tu vois ! :mrgreen:

Plus compliqué je ne sais pas mais plus faisable, à mon avis oui (mais ce n'est que mon avis et je le partage) ;)

Ta demande ne correspond pas à un élagage simple mais à réaliser des couper/coller dans ton arbre.
23/06/2010, 17h23
Yann39

Sinon je pourrais directement modifier ma petite fonction PL/SQL qui génère le tableau, mais j'ai déja passer plus d'une journée entière sans succès, alors j'avais laissé tombé.

Peut-être devrais-je faire un post dans la section PL/SQL.