Open In App

Find the Jaccard Index and Jaccard Distance between the two given sets

Last Updated : 29 Aug, 2022
Comments
Improve
Suggest changes
Like Article
Like
Report

Given two sets of integers s1 and s2, the task is to find the Jaccard Index and the Jaccard Distance between the two sets. Examples:

Input: s1 = {1, 2, 3, 4, 5}, s2 = {4, 5, 6, 7, 8, 9, 10} Output: Jaccard index = 0.2 Jaccard distance = 0.8 Input: s1 = {1, 2, 3, 4, 5}, s2 = {4, 5, 6, 7, 8} Output: Jaccard index = 0.25 Jaccard distance = 0.75

Approach: The Jaccard Index and the Jaccard Distance between the two sets can be calculated by using the formula: \[ Jaccard Index = \frac {| A \cap B |}{| A \cup B |} = \frac {|A \cap B |}{|A| +|B| -|A \cap B |} \] \[ Jaccard Distance = 1 - Jaccard Index \]       Below is the implementation of the above approach: 

C++ 
// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;

// Function to return the
// intersection set of s1 and s2
set<int> intersection(set<int> s1, set<int> s2)
{
    set<int> intersect;

    // Find the intersection of the two sets
    set_intersection(s1.begin(), s1.end(), s2.begin(), s2.end(),
                     inserter(intersect, intersect.begin()));

    return intersect;
}

// Function to return the Jaccard index of two sets
double jaccard_index(set<int> s1, set<int> s2)
{
    // Sizes of both the sets
    double size_s1 = s1.size();
    double size_s2 = s2.size();

    // Get the intersection set
    set<int> intersect = intersection(s1, s2);

    // Size of the intersection set
    double size_in = intersect.size();

    // Calculate the Jaccard index
    // using the formula
    double jaccard_in = size_in
                        / (size_s1 + size_s2 - size_in);

    // Return the Jaccard index
    return jaccard_in;
}

// Function to return the Jaccard distance
double jaccard_distance(double jaccardIndex)
{
    // Calculate the Jaccard distance
    // using the formula
    double jaccard_dist = 1 - jaccardIndex;

    // Return the Jaccard distance
    return jaccard_dist;
}

// Driver code
int main()
{
    // Elements of the 1st set
    set<int> s1;
    s1.insert(1);
    s1.insert(2);
    s1.insert(3);
    s1.insert(4);
    s1.insert(5);

    // Elements of the 2nd set
    set<int> s2;
    s2.insert(4);
    s2.insert(5);
    s2.insert(6);
    s2.insert(7);
    s2.insert(8);
    s2.insert(9);
    s2.insert(10);

    double jaccardIndex = jaccard_index(s1, s2);

    // Print the Jaccard index and Jaccard distance
    cout << "Jaccard index = "
         << jaccardIndex << endl;
    cout << "Jaccard distance = "
         << jaccard_distance(jaccardIndex);

    return 0;
}
Java 
// Java implementation of the approach
import java.util.*;
class GFG
{

  // Function to return the
  // intersection set of s1 and s2
  static HashSet<Integer> intersection(HashSet<Integer> a, HashSet<Integer> b)
  {

    // Find the intersection of the two sets
    HashSet<Integer> intersect = new HashSet<Integer>();
    for (int n : a)
    {
      if (b.contains(n))
        intersect.add(n);
    }

    return intersect;
  }

  // Function to return the Jaccard index of two sets
  static double jaccard_index(HashSet<Integer> s1, HashSet<Integer> s2)
  {
    // Sizes of both the sets
    int size_s1 = s1.size();
    int size_s2 = s2.size();

    // Get the intersection set
    HashSet<Integer> intersect = intersection(s1, s2);

    // Size of the intersection set
    int size_in = intersect.size();

    // Calculate the Jaccard index
    // using the formula
    double jaccard_in  = (double)size_in / (double)(size_s1 + size_s2 - size_in);

    // Return the Jaccard index
    return jaccard_in;
  }

  // Function to return the Jaccard distance
  static double jaccard_distance(double jaccardIndex)
  {
    // Calculate the Jaccard distance
    // using the formula
    double jaccard_dist = 1 - jaccardIndex;

    // Return the Jaccard distance
    return jaccard_dist;
  }

  // Driver code

  // Elements of the 1st set
  public static void main(String[] args)
  {
    HashSet<Integer> s1 = new HashSet<Integer>();
    s1.add(1);
    s1.add(2);
    s1.add(3);
    s1.add(4);
    s1.add(5);

    // Elements of the 2nd set
    HashSet<Integer> s2 = new HashSet<Integer>();
    s2.add(4);
    s2.add(5);
    s2.add(6);
    s2.add(7);
    s2.add(8);
    s2.add(9);
    s2.add(10);

    double jaccardIndex = jaccard_index(s1, s2);

    // Print the Jaccard index and Jaccard distance
    System.out.println("Jaccard index = " + jaccardIndex);
    System.out.println("Jaccard distance = " +
                      jaccard_distance(jaccardIndex));
  }
}

// This code is contributed by phasing17
Python3 
# Python3 implementation of the approach 

# Function to return the 
# intersection set of s1 and s2 
def intersection(s1, s2) :

    # Find the intersection of the two sets 
    intersect = s1 & s2 ;

    return intersect; 


# Function to return the Jaccard index of two sets 
def jaccard_index(s1, s2) :
    
    # Sizes of both the sets 
    size_s1 = len(s1); 
    size_s2 = len(s2); 

    # Get the intersection set 
    intersect = intersection(s1, s2); 

    # Size of the intersection set 
    size_in = len(intersect); 

    # Calculate the Jaccard index 
    # using the formula 
    jaccard_in = size_in  / (size_s1 + size_s2 - size_in); 

    # Return the Jaccard index 
    return jaccard_in; 


# Function to return the Jaccard distance 
def jaccard_distance(jaccardIndex)  :

    # Calculate the Jaccard distance 
    # using the formula 
    jaccard_dist = 1 - jaccardIndex; 

    # Return the Jaccard distance 
    return jaccard_dist; 


# Driver code 
if __name__ == "__main__" : 

    # Elements of the 1st set 
    s1 = set(); 
    s1.add(1); 
    s1.add(2); 
    s1.add(3); 
    s1.add(4); 
    s1.add(5); 

    # Elements of the 2nd set 
    s2 = set(); 
    s2.add(4); 
    s2.add(5); 
    s2.add(6); 
    s2.add(7); 
    s2.add(8); 
    s2.add(9); 
    s2.add(10); 

    jaccardIndex = jaccard_index(s1, s2); 

    # Print the Jaccard index and Jaccard distance 
    print("Jaccard index = ",jaccardIndex); 
    print("Jaccard distance = ",jaccard_distance(jaccardIndex)); 
    
    # This code is contributed by AnkitRai01
C# 
// C# implementation of the approach
using System;
using System.Collections.Generic;

class GFG
{

  // Function to return the
  // intersection set of s1 and s2
  static HashSet<int> intersection(HashSet<int> a, HashSet<int> b)
  {

    // Find the intersection of the two sets
    HashSet<int> intersect = new HashSet<int>();
    foreach (int n in a)
    {
      if (b.Contains(n))
        intersect.Add(n);
    }

    return intersect;
  }

  // Function to return the Jaccard index of two sets
  static double jaccard_index(HashSet<int> s1, HashSet<int> s2)
  {
    // Sizes of both the sets
    int size_s1 = s1.Count;
    int size_s2 = s2.Count;

    // Get the intersection set
    HashSet<int> intersect = intersection(s1, s2);

    // Size of the intersection set
    int size_in = intersect.Count;

    // Calculate the Jaccard index
    // using the formula
    double jaccard_in  = (double)size_in / (double)(size_s1 + size_s2 - size_in);

    // Return the Jaccard index
    return jaccard_in;
  }

  // Function to return the Jaccard distance
  static double jaccard_distance(double jaccardIndex)
  {
    // Calculate the Jaccard distance
    // using the formula
    double jaccard_dist = 1 - jaccardIndex;

    // Return the Jaccard distance
    return jaccard_dist;
  }

  // Driver code

  // Elements of the 1st set
  public static void Main(string[] args)
  {
    HashSet<int> s1 = new HashSet<int>();
    s1.Add(1);
    s1.Add(2);
    s1.Add(3);
    s1.Add(4);
    s1.Add(5);

    // Elements of the 2nd set
    HashSet<int> s2 = new HashSet<int>();
    s2.Add(4);
    s2.Add(5);
    s2.Add(6);
    s2.Add(7);
    s2.Add(8);
    s2.Add(9);
    s2.Add(10);

    double jaccardIndex = jaccard_index(s1, s2);

    // Print the Jaccard index and Jaccard distance
    Console.WriteLine("Jaccard index = " + jaccardIndex);
    Console.WriteLine("Jaccard distance = " +
                      jaccard_distance(jaccardIndex));
  }
}

// This code is contributed by phasing17
JavaScript 
// JavaScript implementation of the approach

// Function to return the
// intersection set of s1 and s2
function intersection(a, b)
{
    // Find the intersection of the two sets
    let intersect = new Set([...a].filter(i => b.has(i)));

    return intersect;
}

// Function to return the Jaccard index of two sets
function jaccard_index(s1, s2)
{
    // Sizes of both the sets
    let size_s1 = s1.size;
    let size_s2 = s2.size;

    // Get the intersection set
    let intersect = intersection(s1, s2);

    // Size of the intersection set
    let size_in = intersect.size;

    // Calculate the Jaccard index
    // using the formula
    let jaccard_in  = size_in / (size_s1 + size_s2 - size_in);

    // Return the Jaccard index
    return jaccard_in;
}

// Function to return the Jaccard distance
function jaccard_distance(jaccardIndex)
{
    // Calculate the Jaccard distance
    // using the formula
    let jaccard_dist = 1 - jaccardIndex;

    // Return the Jaccard distance
    return jaccard_dist;
}

// Driver code

// Elements of the 1st set
let s1 = new Set();
s1.add(1);
s1.add(2);
s1.add(3);
s1.add(4);
s1.add(5);

// Elements of the 2nd set
let s2 = new Set();
s2.add(4);
s2.add(5);
s2.add(6);
s2.add(7);
s2.add(8);
s2.add(9);
s2.add(10);

let jaccardIndex = jaccard_index(s1, s2);

// Print the Jaccard index and Jaccard distance
console.log("Jaccard index = ", jaccardIndex);
console.log("Jaccard distance = ",
            jaccard_distance(jaccardIndex));

// This code is contributed by phasing17
Output:
Jaccard index = 0.2
Jaccard distance = 0.8

Next Article
Analysis of Algorithms

A
andrew1234
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox