Absolute difference of all pairwise consecutive elements in a Set

Given a set of integers of N elements. The task is to print the absolute difference of all of the pairwise consecutive elements in a set. Pairwise consecutive pairs of a set of size N are accessed using iterator. 

Example:

Input: s = {8, 5, 4, 3, 15, 20}

Output: 1 1 3 7 5

Explanation:

The set is : 3 4 5 8 15 20
The difference between 4 and 3 is 1
The difference between 5 and 4 is 1
The difference between 8 and 5 is 3
The difference between 15 and 8 is 7
The difference between 20 and 15 is 5

Input: s = {5, 10, 15, 20}

Output: 5 5 5 

Explanation:
The set is : 5 10 15 20
The difference between 10 and 5 is 5
The difference between 15 and 10 is 5
The difference between 20 and 15 is 5

The article Absolute Difference of all pairwise consecutive elements in an array covers the approach to find the absolute difference of all pairwise consecutive elements in an array. 

Approach: This problem can be solved using two pointer algorithm. We will be using iterators as the two pointers to iterate the set and check for a given condition. Follow the steps below to understand the solution to the above problem:

1. Declare two iterators itr1 and itr2 and both of them point to the beginning element of the set.
2. Increment itr2 i.e. itr2++ at the beginning of the loop.
3. Subtract values pointed by itr1 and itr2 i.e. *itr2 - *itr1.
4. Increment itr1 at the end of the loop, this means *itr1++.
5. If itr2 reaches the end of the set, then break the loop and exit.

In C++, the set elements are sorted and duplicates are removed before storing in the memory. Therefore, in the below C++ program the difference between the pairwise consecutive elements is computed on the sorted set as explained in the above examples.

Below is the C++ program implementation of the above approach:

// C++ program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to calculate the
// difference of consecutive pairwise
// elements in a set
void display_difference(set<int> s)
{
    // Declaring the set iterator
    set<int>::iterator itr;

    // Printing difference between
    // consecutive elements in a set
    set<int>::iterator itr1 = s.begin();
    set<int>::iterator itr2 = s.begin();
    while (1) {
        itr2++;
        if (itr2 == s.end())
            break;
        cout << (*itr2 - *itr1) << " ";
        itr1++;
    }
}
// Driver code
int main()
{
    // Declaring the set
    set<int> s{ 8, 5, 4, 3, 15, 20 };

    // Invoking the display_difference()
    // function
    display_difference(s);
    return 0;
}

// Java program to implement
// the above approach
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.TreeSet;

// Function to calculate the
// difference of consecutive pairwise
// elements in a set
class GFG {
  static void display_difference(HashSet<Integer> S) {

    // Printing difference between
    // consecutive elements in a set
    TreeSet<Integer> s = new TreeSet<Integer>(S);

    int itr1 = 0;
    int itr2 = 0;
    while (true) {
      itr2 += 1;
      ;
      if (itr2 >= s.size()) {
        break;
      }
      List<Integer> temp = new ArrayList<Integer>();
      temp.addAll(s);
      System.out.print((temp.get(itr2) - temp.get(itr1)) + " ");
      itr1 += 1;
    }
  }

  // Driver code

  public static void main(String args[]) 
  {
    
    // Declaring the set
    HashSet<Integer> s = new HashSet<Integer>();
    s.add(8);
    s.add(5);
    s.add(4);
    s.add(3);
    s.add(15);
    s.add(20);

    // Invoking the display_difference()
    // function
    display_difference(s);

  }
}

// This code is contributed by gfgking

# Python 3 program to implement
# the above approach

# Function to calculate the
# difference of consecutive pairwise
# elements in a set
def display_difference(s):

    # Printing difference between
    # consecutive elements in a set
    itr1 = 0
    itr2 = 0
    while (1):
        itr2 += 1
        if (itr2 >= len(s)):
            break
        print((list(s)[itr2] - list(s)[itr1]), end=" ")
        itr1 += 1

# Driver code
if __name__ == "__main__":

    # Declaring the set
    s = set([8, 5, 4, 3, 15, 20])

    # Invoking the display_difference()
    # function
    display_difference(s)

    # This code is contributed by ukasp.

// C# program to implement
// the above approach

// Function to calculate the
// difference of consecutive pairwise
// elements in a set
using System;
using System.Collections.Generic;
public class GFG
{
  static void display_difference(HashSet<int> S) 
  {

    // Printing difference between
    // consecutive elements in a set
    SortedSet<int> s = new SortedSet<int>(S);

    int itr1 = 0;
    int itr2 = 0;
    while (true) {
      itr2 += 1;
      ;
      if (itr2 >= s.Count) {
        break;
      }
      List<int> temp = new List<int>();
      temp.AddRange(s);
      Console.Write((temp[itr2] - temp[itr1]) + " ");
      itr1 += 1;
    }
  }

  // Driver code
  public static void Main(String []args)
  {

    // Declaring the set
    HashSet<int> s = new HashSet<int>();
    s.Add(8);
    s.Add(5);
    s.Add(4);
    s.Add(3);
    s.Add(15);
    s.Add(20);

    // Invoking the display_difference()
    // function
    display_difference(s);
  }
}

// This code is contributed by Rajput-Ji. 

<script>
// Javascript program to implement
// the above approach

// Function to calculate the
// difference of consecutive pairwise
// elements in a set
function display_difference(s) {

    // Printing difference between
    // consecutive elements in a set
    s = new Set([...s].sort((a, b) => a - b));

    let itr1 = 0
    let itr2 = 0
    while (1) {
        itr2 += 1
        if (itr2 >= s.size) {
            break
        }
        document.write(([...s][itr2] - [...s][itr1]) + " ")
        itr1 += 1
    }
}

// Driver code

// Declaring the set
let s = new Set([8, 5, 4, 3, 15, 20]);

// Invoking the display_difference()
// function
display_difference(s)

// This code is contributed by Saurabh Jaiswal
</script>

Output:

1 1 3 7 5

Time Complexity: O(n)
Auxiliary Space: O(n)