[LBP] 김태우 사다리 1단계 제출합니다

src/main/java/LadderApplication.java

@@ -0,0 +1,10 @@
+import controller.LadderController;
+
+public class LadderApplication {
+    public static void main(String[] args) {
+        LadderController ladderController = LadderController.getInstance();
+
+        ladderController.run();
+    }
+
+}

src/main/java/controller/LadderController.java

@@ -0,0 +1,33 @@
+package controller;
+
+import dto.LineDto;
+import model.Ladder;
+import model.Line;
+import view.LadderOutputView;
+
+import java.util.List;
+
+public class LadderController {
+    private static final LadderController ladderController = new LadderController();
+
+    private final LadderOutputView ladderOutputView = LadderOutputView.getInstance();
+
+    private LadderController() {
+    }
+
+    public static LadderController getInstance() {
+        return ladderController;
+    }
+
+    public void run() {
+        Ladder ladder = new Ladder(4, 4);
+        List<Line> lines = ladder.getLines();
+
+        ladderOutputView.printResultHeader();
+        for (Line line : lines) {
+            LineDto lineDto = LineDto.from(line);
+            ladderOutputView.printLine(lineDto);
+        }
+    }
+
+}

src/main/java/dto/LineDto.java

@@ -0,0 +1,29 @@
+package dto;
+
+import model.Line;
+import model.Link;
+import model.LinkStatus;
+
+import java.util.List;
+
+public class LineDto {
+    private final List<Boolean> linkExistCollection;
+
+    private LineDto(List<Boolean> linkExistCollection) {
+        this.linkExistCollection = linkExistCollection;
+    }
+
+    public static LineDto from(Line line) {
+        List<Boolean> linkExistCollection = line.getLinks().stream()
+                .map(Link::getLinkstatus)
+                .map(LinkStatus::isPresent)
+                .toList();
+
+        return new LineDto(linkExistCollection);
+    }
+
+    public List<Boolean> getLinkExistCollection() {
+        return List.copyOf(linkExistCollection);
+    }
+
+}

src/main/java/model/Ladder.java

@@ -0,0 +1,23 @@
+package model;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class Ladder {
+    private final List<Line> lines;
+
+    public Ladder(int width, int height) {
+        List<Line> lines = new ArrayList<>();
+        for (int i = 0; i < height; i++) {
+            lines.add(new Line(width));
+        }
+
+        this.lines = Collections.unmodifiableList(lines);
+    }
+
+    public List<Line> getLines() {
+        return List.copyOf(lines);
+    }
+
+}

src/main/java/model/Line.java

@@ -0,0 +1,99 @@
+package model;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+import static model.LinkStatus.PRESENT;
+import static model.LinkStatus.UNDEFINED;
+
+public class Line {
+    private static final Random random = new Random();
+
+    private final List<Link> links;
+
+    public Line(int width) {
+        int size = width - 1;
+        List<Link> links = initializeLinks(size);
+
+        setupLinks(links);
+
+        this.links = List.copyOf(links);
+    }
+
+    public List<Link> getLinks() {
+        return List.copyOf(links);
+    }
+
+    private List<Link> initializeLinks(int size) {
+        List<Link> links = new ArrayList<>();
+        for (int i = 0; i < size; i++) {
+            links.add(Link.getUndefinedLink());
+        }
+
+        return List.copyOf(links);
+    }
+
+    private void setupLinks(List<Link> links) {
+        int index = getRandomStartIndex(links);
+
+        while (containsUndefined(links)) {
+            boolean connectDecider = getConnectDecider();
+            boolean connectable = isConnectable(index, links);
+
+            Link link = links.get(index);
+            link.setLinkStatus(connectDecider, connectable);
+
+            index = getNextIndex(index, links);
+        }
+    }
+
+    private int getRandomStartIndex(List<Link> links) {
+        return random.nextInt(links.size());
+    }
+
+    private boolean containsUndefined(List<Link> links) {
+        return links.stream()
+                .anyMatch(link -> link.getLinkstatus() == UNDEFINED);
+    }
+
+    private boolean getConnectDecider() {
+        return random.nextBoolean();
+    }
+
+    private boolean isConnectable(int index, List<Link> links) {
+        if (isFirstIndex(index)) {
+            return isRightNotPresent(index, links);
+        }
+        if (isLastIndex(index, links)) {
+            return isLeftNotPresent(index, links);
+        }
+
+        return isRightNotPresent(index, links) && isLeftNotPresent(index, links);
+    }
+
+    private boolean isFirstIndex(int index) {
+        return index == 0;
+    }
+
+    private boolean isLastIndex(int index, List<Link> links) {
+        return index == links.size() - 1;
+    }
+
+    private boolean isRightNotPresent(int index, List<Link> links) {
+        Link rightLink = links.get(index + 1);
+
+        return rightLink.getLinkstatus() != PRESENT;
+    }
+
+    private boolean isLeftNotPresent(int index, List<Link> links) {
+        Link leftLink = links.get(index - 1);
+
+        return leftLink.getLinkstatus() != PRESENT;
+    }
+
+    private int getNextIndex(int index, List<Link> linkStatuses) {
+        return ++index % linkStatuses.size();
+    }
+
+}

src/main/java/model/Link.java

@@ -0,0 +1,39 @@
+package model;
+
+public class Link {
+    private LinkStatus linkstatus;
+
+    private Link(LinkStatus linkstatus) {
+        this.linkstatus = linkstatus;
+    }
+
+    public static Link getUndefinedLink() {
+        return new Link(LinkStatus.UNDEFINED);
+    }
+
+    public void setLinkStatus(boolean connectDecider, boolean connectable) {
+        validateUpdateStatus();
+
+        if (connectDecider && connectable) {
+            this.linkstatus = LinkStatus.PRESENT;
+            return;
+        }
+
+        this.linkstatus = LinkStatus.ABSENT;
+    }
+
+    public LinkStatus getLinkstatus() {
+        return linkstatus;
+    }
+
+    private void validateUpdateStatus() {
+        if (isAlreadyFixed()) {
+            throw new UnsupportedOperationException("이미 값이 결정된 링크입니다");
+        }
+    }
+
+    private boolean isAlreadyFixed() {
+        return this.linkstatus != LinkStatus.UNDEFINED;
+    }
+
+}

src/main/java/model/LinkStatus.java

@@ -0,0 +1,10 @@
+package model;
+
+public enum LinkStatus {
+    UNDEFINED, ABSENT, PRESENT;
+
+    public boolean isPresent() {
+        return this == PRESENT;
+    }
+
+}

src/main/java/view/LadderOutputView.java

@@ -0,0 +1,47 @@
+package view;
+
+import dto.LineDto;
+
+public class LadderOutputView {
+
+    private static final String INDENTATION = "    ";
+    private static final String DASH_COUPLER = "-----";
+    private static final String BLANK_COUPLER = "     ";
+    private static final String PILLAR = "|";
+
+    private LadderOutputView() {
+    }
+
+    private static final LadderOutputView ladderOutputView = new LadderOutputView();
+
+    public static LadderOutputView getInstance() {
+        return ladderOutputView;
+    }
+
+    public void printResultHeader() {
+        System.out.println("실행결과");
+        System.out.println();
+    }
+
+    public void printLine(LineDto lineDto) {
+        StringBuilder output = new StringBuilder()
+                .append(INDENTATION)
+                .append(PILLAR);
+
+        for (boolean isExist : lineDto.getLinkExistCollection()) {
+            String coupler = getCoupler(isExist);
+            output.append(coupler)
+                    .append(PILLAR);
+        }
+
+        System.out.println(output);
+    }
+
+    private String getCoupler(boolean isLinkExist) {
+        if (isLinkExist) {
+            return DASH_COUPLER;
+        }
+        return BLANK_COUPLER;
+    }
+
+}