Post

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

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

programmers Lv1(24.09.25 - 10๋ฌธ์ œ)

21) ๋‚ด์ 

  • a, b ๋ฐฐ์—ด์˜ ๋‚ด์  ๊ตฌํ•˜๊ธฐ

  • ๐Ÿ“Œ ๋‚ด ํ’€์ด

    • 1) ๋ฐ˜๋ณต๋ฌธ์œผ๋กœ a๋ฐฐ์—ด์˜ ๊ธธ์ด๋งŒํผ(a, b ๋ฐฐ์—ด์˜ ๊ธธ์ด๊ฐ€ ๊ฐ™์œผ๋ฏ€๋กœ) ๋ฐ˜๋ณต

    • 2) ๋‚ด์  ๊ณ„์‚ฐํ•˜๊ธฐ

1
2
3
4
5
6
7
8
9
10
class Solution {
    public int solution(int[] a, int[] b) {
        int answer = 0;
        for(int i=0;i<a.length;i++)
        {
            answer += a[i]*b[i];
        }
        return answer;
    }
}



22) ๊ฐ€์šด๋ฐ ๊ธ€์ž ๊ฐ€์ ธ์˜ค๊ธฐ

  • ๋‹จ์–ด์˜ ๊ฐ€์šด๋ฐ ๊ธ€์ž ๋ฐ˜ํ™˜ํ•˜๊ธฐ, ์ง์ˆ˜๋ฉด ๊ฐ€์šด๋ฐ ๋‘ ๊ธ€์ž ๋ฐ˜ํ™˜

  • ๐Ÿ“Œ ๋‚ด ํ’€์ด

    • 1) ๋ฌธ์ž์—ด์„ ๋ฌธ์ž๋กœ ๋ณ€ํ™˜

    • 2) ๋ฌธ์ž์˜ ํšŸ์ˆ˜ ์นด์šดํŠธ
    • 3) ์ธ๋ฑ์Šค ๋ฒˆํ˜ธ๋ฅผ ๊ตฌํ•ด์„œ ๊ฒฐ๊ณผ๊ฐ’์— ๋Œ€์ž…, ์ง์ˆ˜์ผ ๊ฒฝ์šฐ๋Š” ์ธ๋ฑ์Šค ๋ฒˆํ˜ธ 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
25
import java.util.*;
class Solution {
    public String solution(String s) {
        String answer = "";
        char[] ch = s.toCharArray();
        int cnt = 0;
        for(int i=0;i<ch.length;i++)
        {
            cnt++;
        }
        int idx1 = 0, idx2 = 0;
        if(cnt%2==1)
        {
            idx1 = ch.length / 2; 
            answer += ch[idx1];
        }
        else{
            idx1 = ch.length / 2 - 1;
            idx2 = ch.length / 2;
            answer += ch[idx1];
            answer += ch[idx2];
        }
        return answer;
    }
}



23) ์ˆ˜๋ฐ•์ˆ˜๋ฐ•์ˆ˜๋ฐ•์ˆ˜๋ฐ•์ˆ˜๋ฐ•์ˆ˜?

  • ๊ธธ์ด๊ฐ€ n์ด๊ณ  โ€œ์ˆ˜๋ฐ•์ˆ˜๋ฐ•์ˆ˜โ€ฆโ€œ์™€ ๊ฐ™์€ ํŒจํ„ด์„ ์œ ์ง€ํ•˜๋Š” ๋ฌธ์ž์—ด ๋ฐ˜ํ™˜

  • ๐Ÿ“Œ ๋‚ด ํ’€์ด

    • 1) n๊นŒ์ง€ ๋ฐ˜๋ณตํ•˜๋ฉฐ ๋ฐ˜๋ณตํ•˜๋Š” i๊ฐ€ ์ง์ˆ˜์ผ ๋•Œ โ€œ์ˆ˜โ€๋ฅผ, ํ™€์ˆ˜์ผ ๋•Œ๋Š” โ€œ๋ฐ•โ€์„ ๊ฒฐ๊ณผ๊ฐ’์— ๋”ํ•˜๊ธฐ
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import java.util.*;
class Solution {
    public String solution(int n) {
        String answer = "";
        for(int i=0;i<n;i++){
            if(i%2 == 0)
            {
                answer += "์ˆ˜";
            }
            else 
            {
                answer += "๋ฐ•";   
            }
        } 
        return answer;
    }
}



24) ์•ฝ์ˆ˜์˜ ๊ฐœ์ˆ˜์™€ ๋ง์…ˆ

  • left ๋ถ€ํ„ฐ right ๊นŒ์ง€ ์•ฝ์ˆ˜์˜ ๊ฐœ์ˆ˜๊ฐ€ ์ง์ˆ˜์ธ ์ˆ˜๋Š” ๋”ํ•˜๊ณ  ํ™€์ˆ˜์ด๋Š” ์ˆ˜๋Š” ๋นผ๊ธฐ

  • ๐Ÿ“Œ ๋‚ด ํ’€์ด

    • 2์ค‘๋ฐ˜๋ณต๋ฌธ์œผ๋กœ 1๋ถ€ํ„ฐ right๊นŒ์ง€, left๋ถ€ํ„ฐ right ๊นŒ์ง€ ๋ฐ˜๋ณต๋ฌธ์„ ๋งŒ๋“  ๋’ค j%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
class Solution {
    public int solution(int left, int right) {
        int answer = 0;
        for(int i=left;i<=right;i++)
        {
            int cnt = 0;
            for(int j=1;j<=right;j++)
            {
                if(i%j==0)
                {
                    cnt++;
                }
            }
            if(cnt%2==0)
            {
                answer+=i;
            }
            else if(cnt%2 ==1)
            {
                answer-=i;
            }
        }
        return answer;
    }
}

  • โ— cnt ์ดˆ๊ธฐํ™” ํ•˜๋Š” ๋ถ€๋ถ„์„ for๋ฌธ ์•ˆ์— ํ•ด์•ผ ๊ฐ ์ˆ˜๊ฐ€ ์•Œ๋งž๊ฒŒ ์ดˆ๊ธฐํ™” ๋จ.

  • ๋‹ค๋ฅธ ์‚ฌ๋žŒ์˜ ํ’€์ด : ์ œ๊ณฑ์ˆ˜์ธ ๊ฒฝ์šฐ ์•ฝ์ˆ˜์˜ ๊ฐœ์ˆ˜๋Š” ํ™€์ˆ˜ (ex. 25 -> 1, 5, 25)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Solution {
    public int solution(int left, int right) {
        int answer = 0;
        for (int i = left; i <= right; i++) {
            // ์ œ๊ณฑ์ˆ˜์ธ์ง€ ํ™•์ธ (i์˜ ์ œ๊ณฑ๊ทผ์ด ์ •์ˆ˜์ด๋ฉด ์ œ๊ณฑ์ˆ˜)
            if (Math.sqrt(i) == (int)Math.sqrt(i)) {
                answer -= i; // ์ œ๊ณฑ์ˆ˜์ผ ๊ฒฝ์šฐ ์•ฝ์ˆ˜์˜ ๊ฐœ์ˆ˜๊ฐ€ ํ™€์ˆ˜
            } else {
                answer += i; // ๊ทธ ์™ธ์˜ ๊ฒฝ์šฐ ์•ฝ์ˆ˜์˜ ๊ฐœ์ˆ˜๊ฐ€ ์ง์ˆ˜
            }
        }
        return answer;
    }
}



25) ๋ฌธ์ž์—ด ๋‚ด๋ฆผ์ฐจ์ˆœ์œผ๋กœ ๋ฐฐ์น˜ํ•˜๊ธฐ

  • ๋Œ€๋ฌธ์ž๊ฐ€ ์†Œ๋ฌธ์ž๋ณด๋‹ค ์ž‘๋‹ค๊ณ  ๊ฐ€์ •ํ•˜๊ณ  ๋ฌธ์ž์—ด s์— ๋‚˜ํƒ€๋‚˜๋Š” ๋ฌธ์ž๋ฅผ ํฐ๊ฒƒ๋ถ€ํ„ฐ ์ž‘์€ ์ˆœ์œผ๋กœ ์ •๋ ฌํ•˜๊ธฐ

  • ๐Ÿ“Œ ๋‚ด ํ’€์ด

    • 1) ๋ฌธ์ž์—ด์„ ๋ฌธ์ž ๋ฐฐ์—ด๋กœ ๋ณ€ํ™˜ํ•˜๊ธฐ

    • 2) ์˜ค๋ฆ„์ฐจ์ˆœ ์ •๋ ฌํ•œ ๋’ค, StringBuilder๋ฅผ ์ด์šฉํ•˜์—ฌ ๋‚ด๋ฆผ์ฐจ์ˆœ ์ •๋ ฌํ•˜๊ธฐ

1
2
3
4
5
6
7
8
9
10
11
import java.util.*;
class Solution {
    public String solution(String s) {
        String answer = "";
        char[] ch = s.toCharArray(); //๋ฌธ์ž์—ด์„ ๋ฌธ์ž ๋ฐฐ์—ด๋กœ ๋ณ€ํ™˜
        Arrays.sort(ch); // ์˜ค๋ฆ„์ฐจ์ˆœ
        StringBuilder sb = new StringBuilder(new String(ch)).reverse(); //๋‚ด๋ฆผ์ฐจ์ˆœ
        answer+=sb.toString();
        return answer;
    }
}



26) ๋ถ€์กฑํ•œ ๊ธˆ์•ก ๊ณ„์‚ฐํ•˜๊ธฐ

  • ๋†€์ด๊ธฐ๊ตฌ ์ด์šฉ๋ฃŒ price์›, ๋†€์ด๊ธฐ๊ตฌ๋ฅผ N๋ฒˆ ์ด์šฉํ•œ๋‹ค๋ฉด N๋ฐฐ๋ฅผ ๋ฐ›์Œ, ๋†€์ด๊ธฐ๊ตฌ๋ฅผ count๋ฒˆ ํƒ€๊ฒŒ ๋˜๋ฉด ํ˜„์žฌ ์ž์‹ ์ด ๊ฐ€์ง€๊ณ  ์žˆ๋Š” ๊ธˆ์•ก์—์„œ ์–ผ๋งˆ๊ฐ€ ๋ชจ์ž๋ž€์ง€ ๊ตฌํ•˜๊ธฐ

  • ๐Ÿ“Œ ๋‚ด ํ’€์ด

    • 1) 1๋ถ€ํ„ฐ cnt๋ฒˆ์„ ๋ฐ˜๋ณตํ•˜๋ฉด์„œ sum ๋ณ€์ˆ˜์— ์ด์šฉ๋ฃŒ * N ๋”ํ•˜๊ธฐ

    • 2) sum์ด ์›๋ž˜ ๊ฐ€์ง€๊ณ  ์žˆ๋Š” ๊ธˆ์•ก๋ณด๋‹ค ํฌ๋ฉด sum-money๋กœ ๊ฐ’ ์ถœ๋ ฅ, ์•„๋‹ˆ๋ผ๋ฉด 0 ๋ฐ˜ํ™˜

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Solution {
    public long solution(int price, int money, int count) {
        long sum = 0;
        
        for(int i=1;i<=count;i++)
        {
            sum += price*i;
        }
        
        if(money>=sum)
        {
           return 0;
        }
        else
        {
            return sum - money;
        }
    }
}
  • โ— ์•„๋ฌด๋ฆฌ ํ•ด๋„ ๋งž๋Š” ๊ฑฐ ๊ฐ™์€๋ฐ ์ž๊พธ ํ…Œ์ŠคํŠธ์—์„œ ์‹คํŒจ๊ฐ€ ๋ช‡ ๊ฐœ ๋– ์„œ ๋ฌด์—‡์ธ์ง€ ํ•œ์ฐธ์„ ๊ณ ๋ฏผํ•˜๋‹ˆ sum์„ ์ฒ˜์Œ์— int ํƒ€์ž…์œผ๋กœ ํ•ด์„œ ํ‹€๋ ธ์—ˆ๋‹ค.

price = 2,500 (์ตœ๋Œ€๊ฐ’), count = 2,500 (์ตœ๋Œ€๊ฐ’)์ผ ๋•Œ, ํ•„์š”ํ•œ ์ด ๊ธˆ์•ก์„ ๊ณ„์‚ฐํ•ด ๋ณด๋ฉด:

  1. ์ฒซ ๋ฒˆ์งธ ํƒ‘์Šน: 2,500
  2. ๋‘ ๋ฒˆ์งธ ํƒ‘์Šน: 2,500 ร— 2 = 5,000
  3. ์„ธ ๋ฒˆ์งธ ํƒ‘์Šน: 2,500 ร— 3 = 7,500 โ€ฆ
  4. ๋งˆ์ง€๋ง‰ ํƒ‘์Šน(2,500๋ฒˆ์งธ): 2,500 ร— 2,500 = 6,250,000

์ด๋ฅผ ๋ชจ๋‘ ๋”ํ•˜๋ฉด 7,815,625,000์€ int์˜ ๋ฒ”์œ„๋ฅผ ๋„˜์Œ.



27) ๋ฌธ์ž์—ด ๋‹ค๋ฃจ๊ธฐ ๊ธฐ๋ณธ

  • ๋ฌธ์ž๋กœ๋งŒ ๊ตฌ์„ฑ๋˜์–ด ์žˆ๊ณ  ๋ฌธ์ž์—ด์˜ s์˜ ๊ธธ์ด๊ฐ€ 4 ํ˜น์€ 6์ธ์ง€ ํ™•์ธ

  • ๐Ÿ“Œ ๋‚ด ํ’€์ด

    • 1) ๋ฌธ์ž์—ด์˜ ๊ธธ์ด๊ฐ€ 4 ํ˜น์€ 6์ด ์•„๋‹ˆ๋ฉด false ๋ฐ˜ํ™˜

    • 2) s.charAt(i) ๊ฐ€ 0 ~ 9๊นŒ์ง€ ์ˆซ์ž๊ฐ€ ์•„๋‹ˆ๋ฉด false ๋ฐ˜ํ™˜

      • Java์—์„œ ๋ฌธ์ž์—ด s์˜ i๋ฒˆ์งธ ๋ฌธ์ž๋ฅผ ๋ฐ˜ํ™˜ํ•˜๋Š” ๋ฉ”์„œ๋“œ
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Solution {
    public boolean solution(String s) {
       if(s.length() != 4 && s.length()!=6)
       {
           return false;
       }
        for(int i=0;i<s.length();i++)
        {
            if(s.charAt(i)<'0' || s.charAt(i)>'9')
            {
                return false;
            }
        }
       return true;
    }
}



28) ํ–‰๋ ฌ์˜ ๋ง์…ˆ

  • 2๊ฐœ์˜ ํ–‰๋ ฌ ์ž…๋ ฅ ๋ฐ›์•„ ๋‹ต ๊ตฌํ•˜๊ธฐ

  • ๐Ÿ“Œ ๋‚ด ํ’€์ด

    • 1) ํ–‰, ์—ด ๊ธธ์ด ๊ตฌํ•˜๊ณ  ๋ฐ˜๋ณต๋ฌธ์œผ๋กœ ๊ฐ’ ๋”ํ•˜๊ธฐ
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Solution {
    public int[][] solution(int[][] arr1, int[][] arr2) {
        int rows = arr1.length;
        int cols = arr1[0].length;
        int[][] answer = new int[rows][cols];
        for(int i=0;i<rows;i++)
        {
            for(int j=0;j<cols;j++)
            {
                answer[i][j] = arr1[i][j]+arr2[i][j];
            }
        }
        return answer;
    }
}
  • ์˜ค๋žœ๋งŒ์— ํ–‰, ์—ด์„ ๊ตฌํ•ด์„œ ์—ด์˜ ๊ฒฝ์šฐ ๊ธธ์ด๊ฐ€ arr[0].length๋กœ ๊ตฌํ•ด์•ผ ๋˜๋Š”๋ฐ arr.length๋กœ ์‹ค์ˆ˜๋ฅผ ํ–ˆ๋‹ค.

  • ์˜ˆ๋ฅผ ๋“ค์–ด [[1],[2]] [[3],[4]] ์ด ๊ฒฝ์šฐ 2ํ–‰ 1์—ด์ด๋‹ค. ์ƒ๊ฐ์ด ์•ˆ ๋‚  ๋•Œ๋Š” ์˜ˆ์‹œ๋กœ ๊ทธ๋ ค๋ณด๋Š” ๊ฒƒ๋„ ์‹ค์ˆ˜๋ฅผ ์ค„์ผ ์ˆ˜ ์žˆ์„ ๊ฑฐ ๊ฐ™๋‹ค.



29) ์ง์‚ฌ๊ฐํ˜• ๋ณ„์ฐ๊ธฐ

  • ์ง์‚ฌ๊ฐํ˜• ๋ณ„์ฐ๊ธฐ

  • ๐Ÿ“Œ ๋‚ด ํ’€์ด

    • b๋ฅผ ํ–‰, a๋ฅผ ์—ด๋กœ ๋†“๊ณ  ๋ฐ˜๋ณต๋ฌธ ๋Œ๋ฆฌ๊ธฐ
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import java.util.Scanner;

class Solution {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        
        for(int i=0;i<b;i++)
        {
            for(int j=0;j<a;j++)
            {
                 System.out.print("*");
            }
             System.out.println();
        }
    }
}



30) ์ตœ๋Œ€๊ณต์•ฝ์ˆ˜์™€ ์ตœ์†Œ๊ณต๋ฐฐ์ˆ˜

  • ์ตœ๋Œ€๊ณต์•ฝ์ˆ˜์™€ ์ตœ์†Œ๊ณต๋ฐฐ์ˆ˜๋ฅผ ๊ตฌํ•˜๊ธฐ

  • ๐Ÿ“Œ ๋‚ด ํ’€์ด

    • 1) ์ตœ๋Œ€๊ณต์•ฝ์ˆ˜๋Š” ๋‘ ์ˆ˜๊ฐ€ ๋ชจ๋‘ ๋‚˜๋ˆ„์–ด ๋–จ์–ด์ง€๋Š” ๊ฒฝ์šฐ์˜ ๋ชซ์ด๋ฏ€๋กœ ๊ฐ’์„ ๊ตฌํ•œ ๋’ค ํ•ด๋‹น ๊ฐ’ ์ €์žฅ
    • 2) ์ตœ์†Œ๊ณต๋ฐฐ์ˆ˜๋Š” ํ•ด๋‹น ์ˆ˜๋ฅผ ์œ„์—์„œ ๊ตฌํ•œ ๋ชซ์œผ๋กœ ๋‚˜๋ˆˆ ๊ฐ’๊ณผ ๋ชซ์œผ๋กœ ๊ณฑํ–ˆ์„ ๊ฒฝ์šฐ์— ๊ตฌํ•˜๊ธฐ

    1

  • ์กฐ๊ธˆ ์›ƒ๊ธฐ์ง€๋งŒ ์ด๋ ‡๊ฒŒ ํ’€์—ˆ๋‹ค..

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 n, int m) {
        int[] answer = new int[2];
        int answer_Idx1 = 0, answer_Idx2 = 0;
        int n1=0, m1 =0;
      
        for(int i=1;i<=Math.min(n,m);i++)
        {
            if(n%i==0 && m%i==0)
            {
                answer_Idx1 = i; 
            }
        }
        n1 = n / answer_Idx1;
        m1 = m / answer_Idx1;
        answer_Idx2 = answer_Idx1 * n1 * m1;
    
        answer[0] = answer_Idx1;
        answer[1] = answer_Idx2; 
    
        return answer;
    }
}
This post is licensed under CC BY 4.0 by the author.