더 좋은 문제 풀이가 있거나 궁금하신 점이 있다면 편하게 댓글 남겨주세요!

📝 문제

전화번호 목록

🤷‍♂️ 접근 방법

String을 활용한 방법1과 HashSet을 활용한 방법2을 비교해보겠습니다.

[String을 사용한 방법1] 메모리: 113 MB, 시간: 346.65 ms [HashSet을 사용한 방법2] 메모리: 138 MB, 시간: 212.58 ms

위를 통해 HashSet의 성능이 String을 사용한 것보다 좋다는 것을 알 수 있었습니다. 저는 추가적으로 HashMap을 사용한 방식과도 비교를 해보았습니다. 처음에는 HashMap이 value 부분을 추가적으로 사용하여 HashSet 보다 성능이 좋지 않을 것이라고 생각했습니다. 그러나 더 찾아보니 HashSet이 객체 자체를 저장하고 내부적으로 HashMap을 사용하기 때문에 HashMap이 HashSet보다 속도가 더 빠르다는 사실을 알게 되었습니다. HashMap vs HashSet 비교 참고자료1 참고자료2

다음으로는 문제에 사용된 startsWith() 메소드와 함께 java의 String 관련 함수를 정리해보겠습니다.

📌 String startsWith()

boolean startsWith(String prefix)

• java의 String 함수 중 startsWith()는 해당 문자열이 특정 문자열로 시작하는지 확인하는 함수입니다.
• 해당 문자열로 시작되는지의 여부를 true/false 값으로 반환합니다.
• 단, 공백도 확인하기 때문에 해당 부분은 주의가 필요합니다.

  String str1 = "자바 스프링";
  System.out.println(str1.startsWith("자바")); //true
  

String str2 = " 자바 스프링"; System.out.println(str2.startsWith("자바")); //false

<br>

### 📌 String endsWith()

>boolean endsWith(String suffix)

- java의 String 함수 중 endsWith()는 해당 문자열이 특정 문자열로 끝나는지 확인하는 함수입니다.
- 해당 문자열로 반환되는지의 여부를 true/false 값으로 반환합니다.
- startsWith() 와 마찬가지로 공백을 확인함으로 주의가 필요합니다.

```java
String str3 = "자바 스프링";
System.out.println(str3.endsWith("스프링")); //true

String str4 = "자바 스프링 ";
System.out.println(str4.endsWith("스프링")); //false

📌 String contains()

startsWith()와 endsWith()와 비슷하게 특정 문자열을 확인하는 함수가 있습니다. 바로 contains인데요. 이번에 함께 사용법을 정리해보겠습니다.

boolean contains(CharSequence s)

• 대상 문자열에 특정 문자열이 포함되어 있는지 확인하는 함수입니다.
• 대소문자를 구분합니다.

String str5 = "자바 스프링";
System.out.println(str5.contains("스프링")); //true

📌 String substring()

String substring(int index) String substring(int startIndex, int endIndex)

• 문자열을 특정 부분을 잘라내는 함수입니다.
• int index 위치의 문자를 포함한 문자열을 반환합니다.
• int startIndex는 포함, int endIndex는 미포함입니다.

String str6 = "012345";
System.out.println(str6.substring(3)); //345

String str7 = "자바배우기";
System.out.println(str7.substring(2)) //배우기

             //01234
String str8 = "Hello";
System.out.println(str7.substring(2,4)) // ll

✍ 풀이

방법1 String

import java.util.Arrays;

class Solution {
    public boolean solution(String[] phone_book) {
        boolean answer = true;

        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 answer;
    }
}

방법2 HashSet

import java.util.HashSet;

class Solution {
    public boolean solution(String[] phone_book) {

        HashSet<String> set = new HashSet<>();

        for(String num : phone_book){
            set.add(num);
        }

        for(int i =0; i< set.size(); i++){
            for(int j=0; j<phone_book[i].length(); j++){
                if(set.contains(phone_book[i].substring(0,j))) return false;
            }
        }

        return true;

    }
}

방법3 HashMap

import java.util.HashMap;

class Solution {
    public boolean solution(String[] phone_book) {

        HashMap<String, Integer> map = new HashMap<>();

        for(int i = 0; i < phone_book.length; i++) {
            map.put(phone_book[i], i);
        }

        for(int i =0; i< map.size(); i++){
            for(int j=0; j<phone_book[i].length(); j++){
                if(map.containsKey(phone_book[i].substring(0,j))) return false;
            }
        }

        return true;

    }
}

Reference

• HashSet 주요 메소드 정리 https://kadosholy.tistory.com/119

더 좋은 문제 풀이가 있거나 궁금하신 점이 있다면 편하게 댓글 남겨주세요!

📝 문제

완주하지 못한 선수

🤷‍♂️ 접근 방법

문제를 처음보고 저는 배열을 정렬하여 문제를 해결했습니다. 그러나 HahsMap을 사용하니 속도적인 측면에서 아래와 같은 큰 차이가 났습니다.

배열로 문제를 풀었을 때 300ms HashMap으로 문제를 풀었을 때 72ms

하여 이번 글은 HashMap을 사용법을 익히고자 작성하였습니다.

📌 HashMap getOrDefault

    getOrDefault(Object key, V DefaultValue)

HahsMap.getOrDefault() 메소드는 해당 key가 존재할 경우 key의 value 값을 반환하지만, key 가 존재하지 않을 경우 DefaultValue를 반환합니다.

본 코드에서 위의 메소드를 사용한 이유는 중복된 이름이 있을 경우를 처리하기 위함이었습니다.

        HashMap<String, Integer> map = new HashMap<>();

        for(String key : participant) map.put(key, map.getOrDefault(key,0) +1);

put을 통해 key와 value 값을 입력할 때, 기존에 key 값이 존재한다면 value를 새로운 값으로 update 합니다. 그러나 map.getOrDefault(key,0) +1 를 사용한다면 기존에 값이 있다면 기존값+1을, 없다면 0+1을 할 것입니다. 하여 이미 중복된 key 값이 있다면 해당 value는 2가 됩니다.

✍ 풀이

방법1 Arrays

import java.util.Arrays;

class Solution {
    public String solution(String[] participant, String[] completion) {
        String answer = "";

        Arrays.sort(participant);
        Arrays.sort(completion);

        for(int i = 0; i< participant.length; i++){
            if(i == completion.length) return participant[i];

            if(!participant[i].equals(completion[i])){
                return participant[i];
            }
        }

        return "";
    }
}

방법2 HashMap

import java.util.HashMap;

class Solution {
    public String solution(String[] participant, String[] completion) {
        String answer = "";

        HashMap<String, Integer> map = new HashMap<>();

        for(String key : participant) map.put(key, map.getOrDefault(key,0) +1);
        for(String key : completion) map.put(key, map.get(key)-1);

        for(String key : map.keySet()){
            if(map.get(key) != 0) {
                answer = key; 
                break;
            }
        }

        return answer;
    }
}

Reference

• HashMap 주요 메소드 정리 https://gre-eny.tistory.com/97

더 좋은 문제 풀이가 있거나 궁금하신 점이 있다면 편하게 댓글 남겨주세요!

📝 문제

11651번 좌표 정렬하기2

🤷‍♂️ 접근 방법

지난 문제인 [백준/JAVA] 정렬 - 11651번 좌표 정렬하기2 와 같은 방식의 문제입니다. 이전 문제와 다른 점이 있다면 y값을 기준으로 오름차순으로 정렬하고, y값이 같다면 x값을 기준으로 오름차순 정렬한다는 것입니다. 그러므로 x와 y의 입력 값만 바꿔주면 되겠습니다.

✍ 풀이

import java.util.Scanner;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);

        int N = in.nextInt();

        int[][] arr = new int[N][2];

        for(int i = 0; i < N; i++) {
            // 변경
            arr[i][1] = in.nextInt(); //x
            arr[i][0] = in.nextInt(); //y
        }

        Arrays.sort(arr, (e1, e2) -> {
            if(e1[0] == e2[0]) {
                return e1[1] - e2[1];
            } else {
                return e1[0] - e2[0];
            }
        });

        for(int i = 0; i < N; i++) {
            // 변경
            System.out.println(arr[i][1] + " " + arr[i][0]);
        }
    }
}

더 좋은 문제 풀이가 있거나 궁금하신 점이 있다면 편하게 댓글 남겨주세요!

📝 문제

11650번 좌표 정렬하기

🤷‍♂️ 접근 방법

문제를 보자마자 2차원 배열을 정렬하면 되겠다 라는 생각이 들었습니다. 그러나 기존에 사용하던 Arrays.sort 로는 2차원 배열을 정렬할 수 없습니다. 그래서 여러 검색을 통해 Arrays.sort을 오버라이드 해야 한다는 사실을 알았고 아래의 내용부터는 제가 이해한 내용을 바탕으로 정리해보겠습니다.

📌 Arrays.sort로 2차원 배열 정렬

Array.sort의 자바 API를 보면 위의 그림과 같습니다. 먼저 첫번째 매개변수로 객체 배열 T[] a 가 있습니다. T 는 제너릭 타입으로 모든 타입이 다 올 수 있다는 뜻이고 a는 배열의 이름입니다. 이번 문제에서는 2차원 배열을 사용할 것이니 T[]는 2차원 배열 int[][]을 의미하게 될 것입니다.

다음으로 두번째 매개변수로 Comparator<? super T> c 이 있습니다. Comparator는 정렬 시, 우선순위를 정하는 부분으로 우선순위에 따라 두 매개변수 객체를 비교합니다. 이 부분을 오버라딩하면 y좌표를 오름차순으로 정렬할 수 있겠습니다.

아래의 코드는 compare 함수를 오버라이딩 한 코드입니다. Arrays.sort()함수 내부에서는 정렬을 위해 두 매개변수를 비교할 때 어떤 변수가 우선순위가 높은지 compare() 함수를 통해 판별하고 위치를 바꿀 것입니다.

    Arrays.sort(arr, new Comparator<int[]>() {
        @Override
        public int compare(int[] o1, int[] o2) {
            if(o1[0] == o2[0]) return o1[1] - o2[1];
            else return o1[0] - o2[0];

        }
    });

✍ 풀이

import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        int N = sc.nextInt();

        int arr[][] = new int [N][2];

        //x,y 좌표 입력
        for(int i=0; i< N; i++){

            arr[i][0] = sc.nextInt(); //x
            arr[i][1] = sc.nextInt(); //y
        }

        //정렬
        Arrays.sort(arr, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                if(o1[0] == o2[0]) return o1[1] - o2[1];
                else return o1[0] - o2[0];

            }
        });


        //출력
        for(int i = 0 ; i< N; i++){
            System.out.println(arr[i][0] + " " + arr[i][1]);
        }


    }
}

더 좋은 문제 풀이가 있거나 궁금하신 점이 있다면 편하게 댓글 남겨주세요!

📝 문제

1427번 소트인사이드

🤷‍♂️ 접근 방법

이번 문제는 지난 [백준/JAVA] 정렬 - 25305번 커트라인 에서 배운 Collections.reverseOrder() 를 사용하여 내림차순으로 배열을 정렬하는 문제와 같습니다. 먼저 정수를 입력 받고, 이를 String으로 변환하여 배열의 값으로 한 글자씩 넣어줍니다. 마지막으로 배열을 내림차순으로 정렬하면 문제가 해결 가능합니다.

다른 사이트를 참고해 살펴본 결과, 또 다른 방법으로는 toCharArray() 메소드로 하나의 문자열을 각 자리의 문자(아스키값)으로 변환하여 char[] 배열을 만드는 방법이 있었습니다. 이 방법은 정말 간단하게 문제를 해결할 수 있기에 아래의 문제 풀이에 방법 2로 정리했으니 꼭 참고해 보시는 것이 좋겠습니다.

📌 str.charAt()

str.charAt(int index) 메서드는 String로 저장된 문자열 중 index의 위치에 있는 한 글자를 char 타입으로 반환합니다. 그렇기 때문에 charAt을 통해 반환된 값을 int 형으로 변환하여 계산식에 사용하고자 하면 아래와 같은 문제가 발생합니다.

String str = "12345";

str.charAt(0);    // 1
str.charAt(1);    // 2

(int) str.charAt(0) + (int) str.charAt(1);    // 49 + 50 = 99

str.charAt(0)에서 charAt을 통해 추출한 값은 char 형인 '1' 입니다. 즉, char 형인 '1'을 int로 변환시키면 아스키 코드 값 49이 되고, str.charAt(1)를 통해 char 형인 '2'을 int로 변환시키면 아스키 코드값 50가 되기 때문에 (int) str.charAt(0) + (int) str.charAt(1); 값으로 99가 출력되는 것입니다.

'0'(char) -> 48 '1'(char) -> 49 '2'(char) -> 50 '3'(char) -> 51 '4'(char) -> 52

이를 해결하기 위해서는 charAt(int i) - '0' 을 통해 char형의 문자를 int형으로 변환시켜야 합니다.

48 - '0'(48) = 0 49 - '0'(48) = 1 50 - '0'(48) = 2 51 - '0'(48) = 3 52 - '0'(48) = 4

CharAt(int i) - '0'을 통해 char형의 문자들을 int형으로 변환시킬 수 있습니다.

📌 valueOf()를 통한 객체 형변환

먼저 valueOf를 살펴보기 전에 Primitive Type 과 Wrapper Class에 대해 알아보도록 하겠습니다. Wrapper Class는 Primitive Type을 객체화한 것으로 아래의 표와 같이 표현합니다.

원시 데이터 타입(Primitive type)을 클래스로 나타낸 Wrapper클래스는 모두 valueOf() 메서드를 가지고 있습니다. valueOf()메서드의 경우 입력 받은 값을 valueOf() 메서드를 호출한 클래스의 객체로 반환하는 역할을 합니다. 아래의 예를 통해 살펴보도록 하겠습니다.

    Integer a =Integer.valueOf(9);        // int 타입을 Wrapper클래스의 Integer 객체로 변환
    Double b = Double.valueOf(5);        // int 타입을 Double 객체로 변환
    Float c = Float.valueOf("80");        // String 타입을 Float 객체로 변환
    String d = String.valueOf(100.0)    // dobule 타입을 String 객체로 변환     

Integer.parseInt() vs Integer.valueOf

Integer.parseInt() vs Integer.valueOf를 비교해보며 더 자세히 알아보겠습니다. 아래의 코드와 같이 int number1, number2에 담긴 값은 같지만 둘의 자료형이 다른 것을 알 수 있습니다. 둘은 무엇이 다를까요?

int number1 = Integer.valueOf("100"); //100
int number2 = Integer.parseInt("100"); //100

Integer.parseInt()의 경우 기본타입을 int 타입(Primitive type)으로 변환합니다. Integer.valueOf()의 경우 기본타입을 Wrapper클래스인 Integer 객체로 변환합니다.

📌String.toCharArray()

String.toCharArray()를 사용하면 문자열을 한 글자씩 분리하여 char타입의 배열로 생성할 수 있습니다. 단, 문자열의 공백 또한 인덱스에 포함되니 주의가 필요합니다.

    String str = "hello";

    char[] arr = str.toCharArray(); // ['h', 'e', 'l', 'l', 'o']

✍ 풀이

방법 1

import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        int N = sc.nextInt();

        String str = Integer.toString(N);

        Integer []arr = new Integer[str.length()];

        for(int i=0; i< arr.length; i++){
            arr[i] = Integer.valueOf(str.charAt(i) - '0');
        }

        //내림차순 정렬
        Arrays.sort(arr, Collections.reverseOrder());

        for(int i =0; i< arr.length; i++){
            System.out.print(arr[i]);
        }
    }
}

방법 2

import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        char[] arr = sc.nextLine().toCharArray();

        Arrays.sort(arr);

        for (int i = arr.length - 1; i >= 0; i--) {
            System.out.print(arr[i]);
        }
    }
}

Reference

• http://kwseo.github.io/2015/10/18/value-of/

• https://st-lab.tistory.com/109?category=857114

더 좋은 문제 풀이가 있거나 궁금하신 점이 있다면 편하게 댓글 남겨주세요!

📝 문제

25305번 커트라인

🤷‍♂️ 접근 방법

커트라인을 구하는 문제로 N개의 점수를 입력 받고 이를 정렬하여 K번째 점수를 출력하는 되는 문제입니다. 이번 문제를 통해 내림차순으로 배열을 정렬하는 법을 알아보겠습니다.

📌 배열 내림차순 정렬 Collections.reverseOrder()

오름 차순 정렬의 경우 Arrays.sort(int arr[]) 을 통해 오름 차순으로 정렬할 수 있습니다. 반대로 내림차순으로 정렬하기 위해서는 Collections의 도움을 받아 아래와 같이 Collections.reverseOrder() 를 인자로 추가해 주면 됩니다.

그러나, 아래와 같이 코드를 작성하면 컴파일 오류가 발생합니다.

    int arr[] = new int[N];

    Arrays.sort(arr, Collections.reverseOrder());

그 이유는 Arrays.sort의 경우 아래와 같은 형식을 사용하기 때문입니다. T는 Generic Class로 모든 객체를 허용하지만, int는 기본형 타입으로(Primitive type) Collections에서 사용하는 객체(Reference type)가 아닙니다. (primitive type과 reference type 차이)

    public static <T> void sort(T[] a,  Comparator <? super T> c)

하여 객체 타입인 Integer 타입으로 배열을 선언해 주어야 합니다.

    Integer arr[] = new Integer[N];

다음으로는 코드에 적용시켜보겠습니다. 먼저 배열을 선언하여 N명의 점수를 입력받고, 내림차순으로 정렬해보겠습니다.

    Integer arr[] = new Integer[N];

    for(int i = 0; i< N; i++){
        arr[i] = sc.nextInt();
    }

    //내림차순 정렬 
    Arrays.sort(arr, Collections.reverseOrder());

✍ 풀이

import java.util.Arrays;

import java.util.Collections;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        int N = sc.nextInt();
        int k = sc.nextInt();

        //방법 1 내림차순 정렬
        Integer arr[] = new Integer[N];

        for(int i = 0; i< N; i++){
            arr[i] = sc.nextInt();
        }

        Arrays.sort(arr,Collections.reverseOrder());

        System.out.println(arr[k-1]);


        //방법2 오름차순 정렬
        int arr2[] = new int[N];

        for(int i = 0; i< N; i++){
            arr2[i] = sc.nextInt();
        }

        Arrays.sort(arr2);

        System.out.println(arr2[N-k]);


    }
}

Reference

• Collections.reverseOrder()
• primitive type과 reference type 차이

더 좋은 문제 풀이가 있거나 궁금하신 점이 있다면 편하게 댓글 남겨주세요!

📝 문제

4948번 베르트랑 공준

🤷‍♂️ 접근 방법

지난 시간에 포스팅한 소수 판별법과 같은 문제입니다! [백준/JAVA] 기본 수학2 - 1929번 소수구하기 를 참조하여 볷

✍ 풀이

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        while (true) {
            int n = sc.nextInt();
            int cnt = 0;
            if(n == 0) break;

            boolean check[] = new boolean[2*n +1]; // 0 ~ 2n

            //false 가 소수 true 가 소수가 아닌 수
            check[0] = true;
            check[1] = true;

            //에라토스테네스의 체
            for (int i = 2; i <= Math.sqrt(check.length); i++) {
                //이미 체크한 것이라면
                if(check[i] == true) continue;

                for( int j = i * i; j< check.length; j = j+i){
                    check[j] = true;
                }

            }

            //n보다 크고, 2n보다 작거나 같은 소수
            for(int i = n+1; i< check.length; i++){
                if(check[i] == false) cnt++;
            }
            System.out.println(cnt);

        }

    }
}

더 좋은 문제 풀이가 있거나 궁금하신 점이 있다면 편하게 댓글 남겨주세요!

📝 문제

1929번 소수구하기

🤷‍♂️ 접근 방법

저는 처음 문제를 풀 때, 시간 제한이 있는 줄 모르고 2부터 해당 수까지 전부 반복하다 시간 초과가 발생하였습니다. 아래의 방법의 두가지 방법을 통해 시간 복잡도를 줄이며 문제를 풀어보겠습니다.

📌 N이 소수인지 판별 - 시간복잡도 O(√N)

먼저 시간복잡도가 O(√N)인 방법으로 숫자 N이 소수인지를 판별해 보겠습니다.

    for (int j = 2; j <= Math.sqrt(i); j++) {
        if (i % j == 0) {
            check = true;
            break;
        }

    }

예를 들어 숫자 20까지의 소수를 판별한다고 하면 √20 =4.47213xx 이고, 20 의 약수는 (1,20), (2,10), (4,5), (5,4), (10,2), (20,1) 입니다.

📌 N 이하의 모든 수 소수 판별(에라토스테네스의 체) - 시간복잡도 O(Nlog(log N))

또 다른 방법으로는 여러 수를 소수인지 아닌지 판별하는 에라토스테네스의 체가 있습니다. 에라토스테네스의 체는 N 이하의 모든 소수를 판별하는 알고리즘으로, N의 루트를 씌운 값의 배수까지만 확인하면 되는 방법입니다.

위의 그림에서 알 수 있듯이 알고리즘은 다음과 같습니다.

1. 2부터 N까지의 모든 자연수를 나열한다.
2. 아직 처리하지 않은 가장 작은 수 i를 찾고 i의 배수를 제거한다.
3. i가 √N까지 2번의 과정을 반복한다.
4. 위 과정을 통해 남겨진 값들은 소수이다.

에라토스테네스의 체 소수 구하는 알고리즘 - 에라토스테네스의 체

✍ 풀이

📌 √N 사용법 - 시간복잡도 O(√N)

//시간복잡도 O(√N)
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        int M = sc.nextInt();
        int N = sc.nextInt();

        for(int i =M; i <=N; i++){
            boolean check = false;

            if( i == 1 ) continue;
            else if( i == 2 ) System.out.println(2);
            else {
                for (int j = 2; j <= Math.sqrt(i); j++) {
                    if (i % j == 0) {
                        check = true;
                        break;
                    }

                }
                if (check == false) System.out.println(i);
            }
        }

    }
}

📌 에라토스테네스의 체 - 시간복잡도 O(Nlog(log N))

import java.util.Scanner;

public class test22 {

    public static boolean prime[];

    public static void main(String[] args) {

        Scanner sc  = new Scanner(System.in);

        int N = sc.nextInt();

        make_prime(N);

        for (int i = 0; i < prime.length; i++){
            if(prime[i] == false) System.out.println(prime[i]);
        }

    }

    // 소수면 false
    // 소수가 아니면 true
    public static void make_prime(int N ){

        prime = new boolean[N+1]; // 0 ~ N

        if( N < 2) return;

        prime[0] = true;
        prime[1] = true;


        for(int i = 2; i < Math.sqrt(N); i++){

            if(prime[i] == true) continue;

            for (int j = i * i; j< prime.length; j = j+i){

                prime[j] = true;

            }

        }


    }

}

더 좋은 문제 풀이가 있거나 궁금하신 점이 있다면 편하게 댓글 남겨주세요!

📝 문제

2292번 벌집

🤷‍♂️ 접근 방법

숫자 N 이 벌집의 몇 겹째에 있는지 물어보는 문제이다. 벌집 그림을 살펴보면 아래와 같이 벌집의 겹수가 범위로 주어져 있다.

1            -> 1겹
2 ~ 7        -> 2겹
8 ~ 19        -> 3겹
20 ~ 38        -> 4겹
39 ~ 62        -> 5겹

여기서 알 수 있는 사실은 벌집의 겹수가 1, 7, 19, 38, 62 로 6의 배수만큼 늘어난다는 것이다.

즉, 겹마다 늘어나는 범위는 몇번째 겹인지 * 6이다.

이를 코드로 작성해보자.

✍ 풀이

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        int N = sc.nextInt(); //숫자 N
        int range = 1 ; //벌집의 범위
        int cnt = 1; // 벌집의 겹수

        while(N > range){

            range = range + cnt * 6;
            cnt ++;
        }

        System.out.println(cnt);
    }
}

더 좋은 문제 풀이가 있거나 궁금하신 점이 있다면 편하게 댓글 남겨주세요!

📝 문제

1712번 손익분기점

🤷‍♂️ 접근 방법

막상 문제만 이해한다면 쉽게 해결할 수 있는 수학문제입니다. 먼저 문제를 정리해보겠습니다.

• A만원 고정 비용 = 노트북 판매 대수에 상관없이 매년 지불하는 금액 (ex 임대료, 재산세, 보험료, 급여)

• B만원 가변 비용 = 한 대의 노트북을 생산하는 데에 드는 비용 (ex 재료비와 인건비)

• C만원 노트북 가격 = 한 대의 노트북 판매가격

• 손익분기점 = 총 판매 가격 > 총비용(고정비용 + 가변비용)

n을 판매량이라고 한다면 Cn = A + Bn 임으로 n = A/(C-B)가 총수익과 총비용이 같아지는 지점입니다.

손익분기점은 이익이 발생하는 시점임으로 n에 1을 더한 A/(B-C) +1 이 됩니다.

✍ 풀이

import java.util.Scanner;

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


        int A = in.nextInt();    // 불변 비용
        int B = in.nextInt();    // 가변 비용
        int C = in.nextInt();     // 노트북 가격

        if (C <= B) {
            System.out.println("-1");
        } 
        else {
            System.out.println((A/(C-B))+1);
        }
    }
}

Reference

• https://ooyoung.tistory.com/80

더 좋은 문제 풀이가 있거나 궁금하신 점이 있다면 편하게 댓글 남겨주세요!

📝 문제

1316번 그룹 단어 체커

🤷‍♂️ 접근 방법

✍ 풀이

더 좋은 문제 풀이가 있거나 궁금하신 점이 있다면 편하게 댓글 남겨주세요!

📝 문제

2941번 크로아티아 알파벳

🤷‍♂️ 접근 방법

✍ 풀이

더 좋은 문제 풀이가 있거나 궁금하신 점이 있다면 편하게 댓글 남겨주세요!

📝 문제

5622번 다이얼

🤷‍♂️ 접근 방법

✍ 풀이

더 좋은 문제 풀이가 있거나 궁금하신 점이 있다면 편하게 댓글 남겨주세요!

📝 문제

2908번 상수

🤷‍♂️ 접근 방법

✍ 풀이

더 좋은 문제 풀이가 있거나 궁금하신 점이 있다면 편하게 댓글 남겨주세요!

📝 문제

1152번 단어의 개수

🤷‍♂️ 접근 방법

✍ 풀이

더 좋은 문제 풀이가 있거나 궁금하신 점이 있다면 편하게 댓글 남겨주세요!

📝 문제

1157번 단어 공부

🤷‍♂️ 접근 방법

📌 문자열을 문자열 배열로 만들기

java String to String array

        String str = sc.nextLine() // str ="abcd"

        String arr[ ] = str.split(""); // arr = ["a", "b", "c", "d"]

✍ 풀이

더 좋은 문제 풀이가 있거나 궁금하신 점이 있다면 편하게 댓글 남겨주세요!

📝 문제

2675번 문자열 반복

✍ 풀이

방법1

import java.util.Scanner;
public class Main {

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

        int T = in.nextInt();
        for(int i = 0; i < T; i++) {

            int R = in.nextInt();
            String S = in.next();

            for(int j = 0; j < S.length(); j++) {           
                for(int k = 0; k < R; k++) {    
                    System.out.print(S.charAt(j));
                }
            }

            System.out.println();
        }
    }
}

방법2

import java.util.Scanner;

public class Main {
    public static void main(String arg[]) {

        Scanner sc = new Scanner(System.in);

        int T = sc.nextInt(); 

        for(int i = 0; i < T; i++){
            int R = Integer.parseInt(sc.next());
            String str = sc.next(); 
            String P [] = new String[str.length() * R];

            for(int j =0; j < P.length; j +=R ){
                for(int k = 0 ; k< R; k++){
                    P[j + k] = Character.toString(str.charAt(j/R));
                }
            }

            for(int k = 0; k < P.length; k++){
                System.out.print(P[k]);
            }
            System.out.println();

        }

    }
}

더 좋은 문제 풀이가 있거나 궁금하신 점이 있다면 편하게 댓글 남겨주세요!

📝 문제

10809번 알파벳 찾기

🤷‍♂️ 접근 방법

단어 S를 입력 받고 알파벳 크키 만큼의 배열을 선언합니다.

    String S = sc.next();

    int arr[] = new int [26];

다음으로는 배열의 초기값을 모두 -1로 지정하였습니다.

    for(int i =0; i<arr.length; i++){
        arr[i] = -1;
    }

입력 받은 문자열에서 문자를 추출하고 -'a'를 통해 해당 위치의 값에 문자의 처음 등장 위치를 저장하였습니다. 단, 처음 등장하는 위치의 값을 입력해야 함으로 arr 값이 변경 되지 않았을 때만 값을 변경합니다.

    for(int j =0; j< S.length(); j++) {
           if( arr[S.charAt(j) -'a'] == -1) arr[S.charAt(j) - 'a'] = j;
    }

✍ 풀이

import java.util.Scanner;

public class test {
    public static void main(String arg[]) {

        Scanner sc = new Scanner(System.in);

        String S = sc.next();

        int arr[] = new int [26];

        for(int i =0; i<arr.length; i++){
            arr[i] = -1;
        }

        for(int j =0; j< S.length(); j++) {
            if( arr[S.charAt(j) -'a'] == -1) arr[S.charAt(j) - 'a'] = j;
        }

        for(int k = 0; k < arr.length; k++){
            System.out.printf(arr[k] + " ");
        }

    }
}

더 좋은 문제 풀이가 있거나 궁금하신 점이 있다면 편하게 댓글 남겨주세요!

📝 문제

11720번 숫자의 합

🤷‍♂️ 접근 방법

먼저 숫자의 개수 N을 입력받습니다. 다음으로는 N 만큼의 숫자를 String으로 입력받습니다.

int N = sc.nextInt();
String str = sc.next();

String으로 입력 받은 문자열을 charAt()메서드를 통해 한 문자로 잘라주고 각각을 더해줍니다.

여기서 주의할 것이 있다면 charAt()은 char 형임으로 str.charAt(i)에 저장된 숫자는 아스키 코드값을 반환할 것입니다.

따라서 아래의 아스키 코드 표에 따라 '0'을 빼주어야 입력받은 숫자 값을 더할 수 있습니다.

✍ 풀이

import java.util.Scanner;

public class Main {
    public static void main(String arg[]) {

        Scanner sc = new Scanner(System.in);

        int N = sc.nextInt();
        String str = sc.next();
        int sum = 0;

        for(int i = 0; i< str.length(); i++){
            sum += str.charAt(i) - '0';
        }

        System.out.println(sum);

    }
}

더 좋은 문제 풀이가 있거나 궁금하신 점이 있다면 편하게 댓글 남겨주세요!

📝 문제

11654번 아스키 코드

🤷‍♂️ 접근 방법

입력 받은 문자열을 아스키코드로 변환하는 간단한 문제입니다. 그럼 아스키 코드란 무엇일까요?

컴퓨터는 문자를 문자로 저장하지 않고 숫자로 저장합니다. 이 규칙이 바로 아스키 코드이며 아스키 코드는 0에서 127까지의 숫자를 이용하여 문자를 표현합니다.

아래의 그림은 아스키 코드 테이블입니다. 이를 참고하여 문제를 풀어보겠습니다.

먼저 sc.next()를 통해 문자열(String)을 입력받고 charAt(0)을 통해 문자열을 문자로 잘라 저장하였습니다.

다음으로는 char를 int 타입 변수에 저장하여 문자에 대응하는 값, 아스키 코드값을 저장하였습니다.

    //int ASCII = sc.next().charAt(0);

    char ch = sc.next().charAt(0);
    int ASCII = (int)ch;

📌 Scanner.next()

Scanner 클래스의 next(), nextLine(), nextInt() 메소드를 비교해보겠습니다.

• sc.next() : 공백(space) 이전까지 입력 받은 문자열을 리턴

• sc.nextInt() : Enter 전까지만 숫자로 입력 받아 리턴

• sc.nextLine() : Enter 전까지만 쓴 문자열을 리턴

그래서 주로 한 단어만 입력받고 싶다면 sc.next() 를, 공백이 있는 문자열 한줄을 입력받고 싶다면 sc.nextLine() 메소드를 사용합니다.

next(), nextLine(), nextInt() 메서드 총정리

다음으로는 각각의 차이를 살펴보며 메서드를 이해해 보겠습니다. 우리가 키보드를 통해 입력을 하면 입력 받은 내용은 버퍼에 저장됩니다. 예를 들어 키보드로 123을 입력하고 Enter을 누르면 버퍼에는 아래의 사진과 같이 123\n이라고 저장될 것 입니다.

입력은 next(), nextInt(), nextLine() 메소드가 실행된 후 버퍼에 내용이 있는지 확인할 때 시작됩니다. 이때 sc.next() ,sc.nextInt() 와 sc.nextLine() 에 차이가 있습니다.

sc.next() 와 sc.nextInt() 는 버퍼에서 공백, 탭문자, 개행문자(Enter)를 제외하고 읽어오고 sc.nextLine() 는 공백, 탭문자, 개행문자(Enter)를 다 읽어 온 후 개행문자를 제거하여 이전 문자열만 반환합니다.

이러한 차이 때문에 sc.nextInt() 사용 후 sc.nextLine() 을 사용하면 입력 받기 전에 프로그램이 종료되는 문제가 발생합니다.

sc.nextInt() 로 123을 입력하고 Enter을 눌렀다면 버퍼에는 123\n이 존재할 것이고 sc.nextInt() 에서 버퍼의 내용을 가져올 때 123만 가져가 버퍼에는 \n 이 남게됩니다. 이 상황에서 nextLine을 실행한다면 버퍼에 있는 \n만 가져오고 프로그램이 종료되는 것입니다.

따라서 위와 같은 상황을 방지하기 위해 중간에 sc.nextLine()을 통해 버퍼를 정리하거나

    int num = sc.nextInt();
    sc.nextLine();    //개행문자 Enter를 제거하기 위해 추가

    Stirng str = sc.nextLine(); 

아래와 같이 nextLine을 실행해 개행문자까지 가져온 뒤 정수형으로 반환하는 방법이 있습니다. [백준/JAVA] 1차원 배열 - 8958번 OX퀴즈 참고

    int num = Integer.parseInt(sc.nextInt());

    Stirng str = sc.nextLine(); 

✍ 풀이

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        //int ASCII = sc.next().charAt(0);

        char ch = sc.next().charAt(0);
        int ASCII = (int)ch;

        System.out.print(ASCII);
    }
}

Reference

• https://devlog-wjdrbs96.tistory.com/80