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