Floyd's triangle

Floyd's triangle is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.

Floyd's triangle lists the natural numbers in a right triangle aligned to the left where

• the first row is just 1
• successive rows start towards the left with the next number followed by successive naturals listing one more number than the line above.

The first few lines of a Floyd triangle looks like this:

 1
 2  3
 4  5  6
 7  8  9 10
11 12 13 14 15

The task is to:

1. Write a program to generate and display here the first n lines of a Floyd triangle.
   (Use n=5 and n=14 rows).
2. Ensure that when displayed in a monospace font, the numbers line up in vertical columns as shown and that only one space separates numbers of the last row.

Go

This example is incorrect. Please fix the code and remove this message. Details: The draft task goal has been modified, (see the talk page).

<lang go>package main

import "fmt"

func main() {

   floyd(5)
   floyd(15)

}

func floyd(n int) {

   fmt.Printf("Floyd %d:\n", n)
   w := len(fmt.Sprint(n * (n + 1) / 2))
   for i, row, last := 1, 1, 1; row <= n; i++ {
       fmt.Printf("%*d", w, i)
       if i < last {
           fmt.Print(" ")
       } else {
           fmt.Println()
           row++
           last += row
       }
   }

}</lang>

Output:

Floyd 5:
 1
 2  3
 4  5  6
 7  8  9 10
11 12 13 14 15
Floyd 15:
  1
  2   3
  4   5   6
  7   8   9  10
 11  12  13  14  15
 16  17  18  19  20  21
 22  23  24  25  26  27  28
 29  30  31  32  33  34  35  36
 37  38  39  40  41  42  43  44  45
 46  47  48  49  50  51  52  53  54  55
 56  57  58  59  60  61  62  63  64  65  66
 67  68  69  70  71  72  73  74  75  76  77  78
 79  80  81  82  83  84  85  86  87  88  89  90  91
 92  93  94  95  96  97  98  99 100 101 102 103 104 105
106 107 108 109 110 111 112 113 114 115 116 117 118 119 120

Python

<lang python>>>> def floyd(rowcount=5): rows = 1 while len(rows) < rowcount: n = rows[-1][-1] + 1 rows.append(list(range(n, n + len(rows[-1]) + 1))) return rows

>>> floyd() [[1], [2, 3], [4, 5, 6], [7, 8, 9, 10], [11, 12, 13, 14, 15]] >>> def pfloyd(rows=[[1], [2, 3], [4, 5, 6], [7, 8, 9, 10]]): colspace = [len(str(n)) for n in rows[-1]] for row in rows: print( ' '.join('%*i' % space_n for space_n in zip(colspace, row)))

>>> pfloyd() 1 2 3 4 5 6 7 8 9 10 >>> pfloyd(floyd(5))

1
2  3
4  5  6
7  8  9 10

11 12 13 14 15 >>> pfloyd(floyd(14))

1
2  3
4  5  6
7  8  9 10

11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 >>> </lang>