GrainsOfSand

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
                                .stream()
                                .filter(element-> element==Integer.parseInt(token[1]))
                                .findFirst()
                                .map(element ->
                                        initialSequence
                                                .set(initialSequence.indexOf(element),
                                                        Integer.parseInt(token[2])
                                                )
                                );
                    }
                    break;

                case "increase" :
                    if (initialSequence.contains(Integer.parseInt(token[1]))) {
                        initialSequence
                                .stream()
                                .filter(element -> element >= Integer.parseInt(token[1]))
                                .forEach(element -> initialSequence
                                        .set(initialSequence.indexOf(element),
                                                initialSequence.get(element)
                                                        +
                                                        Integer.parseInt(token[2])
                                        ));
                    } else {
                        int increaseValue = initialSequence.get(initialSequence.size() - 1);

//                        for (int i = 0; i <= initialSequence.size()-1; i++) {
//                            initialSequence.set(i, initialSequence.get(i) + increaseValue);
//                        }

                        initialSequence
                                .stream()
                                .forEach(element->
                                        initialSequence
                                .set(element, initialSequence.get(element) + increaseValue));

                                           }
                    break;

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

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