20221114-n-queen

n-queen/java/20221114/Board.java

@@ -0,0 +1,29 @@
+import java.util.ArrayList;
+import java.util.List;
+
+public class Board {
+    private int[][] board;
+    private List<Queen> queens = new ArrayList<>();
+
+    public Board(int size) {
+        this.board = new int[size][size];
+    }
+
+    public int[][] status() {
+        return board;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        Board otherBoard = (Board) other;
+
+        return board.length == otherBoard.board.length
+                && board[0].length == otherBoard.board[0].length;
+    }
+
+    public void put(Queen queen) {
+        queens.add(queen);
+
+        this.board = queen.drawAttackable(board);
+    }
+}

n-queen/java/20221114/BoardTest.java

@@ -0,0 +1,16 @@
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class BoardTest {
+
+    @Test
+    void creation() {
+        int size = 4;
+        Board board = new Board(size);
+
+        int [][] currentBoard = board.status();
+
+        assertArrayEquals(new int[size][size], currentBoard);
+    }
+}

n-queen/java/20221114/Queen.java

@@ -0,0 +1,53 @@
+import java.util.stream.IntStream;
+
+public class Queen {
+    private int[] position;
+
+    public Queen setPosition(int y, int x) {
+        this.position = new int[]{y, x};
+
+        return this;
+    }
+
+    public int[][] drawAttackable(int[][] board) {
+        IntStream.range(0, board.length)
+                .forEach((y) -> IntStream.range(0, board[y].length)
+                        .forEach((x) -> {
+                    if (y == position[0] && x == position[1]) {
+                        board[y][x] = 1;
+
+                        return;
+                    }
+
+                    if (y == position[0]) {
+                        board[y][x] = 1;
+
+                        return;
+                    }
+
+                    if (x == position[1]) {
+                        board[y][x] = 1;
+
+                        return;
+                    }
+
+                    if (x + y == position[0] + position[1]) {
+                        board[y][x] = 1;
+
+                        return;
+                    }
+
+                    if (Math.abs(y - x) == Math.abs(position[0] - position[1])) {
+                        board[y][x] = 1;
+
+                        return;
+                    }
+                }));
+
+        return board;
+    }
+
+    public int[] position() {
+        return position;
+    }
+}

n-queen/java/20221114/QueenTest.java

@@ -0,0 +1,26 @@
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class QueenTest {
+
+    @Test
+    void creation() {
+        Queen queen = new Queen();
+    }
+
+    @Test
+    void drawAttackable() {
+        Queen queen = new Queen();
+        queen.setPosition(0, 0);
+
+        int [][] afterDrawn = queen.drawAttackable(new int[4][4]);
+
+        assertArrayEquals(new int[][] {
+                {1, 1, 1, 1},
+                {1, 1, 0, 0},
+                {1, 0, 1, 0},
+                {1, 0, 0, 1}
+        }, afterDrawn);
+    }
+}

n-queen/java/20221114/README.md

@@ -0,0 +1,63 @@
+### 1. 이해
+> 아래의 질문에 대한 답변이 녹아 있어야 한다.
+
+- [ ] 모르는 것은 무엇인가?
+- [ ] 주어진 것은 무엇인가?
+- [ ] 자료는 무엇인가?
+- [ ] 조건은 무엇인가?
+- [ ] 조건은 알아내야 하는 것을 찾는데 충분한가?
+
+### 2. 계획
+> A) 계획을 세우기 전에 아래와 같은 질문을 던지면 굉장히 유용하다.
+
+- [ ] 관련된 문제를 알고 있는가?
+- [ ] 모르는 부분이 유사한 다른 문제를 풀어 본 적이 있는가?
+- [ ] 전에 풀어 본 문제를 활용하려면 어떤 보조 요소를 도입해야 되는가?
+- [ ] 도움이 될 것 같은 어떤 사실이나 정리를 알고 있는가? (보통은 자료 구조나 수학적 공리 또는 정의가 해당됨)
+
+> B) 계획을 세운 뒤 아래 질문을 통해 한번 더 점검해보자.
+
+- [ ] 자료와 조건은 모두 활용 했는가? (Edge case가 될 조건을 꼭 확인해야 함)
+
+### 3. 실행
+> 코딩을 하는 단계! 무조건 Test case부터 먼저 작성해야 한다.
+💡 TDD를 같이 하는 이유: Test code를 통해 각 단계가 올바르게 동작하는 것을 증명할 수 있다.
+
+- [ ] 각 단계가 올바른지 명확히 알 수 있는가?
+- [ ] 그것이 옳다는 것을 설명할 수 있는가?
+
+### 4. 반성
+> 문제를 다 풀고 나서 회고하는 시간을 갖는다. 반성한 부분을 다음 문제 풀이에 반영한다.
+
+- [ ] 다른 방법으로 해결할 수는 없었는가? (이때 다른 사람의 풀이도 참고하면 좋음)
+- [ ] 결과나 방법을 다른 문제에 활용할 수 있는가? (유용한 패턴은 따로 정리해두자)
+
+</div>
+</details>
+
+## [N-queen](https://school.programmers.co.kr/learn/courses/30/lessons/12952?language=java)
+사이즈가 n*n인 체스판이 주어지고, 체스판 위에 n개의 퀸을 서로를 공격할 수 없도록 배치하고 싶다. 
+체스판의 가로 세로 길이인 n이 매개변수로 주어질 때, n개의 퀸이 조건에 만족하도로록 배치할 수 있는 방법의 수를 반환해라.
+퀸은 가로 세로 대각선으로 움직일 수 있다. 
+n은 12이하의 자연수이다. 
+
+### 1. 이해
+- 체스판의 사이즈인 n이 매개변수로 들어온다. 2차원 배열 n*n이 성립된다.
+- 퀸이 (0,0) 위치에 있을 때 (n, 0), (0, n), (0 ~ n, 0 ~ n)까지 공격이 가능하다.
+- n개 만큼 퀸이 주어진다.
+
+### 2. 계획
+- n만큼 갯수의 퀸 객체를 만든다. 
+- 퀸 객체는 위치 (0, 0) ~ (n, n) 필드를 가진다. 
+- 퀸 객체는 공격가능한지 알 수 있는 attackable 메서드를 가지고 있다,
+- 퀸의 위치가 (2, 2) 일때 공격 가능한 범위는 
+- (2, 0 ~n) , (0~n, 2) , x + y = 4, x - y = 0 이다.   
+- 하나의 퀸 객체를 추가할 떄 마다 모든 퀸 객체의 attackable 메서드를 확인해야 한다. 
+- n개의 퀸개를 체스판 객체에 하나씩 배치하고, 배치하면서 체스판의 타일에 공격가능 여부를 그린다. 공격가능x, 공격 불가능o 
+- 모든 퀸을 다 채우지 못 한다면 0을 반환하고, 다 채웠다면 1을 반환하고 n만큼 시도를 한다.  
+
+### 3. 실행
+- 
+
+### 4. 반성
+-

n-queen/java/20221114/Solution.java

@@ -0,0 +1,36 @@
+import java.util.;
+import java.util.stream.;
+
+class Solution {
+    public int solution(int n) {
+        int result = 0;
+        int[] cols = new int[n];
+        result = backTrack(0, cols, n);
+
+        return result;
+    }
+
+    public int backTrack(int level, int[] cols, int n) {
+        int sum = 0;
+        if (level == n) {
+            return 1;
+        } else {
+            for (int i = 0; i < n; i++) {
+                cols[level] = i;
+                if (possible(level, cols)) {
+                    sum += backTrack(level + 1, cols, n);
+                }
+            }
+        }
+        return sum;
+    }
+
+    public boolean possible(int level, int[] cols) {
+        for (int i = 0; i < level; i++) {
+            if (cols[i] == cols[level] || Math.abs(level - i) == Math.abs(cols[i] - cols[level])) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

n-queen/java/20221114/SolutionTest.java

@@ -0,0 +1,11 @@
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class SolutionTest {
+
+    @Test
+    void solution() {
+
+    }
+}

n-queen/java/20221114/User.java

@@ -0,0 +1,94 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class User {
+    private Board board;
+    private List<Queen> queens;
+
+    public User(int n) {
+        this.board = new Board(n);
+        this.queens = setQueens(n);
+    }
+
+    private List<Queen> setQueens(int n) {
+        return Arrays.stream(new int[n])
+                .mapToObj((number) -> new Queen())
+                .collect(Collectors.toList());
+    }
+
+    public int queens() {
+        return queens.size();
+    }
+
+    public Board board() {
+        return board;
+    }
+
+    public int put(int index, int order, int boardLength) {
+        System.out.println(index);
+        System.out.println(order);
+        if (order == boardLength) {
+            return 1;
+        }
+
+        Queen queen = getQueen(order);
+
+        int[][] boardStatus = board.status();
+
+        for (int i = 0; i < boardStatus.length; i +=1 ) {
+            for (int j = 0; j < boardStatus[i].length; j += 1 ) {
+                System.out.print(boardStatus[i][j]);
+            }
+            System.out.println();
+        }
+        System.out.println();
+
+        List<int[]> positions = new ArrayList<>();
+
+        IntStream.range(order, boardStatus.length)
+                .forEach((y) -> IntStream.range(index, boardStatus[y].length)
+                        .forEach((x) -> {
+                            if (positions.size() > 0) {
+                                return;
+                            }
+
+                            if (boardStatus[y][x] == 0) {
+                                positions.add(new int[]{y, x});
+                                return;
+                            }
+                        }));
+
+
+        if (positions.size() == 0) {
+            this.board = new Board(4);
+            this.queens = setQueens(4);
+
+            return 0;
+        }
+
+        int[] position = positions.get(0);
+
+        board.put(queen.setPosition(position[0], position[1]));
+
+        return put(index, order + 1, boardLength);
+    }
+
+    public Queen getQueen(int order) {
+        return queens.get(order);
+    }
+
+    public int findWaysToPutQueen() {
+        int answer = 0;
+
+        for (int i = 0; i < 4; i += 1) {
+            for (int j = 0; j < 4; j += 1) {
+                answer += put(i, j, 4);
+            }
+        }
+
+        return answer;
+    }
+}

n-queen/java/20221114/UserTest.java

@@ -0,0 +1,25 @@
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class UserTest {
+
+    @Test
+    void creation() {
+        int n = 4;
+        User user = new User(n);
+
+        assertEquals(4, user.queens());
+        assertEquals(new Board(n), user.board());
+    }
+
+
+    @Test
+    void waysToPutQueens() {
+        User user = new User(4);
+
+        int ways =  user.findWaysToPutQueen();
+
+        assertEquals(2, ways);
+    }
+}