์
์ถ๋ ฅ ์
order | result |
---|---|
3 | 1 |
29423 | 2 |
์
์ถ๋ ฅ ์ ์ค๋ช
๋์ ํ์ด
package ํ๋ก๊ทธ๋๋จธ์ค;
public class Clap {
public static int solution(int order) {
int answer = 0;
String[] str = Integer.toString(order).split("");
int[] clab = new int[str.length];
for(int i = 0; i <str.length; i++) {
clab[i] = Integer.parseInt(str[i]);
if(clab[i] != 0 && clab[i] % 3 == 0) {
answer++;
}
}
return answer;
}
public static void main(String[] args) {
solution(10);
}
}
๋์ ์๊ฐ
์ ์ผ ๋จผ์ ์๊ฐํ๋ ๋ถ๋ถ์ด, ์ซ์์์ ํน์ ์ซ์๋ฅผ ํ๋ณํ๋ ๋ฐฉ๋ฒ์ ๋ํด์ ๊ณ ๋ฏผ์ ์์ํ์๋ค.
intํ ๋ณ์ ๊ทธ ์์ฒด๋ split๋ฉ์๋๊ฐ ์์ผ๋๊น, ๋ฌธ์์ด ๋ฐฐ์ด์ Integer
๋ด์ฅ ํด๋์ค๋ฅผ ์ฌ์ฉํด์ ์ชผ๊ฐ๋ฉด ๋๊ฒ๋ค๊ณ ์๊ฐ. ๊ทธ๋ฆฌ๊ณ ๋ฐ๋ณต์ ๋๋ ค, ๋ฌธ์๋ฅผ ๋ค์ intํ์ผ๋ก parseInt
, ๊ทธ ๋ค์์
if๋ฌธ์ผ๋ก intํ ๋ฐฐ์ด์ ์ฐจ๋ก๋ก ์ฒดํฌํด์ 3์ผ๋ก ๋๋ ๋๋จธ์ง๊ฐ 0์ด๋ฉด 3,6,9
์ ํด๋นํ๊ธฐ ๋๋ฌธ์ answer์ cntํด์ฃผ๋ ๋ฐฉ๋ฒ์ ์ฌ์ฉ. ๋จ, ์ซ์0์ด ๋์ฌ๋์๋ ๋๋จธ์ง๊ฐ 0์ด๊ธฐ๋๋ฌธ์, if๋ฌธ ์์ ์กฐ๊ฑด์ ํ๋ ์ถ๊ฐํด์ ํํฐ๋ฅผ ํด์คฌ์
์ฒ์์๋ 0์ ์๊ฐ ๋ชปํด์ ์ผ์ด์ค ์ค๋ฅ๊ฐ ๋ฐ์ํ๋๋ฐ ์ ์คํ๊ฒ ๊ณ ๋ฏผ์ ํด๋ด์ผ๊ฒ ๋ค.
๊ฐ์ ๋ ํ์ด
class Solution {
public int solution(int order) {
int answer = 0;
String str = order+"";
for(int i=0; i<str.length(); i++){
char c = str.charAt(i);
if(c=='3'||c=='6'||c=='9') answer++;
}
return answer;
}
}
๋ด๊ฐ intํ ๋ณ์๋ฅผ ์ด๋ป๊ฒ ์ชผ๊ฐค๊น๋ฅผ ์๊ฐํ ๋, ์ด๋ฐ ๋ฐฉ๋ฒ์ ํ์ฉํด์ ์ธ ์ค์ ์์๋ ๋ชปํ๋ค...
intํ ๋ณ์ ๋ฅผ+
์ฐ์ฐ์์""
๋ก ๋ฌถ์ผ๋ฉด ์๋ ํ๋ณํ์ผ๋ก ๋ฌธ์๊ฐ ๋๋ค๋๊ฑฐ...
์์ถ๋ ฅ ์
n | result |
---|---|
24 | [1, 2, 3, 4, 6, 8, 12, 24] |
29 | [1,29] |
์
์ถ๋ ฅ ์ ์ค๋ช
24์ ์ฝ์๋ฅผ ์ค๋ฆ์ฐจ์์ผ๋ก ๋ด์ ๋ฐฐ์ด [1, 2, 3, 4, 6, 8, 12, 24]๋ฅผ returnํฉ๋๋ค.
29์ ์ฝ์๋ฅผ ์ค๋ฆ์ฐจ์์ผ๋ก ๋ด์ ๋ฐฐ์ด [1, 29]๋ฅผ returnํฉ๋๋ค.
๋์ ํ์ด
package programmers;
import java.util.ArrayList;
public class Divisor {
public static int[] solution(int n) {
int cnt = 0;
ArrayList<Integer> value = new ArrayList<>();
while(true) {
cnt++;
if( n % cnt == 0) {
System.out.println(cnt);
value.add(cnt);
}else if (cnt > n) {
break;
}
}
int[] answer = new int[value.size()];
for(int i = 0; i<value.size(); i++) {
answer[i]= value.get(i);
}
return answer;
}
public static void main(String[] args) {
solution(24);
}
}
๋์ ํ์ด
๋งค๊ฐ๋ณ์ n
์ ์ฝ์๋ฅผ ์ฐพ๋๊ฑฐ๋ ์ฝ๊ฒ ์ฐพ์๋๋ฐ, int[] answer = {};
์ ๋งค๊ฐ๋ณ์ n์ ์ฝ์๋ฅผ ์ด๋ป๊ฒ ๋ฃ์ ๊ฒ์ธ๊ฐ์ ๋ํด ์๊ฐ์ ๋ง์ด ํ์๋ค. ArrayList๋ add()
๋ฉ์๋๊ฐ ์๊ธฐ๋๋ฌธ์ ์ด ๋ฉ์๋๋ฅผ ์ฐ๋ฉด ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ๋ฐ๋ก ์ถ๊ฐ ํ ๋นํ์ง์์๋ ๋ฐฐ์ด์ ์ถ๊ฐ ๋๋ ์ฅ์ ์ด ์์ด, ArrayList์ ์ฝ์๋ฅผ ๋ฃ๊ณ , ๋ค์ int[] answer
์ ์ถ๊ฐ ํด์ฃผ๋ ๋ฐฉ๋ฒ์ ์ผ๋ค. ์ด์ฐ ์ด์ฐ ํ
์คํธ ์กฐ๊ฑด์ ๋ชจ๋ ๋ถํฉํ๊ฒ ํ๊ธด ํ๋๋ฐ, ๊ทธ๋ ๊ฒ ๊ด์ฐฎ์ ์ฝ๋๋ ์๋๊ฑฐ ๊ฐ๋ค.
์ด๋ ๊ฒ๋ ํ ์ ์๋ค
import java.util.*;
class Solution {
public ArrayList<Integer> solution(int n) {
ArrayList<Integer> answer = new ArrayList<Integer>();
for(int i=1; i<=n; i++){
if(n % i == 0) answer.add(i);
}
return answer;
}
}
public static int[] solution(int n) { }
int[] ํ ๋ฉ์๋ ๋์ ArrayList<Integer> solution(int n) { }
๋ฉ์๋๋ฅผ ์จ์ , int[] ๋ฐฐ์ด์ ๋ค์ ๋ด์๋ ค๊ณ ํ์ง ์๊ณ , ๋ฐ๋ก ArrayList์ n % i == 0
์ ๊ฒฐ๊ณผ๋ฅผ ๋ด์ return ํ๋ ๋ฐฉ๋ฒ์ ์ฌ์ฉ
import java.util.Arrays;
public class Divisor {
public static int[] solution(int n) {
int[] answer = new int[n];
int idx = 0;
for (int i = 1; i <= n; i++) {
if (n % i == 0) {
answer[idx++] = i;
}
}
return Arrays.copyOf(answer, idx);
}
public static void main(String[] args) {
int[] result = Divisor.solution(24);
System.out.println(Arrays.toString(result));
}
}
๋ฉ์๋ ๋ด์
ArrayList
๋ฅผ ์ฌ์ฉํ์ง ์๊ณ , ๋ฐฐ์ด๋ง์ผ๋ก ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์์
๋ฐฐ์ด์ ์ฌ์ฉํ๋ฉดArrayList
๋ณด๋ค ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ด ์ ๊ณ , ์ฝ๋๋ ๊ฐ๊ฒฐํด์ง
answer
๋ฐฐ์ด์ ์ ์ธํ๊ณ ,idx
๋ณ์๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ์ ํ ๋น,n
์ด ์ฃผ์ด์ง ์ ๋ณด๋ค ํด ์ ์์ผ๋ฏ๋ก,anwer
๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผn
์ผ๋ก ์ค์ . ๊ทธ๋ฐ ๋ค์, 1๋ถํฐn
๊น์ง ๋ฐ๋ณตํ๋ฉด์n
์ ์ฝ์์ธ ๊ฒฝ์ฐ์๋งanswer
๋ฐฐ์ด์ ๊ฐ์ ํ ๋น
Arrays.copyof()
๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ฉด ๋ถํ์ํ 0 ๊ฐ์ด ๋ค์ด ์๋ ๋ฐฐ์ด์ ์๋ก์ด ๋ฐฐ์ด๋ก ๋ณต์ฌํ์ฌ ๋ฐํ
์ฌ์ฉ๋ฒ
copyof(original, int newLength)
original
๋งค๊ฐ๋ณ์๋ ๋ณต์ฌํ ์๋ณธ ๋ฐฐ์ดnewLength
๋งค๊ฐ๋ณ์๋ ์๋ก์ด ๋ฐฐ์ด์ ๊ธธ์ดoriginal
๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ์์๋ถํฐ newLength
๊ธธ์ด๊น์ง์ ์์๋ฅผ ๋ณต์ฌํ ์๋ก์ด ๋ฐฐ์ด์ ๋ฐํ. ๋ง์ฝ, newLength
๊ฐ original
๋ฐฐ์ด์ ๊ธธ์ด๋ณด๋ค ์์ ๊ฒฝ์ฐ original
๋ฐฐ์ด์ ์ผ๋ถ ์์๋ง ๋ณต์ฌ๋๋ฉฐ, ์๋ก์ด ๋ฐฐ์ด์ ๋๋จธ์ง ์์๋ ์๋์ผ๋ก ์ด๊ธฐํ์
์ถ๋ ฅ ์
num | k | result |
---|---|---|
29183 | 1 | 3 |
232443 | 4 | 4 |
123456 | 7 | -1 |
์
์ถ๋ ฅ ์ ์ค๋ช
๋์ ํ์ด
class Solution {
public int solution(int num, int k) {
String strNum = num + "";
String digit = k + "";
int index = strNum.indexOf(digit);
if (index == -1) {
return -1;
} else {
return index + 1;
}
}
}
๋์ ์๊ฐ
์๊ฐ๋ณด๋ค ์์ฒญ ๊ณ ๋ฏผ์ ๋ง์ด ํ๋ ๋ฌธ์ ์๋๊ฑฐ ๊ฐ๋ค.
public static int solution(int num, int k) {
int answer = 0;
int[] trans = new int[num];
for(int i = 0; i < trans.length; i++) {
trans[i] = num % 10;
num /= 10;
}
for(int i = 0; i < trans.length; i++) {
if(trans[i] == k) {
answer = trans[i];
break;
}else {
answer = -1;
}
}
์ฒ์์ ๋ด๊ฐ ์๊ฐํ๋ ๋ฐฉ๋ฒ์, ๋งค๊ฐ๋ณ์ num์ ๋ด์ intํ ๋ฐฐ์ด์ ์ ์ธํ์ฌ num ์ 10์ผ๋ก ๋๋ ๋๋จธ์ง๋ฅผ ๋ฐฐ์ด์ ๊ฐ๊ฐ ๋ฃ๋ ๋ฐฉ๋ฒ์ ์ผ์๋๋ฐ, int[] trans = new int[num]
์์ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ num์ผ๋ก ์ก์ ์์ ๋ถํฐ ์ค๋ฅ๋ฅผ ๋ฒํ๋ค. ์๋ฅผ๋ค์ด, ์ซ์๊ฐ 29831
์ผ๊ฒฝ์ฐ, ๋ด๊ฐ ์ํ๋๊ฒ์ 29831์ผ์ ์ ์ฒด ๊ธธ์ด, ์ฆ,5
๋ฅผ ์ํ๋ ๊ฒ์ธ๋ฐ, ๋ฐฐ์ด ์ ์ฒด์ ํฌ๊ธฐ๊ฐ 29831๋ก ์กํ๋ ์ค๋ฅ๋ฅผ... ๊ทธ๋ฆฌ๊ณ ๋ฌด์๋ณด๋ค ์น๋ช
์ ์ธ ์ค์๋
for(int i = 0; i < trans.length; i++) {
trans[i] = num % 10;
num /= 10;
}
์์ ์ซ์ 29831
์ด๋ผ๊ณ ํ ๋, ์ค์ ๋ก ๋ฐฐ์ด์๋
trans[0] = 1;
trans[1] = 3;
trans[2] = 8;
trans[3] = 9;
trans[4] = 2;
๊ฑฐ๊พธ๋ก ํ ๋น๋๊ธฐ๋๋ฌธ์, ๋ค์ ๋ค์ง์ด์ค์ผํ๋ ๋ฒ๊ฑฐ๋ก์์ด ๋ฐ์ํ๋ค.
์ฒ์๋ถํฐ ๋ค์ ์๊ฐํ์ฌ, intํ ๋ณ์๋ฅผ ์ฝ๊ฒ ๋ฌธ์ํ์ผ๋ก ๋ณํํ๋ ์ซ์
+
""
๋ฐฉ๋ฒ์ ์ฌ์ฉํ์ฌ
String strNum = num + "";
String digit = k + "";
int index = strNum.indexOf(digit);
if (index == -1) {
return -1;
} else {
return index + 1;
}
๋ฌธ์ํ์์ indexOf() ๋ฉ์๋
๋ฅผ ์ฌ์ฉํ์ฌ ์๋ฆฟ์์ ํด๋นํ๋ ๋ฌธ์๋ฅผ ๊ฒ์ถํ์ฌ, -1
์ผ ๊ฒฝ์ฐ,
์ฆ, indexOf(digit)
์์ ์ผ์นํ๋ ๋ฌธ์๊ฐ ์์ ๊ฒฝ์ฐ -1
์ ๋ฐํ return -1์, ๊ทธ๋ ์ง์์ผ๋ฉด strNum.indexOf(digit)+1
์ ๋ฐํํ์๋ค, ์ฌ๊ธฐ์ indexOf(digit)+1
์ ํ๋ ์ด์ ๋
strNum[0]๋ถํฐ ์์ํ๊ธฐ๋๋ฌธ์ +1
์ ํ์ฌ ์๋ฆฌ์๋ฅผ ๋ง์ถฐ์ค์ผํ๋ค!
์
์ถ๋ ฅ ์
my_string | result |
---|---|
"Bcad" | "abcd" |
"heLLo" | "ehllo" |
"Python" | "hnopty |
์
์ถ๋ ฅ ์ ์ค๋ช
๋์ ํ์ด
package ํ๋ก๊ทธ๋๋จธ์ค;
import java.util.Arrays;
public class SortString {
public static String solution(String my_string) {
String answer = "";
for(int i= 0; i<my_string.length(); i++) {
char ch = my_string.charAt(i);
if(ch>=65 && ch <= 90) {
answer += (char)(ch+32);
}else {
answer += (char)(ch);
}
}
char[] chars = answer.toCharArray();
Arrays.sort(chars);
String sortedAnswer = new String(chars);
return sortedAnswer;
}
public static void main(String[] args) {
String my_string = "Python";
solution(my_string);
}
}
๋์ ์๊ฐ
๋,์๋ฌธ์ ๋ณํ์ char
ํ ๋ณ์๋ฅผ ์ ์ธํ์ฌ ์ด๋ฅผ ์์คํค์ฝ๋ ํ ์ ๋๋ฌธ์์ ํด๋นํ๋ 10์ง์๋ฅผ ํ๋ณํ์ฌ, ๋๋ฌธ์๋ ์๋ฌธ์๋ก ๋ณํํ๊ณ , ์๋ฌธ์๋ ๊ทธ๋๋ก ์ฌ์ฉํ์๋ค,
๊ทธ ํ, ๋ฌธ์์ด์ char
ํ ๋ฐฐ์ด๋ก ์ ์ธํ์ฌ, ๋ฌธ์์ด์ charํ ๋ฐฐ์ด๋ก ๋ณํํ์ฌ, sort๋ฅผ ๋๋ ค
์๋ก์ด String sortedAnswer์ ์๋ก ๋ด๋ ๋ฐฉ๋ฒ์ ์ฌ์ฉํ์๋ค.
๋ ๋์ ํ์ด
import java.util.*;
class Solution {
public String solution(String my_string) {
char[] c = my_string.toLowerCase().toCharArray();
Arrays.sort(c);
return new String(c);
}
}
๋ด๊ฐ ์ฌ์ฉํ ๋ฐฉ๋ฒ | ํ ์ค๋ก ํํํ ๋ฐฉ๋ฒ |
---|---|
![]() | ![]() |
์
์ถ๋ ฅ ์
n | result |
---|---|
10 | 5 |
15 | 8 |
์
์ถ๋ ฅ ์ ์ค๋ช
๋์ ํ์ด
package ํ๋ก๊ทธ๋๋จธ์ค;
public class CompositeNumber {
public static int solution(int n) {
int answer = 0;
int cnt = 0;
for(int i = 1; i <= n; i++) {
for(int j = 1; j <= i; j++ ) {
if(i % j == 0) {
cnt++;
}
}
if(cnt >= 3) {
answer++;
}
cnt = 0;
}
return answer;
}
public static void main(String[] args) {
solution(4);
}
}
๋์ ์๊ฐ
์ ์ฒด์ ์ผ๋ก ๋งค๊ฐ๋ณ์ n๋ฒ ๋ฐ๋ณต์ ๋๋ฆฌ๊ณ , ๋ฐ๋ณต๋ฌธ ์์์ ๋ฐ๋ณต๋ฌธ์ ํ๋ฒ๋ ์คํํ์ฌ, if(i % j == 0)
๋ฅผ ํตํด ๋๋จธ์ง๊ฐ 0์ผ๋ก ๋จ์ด์ง๋ ์ฆ, ์ฝ์๊ฐ ๋ช ๊ฐ ์ธ์ง ํ๋ณํ๋ค, ํ๋ณํ ๊ฒฐ๊ณผ๋ฅผ cnt์ ๋ด์, cnt์ ์๊ฐ 3๊ฐ ์ด์์ด๋ฉด, ํฉ์ฑ์๋ฅผ ์นด์ดํธํ๋ answer
์ ์ฆ๊ฐ์์ผ ์ต์ข
์ ์ผ๋ก answer
์ ๋ฐํํ๋ค.