Floyd's triangle: Difference between revisions
Added XBasic
m (→{{header|Haskell}}: (slight rearrangement)) |
(Added XBasic) |
||
| (144 intermediate revisions by 51 users not shown) | |||
Line 21:
<br><br>
=={{header|
{{trans|Python}}
<syntaxhighlight lang="11l">F floyd(rowcount)
V rows = [[1]]
L rows.len < rowcount
V n = rows.last.last + 1
rows.append(Array(n .. n + rows.last.len))
R rows
F pfloyd(rows)
V colspace = rows.last.map(n -> String(n).len)
L(row) rows
print(zip(colspace, row).map2((space, n) -> String(n).rjust(space)).join(‘ ’))
pfloyd(floyd(5))
pfloyd(floyd(14))</syntaxhighlight>
{{out}}
<pre>
1
2 3
4 5
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
</pre>
=={{header|360 Assembly}}==
{{incorrect|360 Assembly|The last line should only have one space between values}}
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 [[360_Assembly_macros#360_Assembly_Structured_Macros|Structured Macros]] .
<syntaxhighlight lang="360asm">* Floyd's triangle 21/06/2018
FLOYDTRI 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
EPILOG
MVCX MVC 0(0,R10),0(R11) mvc PG,XDEC
NN DC F'14' number of rows
PG DC CL80' ' buffer
XDEC DS CL12 temp
ZN DC X'4020202020202020' mask CL8 7num
YREGS
END FLOYDTRI</syntaxhighlight>
{{out}}
<pre>
1
2 3
4 5 6
7 8 9 10
11 12 13 14 15
</pre>
{{out}}
<pre>
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
</pre>
=={{header|ABAP}}==
REPORT zmbr_test.
PARAMETERS: p_row TYPE i.
START-OF-SELECTION.
DATA(lv_column) = 0.
DATA(lv_number) = 0.
DO p_row TIMES.
lv_column += 1.
DO lv_column TIMES.
lv_number += 1.
WRITE: lv_number.
ENDDO.
WRITE:/ space.
ENDDO.
{{out}}
<pre>
1
2 3
4 5 6
7 8 9 10
11 12 13 14 15
</pre>
{{out}}
<pre>
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
</pre>
=={{header|ABC}}==
<syntaxhighlight lang="ABC">HOW TO RETURN width n:
SELECT:
n<10: RETURN 1
ELSE: RETURN 1 + width floor (n/10)
HOW TO DISPLAY A FLOYD TRIANGLE WITH lines LINES:
PUT lines * (lines+1)/2 IN maxno
PUT 1 IN n
FOR line IN {1..lines}:
FOR col IN {1..line}:
WRITE n >> (1 + width (maxno - lines + col))
PUT n+1 IN n
WRITE /
DISPLAY A FLOYD TRIANGLE WITH 5 LINES
WRITE /
DISPLAY A FLOYD TRIANGLE WITH 14 LINES
WRITE /</syntaxhighlight>
{{out}}
<pre> 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</pre>
=={{header|Action!}}==
<syntaxhighlight lang="action!">PROC Triangle(BYTE level)
INT v,i
BYTE x,y
BYTE ARRAY widths(20)
CHAR ARRAY tmp(5)
v=1
FOR y=1 TO level-1
DO
v==+y
OD
FOR x=0 TO level-1
DO
StrI(v+x,tmp)
widths(x)=tmp(0)
OD
v=1
FOR y=1 TO level
DO
FOR x=0 TO y-1
DO
StrI(v,tmp)
FOR i=tmp(0) TO widths(x)-1
DO
Put(32)
OD
Print(tmp)
IF x<y-1 THEN
Put(32)
ELSE
PutE()
FI
v==+1
OD
OD
RETURN
PROC Main()
BYTE LMARGIN=$52,oldLMARGIN
oldLMARGIN=LMARGIN
LMARGIN=0 ;remove left margin on the screen
Put(125) PutE() ;clear the screen
Triangle(5)
PutE()
Triangle(13)
LMARGIN=oldLMARGIN ;restore left margin on the screen
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Floyd's_triangle.png Screenshot from Atari 8-bit computer]
<pre>
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
</pre>
=={{header|Ada}}==
<syntaxhighlight lang="ada">
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;
</syntaxhighlight>
{{out}}
<pre>> ./floyd_triangle_triangle 5
1
2 3
Line 71 ⟶ 335:
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
</pre>
=={{header|ALGOL 68}}==
{{works with|ALGOL 68G|Any - tested with release 2.8.win32}}
<
PROC floyds triangle = ( INT n )VOID:
BEGIN
Line 107 ⟶ 372:
floyds triangle( 14 )
)</
{{out}}
<pre>
Line 131 ⟶ 396:
92 93 94 95 96 97 98 99 100 101 102 103 104 105
</pre>
=={{header|ALGOL W}}==
{{trans|ALGOL_68}}
<syntaxhighlight lang="algolw">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.</syntaxhighlight>
{{out}}
<pre>
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
</pre>
=={{header|APL}}==
{{works with|Dyalog APL}}
<syntaxhighlight lang="apl">floyd←{
max←⍵×(⍵+1)÷2
tri←↑(⍳max)⊂⍨(0,⍳max-1)∊+\0,⍳⍵
wdt←⌈⍀⊖≢∘⍕¨tri
↑,/wdt{' ',(-⍺××⍵)↑⍕⍵}¨tri
}</syntaxhighlight>
{{out}}
<syntaxhighlight lang="apl"> 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</syntaxhighlight>
=={{header|AppleScript}}==
===Functional===
{{Trans|JavaScript}}
{{Trans|Haskell}} (mapAccumL versions)
<syntaxhighlight lang
-- floyd :: Int -> [[Int]]
on floyd(n)
script floydRow
on
{start + row + 1, enumFromTo(start, start + row)}
end
end script
Line 153 ⟶ 517:
script aligned
on
script pad
on
justifyRight(w, space, show(x))
end
end script
concat(zipWith(pad, ws, xs))
end
end script
Line 168 ⟶ 532:
-- TEST
on run
script test
on
showFloyd(floyd(n)) & linefeed
end
end script
Line 180 ⟶ 544:
-- GENERIC FUNCTIONS
-- compose :: [(a -> a)] -> (a -> a)
on compose(fs)
script
on
script
on
mReturn(f)'s
end
end script
foldr(result, x, fs)
end
end script
end compose
Line 199 ⟶ 563:
-- concat :: [[a]] -> [a] | [String] -> String
on concat(xs)
if length of xs > 0 and class of (item 1 of xs) is string then
set
else
set
end if
repeat with i from 1 to length of xs
set acc to acc & item i of xs
end repeat
acc
end concat
Line 233 ⟶ 594:
set lng to length of xs
repeat with i from 1 to lng
set v to
end repeat
return v
Line 239 ⟶ 600:
end foldl
-- foldr :: (
on foldr(f, startValue, xs)
tell mReturn(f)
Line 245 ⟶ 606:
set lng to length of xs
repeat with i from lng to 1 by -1
set v to
end repeat
return v
Line 288 ⟶ 649:
set lst to {}
repeat with i from 1 to lng
set end of lst to
end repeat
return lst
Line 302 ⟶ 663:
on mapAccumL(f, acc, xs)
script
on
tell mReturn(f) to set pair to
[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 -> a
on min(x, y)
if y < x then
y
else
x
end if
end min
-- Lift 2nd class handler function into 1st class script wrapper
Line 318 ⟶ 688:
else
script
property
end script
end if
Line 355 ⟶ 725:
if c = list then
script serialized
on
show(v)
end
end script
Line 363 ⟶ 733:
else if c = record then
script showField
on
set {k, v} to kv
k & ":" & show(v)
end
end script
Line 396 ⟶ 766:
-- zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
on zipWith(f, xs, ys)
set
set
tell mReturn(f)
set end of lst to |λ|(item i of xs, item i of ys)
end repeat
return lst
end tell
end zipWith</syntaxhighlight>
{{Out}}
<pre> 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</pre>
Or, defining only the relationship between successive terms:
<syntaxhighlight lang="applescript">-- 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 if
end floyd
-- floydN :: Int -> [[Int]]
on floydN(n)
take(n, iterate(floyd, {1}))
end floydN
-- showFloyd :: [[Int]] -> String
on 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] -> String
on 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
acc
end 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 if
end 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 script
end iterate
-- justifyRight :: Int -> Char -> String -> String
on justifyRight(n, cFiller, strText)
if n > length of strText then
text -n thru -1 of ((replicate(n, cFiller) as text) & strText)
else
strText
end if
end justifyRight
-- length :: [a] -> Int
on |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 if
end |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 tell
end map
-- min :: Ord a => a -> a -> a
on min(x, y)
if y < x then
y
else
x
end if
end 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 if
end mReturn
-- pred :: Int -> Int
on pred(x)
(-1) + x
end 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 & dbl
end replicate
-- succ :: Int -> Int
on succ(x)
1 + x
end succ
-- take :: Int -> [a] -> [a]
-- take :: Int -> String -> String
on 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 if
end take
-- unlines :: [String] -> String
on 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
str
end unlines</syntaxhighlight>
{{Out}}
<pre> 1
2 3
4 5 6
7 8 9 10
11 12 13 14 15</pre>
Or as a partially populated matrix:
<syntaxhighlight lang="applescript">--------------------- FLOYD'S TRIANGLE -------------------
-- floyd :: Int -> [[Maybe Int]]
on floyd(n)
script go
on |λ|(y, x)
if x ≤ y then
x + (y * (y - 1)) div 2
else
missing value
end if
end |λ|
end script
matrix(n, n, go)
end floyd
--------------------------- TEST -------------------------
on run
-- Floyd triangles of dimensions 5 and 14
unlines(map(compose(showMatrix, floyd), {5, 14}))
end run
------------------------- GENERIC ------------------------
-- compose (<<<) :: (b -> c) -> (a -> b) -> a -> c
on compose(f, g)
script
property mf : mReturn(f)
property mg : mReturn(g)
on |λ|(x)
mf's |λ|(mg's |λ|(x))
end |λ|
end script
end compose
-- enumFromTo :: Int -> Int -> [Int]
on enumFromTo(m, n)
if m ≤ n then
set xs to {}
repeat with i from m to n
set end of xs to i
end repeat
xs
else
{}
end if
end enumFromTo
-- foldl :: (a -> b -> a) -> a -> [b] -> a
on 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 tell
end foldl
-- justifyRight :: Int -> Char -> String -> String
on justifyRight(n, cFiller)
script
on |λ|(s)
if n > length of s then
text -n thru -1 of ((replicate(n, cFiller) as text) & s)
else
s
end if
end |λ|
end script
end justifyRight
-- map :: (a -> b) -> [a] -> [b]
on map(f, xs)
-- The list obtained by applying f
-- to each element of xs.
tell mReturn(f)
set lng to length of xs
set lst to {}
end repeat
return lst
end tell
end map
-- matrix :: Int -> Int -> ((Int, Int) -> a) -> [[a]]
on matrix(nRows, nCols, f)
-- A matrix of a given number of columns and rows,
-- in which each value is a given function of its
-- (zero-based) column and row indices.
script go
property g : mReturn(f)'s |λ|
on |λ|(iRow)
set xs to {}
repeat with iCol from 1 to nCols
set end of xs to g(iRow, iCol)
end repeat
end
end script
map(go, enumFromTo(1, nRows))
end matrix
-- max :: Ord a => a -> a -> a
on max(x, y)
if x > y then
x
else
y
end if
end
-- mReturn :: First-class m => (a -> b) -> m (a -> b)
on mReturn(f)
-- 2nd class handler function lifted into 1st class script wrapper.
if script is class of f then
f
else
script
property |λ| : f
end script
end if
end 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 -> String -> String
on replicate(n, s)
-- Egyptian multiplication - progressively doubling a list,
-- appending stages of doubling to an accumulator where needed
-- for binary assembly of a target length
script p
on |λ|({n})
n ≤ 1
end |λ|
end script
script f
on |λ|({n, dbl, out})
if (n mod 2) > 0 then
set d to out & dbl
else
set d to out
end if
{n div 2, dbl & dbl, d}
end |λ|
end script
set xs to |until|(p, f, {n, s, ""})
item 2 of xs & item 3 of xs
end replicate
-- showMatrix :: [[Maybe a]] -> String
on showMatrix(rows)
-- String representation of rows
-- as a matrix.
script showRow
on |λ|(a, row)
set {maxWidth, prevRows} to a
script showCell
on |λ|(acc, cell)
set {w, xs} to acc
if missing value is cell then
{w, xs & ""}
else
set s to cell as string
{max(w, length of s), xs & s}
end if
end |λ|
end script
set {rowMax, cells} to foldl(showCell, {0, {}}, row)
{max(maxWidth, rowMax), prevRows & {cells}}
end |λ|
end script
set {w, stringRows} to foldl(showRow, {0, {}}, rows)
script go
on |λ|(row)
unwords(map(justifyRight(w, space), row))
end |λ|
end script
unlines(map(go, stringRows)) & linefeed
end showMatrix
-- str :: a -> String
on str(x)
x as string
end str
-- unlines :: [String] -> String
on unlines(xs)
-- A single string formed by the intercalation
-- of a list of strings with the newline character.
set {dlm, my text item delimiters} to ¬
{my text item delimiters, linefeed}
set s to xs as text
set my text item delimiters to dlm
s
end unlines
-- until :: (a -> Bool) -> (a -> a) -> a -> a
on |until|(p, f, x)
set v to x
set mp to mReturn(p)
set mf to mReturn(f)
repeat until mp's |λ|(v)
set v to mf's |λ|(v)
end repeat
v
end |until|
-- unwords :: [String] -> String
on unwords(xs)
set {dlm, my text item delimiters} to ¬
{my text item delimiters, space}
set s to xs as text
set my text item delimiters to dlm
return s
end unwords</syntaxhighlight>
{{Out}}
<pre> 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
</pre>
----
===Straightforward===
<syntaxhighlight lang="applescript">on FloydsTriangle(n)
set triangle to {}
set i to 0
repeat with w from 1 to n
set row to {}
repeat with i from (i + 1) to (i + w)
set end of row to i
end repeat
set end of triangle to row
end repeat
return triangle
end FloydsTriangle
-- Task code:
on matrixToText(matrix, w)
script o
property matrix : missing value
property row : missing value
end script
set o's matrix to matrix
set padding to " "
repeat with r from 1 to (count o's matrix)
set o's row to o's matrix's item r
repeat with i from 1 to (count o's row)
set o's row's item i to text -w thru end of (padding & o's row's item i)
end repeat
set o's matrix's item r to join(o's row, "")
end repeat
return join(o's matrix, linefeed)
end matrixToText
on join(lst, delim)
set astid to AppleScript's text item delimiters
set AppleScript's text item delimiters to delim
set txt to lst as text
set AppleScript's text item delimiters to astid
return txt
end join
local triangle5, text5, triangle14, text14
set triangle5 to FloydsTriangle(5)
set text5 to matrixToText(triangle5, (count (end of end of triangle5 as text)) + 1)
set triangle14 to FloydsTriangle(14)
set text14 to matrixToText(triangle14, (count (end of end of triangle14 as text)) + 1)
return linefeed & text5 & (linefeed & linefeed & text14 & linefeed)</syntaxhighlight>
{{output}}
<syntaxhighlight lang="applescript">"
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
"</syntaxhighlight>
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">width: function [rows col] .memoize [
floor 2 + log col + 1 + (rows * rows - 1) / 2 10
]
floyd: function [rows][
n: 1
row: 1
col: 0
while -> row =< rows [
prints pad ~"|n|" width rows col
inc 'col
inc 'n
if col = row [
print ""
col: 0
inc 'row
]
]
]
floyd 5
print ""
floyd 14</syntaxhighlight>
{{out}}
<pre> 1
2 3
Line 438 ⟶ 1,408:
=={{header|AutoHotkey}}==
<
i = 0
loop %row%
Line 459 ⟶ 1,429:
res.=" "
return % res
}</
Examples:<syntaxhighlight lang
Outputs:<pre> 1
2 3
Line 477 ⟶ 1,447:
=={{header|AWK}}==
<
BEGIN {
Line 492 ⟶ 1,462:
}
}
</syntaxhighlight>
<p>output from: awk -f floyds_triangle.awk -v rows=5</p>
<pre>
Line 519 ⟶ 1,489:
</pre>
=={{header|
==={{header|Applesoft BASIC}}===
Line <code>150,160</code> creates a vector of the length of all entries is the last row. These values are used in line <code>210,220</code> to put the cursor at the correct horizontal position.
<syntaxhighlight lang="basic">
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
</syntaxhighlight>
{{out}}
<pre>]RUN
1
2 3
4 5 6
7 8 9 10
11 12 13 14 15</pre>
<pre>]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</pre>
==={{header|BASIC256}}===
{{works with|BASIC256|2.0.0.11}}
<syntaxhighlight lang="basic256">
function trianglevalue(col, row)
return (row-1)*row\2 + col
end function
subroutine printtriangle(numrows)
for row = 1 to numrows
for col = 1 to row-1
colwidth = length(""+trianglevalue(col, numrows))
print right(" "*colwidth+trianglevalue(col, row), colwidth);" ";
next col
colwidth = length(""+trianglevalue(col, numrows))
print right(" "*colwidth+trianglevalue(col, row), colwidth)
next row
end subroutine
call printtriangle(5)
print
call printtriangle(14)
</syntaxhighlight>
{{out}}
<pre>
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
</pre>
==={{header|BBC BASIC}}===
<syntaxhighlight lang="bbcbasic"> n = 14
num = 1
last = (n^2 - n + 2) DIV 2
Line 531 ⟶ 1,587:
NEXT
PRINT
NEXT row</
Output for n = 5:
<pre>
Line 557 ⟶ 1,613:
92 93 94 95 96 97 98 99 100 101 102 103 104 105
</pre>
==={{header|Chipmunk Basic}}===
{{works with|Chipmunk Basic|3.6.4}}
{{works with|Applesoft BASIC}}
{{works with|BASICA}}
{{works with|GW-BASIC}}
{{works with|PC-BASIC}}
{{works with|QBasic}}
{{works with|QuickBasic}}
{{works with|Just BASIC}}
{{works with|Liberty BASIC}}
{{works with|Run BASIC}}
<syntaxhighlight lang="qbasic">100 CLS : REM 100 HOME for Applesoft BASIC
110 INPUT "Number of rows: "; ROWS
120 DIM COLSIZE(ROWS)
130 FOR COL = 1 TO ROWS
140 COLSIZE(COL) = LEN(STR$(COL + ROWS * (ROWS - 1) / 2))
150 NEXT
160 THISNUM = 1
170 FOR R = 1 TO ROWS
180 FOR COL = 1 TO R
190 PRINT RIGHT$(" " + STR$(THISNUM), COLSIZE(COL)); " ";
200 THISNUM = THISNUM + 1
210 NEXT
220 PRINT
230 NEXT
240 END</syntaxhighlight>
==={{header|Commodore BASIC}}===
<syntaxhighlight lang="basic">100 print chr$(14);chr$(147);"Floyd's triangle"
110 print "How many rows? ";
120 open 1,0:input#1,ro$:close 1:print
130 ro=val(ro$):if ro<1 then 110
140 li=ro*(ro+1)/2
150 dim w(ro-1)
160 n=li-ro+1
170 for i=0 to ro-1:w(i)=len(str$(n)):n=n+1:next i
180 n=1
190 for i=1 to ro
200 : for j=0 to i-1
210 : n$=mid$(str$(n),2)
220 : if len(n$)<w(j) then for k=1 to w(j)-len(n$):print" ";:next k
230 : print n$;
240 : n=n+1
250 : next j
260 : print
270 next i
280 end</syntaxhighlight>
{{Out}}
<pre>Floyd's triangle
How many rows? 5
1
2 3
4 5 6
7 8 9 10
11 12 13 14 15
How many 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</pre>
==={{header|GW-BASIC}}===
The [[#Chipmunk_Basic|Chipmunk Basic]] solution works without any changes.
==={{header|IS-BASIC}}===
{{incorrect|IS-BASIC|last line should only have one space between values}}
<syntaxhighlight lang="is-basic">100 PROGRAM "FloydT.bas"
110 LET N=14:LET J=1
120 TEXT 80
130 FOR I=1 TO N
140 FOR J=J TO J+I-1
150 PRINT USING " ###":J;
160 NEXT
170 PRINT
180 NEXT</syntaxhighlight>
==={{header|MasmBasic}}===
'''[http://www.webalice.it/jj2006/Masm32_Tips_Tricks_and_Traps.htm Builds with Masm, UAsm or AsmC plus the MasmBasic library]'''
<syntaxhighlight lang="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
Inkey
EndOfCode</syntaxhighlight>
{{out}}
<pre> 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</pre>
==={{header|MSX Basic}}===
The [[#Chipmunk_Basic|Chipmunk Basic]] solution works without any changes.
==={{header|QBasic}}===
<syntaxhighlight lang="qbasic">SUB FloydTriangle (fila)
DIM numColum(fila)
FOR colum = 1 TO fila
numColum(colum) = LEN(STR$(colum + fila * (fila - 1) / 2))
NEXT colum
PRINT "output for "; STR$(fila): PRINT
thisNum = 1
FOR r = 1 TO fila
FOR colum = 1 TO r
PRINT RIGHT$(" " + STR$(thisNum), numColum(colum)); " ";
thisNum = thisNum + 1
NEXT colum
PRINT
NEXT
END SUB
FloydTriangle (5)
PRINT
FloydTriangle (14)</syntaxhighlight>
==={{header|True BASIC}}===
{{trans|QBasic}}
<syntaxhighlight lang="qbasic">SUB floydtriangle (fila)
DIM numcolum(0)
MAT REDIM numcolum(fila)
FOR colum = 1 TO fila
LET numcolum(colum) = LEN(STR$(colum+fila*(fila-1)/2))
NEXT colum
PRINT "output for "; STR$(fila)
PRINT
LET thisnum = 1
FOR r = 1 TO fila
FOR colum = 1 TO r
PRINT (" " & STR$(thisnum))[LEN(" " & STR$(thisnum))-numcolum(colum)+1:maxnum]; " ";
LET thisnum = thisnum+1
NEXT colum
PRINT
NEXT r
END SUB
CALL FLOYDTRIANGLE (5)
PRINT
CALL FLOYDTRIANGLE (14)
END</syntaxhighlight>
==={{header|XBasic}}===
{{works with|Windows XBasic}}
<syntaxhighlight lang="qbasic">PROGRAM "Floyd's triangle"
VERSION "0.0001"
DECLARE FUNCTION Entry ()
DECLARE FUNCTION FloydTriangle (n)
FUNCTION Entry ()
FloydTriangle (5)
PRINT
FloydTriangle (14)
END FUNCTION
FUNCTION FloydTriangle (fila)
DIM numColum[fila]
FOR colum = 1 TO fila
t$ = STR$(colum + fila * (fila - 1) / 2)
numColum[colum] = LEN(t$)
NEXT colum
PRINT "output for "; STR$(fila)
PRINT
thisNum = 1
FOR r = 1 TO fila
FOR colum = 1 TO r
PRINT RIGHT$(" " + STR$(thisNum), numColum[colum]); " ";
INC thisNum
NEXT colum
PRINT
NEXT r
END FUNCTION
END PROGRAM</syntaxhighlight>
==={{header|Yabasic}}===
<syntaxhighlight lang="freebasic">sub FloydTriangle (fila)
dim numColum(fila)
for colum = 1 to fila
numColum(colum) = len(str$(colum + fila * (fila - 1) / 2))
next colum
print "output for ", str$(fila), "\n"
thisNum = 1
for r = 1 to fila
for colum = 1 to r
print right$(" " + str$(thisNum), numColum(colum)), " ";
thisNum = thisNum + 1
next colum
print
next
end sub
FloydTriangle (5)
print
FloydTriangle (14)</syntaxhighlight>
=={{header|Batch File}}==
{{trans|QBasic}}
<syntaxhighlight lang="dos">:: Floyd's triangle Task from Rosetta Code
:: Batch File Implementation
@echo off
rem main thing
setlocal enabledelayedexpansion
call :floydtriangle 5
echo(
call :floydtriangle 14
exit /b 0
:floydtriangle
set "fila=%1"
for /l %%c in (1,1,%fila%) do (
set /a "lastRowNum=%%c+fila*(fila-1)/2"
rem count number of digits of whole number trick
rem source: https://stackoverflow.com/a/45472269
set /a "Log=1!lastRowNum:~1!-!lastRowNum:~1!-0"
set /a "numColum[%%c]=!Log:0=+1!"
)
echo(Output for %fila%
set "thisNum=1"
for /l %%r in (1,1,%fila%) do (
set "printLine="
for /l %%c in (1,1,%%r) do (
rem count number of digits of whole number trick
set /a "Log=1!thisNum:~1!-!thisNum:~1!-0"
set /a "thisNumColum=!Log:0=+1!"
rem handle spacing
set "space= "
set /a "extra=!numColum[%%c]!-!thisNumColum!"
for /l %%s in (1,1,!extra!) do set "space=!space! "
rem append current number to printLine
set "printLine=!printLine!!space!!thisNum!"
set /a "thisNum=!thisNum!+1"
)
echo(!printLine!
)
goto :EOF</syntaxhighlight>
{{out}}
<pre>Output for 5
1
2 3
4 5 6
7 8 9 10
11 12 13 14 15
Output for 14
1
2 3
4 5 6
7 8 9 10
11 12 13 14 15
16 17 18 19 20 21
22 23 24 25 26 27 28
29 30 31 32 33 34 35 36
37 38 39 40 41 42 43 44 45
46 47 48 49 50 51 52 53 54 55
56 57 58 59 60 61 62 63 64 65 66
67 68 69 70 71 72 73 74 75 76 77 78
79 80 81 82 83 84 85 86 87 88 89 90 91
92 93 94 95 96 97 98 99 100 101 102 103 104 105</pre>
=={{header|BCPL}}==
<syntaxhighlight lang="bcpl">get "libhdr"
let width(n) = n<10 -> 1, 1 + width(n/10)
let floyd(rows) be
$( let maxno = rows * (rows+1)/2
let num = 1
for r = 1 to rows
$( for c = 1 to r
$( writed(num, 1 + width(maxno-rows+c))
num := num + 1
$)
wrch('*N')
$)
$)
let start() be
$( floyd(5)
wrch('*N')
floyd(14)
$)</syntaxhighlight>
{{out}}
<pre> 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</pre>
=={{header|Befunge}}==
<syntaxhighlight lang="befunge">0" :seniL">:#,_&>:!#@_55+,:00p::1+*2/1v
vv+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+,:!#@_</syntaxhighlight>
{{out}}
<pre>
1
2 3
4 5 6
7 8 9
11
<pre>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</pre>
=={{header|Bracmat}}==
<
= lowerLeftCorner lastInColumn lastInRow row i W w
. put$(str$("Floyd " !arg ":\n"))
Line 601 ⟶ 2,020:
& floyd$5
& floyd$14
);</
Output:
<pre>Floyd 5:
Line 626 ⟶ 2,045:
=={{header|C}}==
<
void t(int n)
Line 687 ⟶ 2,106:
// t(10000);
return 0;
}</
Output identical to D's.
=={{header|C sharp|C#}}==
{{Trans|Perl}}
<syntaxhighlight lang="csharp">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();
}
}</syntaxhighlight>
=={{header|C++}}==
<
#include <windows.h>
#include <sstream>
Line 774 ⟶ 2,242:
return 0;
}
//--------------------------------------------------------------------------------------------------</
{{out}}
<pre>Floyd's Triangle - 5 rows
Line 802 ⟶ 2,270:
92 93 94 95 96 97 98 99 100 101 102 103 104 105</pre>
=={{header|
I didn't translete this, it's from my own creation.
<syntaxhighlight lang="clojure">
(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)
(repeat " "))) x)
e (map #(map (fn [x] (str " " x)) %) l)]
(map #(println (apply str
</syntaxhighlight>
By Average-user.
{{out}}
<pre>
(TrianglePrint 5)
1
2 3
4 5 6
7 8 9 10
11 12 13 14 15
(TrianglePrint 14)
2 3
4 5
7 8 9 10
11 12 13 14
16 17 18 19 20
22 23 24 25 26 27
29 30 31 32 33 34 35
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
</pre>
=={{header|CLU}}==
<syntaxhighlight lang="clu">floyd = cluster is triangle
rep =
width = proc (n: int) returns (int)
w: int := 1
while n >= 10 do
w := w + 1
n := n / 10
end
return (w)
end width
triangle = proc (rows: int) returns (string)
ss: stream := stream$create_output()
maxno: int := rows * (rows+1)/2
num: int := 1
for row: int in int$from_to(1, rows) do
for col: int in int$from_to(1, row) do
stream$putright(ss, int$unparse(num), 1 + width(maxno-rows+col))
num := num + 1
end
stream$putl(ss, "")
end
return (stream$get_contents(ss))
end triangle
end floyd
start_up = proc ()
po: stream := stream$primary_output()
stream$putl(po, floyd$triangle(5))
stream$putl(po, floyd$triangle(14))
end start_up</syntaxhighlight>
{{out}}
<pre> 1
2 3
4 5 6
7 8 9 10
11 12 13 14 15
1
2
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</pre>
=={{header|COBOL}}==
<syntaxhighlight lang="cobol"> IDENTIFICATION DIVISION.
PROGRAM-ID. FLOYD-TRIANGLE.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 VARIABLES COMP.
02 NUM-LINES PIC 99.
02 CUR-LINE PIC 99.
02 CUR-COL PIC 99.
02 CUR-NUM PIC 999.
02 ZERO-SKIP PIC 9.
02 LINE-PTR PIC 99.
02 MAX-NUM PIC 999.
01 OUTPUT-FORMAT.
02 OUT-LINE PIC X(72).
02 ONE-DIGIT PIC B9.
02 TWO-DIGITS PIC BZ9.
02 THREE-DIGITS PIC BZZ9.
02 MAX-COL-NUM PIC 999.
PROCEDURE DIVISION.
BEGIN.
MOVE 5 TO NUM-LINES. PERFORM FLOYD.
DISPLAY ' '.
MOVE 14 TO NUM-LINES. PERFORM FLOYD.
STOP RUN.
FLOYD.
MOVE 1 TO CUR-NUM.
COMPUTE MAX-NUM = NUM-LINES * (NUM-LINES + 1) / 2.
PERFORM FLOYD-LINE
VARYING CUR-LINE FROM 1 BY 1
UNTIL CUR-LINE IS GREATER THAN NUM-LINES.
FLOYD-LINE.
MOVE ' ' TO OUT-LINE.
MOVE 1 TO LINE-PTR.
PERFORM FLOYD-NUM
VARYING CUR-COL FROM 1 BY 1
UNTIL CUR-COL IS GREATER THAN CUR-LINE.
DISPLAY OUT-LINE.
FLOYD-NUM.
COMPUTE MAX-COL-NUM = MAX-NUM - NUM-LINES + CUR-COL.
MOVE 0 TO ZERO-SKIP.
INSPECT MAX-COL-NUM TALLYING ZERO-SKIP FOR LEADING '0'.
IF ZERO-SKIP IS EQUAL TO ZERO
PERFORM FLOYD-THREE-DIGITS
ELSE IF ZERO-SKIP IS EQUAL TO 1
PERFORM FLOYD-TWO-DIGITS
ELSE IF ZERO-SKIP IS EQUAL TO 2
PERFORM FLOYD-ONE-DIGIT.
ADD 1 TO CUR-NUM.
FLOYD-ONE-DIGIT.
MOVE CUR-NUM TO ONE-DIGIT.
STRING ONE-DIGIT DELIMITED BY SIZE INTO OUT-LINE
WITH POINTER LINE-PTR.
FLOYD-TWO-DIGITS.
MOVE CUR-NUM TO TWO-DIGITS.
STRING TWO-DIGITS DELIMITED BY SIZE INTO OUT-LINE
WITH POINTER LINE-PTR.
FLOYD-THREE-DIGITS.
MOVE CUR-NUM TO THREE-DIGITS.
STRING THREE-DIGITS DELIMITED BY SIZE INTO OUT-LINE
WITH POINTER LINE-PTR.</syntaxhighlight>
{{out}}
<pre> 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</pre>
=={{header|CoffeeScript}}==
{{trans|Kotlin}}
<
console.log "#{n} rows:"
printMe = 1
Line 872 ⟶ 2,487:
printMe++
triangle [5, 14]</
Output as Kotlin.
=={{header|Common Lisp}}==
===Version 1===
<
;;;verbose, but more readable and efficient than version 2
Line 893 ⟶ 2,508:
(dotimes (col (+ 1 row))
(format t "~vd " (aref column-widths col)(+ col (lazycat row))))
(format t "~%")))))</
===Version 2 - any base===
<
;;;optional "base" parameter will allow use of any base from 2 to 36
Line 903 ⟶ 2,518:
(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 "~%")))</
{{out}}
Line 954 ⟶ 2,569:
</pre>
=={{header|Cowgol}}==
<syntaxhighlight lang="cowgol">include "cowgol.coh";
sub width(n: uint16): (w: uint8) is
w := 1;
while n >= 10 loop
n := n / 10;
w := w + 1;
end loop;
end sub;
sub print_fixed(n: uint16, w: uint8) is
w := w - width(n);
while w > 0 loop
print_char(' ');
w := w - 1;
end loop;
print_i16(n);
end sub;
sub floyd(rows: uint16) is
var maxno := rows * (rows+1)/2;
var num: uint16 := 1;
var row: uint16 := 1;
while row <= rows loop
var col: uint16 := 1;
while col <= row loop
print_fixed(num, 1 + width(maxno - rows + col));
num := num + 1;
col := col + 1;
end loop;
print_nl();
row := row + 1;
end loop;
end sub;
floyd(5);
print_nl();
floyd(14);</syntaxhighlight>
{{out}}
<pre> 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</pre>
=={{header|D}}==
<
void floydTriangle(in uint n) {
Line 970 ⟶ 2,645:
floydTriangle(5);
floydTriangle(14);
}</
{{out}}
<pre> 1
Line 991 ⟶ 2,666:
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</pre>
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
<syntaxhighlight lang="Delphi">
procedure FloydsTriangle(Memo: TMemo; Rows: integer);
var I,R,C: integer;
var S: string;
begin
I:=1;
S:='';
for R:=1 to Rows do
begin
for C:=1 to R do
begin
S:=S+Format('%4d',[I]);
Inc(I);
end;
S:=S+#$0D#$0A;
end;
Memo.Lines.Add(S);
end;
procedure ShowFloydsTriangles(Memo: TMemo);
begin
FloydsTriangle(Memo,5);
FloydsTriangle(Memo,14);
end;
</syntaxhighlight>
{{out}}
<pre>
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
</pre>
=={{header|Draco}}==
<syntaxhighlight lang="draco">proc width(word n) word:
word w;
w := 0;
while n>0 do
w := w + 1;
n := n / 10
od;
w
corp
proc floyd(word rows) void:
word n, row, col, maxno;
maxno := rows * (rows+1)/2;
n := 1;
for row from 1 upto rows do
for col from 1 upto row do
write(n : 1+width(maxno - rows + col));
n := n+1
od;
writeln()
od
corp
proc main() void:
floyd(5);
writeln();
floyd(14)
corp</syntaxhighlight>
{{out}}
<pre> 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</pre>
=={{header|EasyLang}}==
{{trans|Java}}
<syntaxhighlight>
func ceil h .
f = floor h
if h <> f
f += 1
.
return f
.
proc triangle n . .
print n & " rows:"
row = 1
while row <= n
printme += 1
cols = ceil log10 (n * (n - 1) / 2 + nprinted + 2)
numfmt 0 cols
write printme & " "
nprinted += 1
if nprinted = row
print ""
row += 1
nprinted = 0
.
.
print ""
.
triangle 5
triangle 14
</syntaxhighlight>
{{out}}
<pre>
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
</pre>
=={{header|Elixir}}==
<
def triangle(n) do
max = trunc(n * (n + 1) / 2)
Line 1,010 ⟶ 2,850:
Floyd.triangle(5)
Floyd.triangle(14)</
{{out}}
Line 1,036 ⟶ 2,876:
=={{header|Erlang}}==
<
-module( floyds_triangle ).
Line 1,081 ⟶ 2,921:
strings_from_integers( Integers ) -> [erlang:integer_to_list(X) || X <- Integers].
</syntaxhighlight>
{{out}}
<pre>
Line 1,106 ⟶ 2,946:
=={{header|ERRE}}==
<syntaxhighlight lang="erre">
PROGRAM FLOYD
Line 1,127 ⟶ 2,967:
END FOR
END PROGRAM
</syntaxhighlight>
Example for n=14
{{out}}
Line 1,146 ⟶ 2,986:
92 93 94 95 96 97 98 99 100 101 102 103 104 105
</pre>
=={{header|Excel}}==
===LAMBDA===
We can define this declaratively in Excel by binding the name '''floydTriangle''' to the following lambda expression in the Name Manager of the Excel WorkBook:
(See [https://www.microsoft.com/en-us/research/blog/lambda-the-ultimatae-excel-worksheet-function/ LAMBDA: The ultimate Excel worksheet function])
{{Works with|Office 365 betas 2021}}
<syntaxhighlight lang="lisp">floydTriangle
=LAMBDA(n,
IF(0 < n,
LET(
ixs, SEQUENCE(
n, n,
0, 1
),
x, MOD(ixs, n),
y, QUOTIENT(ixs, n),
IF(x > y,
"",
x + 1 + QUOTIENT(
y * (1 + y),
2
)
)
),
""
)
)</syntaxhighlight>
{{Out}}
The formula in cell B2, for example, defines an array which populates the whole range '''B2:F6'''
{| class="wikitable"
|-
|||style="text-align:right; font-family:serif; font-style:italic; font-size:120%;"|fx
! colspan="15" style="text-align:left; vertical-align: bottom; font-family:Arial, Helvetica, sans-serif !important;"|=floydTriangle(A2)
|- style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff;"
|
| A
| B
| C
| D
| E
| F
| G
| H
| I
| J
| K
| L
| M
| N
| O
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 1
| style="font-weight:bold" | Row count
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 2
| style="text-align:right; font-weight:bold" | 5
| style="text-align:right; background-color:#cbcefb" | 1
|
|
|
|
|
|
|
|
|
|
|
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 3
|
| style="text-align:right" | 2
| style="text-align:right" | 3
|
|
|
|
|
|
|
|
|
|
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 4
|
| style="text-align:right" | 4
| style="text-align:right" | 5
| style="text-align:right" | 6
|
|
|
|
|
|
|
|
|
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 5
|
| style="text-align:right" | 7
| style="text-align:right" | 8
| style="text-align:right" | 9
| style="text-align:right" | 10
|
|
|
|
|
|
|
|
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 6
|
| style="text-align:right" | 11
| style="text-align:right" | 12
| style="text-align:right" | 13
| style="text-align:right" | 14
| style="text-align:right" | 15
|
|
|
|
|
|
|
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 7
| style="text-align:right; font-weight:bold" | 14
| style="text-align:right" | 1
|
|
|
|
|
|
|
|
|
|
|
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 8
|
| style="text-align:right" | 2
| style="text-align:right" | 3
|
|
|
|
|
|
|
|
|
|
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 9
|
| style="text-align:right" | 4
| style="text-align:right" | 5
| style="text-align:right" | 6
|
|
|
|
|
|
|
|
|
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 10
|
| style="text-align:right" | 7
| style="text-align:right" | 8
| style="text-align:right" | 9
| style="text-align:right" | 10
|
|
|
|
|
|
|
|
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 11
|
| style="text-align:right" | 11
| style="text-align:right" | 12
| style="text-align:right" | 13
| style="text-align:right" | 14
| style="text-align:right" | 15
|
|
|
|
|
|
|
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 12
|
| style="text-align:right" | 16
| style="text-align:right" | 17
| style="text-align:right" | 18
| style="text-align:right" | 19
| style="text-align:right" | 20
| style="text-align:right" | 21
|
|
|
|
|
|
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 13
|
| style="text-align:right" | 22
| style="text-align:right" | 23
| style="text-align:right" | 24
| style="text-align:right" | 25
| style="text-align:right" | 26
| style="text-align:right" | 27
| style="text-align:right" | 28
|
|
|
|
|
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 14
|
| style="text-align:right" | 29
| style="text-align:right" | 30
| style="text-align:right" | 31
| style="text-align:right" | 32
| style="text-align:right" | 33
| style="text-align:right" | 34
| style="text-align:right" | 35
| style="text-align:right" | 36
|
|
|
|
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 15
|
| style="text-align:right" | 37
| style="text-align:right" | 38
| style="text-align:right" | 39
| style="text-align:right" | 40
| style="text-align:right" | 41
| style="text-align:right" | 42
| style="text-align:right" | 43
| style="text-align:right" | 44
| style="text-align:right" | 45
|
|
|
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 16
|
| style="text-align:right" | 46
| style="text-align:right" | 47
| style="text-align:right" | 48
| style="text-align:right" | 49
| style="text-align:right" | 50
| style="text-align:right" | 51
| style="text-align:right" | 52
| style="text-align:right" | 53
| style="text-align:right" | 54
| style="text-align:right" | 55
|
|
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 17
|
| style="text-align:right" | 56
| style="text-align:right" | 57
| style="text-align:right" | 58
| style="text-align:right" | 59
| style="text-align:right" | 60
| style="text-align:right" | 61
| style="text-align:right" | 62
| style="text-align:right" | 63
| style="text-align:right" | 64
| style="text-align:right" | 65
| style="text-align:right" | 66
|
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 18
|
| style="text-align:right" | 67
| style="text-align:right" | 68
| style="text-align:right" | 69
| style="text-align:right" | 70
| style="text-align:right" | 71
| style="text-align:right" | 72
| style="text-align:right" | 73
| style="text-align:right" | 74
| style="text-align:right" | 75
| style="text-align:right" | 76
| style="text-align:right" | 77
| style="text-align:right" | 78
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 19
|
| style="text-align:right" | 79
| style="text-align:right" | 80
| style="text-align:right" | 81
| style="text-align:right" | 82
| style="text-align:right" | 83
| style="text-align:right" | 84
| style="text-align:right" | 85
| style="text-align:right" | 86
| style="text-align:right" | 87
| style="text-align:right" | 88
| style="text-align:right" | 89
| style="text-align:right" | 90
| style="text-align:right" | 91
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 20
|
| style="text-align:right" | 92
| style="text-align:right" | 93
| style="text-align:right" | 94
| style="text-align:right" | 95
| style="text-align:right" | 96
| style="text-align:right" | 97
| style="text-align:right" | 98
| style="text-align:right" | 99
| style="text-align:right" | 100
| style="text-align:right" | 101
| style="text-align:right" | 102
| style="text-align:right" | 103
| style="text-align:right" | 104
| style="text-align:right" | 105
|}
=={{header|F_Sharp|F#}}==
<
[<EntryPoint>]
Line 1,167 ⟶ 3,403:
printf "%s%d" pad value
printfn ""
0</
Output for 5 and 14 (via command line argument)
<pre style="float:left"> 1
Line 1,188 ⟶ 3,424:
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</pre>
=={{header|Factor}}==
<syntaxhighlight lang="factor">USING: io kernel math math.functions math.ranges prettyprint
sequences ;
IN: rosetta-code.floyds-triangle
: floyd. ( n -- )
[ dup 1 - * 2 / 1 + dup 1 ] [ [1,b] ] bi
[
[
2dup [ log10 1 + >integer ] bi@ -
[ " " write ] times dup pprint bl [ 1 + ] bi@
] times nl [ drop dup ] dip
] each nl 3drop ;
5 14 [ floyd. ] bi@</syntaxhighlight>
{{out}}
<pre>
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
</pre>
=={{header|Forth}}==
<
: width ( n -- n ) s>f flog ftrunc f>s 2 + ;
Line 1,204 ⟶ 3,479:
loop
2drop ;
</syntaxhighlight>
=={{header|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.
<syntaxhighlight lang="fortran">
!-*- mode: compilation; default-directory: "/tmp/" -*-
!Compilation started at Tue May 21 22:55:08
Line 1,273 ⟶ 3,548:
end program p
</syntaxhighlight>
=={{header|FreeBASIC}}==
<
' compile with: fbc -s console
Line 1,328 ⟶ 3,603:
Print : Print "hit any key to end program"
Sleep
End</
{{out}}
<pre>output for 5 output for 14
Line 1,346 ⟶ 3,621:
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</pre>
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/?gist=57ab1f58785b7e07765881657e4589ab Click this link to run this code]'''
<syntaxhighlight lang="gambas">Public Sub Main()
Dim siCount, siNo, siCounter As Short
Dim siLine As Short = 1
Dim 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
Print
Next
End</syntaxhighlight>
Output:
<pre>
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
</pre>
=={{header|Go}}==
<
import "fmt"
Line 1,374 ⟶ 3,702:
}
}
}</
{{out}}
<pre>
Line 1,400 ⟶ 3,728:
</pre>
=={{header|
{{trans|Java}}
<syntaxhighlight lang="groovy">class Floyd {
static void main(String[] args) {
printTriangle(5)
printTriangle(14)
}
private static void printTriangle(int n) {
println(n + " rows:")
int printMe = 1
int numsPrinted = 0
for (int rowNum = 1; rowNum <= n; printMe++) {
int cols = (int) Math.ceil(Math.log10(n * (n - 1) / 2 + numsPrinted + 2))
printf("%" + cols + "d ", printMe)
if (++numsPrinted == rowNum) {
println()
rowNum++
numsPrinted = 0
}
}
}
}</syntaxhighlight>
{{out}}
<pre>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 </pre>
=={{header|Haskell}}==
<syntaxhighlight lang="haskell">--------------------- FLOYDS TRIANGLE --------------------
floydTriangle :: [[Int]]
floydTriangle =
( zipWith
<*> id
)
[1 ..]
--------------------------- TEST -------------------------
main :: IO ()
main = mapM_ (putStrLn . formatFT) [5, 14]
------------------------- DISPLAY ------------------------
formatFT :: Int -> String
formatFT n = unlines $ unwords . zipWith alignR ws <$> t
where
t = take n floydTriangle
ws =
alignR :: Int -> Int -> String
alignR n =
( (<>)
=<< flip replicate ' '
. (-) n
. length
)
. show</syntaxhighlight>
{{Out}}
<pre> 1
2 3
4 5 6
Line 1,429 ⟶ 3,814:
11 12 13 14 15
1
2 3
Line 1,443 ⟶ 3,827:
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, simplifying a little by delegating the recursion scheme to '''mapAccumL'''
<
import Data.List (mapAccumL)
--------------------- FLOYD'S TRIANGLE -------------------
floyd :: Int -> [[Int]]
floyd n =
snd $
mapAccumL
(\
1
[0 ..
--------------------------- TEST -------------------------
main :: IO ()
main = mapM_ putStrLn $
showFloyd :: [[Int]] -> String
showFloyd x =
let padRight n = (drop . length) <*> (replicate n ' ' <>)
in unlines
( fmap
( zipWith
(\n v -> padRight n (show v))
(fmap (succ . length . show) (last x))
>=> id
)
x
)</syntaxhighlight>
{{Out}}
<pre> 1
Line 1,493 ⟶ 3,882:
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</pre>
Or, defining just the relationship between successive terms:
<syntaxhighlight lang="haskell">----------------- LINES OF FLOYDS TRIANGLE ---------------
floyds :: [[Int]]
floyds = iterate floyd [1]
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)
--------------------------- TEST -------------------------
main :: IO ()
main = do
mapM_ print $ take 5 floyds
putStrLn ""
mapM_ print $ take 14 floyds</syntaxhighlight>
{{Out}}
<pre>[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]</pre>
Or as a partially populated matrix:
<syntaxhighlight lang="haskell">import Control.Monad (join)
import Data.Matrix (Matrix, getElem, matrix, nrows, toLists)
--------------------- FLOYDS TRIANGLE --------------------
floyd :: Int -> Matrix (Maybe Int)
floyd n = matrix n n go
where
go (y, x)
| x > y = Nothing
| otherwise = Just (x + quot (pred y * y) 2)
--------------------------- TEST -------------------------
main :: IO ()
main = mapM_ putStrLn $ showFloyd . floyd <$> [5, 14]
------------------------- DISPLAY ------------------------
showFloyd :: Matrix (Maybe Int) -> String
showFloyd m =
(unlines . fmap unwords . toLists) $
go <$> m
where
go Nothing = ""
go (Just n) = padRight w (show n)
Just v = join getElem (nrows m) m
w = length (show v)
padRight :: Int -> String -> String
padRight n = (drop . length) <*> (replicate n ' ' <>)</syntaxhighlight>
{{Out}}
<pre> 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</pre>
=={{header|Icon}} and {{header|Unicon}}==
The following solution works in both languages:
<
n := integer(a[1]) | 5
w := ((n*(n-1))/2)-n
Line 1,508 ⟶ 4,000:
write()
}
end</
Sample outputs:
Line 1,542 ⟶ 4,034:
=={{header|J}}==
Note: <code>require 'strings'</code> does nothing in J7, but is harmless (strings is already incorporated in J7).
<
floyd=: [: rplc&(' 0';' ')"1@":@(* ($ $ +/\@,)) >:/~@:i.</
Note, the parenthesis around ($ $ +/\@,) is optional, and only included for emphasis.
Line 1,551 ⟶ 4,043:
Example use:
<
1
2 3
Line 1,571 ⟶ 4,063:
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:
Line 1,583 ⟶ 4,075:
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:
<
=={{header|Java}}==
<
public class Floyd {
public static void main(String[] args){
Line 1,606 ⟶ 4,098:
}
}
}</
Output:
<pre>5 rows:
Line 1,638 ⟶ 4,130:
:#and a mapping of that expression to a formatted string.
<
'use strict';
Line 1,758 ⟶ 4,250:
return showFloyd(floyd(n)) + '\n';
}, [5, 14]));
})();</
{{Out}}
<pre> 1
Line 1,783 ⟶ 4,275:
===ES6===
{{Trans|Haskell}} (mapAccumL version)
<
'use strict';
Line 1,879 ⟶ 4,371:
return unlines(map(n => showFloyd(floyd(n)) + '\n', [5, 14]))
})();</
{{Out}}
<pre> 1
Line 1,906 ⟶ 4,398:
(Used TCL example as a starting point.)
<
function main() {
Line 1,941 ⟶ 4,433:
}
main();</
{{out}}
Line 1,968 ⟶ 4,460:
=={{header|jq}}==
<
def floyd(n):
def lpad(len): tostring | (((len - length) * " ") + .);
Line 1,990 ⟶ 4,482:
| [ ($i + $row),
($string + "\n" + line($i; $row + 1; $widths )) ] )
| .[1] ) ;</
'''Task:'''
<
{{out}}
<
floyd(5):
1
Line 2,016 ⟶ 4,508:
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 </
=={{header|Julia}}==
<syntaxhighlight lang="julia">function floydtriangle(rows)
r = collect(1:div(rows *(rows + 1), 2))
for i in 1:rows
for j in 1:i
end
println()
end
floydtriangle(5); println(); floydtriangle(14)
</syntaxhighlight>{{out}}
<pre>
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
</pre>
=={{header|Kotlin}}==
{{trans|Java}}
<
internal class Triangle(n: Int) {
Line 2,083 ⟶ 4,564:
}
}
}</
Output as Java.
=={{header|Lasso}}==
{{Output?|Lasso|There should only be one space between the numbers on the last row.}}
<
local(out = array(array(1)),comp = array, num = 1)
while(#out->size < #n) => {
Line 2,111 ⟶ 4,592:
floyds_triangle(5)
'\r\r'
floyds_triangle(14)</
{{out}}
<pre> 1
Line 2,134 ⟶ 4,615:
92 93 94 95 96 97 98 99 100 101 102 103 104 105</pre>
=={{
<
dim colWidth(rowsNeeded) ' 5 rows implies 5 columns
Line 2,151 ⟶ 4,632:
next
print
next</
{{out}}
<pre>Number of rows needed:- 5
Line 2,176 ⟶ 4,657:
92 93 94 95 96 97 98 99 100 101 102 103 104 105 </pre>
=={{
<
local c = 1
local h = rows*(rows-1)/2
Line 2,195 ⟶ 4,676:
print_floyd(5)
print_floyd(14)</
Output:
Line 2,220 ⟶ 4,701:
=={{header|Maple}}==
<
local num, numRows, numInRow, i, digits;
digits := Array([]);
Line 2,250 ⟶ 4,731:
floyd(5);
floyd(14);</
{{out}}
<pre>
Line 2,275 ⟶ 4,756:
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">
f=Function[n,
Most/@(Range@@@Partition[FindSequenceFunction[{1,2,4,7,11}]/@Range[n+1],2,1])]
TableForm[f@5,TableAlignments->Right,TableSpacing->{1,1}]
TableForm[f@14,TableAlignments->Right,TableSpacing->{1,1}]
</syntaxhighlight>
Output:
<pre>
Line 2,306 ⟶ 4,787:
=={{header|MATLAB}} / {{header|Octave}}==
<
s = 1;
for k = 1 : n
disp(s : s + k - 1)
s = s + k;
end</
{{out}}:
<pre>
Line 2,321 ⟶ 4,802:
11 12 13 14 15
</pre>
=={{header|Maxima}}==
<syntaxhighlight lang="maxima">
floyd_t(m):=block(
t:m*(m+1)/2,
L1:makelist(makelist(k,k,1,t),j,0,m),
L2:makelist(rest(L1[i],((i-1)^2+(i-1))/2),i,1,m+1),
makelist(firstn(L2[i],i),i,1,m),
table_form(%%))$
/* Test cases */
floyd_t(5);
floyd_t(14);
</syntaxhighlight>
[[File:FloydTriangleMaxima5.png|thumb|center]]
[[File:FloydTriangleMaxima14.png|thumb|center]]
=={{header|Miranda}}==
<Syntaxhighlight lang="miranda">main :: [sys_message]
main = [Stdout (lay (map floyd [5, 14]))]
floyd :: num->[char]
floyd n = lay (map fmt rws)
where rws = rows n
cws = map ((+1).width) (last rws)
fmt rw = concat (map (uncurry rjust) (zip2 cws rw))
rows :: num->[[num]]
rows n = rows' [1..n] [1..]
where rows' [] ns = []
rows' (l:ls) ns = row : rows' ls rest
where (row, rest) = split l ns
split :: num->[*]->([*],[*])
split n ls = (take n ls, drop n ls)
rjust :: num->num->[char]
rjust w n = reverse (take w (reverse (show n) ++ repeat ' '))
width :: num->num
width = (#) . show
uncurry :: (*->**->***)->(*,**)->***
uncurry f (a,b) = f a b</syntaxhighlight>
{{out}}
<pre> 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
</pre>
=={{header|Modula-2}}==
<syntaxhighlight lang="modula2">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)
END
END Print;
BEGIN
Print(5);
WriteLn;
Print(14);
ReadChar
END FloydTriangle.</syntaxhighlight>
{{out}}
<pre> 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</pre>
=={{header|NetRexx}}==
Line 2,326 ⟶ 4,933:
===Version 1===
{{Trans|REXX}}
<
options replace format comments java crossref symbols binary
/* REXX ***************************************************************
Line 2,353 ⟶ 4,960:
end i
Say ll -- output last line
</syntaxhighlight>
'''Output:
<pre>
Line 2,383 ⟶ 4,990:
===Version 2===
{{Trans|REXX}}
<
options replace format comments java crossref symbols binary
/*REXX program constructs & displays Floyd's triangle for any number of rows.*/
Line 2,402 ⟶ 5,009:
say output
end row
</syntaxhighlight>
'''Output:
Line 2,434 ⟶ 5,041:
=={{header|Nim}}==
{{trans|Python}}
<
proc floyd(rowcount = 5): seq[seq[int]] =
Line 2,445 ⟶ 5,052:
result.add row
proc pfloyd(rows: seq[seq[int]]) =
var colspace = newSeq[int]()
for n in rows[rows.high]: colspace.add(($n).len)
Line 2,452 ⟶ 5,059:
stdout.write align($x, colspace[i])," "
echo ""
for i in [5, 14]:
pfloyd(floyd(i))
echo ""</
Output:
<pre> 1
2 3
4 5 6
Line 2,483 ⟶ 5,087:
=={{header|OCaml}}==
<
let rec last = function x::[] -> x | _::tl -> last tl | [] -> raise Not_found
let rec list_map2 f l1 l2 =
Line 2,508 ⟶ 5,112:
let () =
print_floyd (floyd (int_of_string Sys.argv.(1)))</
=={{header|OxygenBasic}}==
{{output?|OxygenBasic}}
<
function Floyd(sys n) as string
sys i,t
Line 2,540 ⟶ 5,144:
putfile "s.txt",Floyd(5)+floyd(14)
</syntaxhighlight>
=={{header|PARI/GP}}==
<syntaxhighlight lang="parigp">{floyd(m)=my(lastrow_a,lastrow_e,lastrow_len=m,fl,idx);
lastrow_e=m*(m+1)/2;lastrow_a=lastrow_e+1-m;
fl=vector(lastrow_len);
for(k=1,m,fl[k] = 1 + #Str(k-1+lastrow_a) );
\\
idx=0;
for(i=1,m,
for(j=1,i,
idx++;
printf(Str("%" fl[j] "d"),idx)
);
print()
);
return();}
floyd(5)
floyd(14)
</syntaxhighlight>
{{out}}
<pre>
1
2 3
4 5 6
7 8 9 10
11 12 13 14 15
</pre>
=={{header|Pascal}}==
{{works with|Free_Pascal}}
<
function digits(number: integer): integer;
Line 2,626 ⟶ 5,244:
writeln ('*** Floyd 14 ***');
floyd2(14);
end.</
Output:
<pre>% ./Floyd
Line 2,654 ⟶ 5,272:
=={{header|Perl}}==
{{Trans|NetRexx}}
<
use strict;
use warnings;
Line 2,688 ⟶ 5,306:
0;
__END__
</syntaxhighlight>
'''Output:
<pre>
Line 2,716 ⟶ 5,334:
92 93 94 95 96 97 98 99 100 101 102 103 104 105
</pre>
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">Floyds_triangle</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">widths</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">k</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">n</span> <span style="color: #0000FF;">*</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">))/</span><span style="color: #000000;">2</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">n</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">widths</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%%%dd"</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%d"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">i</span><span style="color: #0000FF;">+</span><span style="color: #000000;">k</span><span style="color: #0000FF;">))+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #000000;">k</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">n</span> <span style="color: #008080;">do</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">j</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">i</span> <span style="color: #008080;">do</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">widths</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">],</span><span style="color: #000000;">k</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">k</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #000000;">Floyds_triangle</span><span style="color: #0000FF;">(</span><span style="color: #000000;">5</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">Floyds_triangle</span><span style="color: #0000FF;">(</span><span style="color: #000000;">14</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
{{out}}
<pre style="float:left">
Line 2,804 ⟶ 5,383:
=={{header|PHP}}==
<
<?php
floyds_triangle(5);
Line 2,822 ⟶ 5,401:
}
?>
</syntaxhighlight>
{{out}}
<pre>
Line 2,847 ⟶ 5,426:
92 93 94 95 96 97 98 99 100 101 102 103 104 105
</pre>
=={{header|Picat}}==
===List comprehension===
<syntaxhighlight lang="picat">import util.
% Calculate the numbers first and then format them
floyd1(N) = S =>
M = [[J+SS : J in 1..I] : I in 1..N, SS=sum(1..I-1)],
S = [slice(SS,2) : Row in M, SS = [to_fstring(to_fstring("%%%dd",M[N,I].to_string().length+1),E) :
{E,I} in zip(Row,1..Row.length)].join('')].join("\n").</syntaxhighlight>
===Loop based===
{{trans|Prolog}}
Picat doesn't support all of SWI-Prolog's nifty format options so we have to tweak a bit.
<syntaxhighlight lang="picat">
floyd2(N) = S =>
S = [],
foreach(I in 1..N)
SS = "",
foreach(J in 1..I)
Last = N * (N-1)/2+J,
V = I * (I-1) // 2 + J,
C = Last.to_string().length-1,
SS := SS ++ to_fstring(to_fstring("%%%dd",C), V)
end,
S := S ++ slice(SS,2) ++ "\n"
end.</syntaxhighlight>
===Test===
<syntaxhighlight lang="picat">
go =>
println("N=5:"),
println(floyd1(5)),
nl,
println("N=14:"),
println(floyd2(14)),
nl.</syntaxhighlight>
{{out}}
<pre>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</pre>
=={{header|PicoLisp}}==
===Calculate widths relative to lower left corner===
<
(let LLC (/ (* N (dec N)) 2)
(for R N
Line 2,858 ⟶ 5,498:
(length (+ LLC C))
(+ C (/ (* R (dec R)) 2)) ) )
(if (= C R) (prinl) (space)) ) ) ) )</
===Pre-calculate all rows, and take format from last one===
<
(let
(Rows
Line 2,869 ⟶ 5,509:
(map inc (cdr Fmt))
(for R Rows
(apply tab R Fmt) ) ) )</
Output in both cases:
<pre>: (floyd 5)
Line 2,895 ⟶ 5,535:
=={{header|PL/I}}==
<
floyd: procedure options (main); /* Floyd's Triangle. Wiki 12 July 2012 */
Line 2,911 ⟶ 5,551:
end;
end floyd;</
{{out}}
Line 2,941 ⟶ 5,581:
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
</pre>
=={{header|PL/M}}==
<syntaxhighlight lang="plm">100H:
BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS;
EXIT: PROCEDURE; GO TO 0; END EXIT;
PRINT: PROCEDURE (S); DECLARE S ADDRESS; CALL BDOS(9,S); END PRINT;
PUT$NUM: PROCEDURE (N, WIDTH);
DECLARE S (6) BYTE INITIAL (' $');
DECLARE N ADDRESS, (I, WIDTH) BYTE;
I = 5;
DIGIT:
S(I := I-1) = N MOD 10 + '0';
IF (N := N/10) > 0 THEN GO TO DIGIT;
DO I=I-1 TO 0 BY -1;
S(I) = ' ';
END;
CALL PRINT(.S(6-WIDTH));
END PUT$NUM;
WIDTH: PROCEDURE (N) BYTE;
DECLARE (N, W) BYTE;
W = 1;
DO WHILE N>0;
N = N/10;
W = W+1;
END;
RETURN W;
END WIDTH;
FLOYD: PROCEDURE (ROWS);
DECLARE (ROWS, ROW, COL) BYTE;
DECLARE (N, MAXNO) ADDRESS;
MAXNO = ROWS * (ROWS+1)/2;
N = 1;
DO ROW = 1 TO ROWS;
DO COL = 1 TO ROW;
CALL PUT$NUM(N, 1 + WIDTH(MAXNO - ROWS + COL));
N = N+1;
END;
CALL PRINT(.(13,10,'$'));
END;
END FLOYD;
CALL FLOYD(5);
CALL PRINT(.(13,10,'$'));
CALL FLOYD(14);
CALL EXIT;
EOF</syntaxhighlight>
{{out}}
<pre> 1
2 3
4 5 6
7 8 9 10
11 12 13 14 15
11
12 13
14 15 16
17 18 19 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</pre>
=={{header|Prolog}}==
Works with SWI-Prolog version 6.5.3
<
forall(between(1, N, I),
( forall(between(1,I, J),
Line 2,957 ⟶ 5,669:
get_column(Last, C) :-
name(Last, N1), length(N1,C).
</syntaxhighlight>
Output :
<pre> ?- floyd(5).
Line 2,987 ⟶ 5,699:
=={{header|PureBasic}}==
<
Protected r,i
For i=1 To n
Line 3,036 ⟶ 5,748:
Print(#crlf$ + #crlf$ + "Press ENTER to exit"): Input()
CloseConsole()
EndIf</
'''Sample Output'''
Line 3,062 ⟶ 5,774:
=={{header|Python}}==
===Procedural===
<syntaxhighlight lang="python">>>> def floyd(rowcount=5):
rows = [[1]]
while len(rows) < rowcount:
Line 3,103 ⟶ 5,816:
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
>>> </
===Functional===
Using the mathematical formula for each row directly,
either in a list comprehension:
<syntaxhighlight lang="python">def floyd(rowcount=5):
return [list(range(i * (i - 1) // 2 + 1, i * (i + 1) // 2 + 1))
for i in range(1, rowcount + 1)]</syntaxhighlight>
or in terms of concatMap:
{{Works with|Python|3}}
<syntaxhighlight lang="python">'''Floyd triangle in terms of concatMap'''
from itertools import chain
# floyd :: Int -> [[Int]]
def floyd(n):
'''n rows of a Floyd triangle.'''
def f(i):
return [
enumFromTo(i * pred(i) // 2 + 1)(
i * succ(i) // 2
)
]
return concatMap(f)(enumFromTo(1)(n))
# main :: IO ()
def main():
'''Test'''
print(unlines(
map(str, floyd(5))
))
# GENERIC FUNCTIONS ---------------------------------------
# enumFromTo :: (Int, Int) -> [Int]
def enumFromTo(m):
'''Integer enumeration from m to n.'''
return lambda n: list(range(m, 1 + n))
# concatMap :: (a -> [b]) -> [a] -> [b]
def concatMap(f):
'''Concatenated list over which a function has been mapped.
The list monad can be derived by using a function f which
wraps its output in a list,
(using an empty list to represent computational failure).'''
return lambda xs: list(
chain.from_iterable(
map(f, xs)
)
)
# pred :: Enum a => a -> a
def pred(x):
'''The predecessor of a value. For numeric types, (- 1).'''
return x - 1 if isinstance(x, int) else (
chr(ord(x) - 1)
)
# succ :: Enum a => a -> a
def succ(x):
'''The successor of a value. For numeric types, (1 +).'''
return 1 + x if isinstance(x, int) else (
chr(1 + ord(x))
)
# unlines :: [String] -> String
def unlines(xs):
'''A single string derived by the intercalation
of a list of strings with the newline character.'''
return '\n'.join(xs)
if __name__ == '__main__':
main()</syntaxhighlight>
Or alternatively, defining just the relationship between successive terms:
{{Works with|Python|3}}
<syntaxhighlight lang="python">'''Floyd triangle in terms of iterate(f)(x)'''
from itertools import islice
# floyd :: Int -> [[Int]]
def floyd(n):
'''n rows of a Floyd triangle.'''
return take(n)(iterate(nextFloyd)([1]))
# nextFloyd :: [Int] -> [Int]
def nextFloyd(xs):
'''A Floyd triangle row derived from
the preceding row.'''
n = succ(len(xs))
return [1] if n < 2 else (
enumFromTo(succ(n * pred(n) // 2))(
n * succ(n) // 2
)
)
# showFloyd :: [[Int]] -> String
def showFloyd(xs):
'''A stringification of Floyd triangle rows.'''
return unlines(str(x) for x in xs)
# main :: IO ()
def main():
'''Test'''
print(showFloyd(
floyd(5)
))
# GENERIC ABSTRACTIONS ------------------------------------
# enumFromTo :: (Int, Int) -> [Int]
def enumFromTo(m):
'''Integer enumeration from m to n.'''
return lambda n: list(range(m, 1 + n))
# iterate :: (a -> a) -> a -> Gen [a]
def iterate(f):
'''An infinite list of repeated applications of f to x.'''
def go(x):
v = x
while True:
yield v
v = f(v)
return lambda x: go(x)
# pred :: Enum a => a -> a
def pred(x):
'''The predecessor of a value. For numeric types, (- 1).'''
return x - 1 if isinstance(x, int) else (
chr(ord(x) - 1)
)
# succ :: Enum a => a -> a
def succ(x):
'''The successor of a value. For numeric types, (1 +).'''
return 1 + x if isinstance(x, int) else (
chr(1 + ord(x))
)
# take :: Int -> [a] -> [a]
# take :: Int -> String -> String
def take(n):
'''The prefix of xs of length n,
or xs itself if n > length xs.'''
return lambda xs: (
xs[0:n]
if isinstance(xs, list)
else list(islice(xs, n))
)
# unlines :: [String] -> String
def unlines(xs):
'''A single string derived by the intercalation
of a list of strings with the newline character.'''
return '\n'.join(xs)
# MAIN ----------------------------------------------------
if __name__ == '__main__':
main()</syntaxhighlight>
{{Out}}
<pre>[1]
[2, 3]
[4, 5, 6]
[7, 8, 9, 10]
[11, 12, 13, 14, 15]</pre>
=={{header|q}}==
<syntaxhighlight lang="q">
floyd:{n:1+ til sum 1+til x;
t:d:0;
while[1+x-:1;0N!(t+:1)#(d+:t)_n]}
floyd2:{n:1+ til sum 1+til x;
t:d:0;
while[1+x-:1;1 (" " sv string each (t+:1)#(d+:t)_n),"\n"]}
//The latter function 'floyd2' includes logic to remove the leading "," before "1" in the first row.
floyd[5]
floyd2[14]</syntaxhighlight>
{{out}}
<pre>
,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
</pre>
=={{header|Quackery}}==
<syntaxhighlight lang="quackery"> [ dup 1+ * 2 / ] is triangulared ( n --> n )
[ number$ tuck size -
times sp echo$ ] is rightecho ( n n --> )
[ dup triangulared
number$ size 1+
0 rot times
[ i^ 1+ times
[ 1+ 2dup
rightecho ]
cr ]
2drop ] is floyd ( n --> )
5 floyd
cr
14 floyd</syntaxhighlight>
{{out}}
<pre> 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
</pre>
=={{header|R}}==
If it weren't for the printing requirements, we could do this in one line.
<syntaxhighlight lang="rsplus">Floyd <- function(n)
{
#The first argument of the seq call is a well-known formula for triangle numbers.
out <- t(sapply(seq_len(n), function(i) c(seq(to = 0.5 * (i * (i + 1)), by = 1, length.out = i), rep(NA, times = n - i))))
dimnames(out) <- list(rep("", times = nrow(out)), rep("", times = ncol(out)))
print(out, na.print = "")
}
Floyd(5)
Floyd(14)</syntaxhighlight>
{{out}}
<pre>
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</pre>
=={{header|Racket}}==
<
#lang racket
(require math)
Line 3,130 ⟶ 6,142:
(floyd 5)
(floyd 14)
</syntaxhighlight>
Output:
<pre>
Line 3,154 ⟶ 6,166:
</pre>
=={{header|Raku}}==
(formerly Perl 6)
Here's two ways of doing it.
<syntaxhighlight lang="raku" line>constant @floyd1 = (1..*).rotor(1..*);
constant @floyd2 = gather for 1..* -> $s { take [++$ xx $s] }
sub format-rows(@f) {
my @table;
my @formats = @f[@f-1].map: {"%{.chars}s"}
for @f -> @row {
@table.push: (@row Z @formats).map: -> ($i, $f) { $i.fmt($f) }
}
join "\n", @table;
}
say format-rows(@floyd1[^5]);
say '';
say format-rows(@floyd2[^14]);</syntaxhighlight>
{{out}}
<pre> 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</pre>
=={{header|Refal}}==
<syntaxhighlight lang="refal">$ENTRY Go {
= <Prout <Floyd 5>>
<Prout <Floyd 14>>;
};
Floyd {
s.N, <Rows s.N>: e.Rows,
e.Rows: e.X (e.MaxRow),
<Each Width e.MaxRow>: e.ColWidths =
<Each ((e.ColWidths)) FormatRow e.Rows>;
}
FormatRow {
(e.W) () = '\n';
(s.W e.WS) (s.C e.CS) = <Cell <+ 1 s.W> s.C> <FormatRow (e.WS) (e.CS)>;
};
Cell {
s.Width s.N, <Repeat s.Width ' '> <Symb s.N>: e.Rfill,
<Last s.Width e.Rfill>: (e.X) e.Cell = e.Cell;
}
Rows {
s.Rows = <Rows s.Rows 1 1>;
s.Rows s.Row s.N, <+ s.Rows 1>: s.Row = ;
s.Rows s.Row s.N, <+ s.N s.Row>: s.Next =
(<Row s.N <- s.Next 1>>)
<Rows s.Rows <+ s.Row 1> s.Next>;
}
Row {
s.To s.To = s.To;
s.From s.To = s.From <Row <+ s.From 1> s.To>;
};
Each {
s.F e.X = <Each () s.F e.X>;
(e.Arg) s.F = ;
(e.Arg) s.F t.I e.X = <Mu s.F e.Arg t.I> <Each (e.Arg) s.F e.X>;
};
Width {
s.N, <Symb s.N>: e.X, <Lenw e.X>: s.Width e.X = s.Width;
};
Repeat {
0 s.X = ;
s.N s.X = s.X <Repeat <- s.N 1> s.X>;
};</syntaxhighlight>
{{out}}
<pre> 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</pre>
=={{header|REXX}}==
===version 1===
<
/* REXX ***************************************************************
* Parse Arg rowcount
Line 3,179 ⟶ 6,302:
end
Say ll /* output last line */
</syntaxhighlight>
Output:
<pre>
Line 3,206 ⟶ 6,329:
</pre>
===version 2, simple formula===
This REXX version uses a simple formula to calculate the maximum value (triangle element) displayed.
<
parse arg
mx=
say 'displaying a '
say /*display a blank line below the title.*/
#=1; do
say substr(_, 2) /*remove 1st leading blank in the line.*/
end
<pre>
displaying a 5 row Floyd's triangle:
Line 3,229 ⟶ 6,352:
11 12 13 14 15
</pre>
<pre>
displaying a 14 row Floyd's triangle:
Line 3,248 ⟶ 6,371:
92 93 94 95 96 97 98 99 100 101 102 103 104 105
</pre>
<pre>
··· 44 rows not shown ···
Line 3,255 ⟶ 6,378:
===version 3, hexadecimal===
<
parse arg
mx=
say 'displaying a '
say
do #=# for r;
_=_ right( d2x(#), length( d2x(mx+i)
end /*#*/
say substr(_, 2)
end /*r*/
<pre>
displaying a 6 row Floyd's triangle in base 16:
Line 3,277 ⟶ 6,400:
10 11 12 13 14 15
</pre>
<pre>
displaying a 23 row Floyd's triangle in base 16:
Line 3,308 ⟶ 6,431:
===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.
<syntaxhighlight lang="rexx">/*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=
say 'displaying a '
say
do #=# for r;
_=_ right(base(#, radx), length( base(mx+i, radx) ) ) /*build triangle row.*/
end /*#*/
say substr(_, 2)
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
Line 3,328 ⟶ 6,453:
@@@= '0123456789'@abc || @abcU /*prefix 'em with numeric digits.*/
@@@=@@@'<>[]{}()?~!@#$%^&*_=|\/;:¢¬≈' /*add some special chars as well.*/
/* [↑]
numeric digits 3000 /*what the hey, support gihugeics*/
mxB=length(@@@) /*max base (radix) supported here*/
Line 3,339 ⟶ 6,464:
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" ? */
Line 3,352 ⟶ 6,478:
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──► " mxB
erd: call ser 'illegal "digit" in' x":" _
erm: call ser 'no argument specified.'
ser: say; say '***error***'; say arg(1); say; exit 13</
<pre>
displaying a 6 row Floyd's triangle in base 2:
Line 3,368 ⟶ 6,494:
10000 10001 10010 10011 10100 10101
</pre>
<pre>
displaying a 12 row Floyd's triangle in base 2:
Line 3,385 ⟶ 6,511:
1000011 1000100 1000101 1000110 1000111 1001000 1001001 1001010 1001011 1001100 1001101 1001110
</pre>
<pre>
displaying a 40 row Floyd's triangle in base 81:
Line 3,432 ⟶ 6,558:
=={{header|Ring}}==
<
rows = 10
n = 0
Line 3,442 ⟶ 6,568:
see nl
next
</syntaxhighlight>
Output:
<pre>
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
</pre>
=={{header|RPL}}==
HP-28 display has 4 lines only, so the task must be run on an HP-48 or greater to achieve n=5, with the advantage of benefitting from additional instructions: <code>INCR</code> increments a variable and returns its updated value and <code>FREEZE</code> acts as a <code>DO UNTIL KEY END</code> loop.
n=14 is out of reach for HP-48+, since only capable of displaying 22 characters per line.
{| class="wikitable"
! RPL code
! Comment
|-
|
≪
0 → c
≪ CLLCD 1 5 '''FOR''' line
"" '''DO'''
'''IF''' c 9 < '''THEN''' " " + '''END'''
'c' INCR →STR + " " +
'''UNTIL''' line DUP 1 + * 2 / c == '''END'''
line DISP
'''NEXT''' 3 FREEZE
≫ ≫ ‘'''FLOYD'''’ STO
|
'''FLOYD''' ''( -- )''
initialize counter
clear screen, for line=1 to 5
initialize output string, loop
if counter<9 then add one space
increment counter and put it in string
until line*(line+1)/2 == counter
display string
freeze screen until key pressed
.
|}
====Output====
[https://aerobarfilms.files.wordpress.com/2023/04/hp-48-floyds-triangle-1-15.png Screenshot from HP-48 emulator]
=={{header|Ruby}}==
<
max = (rows * (rows + 1)) / 2
widths = ((max - rows + 1)..max).map {|n| n.to_s.length + 1}
Line 3,455 ⟶ 6,633:
floyd(5)
floyd(14)</
{{out}}
Line 3,481 ⟶ 6,659:
=={{header|Run BASIC}}==
<
dim colSize(rows)
for col=1 to rows
Line 3,494 ⟶ 6,672:
next
print
next</
<pre>Number of rows: ?14
1
Line 3,510 ⟶ 6,688:
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 </pre>
=={{header|Rust}}==
<syntaxhighlight lang="rust">fn main() {
floyds_triangle(5);
floyds_triangle(14);
}
fn floyds_triangle(n: u32) {
let mut triangle: Vec<Vec<String>> = Vec::new();
let mut current = 0;
for i in 1..=n {
let mut v = Vec::new();
for _ in 0..i {
current += 1;
v.push(current);
}
let row = v.iter().map(|x| x.to_string()).collect::<Vec<_>>();
triangle.push(row);
}
for row in &triangle {
let arranged_row: Vec<_> = row
.iter()
.enumerate()
.map(|(i, number)| {
let space_len = triangle.last().unwrap()[i].len() - number.len() + 1;
let spaces = " ".repeat(space_len);
let mut padded_number = spaces;
padded_number.push_str(&number);
padded_number
})
.collect();
println!("{}", arranged_row.join(""))
}
}
</syntaxhighlight>
=={{header|Scala}}==
<
val s = (1 to n)
val t = s map {i => (s
(s zip t) foreach { n =>
Line 3,531 ⟶ 6,746:
// Test
floydstriangle(5)
floydstriangle(14)</
{{out}}
<pre>
Line 3,558 ⟶ 6,773:
=={{header|Seed7}}==
<
const proc: writeFloyd (in integer: rows) is func
Line 3,584 ⟶ 6,799:
writeFloyd(5);
writeFloyd(14);
end func;</
Output:
Line 3,608 ⟶ 6,823:
92 93 94 95 96 97 98 99 100 101 102 103 104 105
</pre>
=={{header|SETL}}==
<syntaxhighlight lang="setl">program floyd_triangle;
floyd(5);
print;
floyd(14);
print;
proc floyd(rows);
maxno := rows * (rows+1) div 2;
n := 1;
loop for row in [1..rows] do
loop for col in [1..row] do
nprint(lpad(str n, 1 + #str (maxno - rows + col)));
n +:=1;
end loop;
print;
end loop;
end proc;
end program;
</syntaxhighlight>
{{out}}
<pre> 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</pre>
=={{header|Sidef}}==
<
var max = Math.range_sum(1, rows)
var widths = (max-rows .. max-1 -> map{
{ |r|
say %'#{1..r -> map{|i| "%#{widths[i-1]}d"
}
}
floyd(5)
floyd(14)
{{out}}
<pre>
Line 3,641 ⟶ 6,898:
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
</pre>
=={{header|SPL}}==
<syntaxhighlight lang="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)
<
.</syntaxhighlight>
{{out}}
<pre>
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
</pre>
=={{header|Tcl}}==
<
# Compute the column widths
for {set i [expr {$n*($n-1)/2+1}]} {$i <= $n*($n+1)/2} {incr i} {
Line 3,662 ⟶ 6,958:
floydTriangle 5
puts "Floyd 14:"
floydTriangle 14</
{{out}}
<pre>
Line 3,690 ⟶ 6,986:
=={{header|TXR}}==
<
(let* ((last (trunc (* n (+ n 1)) 2))
(colw (mapcar [chain tostring length]
Line 3,708 ⟶ 7,004:
((num blah . etc) (usage "too many arguments"))
((num) (flotri (int-str num)))
(() (usage "need an argument")))</
{{out}}
Line 3,741 ⟶ 7,037:
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</pre>
=={{header|Uiua}}==
Probably terrible and unidiomatic...
<syntaxhighlight lang="Uiua">
Floyd ← ⇌⍥(⊂⍚(+⇡∩(+1)⊃⧻(⊢⇌))⊢.):{[1]}-1
JoinUsing ← ↘1/◇⊂≡(□◇⊂)↯:⊙(⧻.)□
PadL ← ⊂/⊂↯:" "
Lengths ← ⍚∵◇∵(⧻°⋕)°□
PrintIt ← (
# Create table of [last row sizes] [this row sizes] [this row numbers]
⊢⊞⊂⊢⊢↙¯1.⍉[Lengths.]
≡(
# Calculate last row sizes - this row sizes and use to calculate paddings
⍉⊟⊃(-:↙:⊙(⧻.)∩°□°⊟↙2)(°⋕°□⊢↘2)
&pJoinUsing " " ≡(⍚PadL°⊟)
)
)
PrintIt Floyd 4
PrintIt Floyd 14
</syntaxhighlight>
{{out}}
<pre>
1
2 3
4 5 6
7 8 9 10
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
</pre>
=={{header|VBA}}==
Solution in Microsoft Office Word. Based on VBScript
<syntaxhighlight lang="vb">Option Explicit
Dim o As String
Sub 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
Next
End Sub
Sub 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 With
End Sub</syntaxhighlight>
{{out}}
<syntaxhighlight lang="text">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</syntaxhighlight>
=={{header|VBScript}}==
{{works with|Windows Script Host|*}}
<syntaxhighlight lang="vbscript">
' Read the number of rows to use..
intRows = WScript.StdIn.ReadLine
Line 3,760 ⟶ 7,152:
WScript.StdOut.WriteLine ""
Next
</syntaxhighlight>
=={{header|Visual Basic .NET}}==
{{trans|C#}}
<syntaxhighlight lang="vbnet">Imports System.Text
Module Module1
Function MakeTriangle(rows As Integer) As String
Dim maxValue As Integer = (rows * (rows + 1)) / 2
Dim digit = 0
Dim output As New StringBuilder
For row = 1 To rows
For column = 0 To row - 1
Dim colMaxDigit = (maxValue - rows) + column + 1
If column > 0 Then
output.Append(" ")
End If
digit = digit + 1
output.Append(digit.ToString().PadLeft(colMaxDigit.ToString().Length))
Next
output.AppendLine()
Next
Return output.ToString()
End Function
Sub Main()
Dim args = Environment.GetCommandLineArgs()
Dim count As Integer
If args.Length > 1 AndAlso Integer.TryParse(args(1), count) AndAlso count > 0 Then
Console.WriteLine(MakeTriangle(count))
Else
Console.WriteLine(MakeTriangle(5))
Console.WriteLine()
Console.WriteLine(MakeTriangle(14))
End If
End Sub
End Module</syntaxhighlight>
{{out}}
<pre> 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</pre>
=={{header|Wren}}==
{{libheader|Wren-fmt}}
<syntaxhighlight lang="wren">import "./fmt" for Fmt
var floyd = Fn.new { |n|
var k = 1
for (i in 1..n) {
for (j in 1..i) {
Fmt.write("$*d ", (j < 9) ? 2 : 3, k)
k = k + 1
}
System.print()
}
}
System.print("Floyd(5):")
floyd.call(5)
System.print("\nFloyd(14):")
floyd.call(14)</syntaxhighlight>
{{out}}
<pre>
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
</pre>
=={{header|XPL0}}==
<
func IntLen(N); \Return number of digits in a positive integer
Line 3,786 ⟶ 7,288:
[Floyd(5);
Floyd(14);
]</
Output:
Line 3,813 ⟶ 7,315:
=={{header|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 floydsTriangle(rows){
fmt:=[lcNum(rows-1)..lcNum(rows)-1].pump(String,fcn(n){
Line 3,823 ⟶ 7,325:
}
floydsTriangle(5); println();
floydsTriangle(14);</
{{out}}
<pre>
Line 3,849 ⟶ 7,351:
=={{header|ZX Spectrum Basic}}==
<
20 FOR r=1 TO n
30 FOR j=j TO j+r-1
Line 3,857 ⟶ 7,359:
70 PRINT
80 LET col=1
90 NEXT r</
| |||