棒棒糖算法

搜索

您当前位置：首页 > 文章中心 > 网页编程 > Javascript

【Javascript】

下载

新闻

文章

不久前群里提出一个类似棒棒糖的算法，开始毫无头绪现在终于解开了。

如图片，n为自然数，生成一个n*n的距形，数字从1直到n*n并从中间向外圈，类似棒棒糖，也像条蛇

首先想到的是用一个二维数组组成这个表格，但是数字的起点与终点都是变化的，数组下标也需要变化。数字运动是迂回形且方向分“上下左右”，虽然有规则但计算复杂。且看代码：

<script type="text/javascript">
    function getJz(n){
        var jz=new Array;
        for(var i=0;i<n;i++){
            var tmp=new Array;
            for(var j=0;j<n;j++){
                tmp[j]=0;
            }
            jz[i]=tmp;
        }
        var x, y,direct,start=n*n;
        if(n%2==0){
            x=n-1;y=0;direct='r';
        }else{
            x=0;y=n-1;direct='l';
        }
        for(var i=start;i>0;i--){
            if(jz[x][y]==0){
                var tmp_x=x;
                var tmp_y=y;
            }else{
                if(direct=='l'){
                    if(y-1>=0&&jz[x][y-1]==0){
                        y--;
                    }else{
                        direct='d';
                    }
                }
                if(direct=='d'){
                    if(x+1<n&&jz[x+1][y]==0){
                        x++;
                    }else{
                        direct='r';
                    }
                }
                if(direct=='r'){
                    if(y+1<n&&jz[x][y+1]==0){
                        y++;
                    }else{
                        direct='u';
                    }
                }
                if(direct=='u'){
                    if(x-1>=0&&jz[x-1][y]==0){
                        x--;
                    }else{
                        direct='l';
                        if(y-1>=0&&jz[x][y-1]==0){
                            y--;
                        }else{
                            direct='d';
                        }
                    }
                }
            }
            tmp_x=x;
            tmp_y=y;
            jz[tmp_x][tmp_y]=i;
        }
        document.write('<table border=1>');
        for(var i=0;i<n;i++){
            document.write('<tr id=tr'+i+'>');
            for(var j=0;j<n;j++){
                document.write('<td id=td'+jz[i][j]+'>'+jz[i][j]+'</td>');
            }
            document.write('</tr>');
        }
        document.write('</table>');
    }
    getJz(6);
</script>

=========================================这是条美丽的分割线=========================================

首先申明以上代码是我复制过来的，方法是建个二维数组，然后从n*n向1逆向迂回，关键是判断“上下左右”移动方向，看不懂没关系我也感觉很晕。

经过分析我觉得棒棒糖其实只有两种情况：
如图红箭头是n为偶数时增加的部分：只要在原每行最后增加一个数，数的大小从(n-1)*(n-1)+1开始；然后最下面增加一行，数字是继前面的数累加，不过注意是倒过来的哦。
黄色箭头是n为奇数时增加的部分：只要在原每行前面增加一个数，注意数是从下向上的，大小也是从(n-1)*(n-1)+1开始；然后在最上面增加一行，继续累加而且是顺过去的。
理解了解决起来就简单多了：

<script type="text/javascript">
    function lollipop(n){
        var arr=[];//二维数组
        function add(l){
            var temp=[],i= 0,b=(l-1)*(l-1);//b是前一次排的尾数
            if(l%2==0){   //偶数情况
                for(;i< arr.length;i++){
                    b++;
                    arr[i].push(b);//每行最右边添加一个数
                }
                for(i=l-1;i>=0;i--){
                    b++;
                    temp[i]=b;//生成一个倒过来的临时数组
                }
                arr[arr.length]=temp;//临时数组加入二维数组里，即最下新增一行
            }else{   //奇数情况
                for(i=arr.length;i>0;i--){
                    b++;
                    arr[i-1].unshift(b);//每行最左边添加一个数
                    arr[i]=arr[i-1];//每行数组向下移一行
                }
                for(i=0;i<l;i++){
                    b++;
                    temp[i]=b;//生成一个顺的临时数组
                }
                arr[0]=temp;//临时数组加入二维数组里，即在最上面新增一行
            }
        }
        for(var o=1;o<=n;o++){
            add(o);//棒棒糖不断的绕大
        }
        document.write('<table border=1>');
        for(var i=0;i< arr.length;i++){
            document.write('<tr>');
            for(var j=0;j<arr[i].length;j++){
                document.write('<td align="center">'+arr[i][j]+'</td>');
            }
            document.write('</tr>');
        }
        document.write('</table>');
    }
    lollipop(1);
    lollipop(3);
    lollipop(6);
</script>