๐ช๐ป programmers Lv1(24.10.22 - 5๋ฌธ์ )
programmers Lv1(24.10.22 - 5๋ฌธ์ )
60) ๊ณผ์ผ ์ฅ์
์ฌ๊ณผ ๋ฐ์ค์ ์ต๋ ์ด์ต์ ๊ตฌํด์ผ ๋๊ธฐ ๋๋ฌธ์ ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ์ ํ๋ค.
๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ์ ํ ๋ ํ ๋ฐ์ค์ m๊ฐ์ฉ ๋ด์์ผ๋๊ธฐ ๋๋ฌธ์ i-=m์ผ๋ก ์ค์ ํ๋ค.
i-m+1>=0์ ํ๋ ์ด์ ๋ ์์์ m๊ฐ์ฉ ๋ด๊ธธ ๋๋ง ์กฐ๊ฑด์ ๋ง์กฑํด์ผ ๋๊ธฐ ๋๋ฌธ์ด๋ค.
- m = 4์ผ ๋ i = 0, 1, 2 ์ผ ๋๋ 3๊ฐ์ด๋ฏ๋ก ๋ง์กฑํ์ง ์๊ณ i = 3์ด ๋๋ ์๊ฐ 4๊ฐ๊ฐ ๋ฐ์ค์ ๋ค์ด๊ฐ๋ฏ๋ก ๊ฐ๋ฅํ๋ค.
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 k, int m, int[] score) {
int answer = 0;
Arrays.sort(score);
for(int i=score.length-1;i>=0;i-=m)
{
if(i-m+1>=0) // 3-4+1
{
answer+=score[i-m+1]*m; //๊ทธ ๋ฒ์์์ ๊ฐ์ฅ ์์ ๊ฐ
}
}
return answer;
}
}
61) ์์ ์ฐพ๊ธฐ
์๋ผํ ๋ค์ค์ ์ฒด ์๊ณ ๋ฆฌ์ฆ ํ์ฉ
์์๋ฅผ ํ๋ณํ๋ ์๊ณ ๋ฆฌ์ฆ
boolean ํ์ ์ผ๋ก isPrime ๋ฐฐ์ด ์ ์ธ
๋จผ์ ์์๋ 1์ด ํฌํจ๋์ง ์์ผ๋ฏ๋ก 2๋ถํฐ ์์ํด์ n๊น์ง ์์๋ผ๊ณ ๊ฐ์ ํ๋ค.
๋ฐฐ์๋ค์ ์ง์ธ ๋๋ ์ ๊ณฑ๊ทผ๊น์ง๋ง ๊ฒ์ฌํ๋ฉด ๋๋ค.
์์๋ก n=10์ด๋ผ๊ณ ๊ฐ์ ํ๊ฒ ๋ค. ๊ทธ๋ ๋ค๋ฉด i=2์ผ ๋, ๋ ๋ฒ์งธ ๋ฐ๋ณต๋ฌธ์์ i=2; ii=4<=10์ด๋ฏ๋ก ํต๊ณผ๊ฐ ๋๊ณ isPrime[i] = true์ด๋ฉด์ j=ii ~n๊น์ง j+i๋ฒ์ ๋ฐ๋ณตํ๋ค. ๊ทธ๋ ๋ค๋ฉด 4, 6, 8, 10์ด 2์ ๋ฐฐ์์ด๊ธฐ ๋๋ฌธ์ ๋ต์์ ์ ์ธ๊ฐ ๋๋ค.
๊ทธ ๋ค์ i=3์ผ ๋๋ฅผ ๋ณด๋ฉด i*i= 9<=10 ํต๊ณผ๊ฐ ๋๊ณ , isPrime[i] = true, 3์ ๋ฐฐ์๋ฅผ ์ง์ฐ๋ฉด 3, 6, 9๊ฐ ์ ์ธ๊ฐ ๋๋ค.
i=4 ์ผ ๋๋ ์ด๋ฏธ ์ ์ธ๋์๊ณ , i=5 ์ผ ๋ ๋ ๋ฒ์งธ ๋ฐ๋ณต๋ฌธ์์ ํต๊ณผ๋์ง ์๊ณ , i=6์ผ ๋ ์ด๋ฏธ ์ ์ธ๊ฐ ๋์๊ณ , i=7์ผ ๋๋ ๋ ๋ฒ์งธ ๋ฐ๋ณต๋ฌธ์์ ํต๊ณผ๋์ง ์์๊ณ , i= 8, 9, 10์ ๋ค ์ ์ธ๋์๋ค.
๋ฐ๋ผ์ ๋ต์ [2, 3, 5, 7]์ด ๋๋ค.
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
class Solution {
public int solution(int n) {
int answer = 0;
boolean[] isPrime = new boolean[n+1];
for(int i=2;i<=n;i++)
{
isPrime[i] = true; // ์ฒ์ ๋ชจ๋ ์๋ ์์๋ผ๊ณ ๊ฐ์
}
for(int i=2;i*i<=n;i++)
{
if(isPrime[i])
{
for(int j= i*i;j<=n;j+=i)
{
isPrime[j] = false;
}
}
}
for(int i=2;i<=n;i++)
{
if(isPrime[i])
{
answer++;
}
}
return answer;
}
}
62) ์์ ๋ง๋ค๊ธฐ
๋จผ์ 3์คfor๋ฌธ์ ์ด์ฉํด์ 3๊ฐ์ ์๋ฅผ ๋ํ์ ๋ ํฉ์ ๊ตฌํ ๋ค, ๋ฉ์๋๋ฅผ ๋ง๋ค์ด์ ์์์ธ์ง ๊ณ์ฐํด์ ํ์๋ฅผ ๊ตฌํ๋ค.
isPrime()๋ฉ์๋๋ ์์๋ 2๋ถํฐ ์์์ด๋ฏ๋ก 1์ผ ๋ ์ ์ธ๋ฅผ ์ํค๊ณ ์ฝ์๋ ์ ๊ณฑ๊ทผ๊น์ง ๊ตฌํ๋ฉด ๋๋ฏ๋ก i*i๋ก ๊ตฌํ๋ค.
๊ทธ ๋ค์ ์๋ฅผ ๋ค์ด num์ด 13์ด๋ฉด 13 % i == 0์ด ์ฑ๋ฆฝ๋์ง ์์ผ๋ฏ๋ก ์์์ด๊ณ num์ด 6์ด๋ฉด 6%i==0์ด ์ฑ๋ฆฝ๋๋ฏ๋ก ์์๊ฐ ์๋๋ค.
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
import java.util.*;
class Solution {
public boolean isPrime(int num)
{
if(num<2) return false;
for(int i=2;i*i<=num;i++)
{
if(num%i==0)
{
return false;
}
}
return true;
}
public int solution(int[] nums) {
int answer = 0;
for(int i=0;i<nums.length-2;i++)
{
for(int j=i+1;j<nums.length-1;j++)
{
for(int k=j+1;k<nums.length;k++)
{
int sum = nums[i] + nums[j] + nums[k];
if(isPrime(sum))
{
answer++;
}
}
}
}
return answer;
}
}
63) ๋ง์น ํ๊ธฐ
๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ ํ์ฉ
๋งค ๋จ๊ณ ๊ฐ์ฅ ์ต์ ์ ์ ํ์ ํ์ฌ ์ต์ข ์ ์ธ ๊ฒฐ๊ณผ๋ฅผ ๋์ถํ๋ ๋ฐฉ๋ฒ
start๋ ํ์ฌ ๋ธ๋ก์ ์์ ์์น๋ฅผ ๋ํ๋. answer์ ํ์ํ ๋ธ๋ก์ ๊ฐ์๋ฅผ ์ธ๋ ๋ณ์๋ก ์ฒซ ๋ฒ ์งธ ๊ตฌ์ญ์ ๋ฎ๊ธฐ ๋๋ฌธ์ 1๋ก ์ด๊ธฐํ๋ ๊ฒ.
if(start+m > item)์กฐ๊ฑด์ ํ์ฌ ๋ธ๋ก์ด ํด๋น ๊ตฌ์ญ์ ๋ฎ์ ์ ์๋์ง ํ๋จ.๋ฎ๋๋ค๋ฉด continue๋ฅผ ํตํด ๋ค์ ๊ตฌ์ญ์ผ๋ก ๋์ด๊ฐ๊ณ , ์๋๋ผ๋ฉด answer์ ๊ฐ์ ์ฆ๊ฐ
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Solution {
public int solution(int n, int m, int[] section) {
int answer = 0;
int start = section[0];
answer++;
for(int item : section) // 2 3 6
{
if(start+m > item) // 2+4 = 6 > 2, 6>6
{
continue;
}
start = item;
answer++;
}
return answer;
}
}
64) ์๋ง์ด(2)
๋ฐ์ํ ์ ์๋ ๋ฐฐ์ด์ words๋ก ๋ง๋ ๋ค.
ํฅ์๋ for๋ฌธ์ ์ด์ฉํ์ฌ babbling ๋ฐฐ์ด์ b์ ๋ฃ๊ณ modified ๋ณ์์ ๋ณต์ฌํ๋ค.
์ฐ์๋ ๋ฐ์์ด๋ฉด
continue๋ฅผ ํตํด ๋ค์์ผ๋ก ๋์ด๊ฐ๋ค.๊ทธ๋ฆฌ๊ณ
replace()๋ฉ์๋๋ฅผ ์ด์ฉํด ๋ฐ์์ ๊ณต๋ฐฑ์ผ๋ก ๋์ฒดํ๋ค.๋จ์ ๋ฌธ์์ด์ด ๊ณต๋ฐฑ์ธ์ง ํ์ธํ๊ณ ๋จ์ด๋ฅผ ์์ ํ ๋ฐ์ํ ์ ์์ผ๋ฏ๋ก ํ์๋ฅผ ์นด์ดํธ ํ๋ค.
trim(): ๋ฌธ์์ด์ ์์๊ณผ ๋์ ์๋ ๊ณต๋ฐฑ์ ์ ๊ฑฐํ๋ค. ex)"hello "๋ฅผtrim()ํ๋ฉด"hello"๊ฐ ๋๋ค.isEmpty(): ๋ฌธ์์ด์ด ๋น์ด ์๋์ง ํ์ธํ๋ค. ๋น์ด์๋ ๋ฌธ์์ด์ ๊ฒฝ์ฐtrue, ๊ทธ๋ ์ง ์์ผ๋ฉดfalse๋ฐํ
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
class Solution {
public int solution(String[] babbling) {
int answer = 0;
for(String b:babbling)
{
String modified = b;
String[] words = {"aya", "ye", "woo","ma"};
if (b.contains("ayaaya") || b.contains("yeye") || b.contains("woowoo") || b.contains("mama")) {
continue;
}
for(String word : words)
{
modified = modified.replace(word," ");
}
if(modified.trim().isEmpty())
{
answer++;
}
}
return answer;
}
}