[LBP] 박세은 사다리 1단계 제출합니다.

build.gradle

@@ -14,6 +14,9 @@ dependencies {
     testImplementation platform('org.assertj:assertj-bom:3.25.1')
     testImplementation('org.junit.jupiter:junit-jupiter')
     testImplementation('org.assertj:assertj-core')
+    implementation 'org.slf4j:slf4j-api:2.0.9'
+    implementation 'org.slf4j:slf4j-simple:2.0.9'
+    testImplementation 'org.junit.jupiter:junit-jupiter:5.8.2'
 }
 
 test {

src/main/java/Application.java

@@ -0,0 +1,16 @@
+import controller.LadderController;
+import dto.LadderDto;
+import utils.exception.ExceptionHandler;
+import view.LadderView;
+
+public class Application {
+    public static void main(String[] args) {
+        try {
+            LadderController ladderController = new LadderController(4, 4);
+            LadderDto ladderDto = ladderController.getLadderData();
+            LadderView.printLadder(ladderDto);
+        } catch (Exception e) {
+            ExceptionHandler.handleException(e);
+        }
+    }
+}

src/main/java/controller/LadderController.java

@@ -0,0 +1,16 @@
+package controller;
+
+import domain.Ladder;
+import dto.LadderDto;
+
+public class LadderController {
+    private final Ladder ladder;
+
+    public LadderController(int width, int height) {
+        this.ladder = Ladder.of(width, height);
+    }
+
+    public LadderDto getLadderData() {
+        return LadderDto.from(ladder);
+    }
+}

src/main/java/domain/Ladder.java

@@ -0,0 +1,53 @@
+package domain;
+
+import utils.RandomUtil;
+import utils.generator.LadderGenerator;
+import java.util.List;
+import java.util.stream.IntStream;
+
+public class Ladder {
+    private final Lines lines;
+
+    private Ladder(Lines lines) {
+        this.lines = lines;
+    }
+
+    public static Ladder of(int width, int height) {
+        return new Ladder(LadderGenerator.generate(width, height));
+    }
+
+    public Lines getLines() {
+        return lines;
+    }
+
+    public static void validate(List<Line> lines, int width) {
+        IntStream.rangeClosed(0, width)
+                .forEach(i -> validateColumn(lines, i, width));
+    }
+
+    private static void validateColumn(List<Line> lines, int col, int width) {
+        boolean emptyColumn = lines.stream().noneMatch(line -> hasBridgeAt(line, col, width));
+        if (emptyColumn) {
+            int randomIndex = RandomUtil.nextInt(lines.size());
+            connect(lines, randomIndex, col, width);
+        }
+    }
+
+    private static boolean hasBridgeAt(Line line, int col, int width) {
+        if (col == 0) return line.hasBridgeAt(col);
+        if (col == width) return line.hasBridgeAt(col - 1);
+        return line.hasBridgeAt(col - 1) || line.hasBridgeAt(col);
+    }
+
+    private static void connect(List<Line> lines, int randomIndex, int col, int width) {
+        Line oldLine = lines.get(randomIndex);
+
+        int index = col;
+        if (col == width) {
+            index = col - 1;
+        }
+
+        Line updatedLine = oldLine.setBridgeAt(index);
+        lines.set(randomIndex, updatedLine);
+    }
+}

src/main/java/domain/Line.java

@@ -0,0 +1,56 @@
+package domain;
+
+import utils.RandomUtil;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.IntStream;
+
+public class Line {
+    private final List<Boolean> points;
+
+    public Line(List<Boolean> points) {
+        this.points = List.copyOf(points);
+    }
+
+    public List<Boolean> getPoints() {
+        return points;
+    }
+
+    public boolean hasBridgeAt(int index) {
+        return points.get(index);
+    }
+
+    public Line setBridgeAt(int index) {
+        List<Boolean> newPoints = new ArrayList<>(points);
+        newPoints.set(index, true);
+        return new Line(newPoints);
+    }
+
+    public static void applyBridges(List<Boolean> points, Set<Integer> reserved, Line prev, boolean isReserved) {
+        IntStream.range(0, points.size()).forEach(i -> {
+            boolean shouldAddBridge = (isReserved && reserved.contains(i)) || (!isReserved && RandomUtil.nextBoolean());
+
+            if (shouldAddBridge && isValidBridgePosition(points, prev, i)) {
+                points.set(i, true);
+            }
+        });
+    }
+
+    public static void ensureOneBridge(List<Boolean> points, Line prev) {
+        if (points.contains(true)) return;
+
+        IntStream.range(0, points.size())
+                .filter(i -> isValidBridgePosition(points, prev, i))
+                .findFirst()
+                .ifPresent(i -> points.set(i, true));
+    }
+
+    private static boolean isValidBridgePosition(List<Boolean> points, Line prev, int index) {
+        if (prev != null && prev.hasBridgeAt(index)) return false;
+        if (index > 0 && points.get(index - 1)) return false;
+        if (index < points.size() - 1 && points.get(index + 1)) return false;
+        return true;
+    }
+}

src/main/java/domain/Lines.java

@@ -0,0 +1,15 @@
+package domain;
+
+import java.util.List;
+
+public class Lines {
+    private final List<Line> lines;
+
+    public Lines(List<Line> lines) {
+        this.lines = List.copyOf(lines);
+    }
+
+    public List<Line> getLines() {
+        return lines;
+    }
+}

src/main/java/dto/LadderDto.java

@@ -0,0 +1,26 @@
+package dto;
+
+import domain.Ladder;
+import domain.Line;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class LadderDto {
+    private final List<List<Boolean>> ladderData;
+
+    public LadderDto(List<List<Boolean>> ladderData) {
+        this.ladderData = ladderData;
+    }
+
+    public static LadderDto from(Ladder ladder) {
+        return new LadderDto(
+                ladder.getLines().getLines().stream()
+                        .map(Line::getPoints)
+                        .collect(Collectors.toList())
+        );
+    }
+
+    public List<List<Boolean>> getLadderData() {
+        return ladderData;
+    }
+}

src/main/java/utils/RandomUtil.java

@@ -0,0 +1,15 @@
+package utils;
+
+import java.util.Random;
+
+public class RandomUtil {
+    public static final Random random = new Random();
+
+    public static boolean nextBoolean() {
+        return random.nextBoolean();
+    }
+
+    public static int nextInt(int bound) {
+        return random.nextInt(bound);
+    }
+}

src/main/java/utils/exception/ExceptionHandler.java

@@ -0,0 +1,13 @@
+package utils.exception;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class ExceptionHandler {
+    private static final Logger logger = LoggerFactory.getLogger(ExceptionHandler.class);
+
+    public static void handleException(Exception e) {
+        System.err.println("시스템 오류 : " + e.getMessage());
+        logger.error("시스템 오류 : ", e);
+    }
+}

src/main/java/utils/generator/LadderGenerator.java

@@ -0,0 +1,9 @@
+package utils.generator;
+
+import domain.Lines;
+
+public final class LadderGenerator {
+    public static Lines generate(int width, int height) {
+        return LineGenerator.generate(width, height);
+    }
+}

src/main/java/utils/generator/LineGenerator.java

@@ -0,0 +1,34 @@
+package utils.generator;
+
+import domain.Ladder;
+import domain.Line;
+import domain.Lines;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+public final class LineGenerator {
+    public static Lines generate(int width, int height) {
+        List<Set<Integer>> reserved = ReservedPositionGenerator.generate(width - 1, height);
+        List<Line> lines = generateLines(width, height, reserved);
+        Ladder.validate(lines, width - 1);
+        return new Lines(lines);
+    }
+
+    private static List<Line> generateLines(int width, int height, List<Set<Integer>> reserved) {
+        List<Line> lines = new ArrayList<>();
+        for (int row = 0; row < height; row++) {
+            Line previous = getPreviousLine(lines, row);
+            Line line = SingleLineGenerator.generate(width - 1, reserved.get(row), previous);
+            lines.add(line);
+        }
+        return lines;
+    }
+
+    private static Line getPreviousLine(List<Line> lines, int row) {
+        if (row == 0) {
+            return null;
+        }
+        return lines.get(row - 1);
+    }
+}

src/main/java/utils/generator/ReservedPositionGenerator.java

@@ -0,0 +1,27 @@
+package utils.generator;
+
+import utils.RandomUtil;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public final class ReservedPositionGenerator {
+    public static List<Set<Integer>> generate(int width, int height) {
+        List<Set<Integer>> reserved = initializeReservedPositions(height);
+        applyRandomReservations(reserved, width, height);
+        return reserved;
+    }
+
+    private static List<Set<Integer>> initializeReservedPositions(int height) {
+        return IntStream.range(0, height)
+                .mapToObj(i -> new HashSet<Integer>())
+                .collect(Collectors.toList());
+    }
+
+    private static void applyRandomReservations(List<Set<Integer>> reserved, int width, int height) {
+        IntStream.range(0, width)
+                .forEach(i -> reserved.get(RandomUtil.nextInt(height)).add(i));
+    }
+}

src/main/java/utils/generator/SingleLineGenerator.java

@@ -0,0 +1,20 @@
+package utils.generator;
+
+import domain.Line;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+
+public class SingleLineGenerator {
+    public static Line generate(int width, Set<Integer> reserved, Line prev) {
+        List<Boolean> points = new ArrayList<>(Collections.nCopies(width, false));
+
+        Line.applyBridges(points, reserved, prev, true);
+        Line.applyBridges(points, null, prev, false);
+        Line.ensureOneBridge(points, prev);
+
+        return new Line(points);
+    }
+
+}

src/main/java/view/LadderView.java

@@ -0,0 +1,29 @@
+package view;
+
+import dto.LadderDto;
+
+import java.util.List;
+
+public class LadderView {
+    private static final String BRIDGE = "-----|";
+    private static final String SPACE = "     |";
+    private static final String BAR = "|";
+
+    public static void printLadder(LadderDto ladderDto) {
+        ladderDto.getLadderData().forEach(LadderView::printLine);
+    }
+
+    private static void printLine(List<Boolean> line) {
+        System.out.print(BAR);
+        line.forEach(LadderView::printPoint);
+        System.out.println();
+    }
+
+    private static void printPoint(Boolean point) {
+        if (point) {
+            System.out.print(BRIDGE);
+            return;
+        }
+        System.out.print(SPACE);
+    }
+}