๐ช๐ป 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;
}
}