Data commit

Task/Floyds-triangle/00-META.yaml

@@ -0,0 +1,2 @@
+---
+from: http://rosettacode.org/wiki/Floyd's_triangle

Task/Floyds-triangle/00-TASK.txt

@@ -0,0 +1,20 @@
+[[wp:Floyd's triangle|Floyd's triangle]]   lists the natural numbers in a right triangle aligned to the left where 
+* the first row is   '''1'''     (unity)
+* successive rows start towards the left with the next number followed by successive naturals listing one more number than the line above.
+
+
+The first few lines of a Floyd triangle looks like this:
+<pre>
+ 1
+ 2  3
+ 4  5  6
+ 7  8  9 10
+11 12 13 14 15
+</pre>
+
+
+;Task:
+:# Write a program to generate and display here the first &nbsp; n &nbsp; lines of a Floyd triangle. <br>(Use &nbsp; n=5 &nbsp; and &nbsp; n=14 &nbsp; rows).
+:# Ensure that when displayed in a mono-space font, the numbers line up in vertical columns as shown and that only one space separates numbers of the last row.
+<br><br>
+

Task/Floyds-triangle/11l/floyds-triangle.11l

@@ -0,0 +1,14 @@
+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))

Task/Floyds-triangle/360-Assembly/floyds-triangle.360

@@ -0,0 +1,39 @@
+*        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

Task/Floyds-triangle/ALGOL-68/floyds-triangle.alg

@@ -0,0 +1,33 @@
+# procedure to print a Floyd's Triangle with n lines                      #
+PROC floyds triangle = ( INT n )VOID:
+BEGIN
+
+    # calculate the number of the highest number that will be printed     #
+    # ( the sum of the integers 1, 2, ... n )                             #
+    INT max number = ( n * ( n + 1 ) ) OVER 2;
+
+    # determine the widths required to print the numbers of the final row #
+    [ n ]INT widths;
+    INT number := max number + 1;
+    FOR col FROM n BY -1 TO 1 DO
+        widths[ col ] := - ( UPB whole( number -:= 1, 0 ) + 1 )
+    OD;
+
+    # print the triangle                                                  #
+    INT element := 0;
+    FOR row TO n DO
+        FOR col TO row DO
+            print( ( whole( element +:= 1, widths[ col ] ) ) )
+        OD;
+        print( ( newline ) )
+    OD
+
+END; # floyds triangle #
+
+main: (
+
+    floyds triangle(  5 );
+    print( ( newline ) );
+    floyds triangle( 14 )
+
+)

Task/Floyds-triangle/ALGOL-W/floyds-triangle.alg

@@ -0,0 +1,41 @@
+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.

Task/Floyds-triangle/AWK/floyds-triangle.awk

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

Task/Floyds-triangle/Action-/floyds-triangle.action

@@ -0,0 +1,51 @@
+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

Task/Floyds-triangle/Ada/floyds-triangle.ada

@@ -0,0 +1,12 @@
+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;

Task/Floyds-triangle/AppleScript/floyds-triangle-1.applescript

@@ -0,0 +1,276 @@
+-- FLOYDs TRIANGLE -----------------------------------------------------------
+
+-- floyd :: Int -> [[Int]]
+on floyd(n)
+    script floydRow
+        on |λ|(start, row)
+            {start + row + 1, enumFromTo(start, start + row)}
+        end |λ|
+    end script
+
+    snd(mapAccumL(floydRow, 1, enumFromTo(0, n - 1)))
+end floyd
+
+-- showFloyd :: [[Int]] -> String
+on showFloyd(xss)
+    set ws to map(compose({my succ, my |length|, my show}), |last|(xss))
+
+    script aligned
+        on |λ|(xs)
+            script pad
+                on |λ|(w, x)
+                    justifyRight(w, space, show(x))
+                end |λ|
+            end script
+
+            concat(zipWith(pad, ws, xs))
+        end |λ|
+    end script
+
+    unlines(map(aligned, xss))
+end showFloyd
+
+
+-- TEST ----------------------------------------------------------------------
+on run
+    script test
+        on |λ|(n)
+            showFloyd(floyd(n)) & linefeed
+        end |λ|
+    end script
+
+    unlines(map(test, {5, 14}))
+end run
+
+
+-- GENERIC FUNCTIONS ---------------------------------------------------------
+
+-- compose :: [(a -> a)] -> (a -> a)
+on compose(fs)
+    script
+        on |λ|(x)
+            script
+                on |λ|(f, a)
+                    mReturn(f)'s |λ|(a)
+                end |λ|
+            end script
+
+            foldr(result, x, fs)
+        end |λ|
+    end script
+end compose
+
+-- concat :: [[a]] -> [a] | [String] -> String
+on concat(xs)
+    if length of xs > 0 and class of (item 1 of xs) is string then
+        set acc to ""
+    else
+        set acc to {}
+    end if
+    repeat with i from 1 to length of xs
+        set acc to acc & item i of xs
+    end repeat
+    acc
+end concat
+
+-- enumFromTo :: Int -> Int -> [Int]
+on enumFromTo(m, n)
+    if n < m then
+        set d to -1
+    else
+        set d to 1
+    end if
+    set lst to {}
+    repeat with i from m to n by d
+        set end of lst to i
+    end repeat
+    return lst
+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
+
+-- foldr :: (b -> a -> a) -> a -> [b] -> a
+on foldr(f, startValue, xs)
+    tell mReturn(f)
+        set v to startValue
+        set lng to length of xs
+        repeat with i from lng to 1 by -1
+            set v to |λ|(item i of xs, v, i, xs)
+        end repeat
+        return v
+    end tell
+end foldr
+
+-- intercalate :: Text -> [Text] -> Text
+on intercalate(strText, lstText)
+    set {dlm, my text item delimiters} to {my text item delimiters, strText}
+    set strJoined to lstText as text
+    set my text item delimiters to dlm
+    return strJoined
+end intercalate
+
+-- justifyRight :: Int -> Char -> Text -> Text
+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
+
+-- last :: [a] -> a
+on |last|(xs)
+    if length of xs > 0 then
+        item -1 of xs
+    else
+        missing value
+    end if
+end |last|
+
+-- length :: [a] -> Int
+on |length|(xs)
+    length of xs
+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
+
+-- 'The mapAccumL function behaves like a combination of map and foldl;
+-- it applies a function to each element of a list, passing an
+-- accumulating parameter from left to right, and returning a final
+-- value of this accumulator together with the new list.' (see Hoogle)
+
+-- mapAccumL :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])
+on mapAccumL(f, acc, xs)
+    script
+        on |λ|(a, x)
+            tell mReturn(f) to set pair to |λ|(item 1 of a, x)
+            [item 1 of pair, (item 2 of a) & {item 2 of pair}]
+        end |λ|
+    end script
+
+    foldl(result, [acc, []], xs)
+end mapAccumL
+
+-- min :: Ord a => a -> a -> 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 :: Handler -> Script
+on mReturn(f)
+    if class of f is script 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 -> 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
+
+-- snd :: (a, b) -> b
+on snd(xs)
+    if class of xs is list and length of xs > 1 then
+        item 2 of xs
+    else
+        missing value
+    end if
+end snd
+
+-- show :: a -> String
+on show(e)
+    set c to class of e
+    if c = list then
+        script serialized
+            on |λ|(v)
+                show(v)
+            end |λ|
+        end script
+
+        "{" & intercalate(", ", map(serialized, e)) & "}"
+    else if c = record then
+        script showField
+            on |λ|(kv)
+                set {k, v} to kv
+                k & ":" & show(v)
+            end |λ|
+        end script
+
+        "{" & intercalate(", ", ¬
+            map(showField, zip(allKeys(e), allValues(e)))) & "}"
+    else if c = date then
+        ("date \"" & e as text) & "\""
+    else if c = text then
+        "\"" & e & "\""
+    else
+        try
+            e as text
+        on error
+            ("«" & c as text) & "»"
+        end try
+    end if
+end show
+
+-- succ :: Int -> Int
+on succ(x)
+    x + 1
+end succ
+
+-- unlines :: [String] -> String
+on unlines(xs)
+    intercalate(linefeed, xs)
+end unlines
+
+-- zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
+on zipWith(f, xs, ys)
+    set lng to min(length of xs, length of ys)
+    set lst to {}
+    tell mReturn(f)
+        repeat with i from 1 to lng
+            set end of lst to |λ|(item i of xs, item i of ys)
+        end repeat
+        return lst
+    end tell
+end zipWith

Task/Floyds-triangle/AppleScript/floyds-triangle-2.applescript

@@ -0,0 +1,208 @@
+-- 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

Task/Floyds-triangle/AppleScript/floyds-triangle-3.applescript

@@ -0,0 +1,244 @@
+--------------------- 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

Task/Floyds-triangle/AppleScript/floyds-triangle-4.applescript

@@ -0,0 +1,48 @@
+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)

Task/Floyds-triangle/AppleScript/floyds-triangle-5.applescript

@@ -0,0 +1,22 @@
+"
+  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
+"

Task/Floyds-triangle/Applesoft-BASIC/floyds-triangle.basic

@@ -0,0 +1,11 @@
+ 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

Task/Floyds-triangle/Arturo/floyds-triangle.arturo

@@ -0,0 +1,23 @@
+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

Task/Floyds-triangle/AutoHotkey/floyds-triangle-1.ahk

@@ -0,0 +1,22 @@
+Floyds_triangle(row){
+	i = 0
+	loop %row%
+	{
+		n := A_Index
+		loop, %n%
+		{
+			m := n, j := i, i++
+			while (m<row)
+				j += m , m++
+			res .= spaces(StrLen(j+1)-StrLen(i) +(A_Index=1?0:1)) i
+		}
+		if (A_Index < row)
+			res .= "`r`n"
+	}	
+	return res
+}
+Spaces(no){
+	loop, % no
+		res.=" "
+	return % res
+}

Task/Floyds-triangle/AutoHotkey/floyds-triangle-2.ahk

@@ -0,0 +1 @@
+MsgBox % Floyds_triangle(14)

Task/Floyds-triangle/BASIC256/floyds-triangle.basic

@@ -0,0 +1,18 @@
+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)

Task/Floyds-triangle/BBC-BASIC/floyds-triangle.basic

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

Task/Floyds-triangle/BCPL/floyds-triangle.bcpl

@@ -0,0 +1,21 @@
+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)
+$)

Task/Floyds-triangle/Batch-File/floyds-triangle.bat

@@ -0,0 +1,39 @@
+:: 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

Task/Floyds-triangle/Befunge/floyds-triangle.bf

@@ -0,0 +1,5 @@
+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+,:!#@_

Task/Floyds-triangle/Bracmat/floyds-triangle.bracmat

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

Task/Floyds-triangle/C++/floyds-triangle.cpp

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

Task/Floyds-triangle/C-sharp/floyds-triangle.cs

@@ -0,0 +1,46 @@
+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();
+    }
+}

Task/Floyds-triangle/C/floyds-triangle.c

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

Task/Floyds-triangle/CLU/floyds-triangle.clu

@@ -0,0 +1,32 @@
+floyd = cluster is triangle
+    rep = null
+
+    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

Task/Floyds-triangle/COBOL/floyds-triangle.cobol

@@ -0,0 +1,69 @@
+        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.

Task/Floyds-triangle/Chipmunk-Basic/floyds-triangle.basic

@@ -0,0 +1,15 @@
+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

Task/Floyds-triangle/Clojure/floyds-triangle.clj

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

Task/Floyds-triangle/CoffeeScript/floyds-triangle.coffee

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

Task/Floyds-triangle/Commodore-BASIC/floyds-triangle.basic

@@ -0,0 +1,19 @@
+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

Task/Floyds-triangle/Common-Lisp/floyds-triangle-1.lisp

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

Task/Floyds-triangle/Common-Lisp/floyds-triangle-2.lisp

@@ -0,0 +1,8 @@
+;;; more concise than version 1 but less efficient for a large triangle
+;;;optional "base" parameter will allow use of any base from 2 to 36
+
+(defun floydtriangle (rows &optional (base 10))
+       (dotimes (row rows)
+         (dotimes (column (+ 1 row))
+           (format t "~v,vr " base (length (format nil "~vr" base (+ column (/ (+ (expt (- rows 1) 2) (- rows 1) 2) 2)))) (+ column (/ (+ (expt row 2) row 2) 2))))
+         (format t "~%")))

Task/Floyds-triangle/Cowgol/floyds-triangle.cowgol

@@ -0,0 +1,38 @@
+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);

Task/Floyds-triangle/D/floyds-triangle.d

@@ -0,0 +1,16 @@
+import std.stdio, std.conv;
+
+void floydTriangle(in uint n) {
+    immutable lowerLeftCorner = n * (n - 1) / 2 + 1;
+    foreach (r; 0 .. n)
+        foreach (c; 0 .. r + 1)
+            writef("%*d%c",
+                   text(lowerLeftCorner + c).length,
+                   r * (r + 1) / 2 + c + 1,
+                   c == r ? '\n' : ' ');
+}
+
+void main() {
+    floydTriangle(5);
+    floydTriangle(14);
+}

Task/Floyds-triangle/Delphi/floyds-triangle.delphi

@@ -0,0 +1,24 @@
+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;

Task/Floyds-triangle/ERRE/floyds-triangle.erre

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

Task/Floyds-triangle/Elixir/floyds-triangle.elixir

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

Task/Floyds-triangle/Erlang/floyds-triangle.erl

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

Task/Floyds-triangle/Excel/floyds-triangle.excel

@@ -0,0 +1,22 @@
+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
+                )
+            )
+        ),
+        ""
+    )
+)

Task/Floyds-triangle/F-Sharp/floyds-triangle.fs

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

Task/Floyds-triangle/Factor/floyds-triangle.factor

@@ -0,0 +1,14 @@
+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@

Task/Floyds-triangle/Forth/floyds-triangle.fth

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

Task/Floyds-triangle/Fortran/floyds-triangle.f

@@ -0,0 +1,63 @@
+!-*- mode: compilation; default-directory: "/tmp/" -*-
+!Compilation started at Tue May 21 22:55:08
+!
+!a=./f && make $a && OMP_NUM_THREADS=2 $a 1223334444
+!gfortran -std=f2008 -Wall -ffree-form -fall-intrinsics f.f08 -o f
+!  1
+!  2  3
+!  4  5  6
+!  7  8  9 10
+! 11 12 13 14 15
+!
+!
+!  1
+!  2  3
+!  4  5  6
+!  7  8  9 10
+! 11 12 13 14 15
+! 16 17 18 19 20 21
+! 22 23 24 25 26 27 28
+! 29 30 31 32 33 34 35 36
+! 37 38 39 40 41 42 43 44  45
+! 46 47 48 49 50 51 52 53  54  55
+! 56 57 58 59 60 61 62 63  64  65  66
+! 67 68 69 70 71 72 73 74  75  76  77  78
+! 79 80 81 82 83 84 85 86  87  88  89  90  91
+! 92 93 94 95 96 97 98 99 100 101 102 103 104 105
+!
+!
+!
+!Compilation finished at Tue May 21 22:55:08
+
+
+program p
+  integer, dimension(2) :: examples = [5, 14]
+  integer :: i
+  do i=1, size(examples)
+    call floyd(examples(i))
+    write(6, '(/)')
+  end do
+
+contains
+
+  subroutine floyd(rows)
+    integer, intent(in) :: rows
+    integer :: n, i, j, k
+    integer, dimension(60) :: L
+    character(len=504) :: fmt
+    n = (rows*(rows+1))/2 ! Gauss's formula
+    do i=1,rows ! compute format of final row
+      L(i) = 2+int(log10(real(n-rows+i)))
+    end do
+    k = 0
+    do i=1,rows
+      do j=1,i
+        k = k+1
+        write(fmt,'(a2,i1,a1)')'(i',L(j),')'
+        write(6,fmt,advance='no') k
+      enddo
+      write(6,*) ''
+    end do
+  end subroutine floyd
+
+end program p

Task/Floyds-triangle/FreeBASIC/floyds-triangle.basic

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

Task/Floyds-triangle/Gambas/floyds-triangle.gambas

@@ -0,0 +1,25 @@
+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

Task/Floyds-triangle/Go/floyds-triangle.go

@@ -0,0 +1,27 @@
+package main
+
+import "fmt"
+
+func main() {
+    floyd(5)
+    floyd(14)
+}
+
+func floyd(n int) {
+    fmt.Printf("Floyd %d:\n", n)
+    lowerLeftCorner := n*(n-1)/2 + 1
+    lastInColumn := lowerLeftCorner
+    lastInRow := 1
+    for i, row := 1, 1; row <= n; i++ {
+        w := len(fmt.Sprint(lastInColumn))
+        if i < lastInRow {
+            fmt.Printf("%*d ", w, i)
+            lastInColumn++
+        } else {
+            fmt.Printf("%*d\n", w, i)
+            row++
+            lastInRow += row
+            lastInColumn = lowerLeftCorner
+        }
+    }
+}

Task/Floyds-triangle/Groovy/floyds-triangle.groovy

@@ -0,0 +1,21 @@
+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
+            }
+        }
+    }
+}

Task/Floyds-triangle/Haskell/floyds-triangle-1.hs

@@ -0,0 +1,32 @@
+--------------------- FLOYDS TRIANGLE --------------------
+
+floydTriangle :: [[Int]]
+floydTriangle =
+  ( zipWith
+      (fmap (.) enumFromTo <*> (\a b -> pred (a + b)))
+      <$> scanl (+) 1
+      <*> 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 = length . show <$> last t
+
+alignR :: Int -> Int -> String
+alignR n =
+  ( (<>)
+      =<< flip replicate ' '
+        . (-) n
+        . length
+  )
+    . show

Task/Floyds-triangle/Haskell/floyds-triangle-2.hs

@@ -0,0 +1,29 @@
+import Control.Monad ((>=>))
+import Data.List (mapAccumL)
+
+--------------------- FLOYD'S TRIANGLE -------------------
+
+floyd :: Int -> [[Int]]
+floyd n =
+  snd $
+    mapAccumL
+      (\a x -> ((,) . succ <*> enumFromTo a) (a + x))
+      1
+      [0 .. pred n]
+
+--------------------------- TEST -------------------------
+main :: IO ()
+main = mapM_ putStrLn $ showFloyd . floyd <$> [5, 14]
+
+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
+        )

Task/Floyds-triangle/Haskell/floyds-triangle-3.hs

@@ -0,0 +1,22 @@
+----------------- 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

Task/Floyds-triangle/Haskell/floyds-triangle-4.hs

@@ -0,0 +1,32 @@
+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 ' ' <>)

Task/Floyds-triangle/IS-BASIC/floyds-triangle.basic

@@ -0,0 +1,9 @@
+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

Task/Floyds-triangle/Icon/floyds-triangle.icon

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

Task/Floyds-triangle/J/floyds-triangle-1.j

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

Task/Floyds-triangle/J/floyds-triangle-2.j

@@ -0,0 +1,21 @@
+   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

Task/Floyds-triangle/J/floyds-triangle-3.j

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

Task/Floyds-triangle/Java/floyds-triangle.java

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

Task/Floyds-triangle/JavaScript/floyds-triangle-1.js

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

Task/Floyds-triangle/JavaScript/floyds-triangle-2.js

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

Task/Floyds-triangle/JavaScript/floyds-triangle-3.js

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

Task/Floyds-triangle/Jq/floyds-triangle-1.jq

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

Task/Floyds-triangle/Jq/floyds-triangle-2.jq

@@ -0,0 +1 @@
+(5,14) | "floyd(\(.)): \(floyd(.))\n"

Task/Floyds-triangle/Jq/floyds-triangle-3.jq

@@ -0,0 +1,23 @@
+$ jq -M -r -n -f floyds_triangle.jq > floyds_triangle.out
+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

Task/Floyds-triangle/Julia/floyds-triangle.julia

@@ -0,0 +1,11 @@
+function floydtriangle(rows)
+    r = collect(1:div(rows *(rows + 1), 2))
+    for i in 1:rows
+        for j in 1:i
+            print(rpad(lpad(popfirst!(r), j > 8 ? 3 : 2), j > 8 ? 4 : 3))
+        end
+        println()
+    end
+end
+
+floydtriangle(5); println(); floydtriangle(14)

Task/Floyds-triangle/Kotlin/floyds-triangle.kotlin

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

Task/Floyds-triangle/Lasso/floyds-triangle.lasso

@@ -0,0 +1,24 @@
+define floyds_triangle(n::integer) => {
+	local(out = array(array(1)),comp = array, num = 1)
+	while(#out->size < #n) => {
+		local(new = array)
+		loop(#out->last->size + 1) => {
+			#num++
+			#new->insert(#num)
+		}
+		#out->insert(#new)
+	}
+	local(pad = #out->last->last->asString->size)
+	with line in #out do => {
+		local(lineout = string)
+		with i in #line do => {
+			#i != #line->first ? #lineout->append(' ')
+			#lineout->append((' '*(#pad - #i->asString->size))+#i)
+		}
+		#comp->insert(#lineout)
+	}
+	return #comp->join('\r')
+}
+floyds_triangle(5)
+'\r\r'
+floyds_triangle(14)

Task/Floyds-triangle/Liberty-BASIC/floyds-triangle.basic

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

Task/Floyds-triangle/Lua/floyds-triangle.lua

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

Task/Floyds-triangle/MATLAB/floyds-triangle.m

@@ -0,0 +1,6 @@
+function floyds_triangle(n)
+  s = 1;
+  for k = 1 : n
+    disp(s : s + k - 1)
+    s = s + k;
+  end

Task/Floyds-triangle/Maple/floyds-triangle.maple

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

Task/Floyds-triangle/Mathematica/floyds-triangle.math

@@ -0,0 +1,4 @@
+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}]

Task/Floyds-triangle/Modula-2/floyds-triangle.mod2

@@ -0,0 +1,37 @@
+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.

Task/Floyds-triangle/NetRexx/floyds-triangle-1.netrexx

@@ -0,0 +1,27 @@
+/* NetRexx */
+options replace format comments java crossref symbols binary
+/* REXX ***************************************************************
+* 12.07.2012 Walter Pachl  - translated from Python
+**********************************************************************/
+Parse Arg rowcount .
+if rowcount.length() == 0 then rowcount = 1
+say 'Rows:' rowcount
+say
+col = 0
+len = Rexx ''
+ll = ''                               -- last line of triangle
+Loop j = rowcount * (rowcount - 1) / 2 + 1 to rowcount * (rowcount + 1) / 2
+  col = col + 1                       -- column number
+  ll = ll j                           -- build last line
+  len[col] = j.length()               -- remember length of column
+  End j
+Loop i = 1 To rowcount - 1            -- now do and output the rest
+  ol = ''
+  col = 0
+  Loop j = i * (i - 1) / 2 + 1 to i * (i + 1) / 2 -- elements of line i
+    col = col + 1
+    ol=ol j.right(len[col])           -- element in proper length
+    end
+  Say ol                              -- output ith line
+  end i
+Say ll                                -- output last line

Task/Floyds-triangle/NetRexx/floyds-triangle-2.netrexx

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

Task/Floyds-triangle/Nim/floyds-triangle.nim

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

Task/Floyds-triangle/OCaml/floyds-triangle.ocaml

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

Task/Floyds-triangle/OxygenBasic/floyds-triangle.basic

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

Task/Floyds-triangle/PARI-GP/floyds-triangle.parigp

@@ -0,0 +1,17 @@
+{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;
+    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)

Task/Floyds-triangle/PHP/floyds-triangle.php

@@ -0,0 +1,17 @@
+<?php
+floyds_triangle(5);
+floyds_triangle(14);
+
+function floyds_triangle($n) {
+    echo "n = " . $n . "\r\n";
+
+    for($r = 1, $i = 1, $c = 0; $r <= $n; $i++) {
+        $cols = ceil(log10($n*($n-1)/2 + $c + 2));
+        printf("%".$cols."d ", $i);
+        if(++$c == $r) {
+            echo "\r\n";
+            $r++;
+            $c = 0;
+        }
+    }
+?>

Task/Floyds-triangle/PL-I/floyds-triangle.pli

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

Task/Floyds-triangle/Pascal/floyds-triangle.pas

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

Task/Floyds-triangle/Perl/floyds-triangle.pl

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

Task/Floyds-triangle/Phix/floyds-triangle.phix

@@ -0,0 +1,20 @@
+(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>
+<!--

Task/Floyds-triangle/Picat/floyds-triangle-1.picat

@@ -0,0 +1,7 @@
+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").

Task/Floyds-triangle/Picat/floyds-triangle-2.picat

@@ -0,0 +1,12 @@
+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.

Task/Floyds-triangle/Picat/floyds-triangle-3.picat

@@ -0,0 +1,7 @@
+go =>
+  println("N=5:"),
+  println(floyd1(5)),
+  nl,
+  println("N=14:"),
+  println(floyd2(14)),
+  nl.

Task/Floyds-triangle/PicoLisp/floyds-triangle-1.l

@@ -0,0 +1,9 @@
+(de floyd (N)
+   (let LLC (/ (* N (dec N)) 2)
+      (for R N
+         (for C R
+            (prin
+               (align
+                  (length (+ LLC C))
+                  (+ C (/ (* R (dec R)) 2)) ) )
+            (if (= C R) (prinl) (space)) ) ) ) )

Task/Floyds-triangle/PicoLisp/floyds-triangle-2.l

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

Task/Floyds-triangle/Prolog/floyds-triangle.pro

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

Task/Floyds-triangle/PureBasic/floyds-triangle.basic

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

Task/Floyds-triangle/Python/floyds-triangle-1.py

@@ -0,0 +1,42 @@
+>>> def floyd(rowcount=5):
+	rows = [[1]]
+	while len(rows) < rowcount:
+		n = rows[-1][-1] + 1
+		rows.append(list(range(n, n + len(rows[-1]) + 1)))
+	return rows
+
+>>> floyd()
+[[1], [2, 3], [4, 5, 6], [7, 8, 9, 10], [11, 12, 13, 14, 15]]
+>>> def pfloyd(rows=[[1], [2, 3], [4, 5, 6], [7, 8, 9, 10]]):
+	colspace = [len(str(n)) for n in rows[-1]]
+	for row in rows:
+		print( ' '.join('%*i' % space_n for space_n in zip(colspace, row)))
+
+		
+>>> pfloyd()
+1
+2 3
+4 5 6
+7 8 9 10
+>>> pfloyd(floyd(5))
+ 1
+ 2  3
+ 4  5  6
+ 7  8  9 10
+11 12 13 14 15
+>>> pfloyd(floyd(14))
+ 1
+ 2  3
+ 4  5  6
+ 7  8  9 10
+11 12 13 14 15
+16 17 18 19 20 21
+22 23 24 25 26 27 28
+29 30 31 32 33 34 35 36
+37 38 39 40 41 42 43 44  45
+46 47 48 49 50 51 52 53  54  55
+56 57 58 59 60 61 62 63  64  65  66
+67 68 69 70 71 72 73 74  75  76  77  78
+79 80 81 82 83 84 85 86  87  88  89  90  91
+92 93 94 95 96 97 98 99 100 101 102 103 104 105
+>>>

Task/Floyds-triangle/Python/floyds-triangle-2.py

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

Task/Floyds-triangle/Python/floyds-triangle-3.py

@@ -0,0 +1,72 @@
+'''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()

Task/Floyds-triangle/Python/floyds-triangle-4.py

@@ -0,0 +1,94 @@
+'''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()

Task/Floyds-triangle/Q/floyds-triangle.q

@@ -0,0 +1,12 @@
+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]

Task/Floyds-triangle/QBasic/floyds-triangle.basic

@@ -0,0 +1,20 @@
+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)

Task/Floyds-triangle/Quackery/floyds-triangle.quackery

@@ -0,0 +1,17 @@
+  [ 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