JAVA 2일차

4. 제어문과 배열

제어문

일반적으로 프로그램을 처리하는 방식은 ‘순차 처리’이지만, 제어문은 프로그램 실행 순서를 제어할 수 있음

• 모든 제어문은 중괄호를 가짐
• 중괄호 안의 실행문이 1개인 경우 생략 가능 → 컴파일러에 의해 자동 삽입됨
• 제어문 종류
  • 조건문: if, switch
  • 반복문: for, while, do-while
• 제어문 키워드
  • break, continue

if 문

if(조건식){ 실행 내용 };

→ 조건식이 맞으면 true, 틀리면 false

import java.util.Scanner;

public class ex14 {
    public static void main(String[] args) {
        // 선택제어문 - 조건문
        // 조건문: if문, switch
        // if문 4가지 패턴

        // 1. 단일 if문
        // * 조건식에는 비교/논리 연산자가 들어간다.
        if (10 < 20) {
            System.out.println("10이 20보다 작음"); // 10이 20보다 작음
        }
        if (10 < 20) // 실행문이 하나라면 생략 가능
            System.out.println("10이 20보다 작음1"); // 10이 20보다 작음1
        System.out.println("10이 20보다 작음2");
        // 만약 실행문이 2개 이상이라면, 중괄호 써주기!!

        // 2. if else 문
        if (10 < 20) {
            System.out.println("참"); // 참
        } else {
            System.out.println("거짓");
        }

        // 3. if else if문
        int score = 90;
        if (score < 70) {
            System.out.println("70미만");
        } else if (score < 80) {
            System.out.println("80미만");
        } else if (score < 90) {
            System.out.println("90미만");
        } else { // 그 외의 경우
            System.out.println("90이상"); // 90이상
        }

        // 4. 중첩 if 문
        if (10 % 2 == 0) {
            System.out.println("2의 배수"); // 2의 배수
            if (10 % 5 == 0) {
                // 조건식 1 and 조건식 2
                System.out.println("5의 배수"); // 5의 배수
            } else {
                // 조건식 1 and !조건식2
                System.out.println("5의 배수 아님");
            }
        }

        // 연습문제 - DM제출
        // 1.
        // 철수와 영희가 주사위 놀이를 하고 있다.
        // 주사위 2개를 던져서,
        // 두개 다 짝수가 나오면 철수 승!
        // 두개 다 홀수가 나오면, 영희 승!
        // 그외의 경우는 무승부! 이다.
        // 게임의 결과를 출력하시오.
        Scanner scan = new Scanner(System.in);
        int dice1 = scan.nextInt();
        int dice2 = scan.nextInt();

        if (dice1 % 2 == 0 && dice2 % 2 == 0) {
            System.out.println("철수 승!");
        } else if (dice1 % 2 != 0 && dice2 % 2 != 0) {
            System.out.println("영희 승!");
        } else {
            System.out.println("무승부!");
        }

        // 2.
        // 철수와 영희을 주사위게임을 하고 있다.
        // 주사위 2개를 철수가 던지고,
        // 주사위 2개를 영희도 던진다.
        // 게임룰 : 첫번째 주사위는 십의 자릿수로하고,
        //        두번째 주사위는 일의 자릿수로 해서,
        // 더 높은 점수를 가진 사람이 승리한다.
        // 출력값 예시 :
        //        철수 주사위1 수 : 1
        //        철수 주사위2 수 : 3
        //        철수의 점수는 13
        //        영희 주사위1 수 : 3
        //        영희 주사위2 수 : 4
        //        영희의 점수는 34
        //        영희 승!
        System.out.print("철수 주사위1 수:");
        int dice1_1 = scan.nextInt();
        System.out.print("철수 주사위2 수:");
        int dice1_2 = scan.nextInt();

        int sum_dice1 = dice1_1 * 10 + dice1_2;
        System.out.println("철수의 점수는 " + sum_dice1);

        System.out.print("영희 주사위1 수:");
        int dice2_1 = scan.nextInt();
        System.out.print("영희 주사위2 수:");
        int dice2_2 = scan.nextInt();

        int sum_dice2 = dice2_1 * 10 + dice2_2;
        System.out.println("영희의 점수는 " + sum_dice2);

        if (sum_dice1 > sum_dice2) {
            System.out.println("철수 승!");
        } else if (sum_dice1 < sum_dice2) {
            System.out.println("영희 승!");
        } else {
            System.out.println("무승부!");
        }
    }
}

switch 문

// 점프 위치 변수에는 조건문이 아닌, 정수, 문자, 문자열이 들어감
switch (점프위치변수){ 
    case 위치값 1:
        실행내용; 
    case 위치값 2:
         실행 내용;
    default:
        실행 내용;
}

break 문: if 문을 제외한 가장 가까운 중괄호 탈출

• switch문에서 case안에 break는 반드시 넣어준다고 생각하기!! 빼는 경우는 옵션!
• 하나의 실행문에 break 사용하지 않고, 여러 개의 case를 연결하는 경우 코드가 간결해질 수 있다.

public class ex15 {
    public static void main(String[] args) {
        // 조건문 - switch 문
        // 패턴
        //    정수, 문자, 문자열
        int a = 10;
        switch (a) {
            case 9:
                System.out.println("9");
                break;
            case 10:
                System.out.println("10"); // 10
                break;
            default:
                System.out.println("그 외의 값");
        }
        int a2 = 9;
        switch (a2) {
            case 9:
                System.out.println("9"); // 9
            case 10:
                System.out.println("10"); // 10
            default:
                System.out.println("그 외의 값"); // 그 외의 값
        }
        // 해당 case 문을 만나서 실행 내용 출력후, break 문 만날때까지 밑 코드 계속 출력

        // 연습문제 - switch문 연습
        // 애완견 똘이를 기쁘게 해줄 애완용 로봇을 프로그램해보자.
        // 코드 0를 입력하면 "음악을 틀어준다."콘솔 출력
        // 코드 1 : 간식을 준다.
        // 코드 2 : 주인의 영상을 틀어준다.
        // 코드 3 : 산책을 시켜준다.
        // 그외의 코드 : 잘못된 코드입니다. 출력
        // 랜덤수(코드)를 0~5까지 발생시켜, 코드에 맞는 출력문을
        // 작성하시오.
        int code = (int) (Math.random() * 5);
        System.out.println("코드>> " + code);
        switch (code) {
            case 0:
                System.out.println("음악을 틀어준다.");
                break;
            case 1:
                System.out.println("간식을 준다.");
                break;
            case 2:
                System.out.println("주인의 영상을 틀어준다.");
                break;
            case 3:
                System.out.println("산책을 시켜준다.");
                break;
            default:
                System.out.println("잘못된 코드입니다.");
        }

        System.out.println("----------------");

        // 2.
        // 달을 나타내는 랜덤수 1~12까지의 정수를 발생시켜,
        // 3,4,5이면 봄
        // 6,7,8이면 여름
        // 9,10,11이면 가을
        // 12,1,2이면 겨울 이라고 출력하시오.
        int month = (int) (Math.random() * 12 + 1);
        System.out.println("month>> " + month);
        switch (month) {
            case 3:
            case 4:
            case 5:
                System.out.println("봄");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("여름");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("가을");
                break;
            case 12:
            case 1:
            case 2:
                System.out.println("겨울");
                break;
        }

    }
}

for문

for(초기식; 조건식; 증감식) { 실행내용; }

1. 초기식: for문이 시작될 때 딱 1번 실행
2. 조건식: for문 안으로 들어가는 유일한 출입구 → true인 경우 진입, false이면 for문 종료
3. 실행 내용
4. 증감식: for문의 닫힌 괄호() 이후 실행

순서: 1 → 2 → 3 → 4 → 2 → 3 → 4 → 2 → … →4

• 조건식 생략(true)하면 무한루프

public class ex16 {
    public static void main(String[] args) {
        // 반복문 for while do-while
        //      70%   29%    1%

        // for 문
        // 패턴
        // for (초기화(1); 조건식(2); 증감식(4)) {
        //      실행문(3);
        // }
        // 실행 순서: (1) => (2) => (3) => (4) => (2) => (3) => (4) => (2) => ... => (4)
        for (int i = 0; i < 5; i += 1) {
            System.out.println(i);
        }
        // 초기식, 조건식, 증감식을 잘못쓰면 무한루프에 걸린다.
        // for (int i = 0; ; i += 1) {
        //     System.out.println(i);
        // }
        // 무한루프 만드는 방법
        // 1. for(;;)
        // 2. while(true)

        // 연습문제
        // 1. 1부터 100까지 3과 5의 배수인 수만 출력하시오.
        //  for문 안에서 if문 사용
        for (int i = 1; i <= 100; i += 1) {
            if (i % 3 == 0 || i % 5 == 0) {
                System.out.println(i);
            }
        }

        System.out.println("------------------");

        // 2. 1부터 10까지의 합을 출력하시오.
        //  sum = sum + n;
        int sum = 0;
        for (int i = 1; i <= 10; i += 1) {
            sum += i;
        }
        System.out.println("sum>> " + sum);

        System.out.println("------------------");

        // 3. 1부터 100까지 끝자리가 3으로 끝나는 수의
        //   갯수(count)를 출력하시오.
        int count = 0;
        for (int i = 1; i <= 100; i += 1) {
            if (i % 10 == 3) {
                count += 1;
            }
        }
        System.out.println("count>> " + count);

        System.out.println("------------------");

        // 4.
        // 영희가 1부터 100까지 번호가 쓰인 징검다리 돌을
        // 지나고 있다.
        // 뒷자리가 2나 7로 된 돌은 밣지 않고 건너려고 한다.
        // 영희가 밣은 벽돌의 갯수와 밣지 않은 벽돌의 갯수를
        // 출력하시오.
        // 힌트 : 2 7 12 17 22 27 ... 돌은 밣지 않음.
        //       갯수는 count를 세는 것임.
        // 출력 예)
        // 영희가 밣은 벽돌의 갯수:80
        // 밣지 않은 벽돌의 갯수:20
        int brick = 0;
        for (int i = 1; i <= 100; i += 1) {
            if (i % 10 != 2 && i % 10 != 7) {
                brick += 1;
            }
        }
        System.out.println("영희가 밟은 벽돌의 갯수: " + brick);
        System.out.println("밟지 않은 벽돌의 갯수: " + (100 - brick));
    }
}

while문

초기식;
while(조건식) {
	실행내용;
	증감식;
}

• 조건식 생략(true)하면 무한루프

do-while문

초기식;
do {
	실행내용;
	증감식;
} while(조건식);

public class ex21 {
    public static void main(String[] args) {
        // while do-while

        // 패턴
        // for( 초기화; 조건식; 증감식){
        //      실행문;
        // }

        // 초기식;
        // while(조건식){
        //     실행문;
        //     증감문; // 맨 마지막
        // }
        int i = 0;
        while (i < 5) {
            System.out.println(i);
            i += 1;
        }

        // * do-while 문은 적어도 한번은 실행 후 주건 비교
        // 초기식;
        // do {
        //    실행문;
        //    증감문;
        // } while(조건식);
        i = 0;
        do {
            System.out.println(i);
            i += 1;
        } while (i < 5);
    }
}

[반복문 예제]

import java.util.Scanner;

public class ex18 {
    public static void main(String[] args) {
        // 반복문의 제어문: break continue
        // break: 반복문 중단
        // continue: 증감식으로 이동 -> 선택적인 필터링 개념!
        for (int i = 0; i < 10; i += 1) {
            if (i > 5) break;
            System.out.println(i);
        }
        for (int i = 0; i < 10; i += 1) {
            if (i % 2 == 0) continue;
            System.out.println(i);
        }

        // 연습문제 - break,continue
        // 1~100사이의 정수 한개 n을 입력받고
        // 1부터 n까지의 소수를 출력하시오.
        // 소수 조건 : 1과 자신만 나누어 떨어지는 수
        //         : 약수 갯수는 2개
        // 입력 예)
        // 6
        // 출력 예)
        // 1
        // 2
        // 3
        // 5
        // 소수의 갯수는 4개
        Scanner scan = new Scanner(System.in);
        int number = scan.nextInt();
        int totalPrime = 0;
        for (int i = 2; i <= number; i += 1) {
            int count = 0;
            for (int j = 1; j < i; j += 1) {
                if (i % j != 0) continue;
                count += 1;
            }
            if (count == 1) {
                System.out.println(i);
                totalPrime += 1;
            }
        }
        System.out.println("소수의 갯수는 " + totalPrime + "개");
    }
}

import java.util.Scanner;

public class ex19 {
    public static void main(String[] args) {
        // 이중반복문
        // 구구단 출력하기 2단 ~ 9단 / *1 ~ *9
        // for (int i = 2; i < 10; i += 1) {
        //     for (int j = 1; j < 10; j += 1) {
        //         System.out.println(i + "*" + j + "=" + i * j);
        //     }
        // }

        // 연습문제 - 별찍기
        // 1. 다음과 같이 출력하시오.
        // 입력 예)
        // 5
        // 출력 예)
        //*****
        //*****
        //*****
        //*****
        //*****
        // 입력 예)
        // 3
        // 출력 예)
        //***
        //***
        //***
        Scanner scan = new Scanner(System.in);
        int number = scan.nextInt();
        for (int i = 0; i < number; i += 1) {
            for (int j = 0; j < number; j += 1) {
                System.out.print("*");
            }
            System.out.println();
        }

        System.out.println("------------------");

        // 2. 별찍기2
        // 입력 예)
        // 3
        // 출력 예)
        //  *
        // **
        //***
        // 입력 예)
        // 5
        // 출력 예)
        //    *
        //   **
        //  ***
        // ****
        //*****
        int number2 = scan.nextInt();
        for (int i = 0; i < number2; i += 1) {
            for (int j = 0; j < number2; j += 1) {
                if (i + j >= number2 - 1) System.out.print("*");
                else System.out.print(" ");
            }
            System.out.println();
        }

        System.out.println("------------------");

        // 3. 별찍기3
        // 입력 예) 5이상의 홀수
        // 5
        // 출력 예)
        //*****
        //*  **
        //* * *
        //**  *
        //*****
        // 입력 예)
        // 7
        // 출력 예)
        //*******
        //*    **
        //*   * *
        //*  *  *
        //* *   *
        //**    *
        //*******
        int number3 = scan.nextInt();
        for (int i = 0; i < number3; i += 1) {
            if (i == 0 || i == number3 - 1) {
                System.out.println("*".repeat(number3));
                continue;
            }
            for (int j = 0; j < number3; j += 1) {
                if (j == 0 || j == number3 - 1 || j == number3 - 1 - i) {
                    System.out.print("*");
                } else {
                    System.out.print(" ");
                }
            }
            System.out.println();
        }

    }
}

label

public class ex20 {
    public static void main(String[] args) {
        // 중첩반복문에서의 제어: break, continue, lable
        // lable: 반복문의 제어 위치

        loop1:
        for (int i = 0; i < 5; i += 1) {
            System.out.println(i);
            loop2:
            for (int j = 0; j < 5; j += 1) {
                if (j > 3) break loop1; // loop1 for문이 종료됨.
                if (j % 2 == 1) continue loop1;
                System.out.print(j);
            }
            System.out.println();
        }
    }
}

❗️ 런타임 디버깅

반복문에서 코드의 흐름을 파악하거나, 변수의 값을 확인하는 용도

• print문만으로 전체 맥락 파악하기 어려울 때 사용

[사용법]

• Break Point(중단점) 설정
• 실행: 디버그(control + D)
• 스텝 오버: 다음줄로 이동
• 스텝 인투: 함수 안으로 이동
• 다시시작: 계속해서 진행(Resume)
• 스텝 아웃: 함수 밖으로 이동

---

배열

1차원 배열

배열 특징

1. 여러 개 값을 저장할 수 있는 공간으로, Heap 메모리에 생성된다.
2. 동일한 자료형만 묶어서 저장 가능
   • int[] a;, double[] a;, String[] a;
3. 생성시 크기 지정해야함 → 생성 이후 크기 변경 불가
   • int[] a = new int[3]; → 크기 지정해주어야 함.
   • int[] a = new int[]; → 크기 지정안해주어서 에러 발생

배열 선언

• 자료형[] 변수명; : 대부분 이걸로 작성 많이 함
• 자료형 변수명[];
• int[] a = null; 이렇게 작성하면 배열 a에 null이 들어가있음

배열 객체 선언 및 생성 시 메모리 구조

int[] a = new int[3];

new 키워드
”Heap 메모리에 넣어라”라는 의미

• JVM이 비워있는 공간에 객체를 생성
• 어느 공간에 넣었는지 알 수 없기 때문에 JVM은 객체의 위치 정보를 리턴해줌
• 리턴된 값을 참조변수에 저장

class(code) 영역, static 영역, final 영역, 메서드 영역	Stack 영역	Heap 영역
	a[100번지]	100번지[0(a[0]),0(a[1]),0(a[2])]

배열 생성 및 값 대입 방법

방법 1. 배열 객체 생성 + 값 대입

자료형[] 참조변수명 = new 자료형[배열의 길이];

참조변수명[0] = 값;
참조변수명[1] = 값;

참조변수명[배열의 길이-1] = 값;

방법 2. 배열 객체의 생성 및 값 대입

자료형[] 참조변수명 = new 자료형{값, 값, 값, ...};

방법 3. 값 대입 → 대입할 값만 입력

자료형[] 참조변수명 = {값, 값, 값, ...};

❗️방법2와 방법3의 차이점

• 방법 2는 선언과 값 대입 분리 가능하지만, 방법3은 선언과 값 대입 분리 불가능!

  // 방법 2
  int[] a = new int[3]{1,2,3}; // (o)
  
  int[] a;
  a = new int[3]{1,2,3}; // (o)

  // 방법 3
  int[] a = {1,2,3}; // (o)
  
  int[] a;
  a = {1,2,3}; // (x)

배열 객체의 강제 초기값

• Stack 메모리 초기값
  • 초기값 부여하지 않는 경우 빈칸으로 존재 → 초기값 부여하지 않은 경우 읽기 불가능

    int a; // 메모리에서 a공간이 빈칸으로 존재함
    System.out.println(a) // 오류 발생

• Heap 메모리 초기값
  • 빈칸으로 존재할 수 없으므로 디폴트 초기값이 강제로 설정됨
  • 숫자는 0, boolean은 false, 참조 자료형은 null로 초기값이 초기화됨

참조 자료형인 배열의 특징 → 변수 복사

• 기본 자료형의 변수 복사는 값의 복사임

  int a = 3;
  int b = a;
  b = 7;

  
• 참조 자료형의 변수 복사는 위치(번지)의 복사임

  int[] a = {3, 4, 5};
  int[] b = a;
  b[0] = 7;

  

코드로 내용 정리

import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.OptionalInt;

public class ex23 {
    public static void main(String[] args) {
        // 배열 Array
        // 1. 같은 타입의 데이터를 연속된 공간에 나열해 놓은 데이터구조
        // 2. 생성시 크기가 지정되고, 이후에는 변경 불가
        // 3. 인덱스는 0부터 부여

        // 정수형 1차 배열
        // 1. 선언&생성&대입 방법1
        int[] arrNum1 = new int[3];
        // 값 넣기 전에 값이 0으로 초기화됨.
        System.out.println(Arrays.toString(arrNum1)); // [0, 0, 0]
        arrNum1[0] = 10;
        arrNum1[1] = 20;
        arrNum1[2] = 30;
        // 2. 선언&생성&대입 -> 리터럴로 지정
        int[] arrNum2 = new int[]{10, 20, 30};
        // 3. 선언&생성&대입
        int[] arrNum3 = {10, 20, 30};
        // 4. 선언&생성&대입 -> 가능하지만, 사용이 잘 안된다.
        int arrNum4[] = {10, 20, 30};

        // 선언 시에 리터럴을 추가할 수는 있지만, 다음 줄에 리터럴을 넣는 것은 안됨!
        // int[] a;
        // a={3,4,5};

        // 반복문을 이용한 데이터 읽기
        // 1. 일반반복문 - for while
        for (int i = 0; i < arrNum1.length; i += 1) {
            System.out.println(arrNum1[i]);
        }
        // 2. for-each(향상된 for문)
        for (int num : arrNum1) {
            System.out.println(num);
        }

        System.out.println("--------------------");
        System.out.println("연습문제");
        // 연습문제
        int[] nums = {10, 30, 20, 50, 40};
        // 1. 배열의 모든 요소값를 출력하시오.
        System.out.println(Arrays.toString(nums));
        // 2. 배열의 값 갯수를 출력하시오.
        System.out.println(nums.length);
        // 3. 배열의 모든 값의 합계를 출력하시오.
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }
        System.out.println(sum);
        // 4. 배열에서 20은 몇번째에 위치하는지 출력하시오.
        //   출력값: 3번째
        for (int i = 0; i < nums.length; i += 1) {
            if (nums[i] == 20) System.out.println(i + 1 + "번째");
        }

        // 배열의 정렬 - 오름차순
        Arrays.sort(nums);
        System.out.println(Arrays.toString(nums)); // [10, 20, 30, 40, 50]
        // 배열의 정렬 - 내림차순
        Integer[] nums2 = {10, 30, 20, 50, 40};
        Arrays.sort(nums2, Collections.reverseOrder());
        System.out.println(Arrays.toString(nums2)); // [50, 40, 30, 20, 10]

    }
}

2차원 배열

자료형[][] 변수명; 자료형 변수명[][]; 자료형[] 변수명[];

• 선언시 동일한 자료형을 저장해야함
• 메모리는 데이터를 1차원으로만 저장 가능
• 2차원 데이터를 저장하기 위해서는 1차원(행 단위)으로 나누어 저장

2차원 배열 객체 생성 방법

방법 1. 배열 객체의 생성 + 값 대입

자료형[][] 참조변수명 = new 자료형[행의 길이][열의 길이];

참조변수명[0][0] = 값;
참조변수명[0][1] = 값;
...
참조변수명[행의 길이-1][열의 길이-1] = 값;

방법 2. 2차원 배열 객체의 행만 생성 후, 각 행에 대한 열 생성

자료형[][] 참조변수명 = new 자료형[행의 길이][];
참조변수명[0] = 1차원 배열 생성; // new 생성자로 생성
참조변수명[1] = 1차원 배열 생성;
...
참조변수명[행의 길이-1] = 1차원 배열 생성;

방법 3. 자료형과 대입할 값만 입력

자료형[][] 참조변수명 = new 자료형[][]{{값, 값, 값,..}, {값, 값, 값,..}};

• 이 방법은 너무 복잡해서 잘 사용 X

방법 4. 대입할 값만 입력

자료형[][] 참조변수명 = {{값, 값, 값,...}, {값, 값, 값,...}};

코드로 내용 정리

import java.util.Arrays;
import java.util.Random;

public class ex24 {
    public static void main(String[] args) {
        // 2차원 배열
        // 1.
        int[][] arrNum1 = new int[3][3]; // 3행 3열 정수형 2차원 배열
        // 2.
        int[][] arrNum2 =
                new int[][]{{10, 20, 30}, {40, 50, 60}}; // 2행 3열
        // 3.
        int[][] arrNum3 = {{10, 20, 30}, {40, 50, 60}}; // 2행 3열
        // 4.
        int[][] arrNum4 = new int[2][];
        arrNum4[0] = new int[3];
        arrNum4[1] = new int[3]; // 2행 3열

        // 행의 길이
        System.out.println(arrNum2.length);
        // 열의 길이
        System.out.println(arrNum2[0].length);
        System.out.println(arrNum2[1].length);

        System.out.println("------------------");
        System.out.println("연습문제");
        // 연습문제
        // 1. 2차원 정수배열 nums를 행 3개, 열 3개로 만들고,
        // 모든 행열에 값을 넣되,
        // 랜덤값 정수 1~100 사이의 값을 넣고,
        // 전체를 순환하여 출력하시오.
        Random rand = new Random();
        int[][] nums = new int[3][3];

        for (int r = 0; r < nums.length; r += 1) {
            for (int c = 0; c < nums[r].length; c += 1) {
                nums[r][c] = rand.nextInt(100) + 1;
            }
        }

        for (int[] numR : nums) {
            for (int numC : numR) {
                System.out.print(numC + " ");
            }
            System.out.println();
        }
        // 2. 최소값과 최대값을 출력하시오.
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        for (int[] numR : nums) {
            for (int numC : numR) {
                if (numC > max) max = numC;
                if (numC < min) min = numC;
            }
        }
        System.out.println("max>> " + max + ", min>> " + min);
        // 3.
        // 순돌이네 인쇄소
        // 3x3 2차원 정수배열에 아래와 같은 숫자가 들어있다면,
        // 0 1 0       #  *  #
        // 1 2 0   =>  *  +  #
        // 1 0 0       *  #  #
        // 이렇게 출력이 된다.
        // 0 1 2
        // 1 2 0
        // 2 1 0 이렇게 들어가 있을때 출력결과를 표시하시오.
        int[][] data = {{0, 1, 2},
                {1, 2, 0},
                {2, 1, 0}};
        for (int[] c : data) {
            for (int r : c) {
                if (r == 0) System.out.print("# ");
                else if (r == 1) System.out.print("* ");
                else System.out.print("+ ");
            }
            System.out.println();
        }
    }
}