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 5Input: 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:
- Declare two iterators itr1 and itr2 and both of them point to the beginning element of the set.
- Increment itr2 i.e. itr2++ at the beginning of the loop.
- Subtract values pointed by itr1 and itr2 i.e. *itr2 – *itr1.
- Increment itr1 at the end of the loop, this means *itr1++.
- 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)