Question

The pattern of stars that need to be printed 问题是创建同心和嵌套的正方形，从最大的正方形边开始，给定为N.Its就像在另一个ON PAPER中绘制一个正方形一样，直到不再可以绘制正方形，在每个方格之后将边长减少4（从sidePos开始2，从endPos开始2）; N是开始时的正方形的大小。您必须使用乘法符号（'*'）来绘制边。

上面图像的比例（看起来更像是矩形而不是正方形）可能不准确，但它会让你知道需要做什么。以下代码是我尝试过的...... This the exact pattern that needs to be printed..

public static void main(String[] args)
{
    int N=9;
    int iLo=0;
    int iHi=N-1;
    int jLo=0;
    int jHi=N-1;

    for(int i=0;i<N;i++)
    {
        for(int j=0;j<N;j++)
        {
            if(i==0 || (i==N-1) || (j==0) || (j==N-1))
                System.out.print('*');
            else
            {
                if(i<=N/2)
                {
                    if((i%2==0) && (i>=iLo) && (i<=iHi) && (j>=jLo) && (j<=jHi))
                        System.out.print('*');
                    else
                        if(i==iLo || i==iHi )
                            System.out.print('*');
                        else
                            System.out.print(' ');  
                }
                else
                {
                    if((i%2==0) && (i>=iLo) && (i<=iHi) && (j>=jLo) && (j<=jHi))
                            System.out.print('*');
                        else
                            System.out.print(' ');  
                }

            }

        }
        System.out.print("  i-->"+i+"   iLo-->"+iLo+" iHi-->"+iHi+" jLo-->"+jLo+" jHi-->"+jHi);
        if(i%2>0)
        {
            if(i<=N/2)
            {
                jLo=jLo+2;
                jHi=jHi-2;
                iLo=iLo+1;
                iHi=iHi-1;
            }
            else
            {
                jLo=jLo-2;
                jHi=jHi+2;
                iLo=iLo-1;
                iHi=iHi+1;
            }
        }
        else
        {

        }

        System.out.println();
    }

}

Answer 1

这可以通过使用每次递减2的for循环来解决（i - = 2）或者递归地在基本情况下将单个*打印到屏幕上，或者根本没有。正如其他人发布的那样，除非你在每个方格之间留有一些空间，否则你只会有一个实心方块。

编辑：看起来你可能不会在另一个上面打印一个正方形，而是替换另一个正方形。但是，同样的策略适用。

EDIT2：你不需要使用i和j的嵌套for循环。单个for循环，每边的长度作为变量i应该足够了。但是，您需要调整顶点的重复计数。

为什么不尝试这样的事情：

// Assumes a cartesian coordinate system, origin at bottom left.
int startingX = 0;
int startingY = 0;
while( length > 0 ){
  printHorizontally(length, startingX, startingY);
  printVertically(length, startingX, startingY);
  startingX += 2;
  startingY += 2;
  length -= 4; 
}

private void printHorizontally(int length, int startingX, int startingY){
  // Prints length *s to the screen in a horizontal line starting at the
  // given points.  Define printVertically similarly.    
}

Answer 2

<强>概述

此问题适用于Adobe，因为它本质上是一种渲染算法：给定一个像素和一组规则，计算该像素的外观。

最有效的方法是提出一个测试，回答“给定位置（x，y）的大小为n的正方形，是否应标记为*？”，然后回答每个职位的问题。

我们可以先做几个观察来回答这个问题。

请注意此算法输出的对称性。如果我们沿着它的诊断切割正方形，我们留下四个三角形象限。在每个象限内，请注意三角形只是条纹。
垂直或水平条纹易于绘制;只检查行/列是否距离最近的边缘是一个均匀的距离，如果是，则检查它是否为阴影。

所以我们每个位置会做两次计算：（1）这个位置是哪个quandrant，（2）给定这个象限，这个位置的行/列是否应该加阴影？

示例实现（python）

def getQuadrant(i,j,n):
    # 1 means top quadrant; 2 right; 3 bottom; 4 left
    half_n = float(n-1)/2
    x = float(i) - half_n
    y = float(j) - half_n
    if x > 0:
        if y > 0:
            if x > y:
                return 3
            else:
                return 2
        else:
            if x > -1*y:
                return 3
            else:
                return 4
    else:
        if y > 0:
            if -1*x > y:
                return 1
            else:
                return 2
        else:
            if x < y:
                return 1
            else:
                return 4

def isPixelShaded(x,y,n):
    q = getQuadrant(x,y,n)
    if q == 1:
        return (x % 2) == 0
    elif q == 2:
        return ((n-y-1) % 2) == 0
    elif q == 3:
        return ((n-x-1) % 2) == 0
    else:
        return (y % 2) == 0

def getPixelShade(x,y,n):
    if isPixelShaded(x,y,n):
        return ' * '
    else: 
        return '   '

def printSquare(n):
    for i in range(n):
        print ''.join(map(lambda x: str(getPixelShade(i,x,n)),range(n)))

printSquare(3)
printSquare(6)
printSquare(9)

<强>输出

 *  *  * 
 *     * 
 *  *  * 
 *  *  *  *  *  * 
 *              * 
 *     *  *     * 
 *     *  *     * 
 *              * 
 *  *  *  *  *  * 
 *  *  *  *  *  *  *  *  * 
 *                       * 
 *     *  *  *  *  *     * 
 *     *           *     * 
 *     *     *     *     * 
 *     *           *     * 
 *     *  *  *  *  *     * 
 *                       * 
 *  *  *  *  *  *  *  *  *

其他想法

我们也可以通过在预分配矩阵中“走出正方形”a来采用迭代方法，而不是这里采用的渲染方法。这种方法更容易思考，但需要更多内存。此外，本答案中描述的方法具有以下优点：确定给定位置的阴影，我们不需要知道其相邻位置（迭代方法的位置）。这意味着我们可以立即渲染最终渲染的小样本。换句话说，这种方法支持并行性，这总是一个很好的奖励。

Answer 3

以下代码提供了最简单的递归解决方案---

公共类SquaresInSquare {

private static char[][] arr;


public static void populate(int start,int N)
{
    //System.out.println(start+" "+N);
    if(N < 0 || start > N)
        return;

    for (int i = start; i < N; i++)
    {
        for (int j = start; j < N; j++)
        {
            if(i==start || i==N-1 || j==start || j==N-1)
                arr[i][j]='*';
            else
                arr[i][j]=' ';
        }
    }

    populate(start+2,N-2);
}

public static void print()
{
    for (int i = 0; i < arr.length; i++)
    {
        for (int j = 0; j < arr.length; j++)
        {
            System.out.print(arr[i][j]);
        }
        System.out.println();
    }
}

/**
 * @Method :main is Personal Method Of Class-->SquaresInSquare
 * @returns : void
 * @param args
 */
public static void main(String[] args)
{
    int N=21;
    arr=new char[N][N];
    populate(0,N);
    print();

}

}

在Java中使用for循环打印嵌套正方形

3 个答案: