如何从给定的数字制作金字塔？ [关闭]

Question

我正在尝试用给定数量的星星制作一个倒金字塔。

只要知道行数，任何人都可以画出倒金字塔。

我们可以把倒金字塔做成这样

#include <stdio.h>
int main()
{
    int i, space, rows, k=0, count = 0, count1 = 0;

    printf("Enter number of rows: ");
    scanf("%d",&rows);

    for(i=1; i<=rows; ++i)
    {
        for(space=1; space <= rows-i; ++space)
        {
            printf("  ");
            ++count;
        }
        while(k != 2*i-1)
        {
            if (count <= rows-1)
            {
                printf("%d ", i+k);
                ++count;
            }
            else
            {
                ++count1;
                printf("%d ", (i+k-2*count1));
            }
            ++k;
        }
        count1 = count = k = 0;

        printf("\n");
    }
    return 0;
}

---

Result

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

但就我而言，我想制作一个倒金字塔。问了星星的数量后，我想做金字塔形状。我无法确定要使其形状像倒金字塔形的行数。

（不低于示例仅供参考，非强制性 遵循相同的模式，有人说如果你有任何数量 开始你将如何排列这些星星使其形状像倒置 金字塔（这可能是不完整的），据我想 打印如下形状，但不统一）

**Case** :
1. User Enters :  9

 * * * * *
   * * *
     *

2. User Enters :  8

 * * * * 
  * * *
    *




3. User Enters :  7

 * * * * 
  * * *

 (No matter if shape completes or not, but it should print like this)

4. User Enters :  6

 * * *  
  * *
   *     

是否可以根据给定的星数确定行数？

我将利用这个逻辑在滚动视图中创建动态视图。

Answer 1

这将为您生成金字塔阵列，同时尽量减少各层之间的差异，并保持对称性。

也许还有更多优化要做，但这是我脑海中蹦出的第一个想法。

这是在 Swift 中的，可以在 Swift Playground 中运行，我以为我在 OP 的帖子下看到了一个 Swift 标签，但现在它显然已经被删除了，反正代码本身很简单......

func genPyramid(count: Int) -> [Int] {
    var result: [Int] = []
    var maxPossibleRow: Int

    // special case
    if count <= 2 {
        return [count]
    }

    // test row diff: 1
    maxPossibleRow = Int(floor((sqrt(Float(8*count+1))-1.0)/2.0))
    if maxPossibleRow > 1 {
        let base = count - maxPossibleRow * (maxPossibleRow-1) / 2
        if base % maxPossibleRow == 0 {
            let firstRow = base / maxPossibleRow
            for k in 1...maxPossibleRow {
                result.append(firstRow + k - 1)
            }
            return result
        }
    }

    // test row diff: 2
    maxPossibleRow = Int(floor(sqrt(Float(count))))
    if maxPossibleRow > 1 {
        let base = count - 2 * maxPossibleRow * (maxPossibleRow-1) / 2
        if base % maxPossibleRow == 0 {
            let firstRow = base / maxPossibleRow
            for k in 1...maxPossibleRow {
                result.append(firstRow + 2*k-2)
            }
            return result
        }
    }

    // test row diff> 3
    for i in 3...count/2 {
        maxPossibleRow = Int(floor((Float(i-2)+sqrt(Float(i*i-4*i+4+8*i*count)))/2.0/Float(i)))
        print("looping", i, maxPossibleRow)
        if maxPossibleRow > 1 {
            let base = count - i * maxPossibleRow * (maxPossibleRow-1) / 2
            if base % maxPossibleRow == 0 {
                let firstRow = base / maxPossibleRow
                for k in 1...maxPossibleRow {
                    result.append(firstRow + i*(k-1))
                }
                return result
            }
        }
    }
    return []
}

一些测试用例fyr。

Answer 2

嗯，您需要决定的一件事是您要构建什么金字塔形状，规则是什么？您在上面针对特定数量的恒星展示了许多不同的方案，但它们没有遵循构建金字塔的固定模式。

例如，在第一个示例中，您有 3 颗星和 1 颗星，但在最后一个示例中，您有 3 颗星和 2 颗星。对于这种依赖于星数的临时金字塔设计，您可能需要对其进行一些硬编码。

但是，如果您为要构建的金字塔提出了更精确的定义，例如，每一层的星数不应超过其下一层，那么您可能可以设计一种算法来求任意数量的星的行数。

这个算法似乎是一个很好的开始，甚至可能正是你想要的：

int main(void)
{
    // creating two variables
    int num;

    printf("Enter num stars: ");
    scanf("%d", &num);
    printf("\n");

    int i = 0;

    while (num > i) {
        i++;
        num -= i;
    }

    printf("%d rows\n", i);

    return 0;
}

我在认识到perfect 金字塔中每一行恰好相差一颗星的情况下构建它，每行中的星数与该行的级别完全相同。该点有 1 颗星，下一行有 2 颗星，接下来是 3 颗星，依此类推...

因此，如果您计算行数并减去与您刚刚计算的行数相等的星数，并继续这样做，直到您没有足够的星数来组成一整行，您将得到正确的星数行。应将剩余的星号添加到现有行中，而不是创建新行。