Post

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

๐Ÿ’ช๐Ÿป 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;
    }
}
This post is licensed under CC BY 4.0 by the author.