햄버거 만들기

 

풀이1

1. 햄버거는 [1, 2, 3, 1]
2. 입력받은 값을 스택에 하나씩 저장
3. 만약 스택의 사이즈가 4이상이면, 햄버거를 만들 수 있는 지 하나씩 확인 ([1,2,3,1] 을 가지는지 확인)
4. 만약 햄버거를 만들 수 있다면 result를 증가시킨 후, 해당 스택에서 4개를 삭제

---

코드

import java.util.Stack;

public class Hamburger {
	public int solution(int[] ingredient) {
		int result = 0;
		Stack<Integer> stack = new Stack<>();
		for (int in : ingredient) {
			stack.push(in);
			if (stack.size() >= 4) {
				int size = stack.size();
				if(stack.get(size - 1) == 1
						&& stack.get(size - 2) == 3
						&& stack.get(size - 3) == 2
						&& stack.get(size - 4) == 1) {
					result++;
					stack.pop();
					stack.pop();
					stack.pop();
					stack.pop();
				}
			}
		}
		return result;
	}

	public static void main(String[] args) {
		Hamburger divideString = new Hamburger();
		System.out.println(divideString.solution(new int[]{2, 1, 1, 2, 3, 1, 2, 3, 1}));    // 2
		System.out.println(divideString.solution(new int[]{1, 3, 2, 1, 2, 1, 3, 1, 2}));    // 0
	}
}

 

 

풀이2

(subSequence함수를 통해 맨 뒤부터 4가지 숫자만 확인하면 되기에 시간 복잡도를 만족합니다. 위 코드의 시간 복잡도는 O(N*M))

class Solution {
    public static int solution(int[] ingredient) {
        return packed_Burger(ingredient);
    }

    private static int packed_Burger(int[] ingredient) {
        StringBuilder ingredients = new StringBuilder();
        int count = 0;
        for(int num=0; num < ingredient.length; num++) {
            ingredients.append(ingredient[num]);
            if (ingredient[num] == 1 && ingredients.length() > 3) {
                if (make_Burger(ingredients)) {
                    count++;
                }
            }
        }
        return count;
    }

    private static boolean make_Burger(StringBuilder ingredients) {
        if(ingredients.length()>3 && ingredients.subSequence(
                                        ingredients.length()-4,
                                        ingredients.length()).equals("1231")) {
            ingredients.delete(ingredients.length()-4, ingredients.length());
            return true;
        }
        return false;
    }

 

 

풀이3

(Stack을 이용한 자바 코드입니다. 위 코드 역시 시간 복잡도는 O(N*M))

import java.util.Stack;
class Solution {
    public int solution(int[] ingredient) {
        Stack<Integer> ingredients = new Stack<>();
        int count_Burger = 0;
        for (int num = 0; num < ingredient.length; num++) {
            ingredients.push(ingredient[num]);
            int size = ingredients.size();
            if (size > 3 && ingredients.peek() == 1
            && ingredients.get(size-2) == 3
            && ingredients.get(size-3) == 2
            && ingredients.get(size-4) == 1) {
                packaging_Burger(ingredients);
                count_Burger++;
            }
        }
        return count_Burger;
    }

    private static void packaging_Burger(Stack<Integer> ingredients) {
        ingredients.pop();
        ingredients.pop();
        ingredients.pop();
        ingredients.pop();
    }
}