Programmers #4

์ด๊ฐ•์šฉยท2023๋…„ 2์›” 9์ผ
0

Programmers

๋ชฉ๋ก ๋ณด๊ธฐ
4/58

์‚ผ๊ฐํ˜•์˜ ์™„์„ฑ์กฐ๊ฑด (1)

๐Ÿ“‘1) ์„ ๋ถ„ ์„ธ ๊ฐœ๋กœ ์‚ผ๊ฐํ˜•์„ ๋งŒ๋“ค๊ธฐ ์œ„ํ•ด์„œ๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™์€ ์กฐ๊ฑด์„ ๋งŒ์กฑํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.๊ฐ€์žฅ ๊ธด ๋ณ€์˜ ๊ธธ์ด๋Š” ๋‹ค๋ฅธ ๋‘ ๋ณ€์˜ ๊ธธ์ด์˜ ํ•ฉ๋ณด๋‹ค ์ž‘์•„์•ผ ํ•ฉ๋‹ˆ๋‹ค.์‚ผ๊ฐํ˜•์˜ ์„ธ ๋ณ€์˜ ๊ธธ์ด๊ฐ€ ๋‹ด๊ธด ๋ฐฐ์—ด sides์ด ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ์ฃผ์–ด์ง‘๋‹ˆ๋‹ค. ์„ธ ๋ณ€์œผ๋กœ ์‚ผ๊ฐํ˜•์„ ๋งŒ๋“ค ์ˆ˜ ์žˆ๋‹ค๋ฉด 1, ๋งŒ๋“ค ์ˆ˜ ์—†๋‹ค๋ฉด 2๋ฅผ returnํ•˜๋„๋ก solution ํ•จ์ˆ˜๋ฅผ ์™„์„ฑํ•ด์ฃผ์„ธ์š”.

sidesresult
[1,2,3]2
[3,6,2]2
[199,72,222]1

์ž…์ถœ๋ ฅ ์˜ˆ

  • ์ž…์ถœ๋ ฅ ์˜ˆ #1
    • ๊ฐ€์žฅ ํฐ ๋ณ€์ธ 3์ด ๋‚˜๋จธ์ง€ ๋‘ ๋ณ€์˜ ํ•ฉ 3๊ณผ ๊ฐ™์œผ๋ฏ€๋กœ ์‚ผ๊ฐํ˜•์„ ์™„์„ฑํ•  ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ 2๋ฅผ returnํ•ฉ๋‹ˆ๋‹ค.
  • ์ž…์ถœ๋ ฅ ์˜ˆ #2
    • ๊ฐ€์žฅ ํฐ ๋ณ€์ธ 6์ด ๋‚˜๋จธ์ง€ ๋‘ ๋ณ€์˜ ํ•ฉ 5๋ณด๋‹ค ํฌ๋ฏ€๋กœ ์‚ผ๊ฐํ˜•์„ ์™„์„ฑํ•  ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ 2๋ฅผ returnํ•ฉ๋‹ˆ๋‹ค.
  • ์ž…์ถœ๋ ฅ ์˜ˆ #3
    • ๊ฐ€์žฅ ํฐ ๋ณ€์ธ 222๊ฐ€ ๋‚˜๋จธ์ง€ ๋‘ ๋ณ€์˜ ํ•ฉ 271๋ณด๋‹ค ์ž‘์œผ๋ฏ€๋กœ ์‚ผ๊ฐํ˜•์„ ์™„์„ฑํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ 1์„ returnํ•ฉ๋‹ˆ๋‹ค.

๋‚˜์˜ ํ’€์ด


import java.util.Arrays;
class Solution {
    public int solution(int[] sides) {
        int answer = 0;
       Arrays.sort(sides);


        if(sides[2] < (sides[0]+sides[1])) {

            answer = 1;
        }else {
            answer = 2;
        }

        return answer;
    }
}

๋‚˜์˜ ์ ‘๊ทผ
๋งค๊ฐœ๋ณ€์ˆ˜๋ฅผ ๋ฐฐ์—ด๋กœ ๋ฐ›๊ณ , ๊ทธ ๋ฐฐ์—ด ๊ฐ’์„ Arrays ํด๋ž˜์Šค์˜ sort๋ฉ”์„œ๋“œ๋ฅผ ์จ์„œ ์˜ค๋ฆ„์ฐจ์ˆœ์œผ๋กœ ์ •๋ ฌ์„ ์‹œํ‚จ๋‹ค. ๊ทธ๋ ‡๊ฒŒ ํ•˜๋ฉด ์ž์—ฐ์Šค๋Ÿฝ๊ฒŒ sides[0], sides[1], sides[2]์˜ ๊ฐ’์ด ํ• ๋‹น๋˜๊ธฐ ๋•Œ๋ฌธ์— ์—ฐ์‚ฐ๊ฒฐ๊ณผ์— ๋”ฐ๋ผ return๊ฐ’์„ ๊ฒฐ์ •


์ˆœ์„œ์Œ์˜ ๊ฐœ์ˆ˜

๐Ÿ“‘2) ์ˆœ์„œ์Œ์ด๋ž€ ๋‘ ๊ฐœ์˜ ์ˆซ์ž๋ฅผ ์ˆœ์„œ๋ฅผ ์ •ํ•˜์—ฌ ์ง์ง€์–ด ๋‚˜ํƒ€๋‚ธ ์Œ์œผ๋กœ (a, b)๋กœ ํ‘œ๊ธฐํ•ฉ๋‹ˆ๋‹ค. ์ž์—ฐ์ˆ˜ n์ด ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ์ฃผ์–ด์งˆ ๋•Œ ๋‘ ์ˆซ์ž์˜ ๊ณฑ์ด n์ธ ์ž์—ฐ์ˆ˜ ์ˆœ์„œ์Œ์˜ ๊ฐœ์ˆ˜๋ฅผ returnํ•˜๋„๋ก solution ํ•จ์ˆ˜๋ฅผ ์™„์„ฑํ•ด์ฃผ์„ธ์š”.

nresult
206
1009

์ž…์ถœ๋ ฅ ์˜ˆ ์„ค๋ช…

  • ์ž…์ถœ๋ ฅ ์˜ˆ #1

    • n์ด 20 ์ด๋ฏ€๋กœ ๊ณฑ์ด 20์ธ ์ˆœ์„œ์Œ์€ (1, 20), (2, 10), (4, 5), (5, 4), (10, 2), (20, 1) ์ด๋ฏ€๋กœ 6์„ returnํ•ฉ๋‹ˆ๋‹ค.
  • ์ž…์ถœ๋ ฅ ์˜ˆ #2

    • n์ด 100 ์ด๋ฏ€๋กœ ๊ณฑ์ด 100์ธ ์ˆœ์„œ์Œ์€ (1, 100), (2, 50), (4, 25), (5, 20), (10, 10), (20, 5), (25, 4), (50, 2), (100, 1) ์ด๋ฏ€๋กœ 9๋ฅผ returnํ•ฉ๋‹ˆ๋‹ค.

๋‚˜์˜ ํ’€์ด

class Solution {
    public int solution(int n) {
 
        int answer = 0;
        for(int i = 1; i<=n; i++) {
        	if( n % i == 0) {    // 1,2,4,5,10,20
        		answer++;
        	}
        }
        return answer;
    }
}

๋‚˜์˜ ์ƒ๊ฐ
n์˜ ์ˆœ์„œ์Œ์„ ์ƒ๊ฐํ–ˆ์„ ๋•Œ , ๋ฐ”๋กœ ๋“ค์—ˆ๋˜ ์ƒ๊ฐ์€ n์„ 1๋ถ€ํ„ฐ n๊นŒ์ง€ ๋‚˜๋ˆ„์—ˆ์„ ๋•Œ ๋‚˜์˜จ ๋‚˜๋จธ์ง€๊ฐ€ 0์ด๋ฉด ๊ฒฐ๊ตญ ์ด๊ฒƒ์ด ์ˆœ์„œ์Œ์ด๋ž‘ ๊ฐ™๊ตฌ๋‚˜ ๋ผ๊ณ  ์ƒ๊ฐ์ด ๋“ฆ.
๊ทธ ๋•Œ answer๋ฅผ ์นด์šดํ„ฐ๋ผ๊ณ  ํ–ˆ์„ ๋•Œ, ๋‚˜๋ˆˆ ๋‚˜๋จธ์ง€๊ฐ€ 0์ผ๋•Œ ์นด์šดํ„ฐ๋ฅผ 1์”ฉ ์ฆ๊ฐ€ํ•˜์—ฌ ๋ฆฌํ„ด


๋ฌธ์ž ๋ฐ˜๋ณต ์ถœ๋ ฅํ•˜๊ธฐ

๐Ÿ“‘3) ๋ฌธ์ž์—ด my_string๊ณผ ์ •์ˆ˜ n์ด ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ์ฃผ์–ด์งˆ ๋•Œ, my_string์— ๋“ค์–ด์žˆ๋Š” ๊ฐ ๋ฌธ์ž๋ฅผ n๋งŒํผ ๋ฐ˜๋ณตํ•œ ๋ฌธ์ž์—ด์„ return ํ•˜๋„๋ก solution ํ•จ์ˆ˜๋ฅผ ์™„์„ฑํ•ด๋ณด์„ธ์š”.

my_stringnresult
"hello"3"hhheeellllllooo"

์ž…์ถœ๋ ฅ ์˜ˆ ์„ค๋ช…

  • ์ž…์ถœ๋ ฅ ์˜ˆ #1
    • "hello"์˜ ๊ฐ ๋ฌธ์ž๋ฅผ ์„ธ ๋ฒˆ์”ฉ ๋ฐ˜๋ณตํ•œ "hhheeellllllooo"๋ฅผ return ํ•ฉ๋‹ˆ๋‹ค.

๋‚˜์˜ ํ’€์ด

class Solution {
    public String solution(String my_string, int n) {
       String answer = "";
        String[] arr = my_string.split(""); // ๋งค๊ฐœ๋ณ€์ˆ˜๋ฅผ ๋ฐ›์•„์™€ ๋ฐฐ์—ด์— ๋„ฃ๋Š” ์ž‘์—…
      
        
        for(int i = 0; i<arr.length; i++) {
        	for(int j = 0; j<n; j++) {
        	 answer += arr[i]; 
        	}
        }
        return answer;
    }
}

๋‚˜์˜ ์ƒ๊ฐ

๋งค๊ฐœ๋ณ€์ˆ˜ String my_string์„ ์ชผ๊ฐœ์–ด ๋‹ด์„ String ๋ฐฐ์—ด arr์„ ์žก๋Š”๋‹ค.

์ด์ค‘ for๋ฌธ์„ ๋Œ๋ ค ์•ˆ์ชฝfor๋ฌธ์„ ๋งค๊ฐœ๋ณ€์ˆ˜n๋ฒˆ ๋ฐ˜๋ณต์œผ๋กœ ๋Œ๋ฆฌ๊ณ  answer์— arr[i]๋ฅผ ๋”ํ•ด์ค€๋‹ค. ๋ฐ”๊นฅ์ชฝ for๋ฌธ์€ arr์˜ ํฌ๊ธฐ๋งŒํผ ๋ฐ˜๋ณต์„ ๋Œ๋ ค์ค€๋‹ค

ideal

class Solution {
    public String solution(String my_string, int n) {
        String answer = "";
        String[] str = my_string.split("");
        for(int i=0; i<my_string.length(); i++){
            answer += str[i].repeat(n);
        }
        return answer;
    }
}

๋ฐฐ์—ด์˜ repeat() method๋ฅผ ์ด์šฉํ•˜๋ฉด ์ด์ค‘ for๋ฌธ์„ ์“ฐ์ง€์•Š๊ณ  ๋” ์‰ฝ๊ฒŒ ์ ‘๊ทผํ•  ์ˆ˜ ์žˆ๋‹ค.


์˜ท๊ฐ€๊ฒŒ ํ• ์ธ ๋ฐ›๊ธฐ

๐Ÿ“‘4) ๋จธ์“ฑ์ด๋„ค ์˜ท๊ฐ€๊ฒŒ๋Š” 10๋งŒ ์› ์ด์ƒ ์‚ฌ๋ฉด 5%, 30๋งŒ ์› ์ด์ƒ ์‚ฌ๋ฉด 10%, 50๋งŒ ์› ์ด์ƒ ์‚ฌ๋ฉด 20%๋ฅผ ํ• ์ธํ•ด์ค๋‹ˆ๋‹ค.๊ตฌ๋งคํ•œ ์˜ท์˜ ๊ฐ€๊ฒฉ price๊ฐ€ ์ฃผ์–ด์งˆ ๋•Œ, ์ง€๋ถˆํ•ด์•ผ ํ•  ๊ธˆ์•ก์„ return ํ•˜๋„๋ก solution ํ•จ์ˆ˜๋ฅผ ์™„์„ฑํ•ด๋ณด์„ธ์š”.

priceresult
150,000142,500
580,000464,000

์ž…์ถœ๋ ฅ ์˜ˆ ์„ค๋ช…

  • ์ž…์ถœ๋ ฅ ์˜ˆ #1
    • 150,000์›์—์„œ 5%๋ฅผ ํ• ์ธํ•œ 142,500์›์„ return ํ•ฉ๋‹ˆ๋‹ค.
  • ์ž…์ถœ๋ ฅ ์˜ˆ #2
    • 580,000์›์—์„œ 20%๋ฅผ ํ• ์ธํ•œ 464,000์›์„ return ํ•ฉ๋‹ˆ๋‹ค.

๋‚˜์˜ ํ’€์ด

class Solution {
    public int solution(int price) {
       
       if(price >= 500000){
            return (int) (price - (price*0.2));  //(0.8* price)
        }else if(price >= 300000){
            return (int)(price - (price*0.1));  //(0.9* price)
        }else if(price >= 100000){
            return (int)(price - (price*0.05)); //(0.95* price)
        }else {
        	return (int)price;
        }
    }
}

๋‚˜์˜ ์ƒ๊ฐ

discount ํ•œ ๊ฐ€๊ฒฉ์„ intํ˜•์œผ๋กœ ์บ์ŠคํŒ…ํ•˜๋Š”๊ฒŒ ํฌ์ธํŠธ


ํŽธ์ง€

๐Ÿ“‘5) ๋จธ์“ฑ์ด๋Š” ํ• ๋จธ๋‹ˆ๊ป˜ ์ƒ์‹  ์ถ•ํ•˜ ํŽธ์ง€๋ฅผ ์“ฐ๋ ค๊ณ  ํ•ฉ๋‹ˆ๋‹ค. ํ• ๋จธ๋‹ˆ๊ฐ€ ๋ณด์‹œ๊ธฐ ํŽธํ•˜๋„๋ก ๊ธ€์ž ํ•œ ์ž ํ•œ ์ž๋ฅผ ๊ฐ€๋กœ 2cm ํฌ๊ธฐ๋กœ ์ ์œผ๋ ค๊ณ  ํ•˜๋ฉฐ, ํŽธ์ง€๋ฅผ ๊ฐ€๋กœ๋กœ๋งŒ ์ ์„ ๋•Œ, ์ถ•ํ•˜ ๋ฌธ๊ตฌ message๋ฅผ ์ ๊ธฐ ์œ„ํ•ด ํ•„์š”ํ•œ ํŽธ์ง€์ง€์˜ ์ตœ์†Œ ๊ฐ€๋กœ๊ธธ์ด๋ฅผ return ํ•˜๋„๋ก solution ํ•จ์ˆ˜๋ฅผ ์™„์„ฑํ•ด์ฃผ์„ธ์š”.

messageresult
"happy birthday!"30
"l love you~"22

์ž…์ถœ๋ ฅ ์˜ˆ ์„ค๋ช…

  • ์ž…์ถœ๋ ฅ ์˜ˆ #1
    • message์˜ ๊ธ€์ž ์ˆ˜๊ฐ€ 15๊ฐœ๋กœ ์ตœ์†Œ ๊ฐ€๋กœ 30cm์˜ ํŽธ์ง€์ง€๊ฐ€ ํ•„์š”ํ•ฉ๋‹ˆ๋‹ค.
  • ์ž…์ถœ๋ ฅ ์˜ˆ #2
    • message์˜ ๊ธ€์ž ์ˆ˜๊ฐ€ 11๊ฐœ๋กœ ์ตœ์†Œ ๊ฐ€๋กœ 22cm์˜ ํŽธ์ง€์ง€๊ฐ€ ํ•„์š”ํ•ฉ๋‹ˆ๋‹ค.

๋‚˜์˜ ํ’€์ด

class Solution {
    public int solution(String message) {
        int answer = 0;
        String[] letter = message.split("");
        
        for(int i = 0; i<letter.length;i++){
            answer++;
        }
        return answer*2;
    }
}

์ค‘์•™๊ฐ’ ๊ตฌํ•˜๊ธฐ

๐Ÿ“‘6) ์ค‘์•™๊ฐ’์€ ์–ด๋–ค ์ฃผ์–ด์ง„ ๊ฐ’๋“ค์„ ํฌ๊ธฐ์˜ ์ˆœ์„œ๋Œ€๋กœ ์ •๋ ฌํ–ˆ์„ ๋•Œ ๊ฐ€์žฅ ์ค‘์•™์— ์œ„์น˜ํ•˜๋Š” ๊ฐ’์„ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด 1, 2, 7, 10, 11์˜ ์ค‘์•™๊ฐ’์€ 7์ž…๋‹ˆ๋‹ค. ์ •์ˆ˜ ๋ฐฐ์—ด array๊ฐ€ ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ์ฃผ์–ด์งˆ ๋•Œ, ์ค‘์•™๊ฐ’์„ return ํ•˜๋„๋ก solution ํ•จ์ˆ˜๋ฅผ ์™„์„ฑํ•ด๋ณด์„ธ์š”.

์ž…์ถœ๋ ฅ ์˜ˆ

arrayresult
[1, 2, 7, 10, 11]7
[9, -1, 0]0

๋‚˜์˜ ํ’€์ด

import java.util.Arrays;
class Solution {
    public int solution(int[] array) {
        int answer = 0;
        
        Arrays.sort(array);	  
		answer = array[(array.length)/2]; 
        return answer;
    }
}

๋‚˜์˜ ์ƒ๊ฐ
๋งค๊ฐœ๋ณ€์ˆ˜๋ฅผ ๋ฐฐ์—ด๋กœ ์ฃผ์–ด์กŒ์„ ๋•Œ, Array.sort() ๋ฉ”์„œ๋“œ๋ฅผ ์ด์šฉํ•˜์—ฌ ์ •๋ ฌ์„ ์‹œํ‚จ๋‹ค. ์ •๋ ฌ ์‹œํ‚จ ๊ฐ’์—์„œ /2 ๋ฅผ ํ•ด์ฃผ๋ฉด Index ๋ฒˆํ˜ธ์ƒ ์ค‘์•™๊ฐ’์„ ์„ ๋ณ„ํ•  ์ˆ˜ ์žˆ๋‹ค.


๋ฐฐ์—ด์˜ ์œ ์‚ฌ๋„

๐Ÿ“‘7) ๋‘ ๋ฐฐ์—ด์ด ์–ผ๋งˆ๋‚˜ ์œ ์‚ฌํ•œ์ง€ ํ™•์ธํ•ด๋ณด๋ ค๊ณ  ํ•ฉ๋‹ˆ๋‹ค. ๋ฌธ์ž์—ด ๋ฐฐ์—ด s1๊ณผ s2๊ฐ€ ์ฃผ์–ด์งˆ ๋•Œ ๊ฐ™์€ ์›์†Œ์˜ ๊ฐœ์ˆ˜๋ฅผ returnํ•˜๋„๋ก solution ํ•จ์ˆ˜๋ฅผ ์™„์„ฑํ•ด์ฃผ์„ธ์š”.

์ž…์ถœ๋ ฅ ์˜ˆ

s1s2result
["a", "b", "c"]["com", "b", "d", "p", "c"]2
["n", "omg"]["m", "dot"]0

๋‚˜์˜ ํ’€์ด

import java.util.HashSet;
import java.util.Set;

class Solution {
    public int solution(String[] s1, String[] s2) {
        int count = 0;
        
        Set<String> set = new HashSet<>();
        for(int i = 0; i<s1.length; i++) {
        	set.add(s1[i]);
        	count++;
        }
        for(int i = 0; i<s2.length; i++) {
        	set.add(s2[i]);
        	count++;
        }
        
        return count-set.size();
    }
}

๋‚˜์˜ ์ƒ๊ฐ

๋งค๊ฐœ๋ณ€์ˆ˜๊ฐ€ ๋ฐฐ์—ด s1, s2 ๋กœ ์ฃผ์–ด์ง€๊ธฐ ๋•Œ๋ฌธ์— ์ด ๋‘ ๋ฐฐ์—ด์„ ๊ฐ๊ฐ for๋ฌธ์„ ๋Œ๋ ค ๋ฐฐ์—ด์•ˆ์— ์žˆ๋Š” ๊ฐ’์„ ์นด์šดํŒ…ํ•˜์—ฌ ๋”ํ•˜๊ณ , setํ•ด์„œ ์ค‘๋ณต์„ ์ œ๊ฑฐํ•œ ๊ฐ’์„ ์นด์šดํŒ… ํ•˜์—ฌ ๋นผ๋Š” ๋ฐฉ๋ฒ•์„ ์ด์šฉํ•˜์˜€๋‹ค.

๋‹ค๋ฅธ ํ’€์ด

class Solution {
    public int solution(String[] s1, String[] s2) {
        int answer = 0;
        for(String str1 : s1){
            for(String str2 : s2){
                if(str1.equals(str2)){
                    answer++;
                    break;
                }
            }
        }
        return answer;
    }
}

for-each ๊ตฌ๋ฌธ์œผ๋กœ s1,s2๋ฐฐ์—ด์„ ๋Œ๋ ค ๋‘๋ฐฐ์—ด์˜ ์ธ๋ฑ์Šค ๊ฐ’์„ ๋น„๊ตํ•˜๋Š” ๋ฐฉ๋ฒ•์„ ์ด์šฉ
equals ๋ฉ”์„œ๋“œ๋ฅผ ์‚ฌ์šฉ


์ž๋ฆฟ์ˆ˜ ๋”ํ•˜๊ธฐ

๐Ÿ“‘8) ์ •์ˆ˜ n์ด ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ์ฃผ์–ด์งˆ ๋•Œ n์˜ ๊ฐ ์ž๋ฆฌ ์ˆซ์ž์˜ ํ•ฉ์„ returnํ•˜๋„๋ก solution ํ•จ์ˆ˜๋ฅผ ์™„์„ฑํ•ด์ฃผ์„ธ์š”

nresult
123410
93021116

์ž…์ถœ๋ ฅ ์˜ˆ ์„ค๋ช…

  • 1 + 2 + 3 + 4 = 10์„ returnํ•ฉ๋‹ˆ๋‹ค.
  • 9 + 3 + 0 + 2 + 1 + 1 = 16์„ returnํ•ฉ๋‹ˆ๋‹ค.

๋‚˜์˜ ํ’€์ด

class Solution {
    public int solution(int n) {
        int answer = 0;
        String s1 = Integer.toString(n);
            String[] arr = s1.split("");
        
        for(int i = 0; i<arr.length; i++){
            answer += Integer.parseInt(arr[i]);
        }
        
        return answer;
    }
}

๋‚˜์˜ ์ƒ๊ฐ

๋ฌธ์ œ๋ฅผ ๋ณด์ž๋งˆ์ž intํ˜• ํƒ€์ž… ๋ณ€์ˆ˜๋ฅผ strํ˜•์œผ๋กœ ๋ณ€ํ™˜์„ ์‹œ์ผœ์„œ ๋ฌธ์ž ํ•˜๋‚˜์”ฉ ์ž˜๋ผ ๋ฐฐ์—ด์— ๋„ฃ์–ด์•ผ๊ฒ ๋‹ค๊ณ  ์ƒ๊ฐ, ๊ทธ๋ฆฌ๊ณ  for๋ฌธ์„ ๋Œ๋ ค strํ˜• ๋ณ€์ˆ˜๋ฅผ ๋‹ค์‹œ int๋กœ ํ˜•๋ณ€ํ™˜ํ•˜์—ฌ ๋”ํ•˜์—ฌ ๋ฆฌํ„ด.

ํ•ต์‹ฌ ๊ฐœ๋…

int โ†’ String (์ˆซ์ž๋ฅผ ๋ฌธ์ž๋กœ)

String s = Integer.toString(n); //int n ๋งค๊ฐœ๋ณ€์ˆ˜ 

String โ†’ in (๋ฌธ์ž๋ฅผ ์ˆซ์ž๋กœ)

int answer = Integer.parseInt(s);

String[] arr

String[] arr = s1.split("");

0๊ฐœ์˜ ๋Œ“๊ธ€