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

From Rosetta Code
Content added Content deleted
m (→‎{{header|REXX}}: added whitespace.)
m (added whitespace, used a × symbol for "x".)
Line 1: Line 1:
{{Draft task}}
{{Draft task}}


;Task:
;Task:Find and show on this page the minimum number of cells after, before, above and below '''NxN''' squares, where '''N = 10'''
Find and show on this page the minimum number of cells after, before, above and below   '''N×N'''   squares,   where   '''N = 10'''.

<br><br>
<br><br>



Revision as of 14:41, 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   N×N   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