Post

๐Ÿ’ช๐Ÿป programmers Lv1(24.10.16 - 5๋ฌธ์ œ)

๐Ÿ’ช๐Ÿป programmers Lv1(24.10.16 - 5๋ฌธ์ œ)

programmers Lv1(24.10.16 - 5๋ฌธ์ œ)

47) K๋ฒˆ์งธ์ˆ˜

  • ๋ฐฐ์—ด์˜ i๋ฒˆ์งธ ์ˆ˜๋ถ€ํ„ฐ j๋ฒˆ์งธ ์ˆซ์ž๊นŒ์ง€ ์ž๋ฅด๊ณ  ์ •๋ ฌํ–ˆ์„ ๋•Œ k๋ฒˆ์งธ์— ์žˆ๋Š” ์ˆ˜ ๊ตฌํ•˜๊ธฐ

    • ๐Ÿ“Œ ๋‚ด ํ’€์ด

      • 1) ๋ฐฐ์—ด์„ commands์˜ ์ฒซ ๋ฒˆ์งธ ๊ฐ’๋ถ€ํ„ฐ ๋‘ ๋ฒˆ์งธ ๊ฐ’๊นŒ์ง€ ๋ฝ‘์•„์„œ ์˜ค๋ฆ„์ฐจ์ˆœ ์ •๋ ฌํ•œ ๋’ค, k๋ฒˆ์งธ ๊ฐ’ ๊ตฌํ•˜๊ธฐ
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import java.util.*;
class Solution {
    public int[] solution(int[] array, int[][] commands) {
        int num = commands.length;
        int[] answer = new int[num];
        
        for(int i=0;i<num;i++)
        {
            int[] arr = Arrays.copyOfRange(array,commands[i][0]-1, commands[i][1]);
            
            Arrays.sort(arr);
            
            answer[i] = arr[commands[i][2]-1];
        }
        
        return answer;
    }
}
  • ์–ด๋–ป๊ฒŒ ํ’€์–ด์•ผ๊ฒ ๋‹ค ์ƒ๊ฐ์€ ํ–ˆ๋Š”๋ฐ ๋ฉ”์„œ๋“œ๋ฅผ ๋ชจ๋ฅธ ์ƒํƒœ์—์„œ ํ’€๋ ค๊ณ  ํ•˜๋‹ˆ ํ’€์ด๊ฐ€ ๊ธธ์–ด์ ธ์„œ ๋‹ค๋ฅธ ๋‹ต์•ˆ์„ ์ฐธ๊ณ ํ•œ ๋’ค, ์ˆ˜์ •ํ–ˆ๋‹ค.

  • ์ค‘์š”ํ•œ ๋ถ€๋ถ„ : copyOfRange๋Š” 0๋ถ€ํ„ฐ ์‹œ์ž‘ํ•˜๋Š” ์ธ๋ฑ์Šค๋ฅผ ์‚ฌ์šฉํ•˜๊ณ  ํ•ด๋‹น ๋ฌธ์ œ๋Š” 1๋ถ€ํ„ฐ ์‹œ์ž‘ํ•˜๋Š” ์ธ๋ฑ์Šค๋ฅผ ์‚ฌ์šฉํ•˜๋ฏ€๋กœ copyOfRange(array,commands[i][0]-1, commands[i][1]) ๋‹ค์Œ๊ณผ ๊ฐ™์ด ํ’€์ดํ•œ ๊ฒƒ.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] originalArray = {1, 2, 3, 4, 5, 6};

        // ๋ฐฐ์—ด์˜ ์ธ๋ฑ์Šค 2๋ถ€ํ„ฐ 5๊นŒ์ง€์˜ ๋ถ€๋ถ„์„ ๋ณต์‚ฌ (3, 4, 5)
        int[] copiedArray = Arrays.copyOfRange(originalArray, 2, 5);

        // ์ถœ๋ ฅ: [3, 4, 5]
        System.out.println(Arrays.toString(copiedArray));
    }
}



48) ๋‘ ๊ฐœ ๋ฝ‘์•„์„œ ๋”ํ•˜๊ธฐ

  • ์ •์ˆ˜ ๋ฐฐ์—ด numbers์—์„œ ์„œ๋กœ ๋‹ค๋ฅธ ์ธ๋ฑ์Šค์— ์žˆ๋Š” ๋‘ ๊ฐœ์˜ ์ˆ˜๋ฅผ ๋ฝ‘์•„ ๋”ํ•ด์„œ ๋งŒ๋“ค ์ˆ˜ ์žˆ๋Š” ๋ชจ๋“  ์ˆ˜๋ฅผ ๋ฐฐ์—ด์— ์˜ค๋ฆ„์ฐจ์ˆœ์œผ๋กœ ๋‹ด์•„ ๋ฐ˜ํ™˜ํ•˜๊ธฐ

    • ๐Ÿ“Œ ๋‚ด ํ’€์ด

      • 1) i, j๋กœ ์ด์ค‘for๋ฌธ์„ ์ด์šฉํ•ด์„œ ๋ชจ๋“  ์ˆ˜ ๋”ํ•ด์„œ ๊ฐ’ ๊ตฌํ•˜๊ธฐ

      • 2) ์˜ค๋ฆ„์ฐจ์ˆœ ์ •๋ ฌํ•˜๊ธฐ

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.util.*;
class Solution {
    public int[] solution(int[] numbers) {
        Set<Integer> set = new HashSet<>(); // set์„ ์‚ฌ์šฉํ•˜์—ฌ ์ค‘๋ณต์„ ์ž๋™์œผ๋กœ ์ œ๊ฑฐ
        
        for(int i=0;i<numbers.length;i++)
        {
            for(int j=i+1;j<numbers.length;j++)
            {
                set.add(numbers[i]+numbers[j]);
            }
        }
        
        int[] answer = new int[set.size()]; //set์„ ๋ฐฐ์—ด๋กœ ๋ณ€ํ™˜
        int idx = 0;
        for(int sum : set)
        {
            answer[idx++] = sum;
        }
        
        Arrays.sort(answer);
        return answer;
    }
}
  • โ— Set์„ ์‚ฌ์šฉํ•˜๋ฉด ์ค‘๋ณต์„ ์ž๋™์œผ๋กœ ์ œ๊ฑฐํ•  ์ˆ˜ ์žˆ๋‹ค.



49) ํ‘ธ๋“œ ํŒŒ์ดํŠธ ๋Œ€ํšŒ

  • ์˜ˆ์‹œ๋กœ 1๋ฒˆ ์Œ์‹์ด 3๊ฐœ, 2๋ฒˆ ์Œ์‹์ด 4๊ฐœ, 3๋ฒˆ ์Œ์‹์ด 6๊ฐœ ์ค€๋น„๋˜์—ˆ๋‹ค๊ณ  ํ•˜๊ณ  ๋ฌผ์„ ํŽธ์˜์ƒ 0๋ฒˆ ์Œ์‹์ด๋ผ๊ณ  ํ•œ๋‹ค๋ฉด, โ€œ1223330333221โ€์ด ๋จ. ์Œ์‹์˜ ์นผ๋กœ๋ฆฌ๊ฐ€ ์ ์€ ์ˆœ์„œ๋Œ€๋กœ ๋‚˜ํƒ€๋‚ด๋Š” ๋ฐฐ์—ด food๊ฐ€ ์ฃผ์–ด์กŒ์„ ๋•Œ, ์Œ์‹์˜ ๋ฐฐ์น˜๋ฅผ ๋‚˜ํƒ€๋‚ด๋Š” ํ•จ์ˆ˜๋ฅผ ๊ตฌํ•˜์‹œ์˜ค.

    • ๐Ÿ“Œ ๋‚ด ํ’€์ด

      • 1) StringBuilder๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ์ขŒ์ธก์˜ ์ˆซ์ž ๊ตฌํ•˜๊ธฐ. ์ด์ค‘for๋ฌธ์„ ์ด์šฉํ•ด i=1~food.length๊นŒ์ง€, j๋Š” 0 ~ food[i]/2๊นŒ์ง€

      • 2) ๋ฌธ์ž์—ด 0์„ ๋ถ™์ธ ๋’ค, ์—ญ์ˆœ์œผ๋กœ ๊ตฌํ•˜๊ธฐ. ๋งˆ์ง€๋ง‰์— toString์„ ์‚ฌ์šฉํ•˜์—ฌ ๋ฌธ์ž์—ด๋กœ ๋ฐ”๊พธ๊ธฐ

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Solution {
    public String solution(int[] food) {
        StringBuilder answer = new StringBuilder();
        
        for(int i=1;i<food.length;i++)
        {
            for(int j=0;j<food[i]/2;j++)
            {
                answer.append(i);
            }
        }
        answer.append("0");
        
        for(int i= food.length-1;i>=1;i--)
        {
            for(int j=0;j<food[i]/2;j++)
            {
                answer.append(i);
            }
        }
        return answer.toString();
    }
}
  • ๋‹ค๋ฅธ ์‚ฌ๋žŒ ํ’€์ด๋ฅผ ๋ณด๋‹ˆ ๋งˆ์ง€๋ง‰์— reverse()๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ for๋ฌธ์„ ๋” ์“ฐ์ง€ ์•Š๊ณ  ์†์‰ฝ๊ฒŒ ๊ตฌํ–ˆ๋‹ค.
1
2
3
4
5
6
7
8
9
10
11
class Solution {
    public String solution(int[] food) {
        StringBuilder builder = new StringBuilder();
        for (int i=1; i<food.length; i++) {
            int result = food[i] / 2;
            builder.append(String.valueOf(i).repeat(result));
        }
        String answer = builder + "0";
        return answer + builder.reverse();
    }
}



50) ๋ฌธ์ž์—ด ๋‚ด ๋งˆ์Œ๋Œ€๋กœ ์ •๋ ฌํ•˜๊ธฐ

  • ๋ฆฌ์ŠคํŠธ strings์™€ ์ •์ˆ˜ n์ด ์žˆ์„ ๋•Œ, ๊ฐ ๋ฌธ์ž์—ด์˜ ์ธ๋ฑ์Šค n๋ฒˆ์งธ ๊ธ€์ž๋ฅผ ๊ธฐ์ค€์œผ๋กœ ์˜ค๋ฆ„์ฐจ์ˆœ ์ •๋ ฌํ•˜๋ ค๊ณ  ํ•œ๋‹ค. strings๊ฐ€ [โ€œsunโ€, โ€œbedโ€, โ€œcarโ€]์ด๊ณ  n์ด 1์ด๋ฉด ๊ฐ ๋‹จ์–ด์˜ ์ธ๋ฑ์Šค 1์˜ ๋ฌธ์ž โ€œuโ€, โ€œeโ€, โ€œaโ€๋กœ strings๋ฅผ ์ •๋ ฌํ•œ๋‹ค.

  • โ— ๋‹ต์•ˆ์„ ๋ณด๊ณ  ํ’€์ด

    • ๋ฌธ์ž์˜ ์ธ๋ฑ์Šค ๊ฐ’ ์ถœ๋ ฅ : strings[i].charAt(n)

    • ์ฒซ ๋ฒˆ์งธ ๋ฌธ์ž ๊ธฐ์ค€์œผ๋กœ ์ •๋ ฌ : Collections.sort(arr)

    • ArrayList์— ์ƒˆ๋กœ์šด ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ : arr.add()

    • ArrayList์—์„œ ํŠน์ • ์ธ๋ฑ์Šค์— ์žˆ๋Š” ์š”์†Œ๋ฅผ ๋ฐ˜ํ™˜ : arr.get(idx)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.util.*;
class Solution {
    public String[] solution(String[] strings, int n) {
        String[] answer = {};
        
        ArrayList<String> arr = new ArrayList<>();
        for(int i=0;i<strings.length;i++)
        {
            arr.add(""+strings[i].charAt(n)+strings[i]);
        }
        Collections.sort(arr); //์ฒซ๋ฒˆ์งธ ๋ฌธ์ž ๊ธฐ์ค€์œผ๋กœ ์ •๋ ฌ
        answer = new String[arr.size()];
        
        for(int i=0;i<arr.size();i++)
        {
            answer[i] = arr.get(i).substring(1, arr.get(i).length());
        } // usun -> sun
        return answer;
    }
}



51) ์ฝœ๋ผ ๋ฌธ์ œ

  • ์ฝœ๋ผ๋ฅผ ๋ฐ›๊ธฐ ์œ„ํ•ด ๋งˆํŠธ์— ์ฃผ์–ด์•ผ ํ•˜๋Š” ๋ณ‘ ์ˆ˜ a, ๋นˆ ๋ณ‘ a๊ฐœ๋ฅผ ๊ฐ€์ ธ๋‹ค ์ฃผ๋ฉด ๋งˆํŠธ๊ฐ€ ์ฃผ๋Š” ์ฝœ๋ผ๋ณ‘ ์ˆ˜ b, ๊ฐ€์ง€๊ณ  ์žˆ๋Š” ๋นˆ ๋ณ‘์˜ ๊ฐœ์ˆ˜ n์ด ์ฃผ์–ด์งˆ ๋•Œ ์ฝœ๋ผ์˜ ๋ณ‘ ์ˆ˜ ๋ฐ˜ํ™˜ํ•˜๊ธฐ
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Solution {
    public int solution(int a, int b, int n) {
        int answer = 0;
        
        while(n>=a)
        {
            int cola = n/a; // ๊ตํ™˜ํ•  ์ˆ˜ ์žˆ๋Š” ์ฝœ๋ผ ์ˆ˜
            answer += cola * b; // ๊ตํ™˜ํ•ด์„œ ๋ฐ›๋Š” ์ฝœ๋ผ ์ˆ˜
            n = (n%a) + (cola *b); // ๋‚จ์€ ๋นˆ๋ณ‘ + ์ƒˆ๋กœ ์ƒ๊ธด ๋นˆ ๋ณ‘
        }
        
        return answer;
    }
}
This post is licensed under CC BY 4.0 by the author.