2. 程式人生 > >2048遊戲回顧二：演算法總結（移動、合併、動畫等）

2048遊戲回顧二：演算法總結（移動、合併、動畫等）

阿新 • • 發佈：2019-02-20

如果只是單純的寫一個2048遊戲，讓這個遊戲可以玩的話，工作量還是蠻小的。不過，在這寫工作中，你可能花時間最多的就是數字的移動與合併的演算法了，如果沒有做過，可能確實要花點時間來構思，所以，寫完2048遊戲以後，我希望能把它做個記錄。

移動與合併的演算法

比如說我們有如下一個介面：
這裡寫圖片描述
現在，玩家向左劃，這個導致所有的數字向左移動，並且移動的過程中如果發生碰撞，會檢查數字是不是可以合併。
我們的演算法應該是通用的，不僅對於4*4模式，即便是針對3*3模式，n*n模式，它都應該是一樣的。
那麼怎麼做呢？其實就兩步：
第一步：把第一個空格和空格後面的第一個數字（如果有）交換。
第二步：交換後檢查需不需要合併。
以此類推。
為了便於陳述，我們給圖片做一個座標：
這裡寫圖片描述


在這張圖片中，按照我們說的，第一個空白和第一個數字交換，也就是把（2，C）和（3，C）交換，交換後檢查能不能合併，如果能則合併，不過不能則不合並，這裡顯然可以合併，所以我們把他們合併為4.然後空白後面就沒有數字了，演算法結束。
因此，我們的演算法必須記錄第一個空白的位置和第一個數字的位置，那麼我們用k記錄空白，用j記錄第一個數字，然後對於每一行，從左向右做這樣的事情。
直接上程式碼吧，結合程式碼一說就會明白：
首先，我們的一個數字使用一個Number類來表述：

public class Number {
    public int mScores;
    public int
 
 mCurPosition;
    public int mBeforePosition;
    public boolean isNeedMove;
    public boolean isNeedCombine;
    public Number(int position,int scores){
        mScores = scores;
        mCurPosition = mBeforePosition = position;
        isNeedMove = false;
        isNeedCombine = false;
    }
    public
 
 void reset(){
        mScores = 0;
        isNeedMove = false;
        isNeedCombine = false;
    }
}

可見一個Number中有scores，也就是分數，當前的位置和之前的位置是用來計算動畫的，我們需要把一個Number從之前的位置移動到當前的位置。
然後整個遊戲使用一個Numbers類來表述：

public class Numbers {
    Number [][] mNumbers = new Number[Game2048StaticControl.gamePlayMode][Game2048StaticControl.gamePlayMode];
    public Numbers(){
        for(int i=0;i<Game2048StaticControl.gamePlayMode;i++){
            for(int j=0;j<Game2048StaticControl.gamePlayMode;j++){
                mNumbers[i][j] = new Number(0,0);
            }
        }
    }
    public Number getNumber(int x,int y){
        return mNumbers[x][y];
    }
    public Number [][] getNumbers (){
        return mNumbers;
    }
    public int getBlankCount(){
        int count = 0;
        for(int i=0;i<Game2048StaticControl.gamePlayMode;i++){
            for(int j=0;j<Game2048StaticControl.gamePlayMode;j++){
                if(mNumbers[i][j].mScores==0){
                    count++;
                }
            }
        }
        return count;
    }
    public int getPositonFromBlankCountTh(int blankTh){
        int count = 0;
        for(int i=0;i<Game2048StaticControl.gamePlayMode;i++){
            for(int j=0;j<Game2048StaticControl.gamePlayMode;j++){
                if(mNumbers[i][j].mScores==0){
                    if(count==blankTh){
                        return i*Game2048StaticControl.gamePlayMode+j;
                    }else {
                        count++;
                    }
                }
            }
        }
        return -1;
    }
    public void swapNumber(int position1,int position2){
        mNumbers[position1/Game2048StaticControl.gamePlayMode][position1%Game2048StaticControl.gamePlayMode].mCurPosition = position2;
        mNumbers[position1/Game2048StaticControl.gamePlayMode][position1%Game2048StaticControl.gamePlayMode].mBeforePosition = position1;
        mNumbers[position2/Game2048StaticControl.gamePlayMode][position2%Game2048StaticControl.gamePlayMode].mCurPosition = position1;
        mNumbers[position2/Game2048StaticControl.gamePlayMode][position2%Game2048StaticControl.gamePlayMode].mBeforePosition = position2;
        Number tem = mNumbers[position1/Game2048StaticControl.gamePlayMode][position1%Game2048StaticControl.gamePlayMode];
        mNumbers[position1/Game2048StaticControl.gamePlayMode][position1%Game2048StaticControl.gamePlayMode] = mNumbers[position2/Game2048StaticControl.gamePlayMode][position2%Game2048StaticControl.gamePlayMode];
        mNumbers[position2/Game2048StaticControl.gamePlayMode][position2%Game2048StaticControl.gamePlayMode] = tem;
    }
}

這個類的核心就是一個Number [n][n]的陣列，n可以為任意值，因為我們的演算法是通用的。

有了這個的概念以後，我們來看向左移動的演算法，思想前面已經講過了，直接看程式碼，結合程式碼非常容易理解。

   //return 0:do nothing
    //return 1:move
    //return 2:combine
    public int leftKeyDealAlgorithm(){
        int i, j, k;
        boolean isMoved = false;
        boolean isFinalMove = false;
        boolean isFinalCombie = false;
        for(i=0;i<Game2048StaticControl.gamePlayMode;i++){
            j=k=0;
            isMoved = false;
            while (true) {
                while (j<Game2048StaticControl.gamePlayMode && !isPosionHasNumber(i,j))
                    j++;
                if (j > Game2048StaticControl.gamePlayMode-1)
                    break;
                if (j > k){
                    isMoved = true;
                    isFinalMove = true;
                    Number number = getNumber(i,j);
                    number.isNeedMove = true;
                    number.isNeedCombine = false;
                    swapNumber(i*Game2048StaticControl.gamePlayMode+k,i*Game2048StaticControl.gamePlayMode+j);
                }
                if (k > 0 && getNumber(i,k).mScores==getNumber(i,k-1).mScores && !getNumber(i,k-1).isNeedCombine){
                    isFinalCombie = true;
                    Number numberk = getNumber(i,k);
                    Number numberkl = getNumber(i,k-1);
                    if(isMoved){
                        numberkl.mBeforePosition = numberk.mBeforePosition;
                    }else {
                        numberkl.mBeforePosition =  i*Game2048StaticControl.gamePlayMode+k;
                    }
                    numberkl.mCurPosition = i*Game2048StaticControl.gamePlayMode+k-1;
                    numberkl.isNeedMove = true;
                    numberkl.isNeedCombine = true;
                    numberkl.mScores <<=1;
                    updateCurScoresAndHistoryScores(numberkl.mScores);
                    numberk.reset();
                    numberk.mCurPosition = numberk.mBeforePosition = i*Game2048StaticControl.gamePlayMode+k;
                } else{
                    k++;
                }
                j++;
            }
        }
        return isFinalCombie?2:(isFinalMove?1:0);
    }

第一步：j=k=0;
第二步：找到第一個數字：

                while (j<Game2048StaticControl.gamePlayMode && !isPosionHasNumber(i,j))
                    j++;

第三步：如果j > k，那就意味這k這個位置的數字一定是空的，j這個位置的一定是第一個數字，所以就把他們交換。
第四步：判斷是不是需要合併

if (k > 0 && getNumber(i,k).mScores==getNumber(i,k-1).mScores && !getNumber(i,k-1).isNeedCombine

判斷的條件是k>0,因為是向前合併，所以合併至少是從第二個開始的，其次就是兩個數字要相等，同時，已經合併了得數字不能再合併。
然後再做下一個迴圈，如此往復即可完成。

下面貼出其他三個方向的程式碼。

   public int rightKeyDealAlgorithm(){
        int i, j, k;
        boolean isMoved = false;
        boolean isFinalMove = false;
        boolean isFinalCombie = false;
        for(i=0;i<Game2048StaticControl.gamePlayMode;i++){
            j=k=Game2048StaticControl.gamePlayMode-1;
            isMoved = false;
            while (true) {
                while (j>-1 && !isPosionHasNumber(i,j))
                    j--;
                if (j < 0)
                    break;
                if (j < k){
                    isMoved = true;
                    isFinalMove = true;
                    Number number = getNumber(i,j);
                    number.isNeedMove = true;
                    number.isNeedCombine = false;
                    swapNumber(i*Game2048StaticControl.gamePlayMode+k,i*Game2048StaticControl.gamePlayMode+j);
                }
                if (k < Game2048StaticControl.gamePlayMode-1 && getNumber(i,k).mScores==getNumber(i,k+1).mScores && !getNumber(i,k+1).isNeedCombine){
                    isFinalCombie = true;
                    Number numberk = getNumber(i,k);
                    Number numberkl = getNumber(i,k+1);
                    if(isMoved){
                        numberkl.mBeforePosition = numberk.mBeforePosition;
                    }else {
                        numberkl.mBeforePosition =  i*Game2048StaticControl.gamePlayMode+k;
                    }
                    numberkl.mCurPosition = i*Game2048StaticControl.gamePlayMode+k+1;
                    numberkl.isNeedMove = true;
                    numberkl.isNeedCombine = true;
                    numberkl.mScores <<=1;
                    updateCurScoresAndHistoryScores(numberkl.mScores);
                    numberk.reset();
                    numberk.mCurPosition = numberk.mBeforePosition = i*Game2048StaticControl.gamePlayMode+k;
                } else{
                    k--;
                }
                j--;
            }
        }
        return isFinalCombie?2:(isFinalMove?1:0);
    }
    public int upKeyDealAlgorithm(){
        int i, j, k;
        boolean isMoved = false;
        boolean isFinalMove = false;
        boolean isFinalCombie = false;
        for(i=0;i<Game2048StaticControl.gamePlayMode;i++){
            j=k=0;
            isMoved = false;
            while (true) {
                while (j<Game2048StaticControl.gamePlayMode && !isPosionHasNumber(j,i))
                    j++;
                if (j > Game2048StaticControl.gamePlayMode-1)
                    break;
                if (j > k){
                    isMoved = true;
                    isFinalMove = true;
                    Number number = getNumber(j,i);
                    number.isNeedMove = true;
                    number.isNeedCombine = false;
                    swapNumber(k*Game2048StaticControl.gamePlayMode+i,j*Game2048StaticControl.gamePlayMode+i);
                }
                if (k > 0 && getNumber(k,i).mScores==getNumber(k-1,i).mScores && !getNumber(k-1,i).isNeedCombine){
                    isFinalCombie = true;
                    Number numberk = getNumber(k,i);
                    Number numberkl = getNumber(k-1,i);
                    if(isMoved){
                        numberkl.mBeforePosition = numberk.mBeforePosition;
                    }else {
                        numberkl.mBeforePosition =  k*Game2048StaticControl.gamePlayMode+i;
                    }
                    numberkl.mCurPosition = (k-1)*Game2048StaticControl.gamePlayMode+i;
                    numberkl.isNeedMove = true;
                    numberkl.isNeedCombine = true;
                    numberkl.mScores <<=1;
                    updateCurScoresAndHistoryScores(numberkl.mScores);
                    numberk.reset();
                    numberk.mCurPosition = numberk.mBeforePosition = k*Game2048StaticControl.gamePlayMode+i;
                } else{
                    k++;
                }
                j++;
            }
        }
        return isFinalCombie?2:(isFinalMove?1:0);
    }
    public int downKeyDealAlgorithm(){
        int i, j, k;
        boolean isMoved = false;
        boolean isFinalMove = false;
        boolean isFinalCombie = false;
        for(i=0;i<Game2048StaticControl.gamePlayMode;i++){
            j=k=Game2048StaticControl.gamePlayMode-1;
            isMoved = false;
            while (true) {
                while (j>-1 && !isPosionHasNumber(j,i))
                    j--;
                if (j < 0)
                    break;
                if (j < k){
                    isMoved = true;
                    isFinalMove = true;
                    Number number = getNumber(j,i);
                    number.isNeedMove = true;
                    number.isNeedCombine = false;
                    swapNumber(k*Game2048StaticControl.gamePlayMode+i,j*Game2048StaticControl.gamePlayMode+i);
                }
                if (k < Game2048StaticControl.gamePlayMode-1 && getNumber(k,i).mScores==getNumber(k+1,i).mScores && !getNumber(k+1,i).isNeedCombine){
                    isFinalCombie = true;
                    Number numberk = getNumber(k,i);
                    Number numberkl = getNumber(k+1,i);
                    if(isMoved){
                        numberkl.mBeforePosition = numberk.mBeforePosition;
                    }else {
                        numberkl.mBeforePosition =  k*Game2048StaticControl.gamePlayMode+i;
                    }
                    numberkl.mCurPosition = (k+1)*Game2048StaticControl.gamePlayMode+i;
                    numberkl.isNeedMove = true;
                    numberkl.isNeedCombine = true;
                    numberkl.mScores <<=1;
                    updateCurScoresAndHistoryScores(numberkl.mScores);
                    numberk.reset();
                    numberk.mCurPosition = numberk.mBeforePosition = k*Game2048StaticControl.gamePlayMode+i;
                } else{
                    k--;
                }
                j--;
            }
        }
        return isFinalCombie?2:(isFinalMove?1:0);
    }

動畫

計算結束以後，我們需要使用動畫移動和合並數字，因為都是直線運動，所以動畫並不複雜，想想我們的Number類，計算動畫只需要兩個變數，一個之前的位置，一個是當前的位置。
我們可以理一下思路：當用戶需要向左移動時：

                    case Game2048StaticControl.DIRECT_LEFT:{
                        mNumberQueue.pushItem(mGAM.getmNumbers());
                        int ret =  mGAM.leftKeyDealAlgorithm();
                        if (ret>0){
                            startAnimation(mHolder,mPaint,Game2048StaticControl.DIRECT_LEFT);
                            mGAM.updateNumbers();
                            doDrawGameSurface();
                            sendEmptyMessage(Game2048StaticControl.GENERATE_NUMBER);
                            playSoundEffect(ret);
                        }
                        break;
                    }

我們需要做如下幾步：
第一步：儲存當前的遊戲，用於反悔的時候回退。mNumberQueue.pushItem(mGAM.getmNumbers())
第二步：計算移動與合併
mGAM.leftKeyDealAlgorithm();
第三步：使用動畫移動和合並數字
startAnimation(mHolder,mPaint,Game2048StaticControl.DIRECT_LEFT);
第四步：生成一個新的數字
sendEmptyMessage(Game2048StaticControl.GENERATE_NUMBER);
通過傳送訊息來實現，具體的實現在訊息的處理程式碼中，這很簡單，這裡暫不展開。
下面看一個startAnimation方法。
startAnimation定義如下：

    public void startAnimation(SurfaceHolder holder,Paint paint,int direct){
        int count = 0;
        RectF rectF = new RectF();
        while (count++<Game2048StaticControl.ANIMATION_MOVE_STEP) {
            Canvas canvas = holder.lockCanvas();
            mDrawTools.initSurfaceBg(canvas, paint);
            mDrawTools.drawSurfaceMap(canvas, paint);
            mDrawTools.drawSurfaceMapAndNumbersWhoIsNeedCombine(canvas,paint);
            for (int i = 0; i < Game2048StaticControl.gamePlayMode; i++) {
                for (int j = 0; j < Game2048StaticControl.gamePlayMode; j++) {
                    mGAM.aniInsertValue(i, j, count, Game2048StaticControl.ANIMATION_MOVE_STEP,direct,rectF);
                    if(rectF != null && mGAM.isPosionHasNumber(i,j) && mGAM.getNumber(i,j).isNeedMove){
                        mDrawTools.drawNumberByRectF(i,j,canvas,paint,rectF);
                    }
                }
            }
            holder.unlockCanvasAndPost(canvas);
        }
    }

就是對每一個Number，使用 mGAM.aniInsertValue方法來計算它的座標：

  public void aniInsertValue(int x,int y,int count,int insertCount,int direct,RectF rectF){
        Number number = getNumber(x,y);
        if(number.mCurPosition ==  number.mBeforePosition){
            return;
        }
        float xDiffPixels = Game2048StaticControl.GameNumberViewPosition[number.mCurPosition/Game2048StaticControl.gamePlayMode]
                [number.mCurPosition%Game2048StaticControl.gamePlayMode].left
                -Game2048StaticControl.GameNumberViewPosition[number.mBeforePosition/Game2048StaticControl.gamePlayMode]
                [number.mBeforePosition%Game2048StaticControl.gamePlayMode].left;
        float yDiffPixels = Game2048StaticControl.GameNumberViewPosition[number.mCurPosition/Game2048StaticControl.gamePlayMode]
                [number.mCurPosition%Game2048StaticControl.gamePlayMode].top
                -Game2048StaticControl.GameNumberViewPosition[number.mBeforePosition/Game2048StaticControl.gamePlayMode]
                [number.mBeforePosition%Game2048StaticControl.gamePlayMode].top;
        xDiffPixels = Math.abs(xDiffPixels);
        yDiffPixels = Math.abs(yDiffPixels);
        float xStep = xDiffPixels/insertCount;
        float yStep = yDiffPixels/insertCount;
        float xNewPosition = Game2048StaticControl.GameNumberViewPosition[number.mCurPosition/Game2048StaticControl.gamePlayMode]
                [number.mCurPosition%Game2048StaticControl.gamePlayMode].left;
        float yNewPosition = Game2048StaticControl.GameNumberViewPosition[number.mCurPosition/Game2048StaticControl.gamePlayMode]
                [number.mCurPosition%Game2048StaticControl.gamePlayMode].top;;
        switch (direct){
            case DIRECT_UP:{
                yNewPosition = Game2048StaticControl.GameNumberViewPosition[number.mBeforePosition/Game2048StaticControl.gamePlayMode]
                        [number.mBeforePosition%Game2048StaticControl.gamePlayMode].top
                        - yStep*count;
                break;
            }
            case DIRECT_DOWN:{
                yNewPosition = Game2048StaticControl.GameNumberViewPosition[number.mBeforePosition/Game2048StaticControl.gamePlayMode]
                        [number.mBeforePosition%Game2048StaticControl.gamePlayMode].top
                                + yStep*count;
                break;
            }
            case DIRECT_LEFT:{
                xNewPosition = Game2048StaticControl.GameNumberViewPosition[number.mBeforePosition/Game2048StaticControl.gamePlayMode]
                        [number.mBeforePosition%Game2048StaticControl.gamePlayMode].left
                        - xStep*count;
                break;
            }
            case DIRECT_RIGHT:{
                xNewPosition = Game2048StaticControl.GameNumberViewPosition[number.mBeforePosition/Game2048StaticControl.gamePlayMode]
                        [number.mBeforePosition%Game2048StaticControl.gamePlayMode].left
                        + xStep*count;
                break;
            }
            default:break;
        }
        rectF.set(xNewPosition,yNewPosition,xNewPosition+Game2048StaticControl.gameNumberViewLength
                ,yNewPosition+Game2048StaticControl.gameNumberViewLength);
    }

計算的過程正對上下左右各不相同，原理非常簡單：
這裡寫圖片描述
原理就是在途中的花點的地方繪製一下數字就好了。也就是所謂的線性插值法。

在隨機位置隨機生成2或者4

生成2或者4就太簡單了，隨機位置怎麼計算呢？這裡要注意實在空白方格的隨機位置哦，因此首先要獲取當前有多少個空格：

    public int getBlankCount(){
        return mNumbers.getBlankCount();
    }

進一步：

    public int getBlankCount(){
        int count = 0;
        for(int i=0;i<Game2048StaticControl.gamePlayMode;i++){
            for(int j=0;j<Game2048StaticControl.gamePlayMode;j++){
                if(mNumbers[i][j].mScores==0){
                    count++;
                }
            }
        }
        return count;
    }

比如說當前有7個空白處，那麼就只能生7以內的隨機數n，然後 把它插到第n個空白處。
插入方法如下：

    public int  setOneRandomNumberInRandomPosition(){
        int scores = Game2048Algorithm.getRandom2Or4();
        int blankCount = getBlankCount();
        Log.d(TAG,"blankCount:"+blankCount);
        int blankTh = 0;
        if(blankCount<=0){
            return -1;
        }else{
            blankTh = Game2048Algorithm.getRandomPosition(blankCount);
        }
        int position = mNumbers.getPositonFromBlankCountTh(blankTh);
        if (position<0){
            Log.d(TAG,"getPositonFromBlankCountTh return error");
            return -1;
        }
        Number num = mNumbers.getNumber(position/Game2048StaticControl.gamePlayMode,position%Game2048StaticControl.gamePlayMode);
        num.mScores = scores;
        num.mBeforePosition = num.mCurPosition = position;
        num.isNeedCombine = num.isNeedMove = false;
        return position;
    }

檢測遊戲失敗

檢測遊戲的失敗也有一個通用的方式：

   public boolean checkGameOver(){
        Log.d(TAG,"checkGameOver");
        for (int i = 0; i < Game2048StaticControl.gamePlayMode; i++)
        {
            for (int j = 0; j < Game2048StaticControl.gamePlayMode; j++)
            {
                if (j != Game2048StaticControl.gamePlayMode-1 && getNumber(i,j).mScores == getNumber(i,j+1).mScores)
                    return false;
                if (i != Game2048StaticControl.gamePlayMode-1 && getNumber(i,j).mScores == getNumber(i+1,j).mScores)
                    return false;
            }
        }
        if (mListener!=null){
            mListener.onGameOver();
        }
        return true;
    }

演算法的核心思想就是一定要對每一個數字對比它的前後左右。只要發現有相等的就認為可以繼續。當然，判斷的前提的空白格子的數量為0。

相關推薦

2048遊戲回顧二：演算法總結（移動、合併、動畫等）

如果只是單純的寫一個2048遊戲，讓這個遊戲可以玩的話，工作量還是蠻小的。不過，在這寫工作中，你可能花時間最多的就是數字的移動與合併的演算法了，如果沒有做過，可能確實要花點時間來構思，所以，寫完2048遊戲以後，我希望能把它做個記錄。 移動與合併的演算法

2048遊戲回想二：算法總結（移動、合並、動畫等）

switch com asm isp error 結束 復雜 因此 playsound 假設僅僅是單純的寫一個2048遊戲。讓這個遊戲能夠玩的話，工作量還是蠻小的。只

在webstorm中配置本地伺服器-區域網內其他裝置訪問（移動端手機訪問測試等）

前言：我在網上找了很多教程，都寫得不夠全面，於是我親自經過多次試驗，試驗出來了，現在分享給大家，另外我用的版本是webstorm 2018.1.5，我們一起看下面的配置一流程： 1.首先需要配置你的埠號並允許服務被外部訪問   操作順序： 　　① 點選左上角“ file（檔案）”

機器學習 演算法總結（二） 調參技巧

偏差和方差 在統計學習框架下，Error = Bias + Variance。Error指的模型的預測錯誤率，由兩部分組成，一部分是由於模型太簡單而帶來的估計不準確的部分（Bias），另一部分是由於模型太複雜而帶來的更大的變化空間和不確定性（Variance）。 如果要降低模型的Bi

程式設計菜鳥到大佬之路：演算法基礎（二）

第二天學習精要 列舉 生理週期 例題2：生理週期 題目描述 人有體力、情商、智商的高峰日子，它們分別每隔23天、 28天和33天出現一次。 對於每個人，我們想知道何時三個高峰落在同一天。 給

基於Deep Learning的跟蹤演算法總結（二）

本文主要談談TCNN（樹狀CNN）實現物體跟蹤演算法的大致流程和原理。 論文：《Modeling and Propagating CNNs in a Tree Structure for Visual Tracking》，應該是投了CVPR2017。 論文地

查詢演算法總結（順序、折半、分塊、二叉排序樹）

一、基本概念： 1、  列表：待搜尋的資料集合。 2、  關鍵字：要查詢的那個資料。 3、  查詢，檢索：一種演算法過程。給出一個key值（關鍵字），在含有若干個結點的序列中找出它。 4、  查詢表：

影象拼接演算法總結（二）

2、特徵提取與匹配 OpenCV中關於SURF演算法的部分，常常涉及到的是SURF、SurfFeatureDetector、SurfDescriptorExtractor這三個類； features2d.hpp標頭檔案中，有：typedef SURF SurfFeature

python並發編程之多進程(二)：互斥鎖（同步鎖）&進程其他屬性&進程間通信（queue）&生產者消費者模型

互斥 數據 socket pan copy src too 如果 搶票 一，互斥鎖，同步鎖 進程之間數據不共享,但是共享同一套文件系統,所以訪問同一個文件,或同一個打印終端,是沒有問題的, 競爭帶來的結果就是錯亂，如何控制，就是加鎖處理 part1：多個進程共享同

日誌收集二：使用rsyslog （v5版本）進行日誌匯總

rsyslog日誌匯總rsyslog相關： 一般系統默認安裝的都是舊版本，如果不升級，使用v5版本的配置語法v5配置參照：https://www.rsyslog.com/doc/v5-stable/監聽端口：514（使用UDP協議，減少系統負載）自定義設備號使用約定：local0 ~ local7 loca

JavaEE複習回顧二： JavaScript && jQuery && Ajax

           寫這篇回顧之前，蒐集了一些 JavaScript 和 jQuery 的文章，我把連結放到下面，供大家檢視。 1  JavaScript 標準參考教程（alpha）   h

比較全面的Adaboost演算法總結（一）

目錄： 1. Boosting演算法基本原理 2. Boosting演算法的權重理解 3. AdaBoost的演算法流程 4. AdaBoost演算法的訓練誤差分析 5. AdaBoost演算法的解釋 6. AdaBoost演算法的正則化 7. AdaBoost演算法的過

程式設計菜鳥到大佬之路：演算法基礎（一）

第一天學習精要 列舉 完美立方 列舉：基於逐個嘗試答案的一種問題求解策略。 例題1：完美立方 題目描述 形如

《組合語言（第3版）（王爽 著）》學習筆記二：基礎知識（2）

1.7 CPU 對儲存器的讀寫 以上講到，儲存器被劃分成多個儲存單元，儲存單元從零開始編號。這些編號可以看作儲存單元在儲存器中的地址。就想一條街，每個房子都有門牌號碼。 CPU 要從記憶體中讀資料，

Unity遊戲開發教程：飛機大戰（一）

Unity版本：Unity 2018.2.14f1 新建專案 File -> New project -> 輸入Project name -> Preate project 匯入飛

golang常用加密解密演算法總結（AES、DES、RSA、Sha1MD5）

在專案開發過程中，當操作一些使用者的隱私資訊，諸如密碼、帳戶金鑰等資料時，往往需要加密後可以在網上傳輸。這時，需要一些高效地、簡單易用的加密演算法加密資料，然後把加密後的資料存入資料庫或進行其他操作；當需要讀取資料時，把加密後的資料取出來，再通過演算法解密。 關於加密解密 當前我們專案中常用

常用排序演算法總結（Java實現）

排序演算法比較： 1. 氣泡排序 /** * 氣泡排序 * 比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。 * 對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。 * 針對所有的元素重複以上的步驟，除了最後一個

敏捷外包工程系列之二：人員結構（敏捷外包工程，敏捷開發，產品負責人，客戶價值）

本文是敏捷外包工程系列的第二篇。（之一，之二，之三，之四）敏捷開發整體上適合小團隊、產品研發（所以才有product owner一稱）的環境，而外包軟體開發中常常存在的則相反，因此在建立團隊的時候要充分認識到這一點。下文提到“企業”時指軟體開發公司即乙方，而“客戶”指政府、銀

筆記十二：智慧指標（二）

導語： 在智慧指標（一） 中講解了智慧指標的實現方式一，即僱傭一個使用計數類記錄共享物件。現在講解智慧指標的另一種實現方式，控制代碼形式的智慧指標。在介紹控制代碼形式的智慧指標之前，先介紹代理類。 代理類： 1、現假設存在一個基類和它的派生類，設計如下

資料結構與演算法- 五大常用演算法總結（分治法，回溯法，分治限界法，貪心演算法，動態規劃法）

1.分治法（Recurrence and Divide-Conquer）        對於一個規模為n的問題，若該問題可以容易解決（比如說規模n較小）則直接解決，否則將其分解為k個規模較小的子問題，這些子問題互相獨立且與原問題形式相同，遞迴地解決這些子問