์
์ถ๋ ฅ ์
my_string | result |
---|---|
"people" | "peol" |
"We are the world" | "We arthwold" |
์
์ถ๋ ฅ ์ ์ค๋ช
๋์ ํ์ด
package ํ๋ก๊ทธ๋๋จธ์ค;
import java.util.LinkedHashSet;
public class DuplicateCharacter {
public static String solution(String my_string) {
String answer = "";
String[] oldArray = my_string.split("");
LinkedHashSet<String> DupRemoveArray = new LinkedHashSet<>();
for(int i = 0; i < my_string.length();i++) {
DupRemoveArray.add(oldArray[i]);
}
for(String str : DupRemoveArray) {
answer += str;
}
return answer;
}
public static void main(String[] args) {
solution("We are the world");
}
}
๋์ ์๊ฐ
๋ฌธ์์ด my_string์ split() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ ๋ฌธ์๋ฅผ ๋ถ๋ฆฌํ ํ, String[] ๋ฐฐ์ด oldArray์ ์ ์ฅํ๋ค.
์ค๋ณต์ ์ ๊ฑฐํ๊ธฐ ์ํด ์ปฌ๋ ์ (Collection) ์๋ฃ๊ตฌ์กฐ ์ค ํ๋์ธ Set์ ์ฌ์ฉํ๋ค. ๋ํ ์๋ ๋ฌธ์์ด์ ์์๋ฅผ ์ ์งํด์ผ ํ๊ธฐ ๋๋ฌธ์, LinkedHashSet์ ์ฌ์ฉํ๋ค. ์ด๋ฅผ DupRemoveArray๋ผ๋ ๋ณ์์ ํ ๋นํ๋ค.
oldArray์ ๊ฐ ์์๋ฅผ ์ํํ๋ฉฐ, DupRemoveArray์ ์ถ๊ฐํ๋ค. ์ด ๊ณผ์ ์์ LinkedHashSet์ ํน์ฑ์ผ๋ก ์ธํด ์์๋ ์ ์ง๋๋ฉด์ ์ค๋ณต๋ ๋ฌธ์๋ ์ ๊ฑฐ๋๋ค.
๋ง์ง๋ง์ผ๋ก DupRemoveArray๋ฅผ ๋ฐ๋ณตํ์ฌ ๋ฌธ์์ด ํ์ ์ answer ๋ณ์์ ์์๋ค์ ํ๋์ฉ ์ถ๊ฐํ๋ค. ์ด๋ ๊ฒ ํ๋ฉด ์๋ ๋ฌธ์์ด์ ์์๋ฅผ ์ ์งํ๋ฉด์ ์ค๋ณต๋ ๋ฌธ์๊ฐ ์ ๊ฑฐ๋ ๊ฒฐ๊ณผ๋ฅผ ์ป์ ์ ์๋ค.
๋ ํด๋ฆฐํ ์ฝ๋
class Solution {
public String solution(String my_string) {
String answer = "";
for(int i=0; i<my_string.length(); i++){
if(i==my_string.indexOf(my_string.charAt(i)))
answer+=my_string.charAt(i);
}
return answer;
}
}
์ด๊ฒ ์ด๋ป๊ฒ ๋์๊ฐ๋์ง ํ์ฐธ ์๊ฐํ ๋ค์ ์... ์ด๊ฑธ ์ด๋ ๊ฒ ํ์ด??? ๋ผ๋ ์๊ฐ์ ํ๊ฒ ๋๋ค..
๋๋ ๋ฌธ์ํ ๋ณ์๋ฅผ ๋ฐฐ์ด์ ๋ด์ ์๊ฐ์ ๋จผ์ ํ๋๋ฐ, ์ฌ๊ธฐ์๋ my_string.indexOf
๋ฉ์๋๋ฅผ ํ์ฉํ์ฌ indexOf(my_string.charAt(i))
๋ฅผ ๋ฃ๊ณ i์ ๊ฐ์ผ๋ฉด, anwer์ ์ถ๊ฐ, ์๋๋ฉด ๋์ด๊ฐ๋ ๋ฐฉ๋ฒ์ ์ฌ์ฉํ์๋ค.
์๋ฅผ๋ค์ด, APPLE
๋ผ๋ ๋ฌธ์๊ฐ ์์๋, i=0, my_string.charAt(0) = A
์ด๊ณ indexOf(A)
๋ ๋ค์ 0 ์ด๋ฏ๋ก i = 0 = 0 ์ด ์ผ์น ํ๊ธฐ๋๋ฌธ์ answer ์ ์ถ๊ฐ, i=1, my_string.charAt(1) = P
์ด๊ณ indexOf(P)
๋ 1์ด๋ฏ๋ก, i = 1 = 1 ์ผ์นํ๊ธฐ ๋๋ฌธ์ answer์์ถ๊ฐ, i=2, my_string.charAt(2) = P
์ด๊ณ indexOf(p)
๋ 1์ด๋ฏ๋ก, i = 2 = 1 ๋ก ๋ถ์ผ์น ํ๊ธฐ๋๋ฌธ์ ์ค๋ณต์ ๊ฑธ๋ฌ์ฃผ๋ ๋ฐฉ๋ฒ์ด๋ค. ์๋ฆ๋ต๋ค....
๋ชจ์ค๋ถํธ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
morse = {
'.-':'a','-...':'b','-.-.':'c','-..':'d','.':'e','..-.':'f',
'--.':'g','....':'h','..':'i','.---':'j','-.-':'k','.-..':'l',
'--':'m','-.':'n','---':'o','.--.':'p','--.-':'q','.-.':'r',
'...':'s','-':'t','..-':'u','...-':'v','.--':'w','-..-':'x',
'-.--':'y','--..':'z'
}
์
์ถ๋ ฅ ์
letter | result |
---|---|
".... . .-.. .-.. ---" | "hello" |
".--. -.-- - .... --- -." | "python" |
์
์ถ๋ ฅ ์ ์ค๋ช
.... = h
. = e
.-.. = l
.-.. = l
--- = o
๋ฐ๋ผ์ "hello"๋ฅผ return ํฉ๋๋ค.
a ~ z์ ํด๋นํ๋ ๋ชจ์ค๋ถํธ๊ฐ ์์๋๋ก ๋ด๊ธด ๋ฐฐ์ด์ ๋๋ค.
{".-","-...","-.-.","-..",".","..-.",
"--.","....","..",".---","-.-",".-..",
"--","-.","---",".--.","--.-",".-.",
"...","-","..-","...-",".--","-..-",
"-.--","--.."}
๋์ ํ์ด
package programmers;
public class MorseCode {
public static String solution(String letter) {
String[] Morse = {".-","-...","-.-.","-..",".","..-.","--.","....",
"..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.",
"...","-","..-","...-",".--","-..-","-.--","--.."};
String[] convert = letter.split(" ");
String answer = "";
for(int i = 0; i < convert.length; i++) {
for(int j = 0; j < Morse.length; j++) {
if(convert[i].equals(Morse[j])) {
char letterChar = (char)(j + 97);
answer += Character.toString(letterChar);
}
}
}
return answer;
}
public static void main(String[] args) {
solution(".--. -.-- - .... --- -.");
}
}
๋์ ํ์ด
Morse ๋ถํธ๋ฅผ ์ผ๋จ String[] ๋ฐฐ์ด๋ก ๋จผ์ ์ก๊ณ , ๋ฌธ์์ด letter์ ํ๊ธ์ ์ฉ splitํ์ฌ ์ด ๋ ๋ฐฐ์ด์ ๋น๊ตํด์ผ๊ฒ ๋ค๋ผ๊ณ ๋จผ์ ์๊ฐ์ ํจ...์ด์ค for๋ฌธ์ผ๋ก convert[0].equals(Morse[0~25]) ๋ฐ๋ณต์ ๋๋ ค, ์๋ก ์ผ์นํ๋ ๊ฐ์ ์ธ๋ฑ์ค๋ฅผ ์ฐพ์ผ๋ฉด ๋๊ฒ ๊ตฌ๋ ๊น์ง ์๊ฐ์ ํ์ง๋ง, ๋ฌธ์ ๋ ์ฌ๊ธฐ์ ๋ถํฐ... ์ธ๋ฑ์ค ๊ฐ์ด์ผ j ๊ฐ์ ์ถ์ถํ๋ฉด ๋๋๊น ๋ฌธ์ ์๋๋ฐ, ๋ชจ์ค ๋ถํธ๋ฅผ ์ํ๋ฒณ ์๋ฌธ์๋ก ๋ณํํ๋ ค๋ฉด ์์คํค ์ฝ๋๊ฐ์ผ๋ก ๋ง์ถฐ์ผ ํ๊ธฐ๋๋ฌธ์ charํ ๋ณ์์๋ค๊ฐ ๋ํด์ค์ผํ๋๋ฐ,,, intํ์ charํ์ผ๋ก ๋ค์ด ์บ์คํ
ํ๋ฉด ์ค๋ฅ๋จ๊ฒ ์ง? ๋ฅผ ๋จผ์ ์๊ฐ....์๋ฌธ์ a~z ๊น์ง ์์คํค ์ฝ๋ ๋ฒํธ 97~122๋ฒ ์ด๋๊น, j + 97์ด ๋ง๋์ง, j+'97'์ด ๋ง๋์ง ๊ณ ๋ฏผ์ ํ๋๋ฐ (char)(J+97) ํ๋ณํ ํ๋๊น... ๊ธ๋ฐฉ ํด๊ฒฐ๋๋ ๋ฌธ์ ! ๋ค์ Stringํ answer ๋ณ์์ char์ String์ผ๋ก ๋ณํํด์ ๋ฃ์ผ๋ฉด ๋ฌธ์ ํด๊ฒฐ!!!
๋ง์ฝ ์์คํค์ฝ๋ ๋ฒํธ a~z ๊ฐ์ด ๊ธฐ์ต ์๋๋ฉด
j +'a'
๋ฅผ ํด๋ ๊ฐ์ ๊ฒฐ๊ณผ๊ฐ ๋์จ๋ค
์
์ถ๋ ฅ ์
before | after | result |
---|---|---|
"olleh" | "hello" | 1 |
"allpe" | "apple" | 0 |
์
์ถ๋ ฅ ์ ์ค๋ช
๋์ ํ์ด
package ํ๋ก๊ทธ๋๋จธ์ค;
import java.util.ArrayList;
public class MakeBWithA {
public static int solution(String before, String after) {
String[] beforeList = before.split("");
String[] afterList = after.split("");
ArrayList<String> str = new ArrayList<>();
for(int i = 0; i < before.length(); i++) {
str.add(beforeList[i]);
}
for(int i = 0; i < before.length(); i++) {
if(str.contains(afterList[i])) {
str.remove(afterList[i]);
}
}
return str.isEmpty() ? 1 : 0;
}
public static void main(String[] args) {
solution("olleh","hello");
}
}
๋์ ์๊ฐ
์ด๋ป๊ฒ ๋ฌธ์ ๋ฅผ ํ๊ฒ์ธ๊ฐ๋ฅผ ๋๊ณ ์ฌ๋ฌ๊ฐ์ง ๋ฐฉ๋ฒ์ ์๊ฐํด๋ดค๋ค.
๋ฌธ์์ด before
์after
์ String[]
๋ฐฐ์ด์ ๋ค์ ๋ด์, before
๋๋ after
๋ฅผ ๋ค์ List
์ ๋ด์ํ , List๊ฐ๊ณผ ๋ฌธ์์ด ๊ฐ์ ๋น๊ตํ์ฌ, ํฌํจ๋๋ฉด List์์ ํฌํจ๋ ๊ฐ์ ์ ๊ฑฐ ํ๋ ๊ฒ์ผ๋ก, ๋ง์ฝ ๋ชจ๋ ๋ฌธ์๊ฐ ์ผ์น ํ๋ค๋ฉด []
๋น ๋ฐฐ์ด๋ง ์กด์ฌํ ๊ฒ์ด๊ณ , ๋ชจ๋ ๋ฌธ์๊ฐ ์ผ์นํ์ง ์์ผ๋ฉด [@,@]
๋ฐฐ์ด์์ ์ด๋ ํ ๊ฐ์ด ์กด์ฌํ ๊ฒ์ด๋ค. ๋ฐ๋ผ์, str
๋ฆฌ์คํธ๊ฐ ๋น๊ฐ์ธ๊ฐ?๋ฅผ ์ผํญ์ฐ์ฐ์
๋ฅผ ์ด์ฉํ์ฌ, ๋น๊ฐ์ด๋ฉด(๋ชจ๋ ๋ฌธ์๊ฐ ์ผ์นํ๋ฉด) 1, ๊ทธ๋ ์ง์์ผ๋ฉด 0 ์ ๋ฆฌํดํ๊ฒ ์ฝ๋๋ฅผ ๊ตฌ์ฑํ์๋ค.
์
์ถ๋ ฅ ์
n | result |
---|---|
3628800 | 10 |
7 | 3 |
์
์ถ๋ ฅ ์ ์ค๋ช
๋์ ์๊ฐ
package ํ๋ก๊ทธ๋๋จธ์ค;
public class Factorial {
public static int solution(int n) {
int answer = 0;
int[] factor = {1,2,6,24,120,720,5040,40320,362880,3628800};
for(int i = 0; i < 10; i++) {
if(factor[i] <= n) {
answer = i+1;
}
}
return answer;
}
public static void main(String[] args) {
solution(9999);
}
}
๋์ ์๊ฐ
์ฒ์์๋ while๋ฌธ ์์ ์กฐ๊ฑด์ ๋ง๋ค์ด ๋ฌธ์ ๋ฅผ ํ์๋๋ฐ, ๋ช ๊ฐ์ง ๋ฐ๋ก๊ฐ ์์ด, ๋ฐ๋ก ์ฒ๋ฆฌ๋ฅผ ๋ชปํ๋ ๋ฌดํ ๋ฃจํ์ ๋น ์ง๋ ๋ฌธ์ ์ ๋ด์ฐฉํ๋ค.
์์ ๊ฐ์ด factorial์ด 10!
๊น์ง๋ผ๊ณ ์ ํ์ด ์์ผ๋ ์ด๋ ๊ฒ ํ์์ง๋ง, ๋ง์ฝ 100! ๊น์ง๋ค.. ์ด๋ฌ๋ฉด ๋ค๋ฅธ ๋ฐฉ๋ฒ์ผ๋ก ๋ฌธ์ ๋ฅผ ํด๊ฒฐํด์ผํ ๊ฒ ๊ฐ๋ค. ์ข์ ํ์ด๋ ์๋๋ผ๊ณ ์๊ฐํ๋๋ฐ +5์ ์ ์ฃผ๊ธธ๋ ์กฐ๊ธ ์์์ค๋ฝ๋ค... ๋ณดํต ๋ด๊ฐ ๋ฌธ์ ํ๋ฉด +1,+2์ ์ฃผ๋๋ฐ...
์ด๋ฒ ๋ฌธ์ ๋ ์ต๋ํ ๋ฐ๋ก์ ๊ฑธ๋ฆฌ์ง ์๊ธฐ ์ํด, ์ต๋ํ ๊ฐ๋จํ๊ฒ ๋ฌธ์ ๋ฅผ ํ๋ ค๊ณ ๋ ธ๋ ฅํ๋ค. int[]ํ ๋ฐฐ์ด์ 10!๊น์ง์ ์๋ฅผ ์ ์ฅํ๊ณ ,
for๋ฌธ์ผ๋ก ๋ฐ๋ณต์ ๋๋ ค ๋งค๊ฐ๋ณ์n๊ฐ๊ณผ ๋น๊ตํ์ฌ factor[i] < = n
์ด๋ฉด answer = i+1
;์ ํ๋๋ฐ, for๋ฌธ์ int i = 0 ๋ถํฐ ์์ํ๊ธฐ๋๋ฌธ์, ํด๋นํ๋ index๋ฅผ ๊ตฌํ๊ธฐ ์ํด +1์ด ํ์ํ๋ค.
chatGPT ์ ์์ ๊ด์ฐฎ์ ํ์ด๋ผ๊ณ ...?
๋ค๋ฅธ ํ์ด
public static int solution(int n) {
int i = 1;
int factorial = 1;
while (factorial <= n) {
i++;
factorial *= i;
}
return i - 1;
}
- n = 7์ธ๊ฒฝ์ฐ
- i = 1, factorial = 1
- i = 2, factorial = 1 * 2 = 2
- i = 3, factorial = 2 * 3 = 6 (n๋ณด๋ค ์์)
- i = 4, factorial = 6 * 4 = 24 (n๋ณด๋ค ํผ)
- ๋ฐ๋ณต๋ฌธ์ ์ข ๋ฃํ๊ณ , i-1 = 4-1 = 3์ ๋ฐํ
num_list๊ฐ [1, 2, 3, 4, 5, 6, 7, 8] ๋ก ๊ธธ์ด๊ฐ 8์ด๊ณ n์ด 2์ด๋ฏ๋ก num_list๋ฅผ 2 * 4 ๋ฐฐ์ด๋ก ๋ค์๊ณผ ๊ฐ์ด ๋ณ๊ฒฝํฉ๋๋ค. 2์ฐจ์์ผ๋ก ๋ฐ๊ฟ ๋์๋ num_list์ ์์๋ค์ ์์์๋ถํฐ n๊ฐ์ฉ ๋๋ 2์ฐจ์ ๋ฐฐ์ด๋ก ๋ณ๊ฒฝํฉ๋๋ค.
์
์ถ๋ ฅ ์
num_list | n | result |
---|---|---|
[1, 2, 3, 4, 5, 6, 7, 8] | 2 | [[1, 2], [3, 4], [5, 6], [7, 8]] |
[100, 95, 2, 4, 5, 6, 18, 33, 948] | 3 | [[100, 95, 2], [4, 5, 6], [18, 33, 948]] |
์
์ถ๋ ฅ ์ ์ค๋ช
๋์ ์๊ฐ
package programmers;
public class MakeNDArray {
public static int[][] solution(int[] num_list, int n) {
int[][] answer = new int[num_list.length/n][n];
int cnt = 0;
for(int i = 0; i < num_list.length/n; i++) {
for(int j = 0; j<n; j++) {
answer[i][j] = num_list[cnt++];
}
}
return answer;
}
public static void main(String[] args) {
int[] num_list = {1, 2, 3, 4, 5, 6, 7, 8};
solution(num_list,2);
}
}
๋์ ์๊ฐ
๊ธฐ๋ณธ์ ์ผ๋ก 1์ฐจ์ ๋ฐฐ์ด์ 2์ฐจ์ ๋ฐฐ์ด๋ก ๋ณํํ๋ ๋ฐฉ๋ฒ์ ๋ฌป๋ ๋ฌธ์ ์ด๋ค.
num_list
์ ๋ฐฐ์ด ๊ธธ์ด์ ๋งค๊ฐ๋ณ์ n
์ผ๋ก ๋๋ ๋ชซ์ ํ์ ํฌ๊ธฐ
๋ก, ๋งค๊ฐ๋ณ์ n
์ ์ด์ ํฌ๊ธฐ
๋ก ํ๋ 2์ฐจ์ ๋ฐฐ์ด์ ์ ์ธํ๋ค. ์ด์ค for๋ฌธ์ผ๋ก ๋ฐ๊นฅ์ชฝ for๋ฌธ์ ์ด์ ํฌ๊ธฐ ๋งํผ ๋ฐ๋ณต, ์์ชฝ for๋ฌธ์ ํ์ ํฌ๊ธฐ๋งํผ ๋ฐ๋ณต์ ๋๋ ค, num_list์ index์ ํด๋นํ๋ ๊ฐ์ ๋์
ํ๋ ๋ฐฉ๋ฒ์ผ๋ก ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ์๋ค.