Diferencia absoluta de todos los elementos consecutivos por pares en un Conjunto

Dado un conjunto de enteros de N elementos. La tarea es imprimir la diferencia absoluta de todos los elementos consecutivos por pares en un conjunto. Se accede a pares consecutivos de un conjunto de tamaño N mediante iterador . 

Ejemplo:

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

Salida: 1 1 3 7 5

Explicación:

El conjunto es: 3 4 5 8 15 20
La diferencia entre 4 y 3 es 1
La diferencia entre 5 y 4 es 1
La diferencia entre 8 y 5 es 3
La diferencia entre 15 y 8 es 7
La diferencia entre 20 y 15 es 5

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

Salida: 5 5 5 

Explicación:
El conjunto es: 5 10 15 20
La diferencia entre 10 y 5 es 5
La diferencia entre 15 y 10 es 5
La diferencia entre 20 y 15 es 5

El artículo Diferencia absoluta de todos los elementos consecutivos por pares en una array cubre el enfoque para encontrar la diferencia absoluta de todos los elementos consecutivos por pares en una array. 

Enfoque: Este problema se puede resolver utilizando el algoritmo de dos punteros . Usaremos iteradores como los dos punteros para iterar el conjunto y verificar una condición dada. Siga los pasos a continuación para comprender la solución al problema anterior:

1. Declare dos iteradores itr1 e itr2 y ambos apuntan al elemento inicial del conjunto.
2. Incremente itr2, es decir , itr2++ al comienzo del bucle.
3. Resta los valores señalados por itr1 e itr2, es decir , *itr2 – *itr1 .
4. Incremente itr1 al final del ciclo, esto significa *itr1++.
5. Si itr2 llega al final del conjunto, rompa el bucle y salga.

En C++ , los elementos establecidos se ordenan y los duplicados se eliminan antes de almacenarlos en la memoria. Por lo tanto, en el siguiente programa de C++, la diferencia entre los elementos consecutivos por pares se calcula en el conjunto ordenado, como se explica en los ejemplos anteriores.

A continuación se muestra la implementación del programa C++ del enfoque anterior:

// 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>

Producción:

1 1 3 7 5

Complejidad temporal: O(n)
Espacio auxiliar: O(n)