Intersection de deux ensembles de chaînes

Version imprimable

06/05/2018, 11h14
PhilLU

Intersection de deux ensembles de chaînes
Bonjour,
Je cherche à utiliser les fonctions + et * sur des set of mais le set of string n'existe pas.
Cette possibilité existe bien dans python.
Code:

1 2 3 4 5 a = [1,2,3,4,"B"] b = [2, "B"] sa = set(a) sb = set(b) c = sa.intersection(sb)
Y a t'il une alternative?
Merci d'avance,
Phil
06/05/2018, 11h44
tourlourou

Bonjour,
Sur des chaînes ou des caractères ? Si caractères, sur un seul octet ? Si oui, ensembles de Byte en prenant leur code ASCII.
Sinon, je ne vois pas comment faire, surtout si sont mélangées des données de types différents dans l'ensemble.

[EDIT] si a = [1,2,"B"] crée en Python une chaîne de caractères de codes ASCII 1, 2 et Ord('B'), on peut mettre ces codes dans un ensemble en Pascal.

Bonjour,

en Delphi tu peux faire ça:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
type
  TA = (s1, s2, s3, s4, sB = ord('B'));
 //TA = (s1=1,s2=2,s3=3,s4=4,sB = ord('B'));
 
procedure TForm1.Button1Click(Sender: TObject);
var
  st1          : set of TA;
  st2          : set of TA;
begin
  st1 := [s1, s2, s4, sb];
  st2 := [s2, sb];
  if st1 * st2 = [s2, sb] then
    Caption := 'Ok';
end;

Cordialement,
@+

06/05/2018, 21h12
Roland Chastain

Bonjour ! Je ne comprends pas le titre de la discussion. Normalement ça devrait être "intersection entre deux ensembles de chaînes", non ?

Qu'est-ce que vous voulez faire exactement ?
06/05/2018, 21h57
PhilLU

Merci pour vos réponses ;-)
J'ai en fait deux ensemble de mots dont je dois détecter les mots semblables.
Exemple: ensemble 1: lapin, chien, oiseau
Ensemble 2: rat, chien, cheval
L'intersection retournée doit être chien
L'union doit être lapin, chien, oiseau, rat, cheval
Merci pour vos idées,
Phil

Vous pourriez utiliser le type TStringList en guise de type ensemble, et écrire les fonctions dont vous avez besoin, quelque chose comme ç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
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
{$APPTYPE CONSOLE}
 
{$R *.res}
 
uses
  System.SysUtils, System.Classes;
 
function Appartient(const aChaine: string; const aListe: TStringList): boolean;
begin
  result := aListe.IndexOf(aChaine) >= 0;
end;
 
function Intersection(const aListe1, aListe2: TStringList): TStringList;
var
  i: integer;
begin
  result := TStringList.Create;
  for i := 0 to Pred(aListe1.Count) do
    if Appartient(aListe1[i], aListe2) then
      result.Append(aListe1[i]);
end;
 
function Union(const aList1, aList2: TStringList): TStringList;
begin
 
end;
 
var
  vListe1, vListe2, vListe3: TStringList;
begin
  try
    vListe1 := TStringList.Create;
    vListe2 := TStringList.Create;
 
    vListe1.Append('lapin');
    vListe1.Append('chien');
    vListe1.Append('oiseau');
 
    vListe2.Append('rat');
    vListe2.Append('chien');
    vListe2.Append('cheval');
 
    vListe3 := Intersection(vListe1, vListe2);
 
    WriteLn(Appartient('lapin', vListe3)); // FALSE
    WriteLn(Appartient('chien', vListe3)); // TRUE
 
    vListe1.Free;
    vListe2.Free;
    vListe3.Free;
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
 
  ReadLn;
end.

On voit qu'il manque dans la TStringList, une surcharge de Assign avec TListAssignOp comme dans la TList, l'intersection peut se faire via laAnd

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
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
 
type
  TStringListSliteHelper = class helper for TStringList
  public
    procedure AssignEx(ListA: TStringList; AOperator: TListAssignOp; ListB: TStringList);
    function Exists(const S: string): Boolean;
  end;
 
 
procedure TStringListSliteHelper.AssignEx(ListA: TStringList; AOperator: TListAssignOp; ListB: TStringList);
var
  I: Integer;
  LTemp, LSource: TStringList;
begin
  // ListB given?
  if ListB <> nil then
  begin
    LSource := ListB;
    Assign(ListA);
  end
  else
    LSource := ListA;
 
  // on with the show
  case AOperator of
 
    // 12345, 346 = 346 : only those in the new list
    laCopy:
      begin
        Clear;
        Capacity := LSource.Capacity;
        for I := 0 to LSource.Count - 1 do
          Add(LSource[I]);
      end;
 
    // 12345, 346 = 34 : intersection of the two lists
    laAnd:
      for I := Count - 1 downto 0 do
        if LSource.IndexOf(Strings[I]) = -1 then
          Delete(I);
 
    // 12345, 346 = 123456 : union of the two lists
    laOr:
      for I := 0 to LSource.Count - 1 do
        if IndexOf(LSource[I]) = -1 then
          Add(LSource[I]);
 
    // 12345, 346 = 1256 : only those not in both lists
    laXor:
      begin
        LTemp := TStringList.Create; // Temp holder of 4 byte values
        try
          LTemp.Capacity := LSource.Count;
          for I := 0 to LSource.Count - 1 do
            if IndexOf(LSource[I]) = -1 then
              LTemp.Add(LSource[I]);
          for I := Count - 1 downto 0 do
            if LSource.IndexOf(Strings[I]) <> -1 then
              Delete(I);
          I := Count + LTemp.Count;
          if Capacity < I then
            Capacity := I;
          for I := 0 to LTemp.Count - 1 do
            Add(LTemp[I]);
        finally
          LTemp.Free;
        end;
      end;
 
    // 12345, 346 = 125 : only those unique to source
    laSrcUnique:
      for I := Count - 1 downto 0 do
        if LSource.IndexOf(Strings[I]) <> -1 then
          Delete(I);
 
    // 12345, 346 = 6 : only those unique to dest
    laDestUnique:
      begin
        LTemp := TStringList.Create;
        try
          LTemp.Capacity := LSource.Count;
          for I := LSource.Count - 1 downto 0 do
            if IndexOf(LSource[I]) = -1 then
              LTemp.Add(LSource[I]);
          Assign(LTemp);
        finally
          LTemp.Free;
        end;
      end;
  end;
end;
 
function TStringListSliteHelper.Exists(const S: string): Boolean;
begin
  Result := IndexOf(S) >= 0;
end;

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
procedure TZooThomVCLMainForm.btnTStringListAssignExClick(Sender: TObject);
var
  vListe1, vListe2, vListe3: TStringList;
begin
  try
    vListe1 := TStringList.Create;
    vListe2 := TStringList.Create;
 
    vListe1.Append('lapin');
    vListe1.Append('chien');
    vListe1.Append('oiseau');
 
    vListe2.Append('rat');
    vListe2.Append('chien');
    vListe2.Append('cheval');
 
    vListe3 := TStringList.Create;
    vListe3.AssignEx(vListe1, laAnd, vListe2);
 
    ShowMessage(BoolToStr(vListe3.Exists('lapin'), True)); // FALSE
    ShowMessage(BoolToStr(vListe3.Exists('chien'), True)); // TRUE
    ShowMessage(vListe3.Text);
 
 
    vListe1.Free;
    vListe2.Free;
    vListe3.Free;
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
end;

Et Si l'on parle de liste façon Python [1,2,3,4,"B"]

C'est à dire ['lapin', 'chien', 'chat', 123, 456, 789, 0.0123, 0.04567, 0.0789, 'oiseau'] comparé à ['rat', 'chien', 456, 0.04567, 'chat', 'cheval'], Delphi sait faire aussi avec un TList<Variant>

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
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
 
 
type
  TListAssistant<T> = class
  public
    class procedure AssignEx(List: TList<T>; ListA: TList<T>; AOperator: TListAssignOp; ListB: TList<T>);
  end;
 
  TVariantComparer = class(TComparer<Variant>)
    function Compare(const Left, Right: Variant): Integer; override;
  end;
 
class procedure TListAssistant<T>.AssignEx(List: TList<T>; ListA: TList<T>; AOperator: TListAssignOp; ListB: TList<T>);
var
  I: Integer;
  LTemp, LSource: TList<T>;
begin
  // ListB given?
  if ListB <> nil then
  begin
    LSource := ListB;
    List.AddRange(ListA);
  end
  else
    LSource := ListA;
 
  // on with the show
  case AOperator of
 
    // 12345, 346 = 346 : only those in the new list
    laCopy:
      begin
        List.Clear;
        List.Capacity := LSource.Capacity;
        for I := 0 to LSource.Count - 1 do
          List.Add(LSource[I]);
      end;
 
    // 12345, 346 = 34 : intersection of the two lists
    laAnd:
      for I := List.Count - 1 downto 0 do
        if LSource.IndexOf(List.Items[I]) = -1 then
          List.Delete(I);
 
    // 12345, 346 = 123456 : union of the two lists
    laOr:
      for I := 0 to LSource.Count - 1 do
        if List.IndexOf(LSource[I]) = -1 then
         List.Add(LSource[I]);
 
    // 12345, 346 = 1256 : only those not in both lists
    laXor:
      begin
        LTemp := TList<T>.Create; // Temp holder of 4 byte values
        try
          LTemp.Capacity := LSource.Count;
          for I := 0 to LSource.Count - 1 do
            if List.IndexOf(LSource[I]) = -1 then
              LTemp.Add(LSource[I]);
          for I := List.Count - 1 downto 0 do
            if LSource.IndexOf(List.Items[I]) <> -1 then
              List.Delete(I);
          I := List.Count + LTemp.Count;
          if List.Capacity < I then
            List.Capacity := I;
          for I := 0 to LTemp.Count - 1 do
            List.Add(LTemp[I]);
        finally
          LTemp.Free;
        end;
      end;
 
    // 12345, 346 = 125 : only those unique to source
    laSrcUnique:
      for I := List.Count - 1 downto 0 do
        if LSource.IndexOf(List.Items[I]) <> -1 then
          List.Delete(I);
 
    // 12345, 346 = 6 : only those unique to dest
    laDestUnique:
      begin
        LTemp := TList<T>.Create;
        try
          LTemp.Capacity := LSource.Count;
          for I := LSource.Count - 1 downto 0 do
            if List.IndexOf(LSource[I]) = -1 then
              LTemp.Add(LSource[I]);
          List.AddRange(LTemp);
        finally
          LTemp.Free;
        end;
      end;
  end;
end;
 
{ TVariantComparer }
 
function TVariantComparer.Compare(const Left, Right: Variant): Integer;
begin
  if (VarType(Left) = VarType(Right)) or (VarIsNumeric(Left) = VarIsNumeric(Right)) then
    Result := Ord(VarCompareValue(Left, Right))
  else
    Result := VarType(Right) - VarType(Left);
end;

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
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
 
 
procedure TZooThomVCLMainForm.btnTStringListAssignExClick(Sender: TObject);
var
  vListe1, vListe2, vListe3: TStringList;
  vListeG1, vListeG2, vListeG3: TList<string>;
  vListeV1, vListeV2, vListeV3: TList<Variant>;
  S: string;
begin
  vListe1 := TStringList.Create;
  try
    vListe2 := TStringList.Create;
    try
      vListe1.Append('lapin');
      vListe1.Append('chien');
      vListe1.Append('oiseau');
 
      vListe2.Append('rat');
      vListe2.Append('chien');
      vListe2.Append('cheval');
 
      vListe3 := TStringList.Create;
      try
        vListe3.AssignEx(vListe1, laAnd, vListe2);
 
        S := BoolToStr(vListe3.Exists('lapin'), True) // FALSE
          + sLineBreak + BoolToStr(vListe3.Exists('lapin'), True) // FALSE
          + sLineBreak + vListe3.Text;
        ShowMessage(S);
      finally
        vListe3.Free;
      end;
    finally
      vListe2.Free;
    end;
  finally
    vListe1.Free;
  end;
 
 
  vListeG1 := TList<string>.Create;
  try
    vListeG2 := TList<string>.Create;
    try
      vListeG1.Add('lapin');
      vListeG1.Add('chien');
      vListeG1.Add('chat');
      vListeG1.Add('oiseau');
 
      vListeG2.Add('rat');
      vListeG2.Add('chien');
      vListeG2.Add('chat');
      vListeG2.Add('cheval');
 
      vListeG3 := TList<string>.Create;
      try
        TListAssistant<string>.AssignEx(vListeG3, vListeG1, laAnd, vListeG2);
 
        S := BoolToStr(vListeG3.Contains('lapin'), True) // FALSE
          + sLineBreak + BoolToStr(vListeG3.Contains('chien'), True) // TRUE
          + sLineBreak + BoolToStr(vListeG3.Contains('chat'), True); // TRUE
        ShowMessage(S);
 
      finally
        vListeG3.Free;
      end;
    finally
      vListeG2.Free;
    end;
  finally
    vListeG1.Free;
  end;
 
 
  vListeV1 := TList<Variant>.Create(TVariantComparer.Create());
  try
    vListeV2 := TList<Variant>.Create(TVariantComparer.Create());
    try
      vListeV1.Add('lapin');
      vListeV1.Add('chien');
      vListeV1.Add('chat');
      vListeV1.Add(123);
      vListeV1.Add(456);
      vListeV1.Add(789);
      vListeV1.Add(0.0123);
      vListeV1.Add(0.04567);
      vListeV1.Add(0.0789);
      vListeV1.Add('oiseau');
 
      vListeV2.Add('rat');
      vListeV2.Add('chien');
      vListeV2.Add(456);
      vListeV2.Add(0.04567);
      vListeV2.Add('chat');
      vListeV2.Add('cheval');
 
      vListeV3 := TList<Variant>.Create(TVariantComparer.Create());
      try
        TListAssistant<Variant>.AssignEx(vListeV3, vListeV1, laAnd, vListeV2);
 
        S := BoolToStr(vListeV3.Contains('lapin'), True) // FALSE
          + sLineBreak + BoolToStr(vListeV3.Contains('lapin'), True) // FALSE
          + sLineBreak + BoolToStr(vListeV3.Contains('chien'), True) // TRUE
          + sLineBreak + BoolToStr(vListeV3.Contains('chat'), True) // TRUE
          + sLineBreak + BoolToStr(vListeV3.Contains(123), True) // FALSE
          + sLineBreak + BoolToStr(vListeV3.Contains(456), True) // TRUE
          + sLineBreak + BoolToStr(vListeV3.Contains(0.0456), True) // FALSE
          + sLineBreak + BoolToStr(vListeV3.Contains(0.04567), True); // TRUE
 
        ShowMessage(S);
      finally
        vListeV3.Free;
      end;
    finally
      vListeV2.Free;
    end;
  finally
    vListeV1.Free;
  end;
end;

08/05/2018, 06h39
PhilLU

Merci pour toutes vos propositions, je teste rapidement et publie le code final...
Encore Merci
Phil
10/05/2018, 12h48
PhilLU

1 pièce(s) jointe(s)

Merci ShaiLeTroll,
J'ai suivi ta méthode StringList, parfait.
Celà me permet de l'intégrer dans une méthode de comparaison de chaines via la méthode de Jaccard.
(En plus de Damereau-Levensthein après normalisation préalable des chaines :yaisse1:)

Pièce jointe 379152

Encore merci :merci:
Phil.
:resolu:
10/05/2018, 14h27
ShaiLeTroll

J'ai beau avoir lu Wikipédia sur la méthode de Jaccard (qu'est-ce qu'un botaniste vient faire en informatique)

Tu aurais une démo de cet algo, juste la méthode CompareStrings que je suppose tu as redéfini (peut-être même Find ou IndexOf)

Citation:

Envoyé par ShaiLeTroll

J'ai beau avoir lu Wikipédia sur la méthode de Jaccard (qu'est-ce qu'un botaniste vient faire en informatique)

Tu aurais une démo de cet algo, juste la méthode CompareStrings que je suppose tu as redéfini (peut-être même Find ou IndexOf)

https://fr.wikipedia.org/wiki/Mesure_de_similarit%C3%A9

Voici le 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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
function IndiceDeJaccard(const ChaineA, ChaineB: String): Double;
var
vListe1, vListe2, vListeInter, vListeUnion: TStringList;
Chaine1, Chaine2 :string;
 
begin
  Result :=0;
Chaine1:=ChaineA+' ';
Chaine2:=ChaineB+' ';
 
  try
    vListe1 := TStringList.Create;
    vListe2 := TStringList.Create;
 
  //remplir stringList1
    repeat
       vListe1.Append(copy(Chaine1,0,pos(' ',Chaine1)-1));
       Chaine1:=copy(Chaine1,pos(' ',Chaine1)+1);
    until length(Chaine1)<2;
 
  //remplir stringList1
    repeat
        vListe2.Append(copy(Chaine2,0,pos(' ',Chaine2)-1));
       Chaine2:=copy(Chaine2,pos(' ',Chaine2)+1);
    until length(Chaine2)<2;
 
  // creation liste inter
  vListeInter := TStringList.Create;
  vListeInter.AssignEx(vListe1, laAnd, vListe2);
 
  // creation liste union
  vListeUnion := TStringList.Create;
  vListeUnion.AssignEx(vListe1, laOr, vListe2);
 
   except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
 
  union:= vListeUnion.Count;
  inter:= vListeInter.Count;
 
    if union<>0 then Result:=(inter/union) else Result:=1;
    vListe1.Free;
    vListe2.Free;
    vListeUnion.Free;
    vListeInter.Free;
 
end;

Encore merci ;-)
Phil.