A-M baby

Task/Floyds-triangle/0DESCRIPTION

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

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

@@ -0,0 +1,17 @@
+# syntax: GAWK -f FLOYDS_TRIANGLE.AWK rows
+BEGIN {
+    rows = ARGV[1]
+    if (rows !~ /^[0-9]+$/) {
+      print("rows invalid or missing from command line")
+      exit(1)
+    }
+    width = length(rows * (rows + 1) / 2) + 1 # width of last n
+    for (i=1; i<=rows; i++) {
+      cols++
+      for (j=1; j<=cols; j++) {
+        printf("%*d",width,++n)
+      }
+      printf("\n")
+    }
+    exit(0)
+}

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

@@ -0,0 +1,23 @@
+with Ada.Text_IO, Ada.Integer_Text_IO, Ada.Command_Line;
+
+procedure Floyd_Triangle is
+
+   Rows:    constant Positive := Integer'Value(Ada.Command_Line.Argument(1));
+   Current:          Positive := 1;
+   Width:            array(1 .. Rows) of Positive;
+
+begin
+   -- compute the width for the different columns
+   for I in Width'Range loop
+      Width(I) := Integer'Image(I + (Rows * (Rows-1))/2)'Length;
+   end loop;
+
+   -- output the triangle
+   for Line in 1 .. Rows loop
+      for Column in 1 .. Line loop
+        Ada.Integer_Text_IO.Put(Current, Width => Width(Column));
+        Current := Current + 1;
+      end loop;
+      Ada.Text_IO.New_Line;
+   end loop;
+end Floyd_Triangle;

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

@@ -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/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.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/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/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/Haskell/floyds-triangle-1.hs

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

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

@@ -0,0 +1,22 @@
+*Main> formatFT 5
+ 1
+ 2  3
+ 4  5  6
+ 7  8  9 10
+11 12 13 14 15
+
+*Main> formatFT 14
+ 1
+ 2  3
+ 4  5  6
+ 7  8  9 10
+11 12 13 14 15
+16 17 18 19 20 21
+22 23 24 25 26 27 28
+29 30 31 32 33 34 35 36
+37 38 39 40 41 42 43 44  45
+46 47 48 49 50 51 52 53  54  55
+56 57 58 59 60 61 62 63  64  65  66
+67 68 69 70 71 72 73 74  75  76  77  78
+79 80 81 82 83 84 85 86  87  88  89  90  91
+92 93 94 95 96 97 98 99 100 101 102 103 104 105

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,21 @@
+public class Floyd {
+	public static void main(String[] args){
+		System.out.println("5 rows:");
+		printTriangle(5);
+		System.out.println("14 rows:");
+		printTriangle(14);
+	}
+	
+	private static void printTriangle(int n){
+		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.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/Julia/floyds-triangle.julia

@@ -0,0 +1,6 @@
+#floyd(n) creates an n-row floyd's triangle counting from 1 to (n/2+.5)*n
+function floyd(n)
+	x = 1
+	dig(x,line,n) = (while line < n; x+=line; line+= 1 end; return ndigits(x)+1)
+	for line = 1:n, i = 1:line; print(lpad(x,dig(x,line,n)," ")); x+=1; i==line && print("\n") end
+end

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

@@ -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/Mathematica/floyds-triangle.mathematica

@@ -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/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/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/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/REXX/floyds-triangle-1.rexx

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

Task/Floyds-triangle/REXX/floyds-triangle-2.rexx

@@ -0,0 +1,12 @@
+/*REXX program constructs & displays Floyd's triangle for any # of rows.*/
+parse arg rows .;  if rows=='' then rows=1   /*assume 1 row is not given*/
+mV=rows * (rows+1) % 2                       /*calculate the max value. */
+say 'displaying a' rows "row Floyd's triangle:";     say
+#=1
+             do     r=1  for rows;    i=0;      _=''
+                 do #=#  for r;       i=i+1
+                 _=_ right(#, length(mV-rows+i))
+                 end   /*#*/
+             say _
+             end       /*r*/
+                                       /*stick a fork in it, we're done.*/

Task/Floyds-triangle/Racket/floyds-triangle.rkt

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

Task/Floyds-triangle/Ruby/floyds-triangle.rb

@@ -0,0 +1,14 @@
+raise ArgumentError, "Usage: #{$0} ROWS" unless
+  ARGV.length == 1 && (rows = ARGV[0].to_i) > 0
+
+max = (rows * (rows + 1)) / 2
+widths = ((max - rows + 1)..max).map {|n| n.to_s.length + 1}
+
+n = 0
+rows.times do |r|
+  (r+1).times do |i|
+    n += 1
+    print "%#{widths[i]}d" % n
+  end
+  print "\n"
+end

Task/Floyds-triangle/Scala/floyds-triangle.scala

@@ -0,0 +1,20 @@
+def floydstriangle( n:Int ) {
+  val s = (1 to n)
+  val t = s map {i => (s take(i-1) sum) + 1}
+
+  (s zip t) foreach { n =>
+    var m = n._2;
+	
+    for( i <- 0 until n._1 ) {
+      val w = (t.last + i).toString.length + 1  // Column width from last row
+      print("           " + m takeRight w )
+      m+=1
+    }
+	
+    print("\n")
+  }
+}
+
+// Test
+floydstriangle(5)
+floydstriangle(14)

Task/Floyds-triangle/Tcl/floyds-triangle.tcl

@@ -0,0 +1,19 @@
+proc floydTriangle n {
+    # Compute the column widths
+    for {set i [expr {$n*($n-1)/2+1}]} {$i <= $n*($n+1)/2} {incr i} {
+	lappend w [string length $i]
+    }
+    # Print the triangle
+    for {set i 0; set j 1} {$j <= $n} {incr j} {
+	for {set p -1; set k 0} {$k < $j} {incr k} {
+	    puts -nonewline [format "%*d " [lindex $w [incr p]] [incr i]]
+	}
+	puts ""
+    }
+}
+
+# Demonstration
+puts "Floyd 5:"
+floydTriangle 5
+puts "Floyd 14:"
+floydTriangle 14