Skip to content

Instantly share code, notes, and snippets.

@chunghye98

chunghye98/Calculation_Test2.java

Last active December 7, 2022 11:25
Show Gist options
  • Save chunghye98/65c7a49e38278a06f0e8382769ef88bb to your computer and use it in GitHub Desktop.
Save chunghye98/65c7a49e38278a06f0e8382769ef88bb to your computer and use it in GitHub Desktop.
Download ZIP
codesquad-test
Raw
README.md

구현과정 상세 설명

1단계

  1. 원의 크기 n을 입력한다.
  2. n X n 크기의 배열을 생성한다.
  3. 배열을 1, 2, 3, 4사분면으로 쪼개서 기능을 만든다.
    1. y가 0 ~ 반지름, x가 0 ~ 반지름인 범위를 2사분면으로 한다.
    2. y가 0 ~ 반지름, x가 반지름 ~ n인 범위를 1사분면으로 한다.
    3. y가 반지름 ~ n, x가 0 ~ 반지름인 범위를 3사분면으로 한다.
    4. y가 반지름 ~ n, x가 반지름 ~ n인 범위를 4사분면으로 한다.
  4. 각 사분면에 반복문을 돌려 모든 좌표를 확인한다.
    1. 좌표가 원의 둘레에 해당하면 '-'을 배열에 넣어준다.
    2. 좌표가 원의 둘레에 해당하지 않으면 ' '을 배열에 넣어준다.
  5. 배열을 출력한다.

실행 결과

입력
4

결과

 --
-  -
-  -
 --

2단계

  1. 프로그램이 실행될 때 태양, 지구, 달을 만든다.
    1. 태양의 크기 = 5, 지구의 크기 = 3, 달의 크기 = 1
    2. 각 행성은 '*'로 꽉 차게 만든다.
    3. 1,2,3,4 사분면으로 나눠서 원을 구하는 1단계 로직을 이용한다.
    4. 태양은 만들면 바로 태양계 배열에 넣는다.
    5. 태양계 배열은 지구와 달도 넣어줘야 하므로 static으로 선언한다.
  2. 지구의 공전 궤도의 지름은 183으로 한다.
    1. 태양을 한바퀴 돌면 365이므로 365 / 2 한 것을 반올림한 것을 지름으로 한다.
  3. 달의 공전 주기는 28로 한다.
    1. 달의 공전 주기는 27.3일이나 계산의 단순화를 위해 올림한다.
    2. 달의 공전 궤도 지름은 14이다.
  4. 태양계 배열의 크기는 198(183 + 14 + 1)으로 한다.
    1. '지구 공전 궤도 지름 + 달의 공전 궤도 지름 + 1(1부터 계산하기 때문)' 이다.
  5. 날짜를 입력받는다.
    1. String으로 받아서 숫자가 있으면 숫자를 정수형으로 변환하여 month와 date를 구한다.
  6. 1월 1일부터 입력받은 날짜까지의 일수를 구한다.
    1. 월 배열을 만든다.
      1. 배열은 0부터 시작하기 때문에 처음에는 0을 넣어주고 이후 월별 날짜 수를 넣는다.
    2. 입력받은 month 전까지 반복문을 이용해 일수를 구한다.
    3. 구한 일수에 date를 더해 최종 일수를 구한다.
  7. 최종 일수(day)와 태양의 원점(solarXY)를 파라미터로 하여 지구가 공전한 위치(Point)를 구한다.
    1. 지구의 초기 위치(1월 1일)는 y가 solarXY와 같고, x가 지구 공전 궤도의 지름 + 달의 공전 궤도의 반지름과 같다.
    2. 365를 4등분 해서 day만큼 x, y의 위치를 이동시킨다.
    3. 태양계 배열에 지구의 위치를 찾아 넣는다.
    4. 최종 위치를 반환한다.
  8. 반환받은 지구의 위치와 day를 파라미터로 하여 달을 공전시킨다.
    1. 달의 초기 위치는 x가 지구위치.x + 달의 반지름과 같고, y가 지구위치.y와 같다.
    2. 28을 4등분 해서 day만큼 x, y의 위치를 이동시킨다.
    3. 태양계 배열에 달의 위치를 찾아 넣는다.
  9. 태양계 배열을 출력한다.
    1. 배열에 null이 있으면 공백(' ')으로 바꿔 넣는다.

실행 결과

입력
1월 1일

출력

   *                                                                                                  
  ***                                                                                         *       
 *****                                                                                       ***     *
  ***                                                                                         *       
   *

3단계

  1. 프로그램을 실행시키면 태양, 태양계의 행성, 행성의 위성에 대한 enum 을 먼저 생성한다.
    1. 수성과 금성의 위성은 없고, 나머지 행성들에는 위성이 1개씩 있으며 radius는 2로 한다.
    2. 구현의 단순화를 위해 각 행성들의 공전 궤도의 반지름을 6의 배수로 정비례하도록 한다.
    3. 위성의 공전 주기는 '일'로 통일한다.(실제 공전 주기가 '시간'단위라면 '일'로 변환하고 올림한다.)
    4. 가상의 공전 궤도 둘레(round)는 radius * 4로 한다.
    5. 가상의 공전 궤도 반지름(radius), 실제 공전 주기(date), 이름(name), 유형(type)에 대해 정의한다.
      1. 태양 : 0, 0, "태양", "항성"
      2. 수성 : 6, 88, "수성", "행성"
      3. 금성 : 12, 225, "금성", "행성"
      4. 지구 : 18, 365, "지구", "행성"
      5. 화성 : 24, 687, "화성", "행성"
      6. 목성 : 30, 9380, "목성", "행성"
      7. 토성 : 36, 10585, "토성", "행성"
      8. 천왕성 : 42, 30660, "천왕성", "행성"
      9. 해왕성 : 48, 60225, "해왕성", "행성"
      10. 달 : 2, 27, "달", "위성"
      11. 포보스 : 2, 8 / 24 + 1, "포보스", "위성"
      12. 유로파 : 2, 85 / 24 + 1, "유로파", "위성"
      13. 타이탄 : 2, 16, "타이탄", "위성"
      14. 미란다 : 2, 34 / 24 + 1, "미란다", "위성"
      15. 트리톤 : 2, 141 / 24 + 1, "트리톤", "위성"
  2. 프로그램을 실행시키면 모든 항성, 행성, 위성의 객체를 생성한다.
    1. 날짜 계산을 위해 월 배열을 생성한다.
    2. 월 배열에 처음은 0을 넣고, 이후 1월부터 일수를 넣는다.
    3. 태양계 배열을 103의 크기로 생성한다.(천왕성의 radius를 48이라 하고, 트리톤의 radius가 2이므로 48 * 2 + 2 * 2 + 2보다 커야한다.)
    4. 태양을 태양계 배열의 중앙에 넣고 좌표를 반환한다.
    5. 태양은 "*", 행성은 "+", 위성은 "·" 모양으로 한다.
  3. 임의의 날짜(연, 월, 일)를 입력받는다.
    1. 연, 월, 일을 숫자로 변환한다.
    2. 1년 1월 1일부터 입력받은 임의의 날짜까지의 일수를 구한다.
    3. 일수를 구할 때 연도에서 -1을 하고 date에서 -1을 해야한다.(1년 1월 1일이 기준이기 때문이다.)
  4. 구한 일수를 파라미터로 하여 각 행성과 위성을 공전시킨다.
    1. 행성을 공전시켜 최종 좌표를 반환한다.
      1. enum에서 해당 생성의 radius와 round를 가져온다.
      2. 초기 좌표는 y가 태양의 y좌표와 같고, x가 태양의 x좌표 + radius와 같다.
      3. 가상의 공전 주기와 실제 공전 주기의 비율을 구해 day를 계산한다.
        1. ratio = round / dates;
        2. day = radio * day % round
      4. day, radius, y, x를 파라미터로 하여 행성을 공전시킨다.
        1. 나머지연산을 하여 구한 day는 radius * 4보다 작다.
        2. radius * 4 까지의 범위를 4등분 해서 x, y의 좌표가 시계방향으로 움직이도록 한다.
        3. 최종 좌표를 태양계 배열에 넣는다.(행성이 지구라면 지구 위쪽에 HERE! 이라는 메세지를 넣는다.)
        4. 최종 좌표를 반환한다.
    2. 받은 행성의 최종 좌표로 위성을 공전시킨다.
      1. enum에서 해당 생성의 radius와 round를 가져온다.
      2. 초기 좌표는 y가 행성의 y좌표와 같고, x가 행성의 x좌표 + radius와 같다.
      3. 가상의 공전 주기와 실제 공전 주기의 비율을 구해 day를 계산한다.
        1. ratio = round / dates;
        2. day = radio * day % round
      4. day, radius, y, x를 파라미터로 하여 위성을 공전시킨다.
        1. 나머지연산을 하여 구한 day는 radius * 4보다 작다.
        2. radius * 4 까지의 범위를 4등분 해서 x, y의 좌표가 시계방향으로 움직이도록 한다.
        3. 최종 좌표를 태양계 배열에 넣는다.
  5. 태양계 배열을 출력한다.
    1. 배열에 null이 있으면 공백(' ')으로 바꿔 넣는다.

실행 결과

입력
2년 3월 4일

결과

+ ·                                                              
                                                                                                       
                                                                                                       
                                                                                                       
                                                          +                                            
                                                     +                                                 
                                                                                                       
                                                                                                       
                                                                                                       
                                                                                                       
                                                    *                                               + ·
                                                                                             +         
                                                                                            ·          
                                                                             ·                         
                                                                              +   · +                  
                                                                                                       
                                                                                                       
                                                                                                       
                                                         HERE!                                         
                                                           |                                           
                                                          ·V                                           
                                                           +
Raw
Calculation_Test2.java
import java.awt.*;
import java.util.Scanner;
public class Calculation_Test2 {
private final int ZERO = 48;
private final int NINE = 57;
private int[] months = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
private int solarXY;
private StringBuilder sb;
private Planet_Test2 solar;
private Planet_Test2 earth;
private Planet_Test2 moon;
public Calculation_Test2() {
solar = new Planet_Test2(5);
solarXY = solar.addSolarToSolarSystem();
earth = new Planet_Test2(3);
moon = new Planet_Test2(1);
}
public void run() {
System.out.println("Sun, Earth, Moon");
System.out.println("날짜를 입력하세요.");
Scanner sc = new Scanner(System.in);
int month = inputToInteger(sc.next());
int date = inputToInteger(sc.next());
int day = calculateNumberOfDays(month, date);
movePlanet(day);
solar.showSolarSystem();
}
private int inputToInteger(String strInput) {
char[] temp = strInput.toCharArray();
sb = new StringBuilder();
for (int i = 0; i < temp.length; i++) {
if (temp[i] >= ZERO && temp[i] <= NINE) {
sb.append(temp[i]);
}
}
return Integer.parseInt(sb.toString());
}
private void movePlanet(int day) {
Point p = earth.moveEarth(day, solarXY);
moon.moveMoon(day, p);
}
private int calculateNumberOfDays(int month, int date) {
int day = 0;
for (int i = 0; i < month; i++) {
day += months[i];
}
day = day + date;
return day;
}
}
Raw
Calculation_Test3.java
import java.awt.*;
import java.util.Scanner;
public class Calculation_Test3 {
private final int ZERO = 48;
private final int NINE = 57;
private final String INPUT_MESSAGE = "날짜를 입력하세요.";
private int[] months = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
private int solarXY;
private StringBuilder sb;
private Planet_Test3 solar; // 태양
private Planet_Test3 mercury; // 수성
private Planet_Test3 venus; // 금성
private Planet_Test3 earth; // 지구
private Planet_Test3 mars; // 화성
private Planet_Test3 jupiter; // 목성
private Planet_Test3 saturn; // 토성
private Planet_Test3 uranus; // 천왕성
private Planet_Test3 neptune; // 해왕성
private Planet_Test3 moon; // 지구의 위성(달)
private Planet_Test3 phobos; // 화성의 위성(포보스)
private Planet_Test3 europa; // 목성의 위성(유로파)
private Planet_Test3 titan; // 토성의 위성(타이탄)
private Planet_Test3 miranda; // 천왕성의 위성(미란다)
private Planet_Test3 triton; // 해왕성의 위성(트리톤)
public Calculation_Test3() {
solar = new Planet_Test3(StarEnum.SOLAR.getName(), StarEnum.SOLAR.getType(), StarEnum.SOLAR.getDate());
mercury = new Planet_Test3(StarEnum.MERCURY.getName(), StarEnum.MERCURY.getType(), StarEnum.MERCURY.getDate());
venus = new Planet_Test3(StarEnum.VENUS.getName(), StarEnum.VENUS.getType(), StarEnum.VENUS.getDate());
earth = new Planet_Test3(StarEnum.EARTH.getName(), StarEnum.EARTH.getType(), StarEnum.EARTH.getDate());
mars = new Planet_Test3(StarEnum.MARS.getName(), StarEnum.MARS.getType(), StarEnum.MARS.getDate());
jupiter = new Planet_Test3(StarEnum.JUPITER.getName(), StarEnum.JUPITER.getType(), StarEnum.JUPITER.getDate());
saturn = new Planet_Test3(StarEnum.SATURN.getName(), StarEnum.SATURN.getType(), StarEnum.SATURN.getDate());
uranus = new Planet_Test3(StarEnum.URANUS.getName(), StarEnum.URANUS.getType(), StarEnum.URANUS.getDate());
neptune = new Planet_Test3(StarEnum.NEPTUNE.getName(), StarEnum.NEPTUNE.getType(), StarEnum.NEPTUNE.getDate());
moon = new Planet_Test3(StarEnum.MOON.getName(), StarEnum.MOON.getType(), StarEnum.MOON.getDate());
phobos = new Planet_Test3(StarEnum.PHOBOS.getName(), StarEnum.PHOBOS.getType(), StarEnum.PHOBOS.getDate());
europa = new Planet_Test3(StarEnum.EUROPA.getName(), StarEnum.EUROPA.getType(), StarEnum.EUROPA.getDate());
titan = new Planet_Test3(StarEnum.TITAN.getName(), StarEnum.TITAN.getType(), StarEnum.TITAN.getDate());
miranda = new Planet_Test3(StarEnum.MIRANDA.getName(), StarEnum.MIRANDA.getType(), StarEnum.MIRANDA.getDate());
triton = new Planet_Test3(StarEnum.TRITON.getName(), StarEnum.TRITON.getType(), StarEnum.TRITON.getDate());
solarXY = solar.addSolarToSolarSystem();
}
public void run() {
System.out.println(INPUT_MESSAGE);
Scanner sc = new Scanner(System.in);
int year = inputToInteger(sc.next());
int month = inputToInteger(sc.next());
int date = inputToInteger(sc.next());
int day = calculateNumberOfDays(year, month, date);
movePlanet(day);
solar.showSolarSystem();
}
private int inputToInteger(String strInput) {
char[] temp = strInput.toCharArray();
sb = new StringBuilder();
for (int i = 0; i < temp.length; i++) {
if (temp[i] >= ZERO && temp[i] <= NINE) {
sb.append(temp[i]);
}
}
return Integer.parseInt(sb.toString());
}
private int calculateNumberOfDays(int year, int month, int date) {
int day = (year - 1) * 365;
for (int i = 0; i < month; i++) {
day += months[i];
}
day = day + date - 1;
return day;
}
private void movePlanet(int day) {
mercury.movePlanet(day, solarXY);
venus.movePlanet(day, solarXY);
move(earth, moon, day, solarXY);
move(mars, phobos, day, solarXY);
move(jupiter, europa, day, solarXY);
move(saturn, titan, day, solarXY);
move(uranus, miranda, day, solarXY);
move(neptune, triton, day, solarXY);
}
private void move(Planet_Test3 planet, Planet_Test3 satellite, int day, int solarXY) {
Point p = planet.movePlanet(day, solarXY);
satellite.moveSatellite(day, p);
}
}
Raw
Planet_Test2.java
import java.awt.*;
public class Planet_Test2 {
private final String STAR = "*";
private final String BLANK = " ";
private final int SOLAR_RANGE = 2;
private final int EARTH_RANGE = 1;
private final int MOON_XY = 0;
private final int EARTH_MOVE_RANGE_1 = 1;
private final int EARTH_MOVE_RANGE_2 = 91;
private final int EARTH_MOVE_RANGE_3 = 182;
private final int EARTH_MOVE_RANGE_4 = 273;
private final int EARTH_MOVE_RANGE_5 = 365;
private final int MOON_MOVE_RANGE_1 = 1;
private final int MOON_MOVE_RANGE_2 = 8;
private final int MOON_MOVE_RANGE_3 = 15;
private final int MOON_MOVE_RANGE_4 = 22;
private final int MOON_MOVE_RANGE_5 = 28;
private static final int EARTH_MOVE_DIAMETER = 365 / 2 + 1;
private static final int MOON_MOVE_DIAMETER = 28 / 2;
private static String[][] solarSystem = new String[EARTH_MOVE_DIAMETER + MOON_MOVE_DIAMETER + 1][EARTH_MOVE_DIAMETER + MOON_MOVE_DIAMETER + 1];
private String[][] planet;
private int size;
private int solarSystemRange;
public Planet_Test2(int size) {
this.size = size;
this.planet = new String[size][size];
this.solarSystemRange = EARTH_MOVE_DIAMETER + MOON_MOVE_DIAMETER;
makePlanet();
}
private void makePlanet() {
int radius = size / 2;
// 2사분면
for (int i = 0; i < radius; i++) {
for (int j = 0; j < radius; j++) {
if (j > radius - i - 1) {
planet[i][j] = STAR;
} else {
planet[i][j] = BLANK;
}
}
}
// 1사분면
for (int i = 0; i < radius; i++) {
for (int j = radius; j < size; j++) {
if (j <= radius + i) {
planet[i][j] = STAR;
} else {
planet[i][j] = BLANK;
}
}
}
// 3사분면
for (int i = radius; i < size; i++) {
for (int j = 0; j < radius; j++) {
if (j >= i - radius) {
planet[i][j] = STAR;
} else {
planet[i][j] = BLANK;
}
}
}
// 4사분면
for (int i = radius; i < size; i++) {
for (int j = radius; j < size; j++) {
if (j <= size - 1 + (radius - i)) {
planet[i][j] = STAR;
} else {
planet[i][j] = BLANK;
}
}
}
}
// 태양계에 태양 넣기
public int addSolarToSolarSystem() {
int solarXY = solarSystemRange / 2 + 1;
for (int i = solarXY - SOLAR_RANGE; i <= solarXY + SOLAR_RANGE; i++) {
for (int j = solarXY - SOLAR_RANGE; j <= solarXY + SOLAR_RANGE; j++) {
solarSystem[i][j] = planet[i - (solarXY - SOLAR_RANGE)][j - (solarXY - SOLAR_RANGE)];
}
}
return solarXY;
}
// 태양계 보여주기
public void showSolarSystem() {
for (int i = 0; i < solarSystem.length; i++) {
for (int j = 0; j < solarSystem[i].length; j++) {
if (solarSystem[i][j] == null) {
solarSystem[i][j] = BLANK;
}
}
}
for (String[] arr : solarSystem) {
for (String s : arr) {
System.out.print(s);
}
System.out.println();
}
}
// 태양계에 지구 넣기
public void addEarthToSolarSystem(int y, int x) {
for (int i = y - EARTH_RANGE; i <= y + EARTH_RANGE; i++) {
for (int j = x - EARTH_RANGE; j <= x + EARTH_RANGE; j++) {
solarSystem[i][j] = planet[i - (y - EARTH_RANGE)][j - (x - EARTH_RANGE)];
}
}
}
// 태양계에 달 넣기
public void addMoonToSolarSystem(int y, int x) {
solarSystem[y][x] = planet[MOON_XY][MOON_XY];
}
// 지구가 공전한 후 위치 찾기
public Point moveEarth(int day, int solarXY) {
int y = solarXY;
int x = EARTH_MOVE_DIAMETER + MOON_MOVE_DIAMETER / 2;
for (int i = 0; i < day; i++) {
if (i > EARTH_MOVE_RANGE_1 && i <= EARTH_MOVE_RANGE_2) {
y++;
x--;
}
if (i > EARTH_MOVE_RANGE_2 && i <= EARTH_MOVE_RANGE_3) {
y--;
x--;
}
if (i > EARTH_MOVE_RANGE_3 && i <= EARTH_MOVE_RANGE_4) {
y--;
x++;
}
if (i > EARTH_MOVE_RANGE_4 && i <= EARTH_MOVE_RANGE_5) {
y++;
x++;
}
}
addEarthToSolarSystem(y, x);
return new Point(x, y);
}
// 달이 공전한 후 위치 찾기
public void moveMoon(int day, Point p) {
int y = p.y;
int x = p.x + MOON_MOVE_DIAMETER / 2;
day = day % (MOON_MOVE_DIAMETER * 2);
for (int i = 0; i < day; i++) {
if (i > MOON_MOVE_RANGE_1 && i <= MOON_MOVE_RANGE_2) {
y++;
x--;
}
if (i > MOON_MOVE_RANGE_2 && i <= MOON_MOVE_RANGE_3) {
y--;
x--;
}
if (i > MOON_MOVE_RANGE_3 && i <= MOON_MOVE_RANGE_4) {
y--;
x++;
}
if (i > MOON_MOVE_RANGE_4 && i <= MOON_MOVE_RANGE_5) {
x++;
y++;
}
}
addMoonToSolarSystem(y, x);
}
}
Raw
Planet_Test3.java
import java.awt.*;
public class Planet_Test3 {
private final String TYPE_SUN = "항성";
private final String TYPE_SATELLITE = "위성";
private final String TYPE_PLANET = "행성";
private final String SHAPE_SUN = "*";
private final String SHAPE_SATELLITE = "·";
private final String SHAPE_PLANET = "+";
private final String BLANK = " ";
private final String CURRENT_LOCATION_MESSAGE_H = "H";
private final String CURRENT_LOCATION_MESSAGE_E = "E";
private final String CURRENT_LOCATION_MESSAGE_R = "R";
private final String CURRENT_LOCATION_MESSAGE = "!";
private final String CURRENT_LOCATION_ARROW1 = "|";
private final String CURRENT_LOCATION_ARROW2 = "V";
private final int SATELLITE_SIZE = 2;
private static final int mapSize = 103;
private static String[][] solarSystem = new String[mapSize][mapSize];
private String planet;
private int dates;
private String type;
private String name;
public Planet_Test3(String name, String type, int dates) {
this.name = name;
this.type = type;
this.dates = dates;
makePlanet();
}
private void makePlanet() {
if (type.equals(TYPE_SUN)) {
planet = SHAPE_SUN;
} else if (type.equals(TYPE_SATELLITE)) {
planet = SHAPE_SATELLITE;
} else if (type.equals(TYPE_PLANET)) {
planet = SHAPE_PLANET;
}
}
public int addSolarToSolarSystem() {
int solarXY = mapSize / 2 + 1;
solarSystem[solarXY][solarXY] =planet;
return solarXY;
}
// 태양계 보여주기
public void showSolarSystem() {
for (int i = 0; i < solarSystem.length; i++) {
for (int j = 0; j < solarSystem[i].length; j++) {
if (solarSystem[i][j] == null) {
solarSystem[i][j] = BLANK;
}
}
}
for (String[] arr : solarSystem) {
for (String s : arr) {
System.out.print(s);
}
System.out.println();
}
}
private void addPlanetToSolarSystem(int y, int x) {
if (name.equals(StarEnum.EARTH.getName())) {
solarSystem[y-3][x-2] = CURRENT_LOCATION_MESSAGE_H;
solarSystem[y-3][x-1] = CURRENT_LOCATION_MESSAGE_E;
solarSystem[y-3][x] = CURRENT_LOCATION_MESSAGE_R;
solarSystem[y-3][x+1] = CURRENT_LOCATION_MESSAGE_E;
solarSystem[y-3][x+2] = CURRENT_LOCATION_MESSAGE;
solarSystem[y-2][x] = CURRENT_LOCATION_ARROW1;
solarSystem[y-1][x] = CURRENT_LOCATION_ARROW2;
}
solarSystem[y][x] = planet;
}
public Point movePlanet(int day, int solarXY) {
double[] radiusAndRound = getRadiusAndRoundByName();
int radius = (int) radiusAndRound[0];
double round = radiusAndRound[1];
int y = solarXY;
int x = solarXY + radius;
day = calculateDay(day, round);
Point p = revolve(day, radius, y, x);
return p;
}
public double[] getRadiusAndRoundByName() {
double[] radiusAndRound = new double[2];
if (name.equals(StarEnum.MERCURY.getName())) {
radiusAndRound = getRadiusAndRound(StarEnum.MERCURY);
} else if (name.equals(StarEnum.VENUS.getName())) {
radiusAndRound = getRadiusAndRound(StarEnum.VENUS);
} else if (name.equals(StarEnum.EARTH.getName())) {
radiusAndRound = getRadiusAndRound(StarEnum.EARTH);
} else if (name.equals(StarEnum.MARS.getName())) {
radiusAndRound = getRadiusAndRound(StarEnum.MARS);
} else if (name.equals(StarEnum.JUPITER.getName())) {
radiusAndRound = getRadiusAndRound(StarEnum.JUPITER);
} else if (name.equals(StarEnum.SATURN.getName())) {
radiusAndRound = getRadiusAndRound(StarEnum.SATURN);
} else if (name.equals(StarEnum.URANUS.getName())) {
radiusAndRound = getRadiusAndRound(StarEnum.URANUS);
} else if (name.equals(StarEnum.NEPTUNE.getName())) {
radiusAndRound = getRadiusAndRound(StarEnum.NEPTUNE);
}
return radiusAndRound;
}
private double[] getRadiusAndRound(StarEnum star) {
double[] radiusAndRound = {star.getRadius(), star.getRound()};
return radiusAndRound;
}
public void moveSatellite(int day, Point p) {
int radius = SATELLITE_SIZE;
double round = radius * 4;
int y = p.y;
int x = p.x + radius;
day = calculateDay(day, round);
revolve(day, radius, y, x);
}
private int calculateDay(int day, double round) {
double ratio = round / (double) dates;
day = (int) ((ratio * day) % round);
return day;
}
private Point revolve(int day, int radius, int y, int x) {
for (int i = 1; i <= day; i++) {
if (i > 1 && i <= radius + 1) {
y++;
x--;
}
if (i > radius + 1 && i <= radius * 2 + 1) {
y--;
x--;
}
if (i > radius * 2 + 1 && i <= radius * 3 + 1) {
y--;
x++;
}
if (i > radius * 3 + 1 && i <= radius * 4) {
y++;
x++;
}
}
addPlanetToSolarSystem(y, x);
return new Point(x, y);
}
}
Raw
StarEnum.java
public enum StarEnum {
SOLAR(0, 0, "태양", "항성"),
MERCURY(6, 88, "수성", "행성"),
VENUS(12, 225, "금성", "행성"),
EARTH(18, 365, "지구", "행성"),
MARS(24, 687, "화성", "행성"),
JUPITER(30, 9380, "목성", "행성"),
SATURN(36, 10585, "토성", "행성"),
URANUS(42, 30660, "천왕성", "행성"),
NEPTUNE(48, 60225, "해왕성", "행성"),
MOON(2, 27, "달", "위성"),
PHOBOS(2, 8 / 24 + 1, "포보스", "위성"),
EUROPA(2, 85 / 24 + 1, "유로파", "위성"),
TITAN(2, 16, "타이탄", "위성"),
MIRANDA(2, 34 / 24 + 1, "미란다", "위성"),
TRITON(2, 141 / 24 + 1, "트리톤", "위성");
private final int radius;
private final double round;
private final int date;
private final String name;
private final String type;
StarEnum(int radius, int date, String name, String type) {
this.radius = radius;
this.date = date;
this.name = name;
this.type = type;
this.round = (double) radius * 4.0;
}
public int getRadius() {
return radius;
}
public double getRound() {
return round;
}
public int getDate() {
return date;
}
public String getName() {
return name;
}
public String getType() {
return type;
}
}
Raw
Test1.java
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String[][] map = new String[n][n];
int radius = n / 2;
// 2사분면
for (int i = 0; i < radius; i++) {
for (int j = 0; j < radius; j++) {
if (j == n - (radius + i + 1)) {
map[i][j] = "-";
} else {
map[i][j] = " ";
}
}
}
// 1사분면
for (int i = 0; i < radius; i++) {
for (int j = radius; j < n; j++) {
if (j == radius + i) {
map[i][j] = "-";
} else {
map[i][j] = " ";
}
}
}
// 3사분면
for (int i = radius; i < n; i++) {
for (int j = 0; j < radius; j++) {
if (j == i - radius) {
map[i][j] = "-";
} else {
map[i][j] = " ";
}
}
}
// 4사분면
for (int i = radius; i < n; i++) {
for (int j = radius; j < n; j++) {
if (j == n - 1 + (radius - i)) {
map[i][j] = "-";
} else {
map[i][j] = " ";
}
}
}
for (String[] arr : map) {
for (String s : arr) {
System.out.print(s);
}
System.out.println();
}
}
}
Raw
Test2.java
public class Test2 {
public static void main(String[] args) {
Calculation_Test2 calculation = new Calculation_Test2();
calculation.run();
}
}
Raw
Test3.java
public class Test3 {
public static void main(String[] args) {
Calculation_Test3 calculation = new Calculation_Test3();
calculation.run();
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment