打印金字塔式整齐杨辉三角

杨辉三角是比较基础的算法题，如果加上对齐，要求整齐不错位的金字塔式，需要考虑的细节就相对要多一些。

先说需求，输入行数，打印出整齐的金字塔式杨辉三角。

大体思路

将杨辉三角中的数都放到一个数组中，如果简单化，也可以放到2维数组中，行列的概念比较明显。

计算杨辉三角，cur[i]=last[i-1]+last[i],i取值从1到line-1，即去除首尾的闭区间。由于用到了前一行，所以需要加中间变量数组。

每个数占的宽度，比如有的1位数，有的2位数，需要取出最大元素，算出位数digitNum，作为宽度。

每行的对齐，第n行(从1开始)有n个元素，加上中间的空格，每行第一个元素要右移的距离为，(maxLine-curLine)*digitNum.

代码

#ifndef YANGHUITRIANGLE_H
#define YANGHUITRIANGLE_H

#include<vector>
#include<string>

class YangHuiTriangle
{
public:
    YangHuiTriangle(int nLines);

    std::vector<uint32_t> getTriangle() const;
    std::vector<std::vector<uint32_t> > getTriangle2D() const;

    void printTriangle() const;

private:

    uint32_t m_nLines__;					///<total lines

    uint32_t m_nMaxEle__;					///<max element in the triangle

    uint32_t m_nMaxEleWidth__;			        	///<digits in max element

    std::vector<uint32_t>  m_vecTriangle__;			///<triangle array

};

#endif // YANGHUITRIANGLE_H

#include "YangHuiTriangle.h"

#include<iostream>

using namespace std;

YangHuiTriangle::YangHuiTriangle(int nLines):m_nLines__(nLines),m_nMaxEle__(0),m_nMaxEleWidth__(1)
{
    vector<uint32_t> vecLast;
    for(uint32_t i=0;i<m_nLines__;++i){
        vector<uint32_t> vecCur;
        if(i<2){
            vecCur.assign(i+1,1);
            m_nMaxEle__=1;
        }else{
            vecCur.push_back(1);
            for(uint32_t j=1;j<vecLast.size();++j){
                uint32_t u32Ele=vecLast.at(j)+vecLast.at(j-1);
                vecCur.push_back(u32Ele);
                m_nMaxEle__=max(m_nMaxEle__,u32Ele);
            }
            vecCur.push_back(1);
        }
        m_vecTriangle__.insert(m_vecTriangle__.end(),vecCur.begin(),vecCur.end());
        vecLast=vecCur;
    }

    m_nMaxEleWidth__=1;

    for(uint32_t base=10;m_nMaxEle__/base;base*=10){
        ++m_nMaxEleWidth__;
    }

}

std::vector<uint32_t> YangHuiTriangle::getTriangle() const
{
    return m_vecTriangle__;
}



std::vector<std::vector<uint32_t> > YangHuiTriangle::getTriangle2D() const
{
    vector<vector<uint32_t> > vecRet;
    uint32_t nLines=0;
    for(uint32_t i=0;i<m_vecTriangle__.size();++nLines){
        vector<uint32_t> vecLine;
        for(uint32_t j=0;j<nLines+1;++j){
            vecLine.push_back(m_vecTriangle__.at(i++));
        }
        vecRet.push_back(vecLine);
    }
    return vecRet;
}

void YangHuiTriangle::printTriangle() const
{
    string strSpace(m_nMaxEleWidth__,' ');
    int nLine=0;
    for(uint32_t i=0;i<m_vecTriangle__.size();++nLine){
        //print line align
        string strAlgin((m_nLines__-nLine)*m_nMaxEleWidth__,' ');
        cout<<strAlgin.c_str();
        for(int j=0;j<nLine+1;++j){
            char szTxt[256];
            snprintf(szTxt,sizeof(szTxt),"%*d",m_nMaxEleWidth__,m_vecTriangle__.at(i++));
            cout<<szTxt<<strSpace.c_str();
        }
        cout<<endl;
    }
}

Qt工程链接  https://github.com/junbujianwpl/LeetcodePro

测试效果

Qt下测试通过。太古老的编译器如vc6之类的，snprintf得换成_snprintf。

                                1   
                             1     1   
                          1     2     1   
                       1     3     3     1   
                    1     4     6     4     1   
                 1     5    10    10     5     1   
              1     6    15    20    15     6     1   
           1     7    21    35    35    21     7     1   
        1     8    28    56    70    56    28     8     1   
     1     9    36    84   126   126    84    36     9     1   

                                                               1    
                                                           1       1    
                                                       1       2       1    
                                                   1       3       3       1    
                                               1       4       6       4       1    
                                           1       5      10      10       5       1    
                                       1       6      15      20      15       6       1    
                                   1       7      21      35      35      21       7       1    
                               1       8      28      56      70      56      28       8       1    
                           1       9      36      84     126     126      84      36       9       1    
                       1      10      45     120     210     252     210     120      45      10       1    
                   1      11      55     165     330     462     462     330     165      55      11       1    
               1      12      66     220     495     792     924     792     495     220      66      12       1    
           1      13      78     286     715    1287    1716    1716    1287     715     286      78      13       1    
       1      14      91     364    1001    2002    3003    3432    3003    2002    1001     364      91      14       1