std::adjacent_difference en C++

Calcular diferencia adyacente de rango
Asigna a cada elemento en el rango que comienza en resultado, la diferencia entre su elemento correspondiente en el rango [primero, último] y el que lo precede (excepto para *resultado, que se asigna *primero).

Si x representa un elemento en [primero, último] e y representa un elemento en resultado, la y se puede calcular como:

y0 = x0
y1 = x1 - x0
y2 = x2 - x1
y3 = x3 - x2
y4 = x4 - x3
and so on.

1. Uso de la versión predeterminada:
Sintaxis:
Plantilla:

OutputIterator adjacent_difference (InputIterator first,
                                    InputIteratorlast,
                                    OutputIterator result);
Parameters :

first, last
Input iterators to the initial and final positions in a sequence.
The range used is [first, last], which contains all the elements
between first and last, including the element pointed by first but
not the element pointed by last.

result
Output iterator to the initial position in the destination sequence
where the differences are stored. The range starts at result and
shall have a size large enough to contain as many elements as the
range above [first, last]. 

Return Type :
An iterator pointing to past the last element of the destination
sequence where resulting elements have been stored.

// CPP program to illustrate
// std :: adjacent_difference
  
#include <iostream> // std::cout
#include <numeric> // std::adjacent_difference
  
// Driver code
int main()
{
    int val[] = { 1, 2, 3, 5, 9, 11, 12 };
    int n = sizeof(val) / sizeof(val[0]);
    int result[7];
  
    // Array contains
    std::cout << "Array contains :";
    for (int i = 0; i < n; i++)
        std::cout << " " << val[i];
    std::cout << "\n";
  
    // Using default std :: adjacent_difference
    std::adjacent_difference(val, val + 7, result);
    std::cout << "Using default adjacent_difference: ";
    for (int i = 1; i < n; i++)
        std::cout << result[i] << ' ';
    std::cout << '\n';
  
    return 0;
}

Producción:

Array contains : 1 2 3 5 9 11 12
Using default adjacent_difference: 1 1 2 4 2 1

2. Usando una versión personalizada, tomando la función como borrador
Sintaxis:
Plantilla:

OutputIterator adjacent_difference (InputIterator first,
                                    InputIterator last,
                                    OutputIterator result,
                                    BinaryOperation binary_op);

Parameters :

first, last, result are same as above.

binary_op
Binary operation taking as arguments two elements of the type
pointed by InputIterator, and returning the result of the
replacement for the difference operation.
This can either be a function pointer or a function object. 

Return Type :
An iterator pointing to past the last element of the destination
sequence where resulting elements have been stored.

Al cambiar el operador a cualquier operador binario en la función personalizada, podemos cambiar la operación que se aplica en la función STL. Aquí se realiza la suma de elementos adyacentes.

// CPP program to illustrate
// std :: adjacent_difference
  
#include <iostream> // std::cout
#include <numeric> // std::adjacent_difference
  
int comp(int x, int y)
{
    return x + y;
}
  
// Driver code
int main()
{
    int val[] = { 1, 2, 3, 5, 9, 11, 12 };
    int n = sizeof(val) / sizeof(val[0]);
    int result[7];
  
    // Array contains
    std::cout << "Array contains :";
    for (int i = 0; i < n; i++)
        std::cout << " " << val[i];
    std::cout << "\n";
  
    // std :: adjacent_difference using custom function
    std::adjacent_difference(val, val + 7, result, comp);
  
    std::cout << "Using custom function: ";
    for (int i = 0; i < n; i++)
        std::cout << result[i] << ' ';
    std::cout << '\n';
  
    return 0;
}

Producción:

Array contains : 1 2 3 5 9 11 12
Using custom function: 1 3 5 8 14 20 23 

Aplicación práctica: Realizar cualquier operación binaria entre los elementos adyacentes del rango mencionado (excepto el primer elemento del rango).

1. Encuentra el producto de los elementos adyacentes en la array.
Por ejemplo, la array contiene: 2 4 5 6 El
resultado es: 2 8 20 30
Explicación: los primeros elementos permanecen como están. Entonces el segundo elemento será primer elemento * segundo elemento, luego el tercer elemento será segundo elemento * tercer elemento y así sucesivamente.

// CPP program to illustrate
// std :: adjacent_difference
  
#include <iostream> // std::cout
#include <numeric> // std::adjacent_difference
  
int comp(int x, int y)
{
    return x * y;
}
  
// Driver code
int main()
{
    int val[] = { 5, 7, 4, 8, 2 };
    int n = sizeof(val) / sizeof(val[0]);
    int result[n];
  
    // Array contains
    std::cout << "Array contains :";
    for (int i = 0; i < n; i++)
        std::cout << " " << val[i];
    std::cout << "\n";
  
    // Using custom std :: adjacent_difference
    std::adjacent_difference(val, val + 7, result, comp);
    std::cout << "Result contains :";
    for (int i = 0; i < n; i++)
        std::cout << ' ' << result[i];
    std::cout << '\n';
  
    return 0;
}

PRODUCCIÓN :

Array contains : 5 7 4 8 2
Result contains : 5 35 28 32 16

Este artículo es una contribución de Sachin Bisht . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo usando contribuya.geeksforgeeks.org o envíe su artículo por correo a contribuya@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.