ABOUT ME

-

Today
-
Yesterday
-
Total
-
  • 016. 배열의 배열(다차원 배열)실습, 배열의 난수(Random 클래스)
    SsY/Class 2023. 3. 5. 23:17
    728x90

    2023.02.15 (수)

    배열
    - 배열의 배열
    • Test089
      - 배열의 배열(2차원 배열)
    더보기
    /*=====================================
                  ■■■ 배열 ■■■
            - 배열의 배열(2차원 배열)
    ======================================*/
    
    // 배열의 배열(다차원 배열)을 활용하여
    // 다음과 같은 데이터를 요소로 취하는 배열을 구성하고
    // 그 결과를 출력하는 프로그램을 구현한다.
    // 단, 배열을 구성하는 코드와 출력하는 코드는 분리한다.
    
    // 실행 예)
    /*
      1  8   9  16  17			
      2  7  10  15  18			
      3  6  11  14  19		
      4  5  12  13  20			
    계속하려면 아무 키나 누르세요...
    */
    
    /*
    	00	01	02	03	04
    (	 1	 2	 3	 4	 5	)
    	10	11	12	13	14
    (	 6	 7	 8	 9	10	)
    	20	21	22	23	24
    (	11	12	13	14	15	)
    	30	31	32	33	34
    (	16	17	18	19	20	)
    			
    			▼				i와 j를 뒤집어 값을 넣는다
    
    	00	10	20	30			i = 짝수
    (	 1	 2	 3	 4	)
    	01	11	21	31			i = 홀수 j : 5 6 7 8 > 8 7 6 5 
    (	 5	 6	 7	 8	)
    	02	12	22	32			i = 짝수
    (	 9	10	11	12	)
    	03	13	23	33			i = 홀수 j : 13 14 15 16 > 16 15 14 13
    (	13	14	15	16	)
    	04	14	24	34			i = 짝수
    (	17	18	19	20	)
    			〓
    	00	01	02	03	04
    (	 1	 5	 9	13	17	)
    	10	11	12	13	14
    (	 2	 6	10	14	18	)
    	20	21	22	23	24
    (	 3	 7	11	15	19	)
    	30	31	32	33	34
    (	 4	 8	12	16	20	)
    
    			▼				i의 값이 홀수일 때, 3-j 하면 값이 거꾸로 담김
    
    	00	10	20	30			i = 짝수
    (	 1	 2	 3	 4	)
    	01	11	21	31			i = 홀수 j : 5 6 7 8 > 8 7 6 5 
    (	 8	 7	 6	 5	)
    	02	12	22	32			i = 짝수
    (	 9	10	11	12	)
    	03	13	23	33			i = 홀수 j : 13 14 15 16 > 16 15 14 13
    (	16	15	14	13	)
    	04	14	24	34			i = 짝수
    (	17	18	19	20	)
    
    	00	01	02	03	04
    (	 1	 8	 9	16	17	)
    	10	11	12	13	14
    (	 2	 7	10	15	18	)
    	20	21	22	23	24
    (	 3	 6	11	14	19	)
    	30	31	32	33	34
    (	 4	 5	12	13	20	)
    
    */
    
    public class Test089
    {
    	public static void main(String[] args)
    	{
    		int i,j,n;
    		n=1;
    		int[][] arr = new int[4][5];
    
    		for (i = 0; i<5; i++)
    		{
    			for (j = 0; j<4;j++)
    			{
    				if (i%2!=0)
    					arr[3-j][i] = n;
    				else
    					arr[j][i] = n;
    
    				n++;
    			}
    		}
    		
    		for (i=0; i<arr.length; i++)
    		{
    			for (j=0; j<arr[i].length; j++)
    			{
    				System.out.printf("%4d",arr[i][j]);
    			}
    			System.out.println();
    		}
    		
    	}
    }
    //실행결과
    
    /* 
       1   8   9  16  17
       2   7  10  15  18
       3   6  11  14  19
       4   5  12  13  20
    계속하려면 아무 키나 누르십시오 . . .
    */

    • Test090
      - 배열의 배열 (2차원 배열)
    더보기
    /*=====================================
                  ■■■ 배열 ■■■
            - 배열의 배열(2차원 배열)
    ======================================*/
    
    // 배열의 배열(다차원 배열)을 활용하여
    // 다음과 같은 데이터를 요소로 취하는 배열을 구성하고
    // 그 결과를 출력하는 프로그램을 구현한다.
    // 단, 배열을 구성하는 코드와 출력하는 코드는 분리한다.
    
    // 실행 예)
    /*
      E  J  O  T  Y
      D  I  N  S  X			
      C  H  M  R  W			
      B  G  L  Q  V		
      A  F  K  P  U			
    계속하려면 아무 키나 누르세요...
    */
    
    public class Test090
    {
    	public static void main(String[] args)
    	{
    		// 배열의 배열 선언 및 메모리 할당
    		char[][] arr = new char[5][5];
    
    		// int n=0;
    		char start = 'A';	// 65
    
    		for (int i=0; i<5; i++)			// 웅~~		i  0 1 2 3 4
    		{
    			for (int j=4; j>=0; j--)	// 쑝쑝쑝	j  4 3 2 4 0
    			{
    				arr[j][i] = start++; // 65 66 67 68
    				//--------------- ---postfix 처리 이후
    				// arr[4][0] = 'A';→ 'A'
    				// arr[3][0] = 'A';→ 'B'
    				// arr[2][0] = 'A';→ 'C'
    				// arr[1][0] = 'A';→ 'D'
    				// arr[0][0] = 'A';→ 'E'
    
    				// arr[4][1] = 'A';→ 'F'
    				// arr[3][1] = 'A';→ 'G'
    				// arr[2][1] = 'A';→ 'H'
    				// arr[1][1] = 'A';→ 'I'
    				// arr[0][1] = 'A';→ 'J'
    			}
    		}
    		// 전체요소 출력
    		for (int i=0; i<arr.length; i++)
    		{
    			for (int j=0; j<arr[i].length; j++)
    				System.out.printf("%3c", arr[i][j]);
    			System.out.println();
    		}
    	}
    }
    
    // 실행 결과 
    
    /*
      E  J  O  T  Y
      D  I  N  S  X
      C  H  M  R  W
      B  G  L  Q  V
      A  F  K  P  U
    계속하려면 아무 키나 누르십시오 . . .
    */

    • Test091
      - 배열의 배열 (2차원 배열)
    더보기
    /*=====================================
                  ■■■ 배열 ■■■
            - 배열의 배열(2차원 배열)
    ======================================*/
    
    // 배열의 배열(다차원 배열)을 활용하여
    // 다음과 같은 데이터를 요소로 취하는 배열을 구성하고
    // 그 결과를 출력하는 프로그램을 구현한다.
    // 단, 배열을 구성하는 코드와 출력하는 코드는 분리한다.
    
    // 실행 예)
    /*
    	 1	 2	 3	 4	10
    	 5	 6	 7	 8	26
    	 9	10	11	12	42
    	13	14	15	16	58
    	28	32	36	40	136
    계속하려면 아무 키나 누르세요...
    */
    
    public class Test091
    {
    	public static void main(String[] args)
    	{
    		int[][] arr = new int[5][5];
    		int n=0;
    
    		//테스트 변수
    		int sum = 0;
    
    		// 각 for 문 수식 2의 『-1』 → 반복문의 처리가 필요하지 않은 영역
    		for (int i=0; i<arr.length-1; i++)		// 웅		i		0 1 2 3
    		{
    			for (int j=0; j<arr.length-1; j++)	// 숑숑		j		0 1 2 3 
    			{
    				n++;							// 1 2 3 4 ... 14 15 16
    				arr[i][j] = n;
    				
    				//테스트
    				//sum += arr[i][j];
    
    				arr[i][arr[i].length-1] += arr[i][j];
    				// arr[0][4] += arr[0][0]
    				//					:
    				//				arr[0][3]
    				// arr[1][4] += arr[1][0]
    				//					:
    				//	   2
    				//     3
    
    				arr[arr.length-1][j] += arr[i][j];
    				// arr[4][0] += arr[0][0]
    				//					:
    				//				arr[3][0]
    				// arr[4][1] += arr[0][1]
    				//					:
    				//				arr[3][1]
    				//		2
    				//		3
    
    				arr[arr.length-1][arr[i].length-1] += arr[i][j];
    				// arr[5-1][5-1] += arr[i][j];
    				// arr[4][4] += arr[i][j];
    
    				// arr[4][4] += arr[0][0];
    				// arr[4][4] += arr[0][1];
    				//			  :
    				// arr[4][4] += arr[3][3];
    			}
    		}
    		//System.out.println("\nsum : " + sum);
    
    		//배열의 배열 전체 요소 출력 구문
    		for (int i=0; i<arr.length; i++)
    		{
    			for (int j=0; j<arr.length; j++)
    				System.out.printf("%4d",arr[i][j]);
    			System.out.println();
    		}
    
    	}
    }

    • Test092 (과제)
      - 배열의 배열 (2차원 배열)
    // ○ 과제 (혼자서)
    // 배열의 배열(다차원 배열)을 활용하여
    // 다음과 같은 데이터를 요소로 취하는 배열을 구성하고
    // 그 결과를 출력하는 프로그램을 구현한다.
    // 단, 배열을 구성하는 코드와 출력하는 코드는 분리한다.

    // 실행 예)
    /*
    A B C D E
    F G H I J
    K L M N O
    P Q R S T
    U V W X Y
    계속하려면 아무 키나 누르세요...
    */

    풀이

    더보기
    public class Test092
    {
    	public static void main(String[] args)
    	{
    		// 배열의 배열 선언 및 메모리 할당
    		char[][] chs = new char[5][5];	// chs라는 이름을 가진 배열 선언 후 5*5 배열로 메모리 할당함
    		
    		// 주요 변수 선언 및 초기화
    		char start = 'A';					// 변수가 A 부터 시작하여 배열 방 개수만큼 저장해야 하기 때문에
    		
    		// 배열의 배열에 값 담아내기
    		for (int i=0; i<chs.length; i++)			// 배열을 만들면 0번째 방부터 생성되어 5개가 생성되기 때문에 
    		{											// 웅 ~		0		1		2		3		4
    			for (int j=0; j<chs[i].length; j++)		// 숑 ~		01234	01234	01234	01234	01234
    			{
    				chs[i][j] = start++;				// 각 방 안에 들어갈 알파벳이 A부터 (아스키코드값)1씩 증가하여 문자형태로 차례로 들어가게 됨
    			}
    		}
    		//---------------------------------- 이까지 진행되면 각 방에 A B C D ... ... X Y 까지 차례대로 할당 됨.
    
    		// 전체 출력
    		for (int i=0; i<chs.length; i++)
    		{
    			for (int j=0; j<chs.length; j++)
    			{
    				System.out.printf("%2c", chs[i][j]);	// 각 방의 문자를 차례대로 출력하면서, 2칸의 공백을 확보한 채로 문자 출력
    			}
    			System.out.println();						// 5개, 즉 웅~ 숑숑숑숑숑 이 끝날 때 마다 개행 되어야하기 때문에
    		}
    	}
    }
    // 실행 결과
    
    /*
     A B C D E
     F G H I J
     K L M N O
     P Q R S T
     U V W X Y
    계속하려면 아무 키나 누르십시오 . . .
    */

    • Test093 (과제)
      - 배열의 배열 (2차원 배열)
    // ○ 과제
    // 배열의 배열(다차원 배열)을 활용하여
    // 다음과 같은 데이터를 요소로 취하는 배열을 구성하고
    // 그 결과를 출력하는 프로그램을 구현한다.
    // 단, 배열을 구성하는 코드와 출력하는 코드는 분리한다.

    // 실행 예)
    /*
    A
    B C
    D E F
    G H I J
    K L M N O
    계속하려면 아무 키나 누르세요...
    */

    풀이

    더보기
    /*
    	00	//	//	//	//
    	10	11	//	//	//
    	20	21	22	//	//
    	30	31	32	33	//
    	40	41	42	43	44	
    */
    
    public class Test093
    {
    	public static void main(String[] args)
    	{
    		// 배열의 배열 선언 및 메모리 할당
    		char[][] chs = new char[5][5];	// chs라는 이름을 가진 배열 선언 후 5*5 배열로 메모리 할당함
    		
    		// 주요 변수 선언 및 초기화
    		char start = 'A';					// 변수가 A 부터 시작하여 배열 방 개수만큼 저장해야 하기 때문에
    		
    		// 배열의 배열에 값 담아내기
    		for (int i=0; i<chs.length; i++)			// 배열을 만들면 0번째 방부터 생성되어 5개가 생성되기 때문에 
    		{											// 웅 ~		0		1		2		3		4
    			for (int j=0; j<chs[i].length; j++)		// 숑 ~		01234	01234	01234	01234	01234
    			{
    				if (i>=j)							// j의 값이 i 보다 작거나 같을 때 알파벳 값이 차례로 담기도록
    					chs[i][j] = start++;			// 각 방 안에 들어갈 알파벳이 A부터 (아스키코드값)1씩 증가하여 문자형태로 차례로 들어가게 됨
    				else								// j의 값이 i 보다 클 때 아무 값을 넣지 않으면 0으로 출력되기 때문에
    					chs[i][j] = ' ';				// ' ' 공백값이 출력되도록 한다.
    			}
    		}
    
    		// 전체 출력
    		for (int i=0; i<chs.length; i++)
    		{
    			for (int j=0; j<chs[i].length; j++)
    				System.out.printf("%2c", chs[i][j]);	// 각 방의 문자를 차례대로 출력하면서, 2칸의 공백을 확보한 채로 문자 출력
    			System.out.println();						// 5개, 즉 웅~ 숑숑숑숑숑 이 끝날 때 마다 개행 되어야하기 때문에
    		}
    		System.out.println();							// 마지막 계속하려면 아무 키나 누르십시오 전에 나오는 개행
    	}
    }
    
    // 실행결과
    
    /*
     A
     B C
     D E F
     G H I J
     K L M N O
    
    계속하려면 아무 키나 누르십시오 . . .

    • Test094 (과제)
      - 배열의 배열 (2차원 배열)
    // ○ 과제
    // 배열의 배열(다차원 배열)을 활용하여
    // 다음과 같은 데이터를 요소로 취하는 배열을 구성하고
    // 그 결과를 출력하는 프로그램을 구현한다.
    // 단, 배열을 구성하는 코드와 출력하는 코드는 분리한다.

    // 실행 예) (단, // 진행방향 표시는 출력하는 것이 아닌 이해를 돕기 위한 것)
    /*
    A                       // →
    C B                   // ←
    D E F                // →
    J I H G              // ←
    K L M N O        // →
    계속하려면 아무 키나 누르세요...
    */

    풀이

    더보기
    /*
    	00
    	10	11					// i = 홀수
    →	11	10
    
    	20	21	22
    	30	31	32	33			// i = 홀수
    →	33	32	31	30
    
    	40	41	42	43	44
    
    // i 값이 홀수일때 담기는 차례가 거꾸로 되어야 한다
    
    */
    public class Test094
    {
    	public static void main(String[] args)
    	{
    		// 배열의 배열 선언 및 메모리 할당
    		char[][] chs = new char[5][5];		// chs라고하는 char타입으로 선언하고 5*5 배열을 할당
    
    		// 주요변수 선언 및 초기화
    		char start = 'A';					// 문자를 담아나갈 변수 선언 및 시작점인 'A'로 초기화
    
    		// 배열의 배열 값 채우기
    		for (int i=0; i<chs.length; i++)			// 배열을 만들면 0번째 방부터 생성되어 5개가 생성되기 때문에
    		{											// 웅 ~		0		1		2		3		4
    			for (int j=0; j<chs[i].length; j++)		// 숑 ~		01234	01234	01234	01234	01234
    			{
    				if (i>=j)							// j의 값이 i 보다 작거나 같을 때 알파벳 값이 차례로 담기도록
    				{
    					if (i%2==0)						// i 가 짝수일때, 
    						chs[i][j] = start++;		//알파벳이 A부터 (아스키코드값)1씩 증가하여 문자형태로 정방향 차례로 들어가게 됨
    					else if (i==1)					// i 가 홀수인 1일때,
    						chs[i][1-j] = start++;
    					else							// i 가 홀수인 3일때,
    						chs[i][3-j] = start++;		// (아스키코드값)1씩 증가하여 문자형태로들어오는 알파벳이 역방향으로 입력되게 됨
    				}
    				else								// j의 값이 i 보다 클 때 아무 값을 넣지 않으면 0으로 출력되기 때문에
    					chs[i][j] = ' ';				// ' ' 공백값이 출력되도록 한다.
    			}
    		}
    
    		// 전체 출력 
    		for (int i=0; i<chs.length; i++)
    		{
    			for (int j=0; j<chs[i].length; j++)
    				System.out.printf("%2c", chs[i][j]);	// 각 방의 문자를 차례대로 출력하면서, 2칸의 공백을 확보한 채로 문자 출력
    			System.out.println();						// 5개, 즉 웅~ 숑숑숑숑숑 이 끝날 때 마다 개행 되어야하기 때문에
    		}
    		System.out.println();							// 마지막 계속하려면 아무 키나 누르십시오 전에 나오는 개행
    	}
    }
    
    // 실행결과 
    
    /*
     A
     C B
     D E F
     J I H G
     K L M N O
    
    계속하려면 아무 키나 누르십시오 . . .
    */

    배열
    - 배열의 난수 처리 (Random 클래스 활용)
    ※ Random 클래스 (간략)
    import.java.util.Random;    // 자바 util 패키지에 있는 클래스
     - 원래 math 클래스 안에 다양한 수학적 속성들이 들어가있었고,
       그 중에 난수를 발생시키는 형태의 기능도 있었으나, 
       많은 사람들이 난수 발생하는 기능을 사용하면서 이를 전담하는 객체, 즉 Random 클래스가 만들어지게 되었다.
    • Random 클래스의 nextInt( int bounds ) 메소드
      - 매개변수로 정수형태를 넣게 되면, 난수의 발생범위를 지정할 수 있다
        매개변수의 범위는 0(포함) ~ 매개변수 값-1 의 범위를 지정하게 된다.
        ex ) int n = 랜덤클래스타입의 참조변수.nextInt(100) 은
               반환자료형이 int 로,  0~99 까지의 무작위 정수를 1개 발생 시킬 수 있다는 의미가 된다.

    (▼ Java API Random 클래스의 nextInt() 메소드 설명 ) 

    • Test095
      -배열의 난수 처리 (Random 클래스)
    더보기
    /*=============================================
                      ■■■ 배열 ■■■
       - 배열의 난수 처리 (※ Random 클래스 활용)
    ==============================================*/
    
    // 사용자로부터 임의의 정수를 입력받아
    // 그 정수의 갯수만큼 난수(1~100)를 발생시켜 배열에 담고
    // 배열에 담겨있는 데이터들 중
    // 가장 큰 값과 가장 작은 값을 선택하여
    // 결과를 출력하는 프로그램을 구현한다.
    
    // 실행 예)
    // 발생시킬 난수의 갯수 입력 : 10
    // (40 7 13 29 84 61 22 3 75 99 → 무작위로 발생한 정수들...)
    // (int[] arr = {40, 7, 13, 29, 84, 61, 22, 3, 75, 99} → 배열에 담아내기)
    // 가장 큰 값 : 99, 가장 작은 값 : 3
    // 계속하려면 아무 키나 누르세요...
    
    import java.util.Scanner;
    import java.util.Random;
    
    public class Test095
    {
    	public static void main(String[] args)
    	{
    		//Scanner 인스턴스 생성
    		Scanner sc = new Scanner(System.in);
    
    		// 주요 변수 선언
    		int size;							//-- 사용자의 입력값을 담아낼 변수
    
    		// 안내 메세지 출력
    		System.out.print("발생시킬 난수의 갯수 입력 : ");
    		size = sc.nextInt();
    
    		// size 변수에 담아낸 수 만큼의 배열방 만들기(배열 길이)
    		// (배열 선언 및 메모리 할당)
    		int[] arr = new int[size];
    
    		// 무작위 정수(난수)를 발생시키기 위해서는
    		// 난수 발생 전용 객체가 필요하다.
    		// → 『java.util.Random』
    		Random rd = new Random();
    		//-- Random 클래스 기반 인스턴스 생성
            
            // 테스트(확인)
    		//System.out.println("발생한 난수 : " + rd.nextInt(10));
    		//-- 0 ~ 9 까지의 범위 내에서 무작위 정수 1개 발생
    
    		// 배열 구성 → 난수를 발생시켜 각 배열방에 수납
    		//for (int i=0; i<arr.length; i++)
    		for (int i=0; i<size; i++)
    		{
    			// rd.nextInt(100);		→ 0 ~ 99 까지의 무작위 정수 한 개 발생	
    			// rd.nextInt(100) + 1;	→ 1 ~ 100 까지의 무작위 정수 한 개 발생		
    
    			arr[i] = rd.nextInt(100) + 1;
    		}
    
    		// 테스트 → 구성된 배열의 전체 요소 출력
    		for (int i=0; i<arr.length; i++)
    			System.out.printf("%4d",arr[i]);
    		System.out.println();
    		//--==>> 발생시킬 난수의 갯수 입력 : 10
    		//		 26  56  60  83   2  44  26  24  99  24
    		//		발생시킬 난수의 갯수 입력 : 10
    		//		  25  33  21   3  85   2  87   9  69  57
    		//		발생시킬 난수의 갯수 입력 : 10
    		//		  86  28  87  16  62  40  13   6  40  31
    
    		//----------- 여기까지 수행하면 난수를 활용하여 배열 구성 완료~!!
    		
    		/*
    		//++ 추가 코드 구성 방법 ① → 기능 구현 완료
    		// 가장 큰 값과 작은 값을 i 번째(마지막) 방과 0 번째 방으로 넣어 출력하는 방법 
    		int max, min;
    		
    		for (int i=1; i<size; i++)
    		{
    			if (arr[i-1] - arr[i] > 0)
    			{
    				arr[i-1] = arr[i-1]^arr[i];
    				arr[i] = arr[i]^arr[i-1];
    				arr[i-1] = arr[i-1]^arr[i];
    			}
    		}
    		for (int i=1; i<size; i++)
    		{
    			if (arr[0] - arr[i] >= 0)
    			{
    				arr[0]=arr[0]^arr[i];
    				arr[i]=arr[i]^arr[0];
    				arr[0]=arr[0]^arr[i];
    			}
    		}
    
    		max = arr[size-1];
    		min = arr[0];
    
    		System.out.printf("가장 큰 값 : %d, 가장 작은 값 : %d\n", max, min);
    		*/
    
    		//++ 추가 코드 구성 방법 ② → 기능 구현 완료
    		// 가장 큰 값과 작은 값의 변수를 0번방으로 초기화 후, 각 값들과 비교하여 크면 대입 하는 방식으로 max를 , 작으면 대입하는 방식으로 min 의 값을 바꿔 출력
    		// 가장 작은 값, 큰 값 출력~!!!
    		int min, max;										// 배열 요소 중 최소값, 최대값
    		min=max=arr[0];										// arr[0]의 값을 max에 대입하고
    															// 다시 그 max 값을 min에 대입
    		for (int i=1; i<arr.length; i++)
    		{
    			//최대값 얻어내기
    			if (max < arr[i])
    			{
    				// max를 arr[i]의 값으로 덮어쓴다.
    				max = arr[i];
    			}
    
    			// 최소값 얻어내기
    			if (min > arr[i])
    			{
    				// min을 arr[i]의 값으로 덮어쓴다.
    				min = arr[i];
    			}
    		}
    
    		// 결과 출력
    		System.out.printf("가장 큰 값 : %d, 가장 작은 값 : %d\n", max, min);
    		
    	}
    }
    
    // 실행 결과
    
    /*
    발생시킬 난수의 갯수 입력 : 10
      59  29  33  14  24  56  81  64  98  12
    가장 큰 값 : 98, 가장 작은 값 : 12
    계속하려면 아무 키나 누르십시오 . . .
    */

     

    // 개인적 감상

    더보기

    내 약점은 배열의 중첩 파트인 것 같다. 
    과제까지는 무난하게 풀어내고 있으나, 오히려 해설을 들었던 부분을 조금 더 헷갈려하고 있다.
    재 풀이를 통해서 풀어보는데도 시간이 많이 소모되고, 풀이를 통해서 여러번 반복함에도 불구하고 익숙해지는데 시간이 걸릴 것같다.

    그래도 처음보다는 어떻게 풀어야할지 까지는 감이 잡히고 코드 구현 부분에서 버벅임은 있지만 느리지만 진전은 되어가고 있다는 게 보이니까 중간중간 배열파트에 대한 복습을 통해서 더 나아져야겠다.

    728x90
Designed by planet-si