백준 4673번 셀프 넘버

JAVA/알고리즘|2019. 6. 14. 23:45

1 ~ 10000까지의 숫자중에 셀프 넘버가 아닌 데이터를 noSelfNumber에 집어넣고 loop를 순회하면서 selfNumber 여부를 체크하면 된다. 간단한 문제이다.

https://www.acmicpc.net/problem/4673

 

4673번: 셀프 넘버

문제 셀프 넘버는 1949년 인도 수학자 D.R. Kaprekar가 이름 붙였다. 양의 정수 n에 대해서 d(n)을 n과 n의 각 자리수를 더하는 함수라고 정의하자. 예를 들어, d(75) = 75+7+5 = 87이다. 양의 정수 n이 주어졌을 때, 이 수를 시작해서 n, d(n), d(d(n)), d(d(d(n))), ...과 같은 무한 수열을 만들 수 있다.  예를 들어, 33으로 시작한다면 다음 수는 33 + 3 + 3 = 39이고, 그 다음 수는

www.acmicpc.net

import java.util.ArrayList;
import java.util.List;

public class Main {

    public static void main(String[] args) {
        getNonSelfNumber();
    }

    public static void getNonSelfNumber() {
        List<Integer> nonSelfNumber = new ArrayList<>();

        for (int i = 1; i < 10000; i++) {
            if (!nonSelfNumber.contains(i)) {
                System.out.println(i);
            }

            nonSelfNumber.add(func(i));
        }

    }

    public static int func(int num) {
        int result = num;

        while (num != 0) {
            result += num % 10;
            num /= 10;
        }

        return result;
    }

}

댓글()

JPA 상속관계 매핑 전략

web/JPA|2018. 10. 31. 00:58

객체 지향으로 데이터베이스 중심 매핑을 변경하기 위해서 가장 애매한게 상속이다. 이런 상속관계속에서 테이블로 구현할 3가지 방법을 선택할 있다.


1) 각각의 테이블로 변환 : 각각을 모두 테이블로 만들고 조회할 조인을 사용.

2) 통합 테이블로 변환 : 테이블을 하나만 사용해서 통합 

3) 서브타입 테이블로 변환 : 서브 타입마다 하나의 테이블을 만드는 방식.



순서대로 하나씩 정리해보자.




각각의 테이블로 변환 (조인전략)

- 부모와 각각의 자식 엔티티를 모두 각자의 테이블로 만들고 부모의 기본키와 자식의 외래키를 사용하여 조인하여 사용한다.

-  자식 엔티티의 타입을 구별하기 위한 DTYPE 컬럼을 구분컬럼으로 추가하여 사용한다. (없어도 무관)


1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Entity
@Inheritance(strategy = InheritanceType.JOINED)
@DiscriminatorColumn(name = "DTYPE")
public abstract class Culture {
  
  @Id @GeneratedValue
  @Column(name = "CULTURE_ID")
  private Long id;
  
  private String name;
  private int price;
  
}
 
cs

-> 부모 추상 클래스 Culture 선언된 애노테이션에 대한 설명은 다음과 같다.


1
2
3
4
5
6
7
8
9
10
11
12
@Inheritance(strategy = InheritanceType.JOINED) : 조인전략 사용을 의미
@DiscriminatorColumn(name = "DTYPE") : 부모 클래스에 구분 컬럼으로 써 자식 테이블을 구분할 때 사용할 키로 사용된다. 기본값은 DTYPE이며 바꿔서 사용가능 (해당 기능을 사용하지 않아도 무관하다.)
 
 
@Entity
@DiscriminatorValue("M")
public class Movie {
 
  private String artiest;
  private String genre;
 
}
cs


기본적으로 사용하는 자식클래스 형식이다. 기본적으로 부모 테이블의 ID 컬럼명을 승계받아 사용 하지만 만약 변경하고 싶은 경우 클래스 위에 @PrimaryKeyJoinColumn(name = "MOVIE_ID")처럼 정의해서 사용할 있다.


조인전략의 장점은 저장공간을 효율적으로 관리하거나 테이블의 정규성이 지켜진다는 점이 있지만 조회할 조인이 많아지고 조회 쿼리시 귀찮아지며 수정이 발생하면 부모와 자식 테이블 두번을 해주어야한다.

 


 통합 테이블로 변환 (단일 테이블 전략)

부모의 속성과 자식의 속성을 하나의 테이블로 사용하는 것이다. 그리고 구분 컬럼 DTYPE 추가하여 해당 테이블이 어떤 자식 엔티티를 기반으로 만들어진 테이블인지 구분한다. (DTYPE 어떤자식인지 구분하기 위해 사용한다. 만약 속성이 같은 자식인 경우 구분이 안되기 때문이다.) 해당 전략의 단점으로는 자식 엔티티에 추가된 필드는 필수가 아니기 때문에 null 입력 되어도 된다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "DTYPE")
public abstract class Culture {
 
  @Id @GeneratedValue
  @Column(name = "CULTURE_ID")
  private Long id;
 
  private String name;
  private int price;
 
}
 
cs

-> Inheritance(strategy = InheritanceType.SINGLE_TABLE) 조인 타입을 단일 테이블 전략으로 지정한다. 


1
2
3
4
5
6
7
@Entity
@DiscriminatorValue("M")
public class Movie extends Culture {
 
  private String genre;
 
}
cs


 하나의 테이블로 지정되기 때문에 조인전략과 다르게 자식클래스를 구분할 있는 DTYPE 무조건 추가되어야 한다. 방식은 하나로 묶여있어 쿼리가 단순하다는 장점이 있지만 자식 엔티티의 필드의 null 무조건 허용해줘야 한다는 것과 자식마다 성격이 모두 달라도 테이블에 필요없는 필드까지 추가되어 있어야 하는 문제점이 있다.



- 서브타입 테이블로 변환 (구현 클래스마다 테이블 전략)

 자식 엔티티 마다 별도의 모든 테이블을 만들어 주는 방식이다. 부모와 자식을 키로 묶어서 사용하는 조인 방식과 다르게 자식 마다 부모의 속성과 자식의 속성을 모두 포함한 엔티티를 개별적으로 모두 만드는 것이다.


1
2
3
4
5
6
7
8
9
10
11
12
13
@Entity
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
@DiscriminatorColumn(name = "DTYPE")
public abstract class Culture {
 
  @Id @GeneratedValue
  @Column(name = "CULTURE_ID")
  private Long id;
 
  private String name;
  private int price;
 
}
cs


- 단일테이블 전략과 다르게 모든 자식 테이블이 별도로 만들어지기 때문에 필요없는 필드가 추가되지 않아서 not null조건을 넣어줄 있다. 하지만 모두 만들어야하고 자식테이블끼리 합칠 성능의 문제가 발생할 있다. 가장 비효율적인 방법으로 일반적으로 조인이나 단일 테이블 전략중에서 사용한다.


- 참고 JAVA ORM 표준 JPA 프로그래밍


댓글()

JPA 매핑 어노테이션 - DDL

web/JPA|2018. 10. 12. 00:29

JPA 매핑에 사용되는 어노테이션은 크게 유형에 따라 4가지로 나누어진다.

유형
어노테이션
객체와 테이블 매핑
@Entity, @Table
기본 키 매핑
@Id
필드와 컬럼 매핑
@Column
연관관계 매핑
@ManyToOne, @JoinColumn


@Entity

JPA를 사용해서 테이블과 매핑할 클래스에는 무조건 붙혀야하는 어노테이션이다. 속성으로 name을 지정할 수 있다. 안할 시 기본 클래스 이름으로 한다.

1
@Entity(name = "Member")
cs


- 기본 생성자가 필수로 있어야 한다. 
- final 클래스와 private 생성자는 할 수 없다.


@Table

엔티티와 매핑할 테이블을 지정한다. 생략하면 매핑하는 엔티티이름으로 대신한다.
-name, catalog, schema, uniqueConstraints(DDL 선언시 유니크 제약조건) 등을 같이 설정하여 만들 수 있다.

이렇게 설정된 클래스를 가지고 자동으로 테이블을 생성할 수 있다.

1
spring.jpa.hibernate.ddl-auto=update
cs

설정하는 값에 따라서 테이블 생성이 달라지는데 create는 기존 테이블을 삭제하고 새로 생성하고, create-drop는 애플리케이션이 종료될때 제거되고 update는 변경된 사항만 수정하고 validate는 매핑정보가 달라졌을때 경고를 주면서 애플리케이션 실행을 하지 않고 none는 아무런 동작을 하지 않는다.


DDL 생성 시 설정

@Colummn 매핑에는 nullable 속성과 length등의 속성을 지정할 수 있다

1
2
3
4
@Column(name = "NAME", length = 10, nullable = false)
private String userName;
 
// NAME varchar(10) not null 과 매핑
cs


@Table 어노테이션은 UniqueConstraint를 지정할 수 있다.

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
/**
 * springboottest
 *
 * @author wedul
 * @since 03/10/2018
 **/
@Entity(name = "Member")
@Data
@Table(name = "MEMBER", uniqueConstraints = {@UniqueConstraint(
        name = "NAME_AGE_UNIQUE", columnNames = {"NAME""AGE"}
)})
public class Member {
 
  @Id
  @Column(name = "ID")
  private String id;
 
  @Column(name = "NAME", length = 10, nullable = true)
  private String userName;
 
  // 매핑 정보가 없는 필드
  private int age;
 
}
 
// ALTER TABLE MEMBER ADD CONSTRAINT NAME_AGE_UNIQUE UNIQUE(NAME, AGE); 로 매핑
cs


기본키는 @Id를 사용하여 지정할 수 있고 AUTO_INCREMENT와 같은 기능을 @GeneratedValue를 사용하여 지정할 수 있다.

1
2
3
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private long orderId;
cs


추가적인 속성으로 IDENTITY(기본키 생성을 데이터베이스가 함), SEQUENCE(데이터베이스 시퀀스를 사용해서 기본 키 할당), TABLE (키 생성 테이블 생성)이 있다. 각 속성이 모든 데이터베이스 업체에 적용되는건 아니고 적용되는 벤더만 사용된다. 만약 이 모든 설정을 하는게 번거롭다면 그냥 @GeneratedValue 어노테이션만 사용하면 된다. 왜냐하면 기본 설정이 GenerationType.AUTO인데 이는 벤더에 맞게 전략이 선택되어 사용된다.


레퍼런스 : 자바 ORM 표준 JPA 프로그래밍

댓글()

JPA 기본 어노테이션 설명

web/JPA|2018. 10. 6. 11:04

JPA에서 사용되는 기본적인 어노테이션 몇개를 정리해보자.


@Entity

- 클래스와 테이블과 매핑한다고 JPA에게 알려준다. 이렇게 @Entity가 사용될 클래스를 엔티티 클래스라고 한다.


@Table

- 엔티티 클래스에 매핑할 테이블 정보를 알려준다. (이 어노테이션을 생략하면 클래스 이름을 테이블정보로 매핑한다.)


@Id

- 엔티티 클래스의 필드를 테이블에 기본키로 매핑한다. (데이터베이스는 엔티티를 구별할때 이 키값으로 구분한다.)


@Column

- 필드를 컬럼에 매핑한다.


매핑 정보가 없는 필드

- @Column을 생략하면 필드명을 사용해서 컬럼명과 매핑하게 된다. 만약 대소문자를 데이터베이스가 구분할 경우에는 꼭 위에 @Column어노테이션을 사용해서 진행해야한다.


#Dialect(방언)

- 데이터베이스마다 서로 다른 특징(Mysql의 limit, Oracle의 Rownum....)들을 JPA에서 방언(Dialect)라고 한다. 이렇게 데이터베이스 벤더사마다 서로 다른 기능을 사용해서 JPA를 사용하면 나중에 데이터베이스를 바꿀때 문제가 발생하기 때문에 문제가 없는 방언 클래스를 사용해야한다. 


위의 어노테이션이 적용된 클래스

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
package com.wedul.springboottest.member.dto;
 
import lombok.Data;
 
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
 
/**
 * springboottest
 *
 * @author wedul
 * @since 03/10/2018
 **/
@Entity
@Data
@Table(name = "MEMBER")
public class Member {
 
  @Id
  @Column(name = "ID")
  private String id;
 
  @Column(name = "NAME")
  private String userName;
 
  // 매핑 정보가 없는 필드
  private int age;
 
}
 
cs


댓글()

백준 1929번 소수 구하기 문제

JAVA/알고리즘|2018. 10. 5. 00:25

일반적으로 소수 구하는 방식으로 진행하면 시간이 너무 걸려서 에러가 발생한다. 그래서 고민하던 중에이런 생각이 났다. 모든 수는 자신의 제곱근 이상의 수로 나눠지지 않기 때문에 자신의 제곱근까지 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
48
49
50
51
52
53
54
55
56
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
 
public class Main {
 
    public static void main(String[] args) {
 
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
 
        List<Integer> result = new ArrayList<>();
 
        // 순환
        for (int i = n; i <= m; i++) {
            if (isDecimal(i)) {
                result.add(i);
            }
        }
 
        // 결과 출력
        result.stream().forEach((e) -> {
            System.out.println(e);
        });
 
    }
 
    /**
     * 소수 체크
     *
     * @param num
     * @return
     */
    private static boolean isDecimal(int num) {
 
        if (1 == num) {
            return false;
        }
 
        /**
         * 자연수는 자신의 제곱근 이상의 수로 나눠지지 않는다는 조건을 이용해서, 자신의 제곱근 수 까지의 수로 나눠지는지 여부를 판단.
         */
        int sqrpData = new BigDecimal(Math.sqrt(num)).intValue();
 
        for (int i = 2; i <= sqrpData; i++) {
            if (num % i == 0) {
                return false;
            }
        }
 
        return true;
    }
 
}
cs


댓글()

백준 알고리즘1032 명령프롬프트 문제

JAVA/알고리즘|2018. 10. 4. 00:46

문제

입력된 파일 리스트를 보고 공통적으로 사용될 수 있는 Regex를 찾아서 출력하는 문제이다.


코드

코드는 간단하게 처음입력받은 파일명을 기준으로 잡고 추가로 들어오는 나머지 파일명들과 다른 부분에 대해서 모두 ?로 바꿔버렸다.


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
import java.util.Scanner;
 
public class Main {
 
 
    public static void main(String[] args) {
 
        Scanner sc = new Scanner(System.in);
 
        // 파일 개수 입력
        int wordCnt = sc.nextInt();
 
        // 첫 번째 파일이름
        char[] creteria = sc.next().toCharArray();
 
        // 나머지 파일들 이름을 받으면서 Regex todtjd
        for (int i = 1; i < wordCnt; i++) {
            String fileName = sc.next();
 
            // 첫 번째 이름을 기준으로 이름이 다른 부분에 대해서 ? 처리
            for (int j = 0; j < creteria.length; j++) {
                char data = creteria[j];
 
                if (data != '?') {
                    if (data != fileName.charAt(j)) {
                        creteria[j] = '?';
                    }
                }
            }
        }
 
        for (char ch : creteria) {
            System.out.print(ch);
        }
    }
}
 
cs

자세한 코드는 Git 참고
https://github.com/weduls/algorithm/blob/master/%EB%AC%B8%EC%9E%90%EC%97%B4%20%EC%B2%98%EB%A6%AC/%EB%AA%85%EB%A0%B9%20%ED%94%84%EB%A1%AC%ED%94%84%ED%8A%B8/wedul/Main.java

댓글()

Iterator 그리고 Iterable에 대해 정리

JAVA/고급 자바|2018. 10. 4. 00:19

Java8의 Stream에 map 기능을 사용하다가 이런문제를 겪었다.



Iterable과 Iterator 정확한 정리를 하지 않고 무턱대고 사용하다보니 발생한 문제였다.

정확하게 집고 넘어가기 위해 정리해보자.

Iterator

Iterator는 자바 1.2에 발표된 인터페이스이다.  hasNext, next 등을 통해 현재 위치를 알 수 있고 다음 element가 있는지를 판단하는 기능등에 대한 명세를 제공한다. 이를 사용하기 위해서는 Iterator 인터페이스의 내용을 직접 구현해야 한다. 

대게 Collection 인터페이스를 사용하는 클래스의 경우 별도의 Iterator를 구현하여 사용하고 있다. 밑에 Iterable을 설명하면서 정리해보자.

1
2
3
4
5
6
7
8
9
10
11
12
public interface Iterator<E> {
    boolean hasNext();
    E next();
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }
    default void forEachRemaining(Consumer<super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}
cs


Iterable

Java 1.5부터 나온 인터페이스로 Iterator보다 더 늦게 나온 인터페이스로 Iterator를 제공하는 메서드를 보유하고 있는 인터페이스이다.

이 인터페이스는 실질적으로 for-each를 사용할 수 있는 클래스라는것을 명세해주는 기능을 제공하고, Iterable을 상속받은 클래스는 Iterator를 사용하여 for- each 기능을 사용할 수 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public interface Iterable<T> {
   Iterator<T> iterator();
    
   default void forEach(Consumer<super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }
 
   default Spliterator<T> spliterator() {
       return Spliterators.spliteratorUnknownSize(iterator(), 0);
   }
}
cs

조금 더 이해가 가능하도록 ArrayList를 예로 들어보자.

ArrayList는 List를 구현하고 있고, List는 Collection을 상속받고 있으며 Collection은 Iterable을 상속받고 있다.

1
2
3
4
5
6
7
// ArrayList
public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
// List
public interface List<E> extends Collection<E> {
// Collection
public interface Collection<E> extends Iterable<E> {
cs


그래서 ArrayList에 보면 Iterator<E> iterator()가 구현되어 있다.

그리고 Iterator()에서 반환하는 Iterator인터페이스를 구현한 Itr 클래스도 제공하고 있으며 이를 사용하여 반복 동작을 가능하도록 사용한다.

※Java 1.8 부터는 Iterable에 forEach default method를 제공하고 있어서 바로 사용할 수 있다.


결론은
for-each 기능을 제공하는 Collection의 경우 Iterable을 구현하고 있으며, 그 Iterable 인터페이스에 있는 Iterator<E> iterator() 메소드를 구현하여 Collection의 요소들은 Iterate 하는데 사용된다.


댓글()

static method와 Override hiding 대한 정리

JAVA/고급 자바|2018. 10. 4. 00:08

static 메소드를 자기고 있는 클래스를 상속받은 자식 클래스에서 그 static 메소드를 override 할 수 있을까?

안될거 알지만 한번 확인해보고 싶었다.

먼저 static method를 가지고 있는 Parent을 만들었다.


1
2
3
4
5
6
7
8
9
10
11
12
/**
 * 부모 클래스
 */
static class Parent {
    public static void getData() {
        System.out.println("부모 getData");
    }
 
    public void method() {
        System.out.println("부모 method");
    }
}
cs


그리고 이를 상속하는 Child 클래스를 만들어보자.

1
2
3
4
5
6
7
8
9
10
11
12
/**
 * 자식 클래스
 */
static class Child extends Parent {
    public static  void getData() {
        System.out.println("자식 getData");
    }
 
    public void method() {
        System.out.println("자식 method");
    }
}
cs


그리고 실행시켜보자.

1
2
3
4
5
6
7
8
9
// 부모클래스
Parent c1 = new Parent();
c1.getData();
c1.method();
 
// 자식 클래스
Parent c2 = new Child();
c2.getData();
c2.method();
cs


만약 정상적으로 상속이 되었을 때 우리가 원하는 결과는 이렇다.

예상 결과

부모 getData
부모 method
자식 getData
자식 method

하지만 실제 결과는 다음과 같다.

실제결과
부모 getData
부모 method
부모 getData
자식 method

왜냐하면 static method는 상속이 되지 않기 때문이다. 왜냐면 static 메서드는 클래스가 컴파일 되는 시점에 결정이 되지만 Override에 경우에는 런타임 시점에 사용될 메서드가 결정이 된다. 그래서 애초에 성립하기 어렵다.


그리고 애초에 static에 경우 클래스단위로 만들어지기 때문에 객체 단위로 형성되는 Override 성립될 수 없다.
이런 문제를 방지하기 위해서는 재정의 하기 위해서는 무조건 @Override를 붙혀 주자. 

@Override만 붙여주어도 이렇게 바로 문제가 된다는 것을 확인 할 수 있다.


참고사항

https://docs.oracle.com/javase/tutorial/java/IandI/override.html

https://blog.naver.com/gngh0101/221206214829


댓글()