Minimum number of cells after, before, above and below NxN squares: Difference between revisions

From Rosetta Code
Content added Content deleted
(→‎{{header|REXX}}: added the computer programming language REXX.)
m (→‎{{header|REXX}}: added whitespace.)
Line 104: Line 104:
parse arg $ /*obtain optional arguments from the CL*/
parse arg $ /*obtain optional arguments from the CL*/
if $='' | $="," then $= 10 9 2 1 /*Not specified? Then use the default.*/
if $='' | $="," then $= 10 9 2 1 /*Not specified? Then use the default.*/

do j=1 for words($) /*process each of the squares specified*/
do j=1 for words($) /*process each of the squares specified*/
x= word($, j) /*obtain the next square to process. */
x= word($, j) /*obtain the next square to process. */
Line 110: Line 111:
say center(' 'title" ", 79) /*center title of output to be shown. */
say center(' 'title" ", 79) /*center title of output to be shown. */
say center('', 79, '─') /*display a separator line below title.*/
say center('', 79, '─') /*display a separator line below title.*/

do r=0 for x /*process output for a N x N square. */
do r=0 for x /*process output for a N x N square. */
_= left('', max(1, 77%2 ) - x ) /*compute indentation output centering.*/
_= left('', max(1, 77%2 ) - x ) /*compute indentation output centering.*/
Line 117: Line 119:
say _ /*display a row of the output square. */
say _ /*display a row of the output square. */
end /*r*/
end /*r*/

say; say /*display 2 blank lines between outputs*/
say; say /*display 2 blank lines between outputs*/
end /*j*/ /*stick a fork in it, we're all done. */</lang>
end /*j*/ /*stick a fork in it, we're all done. */</lang>

Revision as of 14:37, 2 August 2021

Minimum number of cells after, before, above and below NxN squares is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.
Task
Find and show on this page the minimum number of cells after, before, above and below NxN squares, where N = 10



Factor

Works with: Factor version 0.99 2021-06-02

<lang factor>USING: io kernel math math.matrices math.vectors prettyprint sequences ;

square ( n -- matrix )
   [ <cartesian-square-indices> ] keep 1 - dup
   '[ dup sum _ > [ _ v-n vabs ] when infimum ] matrix-map ;

10 square simple-table. nl 9 square simple-table.</lang>

Output:
0 0 0 0 0 0 0 0 0 0
0 1 1 1 1 1 1 1 1 0
0 1 2 2 2 2 2 2 1 0
0 1 2 3 3 3 3 2 1 0
0 1 2 3 4 4 3 2 1 0
0 1 2 3 4 4 3 2 1 0
0 1 2 3 3 3 3 2 1 0
0 1 2 2 2 2 2 2 1 0
0 1 1 1 1 1 1 1 1 0
0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0
0 1 1 1 1 1 1 1 0
0 1 2 2 2 2 2 1 0
0 1 2 3 3 3 2 1 0
0 1 2 3 4 3 2 1 0
0 1 2 3 3 3 2 1 0
0 1 2 2 2 2 2 1 0
0 1 1 1 1 1 1 1 0
0 0 0 0 0 0 0 0 0

Julia

Set up the upper left quadrant and then mirror it. <lang julia>function printNbyN(N) 

   mat = zeros(Int, N, N)
   for xy in CartesianIndices(mat)
       mat[xy] = minimum(Tuple(xy)) - 1
   end
   for (rownum, row) in enumerate(eachrow(mat))
       rownum > N ÷ 2 && (row .= mat[N - rownum + 1, :])
       row[(N+2)÷2:end] .= reverse(row[begin:(N+1)÷2])
       for n in row
           print(rpad(n, 2))
       end
       println()
   end

end

function testNbyN(sizes) 

   for n in sizes
       println("\nSquare of size $n:")
       printNbyN(n)
   end

end

testNbyN([10, 9, 2, 1])

</lang>

Output:
        
Square of size 10:
0 0 0 0 0 0 0 0 0 0
0 1 1 1 1 1 1 1 1 0
0 1 2 2 2 2 2 2 1 0
0 1 2 3 3 3 3 2 1 0
0 1 2 3 4 4 3 2 1 0
0 1 2 3 4 4 3 2 1 0
0 1 2 3 3 3 3 2 1 0
0 1 2 2 2 2 2 2 1 0
0 1 1 1 1 1 1 1 1 0
0 0 0 0 0 0 0 0 0 0

Square of size 9:
0 0 0 0 0 0 0 0 0
0 1 1 1 1 1 1 1 0
0 1 2 2 2 2 2 1 0
0 1 2 3 3 3 2 1 0
0 1 2 3 4 3 2 1 0
0 1 2 3 3 3 2 1 0
0 1 2 2 2 2 2 1 0
0 1 1 1 1 1 1 1 0
0 0 0 0 0 0 0 0 0

Square of size 2:
0 0
0 0

Square of size 1:
0


REXX

<lang rexx>/*REXX pgm finds/shows the minimum # of cells after, before, above, and below NxN square*/ parse arg $ /*obtain optional arguments from the CL*/ if $= | $="," then $= 10 9 2 1 /*Not specified? Then use the default.*/ 

 do j=1  for words($)                           /*process each of the squares specified*/
 x= word($, j)                                  /*obtain the next square to process.   */
 w= length( (x-1) % 2)                          /*calculate the width of the largest #.*/
 title= 'the minimum number of cells after, before, above, and below a ' x "x" x 'square'
 say center(' 'title" ", 79)                    /*center title of output to be shown.  */
 say center(,    79, '─')                     /*display a separator line below title.*/

    do     r=0  for x                           /*process output for a  N x N  square. */
    _= left(, max(1, 77%2 ) - x )             /*compute indentation output centering.*/
        do c=0  for x
        _= _ right( min(r, c, x-r-1, x-c-1), w) /*construct a row of the output square.*/
        end   /*c*/
    say _                                       /*display a row of the output square.  */
    end       /*r*/

  say;  say                                     /*display 2 blank lines between outputs*/
  end         /*j*/                             /*stick a fork in it,  we're all done. */</lang>
output   when using the default inputs:
 the mimimum number of cells after, before, above, and below a  10 x 10 square
───────────────────────────────────────────────────────────────────────────────
                             0 0 0 0 0 0 0 0 0 0
                             0 1 1 1 1 1 1 1 1 0
                             0 1 2 2 2 2 2 2 1 0
                             0 1 2 3 3 3 3 2 1 0
                             0 1 2 3 4 4 3 2 1 0
                             0 1 2 3 4 4 3 2 1 0
                             0 1 2 3 3 3 3 2 1 0
                             0 1 2 2 2 2 2 2 1 0
                             0 1 1 1 1 1 1 1 1 0
                             0 0 0 0 0 0 0 0 0 0


  the mimimum number of cells after, before, above, and below a  9 x 9 square
───────────────────────────────────────────────────────────────────────────────
                              0 0 0 0 0 0 0 0 0
                              0 1 1 1 1 1 1 1 0
                              0 1 2 2 2 2 2 1 0
                              0 1 2 3 3 3 2 1 0
                              0 1 2 3 4 3 2 1 0
                              0 1 2 3 3 3 2 1 0
                              0 1 2 2 2 2 2 1 0
                              0 1 1 1 1 1 1 1 0
                              0 0 0 0 0 0 0 0 0


  the mimimum number of cells after, before, above, and below a  2 x 2 square
───────────────────────────────────────────────────────────────────────────────
                                     0 0
                                     0 0


  the mimimum number of cells after, before, above, and below a  1 x 1 square
───────────────────────────────────────────────────────────────────────────────
                                      0

Ring

<lang ring> see "working..." + nl see "Minimum number of cells after, before, above and below NxN squares:" + nl row = 0 cellsMin = []

for n = 1 to 10 

   for m = 1 to 10
       cells = []
       add(cells,m-1)
       add(cells,10-m)
       add(cells,n-1)
       add(cells,10-n)
       min = min(cells)
       add(cellsMin,min)
   next

next

ind = 100 for n = 1 to ind 

   row++
   see "" + cellsMin[n] + " "
   if row%10 = 0
      see nl
   ok

next

see "done..." + nl </lang>

Output:
working...
Minimum number of cells after, before, above and below NxN squares:
0 0 0 0 0 0 0 0 0 0 
0 1 1 1 1 1 1 1 1 0 
0 1 2 2 2 2 2 2 1 0 
0 1 2 3 3 3 3 2 1 0 
0 1 2 3 4 4 3 2 1 0 
0 1 2 3 4 4 3 2 1 0 
0 1 2 3 3 3 3 2 1 0 
0 1 2 2 2 2 2 2 1 0 
0 1 1 1 1 1 1 1 1 0 
0 0 0 0 0 0 0 0 0 0 
done...

Wren

Library: Wren-math
Library: Wren-fmt

<lang ecmascript>import "/math" for Nums import "/fmt" for Fmt

var printMinCells = Fn.new { |n| 

   System.print("Minimum number of cells after, before, above and below %(n) x %(n) square:")
   for (r in 0...n) {
       var cells = List.filled(n, 0)
       for (c in 0...n) cells[c] = Nums.min([n-r-1, r, c, n-c-1])
       Fmt.print("$d", cells)
   }

}

for (n in [10, 9, 2, 1]) { 

   printMinCells.call(n)
   System.print()

}</lang>

Output:
Minimum number of cells after, before, above and below 10 x 10 square:
0 0 0 0 0 0 0 0 0 0
0 1 1 1 1 1 1 1 1 0
0 1 2 2 2 2 2 2 1 0
0 1 2 3 3 3 3 2 1 0
0 1 2 3 4 4 3 2 1 0
0 1 2 3 4 4 3 2 1 0
0 1 2 3 3 3 3 2 1 0
0 1 2 2 2 2 2 2 1 0
0 1 1 1 1 1 1 1 1 0
0 0 0 0 0 0 0 0 0 0

Minimum number of cells after, before, above and below 9 x 9 square:
0 0 0 0 0 0 0 0 0
0 1 1 1 1 1 1 1 0
0 1 2 2 2 2 2 1 0
0 1 2 3 3 3 2 1 0
0 1 2 3 4 3 2 1 0
0 1 2 3 3 3 2 1 0
0 1 2 2 2 2 2 1 0
0 1 1 1 1 1 1 1 0
0 0 0 0 0 0 0 0 0

Minimum number of cells after, before, above and below 2 x 2 square:
0 0
0 0

Minimum number of cells after, before, above and below 1 x 1 square:
0
Retrieved from "https://rosettacode.org/wiki/Minimum_number_of_cells_after,_before,_above_and_below_NxN_squares?oldid=314464"