Rosetta Code

Floyd's triangle: Difference between revisions

Page Discussion

Floyd's triangle (view source)

Revision as of 22:16, 22 March 2024

31,955 bytes added ,  1 month ago
Added XBasic
(Added XBasic)
 
(38 intermediate revisions by 17 users not shown)
Line 24:
{{trans|Python}}
 
<langsyntaxhighlight lang="11l">F floyd(rowcount)
V rows = [[1]]
L rows.len < rowcount
Line 37:
 
pfloyd(floyd(5))
pfloyd(floyd(14))</langsyntaxhighlight>
 
{{out}}
Line 66:
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]] .
<langsyntaxhighlight lang="360asm">* Floyd's triangle 21/06/2018
FLOYDTRI PROLOG
L R5,NN nn
Line 104:
ZN DC X'4020202020202020' mask CL8 7num
YREGS
END FLOYDTRI</langsyntaxhighlight>
{{out}}
<pre>
Line 130:
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!}}==
<langsyntaxhighlight Actionlang="action!">PROC Triangle(BYTE level)
INT v,i
BYTE x,y
Line 182 ⟶ 270:
 
LMARGIN=oldLMARGIN ;restore left margin on the screen
RETURN</langsyntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Floyd's_triangle.png Screenshot from Atari 8-bit computer]
Line 209 ⟶ 297:
=={{header|Ada}}==
 
<syntaxhighlight lang="ada">
<lang Ada>
with Ada.Text_IO, Ada.Integer_Text_IO, Ada.Command_Line;
 
Line 222 ⟶ 310:
end loop;
end Floyd_Triangle;
</syntaxhighlight>
</lang>
{{out}}
 
Line 252 ⟶ 340:
=={{header|ALGOL 68}}==
{{works with|ALGOL 68G|Any - tested with release 2.8.win32}}
<langsyntaxhighlight lang="algol68"># procedure to print a Floyd's Triangle with n lines #
PROC floyds triangle = ( INT n )VOID:
BEGIN
Line 284 ⟶ 372:
floyds triangle( 14 )
 
)</langsyntaxhighlight>
{{out}}
<pre>
Line 310 ⟶ 398:
 
=={{header|ALGOL W}}==
{{trans| ALgOL_68ALGOL_68}}
<langsyntaxhighlight lang="algolw">begin
% prints a Floyd's Triangle with n lines %
procedure floydsTriangle ( integer value n ) ;
Line 351 ⟶ 439:
floydsTriangle( 14 )
 
end.</langsyntaxhighlight>
{{out}}
<pre>
Line 375 ⟶ 463:
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)
<langsyntaxhighlight AppleScriptlang="applescript">-- FLOYDs TRIANGLE -----------------------------------------------------------
 
-- floyd :: Int -> [[Int]]
Line 654 ⟶ 774:
return lst
end tell
end zipWith</langsyntaxhighlight>
{{Out}}
<pre> 1
Line 680 ⟶ 800:
Or, defining only the relationship between successive terms:
 
<langsyntaxhighlight lang="applescript">-- floyd :: [Int] -> [Int]
on floyd(xs)
set n to succ(length of xs)
Line 887 ⟶ 1,007:
set my text item delimiters to dlm
str
end unlines</langsyntaxhighlight>
{{Out}}
<pre> 1
Line 894 ⟶ 1,014:
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 {}
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
 
 
-- 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
xs
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 max
 
 
-- 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}}==
 
{{incorrect|Arturo|The last line should only have one space between values}}
<langsyntaxhighlight lang="rebol">floydwidth: function [rowcountrows col] .memoize [
floor 2 + log col + 1 + (rows * rows - 1) / 2 10
result: new [[1]]
]
while [rowcount > size result][
 
n: inc last last result
floyd: function [rows][
row: new []
n: 1
loop n..n+size last result 'k -> 'row ++ @[k]
row: 1
'result ++ @[row]
col: 0
while -> row =< rows [
prints pad ~"|n|" width rows col
inc 'col
inc 'n
if col = row [
print ""
col: 0
inc 'row
]
]
return result
]
 
floyd 5
loop [5 14] 'j [
print ""
f: floyd j
floyd 14</syntaxhighlight>
loop f 'row -> print map row 'r [pad to :string r 3]
print ""
]</lang>
 
{{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|AutoHotkey}}==
<langsyntaxhighlight AutoHotkeylang="autohotkey">Floyds_triangle(row){
i = 0
loop %row%
Line 959 ⟶ 1,429:
res.=" "
return % res
}</langsyntaxhighlight>
Examples:<syntaxhighlight lang AutoHotkey="autohotkey">MsgBox % Floyds_triangle(14)</langsyntaxhighlight>
Outputs:<pre> 1
2 3
Line 977 ⟶ 1,447:
 
=={{header|AWK}}==
<langsyntaxhighlight AWKlang="awk">#!/bin/awk -f
 
BEGIN {
Line 992 ⟶ 1,462:
}
}
</syntaxhighlight>
</lang>
<p>output from: awk -f floyds_triangle.awk -v rows=5</p>
<pre>
Line 1,022 ⟶ 1,492:
==={{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.
<langsyntaxhighlight lang="basic">
100 :
110 REM FLOYD'S TRIANGLE
Line 1,034 ⟶ 1,504:
220 HTAB COL: PRINT NR;: NEXT C
230 PRINT : NEXT R
</syntaxhighlight>
</lang>
{{out}}
<pre>]RUN
Line 1,058 ⟶ 1,528:
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">
<lang BASIC256>
function trianglevalue(col, row)
return (row-1)*row\2 + col
Line 1,079 ⟶ 1,550:
print
call printtriangle(14)
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,103 ⟶ 1,574:
92 93 94 95 96 97 98 99 100 101 102 103 104 105
</pre>
 
==={{header|BBC BASIC}}===
<langsyntaxhighlight lang="bbcbasic"> n = 14
num = 1
last = (n^2 - n + 2) DIV 2
Line 1,115 ⟶ 1,587:
NEXT
PRINT
NEXT row</langsyntaxhighlight>
Output for n = 5:
<pre>
Line 1,141 ⟶ 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}}===
<langsyntaxhighlight 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
Line 1,161 ⟶ 1,660:
260 : print
270 next i
280 end</langsyntaxhighlight>
{{Out}}
<pre>Floyd's triangle
Line 1,186 ⟶ 1,685:
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}}
<langsyntaxhighlight ISlang="is-BASICbasic">100 PROGRAM "FloydT.bas"
110 LET N=14:LET J=1
120 TEXT 80
Line 1,197 ⟶ 1,699:
160 NEXT
170 PRINT
180 NEXT</langsyntaxhighlight>
 
==={{header|MasmBasic}}===
'''[http://www.webalice.it/jj2006/Masm32_Tips_Tricks_and_Traps.htm Builds with Masm, UAsm or AsmC plus the MasmBasic library]'''
<langsyntaxhighlight MasmBasiclang="masmbasic">include \masm32\MasmBasic\MasmBasic.inc
SetGlobals rows, columns, ct, maxrows=4
Init
Line 1,220 ⟶ 1,722:
.Until maxrows>13
Inkey
EndOfCode</langsyntaxhighlight>
 
{{out}}
<pre> 1
 
1
2 3
4 5 6
Line 1,246 ⟶ 1,745:
92 93 94 95 96 97 98 99 100 101 102 103 104 105</pre>
 
==={{header|BatchMSX FileBasic}}===
The [[#Chipmunk_Basic|Chipmunk Basic]] solution works without any changes.
{{incorrect|Batch File|The last line should only have one space between values}}
<lang dos>
@echo off
 
==={{header|QBasic}}===
call:floyd 5
<syntaxhighlight lang="qbasic">SUB FloydTriangle (fila)
echo.
DIM numColum(fila)
call:floyd 14
FOR colum = 1 TO fila
pause>nul
numColum(colum) = LEN(STR$(colum + fila * (fila - 1) / 2))
exit /b
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)
:floyd
PRINT
setlocal enabledelayedexpansion
FloydTriangle (14)</syntaxhighlight>
set iterations=%1
set startn=1
set endn=1
 
==={{header|True BASIC}}===
for /l %%i in (1,1,%iterations%) do (
{{trans|QBasic}}
for /l %%j in (!startn!,1,!endn!) do (
<syntaxhighlight lang="qbasic">SUB floydtriangle (fila)
set lastnum=%%j
setDIM /a startn=%%j+1numcolum(0)
MAT REDIM numcolum(fila)
)
FOR colum = 1 TO fila
set /a endn=!startn!+%%i
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)
call:getlength %startn%
PRINT
set digits=%errorlevel%
CALL FLOYDTRIANGLE (14)
END</syntaxhighlight>
 
==={{header|XBasic}}===
set startn=1
{{works with|Windows XBasic}}
set endn=1
<syntaxhighlight lang="qbasic">PROGRAM "Floyd's triangle"
VERSION "0.0001"
 
DECLARE FUNCTION Entry ()
for /l %%i in (1,1,%iterations%) do (
DECLARE FUNCTION FloydTriangle (n)
set "line="
for /l %%j in (!startn!,1,!endn!) do (
set "space="
call:getlength %%j
set /a sparespace=%digits%-!errorlevel!
for /l %%k in (0,1,!sparespace!) do set "space=!space! "
set line=!line!!space!%%j
set /a startn=%%j+1
)
echo !line!
set /a endn=!startn!+%%i
)
exit /b
 
FUNCTION Entry ()
:getlength
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
set offset=0
echo(
set string=%1
call :floydtriangle 14
:floydloop
exit /b 0
if "!string:~%offset%,1!"=="" endlocal && exit /b %offset%
 
set /a offset+=1
:floydtriangle
goto floydloop
set "fila=%1"
</lang>
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
Line 1,310 ⟶ 1,900:
11 12 13 14 15
 
Output for 14
1
2 31
2 4 5 63
4 7 5 8 9 106
117 128 139 14 1510
11 12 13 14 15
16 17 18 19 20 21
16 17 18 19 20 21
22 23 24 25 26 27 28
22 23 24 25 26 27 28
29 30 31 32 33 34 35 36
29 30 31 32 33 34 35 36
37 38 39 40 41 42 43 44 45
37 38 39 40 41 42 43 44 45
46 47 48 49 50 51 52 53 54 55
46 47 48 49 50 51 52 53 54 55
56 57 58 59 60 61 62 63 64 65 66
56 57 6758 59 6860 61 6962 63 70 64 71 65 72 73 74 75 76 77 7866
67 68 7969 70 8071 72 8173 74 82 75 83 76 84 77 85 86 87 88 89 90 9178
79 80 9281 82 9383 84 9485 86 95 87 96 88 97 89 98 90 99 100 101 102 103 104 10591
92 93 94 95 96 97 98 99 100 101 102 103 104 105</pre>
</pre>
 
=={{header|BCPL}}==
<langsyntaxhighlight lang="bcpl">get "libhdr"
 
let width(n) = n<10 -> 1, 1 + width(n/10)
Line 1,347 ⟶ 1,937:
wrch('*N')
floyd(14)
$)</langsyntaxhighlight>
{{out}}
<pre> 1
Line 1,372 ⟶ 1,962:
=={{header|Befunge}}==
 
<langsyntaxhighlight Befungelang="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+,:!#@_</langsyntaxhighlight>
 
{{out}}
Line 1,405 ⟶ 1,995:
 
=={{header|Bracmat}}==
<langsyntaxhighlight lang="bracmat"> ( ( floyd
= lowerLeftCorner lastInColumn lastInRow row i W w
. put$(str$("Floyd " !arg ":\n"))
Line 1,430 ⟶ 2,020:
& floyd$5
& floyd$14
);</langsyntaxhighlight>
Output:
<pre>Floyd 5:
Line 1,455 ⟶ 2,045:
 
=={{header|C}}==
<langsyntaxhighlight lang="c">#include <stdio.h>
 
void t(int n)
Line 1,516 ⟶ 2,106:
// t(10000);
return 0;
}</langsyntaxhighlight>
Output identical to D's.
 
=={{header|C sharp|C#}}==
{{Trans|Perl}}
<langsyntaxhighlight lang="csharp">using System;
using System.Text;
 
Line 1,566 ⟶ 2,156:
return output.ToString();
}
}</langsyntaxhighlight>
 
=={{header|C++}}==
<langsyntaxhighlight lang="cpp">
#include <windows.h>
#include <sstream>
Line 1,652 ⟶ 2,242:
return 0;
}
//--------------------------------------------------------------------------------------------------</langsyntaxhighlight>
{{out}}
<pre>Floyd's Triangle - 5 rows
Line 1,682 ⟶ 2,272:
=={{header|Clojure}}==
I didn't translete this, it's from my own creation.
<langsyntaxhighlight lang="clojure">
(defn TriangleList [n]
(let [l (map inc (range))]
Line 1,700 ⟶ 2,290:
e (map #(map (fn [x] (str " " x)) %) l)]
(map #(println (apply str %)) e)))
</syntaxhighlight>
</lang>
By Average-user.
 
Line 1,730 ⟶ 2,320:
 
=={{header|CLU}}==
<langsyntaxhighlight lang="clu">floyd = cluster is triangle
rep = null
Line 1,761 ⟶ 2,351:
stream$putl(po, floyd$triangle(5))
stream$putl(po, floyd$triangle(14))
end start_up</langsyntaxhighlight>
{{out}}
<pre> 1
Line 1,785 ⟶ 2,375:
 
=={{header|COBOL}}==
<langsyntaxhighlight lang="cobol"> IDENTIFICATION DIVISION.
PROGRAM-ID. FLOYD-TRIANGLE.
Line 1,853 ⟶ 2,443:
MOVE CUR-NUM TO THREE-DIGITS.
STRING THREE-DIGITS DELIMITED BY SIZE INTO OUT-LINE
WITH POINTER LINE-PTR.</langsyntaxhighlight>
{{out}}
<pre> 1
Line 1,878 ⟶ 2,468:
=={{header|CoffeeScript}}==
{{trans|Kotlin}}
<langsyntaxhighlight lang="coffeescript">triangle = (array) -> for n in array
console.log "#{n} rows:"
printMe = 1
Line 1,897 ⟶ 2,487:
printMe++
 
triangle [5, 14]</langsyntaxhighlight>
Output as Kotlin.
 
=={{header|Common Lisp}}==
===Version 1===
<langsyntaxhighlight lang="lisp">;;;using flet to define local functions and storing precalculated column widths in array
;;;verbose, but more readable and efficient than version 2
 
Line 1,918 ⟶ 2,508:
(dotimes (col (+ 1 row))
(format t "~vd " (aref column-widths col)(+ col (lazycat row))))
(format t "~%")))))</langsyntaxhighlight>
 
===Version 2 - any base===
<langsyntaxhighlight lang="lisp">;;; more concise than version 1 but less efficient for a large triangle
;;;optional "base" parameter will allow use of any base from 2 to 36
 
Line 1,928 ⟶ 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 "~%")))</langsyntaxhighlight>
 
{{out}}
Line 1,980 ⟶ 2,570:
 
=={{header|Cowgol}}==
<langsyntaxhighlight lang="cowgol">include "cowgol.coh";
 
sub width(n: uint16): (w: uint8) is
Line 2,017 ⟶ 2,607:
floyd(5);
print_nl();
floyd(14);</langsyntaxhighlight>
{{out}}
<pre> 1
Line 2,040 ⟶ 2,630:
92 93 94 95 96 97 98 99 100 101 102 103 104 105</pre>
=={{header|D}}==
<langsyntaxhighlight lang="d">import std.stdio, std.conv;
 
void floydTriangle(in uint n) {
Line 2,055 ⟶ 2,645:
floydTriangle(5);
floydTriangle(14);
}</langsyntaxhighlight>
{{out}}
<pre> 1
Line 2,076 ⟶ 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}}==
<langsyntaxhighlight lang="elixir">defmodule Floyd do
def triangle(n) do
max = trunc(n * (n + 1) / 2)
Line 2,095 ⟶ 2,850:
 
Floyd.triangle(5)
Floyd.triangle(14)</langsyntaxhighlight>
 
{{out}}
Line 2,121 ⟶ 2,876:
 
=={{header|Erlang}}==
<langsyntaxhighlight lang="erlang">
-module( floyds_triangle ).
 
Line 2,166 ⟶ 2,921:
 
strings_from_integers( Integers ) -> [erlang:integer_to_list(X) || X <- Integers].
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 2,191 ⟶ 2,946:
 
=={{header|ERRE}}==
<syntaxhighlight lang="erre">
<lang ERRE>
PROGRAM FLOYD
 
Line 2,212 ⟶ 2,967:
END FOR
END PROGRAM
</syntaxhighlight>
</lang>
Example for n=14
{{out}}
Line 2,240 ⟶ 2,995:
 
{{Works with|Office 365 betas 2021}}
<langsyntaxhighlight lang="lisp">floydTriangle
=LAMBDA(n,
IF(0 < n,
Line 2,261 ⟶ 3,016:
""
)
)</langsyntaxhighlight>
 
{{Out}}
Line 2,629 ⟶ 3,384:
 
=={{header|F_Sharp|F#}}==
<langsyntaxhighlight lang="fsharp">open System
 
[<EntryPoint>]
Line 2,648 ⟶ 3,403:
printf "%s%d" pad value
printfn ""
0</langsyntaxhighlight>
Output for 5 and 14 (via command line argument)
<pre style="float:left"> 1
Line 2,671 ⟶ 3,426:
 
=={{header|Factor}}==
<langsyntaxhighlight lang="factor">USING: io kernel math math.functions math.ranges prettyprint
sequences ;
IN: rosetta-code.floyds-triangle
Line 2,684 ⟶ 3,439:
] each nl 3drop ;
 
5 14 [ floyd. ] bi@</langsyntaxhighlight>
{{out}}
<pre>
Line 2,710 ⟶ 3,465:
 
=={{header|Forth}}==
<langsyntaxhighlight lang="forth">: lastn ( rows -- n ) dup 1- * 2/ ;
: width ( n -- n ) s>f flog ftrunc f>s 2 + ;
 
Line 2,724 ⟶ 3,479:
loop
2drop ;
</syntaxhighlight>
</lang>
 
=={{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">
<lang FORTRAN>
!-*- mode: compilation; default-directory: "/tmp/" -*-
!Compilation started at Tue May 21 22:55:08
Line 2,793 ⟶ 3,548:
end program p
</syntaxhighlight>
</lang>
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang="freebasic">' version 19-09-2015
' compile with: fbc -s console
 
Line 2,848 ⟶ 3,603:
Print : Print "hit any key to end program"
Sleep
End</langsyntaxhighlight>
{{out}}
<pre>output for 5 output for 14
Line 2,869 ⟶ 3,624:
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/?gist=57ab1f58785b7e07765881657e4589ab Click this link to run this code]'''
<langsyntaxhighlight lang="gambas">Public Sub Main()
Dim siCount, siNo, siCounter As Short
Dim siLine As Short = 1
Line 2,893 ⟶ 3,648:
Next
 
End</langsyntaxhighlight>
Output:
<pre>
Line 2,921 ⟶ 3,676:
 
=={{header|Go}}==
<langsyntaxhighlight lang="go">package main
 
import "fmt"
Line 2,947 ⟶ 3,702:
}
}
}</langsyntaxhighlight>
{{out}}
<pre>
Line 2,975 ⟶ 3,730:
=={{header|Groovy}}==
{{trans|Java}}
<langsyntaxhighlight lang="groovy">class Floyd {
static void main(String[] args) {
printTriangle(5)
Line 2,995 ⟶ 3,750:
}
}
}</langsyntaxhighlight>
{{out}}
<pre>5 rows:
Line 3,020 ⟶ 3,775:
 
=={{header|Haskell}}==
<syntaxhighlight lang="haskell">--------------------- FLOYDS TRIANGLE --------------------
<lang haskell>floydTriangle :: [[Int]]
 
floydTriangle :: [[Int]]
floydTriangle =
( zipWith
(fmap ((.) enumFromTo <$*> enumFromTo(\a b -> pred (a + b)))
<*> \a b -> pred (a + b)
)
<$> scanl (+) 1
<*> id
)
<*>[1 id..]
$ [1 ..]
 
 
alignR :: Int -> Int -> String
--------------------------- TEST -------------------------
alignR n = ((<>) =<< flip replicate ' ' . (-) n . length) . show
main :: IO ()
main = mapM_ (putStrLn . formatFT) [5, 14]
 
------------------------- DISPLAY ------------------------
 
formatFT :: Int -> String
Line 3,040 ⟶ 3,799:
ws = length . show <$> last t
 
alignR :: Int -> Int -> String
main :: IO ()
alignR n =
main = mapM_ (putStrLn . formatFT) [5, 14]</lang>
( (<>)
=<< flip replicate ' '
. (-) n
. length
)
. show</syntaxhighlight>
{{Out}}
<pre> 1
Line 3,067 ⟶ 3,832:
Or, simplifying a little by delegating the recursion scheme to '''mapAccumL'''
 
<langsyntaxhighlight lang="haskell">import Control.Monad ((>=>))
import Data.List (mapAccumL)
 
Line 3,095 ⟶ 3,860:
)
x
)</langsyntaxhighlight>
{{Out}}
<pre> 1
Line 3,120 ⟶ 3,885:
 
Or, defining just the relationship between successive terms:
<langsyntaxhighlight lang="haskell">----------------- LINES OF FLOYDS TRIANGLE ---------------
 
floyds :: [[Int]]
Line 3,141 ⟶ 3,906:
mapM_ print $ take 5 floyds
putStrLn ""
mapM_ print $ take 14 floyds</langsyntaxhighlight>
{{Out}}
<pre>[1]
Line 3,163 ⟶ 3,928:
[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:
<langsyntaxhighlight lang="unicon">procedure main(a)
n := integer(a[1]) | 5
w := ((n*(n-1))/2)-n
Line 3,178 ⟶ 4,000:
write()
}
end</langsyntaxhighlight>
 
Sample outputs:
Line 3,214 ⟶ 4,036:
Note: <code>require 'strings'</code> does nothing in J7, but is harmless (strings is already incorporated in J7).
 
<langsyntaxhighlight Jlang="j">require 'strings'
floyd=: [: rplc&(' 0';' ')"1@":@(* ($ $ +/\@,)) >:/~@:i.</langsyntaxhighlight>
 
Note, the parenthesis around ($ $ +/\@,) is optional, and only included for emphasis.
Line 3,221 ⟶ 4,043:
Example use:
 
<langsyntaxhighlight Jlang="j"> floyd 5
1
2 3
Line 3,241 ⟶ 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</langsyntaxhighlight>
 
How it works:
Line 3,253 ⟶ 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:
 
<langsyntaxhighlight Jlang="j">floyd=: [: ({.~ i.&1@E.~&' 0')"1@":@(* ($ $ +/\@,)) >:/~@:i.</langsyntaxhighlight>
 
=={{header|Java}}==
<langsyntaxhighlight lang="java">
public class Floyd {
public static void main(String[] args){
Line 3,276 ⟶ 4,098:
}
}
}</langsyntaxhighlight>
Output:
<pre>5 rows:
Line 3,308 ⟶ 4,130:
:#and a mapping of that expression to a formatted string.
 
<langsyntaxhighlight JavaScriptlang="javascript">(function () {
'use strict';
 
Line 3,428 ⟶ 4,250:
return showFloyd(floyd(n)) + '\n';
}, [5, 14]));
})();</langsyntaxhighlight>
{{Out}}
<pre> 1
Line 3,453 ⟶ 4,275:
===ES6===
{{Trans|Haskell}} (mapAccumL version)
<langsyntaxhighlight JavaScriptlang="javascript">(() => {
'use strict';
 
Line 3,549 ⟶ 4,371:
 
return unlines(map(n => showFloyd(floyd(n)) + '\n', [5, 14]))
})();</langsyntaxhighlight>
{{Out}}
<pre> 1
Line 3,576 ⟶ 4,398:
(Used TCL example as a starting point.)
 
<langsyntaxhighlight lang="javascript">#!/usr/bin/env js
 
function main() {
Line 3,611 ⟶ 4,433:
}
 
main();</langsyntaxhighlight>
 
{{out}}
Line 3,638 ⟶ 4,460:
 
=={{header|jq}}==
<langsyntaxhighlight lang="jq"># floyd(n) creates an n-row floyd's triangle
def floyd(n):
def lpad(len): tostring | (((len - length) * " ") + .);
Line 3,660 ⟶ 4,482:
| [ ($i + $row),
($string + "\n" + line($i; $row + 1; $widths )) ] )
| .[1] ) ;</langsyntaxhighlight>
'''Task:'''
<langsyntaxhighlight lang="jq">(5,14) | "floyd(\(.)): \(floyd(.))\n"</langsyntaxhighlight>
{{out}}
<langsyntaxhighlight lang="sh">$ jq -M -r -n -f floyds_triangle.jq > floyds_triangle.out
floyd(5):
1
Line 3,686 ⟶ 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 </langsyntaxhighlight>
 
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">function floydtriangle(rows)
r = collect(1:div(rows *(rows + 1), 2))
for i in 1:rows
Line 3,701 ⟶ 4,523:
floydtriangle(5); println(); floydtriangle(14)
 
</langsyntaxhighlight>{{out}}
<pre>
1
Line 3,727 ⟶ 4,549:
=={{header|Kotlin}}==
{{trans|Java}}
<langsyntaxhighlight lang="scala">fun main(args: Array<String>) = args.forEach { Triangle(it.toInt()) }
 
internal class Triangle(n: Int) {
Line 3,742 ⟶ 4,564:
}
}
}</langsyntaxhighlight>
Output as Java.
 
=={{header|Lasso}}==
{{Output?|Lasso|There should only be one space between the numbers on the last row.}}
<langsyntaxhighlight Lassolang="lasso">define floyds_triangle(n::integer) => {
local(out = array(array(1)),comp = array, num = 1)
while(#out->size < #n) => {
Line 3,770 ⟶ 4,592:
floyds_triangle(5)
'\r\r'
floyds_triangle(14)</langsyntaxhighlight>
{{out}}
<pre> 1
Line 3,794 ⟶ 4,616:
 
=={{header|Liberty BASIC}}==
<langsyntaxhighlight lang="lb">input "Number of rows needed:- "; rowsNeeded
 
dim colWidth(rowsNeeded) ' 5 rows implies 5 columns
Line 3,810 ⟶ 4,632:
next
print
next</langsyntaxhighlight>
{{out}}
<pre>Number of rows needed:- 5
Line 3,836 ⟶ 4,658:
 
=={{header|Lua}}==
<langsyntaxhighlight lang="lua">function print_floyd(rows)
local c = 1
local h = rows*(rows-1)/2
Line 3,854 ⟶ 4,676:
 
print_floyd(5)
print_floyd(14)</langsyntaxhighlight>
 
Output:
Line 3,879 ⟶ 4,701:
 
=={{header|Maple}}==
<langsyntaxhighlight lang="maple">floyd := proc(rows)
local num, numRows, numInRow, i, digits;
digits := Array([]);
Line 3,909 ⟶ 4,731:
 
floyd(5);
floyd(14);</langsyntaxhighlight>
{{out}}
<pre>
Line 3,934 ⟶ 4,756:
 
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">
<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>
</lang>
Output:
<pre>
Line 3,965 ⟶ 4,787:
=={{header|MATLAB}} / {{header|Octave}}==
 
<langsyntaxhighlight Matlablang="matlab">function floyds_triangle(n)
s = 1;
for k = 1 : n
disp(s : s + k - 1)
s = s + k;
end</langsyntaxhighlight>
{{out}}:
<pre>
Line 3,981 ⟶ 4,803:
</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}}==
<langsyntaxhighlight lang="modula2">MODULE FloydTriangle;
FROM FormatString IMPORT FormatString;
FROM Terminal IMPORT WriteString,WriteLn,ReadChar;
Line 4,018 ⟶ 4,906:
 
ReadChar
END FloydTriangle.</langsyntaxhighlight>
{{out}}
<pre> 1
Line 4,045 ⟶ 4,933:
===Version 1===
{{Trans|REXX}}
<langsyntaxhighlight NetRexxlang="netrexx">/* NetRexx */
options replace format comments java crossref symbols binary
/* REXX ***************************************************************
Line 4,072 ⟶ 4,960:
end i
Say ll -- output last line
</syntaxhighlight>
</lang>
'''Output:
<pre>
Line 4,102 ⟶ 4,990:
===Version 2===
{{Trans|REXX}}
<langsyntaxhighlight NetRexxlang="netrexx">/* NetRexx */
options replace format comments java crossref symbols binary
/*REXX program constructs & displays Floyd's triangle for any number of rows.*/
Line 4,121 ⟶ 5,009:
say output
end row
</syntaxhighlight>
</lang>
 
'''Output:
Line 4,153 ⟶ 5,041:
=={{header|Nim}}==
{{trans|Python}}
<langsyntaxhighlight lang="nim">import strutils
 
proc floyd(rowcount = 5): seq[seq[int]] =
Line 4,174 ⟶ 5,062:
for i in [5, 14]:
pfloyd(floyd(i))
echo ""</langsyntaxhighlight>
Output:
<pre> 1
Line 4,199 ⟶ 5,087:
=={{header|OCaml}}==
 
<langsyntaxhighlight lang="ocaml">let ( |> ) f g x = g (f x)
let rec last = function x::[] -> x | _::tl -> last tl | [] -> raise Not_found
let rec list_map2 f l1 l2 =
Line 4,224 ⟶ 5,112:
 
let () =
print_floyd (floyd (int_of_string Sys.argv.(1)))</langsyntaxhighlight>
 
=={{header|OxygenBasic}}==
{{output?|OxygenBasic}}
<langsyntaxhighlight lang="oxygenbasic">
function Floyd(sys n) as string
sys i,t
Line 4,256 ⟶ 5,144:
 
putfile "s.txt",Floyd(5)+floyd(14)
</syntaxhighlight>
</lang>
 
=={{header|PARI/GP}}==
<langsyntaxhighlight lang="parigp">{floyd(m)=my(lastrow_a,lastrow_e,lastrow_len=m,fl,idx);
\\ +++ fl is a vector of fieldlengths in the last row
lastrow_e=m*(m+1)/2;lastrow_a=lastrow_e+1-m;
Line 4,276 ⟶ 5,164:
floyd(5)
floyd(14)
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 4,302 ⟶ 5,190:
=={{header|Pascal}}==
{{works with|Free_Pascal}}
<langsyntaxhighlight lang="pascal">Program FloydDemo (input, output);
 
function digits(number: integer): integer;
Line 4,356 ⟶ 5,244:
writeln ('*** Floyd 14 ***');
floyd2(14);
end.</langsyntaxhighlight>
Output:
<pre>% ./Floyd
Line 4,384 ⟶ 5,272:
=={{header|Perl}}==
{{Trans|NetRexx}}
<langsyntaxhighlight lang="perl">#!/usr/bin/env perl
use strict;
use warnings;
Line 4,418 ⟶ 5,306:
0;
__END__
</syntaxhighlight>
</lang>
'''Output:
<pre>
Line 4,448 ⟶ 5,336:
 
=={{header|Phix}}==
<!--<langsyntaxhighlight Phixlang="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>
Line 4,467 ⟶ 5,355:
<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>
<!--</langsyntaxhighlight>-->
{{out}}
<pre style="float:left">
Line 4,495 ⟶ 5,383:
=={{header|PHP}}==
 
<langsyntaxhighlight lang="php">
<?php
floyds_triangle(5);
Line 4,513 ⟶ 5,401:
}
?>
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 4,538 ⟶ 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===
<langsyntaxhighlight PicoLisplang="picolisp">(de floyd (N)
(let LLC (/ (* N (dec N)) 2)
(for R N
Line 4,549 ⟶ 5,498:
(length (+ LLC C))
(+ C (/ (* R (dec R)) 2)) ) )
(if (= C R) (prinl) (space)) ) ) ) )</langsyntaxhighlight>
===Pre-calculate all rows, and take format from last one===
<langsyntaxhighlight PicoLisplang="picolisp">(de floyd (N)
(let
(Rows
Line 4,560 ⟶ 5,509:
(map inc (cdr Fmt))
(for R Rows
(apply tab R Fmt) ) ) )</langsyntaxhighlight>
Output in both cases:
<pre>: (floyd 5)
Line 4,586 ⟶ 5,535:
 
=={{header|PL/I}}==
<langsyntaxhighlight lang="pli">(fofl, size):
floyd: procedure options (main); /* Floyd's Triangle. Wiki 12 July 2012 */
 
Line 4,602 ⟶ 5,551:
end;
 
end floyd;</langsyntaxhighlight>
 
{{out}}
Line 4,632 ⟶ 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
<langsyntaxhighlight Prologlang="prolog">floyd(N) :-
forall(between(1, N, I),
( forall(between(1,I, J),
Line 4,648 ⟶ 5,669:
get_column(Last, C) :-
name(Last, N1), length(N1,C).
</syntaxhighlight>
</lang>
Output :
<pre> ?- floyd(5).
Line 4,678 ⟶ 5,699:
=={{header|PureBasic}}==
 
<langsyntaxhighlight PureBasiclang="purebasic">Procedure.i sumTo(n)
Protected r,i
For i=1 To n
Line 4,727 ⟶ 5,748:
Print(#crlf$ + #crlf$ + "Press ENTER to exit"): Input()
CloseConsole()
EndIf</langsyntaxhighlight>
 
'''Sample Output'''
Line 4,754 ⟶ 5,775:
=={{header|Python}}==
===Procedural===
<langsyntaxhighlight lang="python">>>> def floyd(rowcount=5):
rows = [[1]]
while len(rows) < rowcount:
Line 4,795 ⟶ 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
>>> </langsyntaxhighlight>
 
===Functional===
Line 4,801 ⟶ 5,822:
Using the mathematical formula for each row directly,
either in a list comprehension:
<langsyntaxhighlight 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)]</langsyntaxhighlight>
 
or in terms of concatMap:
{{Works with|Python|3}}
<langsyntaxhighlight lang="python">'''Floyd triangle in terms of concatMap'''
 
from itertools import chain
Line 4,878 ⟶ 5,899:
 
if __name__ == '__main__':
main()</langsyntaxhighlight>
 
Or alternatively, defining just the relationship between successive terms:
{{Works with|Python|3}}
<langsyntaxhighlight lang="python">'''Floyd triangle in terms of iterate(f)(x)'''
 
from itertools import islice
Line 4,975 ⟶ 5,996:
# MAIN ----------------------------------------------------
if __name__ == '__main__':
main()</langsyntaxhighlight>
{{Out}}
<pre>[1]
Line 4,984 ⟶ 6,005:
 
=={{header|q}}==
<syntaxhighlight lang="q">
<lang q>
floyd:{n:1+ til sum 1+til x;
t:d:0;
Line 4,996 ⟶ 6,017:
floyd[5]
floyd2[14]</langsyntaxhighlight>
{{out}}
<pre>
Line 5,024 ⟶ 6,045:
=={{header|Quackery}}==
 
<langsyntaxhighlight Quackerylang="quackery"> [ dup 1+ * 2 / ] is triangulared ( n --> n )
 
[ number$ tuck size -
Line 5,040 ⟶ 6,061:
5 floyd
cr
14 floyd</langsyntaxhighlight>
 
{{out}}
Line 5,069 ⟶ 6,090:
=={{header|R}}==
If it weren't for the printing requirements, we could do this in one line.
<langsyntaxhighlight lang="rsplus">Floyd <- function(n)
{
#The first argument of the seq call is a well-known formula for triangle numbers.
Line 5,077 ⟶ 6,098:
}
Floyd(5)
Floyd(14)</langsyntaxhighlight>
{{out}}
<pre>
Line 5,102 ⟶ 6,123:
 
=={{header|Racket}}==
<langsyntaxhighlight lang="racket">
#lang racket
(require math)
Line 5,121 ⟶ 6,142:
(floyd 5)
(floyd 14)
</syntaxhighlight>
</lang>
Output:
<pre>
Line 5,148 ⟶ 6,169:
(formerly Perl 6)
Here's two ways of doing it.
<syntaxhighlight lang="raku" perl6line>constant @floyd1 = (1..*).rotor(1..*);
constant @floyd2 = gather for 1..* -> $s { take [++$ xx $s] }
 
Line 5,162 ⟶ 6,183:
say format-rows(@floyd1[^5]);
say '';
say format-rows(@floyd2[^14]);</langsyntaxhighlight>
{{out}}
<pre> 1
Line 5,185 ⟶ 6,206:
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===
<langsyntaxhighlight lang="rexx">
/* REXX ***************************************************************
* Parse Arg rowcount
Line 5,210 ⟶ 6,302:
end
Say ll /* output last line */
</syntaxhighlight>
</lang>
Output:
<pre>
Line 5,239 ⟶ 6,331:
===version 2, simple formula===
This REXX version uses a simple formula to calculate the maximum value (triangle element) displayed.
<langsyntaxhighlight lang="rexx">/*REXX program constructs & displays Floyd's triangle for any number of specified rows.*/
parse arg N .; if N=='' | N=="," then N= 5 /*Not specified? Then use the default.*/
mx= N * (N+1) % 2 - N /*calculate the maximum of any value. */
Line 5,249 ⟶ 6,341:
end /*#*/ /*calculate the max length on the fly. */
say substr(_, 2) /*remove 1st leading blank in the line.*/
end /*r*/ /*stick a fork in it, we're all done. */</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default input:}}
<pre>
Line 5,286 ⟶ 6,378:
 
===version 3, hexadecimal===
<langsyntaxhighlight lang="rexx">/*REXX program constructs & displays Floyd's triangle for any number of rows in base 16.*/
parse arg N .; if N=='' | N=="," then N=6 /*Not specified? Then use the default.*/
mx=N * (N+1) % 2 - N /*calculate maximum value of any value.*/
Line 5,296 ⟶ 6,388:
end /*#*/
say substr(_, 2) /*remove 1st leading blank in the line.*/
end /*r*/ /*stick a fork in it, we're all done. */</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default input:}}
<pre>
Line 5,341 ⟶ 6,433:
 
This version of the '''base''' function has some boilerplate for signed numbers and various error checking.
<langsyntaxhighlight 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.*/
Line 5,390 ⟶ 6,482:
erd: call ser 'illegal "digit" in' x":" _
erm: call ser 'no argument specified.'
ser: say; say '***error***'; say arg(1); say; exit 13</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the input of: &nbsp; <tt> 6 &nbsp; 2 </tt>}}
<pre>
Line 5,466 ⟶ 6,558:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
rows = 10
n = 0
Line 5,477 ⟶ 6,569:
next
 
</syntaxhighlight>
</lang>
Output:
<pre>
Line 5,495 ⟶ 6,587:
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}}==
<langsyntaxhighlight lang="ruby">def floyd(rows)
max = (rows * (rows + 1)) / 2
widths = ((max - rows + 1)..max).map {|n| n.to_s.length + 1}
Line 5,507 ⟶ 6,633:
 
floyd(5)
floyd(14)</langsyntaxhighlight>
 
{{out}}
Line 5,533 ⟶ 6,659:
 
=={{header|Run BASIC}}==
<langsyntaxhighlight lang="runbasic">input "Number of rows: "; rows
dim colSize(rows)
for col=1 to rows
Line 5,546 ⟶ 6,672:
next
print
next</langsyntaxhighlight>
<pre>Number of rows: ?14
1
Line 5,564 ⟶ 6,690:
 
=={{header|Rust}}==
<langsyntaxhighlight lang="rust">fn main() {
floyds_triangle(5);
floyds_triangle(14);
Line 5,598 ⟶ 6,724:
}
 
</syntaxhighlight>
</lang>
 
=={{header|Scala}}==
<langsyntaxhighlight lang="scala">def floydstriangle( n:Int ) = {
val s = (1 to n)
val t = s map {i => (s .take(i-1) .sum) + 1}
(s zip t) foreach { n =>
Line 5,620 ⟶ 6,746:
// Test
floydstriangle(5)
floydstriangle(14)</langsyntaxhighlight>
{{out}}
<pre>
Line 5,647 ⟶ 6,773:
 
=={{header|Seed7}}==
<langsyntaxhighlight lang="seed7">$ include "seed7_05.s7i";
 
const proc: writeFloyd (in integer: rows) is func
Line 5,673 ⟶ 6,799:
writeFloyd(5);
writeFloyd(14);
end func;</langsyntaxhighlight>
 
Output:
Line 5,697 ⟶ 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}}==
<langsyntaxhighlight lang="ruby">func floyd(rows, n=1) {
var max = Math.range_sum(1, rows)
var widths = (max-rows .. max-1 -> map{.+n->to_s.len})
Line 5,708 ⟶ 6,876:
 
floyd(5) # or: floyd(5, 88)
floyd(14) # or: floyd(14, 900)</langsyntaxhighlight>
{{out}}
<pre>
Line 5,733 ⟶ 6,901:
 
=={{header|SPL}}==
<langsyntaxhighlight lang="spl">floyd(5)
floyd(14)
 
Line 5,747 ⟶ 6,915:
#.output(s)
<
.</langsyntaxhighlight>
{{out}}
<pre>
Line 5,772 ⟶ 6,940:
 
=={{header|Tcl}}==
<langsyntaxhighlight lang="tcl">proc floydTriangle n {
# Compute the column widths
for {set i [expr {$n*($n-1)/2+1}]} {$i <= $n*($n+1)/2} {incr i} {
Line 5,790 ⟶ 6,958:
floydTriangle 5
puts "Floyd 14:"
floydTriangle 14</langsyntaxhighlight>
{{out}}
<pre>
Line 5,818 ⟶ 6,986:
=={{header|TXR}}==
 
<langsyntaxhighlight lang="txrlisp">(defun flotri (n)
(let* ((last (trunc (* n (+ n 1)) 2))
(colw (mapcar [chain tostring length]
Line 5,836 ⟶ 7,004:
((num blah . etc) (usage "too many arguments"))
((num) (flotri (int-str num)))
(() (usage "need an argument")))</langsyntaxhighlight>
 
{{out}}
Line 5,869 ⟶ 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
<langsyntaxhighlight VBlang="vb">Option Explicit
Dim o As String
Sub floyd(L As Integer)
Line 5,895 ⟶ 7,109:
.TypeText Text:=o
End With
End Sub</langsyntaxhighlight>
{{out}}
<syntaxhighlight lang="text">5 lines
1
2 3
Line 5,918 ⟶ 7,132:
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</langsyntaxhighlight>
 
=={{header|VBScript}}==
{{works with|Windows Script Host|*}}
<syntaxhighlight lang="vbscript">
<lang VBScript>
' Read the number of rows to use..
intRows = WScript.StdIn.ReadLine
Line 5,938 ⟶ 7,152:
WScript.StdOut.WriteLine ""
Next
</syntaxhighlight>
</lang>
 
=={{header|Visual Basic .NET}}==
{{trans|C#}}
<langsyntaxhighlight lang="vbnet">Imports System.Text
 
Module Module1
Line 5,981 ⟶ 7,195:
End Sub
 
End Module</langsyntaxhighlight>
{{out}}
<pre> 1
Line 6,007 ⟶ 7,221:
=={{header|Wren}}==
{{libheader|Wren-fmt}}
<langsyntaxhighlight ecmascriptlang="wren">import "./fmt" for Fmt
 
var floyd = Fn.new { |n|
Line 6,023 ⟶ 7,237:
floyd.call(5)
System.print("\nFloyd(14):")
floyd.call(14)</langsyntaxhighlight>
 
{{out}}
Line 6,051 ⟶ 7,265:
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">include c:\cxpl\codes; \include 'code' declarations
 
func IntLen(N); \Return number of digits in a positive integer
Line 6,074 ⟶ 7,288:
[Floyd(5);
Floyd(14);
]</langsyntaxhighlight>
 
Output:
Line 6,101 ⟶ 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)):
<langsyntaxhighlight lang="zkl">fcn lcNum(row){(row*(row+1)/2+1)} // lazy caterer's sequence
fcn floydsTriangle(rows){
fmt:=[lcNum(rows-1)..lcNum(rows)-1].pump(String,fcn(n){
Line 6,111 ⟶ 7,325:
}
floydsTriangle(5); println();
floydsTriangle(14);</langsyntaxhighlight>
{{out}}
<pre>
Line 6,137 ⟶ 7,351:
 
=={{header|ZX Spectrum Basic}}==
<langsyntaxhighlight lang="zxbasic">10 LET n=10: LET j=1: LET col=1
20 FOR r=1 TO n
30 FOR j=j TO j+r-1
Line 6,145 ⟶ 7,359:
70 PRINT
80 LET col=1
90 NEXT r</langsyntaxhighlight>
Jjuanhdez
2,122

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/216092...362453"