๋ณธ๋ฌธ ๋ฐ”๋กœ๊ฐ€๊ธฐ
Programmers lv-0

์ปจํŠธ๋กค ์ œํŠธ - Java [ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค ์ž…๋ฌธ]

by ๊ทคํ”ผํ‚ค 2022. 11. 27.

 

โค๏ธ Problem

๋”๋ณด๊ธฐ
  • ๋ฌธ์ œ
    ์ˆซ์ž๋“ค์ด ๊ณต๋ฐฑ์œผ๋กœ ๊ตฌ๋ถ„๋œ ๋ฌธ์ž์—ด์ด ์ฃผ์–ด์ง‘๋‹ˆ๋‹ค. ๋ฌธ์ž์—ด์— ์žˆ๋Š” ์ˆซ์ž๋ฅผ ์ฐจ๋ก€๋Œ€๋กœ ๋”ํ•˜๋ ค๊ณ  ํ•ฉ๋‹ˆ๋‹ค. ์ด ๋•Œ “Z”๊ฐ€ ๋‚˜์˜ค๋ฉด ๋ฐ”๋กœ ์ „์— ๋”ํ–ˆ๋˜ ์ˆซ์ž๋ฅผ ๋บ€๋‹ค๋Š” ๋œป์ž…๋‹ˆ๋‹ค. ์ˆซ์ž์™€ “Z”๋กœ ์ด๋ฃจ์–ด์ง„ ๋ฌธ์ž์—ด s๊ฐ€ ์ฃผ์–ด์งˆ ๋•Œ, ๋จธ์“ฑ์ด๊ฐ€ ๊ตฌํ•œ ๊ฐ’์„ return ํ•˜๋„๋ก solution ํ•จ์ˆ˜๋ฅผ ์™„์„ฑํ•ด๋ณด์„ธ์š”.

 

  • ์ œํ•œ ์‚ฌํ•ญ
    • 0 < s์˜ ๊ธธ์ด < 1,000
    • -1,000 < s์˜ ์›์†Œ ์ค‘ ์ˆซ์ž < 1,000
    • s๋Š” ์ˆซ์ž, "Z", ๊ณต๋ฐฑ์œผ๋กœ ์ด๋ฃจ์–ด์ ธ ์žˆ์Šต๋‹ˆ๋‹ค.
    • s์— ์žˆ๋Š” ์ˆซ์ž์™€ "Z"๋Š” ์„œ๋กœ ๊ณต๋ฐฑ์œผ๋กœ ๊ตฌ๋ถ„๋ฉ๋‹ˆ๋‹ค.
    • ์—ฐ์†๋œ ๊ณต๋ฐฑ์€ ์ฃผ์–ด์ง€์ง€ ์•Š์Šต๋‹ˆ๋‹ค.
    • 0์„ ์ œ์™ธํ•˜๊ณ ๋Š” 0์œผ๋กœ ์‹œ์ž‘ํ•˜๋Š” ์ˆซ์ž๋Š” ์—†์Šต๋‹ˆ๋‹ค.
    • s์˜ ์‹œ์ž‘๊ณผ ๋์—๋Š” ๊ณต๋ฐฑ์ด ์—†์Šต๋‹ˆ๋‹ค.
    • ๋ชจ๋“  ์ˆซ์ž๋ฅผ ์ง€์šฐ๋Š” ๊ฒฝ์šฐ๋Š” ์ฃผ์–ด์ง€์ง€ ์•Š์Šต๋‹ˆ๋‹ค.
    • ์ง€์šธ ์ˆซ์ž๊ฐ€ ์—†๋Š” ์ƒํƒœ์—์„œ "Z"๋Š” ๋ฌด์‹œํ•ฉ๋‹ˆ๋‹ค.

 

์ž…์ถœ๋ ฅ ์˜ˆ & ์„ค๋ช…

no s result
1 "1 2 Z 3" 4
2 "10 20 30 40" 100
3 "10 Z 20 Z 1" 1
  1. ๋ณธ๋ฌธ๊ณผ ๋™์ผํ•ฉ๋‹ˆ๋‹ค.
  2. 10 + 20 + 30 + 40 = 100์„ return ํ•ฉ๋‹ˆ๋‹ค.
  3. "10 Z 20 Z 1"์—์„œ 10 ๋‹ค์Œ Z, 20 ๋‹ค์Œ Z๋กœ 10, 20์ด ์ง€์›Œ์ง€๊ณ  1๋งŒ ๋”ํ•˜์—ฌ 1์„ return ํ•ฉ๋‹ˆ๋‹ค.

 


 

๐Ÿ’› Solution

ํ’€์ด

import java.util.Stack;
class Solution {
    public int solution(String s) {
        String[] str = s.split(" ");
        Stack<String> st = new Stack<>();

        int sum = 0;
        for(int i=0; i<str.length; i++) {
            if(!str[i].equals("Z")) {
                st.push(str[i]);
            } else {
                st.pop();
            }
        }

        while (!st.isEmpty()) {
            sum += Integer.parseInt(st.pop());
        }
        return sum;
    }
}

 

์ฒ˜๋ฆฌ์†๋„๋ฅผ ๋” ๋น ๋ฅด๊ฒŒ ํ•  ์ˆ˜๋Š” ์—†์„๊นŒ

 


 

๐Ÿ’œ Comment

์ด ๋ฌธ์ œ๋Š” ํ†ต๊ณผ๊นŒ์ง€ ์ •๋ง ์˜ค๋ž˜๊ฑธ๋ ธ๋˜ ๋ฌธ์ œ.

์ฒ˜์Œ์—๋Š” ๋ฐฐ์—ด๋กœ ํ•ด๊ฒฐํ•˜๋ ค๊ณ  ํ•ด๋ดค๋Š”๋ฐ ์—ฐ๋‹ฌ์•„์„œ "Z"๊ฐ€ ๋‚˜์˜ค๋Š” ๊ฒฝ์šฐ๋ฅผ ๋„์ €ํžˆ ํ•ด๊ฒฐํ•  ์ˆ˜ ์—†์—ˆ๋‹ค.


if๋ฌธ ์•ˆ์— While๋ฌธ์„ ์จ์„œ "Z"๊ฐ€ ์—ฐ๋‹ฌ์•„ ๋‚˜์˜ค๋Š” ์ƒํ™ฉ์„ ๋Œ€๋น„ํ•˜๋ ค๊ณ  ์•„๋ž˜์™€ ๊ฐ™์ด ์ฝ”๋“œ๋ฅผ ์งฐ๋‹ค.

class Solution {
    public int solution(String s) {
        String[] str = s.split(" ");
        int sum = 0;
        for(int i=0; i<str.length; i++) {
            if(str[i].equals("Z")) {
                int ctrl = i-1;
                String temp = "";
                if(str[ctrl].equals("Z")) {
                    while (str[ctrl].equals("Z")) {
                        temp = str[ctrl-1];
                        ctrl--;
                    }
                    sum -= Integer.parseInt(temp);
                } else {
                    sum -= Integer.parseInt(str[i-1]);
                }
            } else {
                sum += Integer.parseInt(str[i]);
            }
        }
        return sum;
    }
}

 


๊ฒฐ๊ณผ๋Š” ๋ณด๋‹ค์‹œํ”ผ ํ…Œ์ŠคํŠธ 7์—์„œ ์‹คํŒจ๊ฐ€ ๋‚˜์™”๋‹ค.

์–ด๋–ป๊ฒŒ ํ•ด๊ฒฐํ•ด์•ผ ํ• ์ง€ ๋ชจ๋ฅด๊ฒ ์–ด์„œ ๋ง‰๋ง‰ํ•˜๋˜ ์ค‘์— "์ปจํŠธ๋กค ์ œํŠธ"์˜ ์ปจ์…‰์„ ๋‹ค์‹œ ์ƒ๊ฐํ•ด ๋ณด์•˜๋‹ค.


"์ปจํŠธ๋กค ์ œํŠธ"์˜ ์ •์˜๋Š” ์ง์ „์— ์ˆ˜ํ–‰ํ•œ ํ–‰๋™์„ ์ทจ์†Œํ•˜๋Š” ๊ฒƒ.


์ฆ‰, ์ปจํŠธ๋กค ์ œํŠธ๋ฅผ ์—ฐ์†์œผ๋กœ ๋ˆ„๋ฅด๋ฉด ์ง์ „์— ๋”ํ•ด์กŒ๋˜ ๊ฐ’์ด ํ•˜๋‚˜์”ฉ ์ทจ์†Œ๋˜์–ด์•ผํ•˜๋Š” ๊ฒƒ์ด์—ˆ๋‹ค.

๊ทธ๋ ‡๋‹ค๋ฉด ์ง์ „ ๊ฐ’์„ ์ธ๋ฑ์Šค ์—†์ด ๋บ„ ์ˆ˜ ์žˆ๋Š” ํ˜•ํƒœ๋Š” ์—†์„๊นŒ? ๊ณ ๋ฏผ ํ•˜๋˜ ์ค‘์— ๋ฌธ๋“ ์ •๋ณด์ฒ˜๋ฆฌ๊ธฐ์‚ฌ ๊ณต๋ถ€ํ•˜๋ฉด์„œ ๋ฐฐ์› ๋˜ ํ›„์ž…์„ ์ถœ์ด๋ผ๋Š” ๊ฐœ๋…์ด ๋นก ๋– ์˜ฌ๋ž๋‹ค. ๋•๋ถ„์— Stack์„ ์‚ฌ์šฉํ•ด์„œ ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•  ์ˆ˜ ์žˆ์—ˆ๋‹ค๐Ÿคฉ

 

ํ…Œ์ŠคํŠธ ํ†ต๊ณผ๋„ ํ–‰๋ณตํ•œ๋ฐ ์ ์ˆ˜๊นŒ์ง€ ๋งŽ์ด ์ฃผ๋ฉด..๐Ÿ˜

 


 

๐Ÿค Concept

1. Stack

  • ๋ฐ์ดํ„ฐ๊ฐ€ ํ•˜๋‚˜์”ฉ ์Œ“์ด๋Š” ํ˜•ํƒœ์˜ ์ž๋ฃŒ๊ตฌ์กฐ
  • ๊ฐ€์žฅ ๋งˆ์ง€๋ง‰์— ์‚ฝ์ž…๋œ ๋ฐ์ดํ„ฐ๊ฐ€ ๊ฐ€์žฅ ๋จผ์ € ํ˜ธ์ถœ๋จ (ํ›„์ž…์„ ์ถœ, Last In First Out)
  • ๊ฐ™์€ ๊ตฌ์กฐ์™€ ํฌ๊ธฐ์˜ ๋ฐ์ดํ„ฐ๋ฅผ ์ •ํ•ด์ง„ ๋ฐฉํ–ฅ์œผ๋กœ๋งŒ ์Œ“์„ ์ˆ˜ ์žˆ์Œ
  • top์œผ๋กœ ์„ค์ •ํ•œ ๊ณณ์„ ํ†ตํ•ด์„œ๋งŒ ์ ‘๊ทผ

 

  • Stack ๊ด€๋ จ ๋ฉ”์„œ๋“œ
    • Stack ๊ฐ’ ์ถ”๊ฐ€ == stack.push(VALUE);
    • Stack ๊ฐ’ ์ œ๊ฑฐ == stack.pop();
    • Stack ์ดˆ๊ธฐํ™” == stack.clear();
    • ์ตœ์ƒ๋‹จ ๊ฐ’ ์ถœ๋ ฅ == stack.peek();
    • Stack์ด ๋น„์–ด์žˆ๋Š”์ง€ ์ฒดํฌ == stack.empty();
    • Stack์— ํŠน์ • ๊ฐ’์ด ์žˆ๋Š”์ง€ ์ฒดํฌ == stack.contains(VALUE);

 

  • Stack ๊ด€๋ จ ๊ฐœ๋…
    • stack underflow: ๋นˆ ์Šคํ…์—์„œ ๋ฐ์ดํ„ฐ ์ถ”์ถœ ์‹œ ๋ฐœ์ƒ
    • stack overflow: ์Šคํƒ์ด ๋„˜์น˜๋Š” ๊ฒฝ์šฐ ๋ฐœ์ƒ
    • ์šฉ๋ก€: ๋’ค๋กœ๊ฐ€๊ธฐ ๊ธฐ๋Šฅ, ์‹คํ–‰์ทจ์†Œ ๊ธฐ๋Šฅ ๋“ฑ

 


 

2. Queue

  • ๋ฐ์ดํ„ฐ๊ฐ€ ์ˆœ์„œ๋Œ€๋กœ ์ฒ˜๋ฆฌ๋˜๋Š” ์ž๋ฃŒ ๊ตฌ์กฐ
  • ํ•œ์ชฝ ๋์€ front (์‚ญ์ œ๋งŒ ์ˆ˜ํ–‰), ๋‹ค๋ฅธ ์ชฝ ๋์€ rear(์‚ฝ์ž…๋งŒ ์ˆ˜ํ–‰)
  • front์—์„œ ๋ฐœ์ƒํ•˜๋Š” ์‚ญ์ œ์—ฐ์‚ฐ == deQueue
  • rear์—์„œ ๋ฐœ์ƒํ•˜๋Š” ์‚ฝ์ž…์—ฐ์‚ฐ == enQueue
  • ๊ฐ€์žฅ ๋จผ์ € ์‚ฝ์ž…๋œ ๋ฐ์ดํ„ฐ๊ฐ€ ๊ฐ€์žฅ ๋จผ์ € ํ˜ธ์ถœ๋จ (์„ ์ž…์„ ์ถœ, First In First Out)
  • ์ปดํ“จํ„ฐ ๋ฒ„ํผ์—์„œ ์‚ฌ์šฉ (์ˆœ์„œ๋Œ€๋กœ ์ฒ˜๋ฆฌํ•˜๊ธฐ ์œ„ํ•จ)

 

  • Queue๊ด€๋ จ ๋ฉ”์„œ๋“œ
import java.util.LinkedList;
import java.util.Queue;

public static void main(String[] args) {
//    Queue<String> queue = new LinkedList<>()
    Queue<Integer> queue = new LinkedList<>();    
}

 

  1. Queue์— ๊ฐ’์„ ์ถ”๊ฐ€ํ•˜๋Š” ๋ฉ”์„œ๋“œ
    • queue.add(VALUE);
    • queue.offer(VALUE);
  2. Queue ๊ฐ’ ์ œ๊ฑฐ == queue.remove();
  3. Queue ์ดˆ๊ธฐํ™” == queue.clear();
  4. Queue์˜ ์ฒซ๋ฒˆ์งธ ๊ฐ’์„ ๋ฐ˜ํ™˜ ํ›„ ์ œ๊ฑฐ, ๋งŒ์•ฝ ๊ฐ’์ด ๋น„์–ด์žˆ๋‹ค๋ฉด null ๋ฐ˜ํ™˜
    • queue.poll();
  5. Queue์—์„œ ๊ฐ€์žฅ ๋จผ์ € ๋“ค์–ด๊ฐ„ ๊ฐ’ ์ถœ๋ ฅ == queue.peek();

 

  • Queue ์‚ฌ์šฉ ์˜ˆ์‹œ
    • ํ”„๋กœ์„ธ์Šค ๊ด€๋ฆฌ
    • ์บ์‹œ ๊ตฌํ˜„
    • ์ˆœ์ฐจ์ ์œผ๋กœ ์ฒ˜๋ฆฌ๊ฐ€ ํ•„์š”ํ•œ ํ”„๋กœ๊ทธ๋žจ

 

๋Œ“๊ธ€