Floyd's triangle

From Rosetta Code
Jump to: navigation, search
Task
Floyd's triangle
You are encouraged to solve this task according to the task description, using any language you may know.

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.

Contents

[edit] Ada

with Ada.Text_IO, Ada.Integer_Text_IO, Ada.Command_Line;
 
procedure Floyd_Triangle is
 
Rows: constant Positive := Integer'Value(Ada.Command_Line.Argument(1));
Current: Positive := 1;
Width: array(1 .. Rows) of Positive;
 
begin
-- compute the width for the different columns
for I in Width'Range loop
Width(I) := Integer'Image(I + (Rows * (Rows-1))/2)'Length;
end loop;
 
-- output the triangle
for Line in 1 .. Rows loop
for Column in 1 .. Line loop
Ada.Integer_Text_IO.Put(Current, Width => Width(Column));
Current := Current + 1;
end loop;
Ada.Text_IO.New_Line;
end loop;
end Floyd_Triangle;
Output:
> ./floyd_triangle 5
  1
  2  3
  4  5  6
  7  8  9 10
 11 12 13 14 15


> ./floyd_triangle 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

[edit] ALGOL 68

Works with: ALGOL 68G version Any - tested with release 2.8.win32
# procedure to print a Floyd's Triangle with n lines                      #
PROC floyds triangle = ( INT n )VOID:
BEGIN
 
# calculate the number of the highest number that will be printed #
# ( the sum of the integers 1, 2, ... n ) #
INT max number = ( n * ( n + 1 ) ) OVER 2;
 
# determine the widths required to print the numbers of the final row #
[ n ]INT widths;
INT number := max number + 1;
FOR col FROM n BY -1 TO 1 DO
widths[ col ] := - ( UPB whole( number -:= 1, 0 ) + 1 )
OD;
 
# print the triangle #
INT element := 0;
FOR row TO n DO
FOR col TO row DO
print( ( whole( element +:= 1, widths[ col ] ) ) )
OD;
print( ( newline ) )
OD
 
END; # floyds triangle #
 
main: (
 
floyds triangle( 5 );
print( ( newline ) );
floyds triangle( 14 )
 
)
Output:
  1
  2  3
  4  5  6
  7  8  9 10
 11 12 13 14 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

[edit] AutoHotkey

Floyds_triangle(row){
i = 0
loop %row%
{
n := A_Index
loop, %n%
{
m := n, j := i, i++
while (m<row)
j += m , m++
res .= spaces(StrLen(j+1)-StrLen(i) +(A_Index=1?0:1)) i
}
if (A_Index < row)
res .= "`r`n"
}
return res
}
Spaces(no){
loop, % no
res.=" "
return % res
}
Examples:
MsgBox % Floyds_triangle(14)
Outputs:
 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

[edit] AWK

#!/bin/awk -f
 
BEGIN {
if (rows !~ /^[0-9]+$/ || rows < 0) {
print "invalid rows or missing from command line"
print "syntax: awk -v rows=14 -f floyds_triangle.awk"
exit 1
}
 
for (row=cols=1; row<=rows; row++ cols++) {
width[row] = length(row + (rows * (rows-1))/2)
for (col=1; col<=cols; col++)
printf("%*d%c", width[col], ++n, row == col ? "\n" : " ")
}
}
 

output from: awk -f floyds_triangle.awk -v rows=5

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

output from: awk -f floyds_triangle.awk -v rows=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

[edit] BBC BASIC

      n = 14
num = 1
last = (n^2 - n + 2) DIV 2
FOR row = 1 TO n
col = last
FOR num = num TO num + row - 1
@% = LEN(STR$(col)) + 1 : REM set column width
PRINT num ;
col += 1
NEXT
PRINT
NEXT row

Output for n = 5:

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

Output for n = 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

[edit] Bracmat

  ( ( floyd
= lowerLeftCorner lastInColumn lastInRow row i W w
. put$(str$("Floyd " !arg ":\n"))
&  !arg*(!arg+-1)*1/2+1
 : ?lowerLeftCorner
 : ?lastInColumn
& 1:?lastInRow:?row:?i
& whl
' ( !row:~>!arg
& @(!lastInColumn:? [?W)
& @(!i:? [?w)
& whl'(!w+1:~>!W:?w&put$" ")
& put$!i
& (  !i:<!lastInRow
& put$" "
& 1+!lastInColumn:?lastInColumn
| put$\n
& (1+!row:?row)+!lastInRow:?lastInRow
& !lowerLeftCorner:?lastInColumn
)
& 1+!i:?i
)
)
& floyd$5
& floyd$14
);

Output:

Floyd 5:
 1
 2  3
 4  5  6
 7  8  9 10
11 12 13 14 15
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

[edit] C

#include <stdio.h>
 
void t(int n)
{
int i, j, c, len;
 
i = n * (n - 1) / 2;
for (len = c = 1; c < i; c *= 10, len++);
c -= i; // c is the col where width changes
 
#define SPEED_MATTERS 0
#if SPEED_MATTERS // in case we really, really wanted to print huge triangles often
char tmp[32], s[4096], *p;
 
sprintf(tmp, "%*d", len, 0);
 
inline void inc_numstr(void) {
int k = len;
 
redo: if (!k--) return;
 
if (tmp[k] == '9') {
tmp[k] = '0';
goto redo;
}
 
if (++tmp[k] == '!')
tmp[k] = '1';
}
 
for (p = s, i = 1; i <= n; i++) {
for (j = 1; j <= i; j++) {
inc_numstr();
__builtin_memcpy(p, tmp + 1 - (j >= c), len - (j < c));
p += len - (j < c);
 
*(p++) = (i - j)? ' ' : '\n';
 
if (p - s + len >= 4096) {
fwrite(s, 1, p - s, stdout);
p = s;
}
}
}
 
fwrite(s, 1, p - s, stdout);
#else // NO_IT_DOESN'T
int num;
for (num = i = 1; i <= n; i++)
for (j = 1; j <= i; j++)
printf("%*d%c", len - (j < c), num++, i - j ? ' ':'\n');
#endif
}
 
int main(void)
{
t(5), t(14);
 
// maybe not
// t(10000);
return 0;
}

Output identical to D's.

[edit] C++

 
#include <windows.h>
#include <sstream>
#include <iostream>
 
//--------------------------------------------------------------------------------------------------
using namespace std;
 
//--------------------------------------------------------------------------------------------------
class floyds_tri
{
public:
floyds_tri() { lastLineLen = 0; }
~floyds_tri() { killArray(); }
 
void create( int rows )
{
_rows = rows;
calculateLastLineLen();
display();
}
 
private:
void killArray()
{
if( lastLineLen )
delete [] lastLineLen;
}
 
void calculateLastLineLen()
{
killArray();
lastLineLen = new BYTE[_rows];
 
int s = 1 + ( _rows * ( _rows - 1 ) ) / 2;
 
for( int x = s, ix = 0; x < s + _rows; x++, ix++ )
{
ostringstream cvr;
cvr << x;
lastLineLen[ix] = static_cast<BYTE>( cvr.str().size() );
}
}
 
void display()
{
cout << endl << "Floyd\'s Triangle - " << _rows << " rows" << endl << "===============================================" << endl;
int number = 1;
for( int r = 0; r < _rows; r++ )
{
for( int c = 0; c <= r; c++ )
{
ostringstream cvr;
cvr << number++;
string str = cvr.str();
while( str.length() < lastLineLen[c] )
str = " " + str;
cout << str << " ";
}
cout << endl;
}
}
 
int _rows;
BYTE* lastLineLen;
};
//--------------------------------------------------------------------------------------------------
int main( int argc, char* argv[] )
{
floyds_tri t;
int s;
while( true )
{
cout << "Enter the size of the triangle ( 0 to QUIT ): "; cin >> s;
if( !s ) return 0;
if( s > 0 ) t.create( s );
 
cout << endl << endl;
system( "pause" );
}
 
return 0;
}
//--------------------------------------------------------------------------------------------------
 

Output:

Floyd's Triangle - 5 rows
===============================================
 1
 2  3
 4  5  6
 7  8  9 10
11 12 13 14 15


Floyd's Triangle - 14 rows
===============================================
 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

[edit] C#

Translation of: Perl
using System;
using System.Text;
 
public class FloydsTriangle
{
internal static void Main(string[] args)
{
int count;
if (args.Length >= 1 && int.TryParse(args[0], out count) && count > 0)
{
Console.WriteLine(MakeTriangle(count));
}
else
{
Console.WriteLine(MakeTriangle(5));
Console.WriteLine();
Console.WriteLine(MakeTriangle(14));
}
}
 
public static string MakeTriangle(int rows)
{
int maxValue = (rows * (rows + 1)) / 2;
int digit = 0;
StringBuilder output = new StringBuilder();
 
for (int row = 1; row <= rows; row++)
{
for (int column = 0; column < row; column++)
{
int colMaxDigit = (maxValue - rows) + column + 1;
if (column > 0)
{
output.Append(' ');
}
 
digit++;
output.Append(digit.ToString().PadLeft(colMaxDigit.ToString().Length));
}
 
output.AppendLine();
}
 
return output.ToString();
}
}
 

[edit] Common Lisp

[edit] Version 1

;;;using flet to define local functions and storing precalculated column widths in array
;;;verbose, but more readable and efficient than version 2
 
(defun floydtriangle (rows)
(let (column-widths)
(setf column-widths (make-array rows :initial-element nil))
(flet (
(lazycat (n)
(/ (+ (expt n 2) n 2) 2))
(width (v)
(+ 1 (floor (log v 10)))))
(dotimes (i rows)
(setf (aref column-widths i)(width (+ i (lazycat (- rows 1))))))
(dotimes (row rows)
(dotimes (col (+ 1 row))
(format t "~vd " (aref column-widths col)(+ col (lazycat row))))
(format t "~%")))))

[edit] Version 2 - any base

;;; more concise than version 1 but less efficient for a large triangle
;;;optional "base" parameter will allow use of any base from 2 to 36
 
(defun floydtriangle (rows &optional (base 10))
(dotimes (row rows)
(dotimes (column (+ 1 row))
(format t "~v,vr " base (length (format nil "~vr" base (+ column (/ (+ (expt (- rows 1) 2) (- rows 1) 2) 2)))) (+ column (/ (+ (expt row 2) row 2) 2))))
(format t "~%")))
Output:
(floydtriangle 5)
 1
 2  3
 4  5  6
 7  8  9 10
11 12 13 14 15

(floydtriangle 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

(floydtriangle 5 2)
   1 
  10   11 
 100  101  110 
 111 1000 1001 1010 
1011 1100 1101 1110 1111 

(floydtriangle 14 36)
 1 
 2  3 
 4  5  6 
 7  8  9  A 
 B  C  D  E  F 
 G  H  I  J  K  L 
 M  N  O  P  Q  R  S 
 T  U  V  W  X  Y  Z 10 
11 12 13 14 15 16 17 18 19 
1A 1B 1C 1D 1E 1F 1G 1H 1I 1J 
1K 1L 1M 1N 1O 1P 1Q 1R 1S 1T 1U 
1V 1W 1X 1Y 1Z 20 21 22 23 24 25 26 
27 28 29 2A 2B 2C 2D 2E 2F 2G 2H 2I 2J 
2K 2L 2M 2N 2O 2P 2Q 2R 2S 2T 2U 2V 2W 2X

[edit] D

import std.stdio, std.conv;
 
void floydTriangle(in uint n) {
immutable lowerLeftCorner = n * (n - 1) / 2 + 1;
foreach (r; 0 .. n)
foreach (c; 0 .. r + 1)
writef("%*d%c",
text(lowerLeftCorner + c).length,
r * (r + 1) / 2 + c + 1,
c == r ? '\n' : ' ');
}
 
void main() {
floydTriangle(5);
floydTriangle(14);
}
Output:
 1
 2  3
 4  5  6
 7  8  9 10
11 12 13 14 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

[edit] Erlang

 
-module( floyds_triangle ).
 
-export( [integers/1, print/1, strings/1, task/0] ).
 
integers( N ) ->
lists:reverse( integers_reversed(N) ).
 
print( N ) ->
[io:fwrite("~s~n", [lists:flatten(X)]) || X <- strings(N)].
 
strings( N ) ->
Strings_reversed = [strings_from_integers(X) || X <- integers_reversed(N)],
Paddings = paddings( [lengths(X) || X <- Strings_reversed] ),
[formats(X, Y) || {X, Y} <- lists:zip(Paddings, lists:reverse(Strings_reversed))].
 
task() ->
print( 5 ),
print( 14 ).
 
 
 
formats( Paddings, Strings ) -> [lists:flatten(io_lib:format(" ~*s", [X, Y])) || {X, Y} <- lists:zip(Paddings, Strings)].
 
integers_reversed( N ) ->
{_End, Integers_reversed} = lists:foldl( fun integers_reversed/2, {1, []}, lists:seq(0, N - 1) ),
Integers_reversed.
 
integers_reversed( N, {Start, Acc} ) ->
End = Start + N,
{End + 1, [lists:seq(Start, End) | Acc]}.
 
lengths( Strings ) -> [string:len(X) || X <- Strings].
 
paddings( [Last_line | T] ) ->
{[], Paddings} = lists:foldl( fun paddings/2, {paddings_lose_last(Last_line), [Last_line]}, lists:seq(1, erlang:length(T)) ),
Paddings.
 
paddings( _N, {Current, Acc} ) -> {paddings_lose_last(Current), [Current | Acc]}.
 
paddings_lose_last( List ) ->
[_H | T] = lists:reverse( List ),
lists:reverse( T ).
 
strings_from_integers( Integers ) -> [erlang:integer_to_list(X) || X <- Integers].
 
Output:
  1
  2  3
  4  5  6
  7  8  9 10
 11 12 13 14 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

[edit] freebasic

This example is incorrect. Treatment of column widths does not meet task requirements. Please fix the code and remove this message.
 
 
function rows(n as integer) as string
var a=n*(n+1)\2,b=n*(n-1)\2+1
dim as string s
for z as integer=a to b step -1
var pad=string(len(n)-len(str(z))," ")
s=pad+str(z)+" "+s
next z
return s
end function
 
print "output for 5:":print
for n as integer=1 to 5
print rows(n)
next n
print:print "output for 14:":print
for n as integer=1 to 14
print rows(n)
next n
sleep
 
output for 5:

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

output for 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

[edit] F#

open System
 
[<EntryPoint>]
let main argv =
// columns and rows are 0-based, so the input has to be decremented:
let maxRow =
match UInt32.TryParse(argv.[0]) with
| (true, v) when v > 0u -> int (v - 1u)
| (_, _) -> failwith "not a positive integer"
 
let len (n: int) = int (Math.Floor(Math.Log10(float n)))
let col0 row = row * (row + 1) / 2 + 1
let col0maxRow = col0 maxRow
for row in [0 .. maxRow] do
for col in [0 .. row] do
let value = (col0 row) + col
let pad = String(' ', (len (col0maxRow + col) - len (value) + 1))
printf "%s%d" pad value
printfn ""
0

Output for 5 and 14 (via command line argument)

  1
  2  3
  4  5  6
  7  8  9 10
 11 12 13 14 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

[edit] Forth

: lastn ( rows -- n ) dup 1- * 2/ ;
: width ( n -- n ) s>f flog ftrunc f>s 2 + ;
 
: triangle ( rows -- )
dup lastn 0 rot ( last 0 rows )
0 do
over cr
i 1+ 0 do
1+ swap 1+ swap
2dup width u.r
loop
drop
loop
2drop ;
 

[edit] Fortran

Please find compilation instructions on GNU/linux system at the beginning of the source. There, also, are the example output triangles produced by running the program. The environment variable setting and command line argument are vestigial. Ignore them. The code demonstrates writing to an in memory buffer, an old feature of FORTRAN.

 
!-*- mode: compilation; default-directory: "/tmp/" -*-
!Compilation started at Tue May 21 22:55:08
!
!a=./f && make $a && OMP_NUM_THREADS=2 $a 1223334444
!gfortran -std=f2008 -Wall -ffree-form -fall-intrinsics f.f08 -o f
! 1
! 2 3
! 4 5 6
! 7 8 9 10
! 11 12 13 14 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
!
!
!
!Compilation finished at Tue May 21 22:55:08
 
 
program p
integer, dimension(2) :: examples = [5, 14]
integer :: i
do i=1, size(examples)
call floyd(examples(i))
write(6, '(/)')
end do
 
contains
 
subroutine floyd(rows)
integer, intent(in) :: rows
integer :: n, i, j, k
integer, dimension(60) :: L
character(len=504) :: fmt
n = (rows*(rows+1))/2 ! Gauss's formula
do i=1,rows ! compute format of final row
L(i) = 2+int(log10(real(n-rows+i)))
end do
k = 0
do i=1,rows
do j=1,i
k = k+1
write(fmt,'(a2,i1,a1)')'(i',L(j),')'
write(6,fmt,advance='no') k
enddo
write(6,*) ''
end do
end subroutine floyd
 
end program p
 

[edit] Go

package main
 
import "fmt"
 
func main() {
floyd(5)
floyd(14)
}
 
func floyd(n int) {
fmt.Printf("Floyd %d:\n", n)
lowerLeftCorner := n*(n-1)/2 + 1
lastInColumn := lowerLeftCorner
lastInRow := 1
for i, row := 1, 1; row <= n; i++ {
w := len(fmt.Sprint(lastInColumn))
if i < lastInRow {
fmt.Printf("%*d ", w, i)
lastInColumn++
} else {
fmt.Printf("%*d\n", w, i)
row++
lastInRow += row
lastInColumn = lowerLeftCorner
}
}
}
Output:
Floyd 5:
 1
 2  3
 4  5  6
 7  8  9 10
11 12 13 14 15
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

[edit] Haskell

Program

import Data.List
import Control.Monad
import Control.Arrow
 
alignR :: Int -> Integer -> String
alignR n = (\s -> replicate (n - length s) ' ' ++ s). show
 
floydTriangle = liftM2 (zipWith (liftM2 (.) enumFromTo ((pred.). (+)))) (scanl (+) 1) id [1..]
 
formatFT n = mapM_ (putStrLn. unwords. zipWith alignR ws) t where
t = take n floydTriangle
ws = map (length. show) $ last t

Output:

*Main> formatFT 5
1
2 3
4 5 6
7 8 9 10
11 12 13 14 15
 
*Main> formatFT 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

[edit] Icon and Unicon

The following solution works in both languages:

procedure main(a)
n := integer(a[1]) | 5
w := ((n*(n-1))/2)-n
c := create seq()
every row := 1 to n do {
every col := 1 to row do {
width := *(w+col)+1
every writes(right(@c,width))
}
write()
}
end

Sample outputs:

->ft
  1
  2  3
  4  5  6
  7  8  9 10
 11 12 13 14 15
->
->ft 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
->

[edit] J

Note: require 'strings' does nothing in J7, but is harmless (strings is already incorporated in J7).

require 'strings'
floyd=: [: rplc&(' 0';' ')"1@":@(* ($ $ +/\@,)) >:/~@:i.

Note, the parenthesis around ($ $ +/\@,) is optional, and only included for emphasis.

Example use:

   floyd 5
1
2 3
4 5 6
7 8 9 10
11 12 13 14 15
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

How it works:

First, we create a square lower triangular matrix with our argument as the length of one side. We have 1s along the diagonal and the lower triangle, and 0s for the upper triangle.

Second, we create a running sum of these values (treating rows as being adjacent horizontally for this purpose). Then, we multiply this result by our lower triangular matrix (forcing the upper triangle to be 0s).

Then, we format the matrix as text (which gives us the required vertical alignment), and in each row we replace each space followed by a zero with two spaces.

Efficiency note: In a measurement of time used: in floyd 100, 80% the time here goes into the string manipulations -- sequential additions and multiplications are cheap. In floyd 1000 this jumps to 98% of the time. Here's a faster version (about 3x on floyd 1000) courtesy of Aai of the J forums:

floyd=: [: ({.~ i.&1@E.~&' 0')"1@":@(* ($ $ +/\@,)) >:/~@:i.

[edit] Java

 
public class Floyd {
public static void main(String[] args){
printTriangle(5);
printTriangle(14);
}
 
private static void printTriangle(int n){
System.out.println(n + " rows:");
for(int rowNum = 1, printMe = 1, numsPrinted = 0;
rowNum <= n; printMe++){
int cols = (int)Math.ceil(Math.log10(n*(n-1)/2 + numsPrinted + 2));
System.out.printf("%"+cols+"d ", printMe);
if(++numsPrinted == rowNum){
System.out.println();
rowNum++;
numsPrinted = 0;
}
}
}
}

Output:

5 rows:
 1 
 2  3 
 4  5  6 
 7  8  9 10 
11 12 13 14 15 
14 rows:
 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 

[edit] JavaScript

[edit] Spidermonkey

(Used TCL example as a starting point.)

#!/usr/bin/env js
 
function main() {
print('Floyd 5:');
floyd(5);
print('\nFloyd 14:');
floyd(14);
}
 
 
function padLeft(s, w) {
for (s = String(s); s.length < w; s = ' ' + s);
return s;
}
 
 
function floyd(nRows) {
var lowerLeft = nRows * (nRows - 1) / 2 + 1;
var lowerRight = nRows * (nRows + 1) / 2;
 
var colWidths = [];
for (var col = lowerLeft; col <= lowerRight; col++) {
colWidths.push(String(col).length);
}
 
var num = 1;
for (var row = 0; row < nRows; row++) {
var line = [];
for (var col = 0; col <= row; col++, num++) {
line.push(padLeft(num, colWidths[col]));
}
print(line.join(' '));
}
}
 
main();
 


Output:

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

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

[edit] Julia

#floyd(n) creates an n-row floyd's triangle counting from 1 to (n/2+.5)*n
function floyd(n)
x = 1
dig(x,line,n) = (while line < n; x+=line; line+= 1 end; return ndigits(x)+1)
for line = 1:n, i = 1:line; print(lpad(x,dig(x,line,n)," ")); x+=1; i==line && print("\n") end
end
julia> floyd(5)
  1
  2  3
  4  5  6
  7  8  9 10
 11 12 13 14 15

julia> 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

Here is another solution that makes use of the fact that the number in the (i,j)th position in the array is equal to the sum of j and the binomial coefficient (j,2). This number should be padded according to the number of digits in the coefficient (n,j).

floyd(n) = 
print([join([lpad(j+binomial(i,2), (j==1?0:1)+ndigits(j+binomial(n,2)), " ")
for j=1:i])
for i=1:n])
 
Output:
julia> floyd(5)
 1
 2  3
 4  5  6
 7  8  9 10
11 12 13 14 15

[edit] Mathematica

 
f=Function[n,
Most/@(Range@@@Partition[FindSequenceFunction[{1,2,4,7,11}]/@Range[n+1],2,1])]
TableForm[f@5,TableAlignments->Right,TableSpacing->{1,1}]
TableForm[f@14,TableAlignments->Right,TableSpacing->{1,1}]
 

Output:

  1
  2  3
  4  5  6
  7  8  9 10
 11 12 13 14 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


[edit] Lasso

This example does not show the output mentioned in the task description on this page (or a page linked to from here). There should only be one space between the numbers on the last row. Please ensure that it meets all task requirements and remove this message.
Note that phrases in task descriptions such as "print and display" and "print and show" for example, indicate that (reasonable length) output be a part of a language's solution.


define floyds_triangle(n::integer) => {
local(out = array(array(1)),comp = array, num = 1)
while(#out->size < #n) => {
local(new = array)
loop(#out->last->size + 1) => {
#num++
#new->insert(#num)
}
#out->insert(#new)
}
local(pad = #out->last->last->asString->size)
with line in #out do => {
local(lineout = string)
with i in #line do => {
#i != #line->first ? #lineout->append(' ')
#lineout->append((' '*(#pad - #i->asString->size))+#i)
}
#comp->insert(#lineout)
}
return #comp->join('\r')
}
floyds_triangle(5)
'\r\r'
floyds_triangle(14)
Output:
 1
 2  3
 4  5  6
 7  8  9 10
11 12 13 14 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

[edit] Liberty BASIC

 
input "Number of rows needed:- "; rowsNeeded
 
dim colWidth(rowsNeeded) ' 5 rows implies 5 columns
 
for col=1 to rowsNeeded
colWidth(col) = len(str$(col + rowsNeeded*(rowsNeeded-1)/2))
next
 
currentNumber =1
 
for row=1 to rowsNeeded
for col=1 to row
print right$( " "+str$( currentNumber), colWidth(col)); " ";
currentNumber = currentNumber + 1
next
print
next
 
 

Output:

Number of rows needed:- 5
 1 
 2  3 
 4  5  6 
 7  8  9 10 
11 12 13 14 15 

Number of rows needed:- 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 

[edit] Lua

function print_floyd(rows)
local c = 1
local h = rows*(rows-1)/2
for i=1,rows do
local s = ""
for j=1,i do
for k=1, #tostring(h+j)-#tostring(c) do
s = s .. " "
end
if j ~= 1 then s = s .. " " end
s = s .. tostring(c)
c = c + 1
end
print(s)
end
end
 
print_floyd(5)
print_floyd(14)

Output:

 1
 2  3
 4  5  6
 7  8  9 10
11 12 13 14 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

[edit] MATLAB / Octave

function floyds_triangle(n)
 
width = 1+floor(log10(nr*(nr+1)/2));
for k=1:n,
fprintf(stdout,' %*i',[width(ones(1,k));k*(k-1)/2+1:k*(k+1)/2]);
fprintf(stdout,'\n');
end;

gives the output:

octave:22> floyds_triangle(5)
  1
  2  3
  4  5  6
  7  8  9 10
 11 12 13 14 15

[edit] NetRexx

Both REXX versions lend themselves very well to conversion into NetRexx programs with few changes.

[edit] Version 1

Translation of: REXX
/* NetRexx */
options replace format comments java crossref symbols binary
/* REXX ***************************************************************
* 12.07.2012 Walter Pachl - translated from Python
**********************************************************************/

Parse Arg rowcount .
if rowcount.length() == 0 then rowcount = 1
say 'Rows:' rowcount
say
col = 0
len = Rexx ''
ll = '' -- last line of triangle
Loop j = rowcount * (rowcount - 1) / 2 + 1 to rowcount * (rowcount + 1) / 2
col = col + 1 -- column number
ll = ll j -- build last line
len[col] = j.length() -- remember length of column
End j
Loop i = 1 To rowcount - 1 -- now do and output the rest
ol = ''
col = 0
Loop j = i * (i - 1) / 2 + 1 to i * (i + 1) / 2 -- elements of line i
col = col + 1
ol=ol j.right(len[col]) -- element in proper length
end
Say ol -- output ith line
end i
Say ll -- output last line
 

Output:

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

Rows: 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 

[edit] Version 2

Translation of: REXX
/* NetRexx */
options replace format comments java crossref symbols binary
/*REXX program constructs & displays Floyd's triangle for any number of rows.*/
parse arg numRows .
if numRows == '' then numRows = 1 -- assume 1 row is not given
maxVal = numRows * (numRows + 1) % 2 -- calculate the max value.
say 'displaying a' numRows "row Floyd's triangle:"
say
digit = 1
loop row = 1 for numRows
col = 0
output = ''
loop digit = digit for row
col = col + 1
colMaxDigit = maxVal - numRows + col
output = output Rexx(digit).right(colMaxDigit.length())
end digit
say output
end row
 

Output:

displaying a 5 row Floyd's triangle: 
 
  1 
  2  3 
  4  5  6 
  7  8  9 10 
 11 12 13 14 15
  
displaying a 14 row Floyd's triangle: 
 
  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

[edit] Nimrod

Translation of: Python
import strutils
 
proc floyd(rowcount = 5): seq[seq[int]] =
result = @[@[1]]
while result.len < rowcount:
let n = result[result.high][result.high] + 1
var row = newSeq[int]()
for i in n .. n + result[result.high].len:
row.add i
result.add row
 
proc pfloyd(rows) =
var colspace = newSeq[int]()
for n in rows[rows.high]: colspace.add(($n).len)
for row in rows:
for i, x in row:
stdout.write align($x, colspace[i])," "
echo ""
 
echo floyd()
 
for i in [5, 14]:
pfloyd(floyd(i))
echo ""

Output:

@[@[1], @[2, 3], @[4, 5, 6], @[7, 8, 9, 10], @[11, 12, 13, 14, 15]]
 1 
 2  3 
 4  5  6 
 7  8  9 10 
11 12 13 14 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 

[edit] OCaml

let ( |> ) f g x = g (f x)
let rec last = function x::[] -> x | _::tl -> last tl | [] -> raise Not_found
let rec list_map2 f l1 l2 =
match (l1, l2) with
| ([], _) | (_, []) -> []
| (x::xs, y::ys) -> (f x y) :: list_map2 f xs ys
 
let floyd n =
let rec aux acc cur len i j =
if (List.length acc) = n then (List.rev acc) else
if j = len
then aux ((List.rev cur)::acc) [] (succ len) i 0
else aux acc (i::cur) len (succ i) (succ j)
in
aux [] [] 1 1 0
 
let print_floyd f =
let lens = List.map (string_of_int |> String.length) (last f) in
List.iter (fun row ->
print_endline (
String.concat " " (
list_map2 (Printf.sprintf "%*d") lens row))
) f
 
let () =
print_floyd (floyd (int_of_string Sys.argv.(1)))

[edit] OxygenBasic

This example does not show the output mentioned in the task description on this page (or a page linked to from here). Please ensure that it meets all task requirements and remove this message.
Note that phrases in task descriptions such as "print and display" and "print and show" for example, indicate that (reasonable length) output be a part of a language's solution.


 
function Floyd(sys n) as string
sys i,t
for i=1 to n
t+=i
next
string s=str t
sys le=1+len s
string cr=chr(13,10)
sys lc=len cr
string buf=space(le*t+n*lc)
sys j,o,p=1
t=0
for i=1 to n
for j=1 to i
t++
s=str t
o=le-len(s)-1 'right justify
mid buf,p+o,str t
p+=le
next
mid buf,p,cr
p+=lc
next
return left buf,p-1
end function
 
putfile "s.txt",Floyd(5)+floyd(14)
 

[edit] PARI/GP

This example is incorrect. It does not ensure that there is exactly one space between the columns in the last row. Please fix the code and remove this message.


F(n)=my(fmt=Str("%"1+#Str(n*(n+1)/2)"d"),t);for(i=1,n,for(j=1,i,printf(fmt,t++));print)
F(5)
F(14)
Output:
  1
  2  3
  4  5  6
  7  8  9 10
 11 12 13 14 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

[edit] Pascal

Works with: Free_Pascal
Program FloydDemo (input, output);
 
function digits(number: integer): integer;
begin
digits := trunc(ln(number) / ln(10)) + 1;
end;
 
procedure floyd1 (numberOfLines: integer);
{ variant with repeat .. until loop }
var
i, j, numbersInLine, startOfLastlLine: integer;
 
begin
startOfLastlLine := (numberOfLines - 1) * numberOfLines div 2 + 1;
i := 1;
j := 1;
numbersInLine := 1;
repeat
repeat
write(i: digits(startOfLastlLine - 1 + j), ' ');
inc(i);
inc(j);
until (j > numbersInLine);
writeln;
j := 1;
inc(numbersInLine);
until (numbersInLine > numberOfLines);
end;
 
procedure floyd2 (numberOfLines: integer);
{ Variant with for .. do loop }
var
i, j, numbersInLine, startOfLastlLine: integer;
 
begin
startOfLastlLine := (numberOfLines - 1) * numberOfLines div 2 + 1;
i := 1;
for numbersInLine := 1 to numberOfLines do
begin
for j := 1 to numbersInLine do
begin
write(i: digits(startOfLastlLine - 1 + j), ' ');
inc(i);
end;
writeln;
end;
end;
 
begin
writeln ('*** Floyd 5 ***');
floyd1(5);
writeln;
writeln ('*** Floyd 14 ***');
floyd2(14);
end.

Output:

% ./Floyd
*** Floyd 5 ***
 1 
 2  3 
 4  5  6 
 7  8  9 10 
11 12 13 14 15 

*** 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 

[edit] Perl

Translation of: NetRexx
#!/usr/bin/env perl
use strict;
use warnings;
 
sub displayFloydTriangle {
my $numRows = shift;
print "\ndisplaying a $numRows row Floyd's triangle:\n\n";
my $maxVal = int($numRows * ($numRows + 1) / 2); # calculate the max value.
my $digit = 0;
foreach my $row (1 .. $numRows) {
my $col = 0;
my $output = '';
foreach (1 .. $row) {
++$digit;
++$col;
my $colMaxDigit = $maxVal - $numRows + $col;
$output .= sprintf " %*d", length($colMaxDigit), $digit;
}
print "$output\n";
}
return;
}
 
# ==== Main ================================================
my @counts;
@counts = @ARGV;
@counts = (5, 14) unless @ARGV;
 
foreach my $count (@counts) {
displayFloydTriangle($count);
}
 
0;
__END__
 

Output:

displaying a 5 row Floyd's triangle:

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

displaying a 14 row Floyd's triangle:

  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

[edit] Perl 6

sub chunk(@flat is copy, *@size) {
gather for @size -> $s { take [@flat.shift xx $s] }
}
 
constant @floyd = chunk 1..*, 1..*;
 
sub say-floyd($n) {
my @fmt = @floyd[$n-1].map: {"%{.chars}s"}
 
for @floyd[^$n] -> @i {
say join ' ', (@i Z @fmt).map: -> $i, $f { $i.fmt($f) }
}
}
 
say-floyd 5;
say-floyd 14;
Output:
 1 
 2  3 
 4  5  6 
 7  8  9 10 
11 12 13 14 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

[edit] PHP

 
<?php
floyds_triangle(5);
floyds_triangle(14);
 
function floyds_triangle($n) {
echo "n = " . $n . "\r\n";
 
for($r = 1, $i = 1, $c = 0; $r <= $n; $i++) {
$cols = ceil(log10($n*($n-1)/2 + $c + 2));
printf("%".$cols."d ", $i);
if(++$c == $r) {
echo "\r\n";
$r++;
$c = 0;
}
}
?>
 
Output:
 
n = 5
 1 
 2  3 
 4  5  6 
 7  8  9 10 
11 12 13 14 15 
n = 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 

[edit] PicoLisp

[edit] Calculate widths relative to lower left corner

(de floyd (N)
(let LLC (/ (* N (dec N)) 2)
(for R N
(for C R
(prin
(align
(length (+ LLC C))
(+ C (/ (* R (dec R)) 2)) ) )
(if (= C R) (prinl) (space)) ) ) ) )

[edit] Pre-calculate all rows, and take format from last one

(de floyd (N)
(let
(Rows
(make
(for ((I . L) (range 1 (/ (* N (inc N)) 2)) L)
(link (cut I 'L)) ) )
Fmt (mapcar length (last Rows)) )
(map inc (cdr Fmt))
(for R Rows
(apply tab R Fmt) ) ) )

Output in both cases:

: (floyd 5)
 1
 2  3
 4  5  6
 7  8  9 10
11 12 13 14 15

: (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

[edit] PL/I

(fofl, size):
floyd: procedure options (main); /* Floyd's Triangle. Wiki 12 July 2012 */
 
declare (i, m, n) fixed (10), (j, k, w, nr) fixed binary;
 
put list ('How many rows do you want?');
get list (nr); /* the number of rows */
n = nr*(nr+1)/2; /* the total number of values */
 
j,k = 1; m = n - nr + 1;
do i = 1 to n;
put edit (i) ( x(1), f(length(trim(m))) );
if k > 1 then do; k = k - 1; m = m + 1; end;
else do; k,j = j + 1; m = n - nr + 1; put skip; end;
end;
 
end floyd;
Output:
How many rows do you want?
  1
  2  3
  4  5  6
  7  8  9 10
 11 12 13 14 15

How many rows do you want? 
  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

Final row for n=45:
 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035

[edit] Prolog

Works with SWI-Prolog version 6.5.3

floyd(N) :-
forall(between(1, N, I),
( forall(between(1,I, J),
( Last is N * (N-1)/2+J,
V is I * (I-1) /2 + J,
get_column(Last, C),
sformat(AR, '~~t~~w~~~w| ', [C]),
sformat(AF, AR, [V]),
writef(AF))),
nl)).
 
get_column(Last, C) :-
name(Last, N1), length(N1,C).
 

Output :

 ?- floyd(5).
 1 
 2  3 
 4  5  6 
 7  8  9 10 
11 12 13 14 15 
true.

 ?- 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 
true.

[edit] PureBasic

Procedure.i sumTo(n) 
Protected r,i
For i=1 To n
r+i
Next
ProcedureReturn r.i
EndProcedure
 
; [1]
; array rsA(n)... string-lengths of the numbers
; in the bottom row
 
; [2]
; sumTo(i-1)+1 to sumTo(i)
; 11 12 13 14 15
; here k is the column-index for array rsA(k)
 
Procedure.s FloydsTriangle(n)
Protected r.s,s.s,t.s,i,j,k
; [1]
Dim rsA(n)
i=0
For j=sumTo(n-1)+1 To sumTo(n)
i+1
rsA(i)=Len(Str(j))
Next
; [2]
For i=1 To n
t.s="":k=0
For j=sumTo(i-1)+1 To sumTo(i)
k+1:t.s+RSet(Str(j),rsA(k)," ")+" "
Next
r.s+RTrim(t.s)+Chr(13)+Chr(10)
Next
r.s=Left(r.s,Len(r.s)-2)
ProcedureReturn r.s
EndProcedure
 
If OpenConsole()
n=5
r.s=FloydsTriangle(n)
PrintN(r.s)
 
n=14
r.s=FloydsTriangle(n)
PrintN(r.s)
 
Print(#crlf$ + #crlf$ + "Press ENTER to exit"): Input()
CloseConsole()
EndIf

Sample Output

 1
 2  3
 4  5  6
 7  8  9 10
11 12 13 14 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

[edit] 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
>>>

Alternately (using the mathematical formula for each row directly):

def floyd(rowcount=5):
return [list(range(i*(i-1)//2+1, i*(i+1)//2+1))
for i in range(1, rowcount+1)]

[edit] Racket

 
#lang racket
(require math)
 
(define (tri n)
(if (zero? n) 0 (triangle-number n)))
 
(define (floyd n)
(define (width x) (string-length (~a x)))
(define (~n x c) (~a x
#:width (width (+ (tri (- n 1)) 1 c))
#:align 'right #:left-pad-string " "))
(for ([r n])
(for ([c (+ r 1)])
(display (~a (~n (+ (tri r) 1 c) c) " ")))
(newline)))
 
(floyd 5)
(floyd 14)
 

Output:

 1 
 2  3 
 4  5  6 
 7  8  9 10 
11 12 13 14 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 

[edit] REXX

[edit] version 1

 
/* REXX ***************************************************************
* Parse Arg rowcount
* 12.07.2012 Walter Pachl - translated from Python
**********************************************************************/

Parse Arg rowcount
col=0
ll='' /* last line of triangle */
Do j=rowcount*(rowcount-1)/2+1 to rowcount*(rowcount+1)/2
col=col+1 /* column number */
ll=ll j /* build last line */
len.col=length(j) /* remember length of column */
End
Do i=1 To rowcount-1 /* now do and output the rest */
ol=''
col=0
Do j=i*(i-1)/2+1 to i*(i+1)/2 /* elements of line i */
col=col+1
ol=ol right(j,len.col) /* element in proper length */
end
Say ol /* output ith line */
end
Say ll /* output last line */
 

Output:

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

n=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 

[edit] version 2

This REXX version uses a simple formula to calculate the maximum value (triangle element) displayed.

/*REXX pgm constructs & displays Floyd's triangle for any number of rows*/
parse arg rows .; if rows=='' then rows=5 /*Not specified? Use default*/
maxV = rows * (rows+1) % 2 /*calculate the max value. */
say 'displaying a' rows "row Floyd's triangle:"; say /*show header*/
#=1; do r=1 for rows; i=0; _= /*row by row.*/
do #=# for r; i=i+1 /*start a row*/
_ = _ right(#, length(maxV-rows+i)) /*build a row*/
end /*#*/ /*row is done*/
say substr(_,2) /*suppress the 1st leading blank,*/
end /*r*/ /* [↑] introduced by 1st abutt.*/
/*stick a fork in it, we're done.*/

output when using the default input:

displaying a 5 row Floyd's triangle:

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

output when using the input of:   14

displaying a 14 row Floyd's triangle:

 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

output (only showing the last row) when using the input of: 45

  ··· 44 rows not shown ··· 
991  992  993  994  995  996  997  998  999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035

[edit] version 3, hexadecimal

/*REXX pgm displays Floyd's triangle for any number of rows  in base 16.*/
parse arg rows .; if rows=='' then rows=6 /*Not specified? Use default*/
maxV = rows * (rows+1) % 2 /*calculate the max value. */
say 'displaying a' rows "row Floyd's triangle in base 16:"; say /*hdr*/
#=1; do r=1 for rows; i=0; _= /*row by row.*/
do #=# for r; i=i+1 /*start a row*/
_ = _ right(d2x(#), length(d2x(maxV - rows + i)))
end /*#*/ /* [↑] the triangle row is done.*/
say substr(_,2) /*suppress the 1st leading blank,*/
end /*r*/ /* [↑] introduced by 1st abutt.*/
/*stick a fork in it, we're done.*/

output when using the default input:

displaying a 6 row Floyd's triangle in base 16:

 1
 2  3
 4  5  6
 7  8  9  A
 B  C  D  E  F
10 11 12 13 14 15

output when using the input of:   23

displaying a 23 row Floyd's triangle in base 16:

 1
 2  3
 4  5   6
 7  8   9   A
 B  C   D   E   F
10 11  12  13  14  15
16 17  18  19  1A  1B  1C
1D 1E  1F  20  21  22  23  24
25 26  27  28  29  2A  2B  2C  2D
2E 2F  30  31  32  33  34  35  36  37
38 39  3A  3B  3C  3D  3E  3F  40  41  42
43 44  45  46  47  48  49  4A  4B  4C  4D  4E
4F 50  51  52  53  54  55  56  57  58  59  5A  5B
5C 5D  5E  5F  60  61  62  63  64  65  66  67  68  69
6A 6B  6C  6D  6E  6F  70  71  72  73  74  75  76  77  78
79 7A  7B  7C  7D  7E  7F  80  81  82  83  84  85  86  87  88
89 8A  8B  8C  8D  8E  8F  90  91  92  93  94  95  96  97  98  99
9A 9B  9C  9D  9E  9F  A0  A1  A2  A3  A4  A5  A6  A7  A8  A9  AA  AB
AC AD  AE  AF  B0  B1  B2  B3  B4  B5  B6  B7  B8  B9  BA  BB  BC  BD  BE
BF C0  C1  C2  C3  C4  C5  C6  C7  C8  C9  CA  CB  CC  CD  CE  CF  D0  D1  D2
D3 D4  D5  D6  D7  D8  D9  DA  DB  DC  DD  DE  DF  E0  E1  E2  E3  E4  E5  E6  E7
E8 E9  EA  EB  EC  ED  EE  EF  F0  F1  F2  F3  F4  F5  F6  F7  F8  F9  FA  FB  FC  FD
FE FF 100 101 102 103 104 105 106 107 108 109 10A 10B 10C 10D 10E 10F 110 111 112 113 114

[edit] version 4, up to base 90

This REXX version could be extended to even higher bases, all that is needed is to append more viewable characters to express "higher" numerals.

/*REXX pgm displays Floyd's triangle for any  # of rows  up to base  90.*/
parse arg rows b .; if rows=='' then rows=5 /*Not given? Use default.*/
if b=='' then b=10 /*use base 10 if not given.*/
maxV = rows * (rows+1) % 2 /*calculate the max value. */
say 'displaying a' rows "row Floyd's triangle in base" b':'; say
#=1; do r=1 for rows; i=0; _= /*row by row.*/
do #=# for r; i=i+1 /*start a row*/
_ = _ right(base(#, b), length(base(maxV-rows+i, b)))
end /*#*/ /*row is done*/
say substr(_,2) /*suppress the 1st leading blank,*/
end /*r*/ /* [↑] introduced by 1st abutt.*/
exit /*stick a fork in it, we're done.*/
/*──────────────────────────────────BASE subroutine─────────────────────*/
base: procedure; parse arg x 1 ox,toB,inB /*get number, toBase, inBase*/
@abc='abcdefghijklmnopqrstuvwxyz' /*lowercase Latin alphabet. */
@abcU=@abc; upper @abcU /*go whole hog and extend 'em. */
@@@='0123456789'@abc || @abcU /*prefix 'em with numeric digits.*/
@@@=@@@'<>[]{}()?~!@#$%^&*_=|\/;:¢¬≈' /*add some special chars as well.*/
/*handles up to base 90, special chars must be viewable.*/
numeric digits 1000 /*what the hey, support gihugeics*/
maxB=length(@@@) /*max base (radix) supported here*/
if toB=='' | toB==',' then toB=10 /*if skipped, assume default (10)*/
if inB=='' | inB==',' then inB=10 /* " " " " " */
if inB<2 | inb>maxB then call erb 'inBase',inB /*bad boy inBase.*/
if toB<2 | tob>maxB then call erb 'toBase',toB /* " " toBase.*/
if x=='' then call erm /* " " number.*/
sigX=left(x,1); if pos(sigX,"-+")\==0 then x=substr(x,2) /*X has sign?*/
else sigX= /*no sign. */
#=0; do j=1 for length(x) /*convert X, base inB ──► base 10*/
_=substr(x, j, 1) /*pick off a numeral from X. */
v=pos(_, @@@) /*get the value of this "digit". */
if v==0 | v>inB then call erd x,j,inB /*illegal "digit"? */
#=#*inB+v-1 /*construct new num, dig by dig. */
end /*j*/
y=
do while #>=toB /*convert #, base 10 ──► base toB*/
y=substr(@@@, (#//toB)+1, 1)y /*construct the number for output*/
#=#%toB /*··· and whittle # down also. */
end /*while #≥toB*/
 
y=sigX || substr(@@@, #+1, 1)y /*prepend the sign if it existed.*/
return y /*rturn the number in base toB. */
/*──────────────────────────────────error subroutines───────────────────*/
erb: call ser 'illegal' arg(2) "base:" arg(1) "must be in range: 2──►" maxB
erd: call ser 'illegal "digit" in' x":" _
erm: call ser 'no argument specified.'
ser: say; say '*** error! ***'; say arg(1); say; exit 13

output when using the input of:   6 2

displaying a 6 row Floyd's triangle in base 2:

    1
   10    11
  100   101   110
  111  1000  1001  1010
 1011  1100  1101  1110  1111
10000 10001 10010 10011 10100 10101

output when using the input of:   23 2

displaying a 12 row Floyd's triangle in base 2:

      1
     10      11
    100     101     110
    111    1000    1001    1010
   1011    1100    1101    1110    1111
  10000   10001   10010   10011   10100   10101
  10110   10111   11000   11001   11010   11011   11100
  11101   11110   11111  100000  100001  100010  100011  100100
 100101  100110  100111  101000  101001  101010  101011  101100  101101
 101110  101111  110000  110001  110010  110011  110100  110101  110110  110111
 111000  111001  111010  111011  111100  111101  111110  111111 1000000 1000001 1000010
1000011 1000100 1000101 1000110 1000111 1001000 1001001 1001010 1001011 1001100 1001101 1001110

[edit] Ruby

def floyd(rows)
max = (rows * (rows + 1)) / 2
widths = ((max - rows + 1)..max).map {|n| n.to_s.length + 1}
n = 0
rows.times do |r|
puts (0..r).map {|i| n += 1; "%#{widths[i]}d" % n}.join
end
end
 
floyd(5)
floyd(14)
Output:
  1
  2  3
  4  5  6
  7  8  9 10
 11 12 13 14 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

[edit] Run BASIC

This example does not show the output mentioned in the task description on this page (or a page linked to from here). There should be only one space between the numbers in the last row. Please ensure that it meets all task requirements and remove this message.
Note that phrases in task descriptions such as "print and display" and "print and show" for example, indicate that (reasonable length) output be a part of a language's solution.


input "   Number of rows:"; rows
for r = 1 to rows ' r = rows
for c = 1 to r ' c = columns
j = j + 1
print using("#####",j);" ";
next c
print
next r
  Number of rows:?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

[edit] Scala

def floydstriangle( n:Int ) { 
val s = (1 to n)
val t = s map {i => (s take(i-1) sum) + 1}
 
(s zip t) foreach { n =>
var m = n._2;
 
for( i <- 0 until n._1 ) {
val w = (t.last + i).toString.length + 1 // Column width from last row
print(" " + m takeRight w )
m+=1
}
 
print("\n")
}
}
 
// Test
floydstriangle(5)
floydstriangle(14)
Output:
  1
  2  3
  4  5  6
  7  8  9 10
 11 12 13 14 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

[edit] Seed7

$ include "seed7_05.s7i";
 
const proc: writeFloyd (in integer: rows) is func
local
var integer: number is 1;
var integer: numBeforeLastLine is 0;
var integer: line is 0;
var integer: column is 0;
begin
numBeforeLastLine := rows * pred(rows) div 2;
for line range 1 to rows do
for column range 1 to line do
if column <> 1 then
write(" ");
end if;
write(number lpad length(str(numBeforeLastLine + column)));
incr(number);
end for;
writeln;
end for;
end func;
 
const proc: main is func
begin
writeFloyd(5);
writeFloyd(14);
end func;

Output:

 1
 2  3
 4  5  6
 7  8  9 10
11 12 13 14 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

[edit] Tcl

proc floydTriangle n {
# Compute the column widths
for {set i [expr {$n*($n-1)/2+1}]} {$i <= $n*($n+1)/2} {incr i} {
lappend w [string length $i]
}
# Print the triangle
for {set i 0; set j 1} {$j <= $n} {incr j} {
for {set p -1; set k 0} {$k < $j} {incr k} {
puts -nonewline [format "%*d " [lindex $w [incr p]] [incr i]]
}
puts ""
}
}
 
# Demonstration
puts "Floyd 5:"
floydTriangle 5
puts "Floyd 14:"
floydTriangle 14
Output:
Floyd 5:
 1 
 2  3 
 4  5  6 
 7  8  9 10 
11 12 13 14 15 
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 

[edit] TXR

@(do
(defun flotri (n)
(let* ((last (trunc (* n (+ n 1)) 2))
(colw (mapcar [chain tostring length]
(range (- last n -1) last)))
(x 0))
(each ((r (range* 0 n)))
(each ((c (range 0 r)))
(format t " ~*a" [colw c] (inc x)))
(put-line))))
 
(defun usage (msg)
(put-line `error: @msg`)
(put-line `usage:\n@(ldiff *full-args* *args*) <smallish-positive-integer>`)
(exit 1))
 
(tree-case *args*
((num blah . etc) (usage "too many arguments"))
((num) (flotri (int-str num)))
(() (usage "need an argument"))))
Output:
$ txr floyds-triangle.txr 
error: need an argument
usage:
txr floyds-triangle.txr <smallish-positive-integer>
$ txr floyds-triangle.txr 1 2
error: too many arguments
usage:
txr floyds-triangle.txr <smallish-positive-integer>
$ txr floyds-triangle.txr 5
  1
  2  3
  4  5  6
  7  8  9 10
 11 12 13 14 15
$ txr floyds-triangle.txr 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

[edit] VBScript

Works with: Windows Script Host version *
 
' Read the number of rows to use..
intRows = WScript.StdIn.ReadLine
 
' Get the first number of the final row so we can calculate widths...
intLastRowStart = (intRows ^ 2 - intRows) \ 2 + 1
 
For i = 1 To intRows
intLastRow = intLastRowStart
For j = 1 To i
k = k + 1
WScript.StdOut.Write Space(Len(intLastRow) - Len(k)) & k & " "
intLastRow = intLastRow + 1
Next
WScript.StdOut.WriteLine ""
Next
 

[edit] XPL0

include c:\cxpl\codes;  \include 'code' declarations
 
func IntLen(N); \Return number of digits in a positive integer
int N;
int I;
for I:= 1 to 20 do
[N:= N/10; if N=0 then return I];
 
proc Floyd(N); \Display Floyd's triangle
int N;
int M, Row, Col;
real F;
[M:= (N-1+1)*(N-1)/2; \last Floyd number on second to last row
F:= 1.0; \Floyd number counter
for Row:= 1 to N do
[for Col:= 1 to Row do
[Format(IntLen(M+Col)+1, 0); RlOut(0, F); F:= F+1.0];
CrLf(0);
];
]; \Floyd
 
[Floyd(5);
Floyd(14);
]

Output:

  1
  2  3
  4  5  6
  7  8  9 10
 11 12 13 14 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

[edit] zkl

Format last line and then fit each line to that format (which is wider than terminal width before formating breaks down (at 10 digit numbers)):

fcn lcNum(row){(row*(row+1)/2+1)}   // lazy caterer's sequence
fcn floydsTriangle(rows){
fmt:=[lcNum(rows-1)..lcNum(rows)-1].pump(String,fcn(n){
String("%",n.toString().len(),"d ")}); // eg "%2d %2d %3d %3d"
foreach row in (rows){
ns:=[lcNum(row)..lcNum(row+1)-1].walk(); // eg L(4.5,6)
fmt[0,ns.len()*4].fmt(ns.xplode()).println(); // eg "%2d %2d %2d ".fmt(4,5,6)
}
}
floydsTriangle(5); println();
floydsTriangle(14);
Output:
 1 
 2  3 
 4  5  6 
 7  8  9 10 
11 12 13 14 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 
Personal tools
Namespaces

Variants
Actions
Community
Explore
Misc
Toolbox