요즘 Toad를 MySQL Client 툴로 많이 사용하죠.

 

사용도 편리하고, DB Data를 Import/Export도 쉽게 받으실 수 있습니다.

Freeware이지만 서비스가 종료된 후 요즘 잘못된 링크가 많아서 본 포스팅을 통해 공유드립니다.

 

 

 

 

아래 링크를 통해 Toad For MySQL 7.9을 받으실 수 있습니다.

 

 


 

나중에 시간이 된다면, 툴 사용법도 같이 포스팅에 올리겠습니다.

 

 

 

 

 

금일 포스팅은 여기서 마치겠습니다.

 

 

 

친구들과 파티룸을 찾고 있었는데

많이 검색해봤는데도 불구하고 마땅한 곳을 찾지 못했어요.ㅠㅠ

구글링으로 웹검색을 좀 해보다가 이 곳을 첨 알게됐는데

너무 괜찮아서 글을 남기게 됐습니다.


파티룸은 보통 30만원 정도 하더라고요.

큰 거실에 요리도 해먹을 수 있게 돼있지만,

결론적으로는 이 곳이 더 낫더라고요.

 

바로 광주 더시티호텔의 루프탑펜트하우스입니다.

외부는 이렇게 생겼어요.

루프탑펜트하우스는 7층에 있는데,

독채로 층 전체를 사용할 수 있었습니다.

생각보다 꽤 넓어요.

 

조명도 밝고 이렇게 깔끔하게 돼있습니다.

전체 사이즈로 보면 일반 파티 이벤트룸의 X2~X3정도는 되는 것 같아요.

테라스가 아주 인상적이었는데요.

저희들이 이용하진 않았지만, 이렇게 온수풀이 있었고

외부에 흔들의자, 소파 등도 있었어요:)

 

저희가 잘 썼던건 바로 이거!!

바베큐를 구워먹을 수 있는 바베큐장이 있었는데~

이렇게 먹으니 정말 맛있더라고요ㅎㅎㅎㅎ

룸은 총 3개가 있었습니다.

생각보다 깔끔하고 좋았습니다.

TV가 있는 룸도 하나 있었고요

 

거실에는 대형 TV와 사운드바가 있었는데,

저희는 술마시느라 많이 이용하지는 않았어요ㅋㅋㅋ

만약 파티룸이나 커플 데이트를 알아보신다면,

여기 정말 강추드립니다.

 

일반 파티룸보다 넓으면서 가격은 15만원대로 반값이에요ㅋㅋㅋ

말도 안되게 싼 가격이죠.

 

일반 호텔은 너무 작고 왠만한 에어비앤비랑 잡고 따져봐도

여기가 압도적으로 좋아요.

 

 

주소 : 광주광역시 쌍암동679-8번지 더시티호텔(비지니스 브띠크호텔)

 

연락처 : 062-972-3500

 

사이트 : www.cityhotel.biz

 

광주시티호텔 City Hotel

광주비지니스호텔 (터미널점/첨단점) ,카페테리아,스타일러,세탁실

cityhotel.biz

 

*Practice 1 : 올바른 괄호

 

괄호가 바르게 짝지어졌다는 것은 '(' 문자로 열렸으면 반드시 짝지어서 ')' 문자로 닫혀야 한다는 뜻입니다. 예를 들어

  • ()() 또는 (())() 는 올바른 괄호입니다.
  • )()( 또는 (()( 는 올바르지 않은 괄호입니다.

'(' 또는 ')' 로만 이루어진 문자열 s가 주어졌을 때, 문자열 s가 올바른 괄호이면 true를 return 하고, 올바르지 않은 괄호이면 false를 return 하는 solution 함수를 완성해 주세요.

 

s answer
()() true
(())() true
)()( false
(()( false
class Solution {
    boolean solution(String s) {
        boolean answer = false;
        int count = 0;
        for(int i = 0; i<s.length();i++){
            if(s.charAt(i) == '('){
                count++;
            }
            if(s.charAt(i) == ')'){
                count--;
            }
            if(count < 0){
                break;
            }
        }
        if(count == 0){
            answer = true;
        }
        return answer;
    }
}

 

 

*Practice 2 : 스킬트리

 

선행 스킬이란 어떤 스킬을 배우기 전에 먼저 배워야 하는 스킬을 뜻합니다.

예를 들어 선행 스킬 순서가 스파크 → 라이트닝 볼트 → 썬더일때, 썬더를 배우려면 먼저 라이트닝 볼트를 배워야 하고, 라이트닝 볼트를 배우려면 먼저 스파크를 배워야 합니다.

위 순서에 없는 다른 스킬(힐링 등)은 순서에 상관없이 배울 수 있습니다. 따라서 스파크 → 힐링 → 라이트닝 볼트 → 썬더와 같은 스킬트리는 가능하지만, 썬더 → 스파크나 라이트닝 볼트 → 스파크 → 힐링 → 썬더와 같은 스킬트리는 불가능합니다.

선행 스킬 순서 skill과 유저들이 만든 스킬트리1를 담은 배열 skill_trees가 매개변수로 주어질 때, 가능한 스킬트리 개수를 return 하는 solution 함수를 작성해주세요.

 

skill skill_trees return
CBD [BACDE, CBADF, AECB, BDA] 2
import java.util.*;

class Solution {
    public int solution(String skill, String[] skill_trees) {
        int answer = 0;
        ArrayList<String> skillTrees = new ArrayList<String>(Arrays.asList(skill_trees));
        //ArrayList<String> skillTrees = new ArrayList<String>();
        Iterator<String> it = skillTrees.iterator();

        while (it.hasNext()) {
            if (skill.indexOf(it.next().replaceAll("[^" + skill + "]", "")) != 0) {
                it.remove();
            }
        }
        answer = skillTrees.size();
        return answer;
    }
}

 

 

*Practice 3 : 큰 수 만들기

 

어떤 숫자에서 k개의 수를 제거했을 때 얻을 수 있는 가장 큰 숫자를 구하려 합니다.

예를 들어, 숫자 1924에서 수 두 개를 제거하면 [19, 12, 14, 92, 94, 24] 를 만들 수 있습니다. 이 중 가장 큰 숫자는 94 입니다.

문자열 형식으로 숫자 number와 제거할 수의 개수 k가 solution 함수의 매개변수로 주어집니다. number에서 k 개의 수를 제거했을 때 만들 수 있는 수 중 가장 큰 숫자를 문자열 형태로 return 하도록 solution 함수를 완성하세요.

 

 

number k return
1924 2 94
1231234 3 3234
4177252841 4 775841
import java.util.Stack;
class Solution {
    public String solution(String number, int k) {
        char[] result = new char[number.length() - k];
        Stack<Character> stack = new Stack<>();

        for (int i=0; i<number.length(); i++) {
            char c = number.charAt(i);
            while (!stack.isEmpty() && stack.peek() < c && k-- > 0) {
                stack.pop();
            }
            stack.push(c);
        }
        for (int i=0; i<result.length; i++) {
            result[i] = stack.get(i);
        }
        return new String(result);
    }
}

 

*Practice 4: 카펫

 

Leo는 카펫을 사러 갔다가 아래 그림과 같이 중앙에는 빨간색으로 칠해져 있고 모서리는 갈색으로 칠해져 있는 격자 모양 카펫을 봤습니다.

Leo는 집으로 돌아와서 아까 본 카펫의 빨간색과 갈색으로 색칠된 격자의 개수는 기억했지만, 전체 카펫의 크기는 기억하지 못했습니다.

Leo가 본 카펫에서 갈색 격자의 수 brown, 빨간색 격자의 수 red가 매개변수로 주어질 때 카펫의 가로, 세로 크기를 순서대로 배열에 담아 return 하도록 solution 함수를 작성해주세요.

 

brown red return
10 2 [4, 3]
8 1 [3, 3]
24 24 [8, 6]
class Solution {
    public int[] solution(int brown, int red) {
        int[] answer = new int[2];
        int red_x, red_y;
        for(int i = 1; i<=red; i++){
            if(red % i == 0){
                red_y = i;
                red_x = red/i;
                if(brown == 4 + red_x * 2 + red_y * 2){
                    answer[0] = red_x + 2;
                    answer[1] = red_y + 2;
                    return answer;
                }
            }
        }
        return answer;
    }
}
class Solution {
    public int[] solution(int brown, int red) {
        for(int i=1; i<=red; i++) {
            if(red%i==0 && (red/i+i)*2+4==brown) {
                return new int[] {red/i+2, i+2};
            }
        }
        return null;
    }
}

 

*Practice 5: 짝지어 제거하기

 

짝지어 제거하기는, 알파벳 소문자로 이루어진 문자열을 가지고 시작합니다. 먼저 문자열에서 같은 알파벳이 2개 붙어 있는 짝을 찾습니다. 그다음, 그 둘을 제거한 뒤, 앞뒤로 문자열을 이어 붙입니다. 이 과정을 반복해서 문자열을 모두 제거한다면 짝지어 제거하기가 종료됩니다. 문자열 S가 주어졌을 때, 짝지어 제거하기를 성공적으로 수행할 수 있는지 반환하는 함수를 완성해 주세요. 성공적으로 수행할 수 있으면 1을, 아닐 경우 0을 리턴해주면 됩니다.

예를 들어, 문자열 S = baabaa 라면

b aa baa → bb aa → aa 

의 순서로 문자열을 모두 제거할 수 있으므로 1을 반환합니다.

 

 

s result
baabaa 1
cdcd 0
import java.util.*;

class Solution
{
    public int solution(String s)
    {
        // 문자열을 캐릭터 배열로 변환
       char[] c = s.toCharArray();
       ArrayList<Character> list = new ArrayList<>();

       // 캐릭터를 하나씩 리스트에 삽입
       for(char _c : c){
           Add(list, _c);
       }

       // 만약 리스트가 비었다면 짝지거 제거 완료
       if(list.isEmpty()){
           return 1;
       }
       else {
           return 0;
       }
    }

     // 리스트에 캐릭터 하나씩 삽입하는 함수
    public static void Add(ArrayList _list, char _c){
        _list.add(_c);

        // 만약 리스트의 길이가 2보다 크고 && 마지막 두 원소가 같은 캐릭터라면
        if(_list.size() > 1 && (_list.get(_list.size() - 2) == _list.get(_list.size() - 1))){
                // 마지막 두 원소 제거
                _list.remove(_list.size() - 1);
                _list.remove(_list.size() - 1);
        }
    }
}

 

 

*Practice 6: 숫자의 표현

 

Finn은 요즘 수학공부에 빠져 있습니다. 수학 공부를 하던 Finn은 자연수 n을 연속한 자연수들로 표현 하는 방법이 여러개라는 사실을 알게 되었습니다. 예를들어 15는 다음과 같이 4가지로 표현 할 수 있습니다.

  • 1 + 2 + 3 + 4 + 5 = 15
  • 4 + 5 + 6 = 15
  • 7 + 8 = 15
  • 15 = 15

자연수 n이 매개변수로 주어질 때, 연속된 자연수들로 n을 표현하는 방법의 수를 return하는 solution를 완성해주세요.

 

n result
15 4
public class Expressions {

    public int expressions(int num) {
        int answer = 0;
        int result = 0;

        for(int i = 1; i<=num; i++){
            for(int j = i; j<=num; j++){
                result += j;
                if(result == num){
                    ++answer;
                } else if(result > num){
                    result = 0;
                    break;
                }
            }
        }

        return answer;
    }

    public static void main(String args[]) {
        Expressions expressions = new Expressions();
        // 아래는 테스트로 출력해 보기 위한 코드입니다.
        System.out.println(expressions.expressions(6));
    }
}

 

 

 

*Practice 7: 가장 큰 정사각형 찾기

 

1와 0로 채워진 표(board)가 있습니다. 표 1칸은 1 x 1 의 정사각형으로 이루어져 있습니다. 표에서 1로 이루어진 가장 큰 정사각형을 찾아 넓이를 return 하는 solution 함수를 완성해 주세요. (단, 정사각형이란 축에 평행한 정사각형을 말합니다.)

 

 

0 1 1 1
1 1 1 1
1 1 1 1
0 0 1 0

가 있다면 가장 큰 정사각형은 넓이는 9가 되므로 9를 반환해 주면 됩니다.

 

 

board answer
[[0,1,1,1],[1,1,1,1],[1,1,1,1],[0,0,1,0]] 9
[[0,0,1,1],[1,1,1,1]] 4
class Solution
{
    public int solution(int [][]board) {
        int answer = 0;
        if(board.length==1 && board[0].length==1) {
            if(board[0][0]==1) return 1;
            else return 0;
        }
        for(int y=1; y<board.length; y++) {
            for(int x=1; x<board[0].length; x++) {
                if(board[y][x]==1) {
                    board[y][x] = Math.min(board[y-1][x-1], Math.min(board[y][x-1], board[y-1][x])) + 1;
                }
                if(board[y][x]>answer) {
                    answer=board[y][x];
                }
            }
        }

        return answer*answer;
    }
}

class Solution
{
    public int solution(int [][]board)
    {
        int answer = 1;

        int[][] dp = new int[board.length+1][board[0].length+1];

        int maxLen = 0;
        for(int i=1;i<=board.length;i++){
            for(int j=1;j<=board[0].length;j++){
                if(board[i-1][j-1]==0){
                    dp[i][j]=0;
                }else{
                    dp[i][j] = Math.min(Math.min(dp[i-1][j-1],dp[i-1][j]),dp[i][j-1]) + 1;
                    maxLen = Math.max(maxLen,dp[i][j]);
                }
            }
        }

        answer = maxLen*maxLen;
        return answer;
    }
}

올바른 괄호

Practice1

2차원 배열 열로 정렬하기 :

 

	public static void main(String[] args) {
		
		int [][] inputArray = {{4,5,6,1},{7,8,9,2},{1,42,2,3},{5,2,5,1}};
		
		System.out.println(Arrays.deepToString(orderByColumns(inputArray)));
		
	}

	private static int[][] orderByColumns(int[][] inputArray) {
		
		int[][] resultArray = new int[inputArray.length][inputArray[0].length];
		
		ArrayList<int[]> list = new ArrayList<int[]>();
		
		for(int inx=0; inx<inputArray.length; inx++) {
			Arrays.sort(inputArray[inx]);
			list.add(inputArray[inx]);
		}
		
		for(int inx=0; inx<inputArray.length; inx++) {
			for(int jnx=0; jnx<inputArray[inx].length; jnx++) {
				resultArray[inx][jnx] = list.get(inx)[jnx];
			}
		}
        //result will be : [[1, 4, 5, 6], [2, 7, 8, 9], [1, 2, 3, 42], [1, 2, 5, 5]]
		return resultArray;
	}

 

Practice2

2차원 배열 행으로 정렬하기 :

 

	private static int[][] orderByRows(int[][] inputArray) {
		
		int [][] resultArray = new int[inputArray.length][inputArray[0].length];
		int [][] reorderedArray = new int[inputArray.length][inputArray[0].length];
		
		ArrayList<int[]> list = new ArrayList<int[]>();
		
		for(int inx=0; inx<inputArray.length; inx++) {
			for(int jnx=0; jnx<inputArray[inx].length; jnx++) {
				reorderedArray[inx][jnx] = inputArray[jnx][inx];
			}
			Arrays.sort(reorderedArray[inx]);
			list.add(reorderedArray[inx]);
		}
		
		for(int inx=0; inx<inputArray.length; inx++) {
			for(int jnx=0; jnx<inputArray[inx].length; jnx++) {
				resultArray[inx][jnx] = list.get(jnx)[inx]; 
			}
		}
		
		return resultArray;
	}

 

Practice3  

initialize 2d array like above :

a b c d e        
        f h s d w

String inputData = "abcde, fhsdw"

	private void solution(String inputData) {
		
		String [] strArray = inputData.split(",");
		
		char [] charArr1 = strArray[0].toCharArray();
		char [] charArr2 = strArray[1].toCharArray();
		
		int totLength = charArr1.length + charArr1.length -1;
		
		char[][] initArray = initArray(charArr1, charArr2, totLength);
        
    }
     
     private char[][] initArray(char[] charArr1, char[] charArr2, int totLength) {
		char [][] initArray = new char[2][totLength];
		int pos = 0;
		
		for(int inx=0; inx<initArray.length; inx++) {
			for(int jnx=0; jnx< totLength; jnx++) {
				if(inx == 0 && charArr1.length > jnx) {
					initArray[inx][jnx] = charArr1[jnx];
					pos++;
				} else if(inx == 1 && charArr2.length > jnx) {
					initArray[1][pos -1] = charArr2[jnx];
					pos++;
				}
			}
		}
		System.out.println(Arrays.deepToString(initArray));
		
		return initArray;
	}

 

Practice4

Move(shift) Array 1step Forward

 

private void solution(String inputData) {
		
		String [] strArray = inputData.split(",");
		
		char [] charArr1 = strArray[0].toCharArray();
		char [] charArr2 = strArray[1].toCharArray();
		
		int totLength = charArr1.length + charArr1.length -1;
		
		char[][] initArray = initArray(charArr1, charArr2, totLength);
		
		//move 1st array 1step forward

		int moveStep = totLength - charArr1.length;
		
		char [] modifiedArray = new char[totLength];
		
		for(int inx=0; inx<moveStep ; inx++) {
			modifiedArray = moveOneStepFwd(initArray[0]);
			System.out.println(Arrays.toString(modifiedArray));
		}
  }
  
  
  	private char[] moveOneStepFwd(char[] charArr1) {
		// 오른쪽으로 한 칸 shift
		char temp = charArr1[charArr1.length - 1];
		for(int inx = charArr1.length-1 ; inx > 0 ; inx--) {
			charArr1[inx] = charArr1[inx-1];
		}
		charArr1[0] = temp;
		
		return charArr1;
	}
  

Practice5

Move(shift) Array 1step Backward 

 

	private void solution(String inputData) {
		
		String [] strArray = inputData.split(",");
		
		char [] charArr1 = strArray[0].toCharArray();
		char [] charArr2 = strArray[1].toCharArray();
		
		int totLength = charArr1.length + charArr1.length -1;
		
		char[][] initArray = initArray(charArr1, charArr2, totLength);
		
		//move 2nd array 1step backward
		int moveStep2 = totLength - charArr2.length;
		
		char [] modifiedArray2 = new char[totLength];
		
		for(int inx=0; inx<moveStep2 ; inx++) {
			modifiedArray2 = moveOneStepBwd(initArray[1]);
			System.out.println(Arrays.toString(modifiedArray2));
		}
        
   }
   
   	private char[] moveOneStepBwd(char[] charArr2) {
		// 왼쪽으로 한 칸 shift
		char temp = charArr2[0];
		for(int inx=0; inx<charArr2.length - 1; inx++) {
			charArr2[inx] = charArr2[inx+1];
		}
		charArr2[charArr2.length-1] = temp;
		
		return charArr2;
	}

 

Practice6
With similarity counter

 

	private void solution(String inputData) {
		
		String [] strArray = inputData.split(",");
		
		char [] charArr1 = strArray[0].toCharArray();
		char [] charArr2 = strArray[1].toCharArray();
		
		int totLength = charArr1.length + charArr1.length -1;
		
		char[][] initArray = initArray(charArr1, charArr2, totLength);
		
		//move 1st array 1step forward
		int moveStep = totLength - charArr1.length;
		
		char [] modifiedArray = new char[totLength];
		
		for(int inx=0; inx<moveStep ; inx++) {
			modifiedArray = moveOneStepFwd(initArray[0]);
			System.out.println(Arrays.toString(modifiedArray));
		}
		
		//move 2nd array 1step backward
		int moveStep2 = totLength - charArr2.length;
		
		char [] modifiedArray2 = new char[totLength];
		
		for(int inx=0; inx<moveStep2 ; inx++) {
			modifiedArray2 = moveOneStepBwd(initArray[1]);
			System.out.println(Arrays.toString(modifiedArray2));
		}
		
		//count similarity for 1st and 2nd array 
		ArrayList<Integer> list = new ArrayList<Integer>();
		
		list.add(countSimilarity(modifiedArray, modifiedArray2));
		System.out.println(list);
		
	}

	private int countSimilarity(char[] inputArray1, char[] inputArray2) {
		int similarity = 0;
		
		for(int inx=0; inx<inputArray1.length; inx++) {
			if(inputArray1[inx] == inputArray2[inx] && inputArray1[inx] != 0 ) {
				similarity++;
			}
		}
		return similarity;
	}

Practice1 : 제일 작은 수 제거하기

 

정수를 저장한 배열, arr 에서 가장 작은 수를 제거한 배열을 리턴하는 함수, solution을 완성해주세요. 단, 리턴하려는 배열이 빈 배열인 경우엔 배열에 -1을 채워 리턴하세요. 예를들어 arr이 [4,3,2,1]인 경우는 [4,3,2]를 리턴 하고, [10]면 [-1]을 리턴 합니다.

arr return
[4,3,2,1] [4,3,2]
[10] [-1]

 

public static void main(String[] args) {
		OrderByDesc obd = new OrderByDesc();
		int[] result = obd.solution(new int[] {4,3,2,1,7,190});
	
		System.out.println(Arrays.toString(result));
		
	}
	 public int[] solution(int[] arr) {

		 int[] answer = {};
	      if(arr.length <= 1 ) {	    	  
	    	  return new int[]{-1};
	      } else {
	    	  int cnt = 0;
	    	  answer = new int[arr.length - 1];
	    	  Arrays.sort(arr);
	    	  for(int inx=arr.length-1; inx>0; inx--) {
	    		  answer[cnt] = arr[inx];
	    		  cnt++;
	    	  }
	      }
	      return answer;
	 }
	public static void main(String[] args) {
		OrderByDesc obd = new OrderByDesc();
		int[] result = obd.solution(new int[] {4,3,2,1,7,190});
	
		System.out.println(Arrays.toString(result));
		
	}
	 public int[] solution(int[] arr) {
	      if (arr.length <= 1) return new int[]{ -1 };		 
	      int min = Arrays.stream(arr).min().getAsInt();
	      return Arrays.stream(arr).filter(i -> i != min).toArray();

	 }

Practice2 : 하샤드 수

 

양의 정수 x가 하샤드 수이려면 x의 자릿수의 합으로 x가 나누어져야 합니다. 예를 들어 18의 자릿수 합은 1+8=9이고, 18은 9로 나누어 떨어지므로 18은 하샤드 수입니다. 자연수 x를 입력받아 x가 하샤드 수인지 아닌지 검사하는 함수, solution을 완성해주세요.

arr return
10 true
12 true
11 false
13 false
public static void main(String[] args) {
		OrderByDesc obd = new OrderByDesc();
		boolean result = obd.solution( 10 );
	
		System.out.println(result);
		
	}
	public boolean solution(int inputNumber) {
	      boolean answer = true;
	      int copyOfNum = inputNumber;
	      int sum = 0;
	      while(copyOfNum != 0 ) {
	    	  int lastDigit = copyOfNum % 10;
	    	  sum+=lastDigit;
	    	  copyOfNum /= 10;
	      }
	      
	      if(inputNumber % sum == 0 ) {
	    	  answer = true;
	      } else {
	    	  answer = false;
	      }
	      return answer;
	}

 

Practice3 : 행렬의 덧셈

 

행렬의 덧셈은 행과 열의 크기가 같은 두 행렬의 같은 행, 같은 열의 값을 서로 더한 결과가 됩니다. 2개의 행렬 arr1과 arr2를 입력받아, 행렬 덧셈의 결과를 반환하는 함수, solution을 완성해주세요.

 

arr1 arr2 return
[[1,2],[2,3]] [[3,4],[5,6]] [[4,6],[7,9]]
[[1],[2]] [[3],[4]] [[4],[6]]

 

public static void main(String[] args) {
		OrderByDesc obd = new OrderByDesc();
		int [][] arr1 = {{1,2},{3,4}};
		int [][] arr2 = {{3,4},{5,6}};
		int[][] result = obd.solution( arr1, arr2 );
	
		System.out.println(Arrays.deepToString(result));
		
	}
	  public int[][] solution(int[][] arr1, int[][] arr2) {
	      int[][] answer = new int[arr1.length][arr1[0].length];
	      
	      for(int inx=0; inx<arr1.length; inx++) {
	    	  for(int jnx=0; jnx<arr1[inx].length; jnx++) {
	    		  answer[inx][jnx] = arr1[inx][jnx] + arr2[inx][jnx]; 
	    	  }
	      }
	      return answer;
	  }

 

Practice4 : 예산

 

S사에서는 각 부서에 필요한 물품을 지원해 주기 위해 부서별로 물품을 구매하는데 필요한 금액을 조사했습니다. 그러나, 전체 예산이 정해져 있기 때문에 모든 부서의 물품을 구매해 줄 수는 없습니다. 그래서 최대한 많은 부서의 물품을 구매해 줄 수 있도록 하려고 합니다.

 

물품을 구매해 줄 때는 각 부서가 신청한 금액만큼을 모두 지원해 줘야 합니다. 예를 들어 1,000원을 신청한 부서에는 정확히 1,000원을 지원해야 하며, 1,000원보다 적은 금액을 지원해 줄 수는 없습니다.

부서별로 신청한 금액이 들어있는 배열 d와 예산 budget이 매개변수로 주어질 때, 최대 몇 개의 부서에 물품을 지원해 줄 수 있는지 return 하도록 solution 함수를 완성해주세요.

d budget return
[1,3,2,5,4] 9 3
[2,2,3,3] 10 4
public static void main(String[] args) {
		OrderByDesc obd = new OrderByDesc();
		int [] arr = {1,3,2,5,4};
		int result = obd.solution( arr, 9 );
	
		System.out.println(result);
		
	}
	  public int solution(int[] d, int budget) {
	      int answer = 0;
	      Arrays.sort(d);
	      
	      for(int inx=0; inx<d.length; inx++) {
    		  if(budget >= d[inx] ) {
    			  budget -= d[inx];
    			  answer++;
    		  } 
	      }
	      
	      return answer;
  }

 

Practice5 : 소수 찾기

 

1부터 입력받은 숫자 n 사이에 있는 소수의 개수를 반환하는 함수, solution을 만들어 보세요.

소수는 1과 자기 자신으로만 나누어지는 수를 의미합니다.
(1은 소수가 아닙니다.)

 

n result
10 4
5 3
    int numberOfPrime(int n) {
        int count = 0;
        int result = 0;

        for(int i = 1 ; i <= n ; i++){
            for(int j = 1 ; j <= i ; j++){
                if ( i % j == 0) count++;
            }
            if(count == 2) result++;
            count = 0;
        }

        return result;
    }

    public static void main(String[] args) {
        NumOfPrime prime = new NumOfPrime();
        System.out.println( prime.numberOfPrime(10) );
    }

 

Practice6 : 정수 제곱근 판별

 

임의의 정수 n에 대해, n이 어떤 정수 x의 제곱인지 아닌지 판단하려 합니다.
n이 정수 x의 제곱이라면 x+1의 제곱을 리턴하고, n이 정수 x의 제곱이 아니라면 -1을 리턴하는 함수를 완성하세요.

n return
121 144
3 -1

 

	public static void main(String[] args) {
		OrderByDesc obd = new OrderByDesc();
		
		long result = obd.solution( 121 );
	
		System.out.println(result);
		
	}
	  public long solution(long n) {
	      if (Math.pow((int)Math.sqrt(n), 2) == n) {
	            return (long) Math.pow(Math.sqrt(n) + 1, 2);
	        }

	        return -1;
	  }

 

Practice7 : 최대공약수와 최소공배수

 

두 수를 입력받아 두 수의 최대공약수와 최소공배수를 반환하는 함수, solution을 완성해 보세요. 배열의 맨 앞에 최대공약수, 그다음 최소공배수를 넣어 반환하면 됩니다. 예를 들어 두 수 3, 12의 최대공약수는 3, 최소공배수는 12이므로 solution(3, 12)는 [3, 12]를 반환해야 합니다.

n m return
3 12 [3, 12]
2 5 [1, 10]
public static void main(String[] args) {
	       TryHelloWorld c = new TryHelloWorld();
	       System.out.println(Arrays.toString(c.gcdlcm(3, 12)));
	}
    public int[] gcdlcm(int a, int b) {
        int[] answer = new int[2];

        answer[0] = gcd(a,b);
        answer[1] = (a*b)/answer[0];
        
        return answer;
    }

   public static int gcd(int p, int q){
	    if (q == 0) {
	    	return p;
	    }
	    return gcd(q, p%q);
   }
class TryHelloWorld {
     
  public static void main(String[] args) {
        TryHelloWorld c = new TryHelloWorld();
        System.out.println(Arrays.toString(c.gcdlcm(3, 12)));
  }
  
  public int[] gcdlcm(int a, int b) {
        int[] answer = new int[2];
        int standard = (a > b) ? a : b;

        for(int i=1; i<=standard; i++){
          if(a % i == 0 && b % i == 0) answer[0] = i;
        }
        answer[1] = (a * b) / answer[0];

        return answer;
    }

}

Practice1 : 문자열 내림차순으로 배치하기

 

문자열 s에 나타나는 문자를 큰것부터 작은 순으로 정렬해 새로운 문자열을 리턴하는 함수, solution을 완성해주세요.
s는 영문 대소문자로만 구성되어 있으며, 대문자는 소문자보다 작은 것으로 간주합니다.

 

public class OrderByDesc {

	public static void main(String[] args) {
		OrderByDesc obd = new OrderByDesc();
		String str = "Zbcdefg";
		String reversed = obd.solution(str);
	
		System.out.println(reversed);
		
	}
	  public String solution(String s) {
	        int temp, pos;
	      
	        StringBuffer sb = new StringBuffer();
	
	        char[] strArray = s.toCharArray();
	
	        for (int inx = 0; inx < strArray.length - 1; inx++) {
	            pos = inx;
	            for (int jnx = inx + 1; jnx < strArray.length; jnx++) {
	                if (strArray[jnx] > strArray[pos]) {
	                    pos = jnx;
	                }
	            }
	            temp = strArray[inx];
	            strArray[inx] = strArray[pos];
	            strArray[pos] = (char) temp;
	        }
	      
	        for (int inx = 0; inx < strArray.length; inx++) {
	            sb.append(strArray[inx]);
	        }      
	      
	        return sb.toString();
	  }
}

 

Practice2 : 가운데 글자 가져오기

 

단어 s의 가운데 글자를 반환하는 함수, solution을 만들어 보세요. 

단어의 길이가 짝수라면 가운데 두글자를 반환하면 됩니다.

 

public class OrderByDesc {

	public static void main(String[] args) {
		OrderByDesc obd = new OrderByDesc();
		String str = "abcde";
//		String str = "qwer";
		String reversed = obd.solution(str);
	
		System.out.println(reversed);
		
	}
	 public String solution(String s) {
	        String answer = "";

	        int strLength = s.length();

	        if (strLength % 2 != 0) {
	            answer = s.substring(strLength / 2 , strLength / 2 + 1);
	        } else {
	            answer = s.substring(strLength / 2 - 1, strLength / 2 + 1);
	        }
	        return answer;
	  }
}

 

Practice3 : 나누어 떨어지는 숫자 배열

 

array의 각 element 중 divisor로 나누어 떨어지는 값을 오름차순으로 정렬한 배열을 반환하는 함수, solution을 작성해주세요.
divisor로 나누어 떨어지는 element가 하나도 없다면 배열에 -1을 담아 반환하세요.

public static void main(String[] args) {
		OrderByDesc obd = new OrderByDesc();
		int[] inputArr = {5, 9, 7, 10};
		int divisor = 5;
		int [] result = obd.solution(inputArr, 5);
	
		System.out.println(Arrays.toString(result));
		
	}
	 public int[] solution(int[] array, int divisor) {
	        int[] resultArray = {};
	        boolean isNotDivised = true;
	        ArrayList<Integer> list = new ArrayList<Integer>();

	        for (int inx = 0; inx < array.length; inx++) {
	            if (array[inx] % divisor == 0) {
	                list.add(array[inx]);
	                isNotDivised = false;
	            }
	        }

	        if (isNotDivised) {
	            list.add(-1);
	            resultArray = new int[1];
	        } else {
	            resultArray = new int[list.size()];
	        }

	        int counter = 0;
	        for (int value : list) {
	            resultArray[counter++] = value;
	        }

	        Arrays.sort(resultArray);
	        return resultArray;
	  }

 

Practice4 : 두 정수 사이의 합

 

두 정수 a, b가 주어졌을 때 a와 b 사이에 속한 모든 정수의 합을 리턴하는 함수, solution을 완성하세요. 
예를 들어 a = 3, b = 5인 경우, 3 + 4 + 5 = 12이므로 12를 리턴합니다.

 

public static void main(String[] args) {
		OrderByDesc obd = new OrderByDesc();
		long result = obd.solution(3, 5);
	
		System.out.println(result);
		
	}
	 public long solution(int a, int b) {
	      long answer = 0;
	      
	      if( a < b || a == b){
	          for(int inx=a; inx <= b ; inx++){
	              answer += inx;
	          }          
	      } else {
	          for(int inx=b; inx <= a ; inx++){
	              answer += inx;
	          }
	      }      
	      return answer;
	  }

 

Practice5 : 문자열 내 마음대로 정렬하기

 

문자열로 구성된 리스트 strings와, 정수 n이 주어졌을 때, 각 문자열의 인덱스 n번째 글자를 기준으로 오름차순 정렬하려 합니다. 

예를 들어 strings가 [sun, bed, car]이고 n이 1이면 각 단어의 인덱스 1의 문자 u, e, a로 strings를 정렬합니다

public static void main(String[] args) {
		OrderByStrIWant orderbyI = new OrderByStrIWant();
		String [] inputArray = {"sun", "bed", "car"};
		int n = 1;
		System.out.println(Arrays.toString(orderbyI.solution(inputArray, n)));
	}
	
	public String[] solution(String[] inputArray, int n) {
	      String[] answer = {};
	      ArrayList<String> list = new ArrayList<String>(); 
	      ArrayList<String> tempList = new ArrayList<String>();

	      for(int inx=0; inx< inputArray.length; inx++) {
	    	  String tempStr = inputArray[inx].substring(n,n+1);
	    	  tempList.add(tempStr+"-"+inputArray[inx]);
	      }
	      Collections.sort(tempList);
	      
	      for(int inx=0; inx<tempList.size(); inx++) {
	    	  list.add(tempList.get(inx).substring(tempList.get(inx).indexOf("-")+1));
	      }
	      
	      answer = new String[list.size()];
	      
	      for(int inx=0 ; inx < answer.length; inx++) {
	    	  answer[inx] = list.get(inx);
	      }
	      
	      return answer;
}

Practice6 : 문자열 내 p와 y의 개수

 

대문자와 소문자가 섞여있는 문자열 s가 주어집니다. s에 'p'의 개수와 'y'의 개수를 비교해 같으면 True, 다르면 False를 return 하는 solution를 완성하세요. 'p', 'y' 모두 하나도 없는 경우는 항상 True를 리턴합니다. 단, 개수를 비교할 때 대문자와 소문자는 구별하지 않습니다.

예를들어 s가 pPoooyY면 true를 return하고 Pyy라면 false를 return합니다.

 

public static void main(String[] args) {
		OrderByDesc obd = new OrderByDesc();
		boolean flag = obd.solution("pPoooyY");
	
		System.out.println(flag);
		
	}
	 boolean solution(String inputStr) {
	        boolean resultFlag = true;

	        char[] strArray = inputStr.toLowerCase().toCharArray();
	        
	       HashMap<Character, Integer> counterMap = new HashMap<>();

	       for (Character inputChar : strArray) {
	            if (counterMap.containsKey(inputChar)) {
	                counterMap.put(inputChar, counterMap.get(inputChar) + 1);
	            } else {
	                counterMap.put(inputChar, 1);
	            }
	        }

	        if (counterMap.get('p') != counterMap.get('y')) {
	            resultFlag = false;
	        }
	        return resultFlag;
	    }

 

 

Practice7 : 핸드폰 번호 가리기

 

개인정보 보호를 위해 고지서를 보낼 때 고객들의 전화번호의 일부를 가립니다.
전화번호가 문자열 phone_number로 주어졌을 때, 전화번호의 뒷 4자리를 제외한 나머지 숫자를 전부 *으로 가린 문자열을 리턴하는 함수, solution을 완성해주세요.

 

	public static void main(String[] args) {
		OrderByDesc obd = new OrderByDesc();
		String number = obd.solution("01000009999");
	
		System.out.println(number);
		
	}
	  public String solution(String phone_number) {
	      String answer = "";
	      for (int inx = 0; inx < phone_number.length(); inx++) {
	            if (phone_number.length() - 4 > inx) {
	                answer += "*";
	            } else {
	                answer += phone_number.charAt(inx);
	            }
	        }
	      return answer;
	  }

Practice8 : 시저 암호

 

어떤 문장의 각 알파벳을 일정한 거리만큼 밀어서 다른 알파벳으로 바꾸는 암호화 방식을 시저 암호라고 합니다. 예를 들어 AB는 1만큼 밀면 BC가 되고, 3만큼 밀면 DE가 됩니다. z는 1만큼 밀면 a가 됩니다. 문자열 s와 거리 n을 입력받아 s를 n만큼 민 암호문을 만드는 함수, solution을 완성해 보세요.

s n result
AB 1 BC
z 1 a
a B z 4 e F d
public static void main(String[] args) {
		OrderByDesc obd = new OrderByDesc();
		String result = obd.solution("AB", 1);
	
		System.out.println(result);
		
	}
	 public String solution(String s, int n) {
	      String answer = "";
	      char [] charArray = s.toCharArray();
	      
	      for(int inx=0; inx<charArray.length; inx++) {
	    	  char ch = charArray[inx];
	    	  if(ch != ' ') {
	    		  if(ch >= 'z') {
	    			  ch = (char) ((int)'a' + n - 1);
	    			  answer += (char)(ch);
	    		  } else {
	    			  answer += (char)(ch + n);
	    		  }
	    	  } else {
	    		  answer += (char)(' ');
	    	  }
	      }  
	      return answer;
 }

 

Practice9 : 약수의 합 :

 

자연수 n을 입력받아 n의 약수를 모두 더한 값을 리턴하는 함수, solution을 완성해주세요.

n return
12 28
5 6
	public static void main(String[] args) {
		OrderByDesc obd = new OrderByDesc();
		int result = obd.solution(12);
	
		System.out.println(result);
		
	}
	public int solution(int n) {
	      int answer = 0;
	      for(int inx=1; inx<= n; inx++) {
	    	  if(n % inx == 0) {
	    		  answer += inx;
	    	  }
	      }
	      
	      return answer;
	}

Practice10 : 이상한 문자 만들기

 

문자열 s는 한 개 이상의 단어로 구성되어 있습니다. 각 단어는 하나 이상의 공백문자로 구분되어 있습니다. 각 단어의 짝수번째 알파벳은 대문자로, 홀수번째 알파벳은 소문자로 바꾼 문자열을 리턴하는 함수, solution을 완성하세요.

 

public static void main(String[] args) {
		OrderByDesc obd = new OrderByDesc();
		String result = obd.solution("try hello world");
	
		System.out.println(result);
		
	}
	 public String solution(String s) {
	        String ss = s.toUpperCase();
	        String answer = "";
	        int count = 0;
	        for (int j = 0; j < s.length(); j++) {

	            if (s.charAt(j) == ' ') {
	                count = 0;
	                answer += " ";
	            } else if (count % 2 == 0) {
	                answer += ss.charAt(j);
	                count++;
	            } else {
	                answer += (char)(ss.charAt(j) + 32);
	                count++;
	            }
	        }
	        return answer;
	    }

+ Recent posts