UCB CS61B fa23 proj0（2048） 解析与答案

已于 2023-11-23 22:57:28 修改
阅读量2.2k 收藏 31
点赞数 29
分类专栏： CS61B 文章标签： java intellij-idea 学习方法
于 2023-11-23 22:51:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/THaLatta_t/article/details/134562414
版权

写在前面的废话

作者本人只是一个小白，在自学cs61b 完成 proj0 的时候因为不熟悉Java语法遇到了非常大的挫折（只会C，类用的都不太明白），同时目前网上fa-23的课程相关的HW，lab，proj等的答案比较稀少，所以想写这一篇博客帮助和我一样的小白。

文中的代码没有考虑什么算法，都是暴力遍历（还没学数据结构和算法），希望路过的大佬手下留情

这里附上课程网站
课程网站（fa-23）

前言

课程网站上对这个项目有比较详细的解释，但是大部分是英文，会造成一定障碍，但是还是比较推荐去直接阅读英文，只在必要的时候使用翻译软件，对英语学习有比较不错的帮助。

1. public static boolean emptySpaceExists(Board b)

源代码如下

/** Returns true if at least one space on the Board is empty.
     *  Empty spaces are stored as null.
     * */
//翻译
/** 如果板上仍有空白格，则返回真。
	* 空白格被存储为null。
	* */
    public static boolean emptySpaceExists(Board b) {
        int i , j;
        for(i = 0 ; i < b.size() ; i++ ){
            for(j = 0; j < b.size(); j++ ){
                if(b.tile(i,j) == null ){
                    return true ;
                }
            }
        }
        return false;
    }

解题思路就是双循环遍历表格中的每一个格子，如果有一个格子为 null 则返回 true .
这里的 null 表示的是空地址
根据 Board 文件中的下列代码

/** Return the current Tile at (COL, ROW), when sitting with the board
     *  oriented so that SIDE is at the top (farthest) from you. */
    private Tile vtile(int col, int row, Side side) {
        return _values[side.col(col, row, size())][side.row(col, row, size())];
    }

    /** Return the current Tile at (COL, ROW), where 0 <= ROW < size(),
     *  0 <= COL < size(). Returns null if there is no tile there. */
    public Tile tile(int col, int row) {
        return vtile(col, row, _viewPerspective);
    }

我们知道可以通过调用 public Tile tile(int col, int row); 这一函数，获得 _values[side.col(col, row, size())][side.row(col, row, size())] 的值（中间经过对函数 private Tile vtile(int col, int row, Side side) 的调用）

因为 vtile(int , int , Side ) 函数是 private 类型，所以只能通过调用 tile(int , int ) 函数的方法进行调用。

这里的 _viewPerspective 非常重要，它用于计算表格中每一个方块的“相对位置”具体内容我会在任务4中解释

这里要强调的是，看下面的代码：

/** Create a board where RAWVALUES hold the values of the tiles on the board 
     * (0 is null) with a current score of SCORE and the viewing perspective set to north. */
    public Board(int[][] rawValues) {
        int size = rawValues.length;
        _values = new Tile[size][size];
        _viewPerspective = Side.NORTH;
        for (int col = 0; col < size; col += 1) {
            for (int row = 0; row < size; row += 1) {
                int value = rawValues[size - 1 - row][col];
                Tile tile; //注意这部分
                if (value == 0) {
                    tile = null; //重点关注
                } else {
                    tile = Tile.create(value, col, row);
                }
                _values[col][row] = tile; //到这里
            }
        }
    }

这部分代码创建了一个 Tile 类型的变量，在2.1的课上会讲到，这些变量只存储地址，而不是整个变量内容，因此，看重点关注句，值为零的格子 tile = null; 这里仅仅令地址为空，并没有创建新的 Tile(int value, int col, int row) 的 Tile 类型的变量，并将 tile._value 的值赋为零。

所以原文中的if语句中，判断条件是 b.tile(i,j) == null 而不是 b.tile(i,j).value() == 0 因为 b.tile(i,j) 不一定是一个 Tile 类型的变量，不一定可以调用函数 public int value()

2. public static boolean maxTileExists(Board b)

依旧先上源代码

/**
     * Returns true if any tile is equal to the maximum valid value.
     * Maximum valid value is given by this.MAX_PIECE. Note that
     * given a Tile object t, we get its value with t.value().
     */
//翻译
/**
	* 如果有任何一个格子中的值等于最大有效值（2048），则返回真。
	* 最大有效值通过 this.MAX_PIECE 获得。
	* 对于一个Tile类型的对象t ，使用t.value() 来获得t的值。
	*/ 
    public static boolean maxTileExists(Board b) {
        int i , j;
        for(i = 0 ; i < b.size() ; i++ ){
            for(j = 0; j < b.size(); j++ ){
                int a = 0 ;
                if(b.tile(i,j) != null ){
                    a = b.tile(i,j).value();
                }
                if(a == Model.MAX_PIECE){
                    return true ;
                }
            }
        }

        return false;
    }

这部分逻辑上和 public static boolean emptySpaceExists(Board b) 类似，只不过比较的是某个块中的具体值。这里使用 if 语句判断块是否为 null

				int a = 0 ;
                if(b.tile(i,j) != null ){    //如果 (i,j) 处的块不是 null，则调用 value() 函数获取（i，j）上的值. 
                    a = b.tile(i,j).value(); //注意 b 为 Board 类型，b.tile(int ,int ) 才是 Tile 类型.
                }

3. public static boolean atLeastOneMoveExists(Board b)

代码如下

    /**
     * Returns true if there are any valid moves on the board.
     * There are two ways that there can be valid moves:
     * 1. There is at least one empty space on the board.
     * 2. There are two adjacent tiles with the same value.
     */
     //翻译
     /**
      * 在当前界面上仍可以进行合规的移动的时候返回真
      * 通过下面两点判断是否存在合法的移动
      * 1. 界面上至少有一个空格
      * 2. 有两个相邻的格子的值是相同的
      */
    public static boolean atLeastOneMoveExists(Board b) {
        if(emptySpaceExists(b)){  //调用 任务1 编写的函数判断界面上有无空格
            return true;
        }else{
            int i , j;
            // 双循环检查每一个格子是否和右侧格子的值相等
            //仅遍历前三行
            for(i = 0 ; i < b.size() ; i++ ){
                for(j = 0; j < b.size()-1 ; j++ ){
                    if(b.tile(i,j).value() == b.tile(i,j+1).value()){
                        return true ;
                    }
                }
            }
            
            //双循环检查每一个格子是否和下面的格子的值相等
            //仅遍历左三列
            for(i = 0 ; i < b.size()-1 ; i++ ){
                for(j = 0; j < b.size() ; j++ ){
                    if(b.tile(i,j).value() == b.tile(i+1,j).value()){
                        return true ;
                    }
                }
            }
        }
        return false;
    }

第一次循环遍历示意图

0123
0XXXX
1XXXX
2XXXX
3j+1j+1j+1j+1

第二次循环遍历示意图

0123
0XXXj+1
1XXXj+1
2XXXj+1
3XXXj+1

这里的行号和列号标注并不准确，后面有解释

注意一下这里

		if(b.tile(i,j).value() == b.tile(i+1,j).value()){
             return true ;
        }

因为已经用 emptySpaceExists(b) 函数检测过是否有空白格，所以这里可以直接调用 value() 函数，不用担心 b.tile(i,j) 是否为 null 。

4. public void tilt(Side side)

Main Task: Building the Game Logic

在这个函数里我们要建立游戏的逻辑，先看代码，后面再详细解释。

/** Tilt the board toward SIDE.
     *
     * 1. If two Tile objects are adjacent in the direction of motion and have
     *    the same value, they are merged into one Tile of twice the original
     *    value and that new value is added to the score instance variable
     * 2. A tile that is the result of a merge will not merge again on that
     *    tilt. So each move, every tile will only ever be part of at most one
     *    merge (perhaps zero).
     * 3. When three adjacent tiles in the direction of motion have the same
     *    value, then the leading two tiles in the direction of motion merge,
     *    and the trailing tile does not.
     * */
    //翻译
/**欸嘿，太长了，哥们懒得写了
	 * 这里主要就是介绍合并的规则，相信大家多少都玩过或看人玩过2048，所以就不翻译了
	 * 合理！
	 *  */
    public void tilt(Side side) {
        this.board.setViewingPerspective(side); //调整相对方向为上

        int i , j , record ;
        for(i = 0; i < this.size(); i++ ){
            int bottom = this.size();
            for(j = this.size() - 2; j >= 0 ; j-- ){
                int object = 0;
                if(board.tile(i,j) != null ){
                    object = board.tile(i,j).value();
                }   //获取被操作格的值
                
                if(object != 0){   //如果被操作格为0，则不进行检测或移动操作
                    for(record = j+1; record < bottom; record++ ){  //遍历寻找目标格
                        if(board.tile(i,record) != null) {   //寻找有数字的格或为位于最顶端的空白格
                        
                            if (board.tile(i, record).value() != object) {  //不相等则移动到前一个格子
                                board.move(i, record - 1, board.tile(i, j));
                                break;
                            } else{  //相等则合并，并计算分数
                                board.move(i, record, board.tile(i, j));
                                score += 2 * object;
                                bottom = record;
                                break;
                            }
                            
                        }else if(record == bottom - 1){
                            board.move(i, record , board.tile(i, j));
                            break;
                        }
                    }
                }
            }
        }
        this.board.setViewingPerspective(Side.NORTH); //将方向调整为原来方向
        checkGameOver();
    }

这部分有两个重点一是 二维数组的相对方向和基准点 二是 程序逻辑和游戏规则准确匹配
名字我瞎起的，不要在意 😐

二维数组的相对方向和基准点

We strongly recommend starting by thinking only about the up direction, i.e. when the provided side parameter is equal to Side.NORTH.

课程引导我们对方向做出调整，关于方向的函数和变量再 Side.java 文件中

public enum Side {
    /** The parameters (COL0, ROW0, DCOL, and DROW) for each of the
     *  symbolic directions, D, below are to be interpreted as follows:
     *     The board's standard orientation has the top of the board
     *     as NORTH,
     *  
     *     and rows and columns (see Model) are numbered from its lower-left corner. 
     *     //注意这句话，二维数组的(0,0)是其左下角的格子。
     * 
     *	   Consider the board oriented
     *     so that side D of the board is farthest from you. Then
     *        * (COL0*s, ROW0*s) are the standard coordinates of the
     *          lower-left corner of the reoriented board (where s is the
     *          board size), and
     *        * If (c, r) are the standard coordinates of a certain
     *          square on the reoriented board, then (c+DCOL, r+DROW)
     *          are the standard coordinates of the squares immediately
     *          above it on the reoriented board.
     *  The idea behind going to this trouble is that by using the
     *  col() and row() methods below to translate from reoriented to
     *  standard coordinates, one can arrange to use exactly the same code
     *  to compute the result of tilting the board in any particular
     *  direction. */

    NORTH(0, 0, 0, 1),
    EAST(0, 1, 1, 0),
    SOUTH(1, 1, 0, -1),
    WEST(1, 0, -1, 0);

    /** The side that is in the direction (DCOL, DROW) from any square
     *  of the board.  Here, "direction (DCOL, DROW) means that to
     *  move one space in the direction of this Side increases the row
     *  by DROW and the colunn by DCOL.  (COL0, ROW0) are the row and
     *  column of the lower-left square when sitting at the board facing
     *  towards this Side. */
    Side(int col0, int row0, int dcol, int drow) {
        this._row0 = row0;
        this._col0 = col0;
        this._drow = drow;
        this._dcol = dcol;
    }

    /** Return the standard column number for square (C, R) on a board
     *  of size SIZE oriented with this Side on top. */
    // 计算相对列数
    public int col(int c, int r, int size) {
        return _col0 * (size - 1) + c * _drow + r * _dcol;
    }

    /** Return the standard row number for square (C, R) on a board
     *  of size SIZE oriented with this Side on top. */
    // 计算相对行数
    public int row(int c, int r, int size) {
        return _row0 * (size - 1) - c * _dcol + r * _drow;
    }

    /** Parameters describing this Side, as documented in the comment at the
     *  start of this class. */
    private final int _row0, _col0, _drow, _dcol;
}

以 WEST为例
下面的表格是标准标注（ NORTH 为标准方向）

3XXXX
2XXXX
1XXXX
0XXXX
NORTH0123

为了让按下 左方向键 的操作等价于按下 上方向键 的操作，我们让格子“旋转”。

NORTH0123
0XXXX
1XXXX
2XXXX
3XXXX

注意到此时每一列的标号没有改变，但是每一个格子的行号发生了改变

下面表上每个格子位置的改变
BEFORE：

i:3(3,0)(3,1)(3,2)(3,3)
i:2(2,0)(2,1)(2,2)(2,3)
i:1(1,0)(1,1)(1,2)(1,3)
i:0(0,0)(0,1)(0,2)(0,3)
NORTH (row,col)j:0j:1j:2j:3

AFTER

WEST (row,col)i:0i:1i:2i:3
j:0(3,0)(3,1)(3,2)(3.3)
j:1(2,0)(2,1)(2,2)(2,3)
j:2(1,0)(1,1)(1,2)(1,3)
j:3(0,0)(0,1)(0,2)(0,3)

不难看出 NORTH(i,j) == WEST(3-j,i)

根据下面的函数

    /** Return the standard column number for square (C, R) on a board
     *  of size SIZE oriented with this Side on top. */
    // 计算相对列数
    /** 当NORTH时，return c；
      * 当WEST时，return 3-r；
      */
    public int col(int c, int r, int size) {
        return _col0 * (size - 1) + c * _drow + r * _dcol;
    }

    /** Return the standard row number for square (C, R) on a board
     *  of size SIZE oriented with this Side on top. */
    // 计算相对行数
    /** 当NORTH时，return r；
      * 当WEST时，return c；
      */
    public int row(int c, int r, int size) {
        return _row0 * (size - 1) - c * _dcol + r * _drow;
    }

与我们的推理相符合

注意：这个程序中，标准坐标始终是以 Side NORTH 为标准坐标，使用语句 this.board.setViewingPerspective(side); 仅仅是告诉程序，将我们输入的 int i, j; 以何种规则转化为标准坐标。
即我们输入的是相对坐标，程序将相对坐标转化为绝对坐标（标准坐标），我们对相对坐标进行向上的操作，被程序转化为对应的绝对坐标的向左，右，上，下的操作。

程序逻辑和游戏规则准确匹配

直接上一个手写图示图解1

字迹一般，忍一下，sorry

但是除了这些仍有些情况我们忽略了
举个例子

4022（右移）
正确结果
0044
我们的结果
0008

我们的结果违反了规则中的这一条

  1. A tile that is the result of a merge will not merge again on that tilt. For example, if we have [X, 2, 2, 4], where X represents an empty space, and we move the tiles to the left, we should end up with [4, 4, X, X], not [8, X, X, X]. This is because the leftmost 4 was already part of a merge so should not merge again.原文位置

即是说，做过合并的格子不可以再一次进行合并，所以在程序里我们声明变量 bottom 表示可以移动到的最后一个待检测格子。

还是示意图
图解2
所以我们就顺利完成了这个逻辑的设计！

看不懂图的试试直接看代码，图和代码都看不懂的可以试着再评论区留言，应该有路过的大佬出手。。。
作者本人也会看评论区的，希望帮到大家。

结语（废话）

个人认为 proj0 的难点主要在对 java 语言的不熟悉，这篇博客技术含量基本没有，但是希望能帮到一些刚开始自学的小白解决一些问题，关于 CS61B fa-23 的后续 lab 和 proj 应该会继续更新，毕竟现在网上关于 fa-23 的解析比较少，HW 不一定都会写，但是写的应该会选个人认为有价值的写一写分享，希望能让自学的朋友少一点崩溃 😃
课程整个学完了应该会把所以源码发到github或gitee上，但是不知道要等到什么时候哩（bushi

THaLatta_t
关注
专栏目录
【CS61Bsp21】 proj0 2048 记录解析
xxshowerxx的博客
06-30 711
2048相比大家都玩过，就不过多介绍了。不过移动合并的逻辑容易被忽略，推荐将proj0上的几个Google Form Quiz都完成，避免理解的出入。proj0主要目标是简单熟悉java语法和程序结构等。并不要求全部理解所有代码，只需找到需要使用的部分进行简单运用、对四个方法进行修补即可。个人认为依照详细的指引循序渐进，还是比较容易想到思路并实现的，难度主要在于分析已有代码并筛选出重要的方法再熟练应用。当然仔细研究每一部分的原理和实现，收益肯定更高。
CS61B:CS61B作业
04-29
CS61B CS61B作业
CS61B 2021sp学习笔记1——project0
maxskyer的博客
09-14 1493
CS61B-2021sp project0的学习体会。
UCB CS61B fa23 lab2（Debugging） 解析与答案
THaLatta_t的博客
12-04 1325
封面于内容无关
【记录与感想】CS61b-21sp project0（2048游戏）
最新发布
Achilles0705的博客
06-13 1031
这篇文章记录了作者完成CS61B课程第一个项目——2048游戏的经历和感想。改游戏在4×4网格上移动和合并方块以获得高分。项目要求编写游戏核心逻辑，包括实现三个测试函数和一个核心函数。作者首先实现了判断棋盘是否有空格、最大值图块以及有效移动的方法，提供了详细的代码示例。在核心逻辑部分，作者描述了棋盘移动与合并的实现难点，包括坐标设定、不同语言环境下箭头键识别问题及核心逻辑实现。总结部分，作者分享了学习CS61B的收获，包括编程技能、自学能力和解决问题的能力，并反思了国内外计算机教育的差距。
【CS61B】Project 0 游戏2048
weixin_43821215的博客
08-08 1521
proj0是让我们写一个2048的游戏，大家应该都玩过，就不详细介绍了。主要是完成这个游戏中的四个函数的实现，游戏的整体框架已经有了。
UCB CS61b Data Structures textbook
02-12
《UCB CS61b Data Structures》是一门由加州大学伯克利分校（UC Berkeley）开设的计算机科学课程，主要关注数据结构这一核心主题。这门课的教材包括两本书：《A Java Reference》和《Data Structures Into Java》。...
cs61b-textbook-zh：[翻译] UCB CS61b Java中的数据结构
02-05
《UCB CS61b Java中的数据结构》是加州大学伯克利分校（UC Berkeley）CS61b课程的教材，这门课程专注于教授Java语言中的数据结构与算法。这个翻译版为中文读者提供了深入理解Java编程语言中数据结构概念的机会。让...
ucb-cs61b：关于ucb-61b（2014年Spring）的所有项目，http：//www.cs.berkeley.edu~jrs61bindex.html
02-04
《UCB-CS61B：2014春季数据结构深度探索》 UCB-CS61B是加州大学伯克利分校2014年春季开设的一门数据结构课程，其核心目标是深入理解并掌握数据结构的设计、实现以及应用。这门课程不仅涵盖了基础的数据结构，如数组...
cs61b:对于UCB CS61B实验室和作业（sp18）
03-22
cs61b:对于UCB CS61B实验室和作业（sp18）
CS61B：加州大学伯克利分校CS61B的实验室和作业
02-23
CS61B：加州大学伯克利分校CS61B的实验室和作业
Data Structures Lecture Notes (UCB CS61b)
10-20
本文件为加州大学伯克利分校CS61B课程的讲义，课程全称为“数据结构”。CS61B是计算机科学专业的一门核心课程，主要讲授高级数据结构和算法设计原理。课程内容涵盖数组、链表、栈、队列、二叉树、堆、哈希表、图等...
关于CS61b sp21中proj0的问题
God_onload的博客
08-07 3016
CS61b sp21的proj0无法正常运行
cs61b-sp21笔记
weixin_44692221的博客
04-13 2082
介绍课程+基本的java语法，如果java零基础，可先阅读（optional）如何编写测试程序，以及要如何使用JUnit来简化测试流程。介绍选择排序，将其拆分成三个helper function，并编写和测试了它们。介绍接口、接口的继承（what）、实现继承（how）关于中的X静态类型（编译时期）：在声明时指定的类型。确定我们需要调用方法的名字。动态类型（运行时期）：在实例化时指定的类型，等于指向对象的类型。调用动态类型中有该名字的方法，可能使用Dog**重写（override）**过的方法。
CS61B - Big O vs. Big Theta vs. Big Omega
dhjdjdjdj的博客
05-17 272
Big O vs. Big Theta vs. Big Omega Big O less strength, the worst case Big Theta the range of the runtime scale Big Omega greater than or equal,
伯克利cs61b总结贴
qq_45698833的博客
04-30 6366
伯克利cs61b总结贴 ​ 花了一个多月，总算把cs61b 18sp的刷的差不多了，课后的lab、hw和project也差不多做完了，project3后面还剩几个hw，后面会一一补上。 ​ 总的来说，cs61b真的是名不虚传，果然是享誉全球的神课。开始上这门课的时候，我就只有一个感觉：后悔。后悔自己为什么没有早点接触到这门课，大二再开始上确实太晚了。很多美帝知名cs课程只是课后的lab非常好，而老师讲的其实很一般（比如我现在正在学的cs144…简直无力吐槽），而cs61b不仅lab设计的很好，能够让你真
CS61B project0 记录
abc12657的博客
10-21 549
CS61B project0记录遇到的问题功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 遇到的问题 copy a constructor: 讲义里没有，我很是头秃。瞎Google了一下居然给我找到了（当然了因为是很基础的……只
CS61B Homework4作业回顾（附代码）
everest115的博客
03-03 653
这次作业没有测试代码，一亩地上有测试数据链接:http://pan.baidu.com/s/1dD5ql4PDList中的insertFront, insetBack等方法多为视频前几节讲的Doubly-Linkedlist.在测试TestLockDList的时候总是出现ClassCastException, 然而我LockDList中的代码都没写错，也override newNode。后来发现在...
CS61B Homework5作业回顾（附代码）
everest115的博客
03-07 1814
HW5一开始做不出来的同学可以继续先看Lecture，Encapsulated List那一节老师会回顾一下HW5，对作业有启发思路的作用。Part1.HW5的DListNode增加一个myList的field，用于确认node位于哪个list，同时也为后面的isValidNode()服务。remove()之后需要将myList, prev, next 统统指向null，不然这个node的prev...
UCB cs61b第七次Java家庭作业解析
资源摘要信息:"cs61b-UCB-Homework7" 知识点: 1. CS61B课程介绍： CS61B是加州大学伯克利分校（UC Berkeley）开设的一门高级数据结构课程。该课程通常面向计算机科学专业或相关专业的高年级本科生和研究生。课程...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值