How to remove mirroring pairs and pairs in array?

LOGIC:
1. Main logic is that how a particular index is satisficing both condition which are have same pair and have minor pair. Here we can use the vectorize property of Numpy to check both condition and code for that is :

cond_i = (i == A) | (i[::-1] == A)

2. If sum of True condition is exactly equal to 1 which mean is don't satisfy the both condition so this will be our requirement, for this condition check use this code :

sum(list((cond_i[:,0] & cond_i[:,1])))

3. Finally append this condition satisfying result.

B.append((A[j]))

CODE :

from numpy import array
import numpy as np
A = array([[0, 55], [5, 25], [5, 25], [12, 62], [27, 32], [25, 73], [55, 0],
           [25, 5], [62, 12], [32, 27], [99, 95]])

B = []
for j, i in enumerate(A):
    if np.sum(np.all(i == A, axis=1) | np.all(i[::-1] == A, axis=1)) == 1:
        B.append((A[j]))

print(np.array(B))

OUTPUT :

[[25 73]
 [99 95]]

For more than ~40 rows, these solutions (the numpy one for up to about 1000 rows, then the Pandas-based one) are the fastest so far.

Here is what I would do for a vectorized operation (fast, no Python loops):

import pandas as pd

def unique_pairs(a):
    df = pd.DataFrame({'x': a.min(axis=1), 'y': a.max(axis=1)})
    return a[~df.duplicated(keep=False)]

B = unique_pairs(A)

# on your example:
>>> B
array([[25, 73],
       [99, 95]])

If you are looking for a pure numpy solution (alas, as per the note below, it is slower for large arrays):

def np_unique_pairs(a):
    z = np.stack((a.min(axis=1), a.max(axis=1)))
    _, rix, cnt = np.unique(z, return_inverse=True, return_counts=True, axis=1)
    return a[(cnt==1)[rix]]

Performance

A = np.random.randint(0, 10, (1_000_000, 2))

%timeit unique_pairs(A)
# 45.6 ms ± 49.8 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

Notes

• np.unique(a, axis=0) is quite a bit slower than Pandas family of duplicate functions (drop_duplicates(), duplicated(), etc.). See issue #11136.
• there are other ways that could work, such as mapping each pair of numbers on a row onto a single integer. See this SO answer answer for some ideas.

Speed comparison

Here is a comparison of the speed of 4 methods:

• pd_unique_pairs() is the Pandas solution proposed above.
• np_unique_pairs() is the pure Numpy solution proposed above.
• counter_unique_pairs() is proposed by @Acccumulation and is based on the use of Python loops and Counter.
• loop_unique_pairs() is proposed by @ExploreX and is based on explicit Python loops.

Clearly, for more than 1000 rows, pd_unique_pairs dominates. Between roughly 40 and 1000 rows, np_unique_pairs wins. For very small arrays (under 40 rows), then counter_unique_pairs is most effective.

# additional code for the perfplot above
import perfplot


def counter_unique_pairs(A):
    A_Counter = Counter((tuple(sorted(item)) for item in A))
    single_instances = [item for item in A_Counter if A_Counter[item]==1]
    B = np.array([item for item in A if tuple(sorted(item)) in single_instances])
    return B

def loop_unique_pairs(A):
    B = []
    for j,i in enumerate(A):
        cond_i = (i == A) | (i[::-1] == A)

        if sum(list((cond_i[:,0] & cond_i[:,1]))) == 1:
            B.append((A[j]))
    B = np.array(B)
    return B

perfplot.show(
    setup=lambda n: np.random.randint(0, np.sqrt(n).astype(int), (n, 2)),
    kernels=[pd_unique_pairs, np_unique_pairs, counter_unique_pairs,  loop_unique_pairs],
    n_range=[2 ** k for k in range(3, 14)],
    equality_check=None,  # had to disable since loop_ appear to be wrong sometimes
    
)

The best code that I was able to come up with was

A_Counter = Counter((tuple(sorted(item)) for item in A))
single_instances = [item for item in A_Counter if A_Counter[item]==1]

There's likely further optimization possible.

I found that, using your sample data, this took 52 microseconds, compared to 2574 microseconds for Pierre D's answer and 1024 microseconds for Exploore X's.

It does, however, return each item sorted and as a tuple. This can be corrected with B = [item for item in A if tuple(sorted(item)) in single_instances], which brings its time up to 88 microseconds.

Also, this code looks for duplicates based on any permutation of the elements, not just mirroring. For two-element lists, these two are equivalent, but if you want to expand it to data that has lists of more than two elements, and you want just mirrored lists, you'll have to adjust the code.