[백준] 2525번 오븐 시계

https://www.acmicpc.net/problem/2525

문제

KOI 전자에서는 건강에 좋고 맛있는 훈제오리구이 요리를 간편하게 만드는 인공지능 오븐을 개발하려고 한다. 인공지능 오븐을 사용하는 방법은 적당한 양의 오리 훈제 재료를 인공지능 오븐에 넣으면 된다. 그러면 인공지능 오븐은 오븐구이가 끝나는 시간을 분 단위로 자동적으로 계산한다.

또한, KOI 전자의 인공지능 오븐 앞면에는 사용자에게 훈제오리구이 요리가 끝나는 시각을 알려 주는 디지털 시계가 있다.

훈제오리구이를 시작하는 시각과 오븐구이를 하는 데 필요한 시간이 분단위로 주어졌을 때, 오븐구이가 끝나는 시각을 계산하는 프로그램을 작성하시오.

입력 :

첫째 줄에는 현재 시각이 나온다. 현재 시각은 시 A (0 ≤ A ≤ 23) 와 분 B (0 ≤ B ≤ 59)가 정수로 빈칸을 사이에 두고 순서대로 주어진다. 두 번째 줄에는 요리하는 데 필요한 시간 C (0 ≤ C ≤ 1,000)가 분 단위로 주어진다.

출력 :

첫째 줄에 종료되는 시각의 시와 분을 공백을 사이에 두고 출력한다. (단, 시는 0부터 23까지의 정수, 분은 0부터 59까지의 정수이다. 디지털 시계는 23시 59분에서 1분이 지나면 0시 0분이 된다.)

나의 답안

분이 60분이 넘을 때, 60으로 나눈 몫만큼 '시' 부분을 높여주되,

'시' 부분이 24이상일 경우에는 0부터 표현해줘야 한다.

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        int c = sc.nextInt();

        System.out.println(a+(b+c)/60 > 23 ? a+(b+c)/60-24 + " " + (b+c)%60 : a+(b+c)/60 + " " + (b+c)%60);
    }
}

삼항연산자를 사용하여 작성해봤다.

짧지만 가독성은 좋지 않다.

모범 답안

import java.util.Scanner;

public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);

int A = sc.nextInt();
int B = sc.nextInt();
int C = sc.nextInt();

B += C;

A = (A + B/60)%24;
B = B%60;

System.out.println(A+" "+B);
}
}

• B에 C를 더한 값으로 B에 다시 할당함
• 나는 if문을 사용해 '시'가 24 이상일 경우 24를 빼도록 작성했지만,
  해당 답안에서는 if문 사용 없이 답을 도출할 수 있도록 작성되었다.

B에 바로 C값을 더해주는 부분과 A값을 if문 없이 표현했다는 점이 인상 깊다.

내 코드에 비해 가독성과 효율성 측면에서 더 좋은 코드라는 생각이 든다.

[백준] 2388번 곱셈

https://www.acmicpc.net/problem/2588

문제

(세 자리 수) × (세 자리 수)는 다음과 같은 과정을 통하여 이루어진다.

(1)과 (2)위치에 들어갈 세 자리 자연수가 주어질 때 (3), (4), (5), (6)위치에 들어갈 값을 구하는 프로그램을 작성하라

입력 :

첫째 줄에 (1)의 위치에 들어갈 세 자리 자연수가, 둘째 줄에 (2)의 위치에 들어갈 세자리 자연수가 주어진다.

출력 :

첫째 줄부터 넷째 줄까지 차례대로 (3), (4), (5), (6)에 들어갈 값을 출력한다.

나의 답안

일단 (6)은 그냥 A*B 해주면 되고..

100의 자리 수는 100으로 나눠주면 몫이 그것이고,

1의 자리는 A를 10으로 나눈 나머지로 하면 되겠네? 생각했다.

그리고 10의 자리가 조금 고민이었다.

그러다 결국 10으로 나누면, 100의 자리와 10의 자리만 남을 것이고, 거기에 10을 나눈 나머지가

10의 자리 수가 되겠다는 생각을 하고 코드를 작성했다.

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int A = sc.nextInt();
        int B = sc.nextInt();


        System.out.println(A*(B%10));
        System.out.println(A*((B/10)%10));
        System.out.println(A*(B/100));
        System.out.println(A*B);
    }
}

모범 답안

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
         int a = sc.nextInt();
         int b = sc.nextInt();

         int c = (b % 10) * a;
         int d = ((b % 100) / 10) * a;
         int e = (b / 100) * a;
         System.out.println(c);
         System.out.println(d);
         System.out.println(e);
         System.out.println(a * b);
    }
}

• 1의 자리 수와 100의 자리는 내 답안과 동일.
• 10의 자리는 100을 나눈 나머지에 10을 나눈 몫으로 추출

[프로그래머스] 도둑

https://school.programmers.co.kr/learn/courses/30/lessons/42897

문제

도둑이 어느 마을을 털 계획을 하고 있습니다. 이 마을의 모든 집들은 동그란 형태로 배치되어 있다.

각 집들은 서로 인접한 집들과 방범장치가 연결되어 있어 인접한 두 집을 연속으로 털면 경보가 울린다.

각 집에 있는 돈이 담긴 배열 money가 주어질 때, 도둑이 훔칠 수 있는 돈의 최댓값을 return 하는 메서드를 작성하라.

나의 답안

몇 시간을 헤맨 끝에 겨우 풀었다.

아래 코드들처럼 이것저것 시도해 보았으나 테스트케이스 및 효율성 검사에서 탈락.

첫 번째 코드(오답)

import java.util.*;

class Solution {
    public int[] solution(int[] arr, int[] query) {
        int[] dp = new int[money.length];

        dp[0] = money[0];
        dp[1] = Math.max(money[0], money[1]);

        for (int i=2; i<money.length; i++) {
            dp[i] = Math.max(money[i]+dp[i-2], dp[i-1]);
        }

        int answer = dp[dp.length-1];
        return answer;
    }
}

• n번째 집을 터는 경우와 털지 않는 경우 둘로 나누어 더 큰 값을 dp(n)의 값으로 결정하는 방법.
  집이 원형으로 배치되어 있다는 것을 망각하고 풀었다.
  따라서 맨 앞의 값과 뒤의 값을 둘 다 터는 경우가 발생하므로 오답이다.

두 번째 코드(오답)

class Solution {
    public int solution(int[] money) {
        int evenSum = 0, oddSum = 0;
        for (int i = 0; i < money.length; i++) {
            if (i % 2 == 0) {
                evenSum += money[i];
                System.out.println("evenSum :"+evenSum);
            } else {
                oddSum += money[i];
                System.out.println("oddSum :"+oddSum);
            }
        }

        if (money.length % 2 == 1) {
            evenSum -= Math.min(money[0], money[money.length - 1]);
        }

        return Math.max(evenSum, oddSum);
}

• 한 칸 건너뛰면서 더하는 거니까, 홀수 인덱스 값들의 합과 짝수 인덱스 값들의 합을 비교하면 되겠네? 생각하고 작성.
  꼭 한 칸씩만 건너뛰면서 더해야 최대가 되는 것은 아니다. 예를 들어,
  [1000, 1, 1, 1000, 2] 의 경우 2000이 최댓값이지만, 위의 코드대로 수행하면 1003이 반환될 것이다.

세 번째 코드(오답)

class Solution {
    public int solution(int[] money) {
        int[] dp1 = new int[money.length];
        int[] dp2 = new int[money.length];

        dp1[0] = money[0];
        dp1[1] = Math.max(money[0], money[1]);
        dp2[money.length-1] = money [money.length-1];
        dp2[money.length-2] = Math.max(money[0], money[1]);

        int idx2 = money.length-3;
        for (int i=2; i<money.length-1; i++) {
            dp1[i] = Math.max(money[i]+dp![i-2], dp1[i-1]);
            dp2[idx2] = Math.max(money[idx2]+dp2[idx_r+2], dp2[idx_r+1]);
            
            idx2--;
        }

        return Math.max(dp1[money.length-2], dp2[1]);
}

• 맨 앞과 뒤를 연속해서 털지 않도록  dp1과 dp2로 나누어
  dp1은 앞에서부터 n-1번째 값까지, dp2는 n번째 값부터 2번째 값까지 최댓값을 구하는 코드를 작성했다.
  이건 사실 왜 오답인지 아직도 모르겠다. 예외 케이스가 무엇인지 알려주실 선배님들 부탁드립니다..

모범 답안

1. 원형으로 되어있으므로 맨 앞집을 터는 경우와 털지 않는 경우로 나누어 dp1, dp2로 각각 분류
2. dp1에서는 맨 앞집부터 맨 끝집 직전 집까지 털 경우의 최대값을 구함
3. dp2에서는 두 번째 집부터 맨 끝집까지 털 경우의 최대값을 구함
4. dp1, dp2 중 최대값을 반환

class Solution {
    public int solution(int[] money) {
        int[] dp1 = new int[money.length];
        int[] dp2 = new int[money.length];

        dp1[0] = money[0];
        dp1[1] = Math.max(money[0], money[1]);
        dp2[0] = money[1];
        dp2[1] = Math.max(money[1], money[2]);

        for (int i = 2; i < money.length - 1; i++) {
            dp1[i] = Math.max(money[i] + dp1[i - 2], dp1[i - 1]);
            dp2[i] = Math.max(money[i+1] + dp2[i - 2], dp2[i - 1]);
        }

        return Math.max(dp1[money.length - 2], dp2[money.length - 2]);
    }
}

저녁시간 내내 이것만 고민하다가 끝났지만, 어느 정도 모범답안에 가까운 답을 도출해서 아주 뿌듯했다..

점점 발전하고 있는 것이 보인다!

[프로그래머스] 배열 조각하기

https://school.programmers.co.kr/learn/courses/30/lessons/181893

문제

정수 배열 arr와 query가 주어지며, query를 순회하면서 다음 작업을 반복한다.

• 짝수 인덱스에서는 arr에서 query[i]번 인덱스를 제외하고 배열의 query[i]번 인덱스 뒷부분을 잘라서 버림
• 홀수 인덱스에서는 arr에서 query[i]번 인덱스는 제외하고 배열의 query[i]번 인덱스 앞부분을 잘라서 버림

위 작업을 마친 후 남은 arr의 부분 배열을 return 하는 solution 함수를 완성하라

나의 답안

나는 문제에서 말하는 알고리즘대로 remove 메서드를 이용하여

짝수 인덱스에서는 뒷부분을 자르고,

홀수 인덱스에서는 앞부분을 잘라내고

배열로 변환하도록 코드를 작성했다.

import java.util.*;

class Solution {
    public int[] solution(int[] arr, int[] query) {
        ArrayList <Integer> list = new ArrayList<>();

        for(int i=0; i<arr.length; i++)
            list.add(arr[i]);

        for(int i=0; i<query.length; i++) {
            if(i%2 == 0) {
                int size = list.size() - query[i]-1;
                for(int j=0; j<size; j++)
                    list.remove(query[i]+1);
            }
            else {
                for(int j=0; j<query[i]; j++)
                    list.remove(0);
            }
        }

        int[] answer = new int [list.size()];
        for(int i=0; i<list.size(); i++)
            answer[i] = list.get(i);
        return answer;
    }
}

모범 답안

1. 실제로 배열 내 값을 제거하는 과정을 생략
2. start, end 변수를 이용하여 최종적으로 불러올 인덱스 범위를 조절
3. copyOfRange변수를 사용하여 변수 불러옴

import java.util.*;

class Solution {
    public int[] solution(int[] arr, int[] query) {
        int start = 0;
        int end = arr.length - 1;
        for (int i = 0; i < query.length; i++) {
            if (i % 2 == 0) {
                end = start + query[i] - 1;
            } else {
                start += query[i];
            }
        }

        return Arrays.copyOfRange(arr, start, end + 2);
    }
}

시작점과 끝점만 조정해가며 값을 불러올 수 있다는 생각을 못했다.

순진하게(?) 문제에서 얘기하는 대로 코드를 짰는데,

훨씬 효율적인 처리가 가능한 방법이 있었다.

더 효율적인 방법이 있다는 것을 항상 생각하자!

복습

Arrays.copyOfRange(arr, 시작인덱스, 끝인덱스):

arr배열의 시작인덱스부터 끝인덱스(미포함)의 앞까지 복사하여 반환

배열(Arrays 클래스) 주요 메서드

• toString(배열) : 배열을 문자열로 변한
  
      int[] arr = {1, 2, 3, 4, 5};
      String arrString = Arrays.toString(arr);
      System.out.println(arrString); // 출력: [1, 2, 3, 4, 5]
  
  
  
• sort(배열) : 해당 배열을 오름차순 정렬
  
       int[] arr = {3, 1, 4, 2, 5};
       Arrays.sort(arr);
       System.out.println(Arrays.toString(arr)); // 출력: [1, 2, 3, 4, 5]
  
  
  
• copyOf(배열, 길이): 배열을 0번째 인덱스부터 지정된 길이만큼 복사하여 반환
  
       int[] arr = {1, 2, 3, 4, 5};
       int[] copyArr = Arrays.copyOf(arr, 3);
       System.out.println(Arrays.toString(copyArr)); // 출력: [1, 2, 3]
  
  
• copyOfRange(배열, 시작인덱스, 끝인덱스): 배열의 시작인덱스부터 끝인덱스(미포함)를 복사하여 반환
  
       int[] arr = {1, 2, 3, 4, 5};
       int[] copyArr = Arrays.copyOfRange(arr, 2, 5);
       System.out.println(Arrays.toString(copyArr)); // 출력: [3, 4, 5]
  
  
  
• equals(): 두 배열의 길이와 요소가 모두 같은 경우에만 true 반환
  
       int[] arr1 = {1, 2, 3};
       int[] arr2 = {1, 2, 3};
       boolean isEqual = Arrays.equals(arr1, arr2);
       System.out.println("Arrays are equal: " + isEqual); // 출력: Arrays are equal: true
  
  
  
• deepEquals(): 다차원 배열에서 두 요소가 모두 동일한 경우에만 ture 반환
  
       int[][] arr1 = {{1, 2}, {3, 4}};
       int[][] arr2 = {{1, 2}, {3, 4}};
       boolean isEqual = Arrays.deepEquals(arr1, arr2);
       System.out.println("Arrays are equal: " + isEqual); // 출력: Arrays are equal: true

배열 ▶ 리스트

⊙ Arrays.asList() 사용

import java.util.Arrays;
import java.util.List;

public class ArrayToListExample {
    public static void main(String[] args) {
        // 배열 정의
        Integer[] myArray = {1, 2, 3, 4, 5};

        // 리스트로 변환
        List<Integer> myList = Arrays.asList(myArray);

        System.out.println(myList);  // 출력: [1, 2, 3, 4, 5]
    }
}

⊙ int[] 배열을 Integer리스트로 변환할 경우 type이 맞지 않아 원하는 변환을 할 수 없다.

    이 경우에는 반복문을 통해 일일이 값을 넣어주거나 Stream을 사용해야 한다.

    1) 반복문 사용

        // int 배열 정의
        int[] intArray = {1, 2, 3, 4, 5};

        // Integer 리스트로 변환
        List integerList = new ArrayList<>();
        for (int num : intArray) {
            integerList.add(num);  // 박싱(boxing)
        }

        System.out.println(integerList);  // 출력: [1, 2, 3, 4, 5]

    2) Stream 사용

        // int 배열 정의
        int[] intArray = {1, 2, 3, 4, 5};

        // Integer 리스트로 변환
        List<Integer> integerList = Arrays.stream(intArray)  // int 배열을 스트림으로 변환
                                          .boxed()          // int를 Integer로 박싱(boxing)
                                          .collect(Collectors.toList());  // 리스트로 수집

        System.out.println(integerList);  // 출력: [1, 2, 3, 4, 5]

리스트 ▶ 배열

⊙ toArray() 사용

       // 리스트 정의
        List<Integer> myList = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));

        // 배열로 변환
        Integer[] myArray = myList.toArray(new Integer[0]);

        for (Integer num : myArray) {
            System.print(num + " ");  // 출력: 1 2 3 4 5
        }

StringBuilder 특징

• 변수 선언 시 객체를 생성하며, 문자열을 자주 수정할 때 사용
• String과 다르게 가변적인 속성을 가져 문자열 수정이 빠르고 효율적임
• 단, 멀티스레드 환경에서는 안전하지 않음
• 크기를 지정하지 않고 객체 생성 시 초기 용량은 16으로 설정됨

        String str = "";
        StringBuilder sb = new StringBuilder();

        str = str + "a";
        str = str + "b";
        str = str + "c";    // String은 불변 : 문자열 수정할 때마다 새로운 문자열 객체 생성 >> 메모리 부담

        sb.append("a");
        sb.append("b");
        sb.append("c");    // StringBuilder은 가변 : 문자열 수정 시 기존 객체를 수정 >> 메모리 사용 효율적

StringBuilder 주요 메서드

• append(문자열) : 문자열 추가
  
       StringBuilder sb = new StringBuilder();
       sb.append("Hello");
       sb.append(" ");
       sb.append("world");
       String result = sb.toString();      // result = "Hello world"
  
  
  
• insert(인덱스, 문자열) :지정한 위치에 문자열 삽입
  
       StringBuilder sb = new StringBuilder("Hello");
       sb.insert(5, " world");       // " world"를 인덱스 5에 삽입
       String result = sb.toString(); // result = "Hello world"
  
  
  
• deleteCharAt(인덱스): 지정된 인덱스의 문자 삭제
  
       StringBuilder sb = new StringBuilder("Hello world");
       sb.deleteCharAt(5);       // ' ' 문자 삭제
       String result = sb.toString();      // result = "Helloworld"
  
  
  
• replace(시작인덱스, 끝인덱스, 문자열): 시작위치부터 끝 이전까지의 문자열을 대체
  
       StringBuilder sb = new StringBuilder("Hello world");
       sb.replace(6, 11, "Java");       // 인덱스 6부터 11 이전까지의 문자열을 "Java"로 대체
       String result = sb.toString();      // result = "Hello Java"
  
  
  
• reverse(): 문자열을 역순으로 뒤집음
  
       StringBuilder sb = new StringBuilder("Hello");
       sb.reverse();      // 문자열을 역순으로 변경
       String result = sb.toString();       // result = "olleH"
  
  
  
• length(): 현재 StringBuilder의 길이를 반환
  
       StringBuilder sb = new StringBuilder("Hello world");
       sb.replace(6, 11, "Java");      // 인덱스 6부터 11 이전까지의 문자열을 "Java"로 대체
       String result = sb.toString();      // result = "Hello Java"
  
  
  
• indexOf(문자열): 지정된 문자열이 처음으로 등장하는 인덱스 반환
  
       StringBuilder sb = new StringBuilder("Hello world");
       int index = sb.indexOf("world");       // index = 6
  
  

아스키코드(ASCII)

• American Standard Code for Information Interchange
• 미국에서 표준호한 정보교환용 7비트 부호체계
• 우리가 사용하는 대부분의 기호들이 할당되어 있음
• 어느 시스템이든 적용 가능

유니코드(Unicode)

• 전 세계 모든 문자를 다루도록 설계된 표준 문자 전산 처리 방식
• 대부분의 문자 포함, 악보기호, 이모지 등의 기호까지 포함
• 해당 글자의 코드 표기 시 U+(16진수 숫자) 로 씀
• 한글에서 Ctrl+f10 눌렀을 때 '유니코드 문자표' 가 있음

※  인코딩

유니코드를 저장, 표현하는 방식.

A라는 글자는 유니코드로 65에 배당되어 있는데,

이것을 효율적으로 혹은 특정 목적에 따라 거꾸로 표현하거나 8자릿수로 표현하는 등

해당 글자를 표현하는 방식에 따라 인코딩 종류가 달라진다.

배열 ▶ 문자열

문자열(String) 배열 ▶ 문자열

  1. toString() 메서드 사용

        String[] arr = {"Hello", " ", "Java", " ", "study"};
        String arrToStr  = Arrays.toString(arr);

        System.out.println(arrToStr);
        // 출력: [Hello,  , Java,  , study]

  2. join() 메서드 사용

        String[] arr = {"Hello", " ", "Java", " ", "study"};
        String arrToStr = String.join("",arr);

        System.out.println(arrToStr);
        // 출력: Hello Java study

문자(char) 배열 ▶ 문자열

  1. String.valueOf() 메서드 사용

        char[] charArr = {'H', 'e', 'l', 'l', 'o'};
        String arrToStr = String.valueOf(charArr);

        System.out.println(arrToStr);
        // 출력: Hello

  2. new String()

        char[] charArr = {'H', 'e', 'l', 'l', 'o'};
        String arrToStr = new String(charArr);

        System.out.println(arrToStr);
        // 출력: Hello

배열 ▶ 문자열

1. toCharArray() 메서드 사용: 문자열(String) 배열을 문자(char)배열로 변환함

        String str = "developer";
        char[] strToArr = str.toCharArray();    // 문자 배열(char[])

        System.out.println(Arrays.toString(strToArr));   // 배열 출력 시 내용을 보기 위해 Arrays.toString() 사용
        // 출력: [d, e, v, e, l, o, p, e, r]

2. split(구분자) 메서드 사용: 문자열을 지정한 구분자 (쉼표, 따옴표 등)를 기준으로 나누어 배열에 담음

        String str = "apple,banana,grape";
        String[] strToArr = str.split(",");    // 문자열 배열(String[])

        System.out.println(Arrays.toString(strToArr));
        // 출력: [apple, banana, grape]

Scanner 클래스

• 사용자 입력을 받을 때, 보다 간편하게 받을 수 있도록 제공된 클래스
• java.util 패키지에 포함되어 있어 import java.util.Scanner 필요
• 토큰 기준으로 데이터를 입력받음

※ 토큰(Token) : 한 단어, 탭, 개행 등으로 구분되는 하나의 덩어리

스캐너 클래스 사용

▶ 임포트하기

▶  Scanner 객체 및 입력변수 생성

▶  메서드 이용하여 입력받기

    import java.util.Scanner; 

    System.out.print("문자열을 입력하세요 :");
    Scanner sc = new Scanner(System.in);
    System.out.print("입력한 문자열 : " + sc);
         // 출력 : 문자열을 입력하세요 : Geun
                      입력한 문자열 : Geun

스캐너 메서드 종류

• next()  : String을 읽으며, 토큰 기준으로 읽음
• nextLine() : 한 줄을 읽음. 개행(\n) 이전까지만 읽어들임
  
  
• nextInt() : int를 읽음
  
  
• nextBoolean() : boolean을 읽음
  
  
• nextByte() : byte타입으로 읽음
  
  
• nextShort() : Short타입으로 읽음
  
  
• nextLong() : Long타입으로 읽음
  
  
• nextFloat() : Float 타입으로 읽음
  
  
• nextDouble() : Double 타입으로 읽음
  
  
• hasNext() : 입력이 들어올 때까지 기다렸다가 입력 시 true 반환, 강제 종료 시 false 반환
  
  
• hasNextLine() : 다음 입력받을 Line이 있는지 확인

Scanner sc = new Scanner(System.in);

                byte a = sc.nextByte();       
                short b = sc.nextShort();    
                int c = sc.nextInt();        
                long d = sc.nextLong();    
                float e = sc.nextFloat();     
                double f = sc.nextDouble();   
                boolean g = sc.nextBoolean(); 
                String h = sc.next();    
                String i = sc.nextLine();  

                //출력문
                System.out.println(a);
                System.out.println(b);
                System.out.println(c);
                System.out.println(d);
                System.out.println(e);
                System.out.println(f);
                System.out.println(g);
                System.out.println(h);
                System.out.println(i);