ํฐ ์ A+B ๋ฌธ์ ๋ ์ ์ A์ B๋ฅผ ์ ๋ ฅ๋ฐ์ ๋ค์, A+B๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ์ ๋ ฅ ์ฒซ์งธ ์ค์ A์ B๊ฐ ์ฃผ์ด์ง๋ค. (0 < A,B < 1010000) ์ถ๋ ฅ ์ฒซ์งธ ์ค์ A+B๋ฅผ ์ถ๋ ฅํ๋ค. ์ฒ์์ ๋จ์ํ ๊ทธ๋ฅ ๋ง์ ๋ฌธ์ ์ธ์ค์์๋๋ฐ, ๋ฐํ์์๋ฌ๊ฐ ๋ ์ ์์ธํ๋ณด๋ Longํ์ ์ ๋ฒ์๋ ๋์ด์ ๊ฐ์ ์ถ๋ ฅํ๊ธฐ๋๋ฌธ์ BigInteger ๋ฅผ ์ด์ฉํด์ผํ๋ค. import java.io.BufferedReader; import java.io.InputStreamReader; import java.math.BigInteger; import java.io.IOException; import java.util.*; public class Main { public static void main(String[] a..
๋ฌธ์ ์ค๋ช ๋ฐฐ์ด arr๊ฐ ์ฃผ์ด์ง๋๋ค. ๋ฐฐ์ด arr์ ๊ฐ ์์๋ ์ซ์ 0๋ถํฐ 9๊น์ง๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค. ์ด๋, ๋ฐฐ์ด arr์์ ์ฐ์์ ์ผ๋ก ๋ํ๋๋ ์ซ์๋ ํ๋๋ง ๋จ๊ธฐ๊ณ ์ ๋ถ ์ ๊ฑฐํ๋ ค๊ณ ํฉ๋๋ค. ๋จ, ์ ๊ฑฐ๋ ํ ๋จ์ ์๋ค์ ๋ฐํํ ๋๋ ๋ฐฐ์ด arr์ ์์๋ค์ ์์๋ฅผ ์ ์งํด์ผ ํฉ๋๋ค. ์๋ฅผ ๋ค๋ฉด, arr = [1, 1, 3, 3, 0, 1, 1] ์ด๋ฉด [1, 3, 0, 1] ์ return ํฉ๋๋ค. arr = [4, 4, 4, 3, 3] ์ด๋ฉด [4, 3] ์ return ํฉ๋๋ค. ๋ฐฐ์ด arr์์ ์ฐ์์ ์ผ๋ก ๋ํ๋๋ ์ซ์๋ ์ ๊ฑฐํ๊ณ ๋จ์ ์๋ค์ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์. ์ ํ์ฌํญ ๋ฐฐ์ด arr์ ํฌ๊ธฐ : 1,000,000 ์ดํ์ ์์ฐ์ ๋ฐฐ์ด arr์ ์์์ ํฌ๊ธฐ : 0๋ณด๋ค ํฌ๊ฑฐ๋ ..
๋ฌธ์ ์ค๋ช ํ๋ก๊ทธ๋๋จธ์ค ๋ชจ๋ฐ์ผ์ ๊ฐ์ธ์ ๋ณด ๋ณดํธ๋ฅผ ์ํด ๊ณ ์ง์๋ฅผ ๋ณด๋ผ ๋ ๊ณ ๊ฐ๋ค์ ์ ํ๋ฒํธ์ ์ผ๋ถ๋ฅผ ๊ฐ๋ฆฝ๋๋ค. ์ ํ๋ฒํธ๊ฐ ๋ฌธ์์ด phone_number๋ก ์ฃผ์ด์ก์ ๋, ์ ํ๋ฒํธ์ ๋ท 4์๋ฆฌ๋ฅผ ์ ์ธํ ๋๋จธ์ง ์ซ์๋ฅผ ์ ๋ถ *์ผ๋ก ๊ฐ๋ฆฐ ๋ฌธ์์ด์ ๋ฆฌํดํ๋ ํจ์, solution์ ์์ฑํด์ฃผ์ธ์. ์ ํ ์กฐ๊ฑด phone_number๋ ๊ธธ์ด 4 ์ด์, 20์ดํ์ธ ๋ฌธ์์ด์ ๋๋ค. ์ ์ถ๋ ฅ ์ "01033334444" "*******4444" "027778888" "*****8888" class Solution { public String solution(String phone_number) { String answer=""; for(int i=0; i
๋ฌธ์ ์ค๋ช Stringํ ๋ฐฐ์ด seoul์ element์ค "Kim"์ ์์น x๋ฅผ ์ฐพ์, "๊น์๋ฐฉ์ x์ ์๋ค"๋ String์ ๋ฐํํ๋ ํจ์, solution์ ์์ฑํ์ธ์. seoul์ "Kim"์ ์ค์ง ํ ๋ฒ๋ง ๋ํ๋๋ฉฐ ์๋ชป๋ ๊ฐ์ด ์ ๋ ฅ๋๋ ๊ฒฝ์ฐ๋ ์์ต๋๋ค. ์ ํ ์ฌํญ seoul์ ๊ธธ์ด 1 ์ด์, 1000 ์ดํ์ธ ๋ฐฐ์ด์ ๋๋ค. seoul์ ์์๋ ๊ธธ์ด 1 ์ด์, 20 ์ดํ์ธ ๋ฌธ์์ด์ ๋๋ค. "Kim"์ ๋ฐ๋์ seoul ์์ ํฌํจ๋์ด ์์ต๋๋ค. ์ ์ถ๋ ฅ ์seoulreturn ["Jane", "Kim"] "๊น์๋ฐฉ์ 1์ ์๋ค" 0๋ฒ ์ธ๋ฑ์ค๋ถํฐ ๋๋ฉด์ "Kim"์ ์ฐพ์ผ๋ฉด ํด๋น ์ธ๋ฑ์ค์ ์์น๋ฅผ ๋ฐํํ๋ ๊ฐ๋จํ ๋ฌธ์ . * ์ฃผ์ํ ์ ์, ๋ฌธ์์ด์ ๋น๊ต๋ ==๊ฐ ์๋ equals๋ฅผ ์ฌ์ฉํ ๊ฒ. ๋๊ฐ์ ๋ฌธ์์ด์ด์ด๋ =..
๋ฌธ์ ์ค๋ช ์์ ์ ์ x๊ฐ ํ์ค๋ ์์ด๋ ค๋ฉด x์ ์๋ฆฟ์์ ํฉ์ผ๋ก x๊ฐ ๋๋์ด์ ธ์ผ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด 18์ ์๋ฆฟ์ ํฉ์ 1+8=9์ด๊ณ , 18์ 9๋ก ๋๋์ด ๋จ์ด์ง๋ฏ๋ก 18์ ํ์ค๋ ์์ ๋๋ค. ์์ฐ์ x๋ฅผ ์ ๋ ฅ๋ฐ์ x๊ฐ ํ์ค๋ ์์ธ์ง ์๋์ง ๊ฒ์ฌํ๋ ํจ์, solution์ ์์ฑํด์ฃผ์ธ์. ์ ํ ์กฐ๊ฑด x๋ 1 ์ด์, 10000 ์ดํ์ธ ์ ์์ ๋๋ค. ์ ์ถ๋ ฅ ์ 10 true 12 true 11 false 13 false ์ ์ถ๋ ฅ ์ ์ค๋ช ์ ์ถ๋ ฅ ์ #1 10์ ๋ชจ๋ ์๋ฆฟ์์ ํฉ์ 1์ ๋๋ค. 10์ 1๋ก ๋๋์ด ๋จ์ด์ง๋ฏ๋ก 10์ ํ์ค๋ ์์ ๋๋ค. ์ ์ถ๋ ฅ ์ #2 12์ ๋ชจ๋ ์๋ฆฟ์์ ํฉ์ 3์ ๋๋ค. 12๋ 3์ผ๋ก ๋๋์ด ๋จ์ด์ง๋ฏ๋ก 12๋ ํ์ค๋ ์์ ๋๋ค. ์ ์ถ๋ ฅ ์ #3 11์ ๋ชจ๋ ์๋ฆฟ์์ ํฉ์ 2์ ๋๋ค. 11์..
๋ฌธ์ ์ค๋ช 1937๋ Collatz๋ ์ฌ๋์ ์ํด ์ ๊ธฐ๋ ์ด ์ถ์ธก์, ์ฃผ์ด์ง ์๊ฐ 1์ด ๋ ๋๊น์ง ๋ค์ ์์ ์ ๋ฐ๋ณตํ๋ฉด, ๋ชจ๋ ์๋ฅผ 1๋ก ๋ง๋ค ์ ์๋ค๋ ์ถ์ธก์ ๋๋ค. ์์ ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค. 1-1. ์ ๋ ฅ๋ ์๊ฐ ์ง์๋ผ๋ฉด 2๋ก ๋๋๋๋ค. 1-2. ์ ๋ ฅ๋ ์๊ฐ ํ์๋ผ๋ฉด 3์ ๊ณฑํ๊ณ 1์ ๋ํฉ๋๋ค. 2. ๊ฒฐ๊ณผ๋ก ๋์จ ์์ ๊ฐ์ ์์ ์ 1์ด ๋ ๋๊น์ง ๋ฐ๋ณตํฉ๋๋ค. ์๋ฅผ ๋ค์ด, ์ฃผ์ด์ง ์๊ฐ 6์ด๋ผ๋ฉด 6 → 3 → 10 → 5 → 16 → 8 → 4 → 2 → 1 ์ด ๋์ด ์ด 8๋ฒ ๋ง์ 1์ด ๋ฉ๋๋ค. ์ ์์ ์ ๋ช ๋ฒ์ด๋ ๋ฐ๋ณตํด์ผ ํ๋์ง ๋ฐํํ๋ ํจ์, solution์ ์์ฑํด ์ฃผ์ธ์. ๋จ, ์ฃผ์ด์ง ์๊ฐ 1์ธ ๊ฒฝ์ฐ์๋ 0์, ์์ ์ 500๋ฒ ๋ฐ๋ณตํ ๋๊น์ง 1์ด ๋์ง ์๋๋ค๋ฉด –1์ ๋ฐํํด ์ฃผ์ธ์. ์ ํ ์ฌํญ ์ ๋ ฅ..
class Solution { public int solution(int n) { int answer = 0; for(int i=1; i
for each๋ฌธ์ผ๋ก ๋๋ฉด์ p์ y์ ๊ฐ์๋ฅผ ๊ฐ๊ฐ count ํ๋ ๋ฐฉ์์ผ๋ก ํ์๋๋ฐ, ๋ค๋ฅธ ์ฌ๋์ ์ฝ๋๋ฅผ ๋ณด๋ ๋ณ์ ํ๋๋ง ์ด์ฉํด์ ++, --์ด์ฉํด์ count==0 ์ด๋๊ณ ํ๋๊ฒ์ด ๋ ์ข์ ์ฝ๋๊ฐ์๋ค. ( ํจ์ฌ ๋ ์ข์ ์ฝ๋๋ ์์ง ๋ฌด๋ฆฌ... ) class Solution { boolean solution(String s) { boolean answer=true; int p=0; int y=0; for(char x:s.toLowerCase().toCharArray()){ if(x=='p') p++; else if(x=='y') y++; } if(p==y) return answer; else return false; } }