Programmers #10

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

Programmers

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

์ค‘๋ณต๋œ ๋ฌธ์ž ์ œ๊ฑฐ

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


์ž…์ถœ๋ ฅ ์˜ˆ

my_stringresult
"people""peol"
"We are the world""We arthwold"

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

  • "people"์—์„œ ์ค‘๋ณต๋œ ๋ฌธ์ž "p"์™€ "e"์„ ์ œ๊ฑฐํ•œ "peol"์„ returnํ•ฉ๋‹ˆ๋‹ค.
  • "We are the world"์—์„œ ์ค‘๋ณต๋œ ๋ฌธ์ž "e", " ", "r" ๋“ค์„ ์ œ๊ฑฐํ•œ "We arthwold"์„ returnํ•ฉ๋‹ˆ๋‹ค.

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

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 ๋กœ ๋ถˆ์ผ์น˜ ํ•˜๊ธฐ๋•Œ๋ฌธ์— ์ค‘๋ณต์„ ๊ฑธ๋Ÿฌ์ฃผ๋Š” ๋ฐฉ๋ฒ•์ด๋‹ค. ์•„๋ฆ„๋‹ต๋‹ค....


๋ชจ์Šค๋ถ€ํ˜ธ (1)

๐Ÿ“‘ ๋ฌธ2) ๋จธ์“ฑ์ด๋Š” ์นœ๊ตฌ์—๊ฒŒ ๋ชจ์Šค๋ถ€ํ˜ธ๋ฅผ ์ด์šฉํ•œ ํŽธ์ง€๋ฅผ ๋ฐ›์•˜์Šต๋‹ˆ๋‹ค. ๊ทธ๋ƒฅ์€ ์ฝ์„ ์ˆ˜ ์—†์–ด ์ด๋ฅผ ํ•ด๋…ํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ๋งŒ๋“ค๋ ค๊ณ  ํ•ฉ๋‹ˆ๋‹ค. ๋ฌธ์ž์—ด letter๊ฐ€ ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ์ฃผ์–ด์งˆ ๋•Œ, letter๋ฅผ ์˜์–ด ์†Œ๋ฌธ์ž๋กœ ๋ฐ”๊พผ ๋ฌธ์ž์—ด์„ return ํ•˜๋„๋ก solution ํ•จ์ˆ˜๋ฅผ ์™„์„ฑํ•ด๋ณด์„ธ์š”.

๋ชจ์Šค๋ถ€ํ˜ธ๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

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'
}

์ž…์ถœ๋ ฅ ์˜ˆ

letterresult
".... . .-.. .-.. ---""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' ๋ฅผ ํ•ด๋„ ๊ฐ™์€ ๊ฒฐ๊ณผ๊ฐ€ ๋‚˜์˜จ๋‹ค


A๋กœ B ๋งŒ๋“ค๊ธฐ

๐Ÿ“‘ ๋ฌธ3) ๋ฌธ์ž์—ด before์™€ after๊ฐ€ ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ์ฃผ์–ด์งˆ ๋•Œ, before์˜ ์ˆœ์„œ๋ฅผ ๋ฐ”๊พธ์–ด after๋ฅผ ๋งŒ๋“ค ์ˆ˜ ์žˆ์œผ๋ฉด 1์„, ๋งŒ๋“ค ์ˆ˜ ์—†์œผ๋ฉด 0์„ return ํ•˜๋„๋ก solution ํ•จ์ˆ˜๋ฅผ ์™„์„ฑํ•ด๋ณด์„ธ์š”.


์ž…์ถœ๋ ฅ ์˜ˆ

beforeafterresult
"olleh""hello"1
"allpe""apple"0

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

  • "olleh"์˜ ์ˆœ์„œ๋ฅผ ๋ฐ”๊พธ๋ฉด "hello"๋ฅผ ๋งŒ๋“ค ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
  • "allpe"์˜ ์ˆœ์„œ๋ฅผ ๋ฐ”๊ฟ”๋„ "apple"์„ ๋งŒ๋“ค ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค.

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

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 ์„ ๋ฆฌํ„ดํ•˜๊ฒŒ ์ฝ”๋“œ๋ฅผ ๊ตฌ์„ฑํ•˜์˜€๋‹ค.


ํŒฉํ† ๋ฆฌ์–ผ

๐Ÿ“‘ ๋ฌธ4) iํŒฉํ† ๋ฆฌ์–ผ (i!)์€ 1๋ถ€ํ„ฐ i๊นŒ์ง€ ์ •์ˆ˜์˜ ๊ณฑ์„ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ๋“ค์–ด 5! = 5 4 3 2 1 = 120 ์ž…๋‹ˆ๋‹ค. ์ •์ˆ˜ n์ด ์ฃผ์–ด์งˆ ๋•Œ ๋‹ค์Œ ์กฐ๊ฑด์„ ๋งŒ์กฑํ•˜๋Š” ๊ฐ€์žฅ ํฐ ์ •์ˆ˜ i๋ฅผ return ํ•˜๋„๋ก solution ํ•จ์ˆ˜๋ฅผ ์™„์„ฑํ•ด์ฃผ์„ธ์š”.


์ž…์ถœ๋ ฅ ์˜ˆ

nresult
362880010
73

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

  • 10! = 3,628,800์ž…๋‹ˆ๋‹ค. n์ด 3628800์ด๋ฏ€๋กœ ์ตœ๋Œ€ ํŒฉํ† ๋ฆฌ์–ผ์ธ 10์„ return ํ•ฉ๋‹ˆ๋‹ค.
  • 3! = 6, 4! = 24์ž…๋‹ˆ๋‹ค. n์ด 7์ด๋ฏ€๋กœ, 7 ์ดํ•˜์˜ ์ตœ๋Œ€ ํŒฉํ† ๋ฆฌ์–ผ์ธ 3์„ return ํ•ฉ๋‹ˆ๋‹ค.

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

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์„ ๋ฐ˜ํ™˜

2์ฐจ์›์œผ๋กœ ๋งŒ๋“ค๊ธฐ

๐Ÿ“‘ ๋ฌธ5) ์ •์ˆ˜ ๋ฐฐ์—ด num_list์™€ ์ •์ˆ˜ n์ด ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ์ฃผ์–ด์ง‘๋‹ˆ๋‹ค. num_list๋ฅผ ๋‹ค์Œ ์„ค๋ช…๊ณผ ๊ฐ™์ด 2์ฐจ์› ๋ฐฐ์—ด๋กœ ๋ฐ”๊ฟ” returnํ•˜๋„๋ก solution ํ•จ์ˆ˜๋ฅผ ์™„์„ฑํ•ด์ฃผ์„ธ์š”.

num_list๊ฐ€ [1, 2, 3, 4, 5, 6, 7, 8] ๋กœ ๊ธธ์ด๊ฐ€ 8์ด๊ณ  n์ด 2์ด๋ฏ€๋กœ num_list๋ฅผ 2 * 4 ๋ฐฐ์—ด๋กœ ๋‹ค์Œ๊ณผ ๊ฐ™์ด ๋ณ€๊ฒฝํ•ฉ๋‹ˆ๋‹ค. 2์ฐจ์›์œผ๋กœ ๋ฐ”๊ฟ€ ๋•Œ์—๋Š” num_list์˜ ์›์†Œ๋“ค์„ ์•ž์—์„œ๋ถ€ํ„ฐ n๊ฐœ์”ฉ ๋‚˜๋ˆ  2์ฐจ์› ๋ฐฐ์—ด๋กœ ๋ณ€๊ฒฝํ•ฉ๋‹ˆ๋‹ค.


์ž…์ถœ๋ ฅ ์˜ˆ

num_listnresult
[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]]

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

  • num_list๊ฐ€ [1, 2, 3, 4, 5, 6, 7, 8] ๋กœ ๊ธธ์ด๊ฐ€ 8์ด๊ณ  n์ด 2์ด๋ฏ€๋กœ 2 * 4 ๋ฐฐ์—ด๋กœ ๋ณ€๊ฒฝํ•œ [[1, 2], [3, 4], [5, 6], [7, 8]] ์„ returnํ•ฉ๋‹ˆ๋‹ค.
  • num_list๊ฐ€ [100, 95, 2, 4, 5, 6, 18, 33, 948] ๋กœ ๊ธธ์ด๊ฐ€ 9์ด๊ณ  n์ด 3์ด๋ฏ€๋กœ 3 * 3 ๋ฐฐ์—ด๋กœ ๋ณ€๊ฒฝํ•œ [[100, 95, 2], [4, 5, 6], [18, 33, 948]] ์„ returnํ•ฉ๋‹ˆ๋‹ค.

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

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์— ํ•ด๋‹นํ•˜๋Š” ๊ฐ’์„ ๋Œ€์ž…ํ•˜๋Š” ๋ฐฉ๋ฒ•์œผ๋กœ ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•˜์˜€๋‹ค.

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