How to remove triplicated lines

Question

Here is the information I have

I would like to remove those triplicates but keep singletons and duplicates. Therefore, the expect output should be as below,

Here are the script I have now :

for (int row = 0; row < row_number; row++) {
    if (array[row].equals(array[row+1]) && array[row+1].equals(array[row+2]) ) {                    
    }
    else if (array[row].equals(array[row+1]) && array[row-1].equals(array[row]) ) {
    }
    else if (array[row].equals(array[row-1]) && array[row-1].equals(array[row-2]) ) {
    }
    else{ 
        System.out.println(array[row+1]);
        }               
}

I will be grateful if any help from here.

The original array is sorted or not? – Davide Lorenzo MARINO Jun 06 '16 at 15:30 — Davide Lorenzo MARINO, Jun 06 '16 at 15:30

Davide Lorenzo MARINO · Accepted Answer · 2016-06-06T16:11:13.060

For each element check:

two previous element
two subsequent elements
one previous and one following element

If none of the previous has a duplicate add to your results.

As an example, consider the star as the current element:

 A*, A, A, B, C    Don't add because two following elements are equals
 A, A*, A, B, C    Don't add because previous and next elements are equlas
 A, A, A*, B, C    Don't add because previous two elements are equals
 A, A, A, B*, C    Add because no condition is true
 A, A, A, B, C*    Add because no condition is true

Here is the same code:

// Assuming rows is ordered so that equals elements are close each other

public List noTriplicates(Object[] rows) {
    List results = new ArrayList();
    for (int i = 0; i < rows.length; i++) {
        boolean add = true;

        // Check for two previous
        if (i >= 2 && rows[i-2].equals(rows[i])) {
           add = false;

        // Check previous and next
        } else if (i >= 1 && i < rows.length - 1
                       && rows[i-1].equals(rows[i]) 
                       && rows[i+1].equals(rows[i])) {
           add = false;

        // Check for two next
        } else if (i < rows.length - 2 && rows[i+2].equals(rows[i])) {
           add = false;
        }
        if (add) {
            results.add(rows[i]);
        }

    }
    // Here results has no triplicates
    return results;
}

Note that is also possible to combine all conditions with or operator, but the code will be less readable.

Thank you for your replay and clear explaination. It's easy to understand and use. — user3631848, Jun 07 '16 at 05:47

score 0 · Answer 2 · edited May 23 '17 at 10:29

You may want to have 3 nested loops, but time should be O(n log^2 n):

    boolean triplicates;
    int[] array = initArray();

    // track triplicates. If you don't, then time is O(n^3), as you need to start over for every nested loop
    boolean[] triplicatesPositions = new boolean[array.length];
    Arrays.fill(triplicatesPositions, false); // not necessary, default is false
    for (int j = 0; j < array.length; j++) {
        if (!triplicatesPositions[j]) {
            triplicates = false;
            // no need to start from the beginning
            for (int k = j + 1; k < array.length; k++) {
                if (array[k] == array[j]) {
                    // no need to start from the beginning
                    for (int i = k + 1; i < array.length; i++) {
                        if (array[i] == array[k]) {
                            triplicates = true; // got it!
                            // remember for the future these are triplicates
                            triplicatesPositions[k] = true; 
                            triplicatesPositions[i] = true;
                        }
                    }
                }
            }
            // this way, you don't print the triplicates at all. If you want to print the first and second time they appear, then simply remove the if statement and print anyway
            if (!triplicates)
        }
    }

Elements are not required to be ordered. Adapting this.

Is not necessary to loop three times. You can look two step over, two step back and one step back and one over to be sure, check my answer. — Davide Lorenzo MARINO, Jun 06 '16 at 16:09
This is only true when the array is sorted. When it is sorted, then one loop is enough. — Manu, Jun 06 '16 at 16:12

Marco · Answer 3 · 2016-06-06T16:50:05.063

0

If the array is ordered I'll do like this:

 String lastTriplet="";   
    for (int row = 0; row < row_number; row++) {
     if ((row>=row_number-2) || ( row+2<row_number && !array[row].equals(array[row+2]))){
       if (!lastTriplet.equals(array[row])) System.out.println(array[row]);
    }else{
        lastTriplet=array[row];
        row=row+2;
      }
    }

edited Jun 06 '16 at 16:50

answered Jun 06 '16 at 15:57

Marco

47
4

Doesn't work for example for list [A, A, A] it will print A, A. Check my answer. – Davide Lorenzo MARINO Jun 06 '16 at 16:07
No, it doesn't because array[0]!=array[2] so the else jump to the fourth element – Marco Jun 06 '16 at 16:10
mmmm.... right. I check, but it seems correct. I didn't saw the increment in the else clause. – Davide Lorenzo MARINO Jun 06 '16 at 16:13
needs some additional improuvement. But the idea is great. THe problem is that if the row is the last one or previous you don't print nothing. – Davide Lorenzo MARINO Jun 06 '16 at 16:15
Sorry Marco... it doesn't work well if the sequence is longer than a triple. For example for [A, A, A, A] it will print [A] – Davide Lorenzo MARINO Jun 06 '16 at 16:21
Right, even contemplated that scenario... :) – Marco Jun 06 '16 at 16:23
Changed again, remember last triplet found – Marco Jun 06 '16 at 16:29

pbajpai · Answer 4 · 2016-06-06T16:57:23.457

0

If array is ordered, then We can modify the code as below:

String row_data = array[0];
int count = 0;
if(array.length == 1) 
    System.out.println(row_data);
else
    for (int row = 1; row < array.length; row++) {
        if(row_data == array[row]) {
            count++;
        } else {
            if(count < 3) {
                print(row_data, count);
            }
            row_data = array[row];
            count = 1;
        }
        if(row+1 == array.length && count < 3) {
            print(row_data, count);
        }
    }

Below is the print() method:

   void print(String row_Data, int count) {
       for(int i=0; i<count; i++) {
           System.out.println(row_Data);
       }
   }

Output:

edited Jun 06 '16 at 16:57

answered Jun 06 '16 at 16:13

pbajpai

1,303
1
9
24

It doesn't print nothing for the list [A] – Davide Lorenzo MARINO Jun 06 '16 at 16:16
I have tried at my end with the given input array in question, For me it is working, I am getting the correct output. Here the print() method is printing the rows, if they are less than 3 in nos. – pbajpai Jun 06 '16 at 16:29
I modified the answer for the list with only one element. – pbajpai Jun 06 '16 at 16:39
Same problem for lists of 2 elements – Davide Lorenzo MARINO Jun 06 '16 at 16:41
sorry,,,some edge cases were missed in the solution, I tried to run more edge cases, please check once and let me know if you found more failures, I will fix it. Thanks.. – pbajpai Jun 06 '16 at 16:59

Alex S. Diaz · Answer 5 · 2016-06-06T17:21:23.477

I'm not good with streams, but something like this could work?

Map m = IntStream.of(array).boxed().
        collect(Collectors.groupingBy(n -> n, Collectors.counting()));

array = IntStream.of(array).boxed().filter(n -> {
  long v = (long) m.get(n);
  m.put(n, v > 2 ? 1 : v - 1);
  return v > 0;
}).mapToInt(i -> i).toArray();

Order preserved (if 3 equal numbers are found, it will remove the last).

If you have an array like this:

int[] array = { 1, 1, 1, 2, 3, 2, 3, 2, 3 };

You'll have:

{ 1, 1, 2, 3, 2, 3 }

How to remove triplicated lines

5 Answers5