문제 설명

이중 우선순위 큐는 다음 연산을 할 수 있는 자료구조를 말합니다.

명령어 수신 탑(높이)
I 숫자 큐에 주어진 숫자를 삽입합니다.
D 1 큐에서 최댓값을 삭제합니다.
D -1 큐에서 최솟값을 삭제합니다.
이중 우선순위 큐가 할 연산 operations가 매개변수로 주어질 때, 모든 연산을 처리한 후 큐가 비어있으면 [0,0] 비어있지 않으면 [최댓값, 최솟값]을 return 하도록 solution 함수를 구현해주세요.

나의 풀이 (java)

import java.util.Collections;
import java.util.PriorityQueue;

class Solution {
    public int[] solution(String[] operations) {
        int[] answer = new int[2];
        PriorityQueue<Integer> maxQue = new PriorityQueue(Collections.reverseOrder());
        PriorityQueue<Integer> minQue = new PriorityQueue();

        for (String str:operations) {
            String[] operation = str.split(" ");
             if(operation[0].equals("I")) { // insert
                 maxQue.add(Integer.parseInt(operation[1]));
                 minQue.add(Integer.parseInt(operation[1]));
             }else if (operation[0].equals("D")){ // delete
                 if(maxQue.size()==0) continue;

                 if("1".equals(operation[1])){  // 최대값 삭제 및 동기화
                     minQue.remove(maxQue.remove());
                 }else if("-1".equals(operation[1])){ // 최소값 삭제 및 동기화
                     maxQue.remove(minQue.remove());
                 }
             }
        }
        answer[0] = maxQue.size()>0 ? maxQue.remove():0;
        answer[1] = minQue.size()>0 ? minQue.remove():0;
        return answer;
    }
}

풀이 방법

• (정렬된) 우선순위 큐를 2개 사용해서, 최소/최대값 관리
• 2개의 큐의 동기화 (remove를 이용)

다른사람의 풀이 (java)

import java.util.Collections;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
class Solution {
    public int[] solution(String[] arguments) {
        MidV q = new MidV();

        for(int i = 0; i < arguments.length; i++){
            String[] commend = arguments[i].split(" ");

            int v = Integer.parseInt(commend[1]);
            if(commend[0].equals("I")){
                q.push(v);
            }else{
                switch (v){
                    case 1 : q.removeMax();
                    break;
                    case -1: q.removeMin();
                    break;
                }
            }
        }


        int[] aw = new int[]{q.getMaxValue(),q.getMinValue()};

        return aw;
    }
}

class MidV{
    private PriorityQueue<Integer> leftHeap;
    private PriorityQueue<Integer> rightHeap;

    public MidV(){
        leftHeap = new PriorityQueue<>(10,Collections.reverseOrder());//최대값;
        rightHeap = new PriorityQueue<>();//최소값
    }


    public void push(int v){
        leftHeap.add(v);
    }

    public void removeMax(){

        while(!rightHeap.isEmpty()){
            leftHeap.add(rightHeap.poll());
        }

        leftHeap.poll();
    }

    public void removeMin(){

        while(!leftHeap.isEmpty()){
            rightHeap.add(leftHeap.poll());
        }

        rightHeap.poll();
    }

    public int getMaxValue(){

        if(leftHeap.size() == 0 && rightHeap.size() == 0)
            return 0;

        while(!rightHeap.isEmpty()){
            leftHeap.add(rightHeap.poll());
        }

        return leftHeap.peek();
    }

    public int getMinValue(){

        if(leftHeap.size() == 0 && rightHeap.size() == 0)
            return 0;

        while(!leftHeap.isEmpty()){
            rightHeap.add(leftHeap.poll());
        }

        return rightHeap.peek();
    }

}

느낀점

• (우선순위) 큐의 동작원리는 잘 알고 가자!
  • 노드 추가/삭제: add/remove

문제 설명

스트리밍 사이트에서 장르 별로 가장 많이 재생된 노래를 두 개씩 모아 베스트 앨범을 출시하려 합니다. 노래는 고유 번호로 구분하며, 노래를 수록하는 기준은 다음과 같습니다.

속한 노래가 많이 재생된 장르를 먼저 수록합니다.
장르 내에서 많이 재생된 노래를 먼저 수록합니다.
장르 내에서 재생 횟수가 같은 노래 중에서는 고유 번호가 낮은 노래를 먼저 수록합니다.
노래의 장르를 나타내는 문자열 배열 genres와 노래별 재생 횟수를 나타내는 정수 배열 plays가 주어질 때, 베스트 앨범에 들어갈 노래의 고유 번호를 순서대로 return 하도록 solution 함수를 완성하세요.

나의 풀이 (java)

import java.util.*;

class Solution {
    public int[] solution(String[] genres, int[] plays) {
        ArrayList<Integer> result =  new ArrayList();
        // map에 넣기 (장르+재생, 장르별 재생수용)
        Map playCountMap = new HashMap<>();
        for (int i = 0; i < genres.length; i++) {
            playCountMap.put(genres[i], (int)(playCountMap.get(genres[i])==null ? 0:playCountMap.get(genres[i]))+plays[i]);
        }

        // 정렬(장르별 재생수 합산)
        List<Map.Entry<String,Integer>> entryList = new ArrayList<>(playCountMap.entrySet());
        Collections.sort(entryList, (o1, o2) -> o2.getValue().compareTo(o1.getValue()));


        // 장르별 최대 2곡씩 선택
        for (Map.Entry<String, Integer> song : entryList) {
            int first = 0;
            int firstIndex = 0;
            int second = 0;
            int secondIndex = 0;

            for (int i = 0; i < genres.length; i++) {
                if(genres[i].equals(song.getKey())){
                    if(plays[i] > first){
                        second = first;
                        secondIndex = firstIndex;
                        first = plays[i];
                        firstIndex = i;
                    } else if(plays[i] > second){
                        second = plays[i];
                        secondIndex = i;
                    }
                }
            }
            result.add(firstIndex);
            if(second>0) result.add(secondIndex);
        }

        // arrList->arr
        return result.stream().mapToInt(Integer::intValue).toArray();
    }
}

풀이 방법

• HashMap을 사용하여 중복 제거 or 키-값별 카운트 가능

다른사람의 풀이 (java)

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Solution {
  public class Music implements Comparable<Music>{

    private int played;
    private int id;
    private String genre;

    public Music(String genre, int played, int id) {
      this.genre = genre; 
      this.played = played;
      this.id = id;
    }

    @Override
    public int compareTo(Music other) {
      if(this.played == other.played) return this.id - other.id;
      return other.played - this.played;
    }

    public String getGenre() {return genre;}
  }

  public int[] solution(String[] genres, int[] plays) {
    return IntStream.range(0, genres.length)
    .mapToObj(i -> new Music(genres[i], plays[i], i))
    .collect(Collectors.groupingBy(Music::getGenre))
    .entrySet().stream()
    .sorted((a, b) -> sum(b.getValue()) - sum(a.getValue()))
    .flatMap(x->x.getValue().stream().sorted().limit(2))
    .mapToInt(x->x.id).toArray();
  }

  private int sum(List<Music> value) {
    int answer = 0;
    for (Music music : value) {
      answer+=music.played;
    }
    return answer;
  }
}

Godd Idea : 다른사람 : class 나누고, Stream 활용

느낀점

• Comparator 대신 lamda사용
• arrayList<Integer> → array<int>
  => result.stream().mapToInt(Integer::intValue).toArray();

문제 설명

매운 것을 좋아하는 Leo는 모든 음식의 스코빌 지수를 K 이상으로 만들고 싶습니다. 모든 음식의 스코빌 지수를 K 이상으로 만들기 위해 Leo는 스코빌 지수가 가장 낮은 두 개의 음식을 아래와 같이 특별한 방법으로 섞어 새로운 음식을 만듭니다.

섞은 음식의 스코빌 지수 = 가장 맵지 않은 음식의 스코빌 지수 + (두 번째로 맵지 않은 음식의 스코빌 지수 * 2)

나의 풀이 (java)

import java.util.PriorityQueue;
class Solution {
    public int solution(int[] scoville, int K) {
        int answer = 0;
        // 우선순위큐(힙)에 넣어 정렬
        PriorityQueue<Integer> kScoville = new PriorityQueue();
        for (int scovilleIndex : scoville) {
            kScoville.offer(scovilleIndex);
        }

        while(kScoville.peek() < K){
            // 스코빌 섞기
            if(kScoville.size()==1) return -1;
            answer++;
            kScoville.add(kScoville.poll() + (kScoville.poll() * 2));
        }

        return answer;
    }
}

풀이 방법

• 특정 작업마다 정렬을 하면 비효율적 → 이럴때 힙(우선순위 큐)을 사용하면, 효율적으로 처리 가능
• 예외처리 (스코빌 지수를 K 이상으로 만들 수 없는 경우)

다른사람의 풀이 (java)

대부분 비슷

다만, Class를 나눠서, 재사용 가능하도록 짠 코드들은 인상적.

느낀점

특정 작업마다 정렬을 해야할 때 힙(우선순위 큐)을 사용하면, 효율적으로 처리 가능

문제 설명

트럭 여러 대가 강을 가로지르는 일차선 다리를 정해진 순으로 건너려 합니다. 모든 트럭이 다리를 건너려면 최소 몇 초가 걸리는지 알아내야 합니다. 다리에는 트럭이 최대 bridge_length대 올라갈 수 있으며, 다리는 weight 이하까지의 무게를 견딜 수 있습니다. 단, 다리에 완전히 오르지 않은 트럭의 무게는 무시합니다.

예를 들어, 트럭 2대가 올라갈 수 있고 무게를 10kg까지 견디는 다리가 있습니다. 무게가 [7, 4, 5, 6]kg인 트럭이 순서대로 최단 시간 안에 다리를 건너려면 다음과 같이 건너야 합니다.

나의 풀이 (java)

import java.util.LinkedList;
import java.util.Queue;

class Solution {
    public int solution(int bridge_length, int weight, int[] truck_weights) {
        int seconds = 0;
        int truckIndex = 0;
        int passingWeights = 0;
        Queue<Integer> passingTruck = new LinkedList<>();

        while(truck_weights.length > truckIndex){
            seconds++;

            // 건너가는 트럭이 있다면 앞에서 하나씩 제거
            if(passingTruck.size() == bridge_length){
                passingWeights -= passingTruck.poll();
            }

            if(weight >= passingWeights + truck_weights[truckIndex]){
                // 다리 하중이 괜찮다면, 한 대 더 건너가기
                passingTruck.add(truck_weights[truckIndex]);
                passingWeights += truck_weights[truckIndex];
                truckIndex++;
            }else{
                passingTruck.add(0);
                // 다라 하중이 꽉차면, 다리 위의 트럭만 1칸 건너가기
            }
        }
        return seconds+bridge_length;
    }
}

풀이 방법

• Queue의 기본 메소드 (poll,add)를 이용해 트럭을 이동시킨다 (다리 전 -> 다리 위, 다리 위 -> 다리 후)
• 적절한 조건 처리 (다리 하중)

다른사람의 풀이 (java)

mport java.util.*;

class Solution {
    class Truck {
        int weight;
        int move;

        public Truck(int weight) {
            this.weight = weight;
            this.move = 1;
        }

        public void moving() {
            move++;
        }
    }

    public int solution(int bridgeLength, int weight, int[] truckWeights) {
        Queue<Truck> waitQ = new LinkedList<>();
        Queue<Truck> moveQ = new LinkedList<>();

        for (int t : truckWeights) {
            waitQ.offer(new Truck(t));
        }

        int answer = 0;
        int curWeight = 0;

        while (!waitQ.isEmpty() || !moveQ.isEmpty()) {
            answer++;

            if (moveQ.isEmpty()) {
                Truck t = waitQ.poll();
                curWeight += t.weight;
                moveQ.offer(t);
                continue;
            }

            for (Truck t : moveQ) {
                t.moving();
            }

            if (moveQ.peek().move > bridgeLength) {
                Truck t = moveQ.poll();
                curWeight -= t.weight;
            }

            if (!waitQ.isEmpty() && curWeight + waitQ.peek().weight <= weight) {
                Truck t = waitQ.poll();
                curWeight += t.weight;
                moveQ.offer(t);
            }
        }

        return answer;
    }
}

Godd Idea : Java의 OOP를 활용한 풀이. 객체를 만들어서 무게&이동을 관리한다는 접근이 좋은듯.

느낀점

이번 문제는 풀이가 다양하다. 직독직해 느낌의 내 풀이도 맘에 들지만!

다른 사람들의 풀이를 보는 재미가 있는 문제였다.

풀이 방법은 결국 비슷하지만, 구현하는 방식이 다 다르다!

객체를 만들어서 OOP로 접근하거나

Map으로 제거하는 방법도 좋았다.

문제 설명

일반적인 프린터는 인쇄 요청이 들어온 순서대로 인쇄합니다. 그렇기 때문에 중요한 문서가 나중에 인쇄될 수 있습니다. 이런 문제를 보완하기 위해 중요도가 높은 문서를 먼저 인쇄하는 프린터를 개발했습니다. 이 새롭게 개발한 프린터는 아래와 같은 방식으로 인쇄 작업을 수행합니다.

나의 풀이 (java)

import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.Queue;

class Solution {
    public int solution(int[] priorities, int location) {
        int answer = 0;
        // 필요한 변수 생성 (가장 높은 우선순위, 정렬된 우선순위, 우선순위 리스트)
        Integer biggestNum = 0;
        Queue<Integer> queue = new LinkedList<>();
        ArrayList<Integer> sortedPriorities = new ArrayList();
        for (int num: priorities) {
            queue.add(num);
            sortedPriorities.add(num);
        }
        sortedPriorities.sort(Collections.reverseOrder());

        while(true){
            // 큐에서 하나씩 빼거나, 빼서 맨 뒤로 보내거나
            biggestNum = sortedPriorities.get(answer);
            if (location == 0 && queue.peek() == biggestNum){
                answer++;
                break;
            } else if (queue.peek() < biggestNum){
                queue.add(queue.poll());
            } else {
                queue.poll();
                answer++;
            }

            // 내가 선택한 작업의 위치 관리하기
            if(location==0)
                location = queue.size()-1;
            else
                location--;
        }

        return answer;
    }
}

풀이 방법

• 큐를 이용해 원하는 로직을 구현하기
  • 대기 목록 우선 순위대로 수행 (큐에서 하나씩 빼거나, 빼서 맨 뒤로 보내거나)
  • 적절한 변수 생성 (location:선택한 작업 위치 관리, biggestNum:가장 높은 우선순위)

느낀점

로직 자체는 고민을 좀 하면 나올수 있으나

Array, List, Queue, int형이 섞였을때가 좀 헷갈리니 다시 정리

• Array 정렬 방법
      - 단순 정렬시 - Array.sort(arr)
• List 정렬 방법
      - 단순 정렬시 - Collections.sort(list)

// 둘 다 같음
sortedPriorities.sort(Collections.reverseOrder());
Collections.sort(sortedPriorities, Collections.reverseOrder());

문제 설명

괄호가 바르게 짝지어졌다는 것은 '(' 문자로 열렸으면 반드시 짝지어서 ')' 문자로 닫혀야 한다는 뜻입니다. 예를 들어

"()()" 또는 "(())()" 는 올바른 괄호입니다.
")()(" 또는 "(()(" 는 올바르지 않은 괄호입니다.
'(' 또는 ')' 로만 이루어진 문자열 s가 주어졌을 때, 문자열 s가 올바른 괄호이면 true를 return 하고, 올바르지 않은 괄호이면 false를 return 하는 solution 함수를 완성해 주세요.

나의 풀이 (java)

import java.util.Stack;

class Solution {

    public static void main(String[] args) {
        String str = "()()";
        boolean result = solution(str);
        System.out.println("### Result : " + result);
    }

    static boolean solution(String s) {
				boolean answer = false;
        Stack<Integer> criteria = new Stack<>();

        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c == '('){
                criteria.push(0);
            }else if (c == ')'){
                if (criteria.empty()) return false;
                criteria.pop();
            }
        }

        // split의 경우 효율성 검사에서 떨어짐
//        if (s.length()==0) return false;
//        String[] strArr = s.split("");
//        for (String str:strArr) {
//            if (str.equals("(")){
//                criteria.push(0);
//            }else if (str.equals(")")){
//                if (criteria.empty()) return false;
//                criteria.pop();
//            }
//        }

        if (criteria.empty()) answer = true;
        return answer;
    }
}

풀이 방법

• 간단한 Stack 사용 pop,push 사용법
• 문자열 for문을 사용법

다른사람의 풀이 (java)

Godd Idea :

느낀점

• 문자 for문 사용시, split(””)대신 charAt()으로 사용 (char은 ‘’로 문자열 비교)
  • split으로 문자열 반복문을 사용 할 경우, 효율성에서 통과하지 못하고, 자바 버전에 따라 문제가 생기기도 하니, charAt()을 사용하자!

문제 설명

당신은 폰켓몬을 잡기 위한 오랜 여행 끝에, 홍 박사님의 연구실에 도착했습니다. 홍 박사님은 당신에게 자신의 연구실에 있는 총 N 마리의 폰켓몬 중에서 N/2마리를 가져가도 좋다고 했습니다.
홍 박사님 연구실의 폰켓몬은 종류에 따라 번호를 붙여 구분합니다. 따라서 같은 종류의 폰켓몬은 같은 번호를 가지고 있습니다. 예를 들어 연구실에 총 4마리의 폰켓몬이 있고, 각 폰켓몬의 종류 번호가 [3번, 1번, 2번, 3번]이라면 이는 3번 폰켓몬 두 마리, 1번 폰켓몬 한 마리, 2번 폰켓몬 한 마리가 있음을 나타냅니다. 이때, 4마리의 폰켓몬 중 2마리를 고르는 방법은 다음과 같이 6가지가 있습니다.

나의 풀이 (java)

import java.util.HashSet;
class Solution {
    public int solution(int[] nums) {
        HashSet<Integer> tempSet = new HashSet<>();
        for(int i =0; i<nums.length;i++) {
            tempSet.add(nums[i]);
        }

        // map 크기 중 arr/2 크기 만큼 해서 최댓값 구하기
        int kindCount = tempSet.size();
        int selectCount = nums.length/2;
        return Math.min(kindCount, selectCount);
    }
}

풀이 방법 = 다른사람의 풀이 (java)

Godd Idea :

• HashSet 를 사용한 중복 제거 (HashSet = Array List와 비슷하지만 중복 제외,성능도 더 좋음)

느낀점

HashMap만 썼는데,
이런 경우에는 굳이 Map이 아닌 Set으로 처리 가능하다는 것과 쓰는 법을 배웠다

문제 설명

스파이들은 매일 다른 옷을 조합하여 입어 자신을 위장합니다.

예를 들어 스파이가 가진 옷이 아래와 같고 오늘 스파이가 동그란 안경, 긴 코트, 파란색 티셔츠를 입었다면 다음날은 청바지를 추가로 입거나 동그란 안경 대신 검정 선글라스를 착용하거나 해야 합니다.

종류 이름
얼굴 동그란 안경, 검정 선글라스
상의 파란색 티셔츠
하의 청바지
겉옷 긴 코트
스파이가 가진 의상들이 담긴 2차원 배열 clothes가 주어질 때 서로 다른 옷의 조합의 수를 return 하도록 solution 함수를 작성해주세요.

나의 풀이 (java)

import java.util.HashMap;
class Solution {
    public int solution(String[][] clothes) {
        int answer = 1;
        HashMap<String, Integer> clothesMap = new HashMap<>();
        // Hash로 저장
        for (int i = 0; i < clothes.length; i++) {
            clothesMap.put(clothes[i][1], clothesMap.get(clothes[i][1])==null ? 2:clothesMap.get(clothes[i][1])+1);
        }

        // Hash를 이용해 key(카테고리), value(count++) 해서 count 계산
        for (String category :clothesMap.keySet()) {
            answer *= clothesMap.get(category);
        }

        // count들 끼리 곱 한후 -1 (모두 0을 고른 경우)
        return answer-1;
    }
}

풀이 방법 = 다른사람의 풀이 (java)

Godd Idea :

• Hash로 중복 제거
• Hash를 이용해 key(카테고리), value(count++) 해서 count 계산
• 경우의수 구하기 : 수학적 접근 (n+1) * (m+1) * (o+1)... -1

느낀점

HsahMap은 key, value로 이루어지는데, key가 중복되지 않는걸 이용해서 중복제거, key별로 관리하는 방식으로 사용 (count)

문제 설명

전화번호부에 적힌 전화번호 중, 한 번호가 다른 번호의 접두어인 경우가 있는지 확인하려 합니다.
전화번호가 다음과 같을 경우, 구조대 전화번호는 영석이의 전화번호의 접두사입니다.

• 구조대 : 119
• 박준영 : 97 674 223
• 지영석 : 11 9552 4421

전화번호부에 적힌 전화번호를 담은 배열 phone_book 이 solution 함수의 매개변수로 주어질 때, 어떤 번호가 다른 번호의 접두어인 경우가 있으면 false를 그렇지 않으면 true를 return 하도록 solution 함수를 작성해주세요.

나의 풀이 (java)

import java.util.Arrays;

public class Phonebook {

    public static void main(String[] args) {
        String[] phone_book = {"12", "123", "1235", "567", "88"};
        System.out.println("###    RESULT  : "+ solution(phone_book));
    }

    // String 정렬(12,123,1235,222,..) 후 비교
    public static boolean solution(String[] phone_book) {
        Arrays.sort(phone_book);
        for (int i = 0; i < phone_book.length-1; i++) {
            if(phone_book[i+1].startsWith(phone_book[i])) return false;
        }
        return true;
    }

    // 이중 for문 사용 - 효율성 테스트에서 걸림
    public static boolean solution2(String[] phone_book) {
        for (int i = 0; i < phone_book.length; i++) {
            for (int j = 0; j < phone_book.length; j++) {
                if(i != j && phone_book[i].startsWith(phone_book[j])) return false;
            }
        }
        return true;
    }
}

풀이 방법

예전에 다른 사람의 풀이를 봤던게 어렴풋이 기억에 남아서 비슷하게 사용한 것 같다

중요 아이디어는 

• startWith : 문자열의 prefix(접두사) 확인 가능
• Array.Sort(문자) : 문자를 비교하면 1, 12, 123 이런식으로 정렬된다는 특징을 사용

다른사람의 풀이 (java) 

class Solution {
    public boolean solution(String[] phoneBook) {
        Arrays.sort(phoneBook);
        boolean result = true;
        for (int i=0; i<phoneBook.length-1; i++) {
            if (phoneBook[i+1].contains(phoneBook[i])) {
                result = false;
                break;
            }
        }
        return result;
    }
}

Godd Idea : String 정렬의 특징을 이용한 비교

느낀점

• 해시를 사용하기전 Sorting을 통해 성능만 높이는게 성능을 위한 옵션이 아니라, 
  필수 사항이 되기도 한다

문제 설명

초 단위로 기록된 주식가격이 담긴 배열 prices가 매개변수로 주어질 때, 가격이 떨어지지 않은 기간은 몇 초인지를 return 하도록 solution 함수를 완성하세요.

나의 풀이 (java)

import java.util.ArrayList;
import java.util.List;

public class StockPrices {

    public static void main(String[] args) {
        int[] arr = {1,2,3,2,3};
        solution(arr);
    }

    public static int[] solution(int[] prices) {
        List<Integer> secondsArr = new ArrayList<>();
        for (int i = 0; i < prices.length; i++) {
            int seconds = 0;
            for (int j = i; j < prices.length; j++) {
                if (prices[i] > prices[j] || j == prices.length-1) {
                    secondsArr.add(seconds);
                    break;
                }else{
                    seconds ++;
                }
            }
        }
        return secondsArr.stream().mapToInt(Integer::intValue).toArray();
    }
}

풀이 방법

특별히 어려운 로직은 없고, 스택/큐의 문제임을 무시하고, 이중 for문으로 해결 가능

• List -> Array
  list.stream().mapToInt(Integer::intValue).toArray();

다른사람의 풀이 (java) 

class Solution {
    public int[] solution(int[] prices) {
        int len = prices.length;
        int[] answer = new int[len];
        int i, j;
        for (i = 0; i < len; i++) {
            for (j = i + 1; j < len; j++) {
                answer[i]++;
                if (prices[i] > prices[j])
                    break;
            }
        }
        return answer;
    }
}

Godd Idea : 거의 비슷. seconds 변수를 사용하지 않고 바로 index로 접근해서 카운트하고, 조건문이 조금 다른게 차이

느낀점

• 스택/큐를 사용하지 않는대신, 아래 2가지 방법을 사용 가능
  • temp 변수에 이전 값 or 이전까지의 특정값(최대값 등)을 저장해서 비교/처리 가능
  • 이중 for문 등을 사용하되, list의 index로 값에 직접 접근 : arr[i]++;
• 물론 코드 짜고, 정리하지 않아 지저분한걸 감안해도, 코드가
  가독성이 떨어지고,
  그렇다고 재사용성이 좋지도 않고,
  아이디어가 좋은 것도 아니고,
  그냥 문제를 푼 느낌이 없지 않아 있다
• 하지만, 코드를 직독직해 하듯이 풀었기에, 초보자가 보기에는 오히려 편할수도?!