zoukankan      html  css  js  c++  java
  • google校招在线測试题---2048

    先附代码:(简单地说就是给出一个矩阵代表2048游戏的一个状态以及一个方向,输出往这个方向移动之后的矩阵)

    #include<iostream>
    #include<fstream>
    #include<string>
    using namespace std;
    int main()
    {
    	int T;
    	ifstream ifile("B-large-practice.in");
    	ofstream ofile("out1.txt");
    	int num[21][21];
    	ifile >> T;
    	for(int n_case = 1; n_case <= T; n_case++)
    	{
    		for(int i = 0; i < 21; i++)
    			for(int j = 0; j < 21; j++)
    				num[i][j] = 0;
    		int n;
    		string flag;
    		ifile >> n;
    		ifile >> flag;
    		for(int i = 0; i < n; i++)
    			for(int j = 0; j < n; j++)
    				ifile >> num[i][j];
    		if(flag == "up")
    		{
    			for(int j = 0; j < n; j++)
    			{
    				for(int i = 0; i < n; i++)
    				{
    					if(num[i][j] != 0)
    					{
    						int tmp_i = i;
    						while(num[++i][j] == 0)
    						{;}
    						if(i < n && num[tmp_i][j] == num[i][j])
    						{
    							num[tmp_i][j] = num[tmp_i][j] * 2;
    							num[i][j] = 0;
    						}
    						i--;
    					}
    				}
    			}
    			for(int j = 0; j < n; j++)
    			{
    				int index = 0;
    				for(int i = 0; i < n; i++)
    					if(num[i][j] != 0)
    					{
    						int tmp = num[index][j];
    						num[index][j] = num[i][j];
    						num[i][j] = tmp;
    						index++;
    					}
    			}
    			ofile << "Case #" << n_case << ":
    ";
    			for(int i = 0; i < n; i++)
    			{
    				for(int j = 0; j < n; j++)
    				{
    					ofile << num[i][j];
    					if(j != n - 1)
    						ofile << ' ';
    				}
    				ofile << endl;
    			}
    		}
    		else if(flag == "down")
    			{
    			for(int j = 0; j < n; j++)
    			{
    				for(int i = n - 1; i > -1; i--)
    				{
    					if(num[i][j] != 0)
    					{
    						int tmp_i = i;
    						while(num[--i][j] == 0)
    						{}
    						if(i >= 0 && num[tmp_i][j] == num[i][j])
    						{
    							num[tmp_i][j] = num[tmp_i][j] * 2;
    							num[i][j] = 0;
    						}
    						i++;
    					}
    				}
    			}
    			for(int j = 0; j < n; j++)
    			{
    				int index = n - 1;
    				for(int i = n - 1; i >= 0; i--)
    					if(num[i][j] != 0)
    					{
    						int tmp = num[index][j];
    						num[index][j] = num[i][j];
    						num[i][j] = tmp;
    						index--;
    					}
    			}
    			ofile << "Case #" << n_case << ":
    ";
    			for(int i = 0; i < n; i++)
    			{
    				for(int j = 0; j < n; j++)
    				{
    					ofile << num[i][j];
    					if(j != n - 1)
    						ofile << ' ';
    				}
    				ofile << endl;
    			}
    		}
    		else if(flag == "left")
    			{
    			for(int i = 0; i < n; i++)
    			{
    				for(int j = 0; j < n; j++)
    				{
    					if(num[i][j] != 0)
    					{
    						int tmp_j = j;
    						while(num[i][++j] == 0)
    						{}
    						if(j < n && num[i][tmp_j] == num[i][j])
    						{
    							num[i][tmp_j] = num[i][tmp_j] * 2;
    							num[i][j] = 0;
    						}
    						j--;
    					}
    				}
    			}
    			for(int i = 0; i < n; i++)
    			{
    				int index = 0;
    				for(int j = 0; j < n; j++)
    					if(num[i][j] != 0)
    					{
    						int tmp = num[i][index];
    						num[i][index] = num[i][j];
    						num[i][j] = tmp;
    						index++;
    					}
    			}
    			ofile << "Case #" << n_case << ":
    ";
    			for(int i = 0; i < n; i++)
    			{
    				for(int j = 0; j < n; j++)
    				{
    					ofile << num[i][j];
    					if(j != n - 1)
    						ofile << ' ';
    				}
    				ofile << endl;
    			}
    		}
    		else
    		{
    			for(int i = 0; i < n; i++)
    			{
    				for(int j = n - 1; j >= 0; j--)
    				{
    					if(num[i][j] != 0)
    					{
    						int tmp_j = j;
    						while(num[i][--j] == 0)
    						{}
    						if(j  >= 0 && num[i][tmp_j] == num[i][j])
    						{
    							num[i][tmp_j] = num[i][tmp_j] * 2;
    							num[i][j] = 0;
    						}
    						j++;
    					}
    				}
    			}
    			for(int i = 0; i < n; i++)
    			{
    				int index = n - 1;
    				for(int j = n - 1; j >= 0; j--)
    					if(num[i][j] != 0)
    					{
    						int tmp = num[i][index];
    						num[i][index] = num[i][j];
    						num[i][j] = tmp;
    						index--;
    					}
    			}
    			ofile << "Case #" << n_case << ":
    ";
    			for(int i = 0; i < n; i++)
    			{
    				for(int j = 0; j < n; j++)
    				{
    					ofile << num[i][j];
    					if(j != n - 1)
    						ofile << ' ';
    				}
    				ofile << endl;
    			}
    		}
    	}
    }


    Problem

    2048 is a famous single-player game in which the objective is to slide tiles on a grid to combine them and create a tile with the number 2048.

    2048 is played on a simple 4 x 4 grid with tiles that slide smoothly when a player moves them. For each movement, the player can choose to move all tiles in 4 directions, left, right, up, and down, as far as possible at the same time. If two tiles of the same number collide while moving, they will merge into a tile with the total value of the two tiles that collided. In one movement, one newly created tile can not be merged again and always is merged with the tile next to it along the moving direction first. E.g. if the three "2" are in a row "2 2 2" and the player choose to move left, it will become "4 2 0", the most left 2 "2" are merged.

    The above figure shows how 4 x 4 grid varies when player moves all tiles 'right'.

    Alice and Bob accidentally find this game and love the feel when two tiles are merged. After a few round, they start to be bored about the size of the board and decide to extend the size of board to N x N, which they called the game "Super 2048".

    The big board then makes them dazzled (no zuo no die -_-| ). They ask you to write a program to help them figure out what the board will be looked like after all tiles move to one specific direction on a given board.

    Input

    The first line of the input gives the number of test cases, TT test cases follow. The first line of each test case gives the side length of the board, N, and the direction the tiles will move to, DIRN and DIR are separated by a single space. DIR will be one of four strings: "left", "right", "up", or "down".

    The next N lines each contain N space-separated integers describing the original state of the board. Each line represents a row of the board (from top to bottom); each integer represents the value of a tile (or 0 if there is no number at that position).

    Output

    For each test case, output one line containing "Case #x:", where x is the test case number (starting from 1). Then output N more lines, each containing N space-separated integers which describe the board after the move in the same format as the input.

    Limits

    Each number in the grid is either 0 or a power of two between 2 and 1024, inclusive.

    Small dataset

    1 ≤ T ≤ 20 
    1 ≤ N ≤ 4 

    Large dataset

    1 ≤ T ≤ 100 
    1 ≤ N ≤ 20 

    Sample


    Input 
     

    Output 
     
    3
    4 right
    2 0 2 4
    2 0 4 2
    2 2 4 8
    2 2 4 4
    10 up
    2 0 0 0 0 0 0 0 0 0
    2 0 0 0 0 0 0 0 0 0
    2 0 0 0 0 0 0 0 0 0
    2 0 0 0 0 0 0 0 0 0
    2 0 0 0 0 0 0 0 0 0
    2 0 0 0 0 0 0 0 0 0
    2 0 0 0 0 0 0 0 0 0
    2 0 0 0 0 0 0 0 0 0
    2 0 0 0 0 0 0 0 0 0
    2 0 0 0 0 0 0 0 0 0
    3 right
    2 2 2
    4 4 4
    8 8 8
    
    
    Case #1:
    0 0 4 4
    0 2 4 2
    0 4 4 8
    0 0 4 8
    Case #2:
    4 0 0 0 0 0 0 0 0 0
    4 0 0 0 0 0 0 0 0 0
    4 0 0 0 0 0 0 0 0 0
    4 0 0 0 0 0 0 0 0 0
    4 0 0 0 0 0 0 0 0 0
    0 0 0 0 0 0 0 0 0 0
    0 0 0 0 0 0 0 0 0 0
    0 0 0 0 0 0 0 0 0 0
    0 0 0 0 0 0 0 0 0 0
    0 0 0 0 0 0 0 0 0 0
    Case #3:
    0 2 4
    0 4 8
    0 8 16
    

  • 相关阅读:
    【leetcode❤python】 1. Two Sum
    【leetcode❤python】 67. Add Binary
    【leetcode❤python】 396. Rotate Function
    【leetcode❤python】 400. Nth Digit
    【leetcode❤python】 160. Intersection of Two Linked Lists
    【leetcode❤python】 203. Remove Linked List Elements
    【leetcode❤python】 225. Implement Stack using Queues
    Kotlin:【标准库函数】apply(配置函数)、let、run函数
    Kotlin:【字符串操作】substring、split、replace、字符串比较==与===、foreach遍历字符
    Kotlin:【针对空安全管理的操作】安全调用操作符、使用带let的安全调用、非空断言操作符(感叹号操作符)、使用if判断null值情况、使用空合并操作符(类似三元表达式)
  • 原文地址:https://www.cnblogs.com/yjbjingcha/p/7071326.html
Copyright © 2011-2022 走看看