Generating all possible positions of item by snippet from List

Question

I have this class

public class Operation {

  private double value;
  private boolean inc;

  public Operation(double value, boolean inc) {
    this.value = value;
    this.inc = inc;
  }

  public double getValue() {
    return value;
  }

  public void setValue(double value) {
    this.value = value;
  }

  public boolean isInc() {
    return inc;
  }

  public void setInc(boolean inc) {
    this.inc = inc;
  }

  @Override
  public String toString() {
    return "Operation{" + "value=" + value + ", inc=" + inc + '}';
  }

}

Now I have this List

public class TestOperation {

  public static void main(String[] args) {
    List<Operation> listOperation1 = new ArrayList<>();
    listOperation1.add(new Operation(1.3, true));
    listOperation1.add(new Operation(2.7, true));
    listOperation1.add(new Operation(0.9, false));
    listOperation1.add(new Operation(0.8, false));

    //Generate posible Rotation listOperation1
    //Operation(1.3, true), Operation(2.7, true), Operation(0.9, false), Operation(0.8, false)
    //Operation(1.3, true), Operation(2.7, true), Operation(0.8, false), Operation(0.9, false)
    //Operation(2.7, true), Operation(1.3, true), Operation(0.9, false), Operation(0.8, false)
    //Operation(2.7, true), Operation(1.3, true), Operation(0.8, false), Operation(0.9, false)

    List<Operation> listOperation2 = new ArrayList<>();
    listOperation2.add(new Operation(1.5, true));
    listOperation2.add(new Operation(2.9, true));
    listOperation2.add(new Operation(4.6, true));

    //Generate posible Rotation listOperation2
    //Operation(1.5, true), Operation(2.9, true), Operation(4.6, true)
    //Operation(1.5, true), Operation(4.6, true), Operation(2.9, true)
    //Operation(2.9, true), Operation(4.6, true), Operation(1.5, true)
    //Operation(2.9, true), Operation(1.5, true), Operation(4.6, true)
    //Operation(4.6, true), Operation(2.9, true), Operation(1.5, true)
    //Operation(4.6, true), Operation(1.5, true), Operation(2.9, true)
  }

}

The rotation only occurs between inc = true, and inc = false, Not mixed! The numbers of items inc = true can differs of inc = false. Even, some may not exist.

All submitted items from list must treated, none can be missing, but can't be repeated (like object, not like value).

How generate this rotation?

What should happen if the input is like `[true, false, true, false, true, false]`? — Holger, May 14 '19 at 08:56
@Holger, I forget that situation because previously I ordered, first `true` then `false` — Chepe Questn, May 14 '19 at 10:20
So what should should happen then? Or does your task imply sorting before rotating? — Holger, May 14 '19 at 10:31
@Holger no matters, the `true` need to be ordered only with `true`, and `false`with `false`, this not change the situation. — Chepe Questn, May 14 '19 at 10:33
Then, add an example to the question, showing what should happen then. — Holger, May 14 '19 at 11:14

joseluisbz · Accepted Answer · 2019-05-14T17:25:37.670

public class JavaApplication7 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        List<Operation> listOperation1 = new ArrayList<>();
        listOperation1.add(new Operation(1.3, true));
        listOperation1.add(new Operation(2.7, true));
        listOperation1.add(new Operation(0.9, false));
        listOperation1.add(new Operation(0.8, false));

        List listOperationTrue = listOperation1.stream()
                .filter(operation -> operation.isInc())
                .collect(Collectors.toList());

        List listOperationFalse = listOperation1.stream()
                .filter(operation -> !operation.isInc())
                .collect(Collectors.toList());

        List<List<Operation>> permutationTrue = new ArrayList<>();
        permuteList(listOperationTrue, 0, permutationTrue);
        System.out.println("\npermutationTrue");
        permutationTrue.stream().forEach(System.out::print);
        System.out.println();

        List<List<Operation>> permutationFalse = new ArrayList<>();
        permuteList(listOperationFalse, 0, permutationFalse);
        System.out.println("\npermutationFalse");
        permutationFalse.stream().forEach(System.out::print);

        System.out.println("\n\npermutationTrue -> permutationFalse");
        permutationTrue.stream().forEachOrdered(pTrue -> {
            permutationFalse.stream().forEachOrdered(pFalse -> {
                pTrue.stream().forEach(System.out::print);
                System.out.print(" -> ");
                pFalse.stream().forEach(System.out::print);
                System.out.println();
            });
        });
    }

    private static void permuteList(List<Operation> listOperation, int pos, List<List<Operation>> out) {
        if (pos == listOperation.size() - 1) {
            out.add(listOperation);
        } else {
            for (int i = pos; i < listOperation.size(); i++) {
                listOperation = swap(listOperation, pos, i);
                permuteList(listOperation, pos + 1, out);
                listOperation = swap(listOperation, pos, i);
            }
        }
    }

    public static List<Operation> swap(List<Operation> listOperation, int i, int j) {
        List<Operation> outSwap = new ArrayList<>(listOperation);
        outSwap.set(i, listOperation.get(j));
        outSwap.set(j, listOperation.get(i));
        return outSwap;
    }

}

The output:

    permutationTrue
    [Operation{value=1.3, inc=true}, Operation{value=2.7, inc=true}][Operation{value=2.7, inc=true}, Operation{value=1.3, inc=true}]

    permutationFalse
    [Operation{value=0.9, inc=false}, Operation{value=0.8, inc=false}][Operation{value=0.8, inc=false}, Operation{value=0.9, inc=false}]

    permutationTrue -> permutationFalse
    Operation{value=1.3, inc=true}Operation{value=2.7, inc=true} -> Operation{value=0.9, inc=false}Operation{value=0.8, inc=false}
    Operation{value=1.3, inc=true}Operation{value=2.7, inc=true} -> Operation{value=0.8, inc=false}Operation{value=0.9, inc=false}
    Operation{value=2.7, inc=true}Operation{value=1.3, inc=true} -> Operation{value=0.9, inc=false}Operation{value=0.8, inc=false}
    Operation{value=2.7, inc=true}Operation{value=1.3, inc=true} -> Operation{value=0.8, inc=false}Operation{value=0.9, inc=false}
    BUILD SUCCESSFUL (total time: 0 seconds)

permutation algorythm adapted from https://www.geeksforgeeks.org/write-a-c-program-to-print-all-permutations-of-a-given-string/ — joseluisbz, May 14 '19 at 14:13
Recommended reading: [When to use LinkedList over ArrayList in Java?](https://stackoverflow.com/q/322715/2711488) In short, you’ll rarely find a use case where `LinkedList` is preferable and code extensively using swap operations, i.e. `get(int)` and `set(int, T)`, is definitely *not* one of these cases. — Holger, May 14 '19 at 16:19
@Holger thank you, I changued the used class. And I will read your post. — joseluisbz, May 14 '19 at 17:27

Generating all possible positions of item by snippet from List

1 Answers1