# Floyd's triangle

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   1     (unity)
• 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
```

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 mono-space font, the numbers line up in vertical columns as shown and that only one space separates numbers of the last row.

## 360 Assembly

A very concise coding, an illustration of CISC power of the S/360 operation codes. Also an example of the use of EDMK and EX instructions. For macro usage see Structured Macros .

`*        Floyd's triangle          21/06/2018FLOYDTRI PROLOG         L      R5,NN              nn         BCTR   R5,0               -1         M      R4,NN              nn*(nn-1)         SRA    R5,1               /2         A      R5,NN              m=(nn*(nn-1))/2+nn; max_value         CVD    R5,XDEC            binary to packed decimal (PL8)         EDMK   ZN,XDEC+4          packed dec (PL4) to char (CL8)         S      R1,=A(ZN)          r1=number of spaces         L      R9,=A(L'ZN+1)      length(zn08)+1         SR     R9,R1              s=length(m)+1         SR     R8,R8              k=0         LA     R6,1               i=1       DO WHILE=(C,R6,LE,NN)       do i=1 to nn         LA     R10,PG               pgi=0         LA     R7,1                 j=1       DO WHILE=(CR,R7,LE,R6)          do j=1 to i         LA     R8,1(R8)               k=k+1         XDECO  R8,XDEC                k         LA     R11,XDEC+12            +12         SR     R11,R9                 -s         LR     R2,R9                  s         BCTR   R2,0                   -1         EX     R2,MVCX                mvc @PG+pgi,@XDEC+12-s,LEN=s         AR     R10,R9                 pgi+=s         LA     R7,1(R7)               j++       ENDDO    ,                    enddo j         XPRNT  PG,L'PG              print buffer         LA     R6,1(R6)             i++       ENDDO    ,                  enddo i         EPILOGMVCX     MVC    0(0,R10),0(R11)    mvc PG,XDECNN       DC     F'14'              number of rowsPG       DC     CL80' '            bufferXDEC     DS     CL12               tempZN       DC     X'4020202020202020'  mask CL8 7num         YREGS         END    FLOYDTRI`
Output:
```  1
2  3
4  5  6
7  8  9 10
11 12 13 14 15
```
Output:
```   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
```

` with Ada.Text_IO, Ada.Integer_Text_IO, Ada.Command_Line; procedure Floyd_Triangle is  rows : constant Natural := Natural'Value(Ada.Command_Line.Argument(1));begin  for r in 1..rows loop    for i in 1..r loop       Ada.Integer_Text_IO.put (r*(r-1)/2+i, Width=> Natural'Image(rows*(rows-1)/2+i)'Length);     end loop;    Ada.Text_IO.New_Line;  end loop;end Floyd_Triangle; `
Output:
```> ./floyd_triangle_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
```

## 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
```

## ALGOL W

Translation of: ALgOL_68
`begin    % prints a Floyd's Triangle with n lines                                  %    procedure floydsTriangle ( integer value n ) ;    begin        % the triangle should be left aligned with the individual numbers     %        % right-aligned with only one space before the number in the final    %        % row                                                                 %        % calculate the highest number that will be printed                   %        % ( the sum of the integeregers 1, 2, ... n )                         %        integer array widths( 1 :: n );        integer maxNumber, number;        maxNumber := ( n * ( n + 1 ) ) div 2;        % determine the widths required to print the numbers of the final row %        number := maxNumber;        for col := n step -1 until 1 do begin            integer v, w;            w      := 0;            v      := number;            number := number - 1;            while v > 0 do begin                w  := w + 1;                v  := v div 10            end while_v_gt_0 ;            widths( col ) := w        end for_col;        % print the triangle                                                  %        number := 0;        for row := 1 until n do begin            for col := 1 until row do begin                number := number + 1;                writeon( i_w := widths( col ), s_w := 0, " ", number )            end for_col ;            write()        end for_row     end; % floyds triangle %     floydsTriangle(  5 );    write();    floydsTriangle( 14 ) end.`
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
```

## AppleScript

Translation of: JavaScript
(mapAccumL versions)
`-- FLOYDs TRIANGLE ----------------------------------------------------------- -- floyd :: Int -> [[Int]]on floyd(n)    script floydRow        on |λ|(start, row)            {start + row + 1, enumFromTo(start, start + row)}        end |λ|    end script     snd(mapAccumL(floydRow, 1, enumFromTo(0, n - 1)))end floyd -- showFloyd :: [[Int]] -> Stringon showFloyd(xss)    set ws to map(compose({my succ, my |length|, my show}), |last|(xss))     script aligned        on |λ|(xs)            script pad                on |λ|(w, x)                    justifyRight(w, space, show(x))                end |λ|            end script             concat(zipWith(pad, ws, xs))        end |λ|    end script     unlines(map(aligned, xss))end showFloyd  -- TEST ----------------------------------------------------------------------on run    script test        on |λ|(n)            showFloyd(floyd(n)) & linefeed        end |λ|    end script     unlines(map(test, {5, 14}))end run  -- GENERIC FUNCTIONS --------------------------------------------------------- -- compose :: [(a -> a)] -> (a -> a)on compose(fs)    script        on |λ|(x)            script                on |λ|(f, a)                    mReturn(f)'s |λ|(a)                end |λ|            end script             foldr(result, x, fs)        end |λ|    end scriptend compose -- concat :: [[a]] -> [a] | [String] -> Stringon concat(xs)    if length of xs > 0 and class of (item 1 of xs) is string then        set acc to ""    else        set acc to {}    end if    repeat with i from 1 to length of xs        set acc to acc & item i of xs    end repeat    accend concat -- enumFromTo :: Int -> Int -> [Int]on enumFromTo(m, n)    if n < m then        set d to -1    else        set d to 1    end if    set lst to {}    repeat with i from m to n by d        set end of lst to i    end repeat    return lstend enumFromTo -- foldl :: (a -> b -> a) -> a -> [b] -> aon foldl(f, startValue, xs)    tell mReturn(f)        set v to startValue        set lng to length of xs        repeat with i from 1 to lng            set v to |λ|(v, item i of xs, i, xs)        end repeat        return v    end tellend foldl -- foldr :: (b -> a -> a) -> a -> [b] -> aon foldr(f, startValue, xs)    tell mReturn(f)        set v to startValue        set lng to length of xs        repeat with i from lng to 1 by -1            set v to |λ|(item i of xs, v, i, xs)        end repeat        return v    end tellend foldr -- intercalate :: Text -> [Text] -> Texton intercalate(strText, lstText)    set {dlm, my text item delimiters} to {my text item delimiters, strText}    set strJoined to lstText as text    set my text item delimiters to dlm    return strJoinedend intercalate -- justifyRight :: Int -> Char -> Text -> Texton justifyRight(n, cFiller, strText)    if n > length of strText then        text -n thru -1 of ((replicate(n, cFiller) as text) & strText)    else        strText    end ifend justifyRight -- last :: [a] -> aon |last|(xs)    if length of xs > 0 then        item -1 of xs    else        missing value    end ifend |last| -- length :: [a] -> Inton |length|(xs)    length of xsend |length| -- map :: (a -> b) -> [a] -> [b]on map(f, xs)    tell mReturn(f)        set lng to length of xs        set lst to {}        repeat with i from 1 to lng            set end of lst to |λ|(item i of xs, i, xs)        end repeat        return lst    end tellend map -- 'The mapAccumL function behaves like a combination of map and foldl;-- it applies a function to each element of a list, passing an-- accumulating parameter from left to right, and returning a final-- value of this accumulator together with the new list.' (see Hoogle) -- mapAccumL :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])on mapAccumL(f, acc, xs)    script        on |λ|(a, x)            tell mReturn(f) to set pair to |λ|(item 1 of a, x)            [item 1 of pair, (item 2 of a) & {item 2 of pair}]        end |λ|    end script     foldl(result, [acc, []], xs)end mapAccumL -- min :: Ord a => a -> a -> aon min(x, y)    if y < x then        y    else        x    end ifend min -- Lift 2nd class handler function into 1st class script wrapper-- mReturn :: Handler -> Scripton mReturn(f)    if class of f is script then        f    else        script            property |λ| : f        end script    end ifend mReturn -- Egyptian multiplication - progressively doubling a list, appending-- stages of doubling to an accumulator where needed for binary-- assembly of a target length -- replicate :: Int -> a -> [a]on replicate(n, a)    set out to {}    if n < 1 then return out    set dbl to {a}     repeat while (n > 1)        if (n mod 2) > 0 then set out to out & dbl        set n to (n div 2)        set dbl to (dbl & dbl)    end repeat    return out & dblend replicate -- snd :: (a, b) -> bon snd(xs)    if class of xs is list and length of xs > 1 then        item 2 of xs    else        missing value    end ifend snd -- show :: a -> Stringon show(e)    set c to class of e    if c = list then        script serialized            on |λ|(v)                show(v)            end |λ|        end script         "{" & intercalate(", ", map(serialized, e)) & "}"    else if c = record then        script showField            on |λ|(kv)                set {k, v} to kv                k & ":" & show(v)            end |λ|        end script         "{" & intercalate(", ", ¬            map(showField, zip(allKeys(e), allValues(e)))) & "}"    else if c = date then        ("date \"" & e as text) & "\""    else if c = text then        "\"" & e & "\""    else        try            e as text        on error            ("«" & c as text) & "»"        end try    end ifend show -- succ :: Int -> Inton succ(x)    x + 1end succ -- unlines :: [String] -> Stringon unlines(xs)    intercalate(linefeed, xs)end unlines -- zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]on zipWith(f, xs, ys)    set lng to min(length of xs, length of ys)    set lst to {}    tell mReturn(f)        repeat with i from 1 to lng            set end of lst to |λ|(item i of xs, item i of ys)        end repeat        return lst    end tellend zipWith`
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```

Or, defining only the relationship between successive terms:

`-- floyd :: [Int] -> [Int]on floyd(xs)    set n to succ(length of xs)    if n < 2 then        {1}    else        enumFromTo(succ(n * (pred(n)) div 2), n * (succ(n)) div 2)    end ifend floyd  -- floydN :: Int -> [[Int]]on floydN(n)    take(n, iterate(floyd, {1}))end floydN  -- showFloyd :: [[Int]] -> Stringon showFloyd(xs)    script        on |λ|(ns)            script                on |λ|(n)                    justifyRight(4, space, n as string)                end |λ|            end script            concat(map(result, ns))        end |λ|    end script    unlines(map(result, xs))end showFloyd  -- TEST -------------------------------------------------------------on run     showFloyd(floydN(5)) end run  -- GENERIC ABSTRACTIONS --------------------------------------- -- concat :: [[a]] -> [a]-- concat :: [String] -> Stringon concat(xs)    set lng to length of xs    if 0 < lng and string is class of (item 1 of xs) then        set acc to ""    else        set acc to {}    end if    repeat with i from 1 to lng        set acc to acc & item i of xs    end repeat    accend concat -- enumFromTo :: Int -> Int -> [Int]on enumFromTo(m, n)    if m ≤ n then        set lst to {}        repeat with i from m to n            set end of lst to i        end repeat        return lst    else        return {}    end ifend enumFromTo -- iterate :: (a -> a) -> a -> Gen [a]on iterate(f, x)    script        property v : missing value        property g : mReturn(f)'s |λ|        on |λ|()            if missing value is v then                set v to x            else                set v to g(v)            end if            return v        end |λ|    end scriptend iterate  -- justifyRight :: Int -> Char -> String -> Stringon justifyRight(n, cFiller, strText)    if n > length of strText then        text -n thru -1 of ((replicate(n, cFiller) as text) & strText)    else        strText    end ifend justifyRight  -- length :: [a] -> Inton |length|(xs)    set c to class of xs    if list is c or string is c then        length of xs    else        (2 ^ 29 - 1) -- (maxInt - simple proxy for non-finite)    end ifend |length| -- map :: (a -> b) -> [a] -> [b]on map(f, xs)    tell mReturn(f)        set lng to length of xs        set lst to {}        repeat with i from 1 to lng            set end of lst to |λ|(item i of xs, i, xs)        end repeat        return lst    end tellend map -- min :: Ord a => a -> a -> aon min(x, y)    if y < x then        y    else        x    end ifend min -- Lift 2nd class handler function into 1st class script wrapper -- mReturn :: First-class m => (a -> b) -> m (a -> b)on mReturn(f)    if class of f is script then        f    else        script            property |λ| : f        end script    end ifend mReturn -- pred :: Int -> Inton pred(x)    (-1) + xend pred -- Egyptian multiplication - progressively doubling a list, appending-- stages of doubling to an accumulator where needed for binary -- assembly of a target length-- replicate :: Int -> a -> [a]on replicate(n, a)    set out to {}    if n < 1 then return out    set dbl to {a}     repeat while (n > 1)        if (n mod 2) > 0 then set out to out & dbl        set n to (n div 2)        set dbl to (dbl & dbl)    end repeat    return out & dblend replicate -- succ :: Int -> Inton succ(x)    1 + xend succ -- take :: Int -> [a] -> [a]-- take :: Int -> String -> Stringon take(n, xs)    set c to class of xs    if list is c then        if 0 < n then            items 1 thru min(n, length of xs) of xs        else            {}        end if    else if string is c then        if 0 < n then            text 1 thru min(n, length of xs) of xs        else            ""        end if    else if script is c then        set ys to {}        repeat with i from 1 to n            set v to xs's |λ|()            if missing value is v then                return ys            else                set end of ys to v            end if        end repeat        return ys    else        missing value    end ifend take -- unlines :: [String] -> Stringon unlines(xs)    set {dlm, my text item delimiters} to ¬        {my text item delimiters, linefeed}    set str to xs as text    set my text item delimiters to dlm    strend unlines`
Output:
```   1
2   3
4   5   6
7   8   9  10
11  12  13  14  15```

## 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```

## 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
```

## Batch File

` @echo off call:floyd 5echo.call:floyd 14pause>nulexit /b :floydsetlocal enabledelayedexpansionset iterations=%1set startn=1set endn=1 for /l %%i in (1,1,%iterations%) do (  for /l %%j in (!startn!,1,!endn!) do (    set lastnum=%%j    set /a startn=%%j+1  )  set /a endn=!startn!+%%i) call:getlength %startn%set digits=%errorlevel% set startn=1set endn=1 for /l %%i in (1,1,%iterations%) do (  set "line="  for /l %%j in (!startn!,1,!endn!) do (    set "space="    call:getlength %%j    set /a sparespace=%digits%-!errorlevel!    for /l %%k in (0,1,!sparespace!) do set "space=!space! "     set line=!line!!space!%%j    set /a startn=%%j+1  )  echo !line!  set /a endn=!startn!+%%i)exit /b :getlengthsetlocal enabledelayedexpansionset offset=0set string=%1:floydloopif "!string:~%offset%,1!"=="" endlocal && exit /b %offset%set /a offset+=1goto floydloop `
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
```

## BASIC

### Applesoft BASIC

Line `150,160` creates a vector of the length of all entries is the last row. These values are used in line `210,220` to put the cursor at the correct horizontal position.

`  100 : 110  REM  FLOYD'S TRIANGLE 120 : 130  DEF  FN Q(A) =  INT ( LOG (A) /  LOG (10)) + 1                 140 N = 14 150  DIM P(N): P(0) =  - 1: FOR J = 1 TO N: I = (N * N - N) / 2 + J                               160 P(J) = P(J - 1) + FN Q(I) + 1: NEXT J                           200  FOR R = 1 TO N: FOR C = 1 TO R                                   210 NR = NR + 1:COL = P(C) - ( FN Q(NR) - 1)                          220  HTAB COL: PRINT NR;: NEXT C 230  PRINT : NEXT R                     `
Output:
```]RUN
1
2  3
4  5  6
7  8  9 10
11 12 13 14 15```
```]RUN
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```

### 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
```

### IS-BASIC

`100 PROGRAM "FloydT.bas"110 LET N=14:LET J=1120 TEXT 80130 FOR I=1 TO N140   FOR J=J TO J+I-1150     PRINT USING " ###":J;160   NEXT170   PRINT180 NEXT`

### MasmBasic

`include \masm32\MasmBasic\MasmBasic.inc  SetGlobals rows, columns, ct, maxrows=4  Init  .Repeat	For_ rows=0 To maxrows		For_ columns=0 To rows			inc ct			Print Str\$("%__i", ct)			.if columns>6				Print " "			.endif		Next		Print	Next	Print	Clr ct	add maxrows, 9	; 4+9=13  .Until maxrows>13  InkeyEndOfCode`
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```

## Befunge

`0" :seniL">:#,_&>:!#@_55+,:00p::1+*2/1vvv+1:\-1p01g5-\g00<v`*9"o"\+`"c"\`9:::_\$>>\:::9`\"c"`+\9v:>>+00g1-:00p5p1-00g^<v\*84-\g01+`*"o"<^<<p00:+1\+1/2*+1:::\^>:#\1#,-#:\_\$\$.\:#^_\$\$>>1+\1-55+,:!#@_`
Output:
```Lines: 5

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

## 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```

## 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.

## 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```

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

## Clojure

I didn't translete this, it's from my own creation.

` (defn TriangleList [n]  (let [l (map inc (range))]    (loop [l l x 1 nl []]      (if (= n (count nl))        nl        (recur (drop x l) (inc x) (conj nl (take x l))))))) (defn TrianglePrint [n]  (let [t (TriangleList n)        m (count (str (last (last t))))        f (map #(map str %) t)        l (map #(map (fn [x] (if (> m (count x))                               (str (apply str (take (- m (count x))                                                     (repeat " "))) x)                               x)) %) f)        e (map #(map (fn [x] (str " " x)) %) l)]    (map #(println (apply str %)) e))) `

By Average-user.

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

(TrianglePrint 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
```

## CoffeeScript

Translation of: Kotlin
`triangle = (array) -> for n in array    console.log "#{n} rows:"    printMe = 1    printed = 0    row = 1    to_print = ""    while row <= n        cols = Math.ceil(Math.log10(n * (n - 1) / 2 + printed + 2.0))        p = ("" + printMe).length        while p++ <= cols            to_print += ' '        to_print += printMe + ' '        if ++printed == row            console.log to_print            to_print = ""            row++            printed = 0        printMe++ triangle [5, 14]`

Output as Kotlin.

## Common Lisp

### 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 "~%")))))`

### 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
```

## 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```

## Elixir

`defmodule Floyd do  def triangle(n) do    max = trunc(n * (n + 1) / 2)    widths = for m <- (max - n + 1)..max, do: (m |> Integer.to_string |> String.length) + 1    format = Enum.map(widths, fn wide -> "~#{wide}w" end) |> List.to_tuple    line(n, 0, 1, format)  end   def line(n, n, _, _), do: :ok  def line(n, i, count, format) do    Enum.each(0..i, fn j -> :io.fwrite(elem(format,j), [count+j]) end)    IO.puts ""    line(n, i+1, count+i+1, format)  endend Floyd.triangle(5)Floyd.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
```

## 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
```

## ERRE

` PROGRAM FLOYD !! for rosettacode.org! BEGIN  N=14  NUM=1  LAST=(N^2-N+2) DIV 2  FOR ROW=1 TO N DO    FOR J=1 TO ROW DO       US\$=STRING\$(LEN(STR\$(LAST-1+J))-1,"#")       WRITE(US\$;NUM;)       PRINT(" ";)       NUM+=1    END FOR    PRINT  END FOREND PROGRAM `

Example for n=14

Output:
``` 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
```

## 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```

## Factor

`USING: io kernel math math.functions math.ranges prettyprintsequences ;IN: rosetta-code.floyds-triangle : floyd. ( n -- )    [ dup 1 - * 2 / 1 + dup 1 ] [ [1,b] ] bi    [        [            2dup [ log10 1 + >integer ] [email protected] -            [ " " write ] times dup pprint bl [ 1 + ] [email protected]        ] times nl [ drop dup ] dip    ] each nl 3drop ; 5 14 [ floyd. ] [email protected]`
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
```

## 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 ; `

## 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 `

## FreeBASIC

`' version 19-09-2015' compile with: fbc -s console Sub pascal_triangle(n As UInteger)     Dim As UInteger a = 1, b, i, j, switch = n + 1    Dim As String frmt, frmt_1, frmt_2     ' last number of the last line    i = (n * (n + 1)) \ 2    frmt_2 = String(Len(Str(i)) + 1, "#")    ' first number of the last line    i = ((n - 1) * n) \ 2 + 1    frmt_1 = String(Len(Str(i)) + 1, "#")     ' we have 2 different formats strings    ' find the point where we have to make the switch    If frmt_1 <> frmt_2 Then        j = i + 1        While Len(Str(i)) = Len(Str(J))            j =  j + 1        Wend        switch = j - i    End If     Print "output for "; Str(n) : Print    For i = 1 To n        frmt = frmt_1        b = (i * (i + 1)) \ 2        For j = a To b            ' if we have the switching point change format string            If j - a = switch Then frmt = frmt_2            Print Using frmt; j;        Next j        Print        a = b + 1    Next i    Print End Sub ' ------=< MAIN >=------ pascal_triangle(5) pascal_triangle(14)  ' empty keyboard bufferWhile Inkey <> "" : WendPrint : Print "hit any key to end program"SleepEnd`
Output:
```output for 5             output for 14

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

## Gambas

`Public Sub Main()Dim siCount, siNo, siCounter As ShortDim siLine As Short = 1Dim siInput As Short[] = [5, 14] For siCount = 0 To siInput.Max  Print "Floyd's triangle to " & siInput[siCount] & " lines"  Do    Inc siNo    Inc siCounter    Print Format(siNo, "####");      If siLine = siCounter Then         Print         Inc siLine        siCounter = 0      End If    If siLine - 1 = siInput[siCount] Then Break  Loop  siLine = 1  siCounter = 0  siNo = 0  PrintNext End`

Output:

```Floyd's triangle to 5 lines
1
2   3
4   5   6
7   8   9  10
11  12  13  14  15

Floyd's triangle to 14 lines
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
```

## 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
```

Program

`import Control.Monad (liftM2) floydTriangle =  liftM2    (zipWith (liftM2 (.) enumFromTo ((pred .) . (+))))    (scanl (+) 1)    id    [1 ..] alignR :: Int -> Integer -> StringalignR n = (\s -> replicate (n - length s) ' ' ++ s) . show formatFT :: Int -> IO ()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 1011 12 13 14 15 *Main> formatFT 14 1 2  3 4  5  6 7  8  9 1011 12 13 14 1516 17 18 19 20 2122 23 24 25 26 27 2829 30 31 32 33 34 35 3637 38 39 40 41 42 43 44  4546 47 48 49 50 51 52 53  54  5556 57 58 59 60 61 62 63  64  65  6667 68 69 70 71 72 73 74  75  76  77  7879 80 81 82 83 84 85 86  87  88  89  90  9192 93 94 95 96 97 98 99 100 101 102 103 104 105`

Or, simplifying a little by delegating the recursion scheme to mapAccumL

`import Data.List (mapAccumL)import Control.Arrow ((&&&)) floyd :: Int -> [[Int]]floyd n =  snd \$  mapAccumL    (\a x ->        ((succ &&& enumFromTo a) (a + x)))    1    [0 .. pred n] -- TEST -------------------------------------showFloyd :: [[Int]] -> StringshowFloyd xs =  let padRight n = length >>= (<\$> mappend (replicate n ' ')) . drop  in unlines \$     (concat .      zipWith ((. show) . padRight) ((succ . length . show) <\$> last xs)) <\$>     xs main :: IO ()main = mapM_ putStrLn \$ (showFloyd . floyd) <\$> [5, 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```

Or, defining just the relationship between successive terms:

`floyd :: [Int] -> [Int]floyd xs  | n < 2 = [1]  | otherwise = [succ (div (n * pred n) 2) .. div (n * succ n) 2]  where    n = succ (length xs) floydN :: Int -> [[Int]]floydN n = take n (iterate floyd [1]) main :: IO ()main = mapM_ print \$ floydN 5`
Output:
```[1]
[2,3]
[4,5,6]
[7,8,9,10]
[11,12,13,14,15]```

## 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
->
```

## J

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

`require 'strings'floyd=: [: rplc&(' 0';'  ')"1@":@(* (\$ \$ +/\@,)) >:/[email protected]: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@":@(* (\$ \$ +/\@,)) >:/[email protected]:i.`

## 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 ```

## JavaScript

### ES5

(In a functional idiom of JavaScript)

Two main functions:

1. An expression of the Floyd triangle as a list of lists (a function of the number of rows),
2. and a mapping of that expression to a formatted string.
`(function () {    'use strict';     // FLOYD's TRIANGLE -------------------------------------------------------     // floyd :: Int -> [[Int]]    function floyd(n) {        return snd(mapAccumL(function (start, row) {            return [start + row + 1, enumFromTo(start, start + row)];        }, 1, enumFromTo(0, n - 1)));    };     // showFloyd :: [[Int]] -> String    function showFloyd(xss) {        var ws = map(compose([succ, length, show]), last(xss));        return unlines(map(function (xs) {            return concat(zipWith(function (w, x) {                return justifyRight(w, ' ', show(x));            }, ws, xs));        }, xss));    };      // GENERIC FUNCTIONS ------------------------------------------------------     // compose :: [(a -> a)] -> (a -> a)    function compose(fs) {        return function (x) {            return fs.reduceRight(function (a, f) {                return f(a);            }, x);        };    };     // concat :: [[a]] -> [a] | [String] -> String    function concat(xs) {        if (xs.length > 0) {            var unit = typeof xs[0] === 'string' ? '' : [];            return unit.concat.apply(unit, xs);        } else return [];    };     // enumFromTo :: Int -> Int -> [Int]    function enumFromTo(m, n) {        return Array.from({            length: Math.floor(n - m) + 1        }, function (_, i) {            return m + i;        });    };     // justifyRight :: Int -> Char -> Text -> Text    function justifyRight(n, cFiller, strText) {        return n > strText.length ? (cFiller.repeat(n) + strText)            .slice(-n) : strText;    };     // last :: [a] -> a    function last(xs) {        return xs.length ? xs.slice(-1)[0] : undefined;    };     // length :: [a] -> Int    function length(xs) {        return xs.length;    };     // map :: (a -> b) -> [a] -> [b]    function map(f, xs) {        return xs.map(f);    };     // 'The mapAccumL function behaves like a combination of map and foldl;    // it applies a function to each element of a list, passing an accumulating    // parameter from left to right, and returning a final value of this    // accumulator together with the new list.' (See hoogle )     // mapAccumL :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])    function mapAccumL(f, acc, xs) {        return xs.reduce(function (a, x) {            var pair = f(a[0], x);             return [pair[0], a[1].concat([pair[1]])];        }, [acc, []]);    };     // show ::    // (a -> String) f,  Num n =>    // a -> maybe f -> maybe n -> String    var show = JSON.stringify;     // snd :: (a, b) -> b    function snd(tpl) {        return Array.isArray(tpl) ? tpl[1] : undefined;    };     // succ :: Int -> Int    function succ(x) {        return x + 1;    };     // unlines :: [String] -> String    function unlines(xs) {        return xs.join('\n');    };     // zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]    function zipWith(f, xs, ys) {        var ny = ys.length;        return (xs.length <= ny ? xs : xs.slice(0, ny))            .map(function (x, i) {                return f(x, ys[i]);            });    };     // TEST ( n=5 and n=14 rows ) ---------------------------------------------     return unlines(map(function (n) {        return showFloyd(floyd(n)) + '\n';    }, [5, 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```

### ES6

(mapAccumL version)
`(() => {    'use strict';     // FLOYD's TRIANGLE -------------------------------------------------------     // floyd :: Int -> [[Int]]    const floyd = n => snd(mapAccumL(        (start, row) => [start + row + 1, enumFromTo(start, start + row)],        1, enumFromTo(0, n - 1)    ));     // showFloyd :: [[Int]] -> String    const showFloyd = xss => {        const ws = map(compose([succ, length, show]), last(xss));        return unlines(            map(xs => concat(zipWith(                    (w, x) => justifyRight(w, ' ', show(x)), ws, xs                )),                xss            )        );    };     // GENERIC FUNCTIONS ------------------------------------------------------     // compose :: [(a -> a)] -> (a -> a)    const compose = fs => x => fs.reduceRight((a, f) => f(a), x);     // concat :: [[a]] -> [a] | [String] -> String    const concat = xs => {        if (xs.length > 0) {            const unit = typeof xs[0] === 'string' ? '' : [];            return unit.concat.apply(unit, xs);        } else return [];    };     // enumFromTo :: Int -> Int -> [Int]    const enumFromTo = (m, n) =>        Array.from({            length: Math.floor(n - m) + 1        }, (_, i) => m + i);     // justifyRight :: Int -> Char -> Text -> Text    const justifyRight = (n, cFiller, strText) =>        n > strText.length ? (            (cFiller.repeat(n) + strText)            .slice(-n)        ) : strText;     // last :: [a] -> a    const last = xs => xs.length ? xs.slice(-1)[0] : undefined;     // length :: [a] -> Int    const length = xs => xs.length;     // map :: (a -> b) -> [a] -> [b]    const map = (f, xs) => xs.map(f)     // 'The mapAccumL function behaves like a combination of map and foldl;    // it applies a function to each element of a list, passing an accumulating    // parameter from left to right, and returning a final value of this    // accumulator together with the new list.' (See hoogle )     // mapAccumL :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])    const mapAccumL = (f, acc, xs) =>        xs.reduce((a, x) => {            const pair = f(a[0], x);             return [pair[0], a[1].concat([pair[1]])];        }, [acc, []]);     // show ::    // (a -> String) f,  Num n =>    // a -> maybe f -> maybe n -> String    const show = JSON.stringify;     // snd :: (a, b) -> b    const snd = tpl => Array.isArray(tpl) ? tpl[1] : undefined;     // succ :: Int -> Int    const succ = x => x + 1     // unlines :: [String] -> String    const unlines = xs => xs.join('\n');      // zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]    const zipWith = (f, xs, ys) => {        const ny = ys.length;        return (xs.length <= ny ? xs : xs.slice(0, ny))            .map((x, i) => f(x, ys[i]));    };     // TEST ( n=5 and n=14 rows ) ---------------------------------------------     return unlines(map(n => showFloyd(floyd(n)) + '\n', [5, 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```

### 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```

## jq

`# floyd(n) creates an n-row floyd's triangledef floyd(n):  def lpad(len): tostring | (((len - length) * " ")  + .);   # Construct an array of widths.  # Assuming N is the last integer on the last row (i.e. (n+1)*n/2),  # the last row has n entries from (1+N-n) through N:  def widths:    ((n+1)*n/2) as \$N    | [range(1 + \$N - n; \$N + 1) | tostring | length];   # emit line k assuming it starts with the integer "start"  def line(start; k; widths):    reduce range(start; start+k) as \$i      (""; . + (\$i|lpad(widths[\$i - start])) + " ");   widths as \$widths  | (reduce range(0;n) as \$row      ( [0, ""];   # state: i, string        (.[0] + 1) as \$i | .[1] as \$string        | [ (\$i + \$row),            (\$string + "\n" + line(\$i; \$row + 1; \$widths )) ] )    | .[1] ) ;`

`(5,14) | "floyd(\(.)): \(floyd(.))\n"`
Output:
`\$ jq -M -r -n -f floyds_triangle.jq > floyds_triangle.outfloyd(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 `

## Julia

Works with: Julia version 0.6
` `
Output:
```  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```

## Kotlin

Translation of: Java
`fun main(args: Array<String>) = args.forEach { Triangle(it.toInt()) } internal class Triangle(n: Int) {    init {        println("\$n rows:")        var printMe = 1        var printed = 0        var row = 1        while (row <= n) {            val cols = Math.ceil(Math.log10(n * (n - 1) / 2 + printed + 2.0)).toInt()            print("%\${cols}d ".format(printMe))            if (++printed == row) { println(); row++; printed = 0 }            printMe++        }    }}`

Output as Java.

## 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```

## 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    printnext`
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 ```

## 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)	endend 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```

## Maple

`floyd := proc(rows)	local num, numRows, numInRow, i, digits;	digits := Array([]);	for i to 2 do		num := 1;		numRows := 1;		numInRow := 1;		while numRows <= rows do			if i = 2 then				printf(cat("%", digits[numInRow], "a "), num);			end if;			num := num + 1;			if i = 1 and numRows = rows then				digits(numInRow) := StringTools[Length](convert(num-1, string));			end if;			if numInRow >= numRows then				if i = 2 then					printf("\n");				end if;				numInRow := 1;				numRows := numRows + 1;			else				numInRow := numInRow +1;			end if;		end do;	end do;	return NULL;end proc: 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
```

## Mathematica / Wolfram Language

` f=Function[n,	Most/@([email protected]@@Partition[FindSequenceFunction[{1,2,4,7,11}]/@Range[n+1],2,1])]TableForm[[email protected],TableAlignments->Right,TableSpacing->{1,1}]TableForm[[email protected],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```

## MATLAB / Octave

`function floyds_triangle(n)  s = 1;  for k = 1 : n    disp(s : s + k - 1)    s = s + k;  end`
Output:
:
```octave:22> floyds_triangle(5)
1
2  3
4  5  6
7  8  9 10
11 12 13 14 15
```

## Modula-2

`MODULE FloydTriangle;FROM FormatString IMPORT FormatString;FROM Terminal IMPORT WriteString,WriteLn,ReadChar; PROCEDURE WriteInt(n : INTEGER);VAR buf : ARRAY[0..9] OF CHAR;BEGIN    FormatString("%4i", buf, n);    WriteString(buf)END WriteInt; PROCEDURE Print(r : INTEGER);VAR n,i,limit : INTEGER;BEGIN    IF r<0 THEN RETURN END;     n := 1;    limit := 1;    WHILE r#0 DO        FOR i:=1 TO limit DO            WriteInt(n);            INC(n)        END;        WriteLn;         DEC(r);        INC(limit)    ENDEND Print; BEGIN    Print(5);    WriteLn;    Print(14);     ReadCharEND FloydTriangle.`
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```

## NetRexx

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

### 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 = 1say 'Rows:' rowcountsaycol = 0len = Rexx ''ll = ''                               -- last line of triangleLoop 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 jLoop 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 iSay 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 ```

### 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 if not givenmaxVal = numRows * (numRows + 1) % 2  -- calculate the max value.say 'displaying a' numRows "row Floyd's triangle:"saydigit = 1loop 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
```

## Nim

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: seq[seq[int]]) =  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 ```

## OCaml

`let ( |> ) f g x = g (f x)let rec last = function x::[] -> x | _::tl -> last tl | [] -> raise Not_foundlet 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)))`

## 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 stringsys i,tfor i=1 to n  t+=inextstring s=str tsys le=1+len sstring cr=chr(13,10)sys lc=len crstring buf=space(le*t+n*lc)sys j,o,p=1t=0for 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+=lcnextreturn left buf,p-1end function putfile "s.txt",Floyd(5)+floyd(14) `

## PARI/GP

 This example is incorrect. Please fix the code and remove this message.Details: It does not ensure that there is exactly one space between the columns in the last row.
`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```

## 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 ```

## Perl

Translation of: NetRexx
`#!/usr/bin/env perluse 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
```

## Perl 6

Works with: Rakudo version 2016.08
`constant @floyd = (1..*).rotor(1..*);`

Alternatively, using gather/take:

`constant @floyd = gather for 1..* -> \$s { take [++\$ xx \$s] } # Printing: sub say-floyd(\$n) {    my @formats = @floyd[\$n-1].map: {"%{.chars}s"}     for @floyd[^\$n] -> @i {        say ~(@i Z @formats).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```

## Phix

`procedure Floyds_triangle(integer n)sequence widths = repeat(0,n)    integer k = (n * (n-1))/2    for i=1 to n do        widths[i] = sprintf("%%%dd",length(sprintf("%d",i+k))+1)    end for    k = 1    for i=1 to n do        for j=1 to i do            printf(1,widths[j],k)            k += 1        end for        printf(1,"\n")    end forend procedureFloyds_triangle(5)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
```

## PHP

` <?phpfloyds_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
```

## PicoLisp

### 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)) ) ) ) )`

### 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```

## 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
```

## 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.
```

## PureBasic

`Procedure.i sumTo(n)   Protected r,i  For i=1 To n     r+i  Next   ProcedureReturn r.iEndProcedure ; [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.sEndProcedure 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
```

## 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()12 34 5 67 8 9 10>>> pfloyd(floyd(5)) 1 2  3 4  5  6 7  8  9 1011 12 13 14 15>>> pfloyd(floyd(14)) 1 2  3 4  5  6 7  8  9 1011 12 13 14 1516 17 18 19 20 2122 23 24 25 26 27 2829 30 31 32 33 34 35 3637 38 39 40 41 42 43 44  4546 47 48 49 50 51 52 53  54  5556 57 58 59 60 61 62 63  64  65  6667 68 69 70 71 72 73 74  75  76  77  7879 80 81 82 83 84 85 86  87  88  89  90  9192 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)]`

Or, defining just the relationship between successive terms:

`from itertools import (islice)  # main :: IO ()def main():    print(        showFloyd(floydN(5))    )  # floyd :: [Int] -> [Int]def floyd(xs):    n = succ(len(xs))    return [1] if n < 2 else (        enumFromTo(succ(n * pred(n) // 2))(            n * succ(n) // 2        )    )  # floydN :: Int -> [[Int]]def floydN(n):    return take(n)(iterate(floyd)([1]))  # showFloyd :: [[Int]] -> Stringdef showFloyd(xs):    return unlines(str(x) for x in xs)  # GENERIC ABSTRACTIONS ------------------------------------  # enumFromTo :: Int -> Int -> [Int]def enumFromTo(m):    return lambda n: list(range(m, 1 + n))  # iterate :: (a -> a) -> a -> Gen [a]def iterate(f):    def go(x):        v = x        while True:            yield(v)            v = f(v)    return lambda x: go(x)  # pred :: Int -> Intdef pred(x):    return x - 1  # succ :: Int -> Intdef succ(x):    return 1 + x  # take :: Int -> [a] -> [a]# take :: Int -> String -> Stringdef take(n):    return lambda xs: (        xs[0:n]        if isinstance(xs, list)        else list(islice(xs, n))    )  # unlines :: [String] -> Stringdef unlines(xs):    return '\n'.join(xs)  main()`
Output:
```[1]
[2, 3]
[4, 5, 6]
[7, 8, 9, 10]
[11, 12, 13, 14, 15]```

## 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
```

## REXX

### 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
```

### version 2, simple formula

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

`/*REXX program constructs & displays  Floyd's triangle for any number of specified rows.*/parse arg N .;    if N=='' | N==","  then N= 5   /*Not specified?  Then use the default.*/mx= N * (N+1) % 2  - N                           /*calculate the maximum of any value.  */say 'displaying a '  N  " row Floyd's triangle:" /*show the header for Floyd's triangle.*/say                                              /*display a blank line below the title.*/#=1;    do    r=1  for N;           i= 0;     _= /*construct Floyd's triangle row by row*/           do #=#  for r;           i= i + 1     /*start to construct a row of triangle.*/           _= _ right(#, length( mx+i ) )        /*build a row of the Floyd's triangle. */           end   /*#*/                           /*calculate the max length on the fly. */        say substr(_, 2)                         /*remove 1st leading blank in the line.*/        end      /*r*/                           /*stick a fork in it,  we're all 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 default 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
```

### version 3, hexadecimal

`/*REXX program constructs & displays Floyd's triangle for any number of rows in base 16.*/parse arg N .;  if N=='' | N==","  then N=6      /*Not specified?  Then use the default.*/mx=N * (N+1) % 2  -  N                           /*calculate maximum value of any value.*/say 'displaying a '    N    " row Floyd's triangle in base 16:"  /*show triangle header.*/say#=1;  do     r=1  for N;     i=0;         _=     /*construct Floyd's triangle row by row*/          do #=#  for r;     i=i+1               /*start to construct a row of triangle.*/          _=_ right( d2x(#), length( d2x(mx+i))) /*build a row of the Floyd's triangle. */          end   /*#*/      say substr(_, 2)                           /*remove 1st leading blank in the line.*/      end       /*r*/                            /*stick a fork in it,  we're all 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
```

### 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   ("digits" in base X).

This version of the base function has some boilerplate for signed numbers and various error checking.

`/*REXX program constructs/shows Floyd's triangle for any number of rows in any base ≤90.*/parse arg N radx .                               /*obtain optional arguments from the CL*/if    N=='' |    N==","  then    N= 5            /*Not specified?  Then use the default.*/if radx=='' | radx==","  then radx=10            /* "      "         "   "   "     "    */mx=N * (N+1) % 2  -  N                           /*calculate maximum value of any value.*/say 'displaying a '  N   " row Floyd's triangle in base"  radx':'  /*display the header.*/say#=1;  do     r=1  for N;   i=0;            _=    /*construct Floyd's triangle row by row*/         do #=#  for r;    i=i+1                 /*start to construct a row of triangle.*/         _=_ right(base(#, radx),  length( base(mx+i, radx) ) )    /*build triangle row.*/         end   /*#*/      say substr(_, 2)                           /*remove 1st leading blank in the line,*/      end      /*r*/                             /* [↑]   introduced by first abutment. */exit                                             /*stick a fork in it,  we're all done. *//*──────────────────────────────────────────────────────────────────────────────────────*/base: procedure; parse arg x 1 ox,toB,inB              /*obtain number, toBase, inBase. */      @abc= 'abcdefghijklmnopqrstuvwxyz'               /*lowercase Latin alphabet.      */      @[email protected];        upper @abcU                   /*go whole hog and extend 'em.   */      @@@= '0123456789'@abc || @abcU                   /*prefix 'em with numeric digits.*/      @@@[email protected]@@'<>[]{}()[email protected]#\$%^&*_=|\/;:¢¬≈'            /*add some special chars as well.*/                             /* [↑]  handles up to base 90,  all chars must be viewable.*/      numeric digits 3000                              /*what the hey, support gihugeics*/      mxB=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>mxB  then call erb 'inBase',inB /*invalid/illegal arg:   inBase. */      if toB<2   | tob>mxB  then call erb 'toBase',toB /*    "      "     "     toBase. */      if x==''              then call erm              /*    "      "     "     number. */             sigX=left(x, 1)                           /*obtain a possible leading sign.*/      if pos(sigX, '-+')\==0  then x=substr(x, 2)      /*X  number has a leading sign?  */                              else sigX=               /*           ··· no leading sign.*/      #=0            do j=1  for length(x);  _=substr(x, j, 1)  /*convert X, base inB ──► base 10*/            v=pos(_, @@@)                              /*get the value of this "digit". */            if v==0 | v>inB  then call erd x,j,inB     /*is this an illegal "numeral" ? */            #=# * 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*/       y=sigX || substr(@@@, #+1, 1)y                   /*prepend the sign if it existed.*/      return y                                         /*return the number in base  toB.*//*──────────────────────────────────────────────────────────────────────────────────────*/erb:  call ser  'illegal'   arg(2)   "base: "   arg(1)   "must be in range:  2──► "    mxBerd:  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
```
output   when using the input of:   40   81
```displaying a  40  row Floyd's triangle in base 81:

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  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 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 1< 1> 1[ 1] 1{ 1} 1( 1) 1? 1~ 1!
[email protected] 1# 1\$ 1% 1^ 1& 1* 1_ 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 2y 2z 2A 2B 2C 2D 2E 2F 2G 2H 2I 2J 2K 2L 2M
2N 2O 2P 2Q 2R 2S 2T 2U 2V 2W 2X 2Y 2Z 2< 2> 2[ 2] 2{ 2} 2( 2)
2? 2~ 2! [email protected] 2# 2\$ 2% 2^ 2& 2* 2_ 30 31 32 33 34 35 36 37 38 39 3a
3b 3c 3d 3e 3f 3g 3h 3i 3j 3k 3l 3m 3n 3o 3p 3q 3r 3s 3t 3u 3v 3w 3x
3y 3z 3A 3B 3C 3D 3E 3F 3G 3H 3I 3J 3K 3L 3M 3N 3O 3P 3Q 3R 3S 3T 3U 3V
3W 3X 3Y 3Z 3< 3> 3[ 3] 3{ 3} 3( 3) 3? 3~ 3! [email protected] 3# 3\$ 3% 3^ 3& 3* 3_ 40 41
42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 4g 4h 4i 4j 4k 4l 4m 4n 4o 4p 4q 4r
4s 4t 4u 4v 4w 4x 4y 4z 4A 4B 4C 4D 4E 4F 4G 4H 4I 4J 4K 4L 4M 4N 4O 4P 4Q 4R 4S
4T 4U 4V 4W 4X 4Y 4Z 4< 4> 4[ 4] 4{ 4} 4( 4) 4? 4~ 4! [email protected] 4# 4\$ 4% 4^ 4& 4* 4_ 50 51
52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f 5g 5h 5i 5j 5k 5l 5m 5n 5o 5p 5q 5r 5s 5t 5u
5v 5w 5x 5y 5z 5A 5B 5C 5D 5E 5F 5G 5H 5I 5J 5K 5L 5M 5N 5O 5P 5Q 5R 5S 5T 5U 5V 5W 5X 5Y
5Z 5< 5> 5[ 5] 5{ 5} 5( 5) 5? 5~ 5! [email protected] 5# 5\$ 5% 5^ 5& 5* 5_ 60 61 62 63 64 65 66 67 68 69 6a
6b 6c 6d 6e 6f 6g 6h 6i 6j 6k 6l 6m 6n 6o 6p 6q 6r 6s 6t 6u 6v 6w 6x 6y 6z 6A 6B 6C 6D 6E 6F 6G
6H 6I 6J 6K 6L 6M 6N 6O 6P 6Q 6R 6S 6T 6U 6V 6W 6X 6Y 6Z 6< 6> 6[ 6] 6{ 6} 6( 6) 6? 6~ 6! [email protected] 6# 6\$
6% 6^ 6& 6* 6_ 70 71 72 73 74 75 76 77 78 79 7a 7b 7c 7d 7e 7f 7g 7h 7i 7j 7k 7l 7m 7n 7o 7p 7q 7r 7s
7t 7u 7v 7w 7x 7y 7z 7A 7B 7C 7D 7E 7F 7G 7H 7I 7J 7K 7L 7M 7N 7O 7P 7Q 7R 7S 7T 7U 7V 7W 7X 7Y 7Z 7< 7>
7[ 7] 7{ 7} 7( 7) 7? 7~ 7! [email protected] 7# 7\$ 7% 7^ 7& 7* 7_ 80 81 82 83 84 85 86 87 88 89 8a 8b 8c 8d 8e 8f 8g 8h 8i
8j 8k 8l 8m 8n 8o 8p 8q 8r 8s 8t 8u 8v 8w 8x 8y 8z 8A 8B 8C 8D 8E 8F 8G 8H 8I 8J 8K 8L 8M 8N 8O 8P 8Q 8R 8S 8T
8U 8V 8W 8X 8Y 8Z 8< 8> 8[ 8] 8{ 8} 8( 8) 8? 8~ 8! [email protected] 8# 8\$ 8% 8^ 8& 8* 8_ 90 91 92 93 94 95 96 97 98 99 9a 9b 9c
9d 9e 9f 9g 9h 9i 9j 9k 9l 9m 9n 9o 9p 9q 9r 9s 9t 9u 9v 9w 9x 9y 9z 9A 9B 9C 9D 9E 9F 9G 9H 9I 9J 9K 9L 9M 9N 9O 9P
9Q 9R 9S 9T 9U 9V 9W 9X 9Y 9Z 9< 9> 9[ 9] 9{ 9} 9( 9) 9? 9~ 9! [email protected] 9# 9\$ 9% 9^ 9& 9* 9_ a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 aa
```

## Ring

` rows = 10n = 0for r = 1 to rows       for c = 1 to r          n = n + 1        see string(n) + " "     next     see nlnext  `

Output:

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

## 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  endend 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
```

## Run BASIC

`input "Number of rows: "; rowsdim colSize(rows)   for col=1 to rows    colSize(col) = len(str\$(col + rows * (rows-1)/2))next thisNum = 1for r = 1 to rows    for col = 1 to r        print right\$( "  "+str\$(thisNum), colSize(col)); " ";        thisNum = thisNum + 1    next    printnext`
```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 ```

## 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")  }} // Testfloydstriangle(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

```

## 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
```

## Sidef

`func floyd(rows, n=1) {    var max = Math.range_sum(1, rows)    var widths = (max-rows .. max-1 -> map{.+n->to_s.len})    { |r|        say %'#{1..r -> map{|i| "%#{widths[i-1]}d" % n++}.join(" ")}'    } << 1..rows} floyd(5)     # or: floyd(5, 88)floyd(14)    # or: floyd(14, 900)`
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
```

## SPL

`floyd(5)floyd(14) floyd(n)=  k = 0  > r, 1..n    s = ""    > j, 1..r      k += 1      f = ">"+#.upper(#.log10((n-1)*n/2+j+1)+1)+">"      s += #.str(k,f)    <    #.output(s)  <.`
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
```

## 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 ""    }} # Demonstrationputs "Floyd 5:"floydTriangle 5puts "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
```

## TXR

`(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:\[email protected](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.tl
error: need an argument
usage:
txr floyds-triangle.tl <smallish-positive-integer>
\$ txr floyds-triangle.txr 1 2
error: too many arguments
usage:
txr floyds-triangle.tl <smallish-positive-integer>
\$ txr floyds-triangle.tl 5
1
2  3
4  5  6
7  8  9 10
11 12 13 14 15
\$ txr floyds-triangle.tl 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```

## VBA

Solution in Microsoft Office Word. Based on VBScript

`Option ExplicitDim o As StringSub floyd(L As Integer)    Dim r, c, m, n As Integer    n = L * (L - 1) / 2    m = 1    For r = 1 To L        o = o & vbCrLf        For c = 1 To r            o = o & Space(Len(CStr(n + c)) - Len(CStr(m))) & m & " "            m = m + 1        Next    NextEnd SubSub triangle()    o = "5 lines"    Call floyd(5)    o = o & vbCrLf & "14 lines"    Call floyd(14)    With Selection        .Font.Name = "Courier New"        .TypeText Text:=o    End WithEnd Sub`
Output:
`5 lines 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15  14 lines 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`

## 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 `

## XPL0

`include c:\cxpl\codes;  \include 'code' declarations func IntLen(N);         \Return number of digits in a positive integerint     N;int     I;for I:= 1 to 20 do    [N:= N/10;  if N=0 then return I]; proc Floyd(N);          \Display Floyd's triangleint N;int M, Row, Col;real F;[M:= (N-1+1)*(N-1)/2;   \last Floyd number on second to last rowF:= 1.0;                \Floyd number counterfor 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
```

## 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 sequencefcn 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
```

## ZX Spectrum Basic

`10 LET n=10: LET j=1: LET col=120 FOR r=1 TO n30 FOR j=j TO j+r-140 PRINT TAB (col);j;50 LET col=col+360 NEXT j70 PRINT 80 LET col=190 NEXT r`