๐ช๐ป 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
(์ต๋๊ฐ)์ผ ๋, ํ์ํ ์ด ๊ธ์ก์ ๊ณ์ฐํด ๋ณด๋ฉด:
- ์ฒซ ๋ฒ์งธ ํ์น: 2,500
- ๋ ๋ฒ์งธ ํ์น: 2,500 ร 2 = 5,000
- ์ธ ๋ฒ์งธ ํ์น: 2,500 ร 3 = 7,500 โฆ
- ๋ง์ง๋ง ํ์น(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๋ฒ์งธ ๋ฌธ์๋ฅผ ๋ฐํํ๋ ๋ฉ์๋
- Java์์ ๋ฌธ์์ด
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
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;
}
}