3

需要打印的星星图案 问题是创建同心和嵌套的正方形，从给定为 N 的最大正方形的边开始。就像在纸上画一个正方形到另一个正方形一样，通过将边的长度减 4，直到无法再绘制正方形在每个正方形之后（边的 startPos 有 2 个，endPos 有 2 个）；N 是开始的正方形的大小。您必须使用乘法符号（'*'）来绘制边。

上图的比例（看起来更像矩形而不是正方形）可能不准确，但它会让你知道需要做什么......下面的代码是我尝试过的......这是需要打印的确切图案..

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();
    }

}
4

3 回答 3

1

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

编辑：看来您可能不是在另一个正方形上打印一个正方形，而是代替另一个正方形。然而，同样的策略也适用。

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

为什么不尝试类似的东西：

// 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.    
}
于 2012-06-15T19:28:40.863 回答
0

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

公共类 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();

}

}

于 2012-06-29T09:47:53.080 回答
0

概述

这个问题适合 Adob​​e，因为它本质上是一种渲染算法：给定一个像素和一组规则，计算该像素的外观。

最有效的方法是提出一个测试，回答“给定大小为 n 的正方形中的位置 (x,y)，是否应该用 标记*？”，然后针对每个位置回答该问题。

我们可以通过首先进行一些观察来回答这个问题。

  • 注意该算法输出的对称性。如果我们沿着它的诊断线切割正方形，我们就剩下四个三角形象限。在每个象限内，请注意三角形是简单的条纹。
  • 垂直或水平条纹易于绘制；只需检查行/列是否与最近的边缘距离均匀，如果是，则对其进行遮蔽。

所以我们将对每个位置进行两次计算：（1）这个位置在哪个象限中，（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 来采用迭代方法。这种方法更容易考虑，但需要更多内存。此外，这个答案中描述的方法的好处是确定给定位置的阴影是阴影，我们不需要知道它的相邻位置（迭代方法会这样做）。这意味着我们可以一次渲染最终渲染的小样本。换句话说，这种方法支持并行性，这总是一个不错的好处。

于 2012-06-15T21:47:32.170 回答