SandsOfGrainV2.0

package MidExamPreparation.MidExam27August18;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class O2GrainsOfSands {
    public static void main(String[] args) throws IOException {
        BufferedReader reader =
            new BufferedReader(
                new InputStreamReader(
                    System.in
                )
            );

        List<Integer> initialSequence = Arrays.stream(reader.readLine().split("\\s+"))
                .map(Integer::parseInt)
                .collect(Collectors.toList());

        String line;

        while (!"Mort".equalsIgnoreCase(line= reader.readLine())) {
            String[] token = line.split("\\s+");

            String command = token[0].toLowerCase();

            switch (command) {
                case "add" :
                    initialSequence.add(Integer.parseInt(token[1]));
                    break;

                case "remove" :
                    if (initialSequence.contains(Integer.parseInt(token[1]))) {
                       initialSequence
                                .stream()
                                .filter(element-> element==Integer.parseInt(token[1]))
                                .findFirst()
                                 .map(initialSequence::remove);
                    } else {
                        if (Integer.parseInt(token[1]) >= 0
                                && Integer.parseInt(token[1]) < initialSequence.size()) {
                            initialSequence.remove(Integer.parseInt(token[1]));
                        }
                    }
                    break;

                case "replace" :
                    if (initialSequence.contains(Integer.parseInt(token[1]))) {
                        initialSequence = initialSequence
                                .stream()
                                .filter(element-> element==Integer.parseInt(token[1]))
                                .findFirst()
                                .map(element ->
                                        initialSequence
                                                .set(initialSequence.indexOf(element),
                                                        Integer.parseInt(token[2])
                                                ))
                        ;
                    }
                    break;


                case "increase" :

                    //nums.stream().map(e -> e + nums.stream().filter(x -> x >= value).findFirst().orElse(nums.get(nums.size() - 1)));

                    int value = initialSequence
                            .stream()
                            .filter(element-> element >= Integer.parseInt(token[1]))
                            .findFirst()
                            .orElse(initialSequence
                            .get(initialSequence.size() - 1));
                    initialSequence = initialSequence
                            .stream()
                            .map(element->
                                    element + value)
                            .collect(Collectors.toList());

//                    boolean isThere = true;
//
//                    for (int i = 0; i < initialSequence.size(); i++) {
//
//                         if (initialSequence.get(i) >= Integer.parseInt(token[1])) {
//                             int value = initialSequence.get(i);
//
//                             for (int j = 0; j <= initialSequence.size()-1; j++) {
//                                 initialSequence.set(j, initialSequence.get(j) + value);
//                             }
//
//                             isThere = true;
//                             break;
//                         }  else {
//                             isThere = false;
//                         }
//
//                    }
//                    if (!isThere){
//                    int increaseValue = initialSequence.get(initialSequence.size() - 1);
//
//                    for (int p = 0; p <= initialSequence.size()-1; p++) {
//                        initialSequence.set(p, initialSequence.get(p) + increaseValue);
//                    }
//
//                }
                    break;

                case "collapse" :
                    initialSequence.removeIf(element->
                            element < Integer.parseInt(token[1])
                    );
                    break;
                    default:
                        break;
            }
        }

        System.out.println(initialSequence
                .toString()
                .replaceAll("[\\[|,\\]]", "")
                .trim());
    }
}