๐ช๐ป programmers Lv1(24.11.19 -3๋ฌธ์ )
71) ๋์ถฉ ๋ง๋ ์ํ
HashMap์ ์ฌ์ฉํ์ฌ key, value๋ฅผ ์ ์ฅํ๊ธฐ
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
import java.util.*;
class Solution {
public int[] solution(String[] keymap, String[] targets) {
int[] answer = new int[targets.length];
Map<Character, Integer> map = new HashMap<>();
for(String s : keymap)
{
for(int i=0;i<s.length();i++)
{
char key = s.charAt(i);
int value = map.getOrDefault(key, i+1);
map.put(key, Math.min(value, i+1));
}
}
for(int i=0;i<targets.length;i++)
{
for(int j=0;j<targets[i].length();j++)
{
char key = targets[i].charAt(j);
if(map.containsKey(key))
{
answer[i] += map.get(key);
}
else{
answer[i] = -1;
break;
}
}
}
return answer;
}
}
HashMap์ ์ฌ์ฉํ์ฌ key, value๋ฅผ ์ ์ฅํ๋ ์๋ฃ๊ตฌ์กฐ, ํน์ ํค์ ๋ํ ๊ฐ์ ๋น ๋ฅด๊ฒ ์ฐพ๊ฑฐ๋ ์ ๋ฐ์ดํธํ ์ ์์.
put(key, value)
: ์ง์ ๋ ํค์ ๋ํ ๊ฐ์ ์ ์ฅget(key)
: ์ง์ ๋ ํค์ ๋ํ ๊ฐ์ ๋ฐํ. ํค๊ฐ ์๋ค๋ฉดnull
์ ๋ฐํ.containsKey(key)
: ํน์ ํค๊ฐHashMap
์ ํฌํจ๋์ด ์๋์ง ์ฌ๋ถ๋ฅผ ํ์ธํจ.getOrDefault(key, defaultValue)
: ํน์ ํค๊ฐ ์์ผ๋ฉด ํด๋น ๊ฐ์ ๋ฐํํ๊ณ , ์์ผ๋ฉด ์ง์ ๋ ๊ธฐ๋ณธ๊ฐ์ ๋ฐํํจ.
1
2
3
4
5
6
7
Map<Character, Integer> map = new HashMap<>();
map.put('A', 1); // 'A'๋ผ๋ ํค์ 1์ ์ ์ฅ
map.put('B', 2); // 'B'๋ผ๋ ํค์ 2๋ฅผ ์ ์ฅ
// 'A'๊ฐ ์๋ ๊ฒฝ์ฐ ๊ทธ ๊ฐ์ ๋ฐํ, ์๋ ๊ฒฝ์ฐ ๊ธฐ๋ณธ๊ฐ 5 ๋ฐํ
int valueA = map.getOrDefault('A', 5); // ๊ฒฐ๊ณผ: 1
int valueC = map.getOrDefault('C', 5); // ๊ฒฐ๊ณผ: 5 ('C'๊ฐ ์๊ธฐ ๋๋ฌธ)
72) ์์ฃผํ์ง ๋ชปํ ์ ์
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import java.util.*;
class Solution {
public String solution(String[] participant, String[] completion) {
String answer = "";
Map<String, Integer> map = new HashMap<>();
for(String s : participant)
{
map.put(s, map.getOrDefault(s,0)+1);
}
for(String s : completion)
{
map.put(s, map.get(s)-1);
}
for(String s : map.keySet())
{
if(map.get(s) > 0)
{
answer = s;
break;
}
}
return answer;
}
}
map.getOrDefault(s, 0) + 1
: ํด๋น ์ด๋ฆ s
๊ฐ ์ด๋ฏธ map
์ ์ ์ฅ๋์ด ์์ผ๋ฉด ๊ทธ ๊ฐ(๋ฑ์ฅ ํ์)์ ๊ฐ์ ธ์ค๊ณ , ์ ์ฅ๋์ด ์์ง ์์ผ๋ฉด ๊ธฐ๋ณธ๊ฐ์ผ๋ก 0
์ ์ฌ์ฉํจ.
์ฆ, ๋ค 0์ผ๋ก ์ ์ฅ๋ ๋ค, ์ด๋ฆ์ +1 ์ ํจ. ์ฆ, ์ด๋ฆ์ด 2๊ฐ ๋์ฌ๊ฒฝ์ฐ 2๋ก ์ ์ฅ.
map.put(s, map.get(s)-1)
: ์์ฃผ์์ ์ด๋ฆ์ map
์์ ์ฐพ์์ ๊ทธ ๊ฐ์ 1 ๊ฐ์
map.keySet()
: ๋ชจ๋ ํค๋ฅผ ์ํ
73) ์ฒด์ก๋ฒ
๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ํ์ฌ ์ํฉ์์ ๊ฐ์ฅ ์ต์ ์ธ ์ ํ์ ๋ฐ๋ณตํด์ ์ต์ข ์ ์ธ ๊ฒฐ๊ณผ๋ฅผ ๋์ถํ๋ ๋ฐฉ์์ ์ฌ์ฉ.
๋น๋ฆด ์ ์๋ ์ฒด์ก๋ณต์ ๋ฐ๋ก ๋น๋ ค์ฃผ๋ ์ต์ ์ ์ ํ์ ๋ฐ๋ณตํ์ฌ ์ ์ฒด ํ์ ์ค ๊ฐ๋ฅํ ๋ง์ ํ์์ด ์ฒด์ก๋ณต์ ๊ฐ์ง๋๋ก ํ๋ ๊ฒ์ด ๋ชฉํ.
๊ทธ๋ฆฌ๋ ๋ฐฉ์์ผ๋ก ๊ฐ ํ์์ด ์ฒด์ก๋ณต์ ์ต๋ํ ๋ง์ด ๋น๋ ค์ค ์ ์๋์ง ํ์ธ. ํ ํ์์ด ์์ ์ ์ฒด์ก๋ณต์ ๋น๋ ค์ฃผ๋ฉด, ๊ทธ ์ฒด์ก๋ณต์ ๋ ์ด์ ๋ค๋ฅธ ํ์์๊ฒ ๋น๋ ค์ค ์ ์์ผ๋ฏ๋ก ๋ฐ๋ก ๋ฆฌ์คํธ์์ ์ ๊ฑฐํ์ฌ ๋ ๋์ ์ต์ ์ ๊ฒฐ๊ณผ๋ฅผ ์ ์ง.
์ฒด์ก๋ณต์ด ํ์ํ ํ์์ ์์๋๋ก ํ์ธํ๋ฉด์ ๋น๋ฆด ์ ์๋์ง ํ์ธํ๋ ๊ณผ์ ์ ํตํด ์ต์ ์ ๊ฒฐ๊ณผ๋ฅผ ์ป์.
ํต์ฌ ํฌ์ธํธ
์ฌ๋ถ์ด ์๋ ํ์์ด ๋น๋ ค์ค ์ ์๋ ๊ฒฝ์ฐ ๊ฐ๊น์ด ๋ฒํธ๋ถํฐ ๋น๋ ค์ฃผ๋ ๊ฒ์ด ๊ฐ์ฅ ์ต์ ์ ์ ํ.
๊ฐ ์์ด๋ฒ๋ฆฐ ํ์์ ํ์ธํ๋ฉฐ ๋น๋ฆด ์ ์๋ ๊ฐ์ฅ ๊ฐ๊น์ด ํ์์ด ์๋ค๋ฉด ๋น๋ ค์ฃผ๊ณ , ๊ทธ๋ ์ง ์์ผ๋ฉด ์ฒด์ก๋ณต์ด ์๋ ์ํ๋ก ๋จ๊ธฐ ๋๋ฌธ์ ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ํน์ฑ.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
import java.util.*;
class Solution {
public int solution(int n, int[] lost, int[] reserve) {
int answer = n;
Set<Integer> lostSet = new HashSet<>();
Set<Integer> reserveSet = new HashSet<>();
for(int l : lost)
{
lostSet.add(l);
}
for(int r : reserve)
{
if(lostSet.contains(r))
{
lostSet.remove(r);
}
else{
reserveSet.add(r);
}
}
for(int l : lostSet)
{
if(reserveSet.contains(l-1))
{
reserveSet.remove(l-1);
}
else if(reserveSet.contains(l+1))
{
reserveSet.remove(l+1);
}
else{
answer--;
}
}
return answer;
}
}