[2차원 배열 예제_ 여러 방향으로 뒤집기]

 

1. 90도 회전하기

  [원리] *표시한 노란색 기준
  - 왼쪽의 열이 오른쪽 행로 바뀌었다. (반대로는, 오른쪽 행은 왼쪽의 열이다)
  - 왼쪽의 열은 0~4순번이며, 오른쪽 행도 0~4순번이다. (반대로도 동일)
  - 왼쪽의 행은 0으로 고정되었고, 오른쪽 열은 4로 고정되어 있다. 

[90도 회전 코드]

package myutil;

public class MultiArray {
	public static int[][] rotate90(int[][] arr){
		int row = arr.length, col = arr[0].length;		
		int[][] rotatedArr = new int[row][col];
		
		for(int i = 0; i < row; i++) {
			for(int j = 0; j < col; j++) {
				rotatedArr[i][j] = arr[(row-1)-j][i];
			}
		}
		return rotatedArr;
	}
}

[출력 코드]

package mymain;

import myutil.MultiArray;

public class MultiArrayTest {

	public static void main(String[] args) {
		int[][] arr = new int[5][5];
		int n = 1;
		for(int i = 0; i < arr.length; i++) {
			for(int j = 0; j < arr[0].length; j++) {
				arr[i][j] = n++;
			}
		}
		
		int[][] rotatedArr = MultiArray.rotate90(arr);
		
		n = 1;
		for(int i = 0; i < rotatedArr.length; i++) {
			for(int j = 0; j < rotatedArr[0].length; j++) {
				System.out.printf("%4d",rotatedArr[i][j]);
			}
			System.out.println();
		}
	}

}

>> 결과

  21  16  11   6   1
  22  17  12   7   2
  23  18  13   8   3
  24  19  14   9   4
  25  20  15  10   5

 

 

2. 좌우 바꾸기

  [원리] *표시한 색 기준
  - 왼쪽의 열의 0번째가 오른쪽 열의 4번째가 되었다.
  - 왼쪽의 열의 4번째가 오른쪽 열의 0번째가 되었다.  

[좌우 바꾸기 코드]

package myutil;

public class MultiArray {
	public static int[][] flip_leftRight(int[][] arr){
		int row = arr.length, col = arr[0].length;
		int[][] flipedArr = new int[row][col];
		
		for(int i = 0; i < row; i++) {
			for(int j = 0; j < col; j++) {
				flipedArr[i][j] = arr[i][(col-1)-j];
			}
		}
		return flipedArr;
	}
}

[출력 코드]

package mymain;

import myutil.MultiArray;

public class MultiArrayTest {

	public static void main(String[] args) {
		int[][] arr = new int[5][5];
		int n = 1;
		for(int i = 0; i < arr.length; i++) {
			for(int j = 0; j < arr[0].length; j++) {
				arr[i][j] = n++;
			}
		}
		
		int[][] rotatedArr = MultiArray.flip_leftRight(arr);
		
		n = 1;
		for(int i = 0; i < rotatedArr.length; i++) {
			for(int j = 0; j < rotatedArr[0].length; j++) {
				System.out.printf("%4d",rotatedArr[i][j]);
			}
			System.out.println();
		}
	}

}

>> 결과

   5   4   3   2   1
  10   9   8   7   6
  15  14  13  12  11
  20  19  18  17  16
  25  24  23  22  21

 

3. 위아래 바꾸기

  [원리] *표시한 노란색 기준
  - 왼쪽 행의 0번째가 오른쪽 행의 4번째
  - 왼쪽 행의 4번째가 오른쪽 행의 0번째

[위아래 바꾸기 코드]

package myutil;

public class MultiArray {
	public static int[][] flip_upDown(int[][] arr){
		int row = arr.length, col = arr[0].length;
		int[][] flipedArr = new int[row][col];
		
		for(int i = 0; i < row; i++) {
			for(int j = 0; j < col; j++) {
				flipedArr[i][j] = arr[(row-1)-i][j];
			}
		}
		return flipedArr;
	}
}

[출력 코드]

package mymain;

import myutil.MultiArray;

public class MultiArrayTest {

	public static void main(String[] args) {
		int[][] arr = new int[5][5];
		int n = 1;
		for(int i = 0; i < arr.length; i++) {
			for(int j = 0; j < arr[0].length; j++) {
				arr[i][j] = n++;
			}
		}
		
		int[][] rotatedArr = MultiArray.flip_upDown(arr);
		
		n = 1;
		for(int i = 0; i < rotatedArr.length; i++) {
			for(int j = 0; j < rotatedArr[0].length; j++) {
				System.out.printf("%4d",rotatedArr[i][j]);
			}
			System.out.println();
		}
	}

}

>> 결과

  21  22  23  24  25
  16  17  18  19  20
  11  12  13  14  15
   6   7   8   9  10
   1   2   3   4   5

 

4. 대각선(좌->우) 접기

  [원리] *표시한 노란색 기준
  - 왼쪽의 행이 오른쪽 열로 바뀌었다. 
  - 왼쪽의 행은 0~4순번이며, 오른쪽 열도 0~4순번이다.

[대각선(좌->우) 코드]

package myutil;

public class MultiArray {
	public static int[][] diagonal1(int[][] arr){
		int row = arr.length, col = arr[0].length;
		int[][] diagonalArr = new int[row][col];
		
		for(int i = 0; i < row; i++) {
			for(int j = 0; j < col; j++) {
				diagonalArr[i][j] = arr[j][i];
			}
		}
		return diagonalArr;
	}
}

[출력 코드]

package mymain;

import myutil.MultiArray;

public class MultiArrayTest {

	public static void main(String[] args) {
		int[][] arr = new int[5][5];
		int n = 1;
		for(int i = 0; i < arr.length; i++) {
			for(int j = 0; j < arr[0].length; j++) {
				arr[i][j] = n++;
			}
		}
		
		int[][] rotatedArr = MultiArray.diagonal1(arr);
		
		n = 1;
		for(int i = 0; i < rotatedArr.length; i++) {
			for(int j = 0; j < rotatedArr[0].length; j++) {
				System.out.printf("%4d",rotatedArr[i][j]);
			}
			System.out.println();
		}
	}

}

>> 결과

   1   6  11  16  21
   2   7  12  17  22
   3   8  13  18  23
   4   9  14  19  24
   5  10  15  20  25

 

5. 대각선(우->좌) 접기

  [원리] *표시한 노란색 기준
  - 왼쪽의 행이 오른쪽 열로 바뀌었다. 
  - 왼쪽 행의 0번째가 오른쪽 열의 4번째가 되었다.
  - 왼쪽 열은 0~4순번으로 간다. 오른쪽 행은 4~0순번이다.  

[대각선(우->좌) 코드]

package myutil;

public class MultiArray {
	public static int[][] diagonal2(int[][] arr){
		int row = arr.length, col = arr[0].length;
		int[][] diagonalArr = new int[row][col];
		
		for(int i = 0; i < row; i++) {
			for(int j = 0; j < col; j++) {
				diagonalArr[i][j] = arr[(row-1)-j][(col-1)-i];
			}
		}
		return diagonalArr;
	}
}

[출력 코드]

package mymain;

import myutil.MultiArray;

public class MultiArrayTest {

	public static void main(String[] args) {
		int[][] arr = new int[5][5];
		int n = 1;
		for(int i = 0; i < arr.length; i++) {
			for(int j = 0; j < arr[0].length; j++) {
				arr[i][j] = n++;
			}
		}
		
		int[][] rotatedArr = MultiArray.diagonal2(arr);
		
		n = 1;
		for(int i = 0; i < rotatedArr.length; i++) {
			for(int j = 0; j < rotatedArr[0].length; j++) {
				System.out.printf("%4d",rotatedArr[i][j]);
			}
			System.out.println();
		}
	}

}

>> 결과

  25  20  15  10   5
  24  19  14   9   4
  23  18  13   8   3
  22  17  12   7   2
  21  16  11   6   1

 

6. 더블 크로스

  [원리] *표시한 색 기준
  - 왼쪽의 0행은 오른쪽에서 4행
  - 왼쪽의 0열은 오른쪽에서 4열

[더블 크로스 코드]

package myutil;

public class MultiArray {
	public static int[][] doubleCross(int[][] arr){
		int row = arr.length, col = arr[0].length;
		int[][] xArr = new int[row][col];
		
		for(int i = 0; i < row; i++) {
			for(int j = 0; j < col; j++) {
				xArr[i][j] = arr[(row-1)-i][(col-1)-j];
			}
		}
		return xArr;
	}
}

[출력 코드]

package mymain;

import myutil.MultiArray;

public class MultiArrayTest {

	public static void main(String[] args) {
		int[][] arr = new int[5][5];
		int n = 1;
		for(int i = 0; i < arr.length; i++) {
			for(int j = 0; j < arr[0].length; j++) {
				arr[i][j] = n++;
			}
		}
		
		int[][] rotatedArr = MultiArray.doubleCross(arr);
		
		n = 1;
		for(int i = 0; i < rotatedArr.length; i++) {
			for(int j = 0; j < rotatedArr[0].length; j++) {
				System.out.printf("%4d",rotatedArr[i][j]);
			}
			System.out.println();
		}
	}

}

>> 결과

  25  24  23  22  21
  20  19  18  17  16
  15  14  13  12  11
  10   9   8   7   6
   5   4   3   2   1

class Exercise3_1 { 
	public static void main(String[] args) { 
		int x = 2; 
		int y = 5; 
		char c = 'A'; // 'A'의 문자코드는 65 
		System.out.println(1 + x << 33); 
		System.out.println(y >= 5 || x < 0 && x > 2); 
		System.out.println(y += 10 - x++); 
		System.out.println(x+=2); 
		System.out.println( !('A' <= c && c <='Z') ); 
		System.out.println('C'-c); 
		System.out.println('5'-'0'); 
		System.out.println(c+1); 
		System.out.println(++c); 
		System.out.println(c++); 
		System.out.println(c); 
	} 
}

 

더보기

6

true

13

5

false

2

5

66

B

B

C

 

class Exercise3_2 { 
	public static void main(String[] args) { 
		int numOfApples = 123; // 사과의 개수 
		int sizeOfBucket = 10; // 바구니의 크기 (바구니에 담을 수 있는 사과의 개수)
		int numOfBucket = ( /* (1) */ ) ;

		System.out.println("필요한 바구니의 수 :"+numOfBucket);
	}
}

>> 실행결과

13
더보기

[3-2] X
//나 : numOfApples/sizeOfBucket+(numOfApples%sizeOfBucket==0? 0 : 1)
답 : numOfApples/sizeOfBucket+(numOfApples%sizeOfBucket>0? 1 : 0)

 

class Exercise3_3 { 
	public static void main(String[] args) { 
		int num = 10; 
		System.out.println( /* (1) */ ); 
	} 
}

>> 실행결과

양수
더보기

[3-3]
num < 0? "음수" : "양수";

 

class Exercise3_4 { 
	public static void main(String[] args) { 
		int num = 456; 
		System.out.println( /* (1) */ ); 
	} 
}

>> 실행결과

400
더보기

[3-4]
num/100*100

 

class Exercise3_5 {
	public static void main(String[] args) {
		int num = 333;
		System.out.println( /* (1) */);
	}
}

>> 실행결과

331
더보기

[3-5]
num/10*10+1

 

class Exercise3_6 {
	public static void main(String[] args) {
		int num = 24;
		System.out.println( /* (1) */);
	}
}

>> 실행결과

6
더보기

[3-6] X
//나 : (num/10+1)*10-num
답 : 10 - num%10

 

class Exercise3_7 {
	public static void main(String[] args) { 
		int fahrenheit = 100; 
		float celcius = ( /* (1) */ );
		
		System.out.println("Fahrenheit:"+fahrenheit); 
		System.out.println("Celcius:"+celcius); 
	}
}

>> 실행결과

Fahrenheit:100
Celcius:37.78
더보기

[3-7] X
//나 : ((int)(5f/9*(fahrenheit-32)*100+0.5f))/100f
답 : (int)(5f/9*(fahrenheit-32)*100+0.5)/100f

 

class Exercise3_8 {
	public static void main(String[] args) {
		byte a = 10;
		byte b = 20;
		byte c = a + b;
		char ch = 'A';
		ch = ch + 2;
		float f = 3 / 2;
		long l = 3000 * 3000 * 3000;
		float f2 = 0.1f;
		double d = 0.1;
		boolean result = d == f2;
		System.out.println("c=" + c);
		System.out.println("ch=" + ch);
		System.out.println("f=" + f);
		System.out.println("l=" + l);
		System.out.println("result=" + result);
	}
}

>> 결과

c=30
ch=C
f=1.5
l=27000000000
result=true
더보기

[3-8]
byte c = (byte)(a + b);
ch = (char)(ch + 2);
// 나 : float f = 3f/2;

float f = 3/2f
// 나 : long l = 3000L*3000*3000;

long l = 3000*3000*3000L
boolean result = (float)d == f2;

 

class Exercise3_9 {
	public static void main(String[] args) { 
		char ch = 'z'; 
		boolean b = ( /* (1) */ ); 
		System.out.println(b); 
	}
}

>> 결과

true
더보기

[3-9] X
//나 : (ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') || (ch >= '0' && ch <= '9')? true : false;
답 : (ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') || (ch >= '0' && ch <= '9')

 

class Exercise3_10 {
	public static void main(String[] args) { 
		char ch = 'A'; 
		char lowerCase = ( /* (1) */ ) ? ( /* (2) */ ) : ch; 
		System.out.println("ch:"+ch); 
		System.out.println("ch to lowerCase:"+lowerCase); 
	} 
}

>> 결과

ch:A
ch to lowerCase:a
더보기

[3-10] X
(1) (ch >= 'A' && ch<='Z')
//나 : (2) ch-32
답 : (2) (char)ch-32

더보기
  1byte 2byte 4byte 8byte
논리형 boolean      
문자형   char    
정수형 byte short int long
실수형     float double

 

더보기
long regNo = 6011221324355L;

[ 해설]  정수형 타입으로는 보통  int형을 사용하지만 주민등록번호는 13자리의 정수이기 때문에 int형의 범위를 넘어서는 값이다 그래서 형을 사용해야한다 그리고 리터럴  'L' 의 접미사 을 잊어서는 안된다.

* int형은 -20억 ~ 20억까지 가능 (-10자리~10자리)'

*long형은 -19자리 ~ 19자리

 

더보기

- 리터럴 : 100, 100L, 3.14f

- 변수 : i, l

- 키워드 : int, long, final, float

- 상수 : PI

더보기

b. Byte (Byte클래스이다.)

 

더보기

12

true

131

51

99

Java

오류

 

더보기

b, c, d, e

 

더보기

a, d, e, g

 

더보기

a, d

 

 

더보기

d, e

*byte의 범위 : -128~127, short의 범위 : -3만~3만, int의 범위 : -20억 ~ 20억(-10자리~10자리), long의 범위 : 20자리

*char의 범위 : 0~66535 (5자리)

*실수형 <- 정수형 : 실수형의 저장범위가 정수형 보다 커서 자동형변환 가능 (그러나 정밀도가 다르므로 유의)

 

더보기

0~66535

 

더보기

a, b, c, d

 

더보기

a, b, c, e

 

더보기

c, e, f

[5-1] 다음은 배열을 선언하거나 초기화한 것이다 잘못된 것을 고르고 그 이유를 설명하시오. 

a. int[] arr[];
b. int[] arr = {1,2,3,};
c. int[] arr = new int[5];
d. int[] arr = new int[5]{1,2,3,4,5};
e. int arr[5];
f. int[] arr[] = new int[3][];  
더보기
답) d,e

이유)

d : new int[ ]의 [ ] 안에 배열의 갯수를 지정할 수 없다.

e : [ ]안에 갯수를 넣을 수 없다.



*f. int[] arr[] = new int[3][];  //이건 가능한데, int[] arr[] = new int[][3]; 는 불가능

 

[5-2] 다음과 같은 배열이 있을 때 arr[3].length의 값은 얼마인가 , 

int[][] arr = {
    { 5, 5, 5, 5, 5},
    { 10, 10, 10},
    { 20, 20, 20, 20},
    { 30, 30}
}
더보기

답)

2

 

[5-3] 배열에 담긴 모든 값을 더하는 프로그램을 완성하시오. (실행결과 : 150)

class Exercise5_3
{
    public static void main(String[] args)
    {
        int[] arr = {10, 20, 30, 40, 50};
        int sum = 0;
        /*
            (1) . 알맞은 코드를 넣어 완성하시오
        */
        System.out.println("sum="+sum);
    }
}

 

더보기

답)

for(int i = 0; i < arr.length; i++) 
{
    sum += arr[i];
}

 

 

[5-4] 2차원 배열에 담긴 모든 값의 총합과 평균을 구하는 프로그램을 완성하시오

(실행 결과 : 

total=325
average=16.25)

package arrayex;

class Exercise5_4
{
	public static void main(String[] args)
	{
		int[][] arr = {
			{ 5, 5, 5, 5, 5},
			{10,10,10,10,10},
			{20,20,20,20,20},
			{30,30,30,30,30}
		};
		int total = 0;
		float average = 0;
		/*
		(1) . 알맞은 코드를 넣어 완성하시오
		*/
		System.out.println("total="+total);
		System.out.println("average="+average);
	} // end of main
} // end of class

 

더보기

답)

int total_length = 0;
		
for(int i = 0; i < arr.length; i++) {
    for(int j = 0; j < arr[i].length; j++) {
        total += arr[i][j];
        total_length++;
    }
}

average = (float)(total/total_length);

 

 

 

[5-5] 다음은 과 사이의 중복되지 않은 숫자로 이루어진 자리 숫자를 만들어내는 프로그램이다 (1)~(2) 에 알맞은 코드를 넣어서 프로그램을 완성하시오 . 

package arrayex;

class Exercise5_4 {
public static void main(String[] args) {
		int[] ballArr = {1,2,3,4,5,6,7,8,9};
		int[] ball3 = new int[3];
		
		// ballArr . 배열 의 임의의 요소를 골라서 위치를 바꾼다
		for(int i=0; i< ballArr.length;i++) {
			int j = (int)(Math.random() * ballArr.length);
			int tmp = 0;
			/*
			(1) . 알맞은 코드를 넣어 완성하시오
			*/
		}
		// ballArr 3 ball3 . 배열 의 앞에서 개의 수를 배열 로 복사한다
		/* (2) */
		for(int i=0;i<ball3.length;i++) {
			System.out.print(ball3[i]);
		}
	} // end of main
} // end of class
더보기

답)

package arrayex;

class Exercise5_4 {
public static void main(String[] args) {
		int[] ballArr = {1,2,3,4,5,6,7,8,9};
		int[] ball3 = new int[3];
		
		// 배열 ballArr의 임의의 요소를 골라서 위치를 바꾼다
		for(int i=0; i< ballArr.length;i++) {
			int j = (int)(Math.random() * ballArr.length);
			int tmp = 0;
			tmp = ballArr[i];
			ballArr[i] = ballArr[j];
			ballArr[j] = tmp;
		}
		//  배열 ballArr 의 앞에서 3 개의 수를 배열 ball3로 복사한다
		System.arraycopy(ballArr, 0, ball3, 0, 3);
		
		for(int i=0;i<ball3.length;i++) {
			System.out.print(ball3[i]);
		}
	} // end of main
} // end of class

 

[5-6] 다음은 거스름돈을 몇 개의 동전으로 지불할 수 있는지를 계산하는 문제이다. 변수 money의 금액을 동전으로 바꾸었을 때 각각 몇 개의 동전이 필요한지 계산해서 출력하라 (단, 가능한 한 적은 수의 동전으로 거슬러 주어야한다.)

(1)에 알맞은 코드를 넣어서 프로그램을 완성하시오.

package arrayex;

class Exercise5_6 {
public static void main(String args[]) {
		// . 큰 금액의 동전을 우선적으로 거슬러 줘야한다
		int[] coinUnit = {500, 100, 50, 10};
		
		int money = 2680;
		System.out.println("money="+money);
		
		for(int i=0;i<coinUnit.length;i++) {
		/*
		(1) . 알맞은 코드를 넣어 완성하시오
		*/
		}
	} // main
}

>> 실행결과

money=2680
500 : 5 원
100 : 1 원
50 : 1 원
10 : 3
더보기

답)

for(int i=0;i<coinUnit.length;i++) {
    if(money >= coinUnit[i]) {
        System.out.printf("%d원:%d%n",coinUnit[i],money/coinUnit[i]);
        money = money%coinUnit[i];
    }
}

 

[5-7] 문제 5-6에 동전의 개수를 추가한 프로그램이다. 커맨드라인으로부터 거슬러 줄 금액을 입력받아 계산한다. 보유한 동전의 개수로 거스름돈을 지불할 수 없으면, '거스름돈이 부족합니다.'라고 출력하고 종료한다. 지불할 돈이 충분히 있으면, 거스름돈을 지불한 만큼 가진 돈에서 빼고 남은 동전의 개수를 화면에 출력한다. (1)에 알맞은 코드를 넣어서 프로그램을 완성하시오.

class Exercise5_7 {
	public static void main(String args[]) {
		if (args.length != 1) {
			System.out.println("USAGE: java Exercise5_7 3120");
			System.exit(0);
		}

		// 문자열을 숫자로 변환한다. 입력한 값이 숫자가 아닐 경우 예외가 발생한다.
		int money = Integer.parseInt(args[0]);

		System.out.println("money=" + money);

		int[] coinUnit = { 500, 100, 50, 10 }; // 동전의 단위
		int[] coin = { 5, 5, 5, 5 }; // 단위별 동전의 개수

		for (int i = 0; i < coinUnit.length; i++) {
			int coinNum = 0;
			/*
			 * (1)아래의 로직에 맞게 코드를 작성하시오. 
			 * 1. 금액(money)을 동전단위로 나눠서 필요한 동전의 개수(coinNum)를 구한다. 
			 * 2. 배열 coin에서 coinNum만큼의 동전을 뺀다. (만일 충분한 동전이 없다면 배열 coin에 있는 만큼만 뺀다.) 
			 * 3. 금액에서 동전의 개수(coinNum)와 동전단위를 곱한 값을 뺀다.
			 */

			System.out.println(coinUnit[i] + "원: " + coinNum);
		}

		if (money > 0) {
			System.out.println("거스름돈이 부족합니다 ");
			System.exit(0); // 프로그램을 종료한다.
		}
		System.out.println("= 남은 동전의 개수 =");

		for (int i = 0; i < coinUnit.length; i++) {
			System.out.println(coinUnit[i] + "원:" + coin[i]);
		}
	} // main
}

>> 실행결과

C:\jdk1.8\work\ch5>java Exercise5_7
USAGE: java Exercise5_7 3120
C:\jdk1.8\work\ch5>java Exercise5_7 3170
money=3170
500 : 5 원
100 : 5 원
50 : 3 원
10 : 2 원
= = 남은 동전의 개수
500 :0 원
100 :0 원
50 :2 원
10 :3 원
C:\jdk1.8\work\ch5>java Exercise5_7 3510
money=3510
500 : 5 원
100 : 5 원
50 : 5 원
10 : 5 원
거스름돈이 부족합니다.
더보기
class Exercise5_7 {
	public static void main(String args[]) {
		if (args.length != 1) {
			System.out.println("USAGE: java Exercise5_7 3120");
			System.exit(0);
		}

		// 문자열을 숫자로 변환한다. 입력한 값이 숫자가 아닐 경우 예외가 발생한다.
		int money = Integer.parseInt(args[0]);

		System.out.println("money=" + money);

		int[] coinUnit = { 500, 100, 50, 10 }; // 동전의 단위
		int[] coin = { 5, 5, 5, 5 }; // 단위별 동전의 개수

		for (int i = 0; i < coinUnit.length; i++) {
			int coinNum = 0;

			coinNum = money % coinUnit[i];
			coin[i] -= coinNum;
			money -= coinUnit[i]*coinNum;

			System.out.println(coinUnit[i] + "원: " + coinNum);
		}

		if (money > 0) {
			System.out.println("거스름돈이 부족합니다 ");
			System.exit(0); // 프로그램을 종료한다.
		}
		System.out.println("= 남은 동전의 개수 =");

		for (int i = 0; i < coinUnit.length; i++) {
			System.out.println(coinUnit[i] + "원:" + coin[i]);
		}
	} // main
}

 

[5-8] 다음은 배열 answer에 담긴 데이터를 읽고 각 숫자의 개수를 세어서 개수만큼 '*'을 찍어서 그래프를 그리는 프로그램이다. (1)~(2)에 알맞은 코드를 넣어서 완성하시오.

class Exercise5_8 {
	public static void main(String[] args) {
		int[] answer = { 1, 4, 4, 3, 1, 4, 4, 2, 1, 3, 2 };
		int[] counter = new int[4];
		for (int i = 0; i < answer.length; i++) {
			/* (1) 알맞은 코드를 넣어 완성하시오. */
		}
		for (int i = 0; i < counter.length; i++) {
			/* 알맞은 코드를 넣어 완성하시오 (2) . */
			System.out.println();
		}
	}
}

>> 실행결과

3***
2**
2**
4****
더보기
class Exercise5_8 {
	public static void main(String[] args) {
		int[] answer = { 1, 4, 4, 3, 1, 4, 4, 2, 1, 3, 2 };
		int[] counter = new int[4];
		
		for (int i = 0; i < answer.length; i++) {
			counter[answer[i]-1]++;
		}
		for (int i = 0; i < counter.length; i++) {
			System.out.print(counter[i]+":");
			for(int j = 0; j < counter[i]; j++){
				System.out.print("*");
			}
			System.out.println();
		}
	}
}

 

[5-9] 주어진 배열을 시계방향으로 90도 회전시켜서 출력하는 프로그램을 완성하시오.

class Exercise5_9 {
	public static void main(String[] args) {
		char[][] star = { 
				{ '*', '*', ' ', ' ', ' ' },
				{ '*', '*', ' ', ' ', ' ' }, 
				{ '*', '*', '*', '*', '*' },
				{ '*', '*', '*', '*', '*' } 
		};
		char[][] result = new char[star[0].length][star.length];
		for (int i = 0; i < star.length; i++) {
			for (int j = 0; j < star[i].length; j++) {
				System.out.print(star[i][j]);
			}
			System.out.println();
		}
		System.out.println();
		for (int i = 0; i < star.length; i++) {
			for (int j = 0; j < star[i].length; j++) {
				/* 알맞은 코드를 넣어 완성하시오 (1) . */
			}
		}
		for (int i = 0; i < result.length; i++) {
			for (int j = 0; j < result[i].length; j++) {
				System.out.print(result[i][j]);
			}
			System.out.println();
		}
	}
}

>> 실행결과

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

**** 
**** 
** 
** 
**
더보기
package arrayex;

public class Exercise5_9 {

public static void main(String[] args) {
		char[][] star = { 
				{ '*', '*', ' ', ' ', ' ' },
				{ '*', '*', ' ', ' ', ' ' }, 
				{ '*', '*', '*', '*', '*' },
				{ '*', '*', '*', '*', '*' } 
		};
		char[][] result = new char[star[0].length][star.length];
		for (int i = 0; i < star.length; i++) {
			for (int j = 0; j < star[i].length; j++) {
				System.out.print(star[i][j]);
			}
			System.out.println();
		}
		System.out.println();
		for (int i = 0; i < star.length; i++) {
			for (int j = 0; j < star[i].length; j++) {
				result[j][star.length-1-i]=star[i][j];
			}
		}
		for (int i = 0; i < result.length; i++) {
			for (int j = 0; j < result[i].length; j++) {
				System.out.print(result[i][j]);
			}
			System.out.println();
		}
	}

}

 

[5-10] 다음은 알파벳과 숫자를 아래에 주어진 암호표로 암호화하는 프로그램이다. (1)에 알맞은 코드를 넣어서 완성하시오.

class Exercise5_10 {
	public static void main(String[] args) {
		char[] abcCode = { '`', '~', '!', '@', '#', '$', '%', '^', '&', '*',
				'(', ')', '-', '_', '+', '=', '|', '[', ']', '{', '}', ';',
				':', ',', '.', '/' };
						 // 0	 1	  2	   3    4    5    6    7    8    9 
		char[] numCode = { 'q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p' };

		String src = "abc123";
		String result = "";

		// 문자열 src의 문자를 charAt()으로 하나씩 읽어서 변환 후 result에 저장
		for (int i = 0; i < src.length(); i++) {
			char ch = src.charAt(i);
			/* (1) 알맞은 코드를 넣어 완성하시오 . */
		}

		System.out.println("src:" + src);
		System.out.println("result:" + result);
	} // end of main
} // end of class

>> 실행결과

src:abc123 
result:`~!wer
더보기
package arrayex;

public class Exercise5_10 {

	public static void main(String[] args) {
		char[] abcCode = { '`', '~', '!', '@', '#', '$', '%', '^', '&', '*',
				'(', ')', '-', '_', '+', '=', '|', '[', ']', '{', '}', ';',
				':', ',', '.', '/' };
						 // 0	 1	  2	   3    4    5    6    7    8    9 
		char[] numCode = { 'q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p' };

		String src = "abc123";
		String result = "";
		StringBuffer buffer = new StringBuffer(src.length());

		// 문자열 src의 문자를 charAt()으로 하나씩 읽어서 변환 후 result에 저장
		for (int i = 0; i < src.length(); i++) {
			char ch = src.charAt(i);
			if(ch >= '0' && ch <='9') {
				buffer.append(numCode[ch-'0']);
			}else {
				buffer.append(abcCode[ch-'a']);
			}
		}
		result = buffer.toString();

		System.out.println("src:" + src);
		System.out.println("result:" + result);
	}

}

 

[5-11] 주어진 2차원 배열의 데이터보다 가로와 세로로 1이 더 큰 배열을 생성해서 배열의 행과 열의 마지막 요소에 각 열과 행의 총합을 저장하고 출력하는 프로그램이다. (1)에 알맞은 코드를 넣어서 완성하시오.

class Exercise5_11 {
	public static void main(String[] args) {
		int[][] score = { 
				{ 100, 100, 100 }, 
				{ 20, 20, 20 }, 
				{ 30, 30, 30 },
				{ 40, 40, 40 }, 
				{ 50, 50, 50 } 
			};
		int[][] result = new int[score.length + 1][score[0].length + 1];
		
		for (int i = 0; i < score.length; i++) {
			for (int j = 0; j < score[i].length; j++) {
				
				/* 알맞은 코드를 넣어 완성하시오 (1) . */
				
			}
		}
		
		for (int i = 0; i < result.length; i++) {
			for (int j = 0; j < result[i].length; j++) {
				System.out.printf("%4d", result[i][j]);
			}
			System.out.println();
		}
	} // main }
}

>> 실행결과

100 100 100 300 
20 20 20 60 
30 30 30 90 
40 40 40 120 
50 50 50 150 
240 240 240 720
더보기
package arrayex;

public class Exercise5_11 {

	public static void main(String[] args) {
		int[][] score = { 
				{ 100, 100, 100 }, 
				{ 20, 20, 20 }, 
				{ 30, 30, 30 },
				{ 40, 40, 40 }, 
				{ 50, 50, 50 } 
			};
		int[][] result = new int[score.length + 1][score[0].length + 1];
		
		for (int i = 0; i < score.length; i++) {
			for (int j = 0; j < score[i].length; j++) {
					result[i][j] = score[i][j];
					result[i][score[i].length]+=result[i][j];
					result[score.length][j] += result[i][j];
					result[score.length][result[0].length-1] += result[i][j];
			}
		}
		
		for (int i = 0; i < result.length; i++) {
			for (int j = 0; j < result[i].length; j++) {
				System.out.printf("%4d", result[i][j]);
			}
			System.out.println();
		}
	}

}

 

[5-13] 단어의 글자위치를 섞어서 보여주고 원래의 단어를 맞추는 예제이다. 실행결과와 같이 동작하도록 예제의 빈 곳을 채우시오.

import java.util.Scanner;

class Exercise5_13 {
	public static void main(String args[]) {
		String[] words = { "television", "computer", "mouse", "phone" };

		Scanner scanner = new Scanner(System.in);

		for (int i = 0; i < words.length; i++) {
			char[] question = words[i].toCharArray(); // String을 char[]로 변환

			/*
			 * (1) 알맞은 코드를 넣어 완성하시오 . char배열 question에 담긴 문자의 위치를 임의로 바꾼다.
			 */

			System.out.printf("Q%d. %s의 정답을 입력하세요 .>", i + 1, new String(
					question));
			String answer = scanner.nextLine();

			// trim()으로 answer의 좌우 공백을 제거한 후 , equals로 word[i]와 비교
			if (words[i].equals(answer.trim()))
				System.out.printf("맞았습니다.%n%n");
			else
				System.out.printf("틀렸습니다.%n%n");
		}
	} // main의 끝
}

>> 실행결과

Q1. lvtsieeoin의 정답을 입력하세요.>television 
맞았습니다.

Q2. otepcumr의 정답을 입력하세요.>computer 
맞았습니다.

Q3. usemo 의 정답을 입력하세요.>asdf 
틀렸습니다.
Q4. ohpne 의 정답을 입력하세요.>phone 
맞았습니다.
더보기
package arrayex;

import java.util.Scanner;

class Exercise5_13 {
	public static void main(String args[]) {
		String[] words = { "television", "computer", "mouse", "phone" };

		Scanner scanner = new Scanner(System.in);

		for (int i = 0; i < words.length; i++) {
			char[] question = words[i].toCharArray(); // String을 char[]로 변환

			for(int j = 0; j < question.length; j++) {
				char tmp = ' ';
				int ran = (int)(Math.random()*question.length);
				tmp = question[j];
				question[j] = question[ran];
				question[ran] = tmp;
			}

			System.out.printf("Q%d. %s의 정답을 입력하세요 .>", i + 1, new String(
					question));
			String answer = scanner.nextLine();

			// trim()으로 answer의 좌우 공백을 제거한 후 , equals로 word[i]와 비교
			if (words[i].equals(answer.trim()))
				System.out.printf("맞았습니다.%n%n");
			else
				System.out.printf("틀렸습니다.%n%n");
		}
	} // main의 끝
}

 

 

[참조]

- [자바의 정석], 남궁석 지음

- 블로그 https://codechobo.tistory.com/1

 

1. 알고리즘이란?

https://why-dev.tistory.com/6?category=917883 

 

[컴퓨터 공학_복습] 알고리즘 정의, 검색과 정렬 알고리즘

▼ 부스트 코스의 컴퓨터 공학 내용을 복습 & 요약한 내용입니다. https://www.boostcourse.org/cs112 부스트코스의 컴퓨터 공학을 수강 중인데, 알고리즘 부분 내용이 잘 이해가 가지 않아서ㅠㅠ 스스로

why-dev.tistory.com

 

2. 정렬

- 정의 : 이름,학번,키 등 핵심항목(key)의 대소관계에 따라 순서대로 값을 나열하는 것

- 안정성 : 키값이 같은 요소의 순서가 정렬 후에도 유지되는 것

   (ex. 같은 점수를 지닌 두 학생에 대해 학번으로 순번을 지정)

- 내부 정렬과 외부 정렬 : 정렬할 모든 데이터를 하나의 배열에 저장할 수 있을 때에 내부 정렬을 사용한다. 

- 정렬의 속도 비교 : 

https://youtu.be/ZZuD6iUe3Pc

 

3. 버블정렬, 선택정렬, 삽입정렬

  - Big O는 셋 다 n^2이지만, 속도는 다르다.
  - (정렬이 안 된 자료들을 정렬할때) 버블정렬 보다는 선택정렬이 교환횟수가 적어서 상대적으로 더 빠르다. 
  - (이미 정렬이 어느 정도 된 경우) 삽입정렬을 쓰는 것이 좋다

 

1) 버블정렬 

원리 ) 안쪽에서 두개의 값을 비교한다 
       --> 한 줄 비교가 다 끝나면 마지막 값이 가장 큰 값(또는 가장 작은 값)
       --> 안 쪽은 n-1-i 만큼 두개씩 비교 & swap하면 된다.
       바깥쪽에서 이 과정을 n-1만큼 반복한다.

[코드]

package _02_정렬;

import java.util.Arrays;

public class _04_BubbleSort {

	public static void main(String[] args) {
		
		int[] arr = new int[10];
		
		random(arr);
		
		System.out.println(Arrays.toString(arr));
		
		//오름차순 버블 정렬을 구현하라
		int tmp;
		for (int i = 0; i < arr.length-1; i++) {
			for (int j = 0; j < arr.length-1-i; j++) {
				if (arr[j] > arr[j+1]) {
					tmp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = tmp;
				}
			}
		}
		System.out.println(Arrays.toString(arr));
		
		//내림차순 버블 정렬을 구현하라
		for (int i = 0; i < arr.length-1; i++) {
			for (int j = 0; j < arr.length-1-i; j++) {
				if (arr[j] < arr[j+1]) {
					tmp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = tmp;
				}
			}
		}
		System.out.println(Arrays.toString(arr));

	}
	
	public static int[] random(int[] arr) {
		
		OUTER :
		for (int i = 0; i < arr.length; i++) {
			
			arr[i] = (int)(Math.random()*10)+1;
			
			for (int j = 0; j < i; j++) {
				
				if (arr[j] == arr[i]) {
					i--;
					continue OUTER;
				}
			}
		}
		
		return arr;
		
	}

}

>> 결과

[10, 3, 8, 9, 4, 1, 7, 5, 2, 6]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

 

2) 선택정렬 

원리 ) i index를 min(or max)으로 지정하고, 나머지 값들을 하나씩 비교한 뒤, 교환한다.

[코드]

package _02_정렬;

import java.util.Arrays;

public class _05_SelectionSort {

	public static void main(String[] args) {

		int[] arr = new int[10];
		
		random(arr);
		
		System.out.println(Arrays.toString(arr));
		
		//오름차순 선택정렬을 구현하라
		int min, tmp;
		for (int i = 0; i < arr.length-1; i++) {
			min = i; // 하나의 요소를 min으로 선택(이 값보다 작은 값을 찾는다)
			for (int j = i+1; j < arr.length; j++) {
				if (arr[j] < arr[min]) {
					min = j;
				}
			}
			//i위치값과 min값을 swap
			tmp = arr[i];
			arr[i] = arr[min];
			arr[min] = tmp;
		}
		System.out.println(Arrays.toString(arr));
		
		//내림차순 선택정렬을 구현하라
		int max;
		for (int i = 0; i < arr.length-1; i++) {
			max = i;
			for (int j = i+1; j < arr.length; j++) {
				if (arr[j] > arr[max]) {
					max = j;
				}
			}
			//i위치값과 max값을 swap
			tmp = arr[i];
			arr[i] = arr[max];
			arr[max] = tmp;
		}
		System.out.println(Arrays.toString(arr));

	}
	
	public static int[] random(int[] arr) {
		
		OUTER :
		for (int i = 0; i < arr.length; i++) {
			
			arr[i] = (int)(Math.random()*10)+1;
			
			for (int j = 0; j < i; j++) {
				
				if (arr[j] == arr[i]) {
					i--;
					continue OUTER;
				}
			}
		}
		
		return arr;
		
	}

}

>> 결과

[2, 9, 8, 5, 10, 1, 6, 4, 3, 7]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

 

3) 삽입 정렬 (Insertion Sort)

- 거의 다 정렬된 상태의 데이터를 다시 정렬할 때, 가장 효과적인 알고리즘 (위 정렬 속도 비교 확인)

- 원리 : 아직 정렬되지 않은 부분의 첫번째 요소를 정렬한 부분의 알맞은 위치에 삽입한다.

- 장점 : 정렬이 되었거나 또는 그 상태에 가까우면 정렬 속도가 아주 빠름

- 단점 : 삽입할 곳이 멀리 떨어지면 이동(대입)하는 횟수가 많다

   (ex. 0~10까지 중 0제외 나머지는 정렬된 상태이나, 0값이 인덱스의 끝에 위치)

[코드]

package _02_정렬;

import java.util.Arrays;

public class _02_InsertionSort {

	public static void main(String[] args) {
		int[] arr = new int[10];
		
		random(arr);
		
		System.out.println(Arrays.toString(arr));
		
		//오름차순 삽입정렬을 구현하라
		int tmp;
		for (int i = 1; i < arr.length; i++) {
			tmp = arr[i];
			int j;
			
			for (j = i; j > 0 && arr[j-1] > tmp; j--) {
				arr[j] = arr[j-1];
			}
			arr[j] = tmp;	
		}
		System.out.println(Arrays.toString(arr));
		
		//내림차순 삽입정렬을 구현하라
		for (int i = 1; i < arr.length; i++) {
			tmp = arr[i];
			int j;
			for (j = i; j > 0 && arr[j-1] < tmp; j--) {
				arr[j] = arr[j-1];
			}
			arr[j] = tmp;
		}
		System.out.println(Arrays.toString(arr));
	}
	
	public static int[] random(int[] arr) {
		
		OUTER :
		for (int i = 0; i < arr.length; i++) {
			
			arr[i] = (int)(Math.random()*10)+1;
			
			for (int j = 0; j < i; j++) {
				
				if (arr[j] == arr[i]) {
					i--;
					continue OUTER;
				}
			}
		}
		
		return arr;
		
	}

}

>> 결과

[3, 1, 6, 4, 10, 2, 5, 7, 9, 8]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

 

4. 셸 정렬 (Shell Sort)

 

 

[ 출처 ]

- 자바의 정석, 남궁성

- Do it! 자료구조와 함께 배우는 알고리즘 입문 [자바편], bogyoh shibata지음

- 기타 : 유투브

[자바프로그램이 실행되는 전체적인 흐름]

- C언어는 바로 OS를 통해 하드웨어의 메모리 공간을 할당받는다.

- 자바JVM을 거쳐 OS를 통해 하드웨어의 메모리 공간을 할당 받는다.

 

  *C언어에서는 개발자가 임시로 저장했던 문자열, 배열 공간을 일일히 해제해준다.

   이걸 안 하면, 컴퓨터에 찌꺼기들(쓰레기라고도 한다)이 남아서 디스크 정리를 해줘야한다.

  *자바는 JVM의 가비지 컬렉터가 있어서 임시로 저장했던 배열, 객체 공간을 알아서 해제한다.

   대신, 가비지컬렉터의 인터셉트로 인해 속도는 그만큼 C언어보다 느리다.

 

[변수의 기본타입과 참조타입]

- 변수는 하나의 값을 저장할 수 있는 메모리 공간을 말한다.

- 변수의 타입은 기본타입과 참조타입으로 나뉠 수 있는데,

   기본타입은 기본형 값을 저장하고, 참조타입은 객체나 배열의 주소값(16진수)을 저장한다.

 

[JVM(이 빌려온) 메모리 공간 ]

** 수정되어야할 부분 체크 : 아래 그림에서 상수풀은 현재 힙 영역에 있습니다. 

- 크게 세 가지 영역, 메소드 영역, 스택 영역, 힙 영역이 있다.

- 메소드 영역에서는 프로그램이 시작할 때 정적필드/상수, static초기화블럭/static메소드 코드가 적재되며, 객체가 생성될 때마다 instance초기화블럭/instance생성자/instance메소드가 적재된다.

  *Simple Mind : 자주쓰는 데이터를 미리 축척하거나, 필요할 때 함수식을 꺼내 올려두는 사전 작업소

- 스택 영역에서는 main함수부터 시작해서 함수LIFO(Last in First Out) 형태로 차곡차곡 호출되고(push in) 나간다(pop out)

  *Simple Mind : 함수를 하나씩 실행하는 실질 작업소

- 힙 영역에서는 main함수 또는 그 함수가 호출한 다른 함수들에서 배열 또는 객체를 생성하라 명령할 때, 임시 공간에 명령에 따라 데이터를 저장한다.

  *Simple Mind : 객체와 배열의 데이터를 저장하는 임시 저장 공간

 

[프로그램이 실제로 구동되는 과정_예시) 게임 프로그램을 실행했을 때]

 

[전체 이미지 다운로드]

- 위 내용의 전체구조도 이미지.

- 다운 필요하면 아래의 PDF파일 다운 받아 사용하셔도 됩니다.

정리_메모리_배열.pdf
0.13MB

 

 

[참조]

- 블로그

  자바(Java) - 참조타입과 참조변수1 https://dustink.tistory.com/31

  IT관련 용어 [OS]란 무엇인가?

  https://m.blog.naver.com/PostView.naver?isHttpsRedirect=true&blogId=pst8627&logNo=221663921157 

- 그 외 ) 국비 지원과정 수업 내용 참조

1. 문자열을 정수형을 바꾸는 법 _ 변수타입.parse변수타입();

Boolean.parseBoolean(String s)
Byte.parseByte(String s)
Short.parseShort(String s)
Integer.parseInt(String s)
Long.parseLong(String s)
Float.parseFloat(String s)
Double.parseDouble(String s)

 

package test;

public class TypeTest {

	public static void main(String[] args) {
		String home_addr = "01002";
		int addr = Integer.parseInt(home_addr);
		System.out.printf("HOME ADDRESS : %d",addr);
	}

}

>> 결과

HOME ADDRESS : 1002

※ 앞의 0이 사라지는 걸 볼 수 있다. 0은 정수형 타입으로 변환될 때 삭제되기 때문. 

 

2. 정수형을 문자열로 바꾸는 법 _ String.valueOf(   ); 

package test;

public class TypeTest2 {

	public static void main(String[] args) {
		int addr = 10002; //만약 01002를 적으면 이건 십진수가 아님
		String home_addr = String.valueOf(addr);
		System.out.println("HOME ADDRESS : "+home_addr);
	}

}

>> 결과

HOME ADDRESS : 10002

 

3. 문자타입의 숫자를 정수타입의 숫자로 바꾸는 법_  '9' - '0'

package test;

public class TypeTest4 {

	public static void main(String[] args) {
    	//문자를 숫자로
		char initial = '9';
		int change = initial - '0';
		System.out.println(change);
	}

}

>> 결과

9

 

4. 정수타입의 숫자를 문자타입으로 바꾸는 법_ 9 + '0'

package test;

public class TypeTest3 {

	public static void main(String[] args) {
		//숫자를 문자로
		int initial = 9;
		char change = (char)(initial + '0');
		System.out.println(change);
	}

}

>> 결과

9

 

+ Recent posts