suppréssion particulière de doublons

[Sasophile]

Bonjour,
j'ai une table du type :

Identifiant 1 identifiant 2
1 1
1 2
2 1
2 2

J'aimerai faire un tri de manière à supprimer les lignes où on retrouverai soit l'identifiant 1 soit l'identifiant 2.

Autrement dit, l'objectif est d'avoir un résultat semblable à :
Identifiant 1 identifiant 2
1 1
2 2

ou


Identifiant 1 identifiant 2
1 2
2 1

merci d'avance

[Manoutz]

dans ton exmple de sorties, dans les deux cas tes variables identifiant1 et identifiant2 sont présentes, et dans les deux cas également les différents identifiants de ta variable apparaissent...

je te donne en tout cas le code qui permet de générer les deux tables de sortie à de ta table entrée:

Code :

1
2
3
4
5
DATA table2 table3;
SET table1;
IF identifiant1=identifiant2 then output table2;
else output table3;
run;

[Sasophile]

Merci, mais je me rend compte que je n'ai pas été assez clair.
Et mon exemple est trompeur.
Voyons ça autrement,

V1 V2

01 AB
01 CD
01 EF
02 AB
02 CD

L'objectif est que chaque individus identifié par V1 ne soit lié qu'a un individu lié à V2 et vice-versa

là, mes résultats possibles (et je n'ai aucune préférence) seraient,

V1 V2
01 AB
02 CD

ou
V1 V2
01 CD
02 AB

ou
V1 V2
01 EF
02 AB

ou

V1 V2
01 EF
02 CD


pas certain d'être beaucoup plus précis ...

[Manoutz]

.... oui et non.

je pense voir ou tu veux en venir, mais il existe une combinaison infinie de sorties possibles pour peu que ton dataset entrée ait un minimum de lignes. Je rajoute la contrainte "il ne m'importe pas de savoir quelle est supprimée tant que je n'ai pas de doublons dans ma table finale".
mais tu tu peux faire par exemple deux proc sort avec un nodupkey et un out=. dans ton by , tu mettras une variable dans le premier sort , puis les deux variables dans ton deuxième sort

[Manoutz]

une solution peut etre meilleure:

Code :

1
2
3
4
5
6
7
8
9
10
 
proc sort DATA=entree out=temp;
BY v1 v2;
run;
 
DATA sortie;
SET temp;
BY v1;
IF first.v1;
run;

[Sasophile]

non, cela ne marche pas.
Je me retrouve avec la première ligne de V2 pour chaque individu de V1.
Je vais continuer à chercher.
Merci tout de même

[Manoutz]

OK donc il faut rajouter d'autres contraintes à ton problème, comme "pas de doublons dans V1 ET dans V2".

Il serait bien que tu fournisses un jeu de données sas (ou une étape data le générant) pour pouvoir tester ca. A prioiri je m'orienterais vers une approche proche de ma première proposition. A tester.

Manoutz

[olivier.decourt]

Alors si j'ai bien compris, l'idée est d'avoir en résultat des observations avec des valeurs uniques de V1 et V2, prises séparément, avec comme contrainte que le couple V1,V2 appartienne aux données d'origine.
En réfléchissant à la question ce week-end, j'imaginais une petite variante du jeu de données, genre
V1 V2
----------
01 CD
01 EF
02 AB
02 EF
03 CD
qui n'a qu'une seule solution. Et qu'il ne faudrait pas modifier beaucoup pour qu'il n'existe pas de solution du tout.
Alors ça me semble un genre d'allocation optimale, et plutôt que de bricoler des macros il serait peut-être malin (si tu as le module SAS/OR) d'aller chercher dans des procédures comme OPTMODEL ou NETFLOW ou autres (je ne connais quasiment rien à OR et à ce genre de problèmes).
Bon courage.
Olivier

[Manoutz]

qui n'a qu'une seule solution. Et qu'il ne faudrait pas modifier beaucoup pour qu'il n'existe pas de solution du tout.

+1

Mais avant de se lancer dans des procédures particulières (ce qui m'intéresse même si je n'ai dans ce cas pas les ressources pour vous aider), je pense par pragmatisme qu'il peut être bon de regarder le jeu de données afin de voir la complexité du problème. S'il y a peu de doublons il y a peut être moyen de s'en sortir via une petite bidouille toute bête. En ce sens je commencerais par un petit tableau de fréquence pour chacune des deux variables, couplée à un regard du jeu de donnée...

[suistrop]

Bonjour,

Un peu la flemme d'automatiser, sur cet exemple regarde ce code :

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
DATA aa;
INPUT VAR1 $  VAR2 $ ;
CARDS ;
01 AB
01 CD
01 EF
02 AB
02 CD
;
run;
DATA aa1;
	SET aa;
IF var1 = "01";
RENAME VAR2 = VAR2_1;
label VAR2 = VAR2_1;
DROP var1;
run;
DATA aa2;
	SET aa;
IF var1 = "02";
RENAME VAR2 = VAR2_2;
label VAR2 = VAR2_2;
DROP var1;
run;
 
proc sql;
CREATE TABLE zz AS
SELECT * FROM aa1, aa2
;
quit;

Dans la table zz suffit de prendre les lignes ou les variables ne sont pas egale.

Suistrop

[MEGAMIND2]

Voici la version macro, reste à savoir si on doit supprimer les cas où
VAR2_1=AB VAR2_2=CD
VAR2_1=CD VAR2_2=AB

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
DATA aa;
INPUT VAR1 $  VAR2 $ ;
CARDS ;
01 AB
01 CD
01 EF
02 AB
02 CD
;
run;
 
proc sort DATA=aa nodupkey out=aaa;
BY VAR1;
run;
proc sql;
SELECT VAR1 INTO: l separated BY ' ' FROM aaa;
SELECT count(*) INTO: NB  FROM aaa;
quit;
 
%MACRO M;
%DO i=1 %TO 2;
%let l&i=%scan(&l,&i,' ');
DATA var_&i.;
SET aa;
WHERE VAR1="&&l&i.";
RENAME VAR2 = VAR2_&i;
label VAR2 = VAR2_&i;
DROP var1;
run;
%END;
%MEND;
proc sql;
CREATE TABLE zz AS
SELECT * FROM var_1, var_2 WHERE VAR2_1 ne VAR2_2
;
quit;
 
 
%M;

[z6c3po]

puisque, si j'ai bien compris, V1 et V2 ne doivent jamais être observés deux fois, ce petit programme doit fonctionner (pas super testé parce que bricolé un peu vite...)

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
 
 
** construction de la TABLE ;
DATA test (DROP=i j);
   DO i=1 TO 100;
      V1=round(ranuni(25)*200,1);
      DO j=1 TO 25;
         V2=put(round(ranuni(25)*100,1),3.);
		 alea=ranuni(-55);
         output;
      end;
   end;
run;
 
proc sort DATA=test;
   BY alea;
run;
 
proc sort DATA=test out=temp nodupkeys;
   BY v1;
run;
 
DATA _null_;
   SET temp;
   call symput("n",_n_);
run;
** la macro N donne le nombre max d'itérations dans la macro (ça s'arrête en fait avant...);
 
%macro hop ;
 
DATA test test3;
   SET test;
   IF _n_=1 then do ;
   output test3;
   call symput("sup",v2);
   call symput("sip",v1);
   end;
else output test;
run;
 
**proc append base=final DATA=test3;
**run;
** idiot...;
DATA final;
SET test3;
run;
 
%do i=2 %TO &n ;
DATA test test3;
   SET test (WHERE=(v2 ne "&sup" AND v1 ne &sip));
   IF _n_=1 then do ;
      output test3;
      call symput("sup",v2);
      call symput("sip",v1);
   end;
   else output test;
run;
 
proc append base=final DATA=test3;
run;
 
%end;
%mend;
 
%hop

et à chaque exécution, vous obtenez une table différente (mais qui doit respecter les contraintes)

Cordialement

Sébastien Ringuedé

[MEGAMIND2]

Bonjour Sébastien,
Tu aurais pu appliquer à son cas car il y a trop de lignes pour constater le dédoublonnage. J'ai pas dit que c'est faux, loin de là.
Bonne journée

[z6c3po]

ben il suffit de remplacer mon étape data du départ par :

Code :

1
2
3
4
5
6
7
8
9
10
11
 
DATA test;
input v1 v2 $;
alea=ranuni(-5);
cards;
01 AB
01 CD
01 EF
02 AB
02 CD
;

et re-hop