class Solution {
    public int[] getOrder(int[][] tasks) {
    int tasksLength = tasks.length;

    List<Task> list = new LinkedList<>();
    for (int i = 0; i < tasksLength; i++) {
      list.add(new Task(i, tasks[i][0], tasks[i][1]));
    }
    list.sort((a, b) -> a.getEt() - b.getEt());

    int finishedTaskCount = 0;
    int time = 0;
    int mark = 0;
    int wait = 1;
    StringBuilder sb = new StringBuilder();
    PriorityQueue<Task> pq = new PriorityQueue<>((a, b) -> a.getPt() - b.getPt());
    while (finishedTaskCount < tasksLength) {
      time++;
      wait--;

      // 해당 시간에 처리가능한 작업들 큐에 넣기
      for (int i = mark; i < list.size(); i++) {
        if (list.get(mark).getEt() != time) break;
        pq.add(list.get(mark));
        mark++;
      }


      // cpu 가 idle 이 아니라면, 큐에있는 작업중 처리해야 할 작업 고르고 처리
      if (wait < 1) {
        Task task = pq.stream().filter(o -> pq.peek().getPt() == o.getPt()).min((a, b) -> a.getIdx() - b.getIdx()).orElse(null);
        if(task!=null) {
          wait = task.getPt();
          sb.append(task.getIdx()).append(" ");
          pq.remove(task);
          finishedTaskCount++;
        }
      }
    }


    return Arrays.stream(sb.toString().split(" ")).mapToInt(Integer::parseInt).toArray();
  }

    public static class Task {
    private int idx;
    private int et;
    private int pt;

    public Task(int idx, int et, int pt) {
      this.idx = idx;
      this.et = et;
      this.pt = pt;
    }

    public int getIdx() {
      return idx;
    }

    public int getEt() {
      return et;
    }

    public int getPt() {
      return pt;
    }
  }
}

오늘도 역시 타임아웃 엔딩 

2시간 동안 똥을 만들었다

그나마 위안이 되는건 코드길이는 솔루션이랑 비슷함 ㅎㅎ