1. mybatipse plugin 의 사용 이유


스프링으로 controller service serviceImpl dao vo 파일에서 작업 시 


컨트롤러에서 서비스로 이동할때 


F2를 이용하거나 ctrl을 눌러 open declaration을 통해  컨트롤러에서 이동할 서비스 위치를 찾아가곤한다.


service에서 serviceImpl도 그렇고 DAO에서 VO도 그렇다.


그런데 serviceImpl 이나 dao에서 선택자(id)에 해당하는 mapper 쿼리를 빠르게 조회해보고 싶은 경우가 있다.


이럴 경우 mybatipse plugin (Eclipse plugin adding support for MyBatis SQL Mapper Framework.) 을 사용하면 많은 도움이 된다.



2. 설치 방법



https://github.com/mybatis/mybatipse


에 들어가면 자세한 설명이 있다.



이클립스나 STS에서 설치 시 


상단 메뉴 > help > install new software > add

name : mybatipse

url : http://dl.bintray.com/harawata/eclipse

를 통해 설치가 가능하다.



3. 사용 방법


prSmartreadOnlyDAO.selectDivisonRate(prCmpnDataSet) 


selectDivisonRate 의 ctrl을 누르면 open <select/> in XML Mapper가 뜨게된다.



'전체 > 개발지식' 카테고리의 다른 글

자바(JAVA) 코딩가이드(파일명, 메소드명, 코딩규칙)  (7) 2018.10.04
Spring 개발 구성 및 파일 디렉토리 구조  (0) 2018.10.04
Servlet 정의  (0) 2017.05.15
Maven을 쓰는이유  (1) 2017.05.12
어려웠던 용어 및 개념 - 1  (0) 2017.05.12


기본적인 알고리즘 문제 풀기 - 2


문제 4. 


앞에서부터 읽을 때나 뒤에서부터 읽을 때나 모양이 같은 수를 대칭수(palindrome)라고 부릅니다.

두 자리 수를 곱해 만들 수 있는 대칭수 중 가장 큰 수는 9009 (= 91 × 99) 입니다.

세 자리 수를 곱해 만들 수 있는 가장 큰 대칭수는 얼마입니까?



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
package test1;
 
import java.util.ArrayList;
import java.util.Collections;
 
public class MyTest1 {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyClass1 myClass1 = new MyClass1();
        myClass1.method4();
    }
}
 
class MyClass1{
    // 문제4.     
    // 앞에서부터 읽을 때나 뒤에서부터 읽을 때나 모양이 같은 수를 대칭수(palindrome)라고 부릅니다.
    // 두 자리 수를 곱해 만들 수 있는 대칭수 중 가장 큰 수는 9009 (= 91 × 99) 입니다.
    // 세 자리 수를 곱해 만들 수 있는 가장 큰 대칭수는 얼마입니까?
     public void method4(){
         int intValue1;
         String stringValue1;
         ArrayList<String> arraylist = new ArrayList<String>();
        for(int i=1; i<1000; i++){
            for(int j=1; j<1000; j++){
//                System.out.println("i값: "+i+"x"+j+"="+i*j);
                intValue1 = i*j;
                stringValue1 =Integer.toString(intValue1);
                
                if(stringValue1.length() % 2 == 0){
                    if(stringValue1.length() == 2){
                        if(stringValue1.charAt(0) == stringValue1.charAt(1)){
                            System.out.println("2자리 대칭수: "+stringValue1);
                        }
                    }
                    if(stringValue1.length() == 4){ // 10 01
                        if(stringValue1.substring(0,2).equals(stringValue1.substring(3,4)+stringValue1.substring(2,3))){
                            System.out.println("4자리 대칭수: "+stringValue1);
                        }
                    }
                    if(stringValue1.length() == 6){
                        if(stringValue1.substring(0,3).equals(stringValue1.substring(5,6)+stringValue1.substring(4,5)+stringValue1.substring(3,4))){
                            System.out.println("6자리 대칭수: "+stringValue1);
                            arraylist.add(stringValue1);
                        }
                    }
                }
            }
        }        
        System.out.println("3자리 대칭수 중 가장 큰값은: "+Collections.max(arraylist));
    }
}
cs


출력결과




문제 5.


1 ~ 10 사이의 어떤 수로도 나누어 떨어지는 가장 작은 수는 2520입니다.

그러면 1 ~ 20 사이의 어떤 수로도 나누어 떨어지는 가장 작은 수는 얼마입니까? 


접근방법 5-1. if문 중첩방법



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
package test1;
 
import java.util.ArrayList;
import java.util.Collections;
 
public class MyTest1 {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyClass1 myClass1 = new MyClass1();
        myClass1.method5();
    }
}
 
 
class MyClass1{
        
     // 문제5 접근방법1.
     // 1 ~ 10 사이의 어떤 수로도 나누어 떨어지는 가장 작은 수는 2520입니다.
     // 그러면 1 ~ 20 사이의 어떤 수로도 나누어 떨어지는 가장 작은 수는 얼마입니까?     
     public void method5(){
         int n = 10000;
         for(int i=2; i<=10;){
             if(n % i == 0){// 2
                 i++;
                 if(n % i == 0){ // 3     
                     i++;
                     if(n % i == 0){ // 4          
                         i++;
                          if(n % i == 0){ // 5          
                              i++;
                               if(n % i == 0){ // 6          
                                   i++;
                                    if(n % i == 0){ // 7          
                                        i++;
                                        if(n % i == 0){ // 8        
                                            i++;
                                            if(n % i == 0){ // 9
                                                i++;
                                                if(n % i == 0){ // 10
                                                    System.out.println("1부터 10까지 나눠지는 수: "+n);
                                                    i++;
                                                }
                                            }
                                        }
                                    }
                                }
                           }
                      }
                 }
             }
             if(n>1){
                 n = n-1;                 
             }
             i = 2;
         }
     }
}
cs


출력결과




접근방법 5-2. 메소드 호출방법


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
package test1;
 
import java.util.ArrayList;
import java.util.Collections;
 
public class MyTest1 {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyClass1 myClass1 = new MyClass1();
        myClass1.method5A(999999999,2);
    }
}
 
 
class MyClass1{
    
     // 문제5 접근방법2.
     // 1 ~ 10 사이의 어떤 수로도 나누어 떨어지는 가장 작은 수는 2520입니다.
     // 그러면 1 ~ 20 사이의 어떤 수로도 나누어 떨어지는 가장 작은 수는 얼마입니까?     
     // n= 10000, i= 2
     public void method5A(int n, int i){
         while(n>1){
             if(n%i==0){ // 1000 % 2 == 0
                 i++; // 3
                 if(n > 1){
                     method5B(n, i);
                 }
                 if(i==20){
                     System.out.println("1부터 20까지 나눠지는 수: "+n);
                 }
             }else{
                 if(n>1){
                     n = n-1;
                 }
                 i = 2;  
             }             
         }
     }     
     
     public void method5B(int n, int i){     
         if (n % i == 0 ){
            i++;
        }
     }
}
 
cs


출력결과


문제 6. 


1부터 10까지 자연수를 각각 제곱해 더하면 다음과 같습니다 (제곱의 합).

1^2+2^2+3^2+4^2+5^2+6^2+7^2+8^2+9^2+10^2

1+4+9+16+25+36+49+64+81+100 = 385

1부터 10을 먼저 더한 다음에 그 결과를 제곱하면 다음과 같습니다 (합의 제곱).

(1 + 2 + ... + 10)^2 = 552 = 3025

따라서 1부터 10까지 자연수에 대해 "합의 제곱"과 "제곱의 합" 의 차이는 3025 - 385 = 2640 이 됩니다.

그러면 1부터 100까지 자연수에 대해 "합의 제곱"과 "제곱의 합"의 차이는 얼마입니까?



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
package test1;
 
import java.util.ArrayList;
import java.util.Collections;
 
public class MyTest1 {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyClass1 myClass1 = new MyClass1();
        myClass1.method6();
    }
}
 
 
class MyClass1{
 
    // 1부터 10까지 자연수를 각각 제곱해 더하면 다음과 같습니다 (제곱의 합).
    // 1^2+2^2+3^2+4^2+5^2+6^2+7^2+8^2+9^2+10^2
    // 1+4+9+16+25+36+49+64+81+100 = 385
    // 1부터 10을 먼저 더한 다음에 그 결과를 제곱하면 다음과 같습니다 (합의 제곱).
    // (1 + 2 + ... + 10)^2 = 552 = 3025
    // 따라서 1부터 10까지 자연수에 대해 "합의 제곱"과 "제곱의 합" 의 차이는 3025 - 385 = 2640 이 됩니다.
    // 그러면 1부터 100까지 자연수에 대해 "합의 제곱"과 "제곱의 합"의 차이는 얼마입니까?     
     
     public void method6(){
         int squareSum = 0;
         int sumSquare = 0;
         int subtractSquare = 0;
         for(int i=1; i<=100; i++){
             squareSum += i * i; // 1 * 1 // 2* (2*2) 3*3 4*4
         }
         System.out.println("제곱의 합: "+squareSum);
         for(int i=1; i<=100; i++){
             sumSquare += i;
         }
         sumSquare *= sumSquare;
         System.out.println("합의 제곱: "+sumSquare);
         subtractSquare= sumSquare - squareSum;
         System.out.println("합의제곱-제곱의합: "+subtractSquare);
     }     
     
}
cs


출력결과



'전체 > 알고리즘' 카테고리의 다른 글

퀵정렬  (0) 2018.08.19
단순탐색, 이진탐색, 빅오표기법, 선택정렬, 재귀  (0) 2018.08.19
기본적인 알고리즘 문제 풀기(Project Euler) - 1  (0) 2017.12.14
문자열 거꾸로 출력하기  (0) 2017.12.13
최대공약수 최소공배수 구하기  (0) 2017.12.13


기본적인 알고리즘 문제 풀기


문제 1. 


10보다 작은 자연수 중에서 3 또는 5의 배수는 3, 5, 6, 9 이고, 이것을 모두 더하면 23입니다.

1000보다 작은 자연수 중에서 3 또는 5의 배수를 모두 더하면 얼마일까요?


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
package test1;
 
import java.util.ArrayList;
import java.util.Collections;
 
public class MyTest1 {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyClass1 myClass1 = new MyClass1();
        myClass1.method1();
    }
}
 
 
class MyClass1{
    
    // 문제1. 
    // 10보다 작은 자연수 중에서 3 또는 5의 배수는 3, 5, 6, 9 이고, 이것을 모두 더하면 23입니다.
    // 1000보다 작은 자연수 중에서 3 또는 5의 배수를 모두 더하면 얼마일까요?
    public void method1(){
        int threeMulti = 0;
        int fiveMulti = 0;
        int sum = 0;
        
        for(int i=0; i<1000; i++){
            if( i%3 == 0 ){
                threeMulti += i;
            }
            if( i%5 == 0){
                fiveMulti += i;
            }
        }
        System.out.println("3의 배수: "+threeMulti);
        System.out.println("5의 배수: "+fiveMulti);
        sum = threeMulti+fiveMulti;
        System.out.println("3의배수와 5의 배수를 모두 합한 값: "+sum); ;
    }
}
cs


출력결과




문제 2.


피보나치 수열의 각 항은 바로 앞의 항 두 개를 더한 것이 됩니다. 1과 2로 시작하는 경우 이 수열은 아래와 같습니다.

1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...

짝수이면서 4백만 이하인 모든 항을 더하면 얼마가 됩니까? 



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
package test1;
 
import java.util.ArrayList;
import java.util.Collections;
 
public class MyTest1 {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyClass1 myClass1 = new MyClass1();
        myClass1.method2();
    }
}
 
 
class MyClass1{
        
    // 문제2.     
    // 피보나치 수열의 각 항은 바로 앞의 항 두 개를 더한 것이 됩니다. 1과 2로 시작하는 경우 이 수열은 아래와 같습니다.
    // 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...
    // 짝수이면서 4백만 이하인 모든 항을 더하면 얼마가 됩니까? 
    public void method2(){
        
        int previousData = 1;
        int currentData = 2;
        int nextData = previousData + currentData; // 3
        int sum = 0;
        
        while(previousData < 4000000){            
            previousData = currentData; // 2 
            if(previousData < 4000000 ){
                currentData = nextData;  // 3
                nextData = previousData + currentData; // 5 
                System.out.println("previousData: "+previousData);
                System.out.println("currentData: "+currentData);
                System.out.println("nextData: "+nextData);                
                if(previousData % 2 == 0){
                    sum = sum+ previousData;
                    System.out.println("pre짝수값: "+previousData);
                }
            }
        }
        System.out.println("짝수값: "+sum);
    }
}    
cs


출력 결과




문제 3.


어떤 수를 소수의 곱으로만 나타내는 것을 소인수분해라 하고, 이 소수들을 그 수의 소인수라고 합니다.

예를 들면 13195의 소인수는 5, 7, 13, 29 입니다. // 1, 2, 3, 5, 7, 11

600851475143의 소인수 중에서 가장 큰 수를 구하세요.



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
package test1;
 
import java.util.ArrayList;
import java.util.Collections;
 
public class MyTest1 {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyClass1 myClass1 = new MyClass1();
        myClass1.method3();
    }
}
 
 
class MyClass1{
        
    // 문제3.     
    // 어떤 수를 소수의 곱으로만 나타내는 것을 소인수분해라 하고, 이 소수들을 그 수의 소인수라고 합니다.
    // 예를 들면 13195의 소인수는 5, 7, 13, 29 입니다. // 1, 2, 3, 5, 7, 11
    // 600851475143의 소인수 중에서 가장 큰 수를 구하세요.    
    public void method3(){
        long n = 13195;
        
        // 정적 배열 사용
        long[] myNum1 = new long[10];
        long j = 0;
        long max = 0;
        
        // 동적배열에 사용하는 ArrayList
        ArrayList<Long> array = new ArrayList<Long>();
        
        for(long i=2; i<=n; i++){ // 2639
            if(n % i == 0){
                n = n / i;
                myNum1[(int) j++] = i;
                array.add(i);
            }
        }
        long maxValue = Collections.max(array);
        System.out.println("동적배열 최대값: "+maxValue);
        
        // 정적 배열 비교
        for(int i=0;i<j;i++){
            max = myNum1[0]; 
            if(max < myNum1[i]){
                max = myNum1[i];
            }
        }
        System.out.println("정적배열 최대값: "+max);
    }
}
 
cs


출력 결과






'전체 > 알고리즘' 카테고리의 다른 글

단순탐색, 이진탐색, 빅오표기법, 선택정렬, 재귀  (0) 2018.08.19
기본적인 알고리즘 문제 풀기(Project Euler) - 2  (1) 2017.12.15
문자열 거꾸로 출력하기  (0) 2017.12.13
최대공약수 최소공배수 구하기  (0) 2017.12.13
하노이의 탑 구현  (0) 2017.12.12



사용자로부터 문자열을 입력받아 문자열을 거꾸로 출력해본다.



접근방법


1. 사용자로 부터 문자열 입력받기 위한 scan사용


2. 사용자로 부터 문자를 받아 저장할 변수, 거꾸로 문자열을 저장할 변수, 받은 문자열의 길이를 저장할 변수 선언


3. 받은 문자열 길이를 저장할 변수 - 1을 하여 charAt(index)로 접근한다.


4. 길이만큼 반복하며 거꾸로 저장한다.



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package test1;
 
import java.util.Scanner;
 
public class reverseChar {
 
    public static void main(String[] args) {
        
        Scanner scan = new Scanner(System.in);
        System.out.println("String 입력: ");
 
        String value1; // 사용자에게 입력 받아 저장할 변수
        String value2 = ""; // 거꾸로 문자 저장할 변수
        value1 = scan.nextLine(); // 사용자에게 입력 받기 위해 scanner 사용
        
        int valueLength = value1.length()-1; // 사용자에게 입력 받은 값의 길이 - 1
        
        ReverseClass reverseClass = new ReverseClass();
        reverseClass.reverseMethod(value1,valueLength, value2);
        
    }
}
 
class ReverseClass {
    public void reverseMethod(String value1,int valueLength, String value2){
        for(int i=valueLength; i>=0; i--){ // abc가 들어올 경우 valueLength = 2 부터 1 0 총 3번을 반복한다.
            value2 += value1.charAt(i); // abc가 들어올 경우 charAt은 문자의 위치가 0부터 시작해 2까지다.
        }
        System.out.println(value2);
    }
}
cs



출력 결과




마지막으로 소스를 첨부한다.


reverseChar.java




'전체 > 알고리즘' 카테고리의 다른 글

기본적인 알고리즘 문제 풀기(Project Euler) - 2  (1) 2017.12.15
기본적인 알고리즘 문제 풀기(Project Euler) - 1  (0) 2017.12.14
최대공약수 최소공배수 구하기  (0) 2017.12.13
하노이의 탑 구현  (0) 2017.12.12
자바 배열 최대값 구하기, 배열 중복되는 값 구하기  (0) 2017.12.12



최대공약수 최소공배수 구하기



최대공약수 접근방법


1. 최대공약수는 두개의 값을 받아 두개의 값 모두 같은 수로 나누어 나머지가 0이 되는 공통되는 수를 찾는 것을 말한다.


2. 두 수 value1, value2 (15, 35) 를 받고 2개의 수를 비교해 작은 수(15)를 변수(a)에 담고  


3. value1과 value2를 각각 변수(a)로 나누었을때 ( value1 % 변수a == 0 ) && ( value2 % 변수a == 0 ) 둘다 나머지가 0이 나오면 


4. 최대공약수이다. 둘다 나머지가 0 이 나오지 않으면 둘다 나머지가 0이 나올 때 까지 변수a값을 -1 씩 감소시키며 반복한다.




유클리드 접근방법


1. 재귀 형식으로 접근한다.


value1과 value2 값을 받아 앞의값 % 뒤에값이 0 이 나오지 않으면 반복한다.

나머지가 0이 나오면 최대공약수를 리턴한다.


myMethod2(value2, value1%value2)




최소공배수 접근방법


1.  value1 * value2 / 앞서 구한 최대공약수 = 최소공배수이다.



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
package test1;
 
import java.util.Scanner;
 
public class Gcd_Lcm {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
 
        Scanner scan = new Scanner(System.in);
         
        System.out.println("숫자 2개 입력:");
 
        int value1, value2;
        value1 = scan.nextInt();
        value2 = scan.nextInt();
                
        pubMethod1 pub_method1 = new pubMethod1();
        
        // gcb
        pub_method1.myMethod1(value1, value2);
        System.out.println("gcb(최대공약수): "+pub_method1.myMethod1(value1, value2));
        
        // 유클리드
        pub_method1.myMethod2(value1, value2);
        System.out.println("유클리드: "+pub_method1.myMethod2(value1, value2));
        
        // lcm
        pub_method1.myMethod3(value1, value2);
        System.out.println("lcm(최소공배수): "+pub_method1.myMethod3(value1, value2));
    }
 
}
 
class pubMethod1{
    
    // 1. 일반적인 gcb(최대공약수) 구하기
    public int myMethod1(int value1, int value2){
        int minNum1 = Math.min(value1,value2);
        while(true){
            if(value1%minNum1==0 && value2%minNum1==0){
                return minNum1;
            }
            minNum1-=1;
        }
    }
    
    // 2. 유클리드 알고리즘
    // gcb(a,b) = gcb(b, a%b)
    public int myMethod2(int value1, int value2){ // 40 20
        if(value2==0){
            return value1;
        }else{
            return myMethod2(value2, value1%value2); // 20 , 40 / 20 
        }
    }
    
    // 3. lcm(최소공배수) 구하기
    public int myMethod3(int value1, int value2){
        return value1 * value2 / myMethod1(value1, value2);
    }
    
}
cs


출력 결과



마지막으로 해당 소스를 첨부한다.


Gcd_Lcm.java



'전체 > 알고리즘' 카테고리의 다른 글

기본적인 알고리즘 문제 풀기(Project Euler) - 1  (0) 2017.12.14
문자열 거꾸로 출력하기  (0) 2017.12.13
하노이의 탑 구현  (0) 2017.12.12
자바 배열 최대값 구하기, 배열 중복되는 값 구하기  (0) 2017.12.12
피보나치 수열 구현 두가지 방법  (0) 2017.12.11


하노이의 탑


원반이 n개인 하노이 탑이 어떻게 이동되는지 몇번 이동하는지 구해보자.



조건


하노이의 탑은 다음과 같이 크기 가 다른 원반이 한 기둥에 놓여져 있고 


원반을 모두 왼쪽에서 오른쪽으로 옮겨야 한다.


원반은 큰 것이 아래로 가게 쌓아야 하며 작은 원반 위에 큰 원반이 올 수 없다.


원반을 옮길 때에는 가장 위에 쌓여있는 원반 부터 옮겨야 한다.




1. 원반이 1개 일때


1번에서 3번으로 옮기면 된다.



2. 원반이 2개 일때


1번 기둥의 맨 위에 있는 원반 하나를 2번 기둥에 옮긴다. ( 1 -> 2 )


1번 기둥의 마지막 남아있는 원반 하나를 3번 기둥에 옮긴다. ( 1 -> 3 )


2번 기둥에 있는 원반 하나를 3번 기둥에 옮긴다. ( 2 -> 3 )



3. 원반이 3개 일때


1. 1번 기둥의 가장 작은 원반 하나를 3번 기둥에 옮긴다. ( 1 -> 3 )


2. 1번 기둥의 중간 원반 하나를 2번 기둥에 옮긴다. ( 1 -> 2 )


3. 3번 기둥의 가장 작은 원반 하나를 2번 기둥에 옮긴다 ( 3 -> 2 )


4. 1번 기둥의 가장 큰 원반을 3번 기둥에 옮긴다. ( 1 -> 3 )


5. 2번 기둥에 가장 작은 원반 하나를 1번 기둥에 옮긴다. ( 2 -> 1 )


6. 2번 기둥에 중간 원반 하나를 3번 기둥에 옮긴다. ( 2 > 3 )


7. 1번 기둥에 가장 작은 원반을 3번 기둥에 옮긴다. ( 1 -> 3 )


총 7번 옮김



4. 원반이 n개 일때


1번 기둥에 있는 n-1개 원반을 2번 기둥에 옮긴다.


1번 기둥에 가장 큰 원반을 3번 기둥으로 옮긴다.


2번 기둥에 있는 n-1개 원반을 3번 기둥으로 옮긴다.



소스코드


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package test1;
 
public class Hanoi {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("n=3");
        MyHanoi myHanoi = new MyHanoi();
        
//        myHanoi.hanoiFunction(3, 1, 2, 3);
        System.out.println("총 옮긴 횟수: "+myHanoi.hanoiFunction(3, 1, 2, 3)); // 2의 n제곱 - 1 = 옮긴 횟수
    }
}
class MyHanoi{
    int count = 0 ;
    int hanoiFunction(int n, int first, int second, int third) { 
        if(n==1){
            System.out.println(first+"->"+third); 
            count++;
            return count;
        }
        hanoiFunction(n-1, first, third, second);  
        System.out.println(first+"->"+third); 
        count++; 
        hanoiFunction(n-1, second, first, third); 
        
        return count;
    }    
}
cs



출력결과


마지막으로 해당 소스를 첨부한다.


Hanoi.java





'전체 > 알고리즘' 카테고리의 다른 글

문자열 거꾸로 출력하기  (0) 2017.12.13
최대공약수 최소공배수 구하기  (0) 2017.12.13
자바 배열 최대값 구하기, 배열 중복되는 값 구하기  (0) 2017.12.12
피보나치 수열 구현 두가지 방법  (0) 2017.12.11
n값을 받아 1부터 n까지의 합계 구하기  (0) 2017.12.11



코딩을 하다 콜렉션 객체를 사용하려고 


Map  map1 = new HashMap(); 으로 객체를 생성하려고 했는데 객체가 생성되는 것을 확인하였다.


나는 원래 대부분 객체를 생성할 때 

HashMap map1 = new HashMap(); 과 같이 생성자의 이름과 객체명 앞 타입을 앞뒤 동일하게 맞춰 생성하였다. 


HashMap map1 = new HashMap(); 과 

  Map map1 = new HashMap(); 이 뭐가 다른지 궁금했다.


Map map1 = new Map();은 되는 것인가? 


List list1 = new ArrayList(); 은 되는 것인가?


Collection map1 = new HashMap(); 은 되는가? 등등 


테스트를 통해 인터페이스와 클래스 간 호출, 클래스와 클래스 간의 호출에 대해 알 수 있었다.




작업 방법 및 소스 설명

1. Computer 클래스와 Laptop 클래스가 있다.


2. Computer 클래스에는 cpu, ram, power, mainboard 라는 속성이 있고


3. Laptop 클래스에는 Computer 클래스에는 없는 touchPad, wireless 속성이 있다.


4. Computer 클래스는 부모 클래스 이고 Laptop 클래스는 자식 클래스이다.


5. Laptop은 Computer 클래스를 상속받는다.


6. 객체를 생성할 때 Computer 클래스의 computer 변수명으로 Laptop 생성자를 호출시켜 객체 생성한다.


7. computer 객체가 Laptop 클래스의 메소드를 호출할 수 있는지 확인한다.


8. 부모클래스와 자식클래스 간의 호출이므로 computer 객체는 Laptop 클래스의 메소드를 호출 할 수 없으므로 

캐스팅을 이용한다.


9. 인터페이스에서 클래스 호출하는 것은 된다.


10. 인터페이스에서 인터페이스를 객체화 하는 것은 오류가 난다.


11. Map은 인터페이스 이므로 객체화 할수 없으므로 인터페이스 아래 클래스를 호출해 사용해야 한다.


12. Map은 인터페이스 이므로 메소드에 대한 선언만 있으므로 Map과 HashMap 두개의 선언 방식은 같다.




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
package test1;
 
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
public class ObjectTest {
 
    public static void main(String[] args) {
        
 
        // 1. 부모클래스와 자식클래스 간의 호출
        
        // Computer 클래스로부터 computer이라는 변수명으로 Laptop 생성자 호출시키고 new 연산자 를 통해 객체를 저장할 메모리 할당 후 객체 초기화한다.
        Computer computer = new Laptop();
        computer.setCpu("i7-7700K");
        // ex) computer.setTouchPad("touchModelB"); -> 호출 안됨.
        // computer에선 Laptop 클래스의 메소드를 호출할 수 없다. 
 
        // computer 객체에서 Laptop 클래스의 메소드를 호출 하려면
        // 부모클래스에서 자식클래스 메소드 사용하기 위한 캐스팅이 필요하다.
        ((Laptop) computer).setTouchPad("touchModelB");
        System.out.println(((Laptop) computer).getTouchPad());        
        
        // 2. 인터페이스와 클래스 간의 호출
        
        Map map1 = new Map(); // -> 객체화 오류 발생
        
        // Map은 인터페이스 이므로 객체화 할수 없으므로 객체를 생성할 수 없다.
        // Map ConcurrentHashMap, HashMap, LinkedHashMap, TreeMap 같은 구현클래스를 선택해서 사용해야 한다.
        
        // 1. Map
        Map map2= new HashMap();
        map2.put(1, "데이터1");
        System.out.println(map2.get(1));
        
        // 2. HashMap 
        HashMap hashmap1 = new HashMap();
        hashmap1.put(1, "데이터1");
        System.out.println(hashmap1.get(1));
        
        // Map은 인터페이스 이므로 메소드에 대한 선언만 있으므로 두개의 선언 방식은 똑같다.
        
    }
}
 
// 컴퓨터 클래스에 속성 - cpu, ram, power, mainboard
class Computer{
    String cpu;
    String ram;    
    String power;
    String mainBoard;
    
    public Computer(){
    }
    
    public String getCpu() {
        return cpu;
    }
    public void setCpu(String cpu) {
        this.cpu = cpu;
    }
    public String getRam() {
        return ram;
    }
    public void setRam(String ram) {
        this.ram = ram;
    }
    public String getPower() {
        return power;
    }
    public void setPower(String power) {
        this.power = power;
    }
    public String getMainBoard() {
        return mainBoard;
    }
    public void setMainBoard(String mainBoard) {
        this.mainBoard = mainBoard;
    }
}
 
// 랩탑의 속성 - 터치패드, 무선
class Laptop extends Computer{
    String touchPad;
    String wireless;
    
    public Laptop(){
        super();
    }
    
    public String getTouchPad() {
        return touchPad;
    }
    public void setTouchPad(String touchPad) {
        this.touchPad = touchPad;
    }
    public String getWireless() {
        return wireless;
    }
    public void setWireless(String wireless) {
        this.wireless = wireless;
    }
    
}
cs


해당 소스를 통해 Map은 메소드가 선언만 되어있는 인터페이스인 것을 확인했다.


마지막으로 해당 소스를 첨부한다.



ObjectTest.java




'전체 > Java' 카테고리의 다른 글

Camel to Underscores, Underscores to Camel 플러그인 AnyEdit 사용하기  (0) 2018.04.04
자바, 자바스크립트 Array to String, String to Array 문자열을 배열로 넣는 방법  (0) 2018.04.04
인터페이스 개념 이해하기  (0) 2017.10.13
JSONObject, JSONArray, JSONParser 사용해 데이터 만들어 파싱하기  (3) 2017.09.21
fail-fast 방식 개념  (0) 2017.09.20


배열에서 최대값 구하기



접근방법


1. 배열의 첫번째 index에 해당하는 값에 max value 라고 변수 지정해준다.


2. max value 변수를 배열의 길이만큼 하나하나 비교한다.


3. 비교해서 기존의 max value보다 배열의 index에 해당하는 값이 크면 max value에 값을 바꿔준다.


4. 반복을 다 돌면 배열에서 가장 큰 값이 max value가 된다.




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
package test1;
 
public class MaxValue {
 
    public static void main(String[] args) {
        
        int[] value = {10,5,2,7,15,30,50,100,150,3,5,7};
        int valueLength =value.length;
        int maxValue = value[0];
        int maxIdx = 0;
                
        MyMethod1 mymethod1 = new MyMethod1();
        System.out.println(mymethod1.findMaxValue(value, valueLength, maxValue));
        
        System.out.println(mymethod1.findMaxNumber(value, valueLength, maxIdx));
 
    }
 
}
 
 
class MyMethod1{
    
    // 최대값 구하기
    int findMaxValue(int[] value,int valueLength, int maxValue){
        for(int i=0; i<valueLength; i++){
            if(value[i] > maxValue){
                maxValue = value[i];
            }
        }
        
        return maxValue;
    }
    
    // 최대값의 배열Index 구하기
    int findMaxNumber(int[] value,int valueLength, int maxIdx){
        for(int i=0; i<valueLength; i++){
            if(value[i] > value[maxIdx]){
                maxIdx = i;
            }
        }
        return maxIdx;
    }
    
}
cs


같은 방식으로 최대값의 Index값도 확인 할 수 있다.


출력결과



배열에서 중복되는 값 구하기


접근방법


1. value 배열의 John값을 Eric, Mike, Kelly ... 마지막 원소의 값까지 1:1 비교한다.


2. String 값이 같은 것은 John, Mike , Kelly


3. 2번째 Eric을 Mike Kelly ... 순으로 비교


4. 자기자신과는 비교하지 않고 자기 다음 이름과 비교만 하면 된다.


5. 이름이 같다면 배열에 추가



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
package test1;
 
import java.util.ArrayList;
import java.util.List;
import java.util.stream.IntStream;
 
public class SameNameFind {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String[] value = {"John","Eric","Mike","Kelly","Mike","Tom","Kelly","Henly","John"};
        int valueLength = value.length;
    
        findNameMethod findnamemethod = new findNameMethod();
        System.out.println(findnamemethod.findSameName(value, valueLength));
        findnamemethod.findSameName2(value, valueLength);
        
    }
 
}
 
/*
 * 1. value 배열의 John값을 Eric, Mike, Kelly ... 마지막 원소의 값까지 1:1 비교한다.
 * 2. String 값이 같은 것은 John, Mike , Kelly
 * 3. 2번째 Eric을 Mike Kelly ... 순으로 비교
 * 4. 자기자신과는 비교하지 않고 자기 다음 이름과 비교만 하면 된다.
 * 5. 이름이 같다면 배열에 추가
 * 
 */
 
 
class findNameMethod{
    
    // 배열에서 중복되는 값 찾아 존재하면 중복되는 값 새 배열에 추가
    ArrayList<String> listA = new ArrayList<String>();
    ArrayList<String> findSameName(String[] value, int valueLength){
        for(int i=0; i<valueLength-1; i++){// 자기 자신을 제외한 모든 이름 비교
            for(int j=i+1; j<valueLength; j++){ // 앞에 비교한 이름을 비교하지 않는다.
                if(value[i] == value[j]){
                    listA.add(value[i]); // 같으면 추가한다.
                }
            }
        }
        return listA;
    }    
    
    // 각각 어떻게 비교하는지 확인
    void findSameName2(String[] value, int valueLength){
        for(int i=0; i<valueLength-1; i++){// 자기 자신을 제외한 모든 이름 비교
            for(int j=i+1; j<valueLength; j++){ // 앞에 비교한 이름을 비교하지 않는다.
                System.out.println(value[i]+","+value[j]);
            }
        }
    }    
}
cs


출력결과



배열에서 중복되는 값이 무엇인지, 어떻게 비교하는지 출력결과를 통해 알수 있었다.


마지막으로 해당 소스를 첨부한다.



MaxValue.java

SameNameFind.java




'전체 > 알고리즘' 카테고리의 다른 글

문자열 거꾸로 출력하기  (0) 2017.12.13
최대공약수 최소공배수 구하기  (0) 2017.12.13
하노이의 탑 구현  (0) 2017.12.12
피보나치 수열 구현 두가지 방법  (0) 2017.12.11
n값을 받아 1부터 n까지의 합계 구하기  (0) 2017.12.11

+ Recent posts

티스토리툴바