[JAVA] [SWEA] 6109. 추억의 2048게임

048이라는 추억의 게임을 아는가? 2048은 한 때 유명했던 1인용 게임으로, 격자 위에서 숫자가 적힌

타일들을 밀어서 합치고 최종적으로 2048을 만들어 내는 것이 목표인 게임이다.

한번 타일을 밀 때는 상하좌우를 정해서 밀어야 한다.

방향을 정하면 격자 위에 있는 모든 타일이 그 방향으로 밀린다.

만약 어떤 타일이 밀리는 방향에 다른 타일이 있고, 두 타일에 적힌 숫자가 같다면 두 타일은 합쳐져

새로운 하나의 타일이 되고 이 타일에 적힌 숫자는 합쳐진 숫자들의 합이 된다.

이렇게 합쳐져서 만들어진 새로운 타일은 숫자가 같은 다른 타일이 밀려와도 합쳐져서는 안 된다.

만약 같은 숫자가 적힌 타일이 세 개 이상 있을 때는 헷갈리는 경우를 없애기 위해 빨리 벽에 닿게 될 타일을 먼저 민다고

생각한다.

예를 들어 “2 2 4 2 2 2”가 적힌 타일들이 있을 때, 이 타일들을 왼쪽으로 밀면 결과는 “4 4 4 2 0 0”이 된다.

0은 타일이 없는 빈 칸을 나타낸다.

 

위의 그림은 4×4 크기의 격자(일반적인 2048 게임)에서 모든 타일을 오른쪽으로 이동시킨 예이다.

우리는 2048게임을 N×N 크기의 격자에서 하려고 한다.

현재 격자에 어떤 식으로 타일이 있는지 주어지고, 타일들을 이동시킬 방향이 주어질 때,

타일을 모두 이동시키고 나면 격자가 어떻게 변할 지 계산하는 프로그램을 작성하라.

 

이 문제의 경우 단순 시뮬레이션이기 때문에 방식만 정하면 된다.

 

나 같은 경우 이동 방향을 확인 한 후 그에 대해서 더해주고 더하면서 특정 칸을 0 으로 만든 뒤 나머지 칸들을 이동 방향으로 움직여 주엇다.

 

더하는 코드의 경우 방향에 따라 4가지를 나누어서 각각 작성해 주었고 다음과 같다.

 

static void sum() {
		if(command.equals("up")) {
			for(int j=0; j<N; j++) {
				for(int i=0; i<N-1; i++) {
					if(map[i][j] != 0) {
						for(int k=i+1; k<N; k++) {
							if(map[k][j] != 0) {
								if(map[i][j] == map[k][j]) {
									map[i][j] *= 2;
									map[k][j] = 0;
								}
								break;
							}
						}
					}
				}
			}
		}else if(command.equals("down")) {
			for(int j=0; j<N; j++) {
				for(int i=N-1; i>0; i--) {
					if(map[i][j] != 0) {
						for(int k=i-1; k>=0; k--) {
							if(map[k][j] != 0) {
								if(map[i][j] == map[k][j]) {
									map[i][j] *= 2;
									map[k][j] = 0;
								}
								break;
							}
						}
					}
				}
			}
		}else if(command.equals("left")) {
			for(int i=0; i<N; i++) {
				for(int j=0; j<N-1; j++) {
					if(map[i][j] != 0) {
						for(int k=j+1; k<N; k++) {
							if(map[i][k] != 0) {
								if(map[i][j] == map[i][k]) {
									map[i][j] *= 2;
									map[i][k] = 0;
								}
								break;
							}
						}
					}
				}
			}
		}else if(command.equals("right")) {
			for(int i=0; i<N; i++) {
				for(int j=N-1; j>0; j--) {
					if(map[i][j] != 0) {
						for(int k=j-1; k>=0; k--) {
							if(map[i][k] != 0) {
								if(map[i][j] == map[i][k]) {
									map[i][j] *= 2;
									map[i][k] = 0;
								}
								break;
							}
						}
					}
				}
			}
		}
		move();
	}

잘 보면 오른쪽으로 이동의 경우 맨 오른쪽 부터 시작하여 0이 아닌 경우 또 다른 0이 아닌 수와 매칭 시켜 같으면 두배 증가시키고 또 다른 0 이 아닌 수는 0으로 만들어 주었다.

 

그리고 맨 밑에 move()라는 메서드를 호출하게 되고 move 메소드는 다음과 같다.

 

static void move() {
		int index;
		if(command.equals("up")) {
			for(int j=0; j<N; j++) {
				for(int i=1; i<N; i++) {
					if(map[i][j] != 0) {
						index = -1;
						for(int k=i-1; k>=0; k--) {
							if(map[k][j] != 0) {
								break;
							}
							index = k;
						}
						if(index != -1) {
							map[index][j] = map[i][j];
							map[i][j] = 0;
						}
					}			
				}
			}
		}else if(command.equals("down")) {
			for(int j=0; j<N; j++) {
				for(int i=N-2; i>=0; i--) {
					if(map[i][j] != 0) {
						index = -1;
						for(int k=i+1; k<N; k++) {
							if(map[k][j] != 0) {
								break;
							}
							index = k;
						}
						if(index != -1) {
							map[index][j] = map[i][j];
							map[i][j] = 0;
						}
					}
				}
			}
		}else if(command.equals("left")) {
			for(int i=0; i<N; i++) {
				for(int j=1; j<N; j++) {
					if(map[i][j] != 0) {
						index = -1;
						for(int k=j-1; k>=0; k--) {
							if(map[i][k] != 0) {
								break;
							}
							index = k;
						}
						if(index != -1) {
							map[i][index] = map[i][j];
							map[i][j] = 0;
						}
					}					
				}
			}
		}else if(command.equals("right")) {
			for(int i=0; i<N; i++) {
				for(int j=N-1; j>=0; j--) {
					if(map[i][j] != 0) {
						index = -1;
						for(int k=j+1; k<N; k++) {
							if(map[i][k] != 0) {
								break;
							}
							index = k;
						}
						if(index != -1) {
							map[i][index] = map[i][j];
							map[i][j] = 0;
						}
					}					
				}
			}
		}
		
	}

 

이것 또 한 너무 간단한 것이여서 특별할 것이 없는 코드이다. 혹시나 보기 불편한 사람들을 위해

 

최종 코드 또한 남긴다.

 

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class Solution {
	static int N;
	static String command;
	static int[][] map;
	public static void main(String[] args) throws Exception{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
		int T = Integer.parseInt(br.readLine());
		String[] s = null;
		for(int t=1; t<=T; t++) {
			s = br.readLine().split(" ");
			N = Integer.parseInt(s[0]);
			command = s[1];
			map = new int[N][N];
			for(int i=0; i<N; i++) {
				s = br.readLine().split(" ");
				for(int j=0; j<N; j++) {
					map[i][j] = Integer.parseInt(s[j]);
				}
			}
			sum();
			bw.write("#"+t+"\n");
			for(int i=0; i<N; i++) {
				for(int j=0; j<N; j++) {
					bw.write(""+map[i][j]+" ");
				}
				bw.write("\n");
			}
		}
		bw.close();
		br.close();

	}
	
	static void move() {
		int index;
		if(command.equals("up")) {
			for(int j=0; j<N; j++) {
				for(int i=1; i<N; i++) {
					if(map[i][j] != 0) {
						index = -1;
						for(int k=i-1; k>=0; k--) {
							if(map[k][j] != 0) {
								break;
							}
							index = k;
						}
						if(index != -1) {
							map[index][j] = map[i][j];
							map[i][j] = 0;
						}
					}			
				}
			}
		}else if(command.equals("down")) {
			for(int j=0; j<N; j++) {
				for(int i=N-2; i>=0; i--) {
					if(map[i][j] != 0) {
						index = -1;
						for(int k=i+1; k<N; k++) {
							if(map[k][j] != 0) {
								break;
							}
							index = k;
						}
						if(index != -1) {
							map[index][j] = map[i][j];
							map[i][j] = 0;
						}
					}
				}
			}
		}else if(command.equals("left")) {
			for(int i=0; i<N; i++) {
				for(int j=1; j<N; j++) {
					if(map[i][j] != 0) {
						index = -1;
						for(int k=j-1; k>=0; k--) {
							if(map[i][k] != 0) {
								break;
							}
							index = k;
						}
						if(index != -1) {
							map[i][index] = map[i][j];
							map[i][j] = 0;
						}
					}					
				}
			}
		}else if(command.equals("right")) {
			for(int i=0; i<N; i++) {
				for(int j=N-1; j>=0; j--) {
					if(map[i][j] != 0) {
						index = -1;
						for(int k=j+1; k<N; k++) {
							if(map[i][k] != 0) {
								break;
							}
							index = k;
						}
						if(index != -1) {
							map[i][index] = map[i][j];
							map[i][j] = 0;
						}
					}					
				}
			}
		}
		
	}
	
	static void sum() {
		if(command.equals("up")) {
			for(int j=0; j<N; j++) {
				for(int i=0; i<N-1; i++) {
					if(map[i][j] != 0) {
						for(int k=i+1; k<N; k++) {
							if(map[k][j] != 0) {
								if(map[i][j] == map[k][j]) {
									map[i][j] *= 2;
									map[k][j] = 0;
								}
								break;
							}
						}
					}
				}
			}
		}else if(command.equals("down")) {
			for(int j=0; j<N; j++) {
				for(int i=N-1; i>0; i--) {
					if(map[i][j] != 0) {
						for(int k=i-1; k>=0; k--) {
							if(map[k][j] != 0) {
								if(map[i][j] == map[k][j]) {
									map[i][j] *= 2;
									map[k][j] = 0;
								}
								break;
							}
						}
					}
				}
			}
		}else if(command.equals("left")) {
			for(int i=0; i<N; i++) {
				for(int j=0; j<N-1; j++) {
					if(map[i][j] != 0) {
						for(int k=j+1; k<N; k++) {
							if(map[i][k] != 0) {
								if(map[i][j] == map[i][k]) {
									map[i][j] *= 2;
									map[i][k] = 0;
								}
								break;
							}
						}
					}
				}
			}
		}else if(command.equals("right")) {
			for(int i=0; i<N; i++) {
				for(int j=N-1; j>0; j--) {
					if(map[i][j] != 0) {
						for(int k=j-1; k>=0; k--) {
							if(map[i][k] != 0) {
								if(map[i][j] == map[i][k]) {
									map[i][j] *= 2;
									map[i][k] = 0;
								}
								break;
							}
						}
					}
				}
			}
		}
		move();
	}
}