std::unique_copy en C++ – Barcelona Geeks

std::unique se usa para eliminar duplicados de cualquier elemento presente consecutivamente en un rango [primero, último]. Realiza esta tarea para todos los subgrupos presentes en el rango que tengan el mismo elemento presente consecutivamente.

Pero, ¿qué pasa si no queremos alterar el rango original y solo queremos que el resultado de std::unique se copie en otro contenedor? Para esto tenemos otra función definida en , es decir, std::unique_copy() . En esto, solo se copia el primer elemento de cada grupo consecutivo de elementos equivalentes en el rango [primero, último].

Se puede utilizar de dos formas como se muestra a continuación:

Comparando elementos usando ==:
Sintaxis:

template 
  OutputIterator unique_copy (InputIterator first, InputIterator last,
                              OutputIterator result);

first: Forward iterator to the first element in the container.
last: Forward iterator to the last element in the container.
result: Output iterator to the initial position 
of the container where the resulting range of values is stored. 
The value being pointed should be compatible with the value being assigned.

Return Value: An iterator pointing to the end 
of the copied range, which contains no consecutive duplicates.

// C++ program to demonstrate 
// the use of std::unique_copy
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
    vector<int> v = { 10, 10, 30, 30, 30, 100, 10,
                      300, 300, 70, 70, 80 };
  
    // Declaring a vector to store the copied value
    vector<int> v1(10);
  
    vector<int>::iterator ip;
  
    // Using std::unique_copy
    ip = std::unique_copy(v.begin(), v.begin() + 12, v1.begin());
    // Now v1 contains {10 30 100 10 30 70 80 0 0 0}
  
    // Resizing vector v1
    v1.resize(std::distance(v1.begin(), ip));
  
    cout << "Before: ";
    for (ip = v.begin(); ip != v.end(); ++ip) 
    {
        cout << *ip << " ";
    }
  
    // Displaying the vector after applying std::unique_copy
    cout << "\nAfter: ";
    for (ip = v1.begin(); ip != v1.end(); ++ip) 
    {
        cout << *ip << " ";
    }
  
    return 0;
}

Producción:

Before: 10 10 30 30 30 100 10 300 300 70 70 80
After: 10 30 100 10 30 70 80

Aquí, en este vector, todos los subgrupos que tienen elementos duplicados consecutivos se han reducido a un solo elemento y se han copiado en el vector v1.

Comparando usando una función predefinida:
Sintaxis:

template 
  OutputIterator unique_copy (InputIterator first, InputIterator last,
                              OutputIterator result, BinaryPredicate pred);

Here, first, last and result are the same as previous case.

Pred: Binary function that accepts two elements 
in the range as argument, and returns a value convertible to bool. 
The value returned indicates whether both arguments are considered equivalent
(if true, they are equivalent and one of them is removed).
The function shall not modify any of its arguments.
This can either be a function pointer or a function object.

Return Value: It returns an iterator pointing to the 
end of the copied range, which contains no consecutive duplicates.

// C++ program to demonstrate the 
// use of std::unique_copy
#include <iostream>
#include <algorithm>
#include <string>
using namespace std;
  
// Defining the BinaryFunction
bool Pred(char a, char b)
{
    // Checking if both the arguments are same and equal
    // to 'v' then only they are considered same
    // and duplicates are removed
    if (a == b && a == 'v') 
    {
        return 1;
    } 
    else 
    {
        return 0;
    }
}
int main()
{
    // Declaring a string
    string s = "You arre vvvisiting GFG", s1;
  
    // Using std::unique_copy to remove the consecutive
    // v in the word and copy it to s1
    auto ip = std::unique_copy(s.begin(), s.end(), back_inserter(s1), Pred);
  
    cout << "Before: " << s;
  
    // Displaying the corrected string
    cout << "\nAfter: " << s1;
    return 0;
}

Producción:

Before: You arre vvvisiting GFG
After: You arre visiting GFG

Donde puede ser usado ?

std::unique_copy se puede usar para eliminar todos los elementos duplicados (ya sean consecutivos o no) y almacenar el resultado en otro contenedor , sin afectar el contenedor anterior.

// C++ program to demonstrate the use of std::unique_copy
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
    vector<int> v = { 1, 2, 3, 3, 3, 10, 1, 2, 3, 7, 7, 8 };
  
    vector<int>::iterator ip;
  
    // Sorting the array to make duplicate elements
    // consecutive
    std::sort(v.begin(), v.end());
    // Now v becomes 1 1 2 2 3 3 3 3 7 7 8 10
  
    // Declaring a container to store the unique elements
    vector<int> v1(6);
  
    // Using std::unique_copy
    ip = std::unique_copy(v.begin(), v.begin() + 12, v1.begin());
    // Now v1 becomes {1 2 3 7 8 10}
  
    // Displaying the vector v and v1 after applying std::unique
    cout << "v = ";
  
    for (ip = v.begin(); ip != v.end(); ++ip) 
    {
        cout << *ip << " ";
    }
  
    cout << "\nv1 = ";
    for (ip = v1.begin(); ip != v1.end(); ++ip) 
    {
        cout << *ip << " ";
    }
  
    return 0;
}

Producción:

v = 1 1 2 2 3 3 3 3 7 7 8 10
v1 = 1 2 3 7 8 10

Explicación: aquí, primero hemos ordenado el vector para hacer que los elementos duplicados sean consecutivos y luego hemos aplicado std::unique_copy para eliminar los elementos duplicados y almacenar los elementos únicos en otro contenedor.

También podemos usar std::unique_copy para encontrar si un contenedor contiene solo elementos únicos o no. Esto es solo una extensión del concepto anterior de almacenar los elementos únicos en otro contenedor. Después de esto, podemos comparar los dos contenedores para comprobar si son iguales o no.

// C++ program to demonstrate the use of std::unique_copy
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
    vector<int> v = { 1, 20, 3, 10, 2, 7, 8 };
  
    vector<int>::iterator ip;
  
    // Sorting the array to make duplicate elements
    // consecutive
    std::sort(v.begin(), v.end());
    // Now v becomes 1 2 3 7 8 10 20
  
    // Declaring a container to store the unique elements
    vector<int> v1(7);
  
    // Using std::unique_copy
    ip = std::unique_copy(v.begin(), v.end(), v1.begin());
    // Now v1 becomes {1 2 3 7 8 10 20}
  
    if (v == v1) 
    {
        cout << "v1 contains only unique elements";
    } 
    else 
    {
        cout << "v1 contains duplicate elements";
    }
    return 0;
}

Producción:

v1 contains only unique elements

Explicación: en primer lugar, eliminamos los elementos duplicados y almacenamos el resultado en otro contenedor y luego comparamos el contenedor resultante con el contenedor anterior, si ambos son iguales, esto significa que el contenedor anterior constaba solo de elementos únicos y no hay ningún elemento duplicado. .

Este artículo es una contribución de Mrigendra Singh . 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.

Publicación traducida automáticamente

Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta Cancelar la respuesta