Minimum number of cells after, before, above and below NxN squares: Difference between revisions
Content added Content deleted
m (→{{header|Wren}}: Minor tidy) |
|||
| (21 intermediate revisions by 9 users not shown) | |||
| Line 8: | Line 8: | ||
{{trans|Python}} |
{{trans|Python}} |
||
< |
<syntaxhighlight lang="11l">F min_cells_matrix(siz) |
||
R (0 .< siz).map(row -> (0 .< @siz).map(col -> min(@row, col, @@siz - @row - 1, @@siz - col - 1))) |
R (0 .< siz).map(row -> (0 .< @siz).map(col -> min(@row, col, @@siz - @row - 1, @@siz - col - 1))) |
||
| Line 19: | Line 19: | ||
L(siz) [23, 10, 9, 2, 1] |
L(siz) [23, 10, 9, 2, 1] |
||
display_matrix(min_cells_matrix(siz))</ |
display_matrix(min_cells_matrix(siz))</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
| Line 83: | Line 83: | ||
{{Trans|Wren}} |
{{Trans|Wren}} |
||
As with the Algol W version, the cells are printed as they are calculated. Ensures the counts are shown in the same width. |
As with the Algol W version, the cells are printed as they are calculated. Ensures the counts are shown in the same width. |
||
< |
<syntaxhighlight lang="algol68">BEGIN # show the minimum number of cells above, below, before and after each # |
||
# cell in a suare matrix # |
# cell in a suare matrix # |
||
| Line 117: | Line 117: | ||
OD |
OD |
||
END</ |
END</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
| Line 177: | Line 177: | ||
{{Trans|Wren}} |
{{Trans|Wren}} |
||
This version avoids generating an explicit list of elements for each row in the matrix and just prints the elements as they are calculated. The elements are all shown in the same field width. |
This version avoids generating an explicit list of elements for each row in the matrix and just prints the elements as they are calculated. The elements are all shown in the same field width. |
||
< |
<syntaxhighlight lang="algolw">begin % show the minimum number of cells above, below, before and after each % |
||
% cell in a square matrix % |
% cell in a square matrix % |
||
| Line 205: | Line 205: | ||
for n := 10, 9, 2, 1 do printMinCells( n ) |
for n := 10, 9, 2, 1 do printMinCells( n ) |
||
end.</ |
end.</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
| Line 263: | Line 263: | ||
=={{header|APL}}== |
=={{header|APL}}== |
||
{{works with|Dyalog APL}} |
{{works with|Dyalog APL}} |
||
< |
<syntaxhighlight lang="apl">n_by_n ← (⌽⌊⊖)∘(∘.⌊⍨¯1+⍳) |
||
n_by_n¨ 2 3 9 10</ |
n_by_n¨ 2 3 9 10</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>┌───┬─────┬─────────────────┬───────────────────┐ |
<pre>┌───┬─────┬─────────────────┬───────────────────┐ |
||
| Line 278: | Line 278: | ||
│ │ │ │0 0 0 0 0 0 0 0 0 0│ |
│ │ │ │0 0 0 0 0 0 0 0 0 0│ |
||
└───┴─────┴─────────────────┴───────────────────┘</pre> |
└───┴─────┴─────────────────┴───────────────────┘</pre> |
||
=={{header|AppleScript}}== |
|||
<syntaxhighlight lang="applescript">use framework "Foundation" |
|||
------------------- DISTANCES FROM EDGE ------------------ |
|||
-- distancesFromEdge :: Int -> [[Int]] |
|||
on distancesFromEdge(n) |
|||
-- A matrix of minimum distances to the edge. |
|||
script f |
|||
on |λ|(row, col) |
|||
minimum({row - 1, col - 1, n - row, n - col}) |
|||
end |λ| |
|||
end script |
|||
matrix(n, n, f) |
|||
end distancesFromEdge |
|||
--------------------------- TEST ------------------------- |
|||
on run |
|||
script test |
|||
on |λ|(n) |
|||
showMatrix(my distancesFromEdge(n)) & ¬ |
|||
linefeed |
|||
end |λ| |
|||
end script |
|||
unlines(map(test, {25, 10, 9, 2, 1})) |
|||
end run |
|||
------------------------- GENERIC ------------------------ |
|||
-- 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 |
|||
-- minimum :: Ord a => [a] -> a |
|||
on minimum(xs) |
|||
set ca to current application |
|||
unwrap((ca's NSArray's arrayWithArray:xs)'s ¬ |
|||
valueForKeyPath:"@min.self") |
|||
end minimum |
|||
-- 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 |
|||
-- 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 |
|||
-- 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 |
|||
-- unwrap :: NSValue -> a |
|||
on unwrap(nsValue) |
|||
if nsValue is missing value then |
|||
missing value |
|||
else |
|||
set ca to current application |
|||
item 1 of ((ca's NSArray's arrayWithObject:nsValue) as list) |
|||
end if |
|||
end unwrap |
|||
------------------------ FORMATTING ---------------------- |
|||
-- 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)) |
|||
end showMatrix |
|||
-- 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 |λ|(txt) |
|||
if n > length of txt then |
|||
text -n thru -1 of ((replicate(n, cFiller) as text) & txt) |
|||
else |
|||
txt |
|||
end if |
|||
end |λ| |
|||
end script |
|||
end justifyRight |
|||
-- max :: Ord a => a -> a -> a |
|||
on max(x, y) |
|||
if x > y then |
|||
x |
|||
else |
|||
y |
|||
end if |
|||
end max |
|||
-- 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 |
|||
-- unlines :: [String] -> String |
|||
on unlines(xs) |
|||
-- A single string formed by the intercalation |
|||
-- of a list of strings with the newline character. |
|||
set {dlm, my text item delimiters} to ¬ |
|||
{my text item delimiters, linefeed} |
|||
set s to xs as text |
|||
set my text item delimiters to dlm |
|||
s |
|||
end unlines |
|||
-- until :: (a -> Bool) -> (a -> a) -> a -> a |
|||
on |until|(p, f, x) |
|||
set v to x |
|||
set mp to mReturn(p) |
|||
set mf to mReturn(f) |
|||
repeat until mp's |λ|(v) |
|||
set v to mf's |λ|(v) |
|||
end repeat |
|||
v |
|||
end |until| |
|||
-- unwords :: [String] -> String |
|||
on unwords(xs) |
|||
set {dlm, my text item delimiters} to ¬ |
|||
{my text item delimiters, space} |
|||
set s to xs as text |
|||
set my text item delimiters to dlm |
|||
return s |
|||
end unwords</syntaxhighlight> |
|||
{{Out}} |
|||
<pre> 0 0 0 0 0 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 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 |
|||
0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0 |
|||
0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0 |
|||
0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0 |
|||
0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0 |
|||
0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0 |
|||
0 1 2 3 4 5 6 7 7 7 7 7 7 7 7 7 7 7 6 5 4 3 2 1 0 |
|||
0 1 2 3 4 5 6 7 8 8 8 8 8 8 8 8 8 7 6 5 4 3 2 1 0 |
|||
0 1 2 3 4 5 6 7 8 9 9 9 9 9 9 9 8 7 6 5 4 3 2 1 0 |
|||
0 1 2 3 4 5 6 7 8 9 10 10 10 10 10 9 8 7 6 5 4 3 2 1 0 |
|||
0 1 2 3 4 5 6 7 8 9 10 11 11 11 10 9 8 7 6 5 4 3 2 1 0 |
|||
0 1 2 3 4 5 6 7 8 9 10 11 12 11 10 9 8 7 6 5 4 3 2 1 0 |
|||
0 1 2 3 4 5 6 7 8 9 10 11 11 11 10 9 8 7 6 5 4 3 2 1 0 |
|||
0 1 2 3 4 5 6 7 8 9 10 10 10 10 10 9 8 7 6 5 4 3 2 1 0 |
|||
0 1 2 3 4 5 6 7 8 9 9 9 9 9 9 9 8 7 6 5 4 3 2 1 0 |
|||
0 1 2 3 4 5 6 7 8 8 8 8 8 8 8 8 8 7 6 5 4 3 2 1 0 |
|||
0 1 2 3 4 5 6 7 7 7 7 7 7 7 7 7 7 7 6 5 4 3 2 1 0 |
|||
0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0 |
|||
0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0 |
|||
0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0 |
|||
0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0 |
|||
0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0 |
|||
0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 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 0 0 0 0 0 |
|||
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 |
|||
0 0 |
|||
0 0 |
|||
0 |
|||
</pre> |
|||
=={{header|Arturo}}== |
|||
<syntaxhighlight lang="arturo">printMinCells: function [n][ |
|||
cells: array.of:n 0 |
|||
loop 0..dec n 'r [ |
|||
loop 0..dec n 'c -> |
|||
cells\[c]: min @[dec n-r, r, c, dec n-c] |
|||
print cells |
|||
] |
|||
] |
|||
loop [10 9 2 1] 'n [ |
|||
print ["Minimum number of cells after, before, above and below" n "x" n "square:"] |
|||
printMinCells n |
|||
print "" |
|||
]</syntaxhighlight> |
|||
{{out}} |
|||
<pre>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</pre> |
|||
=={{header|AutoHotkey}}== |
=={{header|AutoHotkey}}== |
||
< |
<syntaxhighlight lang="autohotkey">gridSize := 10 |
||
grid := [] |
grid := [] |
||
| Line 296: | Line 651: | ||
result .= "`n" |
result .= "`n" |
||
} |
} |
||
MsgBox % result</ |
MsgBox % result</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>0 0 0 0 0 0 0 0 0 0 |
<pre>0 0 0 0 0 0 0 0 0 0 |
||
| Line 310: | Line 665: | ||
=={{header|AWK}}== |
=={{header|AWK}}== |
||
<syntaxhighlight lang="awk"> |
|||
<lang AWK> |
|||
# syntax: GAWK -f MINIMUM_NUMBER_OF_CELLS_AFTER_BEFORE_ABOVE_AND_BELOW_NXN_SQUARES.AWK |
# syntax: GAWK -f MINIMUM_NUMBER_OF_CELLS_AFTER_BEFORE_ABOVE_AND_BELOW_NXN_SQUARES.AWK |
||
BEGIN { |
BEGIN { |
||
| Line 327: | Line 682: | ||
} |
} |
||
function min(x,y) { return((x < y) ? x : y) } |
function min(x,y) { return((x < y) ? x : y) } |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
| Line 389: | Line 744: | ||
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 |
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 |
||
</pre> |
</pre> |
||
=={{header|BASIC}}== |
=={{header|BASIC}}== |
||
==={{header|Applesoft BASIC}}=== |
|||
{{works with|Chipmunk Basic}} |
|||
<syntaxhighlight lang="qbasic">100 HOME : REM 100 CLS for Chipmunk Basic |
|||
110 n = 10 |
|||
120 FOR i = 1 TO n |
|||
130 FOR j = 1 TO n |
|||
140 IF i-1 <= n-i THEN a = i-1 : GOTO 160 |
|||
150 IF i-1 > n-i THEN a = n-i |
|||
160 IF j-1 <= n-j THEN b = j-1 : GOTO 180 |
|||
170 IF j-1 > n-j THEN b = n-j |
|||
180 IF a <= b THEN r = a : GOTO 200 |
|||
190 IF a > b THEN r = b |
|||
200 PRINT r " "; |
|||
210 NEXT j |
|||
220 PRINT |
|||
230 NEXT i |
|||
240 END</syntaxhighlight> |
|||
{{out}} |
|||
<pre>Same as Chipmunk Basic entry.</pre> |
|||
==={{header|BASIC256}}=== |
==={{header|BASIC256}}=== |
||
{{trans|FreeBASIC}} |
{{trans|FreeBASIC}} |
||
< |
<syntaxhighlight lang="basic256">function min(a, b) |
||
if a<=b then return a else return b |
if a<=b then return a else return b |
||
end function |
end function |
||
| Line 408: | Line 782: | ||
call minab(10) |
call minab(10) |
||
end</ |
end</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Igual que la entrada de FreeBASIC. |
Igual que la entrada de FreeBASIC. |
||
</pre> |
</pre> |
||
==={{header|Chipmunk Basic}}=== |
|||
{{works with|Chipmunk Basic|3.6.4}} |
|||
{{trans|BASIC256}} |
|||
<syntaxhighlight lang="qbasic">10 cls |
|||
20 call minab(10) |
|||
30 end |
|||
40 sub min(a,b) |
|||
50 if a <= b then min = a else min = b |
|||
60 end sub |
|||
70 sub minab(n) |
|||
80 for i = 1 to n |
|||
90 for j = 1 to n |
|||
100 print using "##"; min(min(i-1,n-i),min(j-1,n-j)); |
|||
110 next j |
|||
120 print |
|||
130 next i |
|||
140 end sub</syntaxhighlight> |
|||
{{out}} |
|||
<pre>Same as BASIC256 entry.</pre> |
|||
==={{header|FreeBASIC}}=== |
|||
<syntaxhighlight lang="freebasic">#define min(a, b) Iif(a<=b,a,b) |
|||
sub minab( n as uinteger ) |
|||
for i as uinteger = 1 to n |
|||
for j as uinteger = 1 to n |
|||
print using "## ";min( min(i-1, n-i), min(j-1, n-j) ); |
|||
next j |
|||
print |
|||
next i |
|||
end sub |
|||
minab(10)</syntaxhighlight> |
|||
{{out}}<pre> |
|||
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 |
|||
</pre> |
|||
==={{header|GW-BASIC}}=== |
|||
<syntaxhighlight lang="gwbasic">10 N = 10 |
|||
20 FOR I = 0 TO N - 1 |
|||
30 IF I < N - 1 - I THEN DI = I ELSE DI = N - 1 - I |
|||
40 FOR J = 0 TO N - 1 |
|||
50 IF J < N - 1 - J THEN DJ = J ELSE DJ = N - 1 - J |
|||
60 IF DI < DJ THEN M = DI ELSE M = DJ |
|||
70 PRINT USING "## ";M; |
|||
80 NEXT J |
|||
90 PRINT |
|||
100 NEXT I</syntaxhighlight> |
|||
==={{header|Minimal BASIC}}=== |
|||
{{trans|GW-BASIC}} |
|||
{{works with|Commodore BASIC|3.5}} |
|||
{{works with|Nascom ROM BASIC|4.7}} |
|||
<syntaxhighlight lang="basic"> |
|||
10 REM Minimum number of cells after, before, above and below NxN squares |
|||
20 LET N = 10 |
|||
30 FOR I = 0 TO N-1 |
|||
40 IF I < N-1-I THEN 70 |
|||
50 LET D = N-1-I |
|||
60 GOTO 80 |
|||
70 LET D = I |
|||
80 FOR J = 0 TO N-1 |
|||
90 IF J < N-1-J THEN 120 |
|||
100 LET E = N-1-J |
|||
110 GOTO 130 |
|||
120 LET E = J |
|||
130 IF D < E THEN 160 |
|||
140 LET M = E |
|||
150 GOTO 170 |
|||
160 LET M = D |
|||
170 IF M >= 10 THEN 190 |
|||
180 PRINT " "; |
|||
190 PRINT M; |
|||
200 NEXT J |
|||
210 PRINT |
|||
220 NEXT I |
|||
230 END |
|||
</syntaxhighlight> |
|||
==={{header|QBasic}}=== |
==={{header|QBasic}}=== |
||
| Line 418: | Line 880: | ||
{{works with|QuickBasic}} |
{{works with|QuickBasic}} |
||
{{trans|FreeBASIC}} |
{{trans|FreeBASIC}} |
||
< |
<syntaxhighlight lang="qbasic">DECLARE FUNCTION min! (a!, b!) |
||
DECLARE SUB minab (n!) |
DECLARE SUB minab (n!) |
||
| Line 436: | Line 898: | ||
PRINT |
PRINT |
||
NEXT i |
NEXT i |
||
END SUB</ |
END SUB</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Igual que la entrada de FreeBASIC. |
Igual que la entrada de FreeBASIC. |
||
</pre> |
|||
==={{header|RapidQ}}=== |
|||
{{trans|FreeBASIC}} |
|||
Introduced extra variables <code>MinI</code> and <code>MinJ</code>, because nested <code>Min</code> functions do not work correctly (why do they not?). |
|||
<syntaxhighlight lang="xbasic"> |
|||
' Minimum number of cells after, before, above and below NxN squares |
|||
DECLARE FUNCTION Min(A AS WORD, B AS WORD) AS WORD |
|||
DECLARE SUB MinAB(N AS WORD) |
|||
CLS |
|||
MinAB(10) |
|||
END |
|||
FUNCTION Min(A AS WORD, B AS WORD) AS WORD |
|||
IF A <= B THEN Min = A ELSE Min = B |
|||
END FUNCTION |
|||
SUB MinAB(N AS WORD) |
|||
FOR I = 1 TO N |
|||
MinI = Min(I - 1, N - I) |
|||
FOR J = 1 TO N |
|||
MinJ = Min(J - 1, N - J) |
|||
PRINT FORMAT$("%2d ", Min(MinI, MinJ)); |
|||
NEXT J |
|||
PRINT |
|||
NEXT I |
|||
END SUB |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
To samo, co we FreeBASIC. |
|||
<pre> |
|||
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 |
|||
</pre> |
|||
==={{header|Tiny BASIC}}=== |
|||
{{trans|Minimal BASIC}} |
|||
{{works with|TinyBasic}} |
|||
<syntaxhighlight lang="basic"> |
|||
10 REM Minimum number of cells after, before, above and below NxN squares |
|||
20 LET N=10 |
|||
30 LET I=0 |
|||
40 IF I<N-1-I THEN GOTO 70 |
|||
50 LET D=N-1-I |
|||
60 GOTO 80 |
|||
70 LET D=I |
|||
80 LET J=0 |
|||
90 IF J<N-1-J THEN GOTO 120 |
|||
100 LET E=N-1-J |
|||
110 GOTO 130 |
|||
120 LET E=J |
|||
130 IF D<E THEN GOTO 160 |
|||
140 LET M=E |
|||
150 GOTO 170 |
|||
160 LET M=D |
|||
170 IF M<10 THEN PRINT " "; |
|||
180 PRINT M;" "; |
|||
190 LET J=J+1 |
|||
200 IF J=N THEN GOTO 220 |
|||
210 GOTO 90 |
|||
220 PRINT |
|||
230 LET I=I+1 |
|||
240 IF I=N THEN GOTO 260 |
|||
250 GOTO 40 |
|||
260 END |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
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 |
|||
</pre> |
</pre> |
||
==={{header|True BASIC}}=== |
==={{header|True BASIC}}=== |
||
{{trans|QBasic}} |
{{trans|QBasic}} |
||
< |
<syntaxhighlight lang="qbasic">FUNCTION min (a, b) |
||
IF a <= b THEN LET min = a ELSE LET min = b |
IF a <= b THEN LET min = a ELSE LET min = b |
||
END FUNCTION |
END FUNCTION |
||
| Line 458: | Line 1,007: | ||
CALL minab (10) |
CALL minab (10) |
||
END</ |
END</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
| Line 466: | Line 1,015: | ||
==={{header|Yabasic}}=== |
==={{header|Yabasic}}=== |
||
{{trans|FreeBASIC}} |
{{trans|FreeBASIC}} |
||
< |
<syntaxhighlight lang="yabasic">minab(10) |
||
end |
end |
||
| Line 476: | Line 1,025: | ||
print |
print |
||
next i |
next i |
||
end sub</ |
end sub</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Igual que la entrada de FreeBASIC. |
Igual que la entrada de FreeBASIC. |
||
</pre> |
</pre> |
||
=={{header|BCPL}}== |
=={{header|BCPL}}== |
||
< |
<syntaxhighlight lang="bcpl">get "libhdr" |
||
let min(a,b) = a<b -> a, b |
let min(a,b) = a<b -> a, b |
||
| Line 495: | Line 1,043: | ||
$) |
$) |
||
let start() be minNbyN(10, 3)</ |
let start() be minNbyN(10, 3)</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> 0 0 0 0 0 0 0 0 0 0 |
<pre> 0 0 0 0 0 0 0 0 0 0 |
||
| Line 509: | Line 1,057: | ||
=={{header|BQN}}== |
=={{header|BQN}}== |
||
< |
<syntaxhighlight lang="bqn">NByN ← ⌊⌜˜ ⌽⊸⌊∘↕ |
||
NByN¨ 2‿3‿9‿10</ |
NByN¨ 2‿3‿9‿10</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>┌─ |
<pre>┌─ |
||
| Line 529: | Line 1,077: | ||
=={{header|C}}== |
=={{header|C}}== |
||
{{trans|FreeBASIC}} |
{{trans|FreeBASIC}} |
||
< |
<syntaxhighlight lang="c">#include<stdio.h> |
||
#include<stdlib.h> |
#include<stdlib.h> |
||
| Line 548: | Line 1,096: | ||
minab(10); |
minab(10); |
||
return 0; |
return 0; |
||
}</ |
}</syntaxhighlight> |
||
{{out}}<pre> |
{{out}}<pre> |
||
0 0 0 0 0 0 0 0 0 0 |
0 0 0 0 0 0 0 0 0 0 |
||
| Line 563: | Line 1,111: | ||
=={{header|CLU}}== |
=={{header|CLU}}== |
||
< |
<syntaxhighlight lang="clu">min = proc [T: type] (a, b: T) returns (T) |
||
where T has lt: proctype (T,T) returns (bool) |
where T has lt: proctype (T,T) returns (bool) |
||
if a<b |
if a<b |
||
| Line 598: | Line 1,146: | ||
start_up = proc () |
start_up = proc () |
||
print_table(stream$primary_output(), min_n_by_n(10)) |
print_table(stream$primary_output(), min_n_by_n(10)) |
||
end start_up</ |
end start_up</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>0 0 0 0 0 0 0 0 0 0 |
<pre>0 0 0 0 0 0 0 0 0 0 |
||
| Line 612: | Line 1,160: | ||
=={{header|COBOL}}== |
=={{header|COBOL}}== |
||
< |
<syntaxhighlight lang="cobol"> IDENTIFICATION DIVISION. |
||
PROGRAM-ID. MINIMUM-CELLS-N-BY-N. |
PROGRAM-ID. MINIMUM-CELLS-N-BY-N. |
||
| Line 656: | Line 1,204: | ||
CHECK-MINIMUM. |
CHECK-MINIMUM. |
||
IF ITEM IS LESS THAN MIN, MOVE ITEM TO MIN.</ |
IF ITEM IS LESS THAN MIN, MOVE ITEM TO MIN.</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> 0 0 0 0 0 0 0 0 0 0 |
<pre> 0 0 0 0 0 0 0 0 0 0 |
||
| Line 677: | Line 1,225: | ||
{{Works with|Office 365 betas 2021}} |
{{Works with|Office 365 betas 2021}} |
||
< |
<syntaxhighlight lang="lisp">=LAMBDA(n, |
||
LET( |
LET( |
||
lastIndex, n - 1, |
lastIndex, n - 1, |
||
| Line 696: | Line 1,244: | ||
)(SEQUENCE(n, n, 0, 1)) |
)(SEQUENCE(n, n, 0, 1)) |
||
) |
) |
||
)</ |
)</syntaxhighlight> |
||
{{Out}} |
{{Out}} |
||
| Line 1,056: | Line 1,604: | ||
| |
| |
||
|} |
|} |
||
=={{header|Delphi}}== |
|||
{{works with|Delphi|6.0}} |
|||
{{libheader|SysUtils,StdCtrls}} |
|||
The problem is not well described. You have to look at other people's code to understand the problem, which turns out to be something quite different from the description seems to say. |
|||
<syntaxhighlight lang="Delphi"> |
|||
function EdgeDistance(P: TPoint; Size: integer): integer; |
|||
{Find the distance to the nearest edge} |
|||
begin |
|||
Result:=Min(Min(P.X,(Size-1)-P.X),Min(P.Y,(Size-1)-P.Y)); |
|||
end; |
|||
procedure MapMatrix(Memo: TMemo; Size: integer); |
|||
{Map each cell in Size X Size matrix} |
|||
{with the distance to nearest edge} |
|||
var X,Y,E: integer; |
|||
var S: string; |
|||
begin |
|||
Memo.Lines.Add(Format('Map for %d X %d Matrix',[Size,Size])); |
|||
S:=''; |
|||
for Y:=0 to Size-1 do |
|||
begin |
|||
for X:=0 to Size-1 do |
|||
begin |
|||
E:=EdgeDistance(Point(X,Y),Size); |
|||
S:=S+Format('%3d',[E]); |
|||
end; |
|||
S:=S+#$0D#$0A; |
|||
end; |
|||
Memo.Lines.Add(S); |
|||
end; |
|||
procedure ShowEdgeMaps(Memo: TMemo); |
|||
{Show a series of maps for matrices of different sizes} |
|||
var I: integer; |
|||
begin |
|||
for I:=3 to 12 do MapMatrix(Memo,I); |
|||
end; |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Map for 3 X 3 Matrix |
|||
0 0 0 |
|||
0 1 0 |
|||
0 0 0 |
|||
Map for 4 X 4 Matrix |
|||
0 0 0 0 |
|||
0 1 1 0 |
|||
0 1 1 0 |
|||
0 0 0 0 |
|||
Map for 5 X 5 Matrix |
|||
0 0 0 0 0 |
|||
0 1 1 1 0 |
|||
0 1 2 1 0 |
|||
0 1 1 1 0 |
|||
0 0 0 0 0 |
|||
Map for 6 X 6 Matrix |
|||
0 0 0 0 0 0 |
|||
0 1 1 1 1 0 |
|||
0 1 2 2 1 0 |
|||
0 1 2 2 1 0 |
|||
0 1 1 1 1 0 |
|||
0 0 0 0 0 0 |
|||
Map for 7 X 7 Matrix |
|||
0 0 0 0 0 0 0 |
|||
0 1 1 1 1 1 0 |
|||
0 1 2 2 2 1 0 |
|||
0 1 2 3 2 1 0 |
|||
0 1 2 2 2 1 0 |
|||
0 1 1 1 1 1 0 |
|||
0 0 0 0 0 0 0 |
|||
Map for 8 X 8 Matrix |
|||
0 0 0 0 0 0 0 0 |
|||
0 1 1 1 1 1 1 0 |
|||
0 1 2 2 2 2 1 0 |
|||
0 1 2 3 3 2 1 0 |
|||
0 1 2 3 3 2 1 0 |
|||
0 1 2 2 2 2 1 0 |
|||
0 1 1 1 1 1 1 0 |
|||
0 0 0 0 0 0 0 0 |
|||
Map for 9 X 9 Matrix |
|||
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 |
|||
Map for 10 X 10 Matrix |
|||
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 |
|||
Map for 11 X 11 Matrix |
|||
0 0 0 0 0 0 0 0 0 0 0 |
|||
0 1 1 1 1 1 1 1 1 1 0 |
|||
0 1 2 2 2 2 2 2 2 1 0 |
|||
0 1 2 3 3 3 3 3 2 1 0 |
|||
0 1 2 3 4 4 4 3 2 1 0 |
|||
0 1 2 3 4 5 4 3 2 1 0 |
|||
0 1 2 3 4 4 4 3 2 1 0 |
|||
0 1 2 3 3 3 3 3 2 1 0 |
|||
0 1 2 2 2 2 2 2 2 1 0 |
|||
0 1 1 1 1 1 1 1 1 1 0 |
|||
0 0 0 0 0 0 0 0 0 0 0 |
|||
Map for 12 X 12 Matrix |
|||
0 0 0 0 0 0 0 0 0 0 0 0 |
|||
0 1 1 1 1 1 1 1 1 1 1 0 |
|||
0 1 2 2 2 2 2 2 2 2 1 0 |
|||
0 1 2 3 3 3 3 3 3 2 1 0 |
|||
0 1 2 3 4 4 4 4 3 2 1 0 |
|||
0 1 2 3 4 5 5 4 3 2 1 0 |
|||
0 1 2 3 4 5 5 4 3 2 1 0 |
|||
0 1 2 3 4 4 4 4 3 2 1 0 |
|||
0 1 2 3 3 3 3 3 3 2 1 0 |
|||
0 1 2 2 2 2 2 2 2 2 1 0 |
|||
0 1 1 1 1 1 1 1 1 1 1 0 |
|||
0 0 0 0 0 0 0 0 0 0 0 0 |
|||
</pre> |
|||
=={{header|F_Sharp|F#}}== |
=={{header|F_Sharp|F#}}== |
||
< |
<syntaxhighlight lang="fsharp"> |
||
// Minimum number of cells after, before, above and below NxN squares. Nigel Galloway: August 1st., 2021 |
// Minimum number of cells after, before, above and below NxN squares. Nigel Galloway: August 1st., 2021 |
||
printfn "%A" (Array2D.init 10 10 (fun n g->List.min [n;g;9-n;9-g])) |
printfn "%A" (Array2D.init 10 10 (fun n g->List.min [n;g;9-n;9-g])) |
||
printfn "\n%A" (Array2D.init 9 9 (fun n g->List.min [n;g;8-n;8-g])) |
printfn "\n%A" (Array2D.init 9 9 (fun n g->List.min [n;g;8-n;8-g])) |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
| Line 1,089: | Line 1,779: | ||
=={{header|Factor}}== |
=={{header|Factor}}== |
||
{{works with|Factor|0.99 2021-06-02}} |
{{works with|Factor|0.99 2021-06-02}} |
||
< |
<syntaxhighlight lang="factor">USING: io kernel math math.matrices math.vectors prettyprint |
||
sequences ; |
sequences ; |
||
| Line 1,096: | Line 1,786: | ||
'[ dup sum _ > [ _ v-n vabs ] when infimum ] matrix-map ; |
'[ dup sum _ > [ _ v-n vabs ] when infimum ] matrix-map ; |
||
{ 10 9 2 1 } [ square simple-table. nl ] each</ |
{ 10 9 2 1 } [ square simple-table. nl ] each</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
| Line 1,127: | Line 1,817: | ||
=={{header|Fermat}}== |
=={{header|Fermat}}== |
||
< |
<syntaxhighlight lang="fermat"> |
||
Func Min(a, b) = if a<=b then a else b fi.; |
Func Min(a, b) = if a<=b then a else b fi.; |
||
n:=10; |
n:=10; |
||
| Line 1,133: | Line 1,823: | ||
[x]:= [<i=1,n> <j=1,n> Min(Min(i-1,n-i),Min(j-1,n-j))]; |
[x]:= [<i=1,n> <j=1,n> Min(Min(i-1,n-i),Min(j-1,n-j))]; |
||
[x]; |
[x]; |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}}<pre> |
{{out}}<pre> |
||
[[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ` |
[[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ` |
||
| Line 1,145: | Line 1,835: | ||
0, 1, 1, 1, 1, 1, 1, 1, 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 ]] |
||
</pre> |
|||
=={{header|FreeBASIC}}== |
|||
<lang freebasic>#define min(a, b) Iif(a<=b,a,b) |
|||
sub minab( n as uinteger ) |
|||
for i as uinteger = 1 to n |
|||
for j as uinteger = 1 to n |
|||
print using "## ";min( min(i-1, n-i), min(j-1, n-j) ); |
|||
next j |
|||
print |
|||
next i |
|||
end sub |
|||
minab(10)</lang> |
|||
{{out}}<pre> |
|||
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 |
|||
</pre> |
</pre> |
||
=={{header|Go}}== |
=={{header|Go}}== |
||
{{trans|Wren}} |
{{trans|Wren}} |
||
< |
<syntaxhighlight lang="go">package main |
||
import "fmt" |
import "fmt" |
||
| Line 1,206: | Line 1,870: | ||
fmt.Println() |
fmt.Println() |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
| Line 1,265: | Line 1,929: | ||
[0] |
[0] |
||
</pre> |
</pre> |
||
=={{header|GW-BASIC}}== |
|||
<lang gwbasic>10 N = 10 |
|||
20 FOR I = 0 TO N - 1 |
|||
30 IF I < N - 1 - I THEN DI = I ELSE DI = N - 1 - I |
|||
40 FOR J = 0 TO N - 1 |
|||
50 IF J < N - 1 - J THEN DJ = J ELSE DJ = N - 1 - J |
|||
60 IF DI < DJ THEN M = DI ELSE M = DJ |
|||
70 PRINT USING "## ";M; |
|||
80 NEXT J |
|||
90 PRINT |
|||
100 NEXT I</lang> |
|||
=={{header|Haskell}}== |
=={{header|Haskell}}== |
||
< |
<syntaxhighlight lang="haskell">import Data.List.Split (chunksOf) |
||
----------- SHORTEST DISTANCES TO EDGE OF MATRIX --------- |
----------- SHORTEST DISTANCES TO EDGE OF MATRIX --------- |
||
| Line 1,304: | Line 1,956: | ||
let w = (succ . maximum) $ fmap (length . show) =<< m |
let w = (succ . maximum) $ fmap (length . show) =<< m |
||
rjust n c = (drop . length) <*> (replicate n c <>) |
rjust n c = (drop . length) <*> (replicate n c <>) |
||
in unlines (unwords . fmap (rjust w ' ' . show) <$> m)</ |
in unlines (unwords . fmap (rjust w ' ' . show) <$> m)</syntaxhighlight> |
||
{{Out}} |
{{Out}} |
||
<pre> 0 0 0 0 0 0 0 0 0 0 |
<pre> 0 0 0 0 0 0 0 0 0 0 |
||
| Line 1,331: | Line 1,983: | ||
0</pre> |
0</pre> |
||
or in terms of Data.Matrix: |
or in terms of Data.Matrix: |
||
< |
<syntaxhighlight lang="haskell">import Data.Matrix ( matrix, Matrix ) |
||
----------- SHORTEST DISTANCES TO EDGE OF MATRIX --------- |
|||
distanceToEdge :: Int -> Matrix Int |
|||
distanceToEdge n = |
|||
matrix |
|||
n |
|||
n |
|||
(\(a, b) -> minimum [pred a, pred b, n - a, n - b]) |
|||
distancesToEdge :: Int -> Matrix Int |
|||
distancesToEdge n = matrix n n |
|||
(\(i, j) -> minimum $ ($) <$> [pred, (n -)] <*> [i, j]) |
|||
--------------------------- TEST ------------------------- |
|||
main :: IO () |
main :: IO () |
||
main = mapM_ print $ distancesToEdge <$> [10, 9, 2, 1]</syntaxhighlight> |
|||
main = |
|||
mapM_ print $ distanceToEdge <$> [10, 9, 2, 1]</lang> |
|||
{{Out}} |
{{Out}} |
||
<pre>┌ ┐ |
<pre>┌ ┐ |
||
| Line 1,378: | Line 2,029: | ||
└ ┘</pre> |
└ ┘</pre> |
||
or bypassing 'minimum', to reduce the count of comparisons (same output as above): |
|||
<syntaxhighlight lang="haskell">import Data.Bifunctor (bimap) |
|||
import Data.Matrix (Matrix, matrix) |
|||
----------- SHORTEST DISTANCES TO EDGE OF MATRIX --------- |
|||
distancesToEdge :: Int -> Matrix Int |
|||
distancesToEdge n = matrix n n (uncurry min . bimap f f) |
|||
where |
|||
m = quot n 2 |
|||
f i |
|||
| i <= m = pred i |
|||
| otherwise = n - i |
|||
--------------------------- TEST ------------------------- |
|||
main :: IO () |
|||
main = mapM_ print $ distancesToEdge <$> [10, 9, 2, 1]</syntaxhighlight> |
|||
=={{header|J}}== |
=={{header|J}}== |
||
< |
<syntaxhighlight lang="j">nByN=: (|."1<.|.)@(<./~@i.) |
||
nByN each 2 3 9 10</ |
nByN each 2 3 9 10</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>┌───┬─────┬─────────────────┬───────────────────┐ |
<pre>┌───┬─────┬─────────────────┬───────────────────┐ |
||
| Line 1,395: | Line 2,064: | ||
│ │ │ │0 0 0 0 0 0 0 0 0 0│ |
│ │ │ │0 0 0 0 0 0 0 0 0 0│ |
||
└───┴─────┴─────────────────┴───────────────────┘</pre> |
└───┴─────┴─────────────────┴───────────────────┘</pre> |
||
=={{header|jq}}== |
|||
{{works with|jq}} |
|||
'''Also works with gojq, the Go implementation of jq''' |
|||
'''Also works with fq, a Go implementation of a large subset of jq''' |
|||
<syntaxhighlight lang=jq> |
|||
def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .; |
|||
def printMinCells: |
|||
"Minimum number of cells after, before, above and below each cell in a \(.) x \(.) matrix:", |
|||
( (. / 2 | ceil | tostring | length) as $p |
|||
| range(0; .) as $r |
|||
| [ range(0; .) as $c |
|||
| [. - $r - 1, $r, $c, . - $c - 1] | min | lpad($p)] | join(" ") ); |
|||
23, 10, 9, 2, 1 |
|||
| printMinCells, "" |
|||
</syntaxhighlight> |
|||
{{output}} |
|||
As expected. |
|||
=={{header|Julia}}== |
=={{header|Julia}}== |
||
< |
<syntaxhighlight lang="julia">function printNbyN(sizes) |
||
for N in sizes |
for N in sizes |
||
mat = zeros(Int, N, N) |
mat = zeros(Int, N, N) |
||
| Line 1,410: | Line 2,100: | ||
printNbyN([23, 10, 9, 2, 1]) |
printNbyN([23, 10, 9, 2, 1]) |
||
</ |
</syntaxhighlight>{{out}} |
||
<pre> |
<pre> |
||
Minimum number of cells after, before, above and below 23 x 23 square: |
Minimum number of cells after, before, above and below 23 x 23 square: |
||
| Line 1,474: | Line 2,164: | ||
=={{header|MiniZinc}}== |
=={{header|MiniZinc}}== |
||
<syntaxhighlight lang="minizinc"> |
|||
<lang MiniZinc> |
|||
%Minimum number of cells after, before, above and below NxN squares. Nigel Galloway, August 3rd., 2021 |
%Minimum number of cells after, before, above and below NxN squares. Nigel Galloway, August 3rd., 2021 |
||
int: Size=10; int: S=Size-1; set of int: N=0..S; |
int: Size=10; int: S=Size-1; set of int: N=0..S; |
||
array[N,N] of var int: G = array2d(N,N,[min([n,g,S-n,S-g])|n,g in N]); |
array[N,N] of var int: G = array2d(N,N,[min([n,g,S-n,S-g])|n,g in N]); |
||
output([show2d(G)]) |
output([show2d(G)]) |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
| Line 1,497: | Line 2,187: | ||
=={{header|Modula-2}}== |
=={{header|Modula-2}}== |
||
< |
<syntaxhighlight lang="modula2">MODULE MinNByN; |
||
FROM InOut IMPORT WriteCard, WriteLn; |
FROM InOut IMPORT WriteCard, WriteLn; |
||
| Line 1,520: | Line 2,210: | ||
BEGIN |
BEGIN |
||
minNbyN(10, 3); |
minNbyN(10, 3); |
||
END MinNByN.</ |
END MinNByN.</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> 0 0 0 0 0 0 0 0 0 0 |
<pre> 0 0 0 0 0 0 0 0 0 0 |
||
| Line 1,535: | Line 2,225: | ||
=={{header|Nim}}== |
=={{header|Nim}}== |
||
{{trans|Go}} |
{{trans|Go}} |
||
< |
<syntaxhighlight lang="nim">import strutils |
||
proc printMinCells(n: Positive) = |
proc printMinCells(n: Positive) = |
||
| Line 1,548: | Line 2,238: | ||
for n in [10, 9, 2, 1]: |
for n in [10, 9, 2, 1]: |
||
printMinCells(n) |
printMinCells(n) |
||
echo()</ |
echo()</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
| Line 1,582: | Line 2,272: | ||
=={{header|PARI/GP}}== |
=={{header|PARI/GP}}== |
||
< |
<syntaxhighlight lang="parigp"> |
||
n=10 |
n=10 |
||
matrix(n,n,i,j,min(min(i-1,n-i),min(j-1,n-j))) |
matrix(n,n,i,j,min(min(i-1,n-i),min(j-1,n-j))) |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}}<pre> |
{{out}}<pre> |
||
[0 0 0 0 0 0 0 0 0 0] |
[0 0 0 0 0 0 0 0 0 0] |
||
| Line 1,610: | Line 2,300: | ||
=={{header|Pascal}}== |
=={{header|Pascal}}== |
||
Using symmetry within row and col.Fill only the middle and let the values before in place. |
Using symmetry within row and col.Fill only the middle and let the values before in place. |
||
< |
<syntaxhighlight lang="pascal">program mindistance; |
||
{$IFDEF FPC} //used fpc 3.2.1 |
{$IFDEF FPC} //used fpc 3.2.1 |
||
{$MODE DELPHI} {$OPTIMIZATION ON,ALL} {$COPERATORS ON} |
{$MODE DELPHI} {$OPTIMIZATION ON,ALL} {$COPERATORS ON} |
||
| Line 1,695: | Line 2,385: | ||
Test(1); |
Test(1); |
||
end. |
end. |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre style="width: 800px; height: 480px> |
<pre style="width: 800px; height: 480px> |
||
| Line 1,752: | Line 2,442: | ||
=={{header|Perl}}== |
=={{header|Perl}}== |
||
< |
<syntaxhighlight lang="perl">use strict; |
||
use warnings; |
use warnings; |
||
use List::Util qw( max min ); |
use List::Util qw( max min ); |
||
| Line 1,764: | Line 2,454: | ||
} |
} |
||
print "\n"; |
print "\n"; |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>0 x 0 distance to nearest edge: |
<pre>0 x 0 distance to nearest edge: |
||
| Line 1,820: | Line 2,510: | ||
=={{header|Phix}}== |
=={{header|Phix}}== |
||
<!--< |
<!--<syntaxhighlight lang="phix">(phixonline)--> |
||
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span> |
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span> |
||
<span style="color: #008080;">procedure</span> <span style="color: #000000;">distance_to_edge</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: #008080;">procedure</span> <span style="color: #000000;">distance_to_edge</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span> |
||
| Line 1,832: | Line 2,522: | ||
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span> |
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span> |
||
<span style="color: #7060A8;">papply</span><span style="color: #0000FF;">({</span><span style="color: #000000;">23</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">,</span><span style="color: #000000;">9</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">},</span><span style="color: #000000;">distance_to_edge</span><span style="color: #0000FF;">)</span> |
<span style="color: #7060A8;">papply</span><span style="color: #0000FF;">({</span><span style="color: #000000;">23</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">,</span><span style="color: #000000;">9</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">},</span><span style="color: #000000;">distance_to_edge</span><span style="color: #0000FF;">)</span> |
||
<!--</ |
<!--</syntaxhighlight>--> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
| Line 1,887: | Line 2,577: | ||
</pre> |
</pre> |
||
Although I rather like it the way it is, you could argue there should be more spacing on the 23x23, if you insist do this before the loops and use fmt on the innermost line: |
Although I rather like it the way it is, you could argue there should be more spacing on the 23x23, if you insist do this before the loops and use fmt on the innermost line: |
||
<!--< |
<!--<syntaxhighlight lang="phix">--> |
||
<span style="color: #004080;">string</span> <span style="color: #000000;">fmt</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;">sprint</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">floor</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: #0000FF;">)))+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span> |
<span style="color: #004080;">string</span> <span style="color: #000000;">fmt</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;">sprint</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">floor</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: #0000FF;">)))+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span> |
||
<!--</ |
<!--</syntaxhighlight>--> |
||
or maybe just (good for n<=200 whereas the above goes on and on to "%4d", etc.) |
or maybe just (good for n<=200 whereas the above goes on and on to "%4d", etc.) |
||
<!--< |
<!--<syntaxhighlight lang="phix">(phixonline)--> |
||
<span style="color: #004080;">string</span> <span style="color: #000000;">fmt</span> <span style="color: #0000FF;">=</span> <span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;"><=</span><span style="color: #000000;">20</span><span style="color: #0000FF;">?</span><span style="color: #008000;">"%2d"</span><span style="color: #0000FF;">:</span><span style="color: #008000;">"%3d"</span><span style="color: #0000FF;">)</span> |
<span style="color: #004080;">string</span> <span style="color: #000000;">fmt</span> <span style="color: #0000FF;">=</span> <span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;"><=</span><span style="color: #000000;">20</span><span style="color: #0000FF;">?</span><span style="color: #008000;">"%2d"</span><span style="color: #0000FF;">:</span><span style="color: #008000;">"%3d"</span><span style="color: #0000FF;">)</span> |
||
<!--</ |
<!--</syntaxhighlight>--> |
||
=={{header|PILOT}}== |
=={{header|PILOT}}== |
||
< |
<syntaxhighlight lang="pilot">C :size=10 |
||
:y=0 |
:y=0 |
||
*line |
*line |
||
| Line 1,914: | Line 2,604: | ||
C :y=y+1 |
C :y=y+1 |
||
J (y<size):*line |
J (y<size):*line |
||
E :</ |
E :</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> 0 0 0 0 0 0 0 0 0 0 |
<pre> 0 0 0 0 0 0 0 0 0 0 |
||
| Line 1,928: | Line 2,618: | ||
=={{header|Python}}== |
=={{header|Python}}== |
||
< |
<syntaxhighlight lang="python">def min_cells_matrix(siz): |
||
return [[min(row, col, siz - row - 1, siz - col - 1) for col in range(siz)] for row in range(siz)] |
return [[min(row, col, siz - row - 1, siz - col - 1) for col in range(siz)] for row in range(siz)] |
||
| Line 1,944: | Line 2,634: | ||
if __name__ == "__main__": |
if __name__ == "__main__": |
||
test_min_mat() |
test_min_mat() |
||
</ |
</syntaxhighlight>{{out}} |
||
<pre> |
<pre> |
||
Minimum number of cells after, before, above and below 23 x 23 square: |
Minimum number of cells after, before, above and below 23 x 23 square: |
||
| Line 2,004: | Line 2,694: | ||
Or, disentangling computation from IO (separating model from display), and composing from generics: |
Or, disentangling computation from IO (separating model from display), and composing from generics: |
||
< |
<syntaxhighlight lang="python">'''Distance to edge of matrix''' |
||
from itertools import chain, product |
from itertools import chain, product |
||
| Line 2,069: | Line 2,759: | ||
# MAIN --- |
# MAIN --- |
||
if __name__ == '__main__': |
if __name__ == '__main__': |
||
main()</ |
main()</syntaxhighlight> |
||
{{Out}} |
|||
<pre>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 |
|||
0 0 |
|||
0 0 |
|||
0</pre> |
|||
and in terms of a generalized matrix function: |
|||
<syntaxhighlight lang="python">'''Minimum distances to edge of matrix''' |
|||
from itertools import chain |
|||
# distanceFromEdge :: Int -> [[Int]] |
|||
def distanceFromEdge(n): |
|||
'''A matrix of minimum distances to the |
|||
edge of the matrix. |
|||
''' |
|||
return matrix(n)(n)( |
|||
lambda row, col: min([ |
|||
row - 1, col - 1, |
|||
n - row, n - col |
|||
]) |
|||
) |
|||
# ------------------------- TEST ------------------------- |
|||
# main :: IO () |
|||
def main(): |
|||
'''Test''' |
|||
for n in [10, 9, 2, 1]: |
|||
print( |
|||
showMatrix( |
|||
distanceFromEdge(n) |
|||
) + "\n" |
|||
) |
|||
# ----------------------- GENERIC ------------------------ |
|||
# matrix :: Int -> Int -> ((Int, Int) -> a) -> [[a]] |
|||
def matrix(nRows): |
|||
'''A matrix of a given number of columns and rows, |
|||
in which each value is a given function over the |
|||
tuple of its (one-based) row and column indices. |
|||
''' |
|||
def go(nCols): |
|||
def g(f): |
|||
return [ |
|||
[f(y, x) for x in range(1, 1 + nCols)] |
|||
for y in range(1, 1 + nRows) |
|||
] |
|||
return g |
|||
return go |
|||
# showMatrix :: [[Int]] -> String |
|||
def showMatrix(xs): |
|||
'''String representation of xs |
|||
as a matrix. |
|||
''' |
|||
def go(): |
|||
rows = [[str(x) for x in row] for row in xs] |
|||
w = max(map(len, chain.from_iterable(rows))) |
|||
return "\n".join( |
|||
" ".join(k.rjust(w, ' ') for k in row) |
|||
for row in rows |
|||
) |
|||
return go() if xs else '' |
|||
# MAIN --- |
|||
if __name__ == '__main__': |
|||
main()</syntaxhighlight> |
|||
{{Out}} |
{{Out}} |
||
<pre>0 0 0 0 0 0 0 0 0 0 |
<pre>0 0 0 0 0 0 0 0 0 0 |
||
| Line 2,098: | Line 2,882: | ||
=={{header|Raku}}== |
=={{header|Raku}}== |
||
<lang |
<syntaxhighlight lang="raku" line>sub distance-to-edge (\N) { |
||
my $c = ceiling N / 2; |
my $c = ceiling N / 2; |
||
my $f = floor N / 2; |
my $f = floor N / 2; |
||
| Line 2,113: | Line 2,897: | ||
say "\n$_ x $_ distance to nearest edge:"; |
say "\n$_ x $_ distance to nearest edge:"; |
||
.fmt("%{$max}d").say for @dte; |
.fmt("%{$max}d").say for @dte; |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>0 x 0 distance to nearest edge: |
<pre>0 x 0 distance to nearest edge: |
||
| Line 2,170: | Line 2,954: | ||
=={{header|REXX}}== |
=={{header|REXX}}== |
||
This REXX version automatically adjusts the width of each (cell) number displayed so that all displayed numbers are aligned. |
This REXX version automatically adjusts the width of each (cell) number displayed so that all displayed numbers are aligned. |
||
< |
<syntaxhighlight lang="rexx">/*REXX pgm finds the minimum# of cells after, before, above, & below a NxN square matrix*/ |
||
parse arg $ /*obtain optional arguments from the CL*/ |
parse arg $ /*obtain optional arguments from the CL*/ |
||
if $='' | $="," then $= 21 10 9 2 1 /*Not specified? Then use the default.*/ |
if $='' | $="," then $= 21 10 9 2 1 /*Not specified? Then use the default.*/ |
||
| Line 2,188: | Line 2,972: | ||
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. */</ |
end /*j*/ /*stick a fork in it, we're all done. */</syntaxhighlight> |
||
{{out|output|text= when using the default inputs:}} |
{{out|output|text= when using the default inputs:}} |
||
<pre> |
<pre> |
||
| Line 2,255: | Line 3,039: | ||
=={{header|Ring}}== |
=={{header|Ring}}== |
||
< |
<syntaxhighlight lang="ring"> |
||
see "working..." + nl |
see "working..." + nl |
||
see "Minimum number of cells after, before, above and below NxN squares:" + nl |
see "Minimum number of cells after, before, above and below NxN squares:" + nl |
||
| Line 2,283: | Line 3,067: | ||
see "done..." + nl |
see "done..." + nl |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
| Line 2,302: | Line 3,086: | ||
=={{header|Ruby}}== |
=={{header|Ruby}}== |
||
< |
<syntaxhighlight lang="ruby">def dist2edge(n) |
||
width = (n/2).to_s.size+1 |
width = (n/2).to_s.size+1 |
||
m = n-1 |
m = n-1 |
||
| Line 2,310: | Line 3,094: | ||
end |
end |
||
puts dist2edge(10)</ |
puts dist2edge(10)</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>0 0 0 0 0 0 0 0 0 0 |
<pre>0 0 0 0 0 0 0 0 0 0 |
||
| Line 2,323: | Line 3,107: | ||
0 0 0 0 0 0 0 0 0 0 |
0 0 0 0 0 0 0 0 0 0 |
||
</pre> |
</pre> |
||
=={{header|V (Vlang)}}== |
|||
{{trans|Go}} |
|||
<syntaxhighlight lang="v (vlang)">fn print_min_cells(n int) { |
|||
println("Minimum number of cells after, before, above and below $n x $n square:") |
|||
for r in 0..n { |
|||
mut cells := []int{len: n} |
|||
for c in 0..n { |
|||
nums := [n - r - 1, r, c, n - c - 1] |
|||
mut min := n |
|||
for num in nums { |
|||
if num < min { |
|||
min = num |
|||
} |
|||
} |
|||
cells[c] = min |
|||
} |
|||
println(cells) |
|||
} |
|||
} |
|||
fn main() { |
|||
for n in [23, 10, 9, 2, 1] { |
|||
print_min_cells(n) |
|||
println('') |
|||
} |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Same as Go entry |
|||
</pre> |
|||
=={{header|Wren}}== |
=={{header|Wren}}== |
||
{{libheader|Wren-math}} |
{{libheader|Wren-math}} |
||
{{libheader|Wren-fmt}} |
{{libheader|Wren-fmt}} |
||
< |
<syntaxhighlight lang="wren">import "./math" for Nums |
||
import "/fmt" for Fmt |
import "./fmt" for Fmt |
||
var printMinCells = Fn.new { |n| |
var printMinCells = Fn.new { |n| |
||
| Line 2,342: | Line 3,159: | ||
printMinCells.call(n) |
printMinCells.call(n) |
||
System.print() |
System.print() |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
| Line 2,403: | Line 3,220: | ||
=={{header|XPL0}}== |
=={{header|XPL0}}== |
||
< |
<syntaxhighlight lang="xpl0">func Min(A, B); |
||
int A, B; |
int A, B; |
||
return if A<B then A else B; |
return if A<B then A else B; |
||
| Line 2,417: | Line 3,234: | ||
CrLf(0); |
CrLf(0); |
||
]; |
]; |
||
]</ |
]</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Revision as of 10:02, 4 January 2024
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.
11l
F min_cells_matrix(siz)
R (0 .< siz).map(row -> (0 .< @siz).map(col -> min(@row, col, @@siz - @row - 1, @@siz - col - 1)))
F display_matrix(mat)
V siz = mat.len
V spaces = I siz < 20 {2} E I siz < 200 {3} E 4
print("\nMinimum number of cells after, before, above and below "siz‘ x ’siz‘ square:’)
L(row) 0 .< siz
print(mat[row].map(n -> String(n).rjust(@spaces)).join(‘’))
L(siz) [23, 10, 9, 2, 1]
display_matrix(min_cells_matrix(siz))- Output:
Minimum number of cells after, before, above and below 23 x 23 square: 0 0 0 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 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0 0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0 0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0 0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0 0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 7 7 7 7 7 7 7 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 8 8 8 8 8 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 9 9 9 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 10 10 10 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 10 11 10 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 10 10 10 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 9 9 9 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 8 8 8 8 8 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 7 7 7 7 7 7 7 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0 0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0 0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0 0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0 0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 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 0 0 0 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
ALGOL 68
As with the Algol W version, the cells are printed as they are calculated. Ensures the counts are shown in the same width.
BEGIN # show the minimum number of cells above, below, before and after each #
# cell in a suare matrix #
PROC min = ( INT a, b )INT: IF a < b THEN a ELSE b FI;
PROC print min cells = ( INT n )VOID:
BEGIN
# deduce how many digits we need to show so the counts are all #
# the same width #
INT w = BEGIN
INT width := 1, v := ( ( n - ( ABS NOT ODD n ) ) OVER 2 );
WHILE v > 9 DO v OVERAB 10; width +:= 1 OD;
width
END;
print( ( "Minimum number of cells after, before, above and below "
, whole( n, 0 )
, " x "
, whole( n, 0 )
, " square:"
, newline
)
);
FOR r FROM 0 TO n - 1 DO
FOR c FROM 0 TO n - 1 DO print( ( whole( min( n-r-1, min( r, min( c, n-c-1 ) ) ), -w ), " " ) ) OD;
print( ( newline ) )
OD
END # print min cells # ;
[]INT tests = ( 10, 9, 2, 1, 21 );
FOR i FROM LWB tests TO UPB tests DO
print min cells( tests[ i ] );
print( ( newline ) )
OD
END- 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 Minimum number of cells after, before, above and below 21 x 21 square: 0 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 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0 0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0 0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0 0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0 0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 7 7 7 7 7 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 8 8 8 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 9 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 10 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 9 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 8 8 8 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 7 7 7 7 7 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0 0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0 0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0 0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0 0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0 0 1 1 1 1 1 1 1 1 1 1 1 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 0
ALGOL W
This version avoids generating an explicit list of elements for each row in the matrix and just prints the elements as they are calculated. The elements are all shown in the same field width.
begin % show the minimum number of cells above, below, before and after each %
% cell in a square matrix %
integer procedure min4( integer value a, b, c, d ) ;
begin
integer m;
m := a;
if b < m then m := b;
if c < m then m := c;
if d < m then m := d;
m
end min4 ;
procedure printMinCells ( integer value n ) ;
begin
integer w, v;
w := 1; v := ( ( n - ( if odd( n ) then 1 else 0 ) ) div 2 );
while v > 9 do begin v := v div 10; w := w + 1 end;
write( i_w := 1, s_w := 0, "Minimum number of cells after, before, above and below ", n, " x ", n, " square:" );
write();
for r := 0 until n - 1 do begin
for c := 0 until n - 1 do writeon( i_w := w, s_w := 1, min4( n-r-1, r, c, n-c-1 ) );
write()
end for_r
end printMinCells ;
for n := 10, 9, 2, 1 do printMinCells( n )
end.- 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 Minimum number of cells after, before, above and below 21 x 21 square: 0 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 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0 0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0 0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0 0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0 0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 7 7 7 7 7 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 8 8 8 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 9 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 10 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 9 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 8 8 8 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 7 7 7 7 7 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0 0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0 0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0 0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0 0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0 0 1 1 1 1 1 1 1 1 1 1 1 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 0
APL
n_by_n ← (⌽⌊⊖)∘(∘.⌊⍨¯1+⍳)
n_by_n¨ 2 3 9 10
- Output:
┌───┬─────┬─────────────────┬───────────────────┐ │0 0│0 0 0│0 0 0 0 0 0 0 0 0│0 0 0 0 0 0 0 0 0 0│ │0 0│0 1 0│0 1 1 1 1 1 1 1 0│0 1 1 1 1 1 1 1 1 0│ │ │0 0 0│0 1 2 2 2 2 2 1 0│0 1 2 2 2 2 2 2 1 0│ │ │ │0 1 2 3 3 3 2 1 0│0 1 2 3 3 3 3 2 1 0│ │ │ │0 1 2 3 4 3 2 1 0│0 1 2 3 4 4 3 2 1 0│ │ │ │0 1 2 3 3 3 2 1 0│0 1 2 3 4 4 3 2 1 0│ │ │ │0 1 2 2 2 2 2 1 0│0 1 2 3 3 3 3 2 1 0│ │ │ │0 1 1 1 1 1 1 1 0│0 1 2 2 2 2 2 2 1 0│ │ │ │0 0 0 0 0 0 0 0 0│0 1 1 1 1 1 1 1 1 0│ │ │ │ │0 0 0 0 0 0 0 0 0 0│ └───┴─────┴─────────────────┴───────────────────┘
AppleScript
use framework "Foundation"
------------------- DISTANCES FROM EDGE ------------------
-- distancesFromEdge :: Int -> [[Int]]
on distancesFromEdge(n)
-- A matrix of minimum distances to the edge.
script f
on |λ|(row, col)
minimum({row - 1, col - 1, n - row, n - col})
end |λ|
end script
matrix(n, n, f)
end distancesFromEdge
--------------------------- TEST -------------------------
on run
script test
on |λ|(n)
showMatrix(my distancesFromEdge(n)) & ¬
linefeed
end |λ|
end script
unlines(map(test, {25, 10, 9, 2, 1}))
end run
------------------------- GENERIC ------------------------
-- 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
-- minimum :: Ord a => [a] -> a
on minimum(xs)
set ca to current application
unwrap((ca's NSArray's arrayWithArray:xs)'s ¬
valueForKeyPath:"@min.self")
end minimum
-- 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
-- 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
-- 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
-- unwrap :: NSValue -> a
on unwrap(nsValue)
if nsValue is missing value then
missing value
else
set ca to current application
item 1 of ((ca's NSArray's arrayWithObject:nsValue) as list)
end if
end unwrap
------------------------ FORMATTING ----------------------
-- 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))
end showMatrix
-- 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 |λ|(txt)
if n > length of txt then
text -n thru -1 of ((replicate(n, cFiller) as text) & txt)
else
txt
end if
end |λ|
end script
end justifyRight
-- max :: Ord a => a -> a -> a
on max(x, y)
if x > y then
x
else
y
end if
end max
-- 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
-- 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
- Output:
0 0 0 0 0 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 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0 0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0 0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0 0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0 0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 7 7 7 7 7 7 7 7 7 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 8 8 8 8 8 8 8 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 9 9 9 9 9 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 10 10 10 10 10 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 10 11 11 11 10 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 10 11 12 11 10 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 10 11 11 11 10 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 10 10 10 10 10 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 9 9 9 9 9 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 8 8 8 8 8 8 8 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 7 7 7 7 7 7 7 7 7 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0 0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0 0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0 0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0 0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 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 0 0 0 0 0 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 0 0 0 0 0
Arturo
printMinCells: function [n][
cells: array.of:n 0
loop 0..dec n 'r [
loop 0..dec n 'c ->
cells\[c]: min @[dec n-r, r, c, dec n-c]
print cells
]
]
loop [10 9 2 1] 'n [
print ["Minimum number of cells after, before, above and below" n "x" n "square:"]
printMinCells n
print ""
]
- 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
AutoHotkey
gridSize := 10
grid := []
loop % gridSize {
row := A_Index
loop % gridSize {
col := A_Index
grid[row, col] := Min(row, col, gridSize+1-row, gridSize+1-col) - 1
}
}
for row, obj in Grid {
for col, v in obj
result .= v " "
result .= "`n"
}
MsgBox % result
- 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
AWK
# syntax: GAWK -f MINIMUM_NUMBER_OF_CELLS_AFTER_BEFORE_ABOVE_AND_BELOW_NXN_SQUARES.AWK
BEGIN {
leng = split("3,4,9,10,23",arr,",")
for (k=1; k<=leng; k++) {
n = arr[k]
printf("\nDistance to nearest edge: %dx%d\n",n,n)
for (i=1; i<=n; i++) {
for (j=1; j<=n; j++) {
printf("%2d ",min(min(i-1,n-i),min(j-1,n-j)))
}
printf("\n")
}
}
exit(0)
}
function min(x,y) { return((x < y) ? x : y) }
- Output:
Distance to nearest edge: 3x3 0 0 0 0 1 0 0 0 0 Distance to nearest edge: 4x4 0 0 0 0 0 1 1 0 0 1 1 0 0 0 0 0 Distance to nearest edge: 9x9 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 Distance to nearest edge: 10x10 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 Distance to nearest edge: 23x23 0 0 0 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 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0 0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0 0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0 0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0 0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 7 7 7 7 7 7 7 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 8 8 8 8 8 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 9 9 9 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 10 10 10 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 10 11 10 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 10 10 10 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 9 9 9 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 8 8 8 8 8 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 7 7 7 7 7 7 7 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0 0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0 0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0 0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0 0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 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 0 0 0
BASIC
Applesoft BASIC
100 HOME : REM 100 CLS for Chipmunk Basic
110 n = 10
120 FOR i = 1 TO n
130 FOR j = 1 TO n
140 IF i-1 <= n-i THEN a = i-1 : GOTO 160
150 IF i-1 > n-i THEN a = n-i
160 IF j-1 <= n-j THEN b = j-1 : GOTO 180
170 IF j-1 > n-j THEN b = n-j
180 IF a <= b THEN r = a : GOTO 200
190 IF a > b THEN r = b
200 PRINT r " ";
210 NEXT j
220 PRINT
230 NEXT i
240 END
- Output:
Same as Chipmunk Basic entry.
BASIC256
function min(a, b)
if a<=b then return a else return b
end function
subroutine minab(n)
for i = 1 to n
for j = 1 to n
print min(min(i-1, n-i), min(j-1, n-j)); " ";
next j
print
next i
end subroutine
call minab(10)
end- Output:
Igual que la entrada de FreeBASIC.
Chipmunk Basic
10 cls
20 call minab(10)
30 end
40 sub min(a,b)
50 if a <= b then min = a else min = b
60 end sub
70 sub minab(n)
80 for i = 1 to n
90 for j = 1 to n
100 print using "##"; min(min(i-1,n-i),min(j-1,n-j));
110 next j
120 print
130 next i
140 end sub
- Output:
Same as BASIC256 entry.
FreeBASIC
#define min(a, b) Iif(a<=b,a,b)
sub minab( n as uinteger )
for i as uinteger = 1 to n
for j as uinteger = 1 to n
print using "## ";min( min(i-1, n-i), min(j-1, n-j) );
next j
print
next i
end sub
minab(10)- 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
GW-BASIC
10 N = 10
20 FOR I = 0 TO N - 1
30 IF I < N - 1 - I THEN DI = I ELSE DI = N - 1 - I
40 FOR J = 0 TO N - 1
50 IF J < N - 1 - J THEN DJ = J ELSE DJ = N - 1 - J
60 IF DI < DJ THEN M = DI ELSE M = DJ
70 PRINT USING "## ";M;
80 NEXT J
90 PRINT
100 NEXT IMinimal BASIC
10 REM Minimum number of cells after, before, above and below NxN squares
20 LET N = 10
30 FOR I = 0 TO N-1
40 IF I < N-1-I THEN 70
50 LET D = N-1-I
60 GOTO 80
70 LET D = I
80 FOR J = 0 TO N-1
90 IF J < N-1-J THEN 120
100 LET E = N-1-J
110 GOTO 130
120 LET E = J
130 IF D < E THEN 160
140 LET M = E
150 GOTO 170
160 LET M = D
170 IF M >= 10 THEN 190
180 PRINT " ";
190 PRINT M;
200 NEXT J
210 PRINT
220 NEXT I
230 END
QBasic
DECLARE FUNCTION min! (a!, b!)
DECLARE SUB minab (n!)
CLS
minab (10)
END
FUNCTION min (a, b)
IF a <= b THEN min = a ELSE min = b
END FUNCTION
SUB minab (n)
FOR i = 1 TO n
FOR j = 1 TO n
PRINT USING "## "; min(min(i - 1, n - i), min(j - 1, n - j));
NEXT j
PRINT
NEXT i
END SUB
- Output:
Igual que la entrada de FreeBASIC.
RapidQ
Introduced extra variables MinI and MinJ, because nested Min functions do not work correctly (why do they not?).
' Minimum number of cells after, before, above and below NxN squares
DECLARE FUNCTION Min(A AS WORD, B AS WORD) AS WORD
DECLARE SUB MinAB(N AS WORD)
CLS
MinAB(10)
END
FUNCTION Min(A AS WORD, B AS WORD) AS WORD
IF A <= B THEN Min = A ELSE Min = B
END FUNCTION
SUB MinAB(N AS WORD)
FOR I = 1 TO N
MinI = Min(I - 1, N - I)
FOR J = 1 TO N
MinJ = Min(J - 1, N - J)
PRINT FORMAT$("%2d ", Min(MinI, MinJ));
NEXT J
PRINT
NEXT I
END SUB- Output:
To samo, co we FreeBASIC.
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
Tiny BASIC
10 REM Minimum number of cells after, before, above and below NxN squares
20 LET N=10
30 LET I=0
40 IF I<N-1-I THEN GOTO 70
50 LET D=N-1-I
60 GOTO 80
70 LET D=I
80 LET J=0
90 IF J<N-1-J THEN GOTO 120
100 LET E=N-1-J
110 GOTO 130
120 LET E=J
130 IF D<E THEN GOTO 160
140 LET M=E
150 GOTO 170
160 LET M=D
170 IF M<10 THEN PRINT " ";
180 PRINT M;" ";
190 LET J=J+1
200 IF J=N THEN GOTO 220
210 GOTO 90
220 PRINT
230 LET I=I+1
240 IF I=N THEN GOTO 260
250 GOTO 40
260 END
- 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
True BASIC
FUNCTION min (a, b)
IF a <= b THEN LET min = a ELSE LET min = b
END FUNCTION
SUB minab (n)
FOR i = 1 TO n
FOR j = 1 TO n
PRINT USING "## ": min(min(i - 1, n - i), min(j - 1, n - j));
NEXT j
PRINT
NEXT i
END SUB
CALL minab (10)
END
- Output:
Igual que la entrada de QBasic.
Yabasic
minab(10)
end
sub minab(n)
for i = 1 to n
for j = 1 to n
print min(min(i-1, n-i), min(j-1, n-j)) using ("##");
next j
print
next i
end sub- Output:
Igual que la entrada de FreeBASIC.
BCPL
get "libhdr"
let min(a,b) = a<b -> a, b
let minNbyN(n, cw) be
for y=0 to n-1
$( for x=0 to n-1 do
writed(min(x, min(n-x-1, min(y, n-y-1))), cw)
wrch('*N')
$)
let start() be minNbyN(10, 3)- 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
BQN
NByN ← ⌊⌜˜ ⌽⊸⌊∘↕
NByN¨ 2‿3‿9‿10
- Output:
┌─
· ┌─ ┌─ ┌─ ┌─
╵ 0 0 ╵ 0 0 0 ╵ 0 0 0 0 0 0 0 0 0 ╵ 0 0 0 0 0 0 0 0 0 0
0 0 0 1 0 0 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0
┘ 0 0 0 0 1 2 2 2 2 2 1 0 0 1 2 2 2 2 2 2 1 0
┘ 0 1 2 3 3 3 2 1 0 0 1 2 3 3 3 3 2 1 0
0 1 2 3 4 3 2 1 0 0 1 2 3 4 4 3 2 1 0
0 1 2 3 3 3 2 1 0 0 1 2 3 4 4 3 2 1 0
0 1 2 2 2 2 2 1 0 0 1 2 3 3 3 3 2 1 0
0 1 1 1 1 1 1 1 0 0 1 2 2 2 2 2 2 1 0
0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0
┘ 0 0 0 0 0 0 0 0 0 0
┘
┘
C
#include<stdio.h>
#include<stdlib.h>
#define min(a, b) (a<=b?a:b)
void minab( unsigned int n ) {
int i, j;
for(i=0;i<n;i++) {
for(j=0;j<n;j++) {
printf( "%2d ", min( min(i, n-1-i), min(j, n-1-j) ));
}
printf( "\n" );
}
return;
}
int main(void) {
minab(10);
return 0;
}
- 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
CLU
min = proc [T: type] (a, b: T) returns (T)
where T has lt: proctype (T,T) returns (bool)
if a<b
then return(a)
else return(b)
end
end min
min_n_by_n = proc (n: int) returns (array[array[int]])
ai = array[int]
aai = array[ai]
t: aai := aai$[]
for y: int in int$from_to(0, n-1) do
aai$addh(t, ai$[])
for x: int in int$from_to(0, n-1) do
i: int := min[int](x, min[int](n-x-1, min[int](y, n-y-1)))
ai$addh(aai$top(t), i)
end
end
return(t)
end min_n_by_n
print_table = proc (s: stream, table: array[array[int]])
ai = array[int]
aai = array[ai]
for line: ai in aai$elements(table) do
for item: int in ai$elements(line) do
stream$puts(s, int$unparse(item) || " ")
end
stream$putl(s, "")
end
end print_table
start_up = proc ()
print_table(stream$primary_output(), min_n_by_n(10))
end start_up- 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
COBOL
IDENTIFICATION DIVISION.
PROGRAM-ID. MINIMUM-CELLS-N-BY-N.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 TABLE-SIZE PIC 99 VALUE 10.
01 X PIC 99.
01 Y PIC 99.
01 ITEM PIC 99.
01 MIN PIC 99.
01 FMT PIC ZZ9.
01 TABLE-LINE PIC X(72).
01 LINE-PTR PIC 99.
PROCEDURE DIVISION.
BEGIN.
PERFORM MAKE-LINE VARYING Y FROM 0 BY 1
UNTIL Y IS EQUAL TO TABLE-SIZE.
STOP RUN.
MAKE-LINE.
MOVE SPACES TO TABLE-LINE.
MOVE 1 TO LINE-PTR.
PERFORM ADD-ITEM VARYING X FROM 0 BY 1
UNTIL X IS EQUAL TO TABLE-SIZE.
DISPLAY TABLE-LINE.
ADD-ITEM.
PERFORM FIND-MINIMUM-VALUE.
MOVE MIN TO FMT.
STRING FMT DELIMITED BY SIZE INTO TABLE-LINE
WITH POINTER LINE-PTR.
FIND-MINIMUM-VALUE.
MOVE X TO MIN.
MOVE Y TO ITEM.
PERFORM CHECK-MINIMUM.
COMPUTE ITEM = TABLE-SIZE - Y - 1.
PERFORM CHECK-MINIMUM.
COMPUTE ITEM = TABLE-SIZE - X - 1.
PERFORM CHECK-MINIMUM.
CHECK-MINIMUM.
IF ITEM IS LESS THAN MIN, MOVE ITEM TO MIN.
- 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
Excel
LAMBDA
Binding the name distancesToEdge to the following lambda expression in the Name Manager of the Excel WorkBook:
(See LAMBDA: The ultimate Excel worksheet function)
=LAMBDA(n,
LET(
lastIndex, n - 1,
LAMBDA(i,
LET(
x, MOD(i, n),
y, QUOTIENT(i, n),
evaluate(
"MIN({" &
TEXT(x, "0") & "," &
TEXT(y, "0") & "," &
TEXT(lastIndex - x, "0") & "," &
TEXT(lastIndex - y, "0") &
"})"
)
)
)(SEQUENCE(n, n, 0, 1))
)
)
- Output:
The single formula in the cell B2 defines the whole matrix value which spills out to column K and row 11:
| fx | =distancesToEdge(A2) | |||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| A | B | C | D | E | F | G | H | I | J | K | ||
| 1 | Dimension | |||||||||||
| 2 | 10 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | |
| 3 | 0 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 0 | ||
| 4 | 0 | 1 | 2 | 2 | 2 | 2 | 2 | 2 | 1 | 0 | ||
| 5 | 0 | 1 | 2 | 3 | 3 | 3 | 3 | 2 | 1 | 0 | ||
| 6 | 0 | 1 | 2 | 3 | 4 | 4 | 3 | 2 | 1 | 0 | ||
| 7 | 0 | 1 | 2 | 3 | 4 | 4 | 3 | 2 | 1 | 0 | ||
| 8 | 0 | 1 | 2 | 3 | 3 | 3 | 3 | 2 | 1 | 0 | ||
| 9 | 0 | 1 | 2 | 2 | 2 | 2 | 2 | 2 | 1 | 0 | ||
| 10 | 0 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 0 | ||
| 11 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ||
| 12 | ||||||||||||
| 13 | 9 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ||
| 14 | 0 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 0 | |||
| 15 | 0 | 1 | 2 | 2 | 2 | 2 | 2 | 1 | 0 | |||
| 16 | 0 | 1 | 2 | 3 | 3 | 3 | 2 | 1 | 0 | |||
| 17 | 0 | 1 | 2 | 3 | 4 | 3 | 2 | 1 | 0 | |||
| 18 | 0 | 1 | 2 | 3 | 3 | 3 | 2 | 1 | 0 | |||
| 19 | 0 | 1 | 2 | 2 | 2 | 2 | 2 | 1 | 0 | |||
| 20 | 0 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 0 | |||
| 21 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | |||
| 22 | ||||||||||||
| 23 | 2 | 0 | 0 | |||||||||
| 24 | 0 | 0 | ||||||||||
| 25 | ||||||||||||
| 26 | 1 | 0 | ||||||||||
Delphi
The problem is not well described. You have to look at other people's code to understand the problem, which turns out to be something quite different from the description seems to say.
function EdgeDistance(P: TPoint; Size: integer): integer;
{Find the distance to the nearest edge}
begin
Result:=Min(Min(P.X,(Size-1)-P.X),Min(P.Y,(Size-1)-P.Y));
end;
procedure MapMatrix(Memo: TMemo; Size: integer);
{Map each cell in Size X Size matrix}
{with the distance to nearest edge}
var X,Y,E: integer;
var S: string;
begin
Memo.Lines.Add(Format('Map for %d X %d Matrix',[Size,Size]));
S:='';
for Y:=0 to Size-1 do
begin
for X:=0 to Size-1 do
begin
E:=EdgeDistance(Point(X,Y),Size);
S:=S+Format('%3d',[E]);
end;
S:=S+#$0D#$0A;
end;
Memo.Lines.Add(S);
end;
procedure ShowEdgeMaps(Memo: TMemo);
{Show a series of maps for matrices of different sizes}
var I: integer;
begin
for I:=3 to 12 do MapMatrix(Memo,I);
end;
- Output:
Map for 3 X 3 Matrix 0 0 0 0 1 0 0 0 0 Map for 4 X 4 Matrix 0 0 0 0 0 1 1 0 0 1 1 0 0 0 0 0 Map for 5 X 5 Matrix 0 0 0 0 0 0 1 1 1 0 0 1 2 1 0 0 1 1 1 0 0 0 0 0 0 Map for 6 X 6 Matrix 0 0 0 0 0 0 0 1 1 1 1 0 0 1 2 2 1 0 0 1 2 2 1 0 0 1 1 1 1 0 0 0 0 0 0 0 Map for 7 X 7 Matrix 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 1 2 2 2 1 0 0 1 2 3 2 1 0 0 1 2 2 2 1 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 Map for 8 X 8 Matrix 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0 1 2 2 2 2 1 0 0 1 2 3 3 2 1 0 0 1 2 3 3 2 1 0 0 1 2 2 2 2 1 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 Map for 9 X 9 Matrix 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 Map for 10 X 10 Matrix 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 Map for 11 X 11 Matrix 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 0 0 1 2 2 2 2 2 2 2 1 0 0 1 2 3 3 3 3 3 2 1 0 0 1 2 3 4 4 4 3 2 1 0 0 1 2 3 4 5 4 3 2 1 0 0 1 2 3 4 4 4 3 2 1 0 0 1 2 3 3 3 3 3 2 1 0 0 1 2 2 2 2 2 2 2 1 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 Map for 12 X 12 Matrix 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 0 0 1 2 2 2 2 2 2 2 2 1 0 0 1 2 3 3 3 3 3 3 2 1 0 0 1 2 3 4 4 4 4 3 2 1 0 0 1 2 3 4 5 5 4 3 2 1 0 0 1 2 3 4 5 5 4 3 2 1 0 0 1 2 3 4 4 4 4 3 2 1 0 0 1 2 3 3 3 3 3 3 2 1 0 0 1 2 2 2 2 2 2 2 2 1 0 0 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0
F#
// Minimum number of cells after, before, above and below NxN squares. Nigel Galloway: August 1st., 2021
printfn "%A" (Array2D.init 10 10 (fun n g->List.min [n;g;9-n;9-g]))
printfn "\n%A" (Array2D.init 9 9 (fun n g->List.min [n;g;8-n;8-g]))
- 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]]
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 9 2 1 } [ square simple-table. nl ] each
- 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 0 0 0 0 0
Fermat
Func Min(a, b) = if a<=b then a else b fi.;
n:=10;
Array x[n, n];
[x]:= [<i=1,n> <j=1,n> Min(Min(i-1,n-i),Min(j-1,n-j))];
[x];- 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 ]]
Go
package main
import "fmt"
func printMinCells(n int) {
fmt.Printf("Minimum number of cells after, before, above and below %d x %d square:\n", n, n)
p := 1
if n > 20 {
p = 2
}
for r := 0; r < n; r++ {
cells := make([]int, n)
for c := 0; c < n; c++ {
nums := []int{n - r - 1, r, c, n - c - 1}
min := n
for _, num := range nums {
if num < min {
min = num
}
}
cells[c] = min
}
fmt.Printf("%*d \n", p, cells)
}
}
func main() {
for _, n := range []int{23, 10, 9, 2, 1} {
printMinCells(n)
fmt.Println()
}
}
- Output:
Minimum number of cells after, before, above and below 23 x 23 square: [ 0 0 0 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 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0] [ 0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0] [ 0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0] [ 0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0] [ 0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0] [ 0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0] [ 0 1 2 3 4 5 6 7 7 7 7 7 7 7 7 7 6 5 4 3 2 1 0] [ 0 1 2 3 4 5 6 7 8 8 8 8 8 8 8 7 6 5 4 3 2 1 0] [ 0 1 2 3 4 5 6 7 8 9 9 9 9 9 8 7 6 5 4 3 2 1 0] [ 0 1 2 3 4 5 6 7 8 9 10 10 10 9 8 7 6 5 4 3 2 1 0] [ 0 1 2 3 4 5 6 7 8 9 10 11 10 9 8 7 6 5 4 3 2 1 0] [ 0 1 2 3 4 5 6 7 8 9 10 10 10 9 8 7 6 5 4 3 2 1 0] [ 0 1 2 3 4 5 6 7 8 9 9 9 9 9 8 7 6 5 4 3 2 1 0] [ 0 1 2 3 4 5 6 7 8 8 8 8 8 8 8 7 6 5 4 3 2 1 0] [ 0 1 2 3 4 5 6 7 7 7 7 7 7 7 7 7 6 5 4 3 2 1 0] [ 0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0] [ 0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0] [ 0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0] [ 0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0] [ 0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0] [ 0 1 1 1 1 1 1 1 1 1 1 1 1 1 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 0 0 0] 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]
Haskell
import Data.List.Split (chunksOf)
----------- SHORTEST DISTANCES TO EDGE OF MATRIX ---------
distancesToEdge :: Int -> [[Int]]
distancesToEdge n =
( \i ->
chunksOf n $
(\(x, y) -> minimum [x, y, i - x, i - y])
<$> (fmap (,) >>= (<*>)) [0 .. i]
)
$ pred n
--------------------------- TEST -------------------------
main :: IO ()
main =
mapM_ putStrLn $
showMatrix . distancesToEdge <$> [10, 9, 2, 1]
------------------------- DISPLAY ------------------------
showMatrix :: Show a => [[a]] -> String
showMatrix m =
let w = (succ . maximum) $ fmap (length . show) =<< m
rjust n c = (drop . length) <*> (replicate n c <>)
in unlines (unwords . fmap (rjust w ' ' . show) <$> m)
- 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 0 0 0 0 0
or in terms of Data.Matrix:
import Data.Matrix ( matrix, Matrix )
----------- SHORTEST DISTANCES TO EDGE OF MATRIX ---------
distancesToEdge :: Int -> Matrix Int
distancesToEdge n = matrix n n
(\(i, j) -> minimum $ ($) <$> [pred, (n -)] <*> [i, j])
--------------------------- TEST -------------------------
main :: IO ()
main = mapM_ print $ distancesToEdge <$> [10, 9, 2, 1]
- 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 │ └ ┘ ┌ ┐ │ 0 0 │ │ 0 0 │ └ ┘ ┌ ┐ │ 0 │ └ ┘
or bypassing 'minimum', to reduce the count of comparisons (same output as above):
import Data.Bifunctor (bimap)
import Data.Matrix (Matrix, matrix)
----------- SHORTEST DISTANCES TO EDGE OF MATRIX ---------
distancesToEdge :: Int -> Matrix Int
distancesToEdge n = matrix n n (uncurry min . bimap f f)
where
m = quot n 2
f i
| i <= m = pred i
| otherwise = n - i
--------------------------- TEST -------------------------
main :: IO ()
main = mapM_ print $ distancesToEdge <$> [10, 9, 2, 1]
J
nByN=: (|."1<.|.)@(<./~@i.)
nByN each 2 3 9 10
- Output:
┌───┬─────┬─────────────────┬───────────────────┐ │0 0│0 0 0│0 0 0 0 0 0 0 0 0│0 0 0 0 0 0 0 0 0 0│ │0 0│0 1 0│0 1 1 1 1 1 1 1 0│0 1 1 1 1 1 1 1 1 0│ │ │0 0 0│0 1 2 2 2 2 2 1 0│0 1 2 2 2 2 2 2 1 0│ │ │ │0 1 2 3 3 3 2 1 0│0 1 2 3 3 3 3 2 1 0│ │ │ │0 1 2 3 4 3 2 1 0│0 1 2 3 4 4 3 2 1 0│ │ │ │0 1 2 3 3 3 2 1 0│0 1 2 3 4 4 3 2 1 0│ │ │ │0 1 2 2 2 2 2 1 0│0 1 2 3 3 3 3 2 1 0│ │ │ │0 1 1 1 1 1 1 1 0│0 1 2 2 2 2 2 2 1 0│ │ │ │0 0 0 0 0 0 0 0 0│0 1 1 1 1 1 1 1 1 0│ │ │ │ │0 0 0 0 0 0 0 0 0 0│ └───┴─────┴─────────────────┴───────────────────┘
jq
Also works with gojq, the Go implementation of jq
Also works with fq, a Go implementation of a large subset of jq
def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;
def printMinCells:
"Minimum number of cells after, before, above and below each cell in a \(.) x \(.) matrix:",
( (. / 2 | ceil | tostring | length) as $p
| range(0; .) as $r
| [ range(0; .) as $c
| [. - $r - 1, $r, $c, . - $c - 1] | min | lpad($p)] | join(" ") );
23, 10, 9, 2, 1
| printMinCells, ""- Output:
As expected.
Julia
function printNbyN(sizes)
for N in sizes
mat = zeros(Int, N, N)
println("\n\nMinimum number of cells after, before, above and below $N x $N square:")
for r in 1:N, c in 1:N
mat[r, c] = min(r - 1, c - 1, N - r, N - c)
end
display(mat)
end
end
printNbyN([23, 10, 9, 2, 1])
- Output:
Minimum number of cells after, before, above and below 23 x 23 square:
23×23 Matrix{Int64}:
0 0 0 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 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0
0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0
0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0
0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0
0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0
0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0
0 1 2 3 4 5 6 7 7 7 7 7 7 7 7 7 6 5 4 3 2 1 0
0 1 2 3 4 5 6 7 8 8 8 8 8 8 8 7 6 5 4 3 2 1 0
0 1 2 3 4 5 6 7 8 9 9 9 9 9 8 7 6 5 4 3 2 1 0
0 1 2 3 4 5 6 7 8 9 10 10 10 9 8 7 6 5 4 3 2 1 0
0 1 2 3 4 5 6 7 8 9 10 11 10 9 8 7 6 5 4 3 2 1 0
0 1 2 3 4 5 6 7 8 9 10 10 10 9 8 7 6 5 4 3 2 1 0
0 1 2 3 4 5 6 7 8 9 9 9 9 9 8 7 6 5 4 3 2 1 0
0 1 2 3 4 5 6 7 8 8 8 8 8 8 8 7 6 5 4 3 2 1 0
0 1 2 3 4 5 6 7 7 7 7 7 7 7 7 7 6 5 4 3 2 1 0
0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0
0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0
0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0
0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0
0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0
0 1 1 1 1 1 1 1 1 1 1 1 1 1 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 0 0 0
Minimum number of cells after, before, above and below 10 x 10 square:
10×10 Matrix{Int64}:
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:
9×9 Matrix{Int64}:
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:
2×2 Matrix{Int64}:
0 0
0 0
Minimum number of cells after, before, above and below 1 x 1 square:
1×1 Matrix{Int64}:
0
MiniZinc
%Minimum number of cells after, before, above and below NxN squares. Nigel Galloway, August 3rd., 2021
int: Size=10; int: S=Size-1; set of int: N=0..S;
array[N,N] of var int: G = array2d(N,N,[min([n,g,S-n,S-g])|n,g in N]);
output([show2d(G)])- 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 |] ---------- Finished in 209msec
Modula-2
MODULE MinNByN;
FROM InOut IMPORT WriteCard, WriteLn;
PROCEDURE minNbyN(n, cellwidth: CARDINAL);
VAR x, y: CARDINAL;
PROCEDURE min(a, b: CARDINAL): CARDINAL;
BEGIN
IF a < b THEN RETURN a;
ELSE RETURN b;
END;
END min;
BEGIN
FOR y := 0 TO n-1 DO
FOR x := 0 TO n-1 DO
WriteCard(min(x, min(n-x-1, min(y, n-y-1))), cellwidth);
END;
WriteLn();
END;
END minNbyN;
BEGIN
minNbyN(10, 3);
END MinNByN.
- 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
Nim
import strutils
proc printMinCells(n: Positive) =
echo "Minimum number of cells after, before, above and below $1 x $1 square:".format(n)
var cells = newSeq[int](n)
for r in 0..<n:
for c in 0..<n:
cells[c] = min([n - r - 1, r, c, n - c - 1])
echo cells.join(" ")
when isMainModule:
for n in [10, 9, 2, 1]:
printMinCells(n)
echo()
- 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
PARI/GP
n=10
matrix(n,n,i,j,min(min(i-1,n-i),min(j-1,n-j)))- 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]
Pascal
Using symmetry within row and col.Fill only the middle and let the values before in place.
program mindistance;
{$IFDEF FPC} //used fpc 3.2.1
{$MODE DELPHI} {$OPTIMIZATION ON,ALL} {$COPERATORS ON}
{$ELSE}
{$APPTYPE CONSOLE}
{$ENDIF}
uses
sysutils
{$IFDEF WINDOWS},Windows{$ENDIF}
;
type
tMinDist = array of Uint32;
tpMinDist= pUint32;
var
dgtwidth : NativeUint;
OneRowElems : tMinDist;
function CalcDigitWidth(n: NativeUint):NativeUint;
begin
result:= 2;
while n>= 10 do
Begin
inc(result);
n := n DIV 10;
end;
end;
procedure OutOneRow(var OneRowElems:tMinDist);
var
one_digit,one_row :string;
i : NativeInt;
begin
one_row:= '';
For i := low(OneRowElems) to High(OneRowElems) do
begin
str(OneRowElems[i]:dgtwidth,one_digit);
one_row += one_digit;
end;
writeln(one_row);
end;
procedure OutSquareDist(MaxCoor : NativeUInt);
var
pRes : tpMinDist;
min_dist,row : NativeInt;
begin
//iniated with 0
setlength(OneRowElems,MaxCoor);
MaxCoor -= 1;//= High(OneRowElems);
pRes := @OneRowElems[0];
row := MaxCoor;
repeat
min_dist := MaxCoor-row;
if min_dist > row then
min_dist := row;
//fill the inner rest with min_dist
FillDWord(pRes[min_dist],(MaxCoor-2*min_dist+1),min_dist);
OutOneRow(OneRowElems);
dec(row);
until row < 0;
writeln;
setlength(OneRowElems,0);
end;
procedure Test(MaxCoor:NativeInt);
begin
if MaxCoor<= 0 then
EXIT;
write('Minimum number of cells after, before, above and below ');
writeln(MaxCoor,' x ',MaxCoor,' square:');
dgtwidth := CalcDigitWidth(NativeUint(MaxCoor) DIV 2);
OutSquareDist(MaxCoor);
end;
Begin
// Test(200*1000);// without output TIO.RUN Real time: 4.152 s CPU share: 97.70 %
Test(23);
Test(10);
Test(9);
Test(1);
end.
- Output:
TIO.RUN Minimum number of cells after, before, above and below 23 x 23 square: 0 0 0 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 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0 0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0 0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0 0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0 0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 7 7 7 7 7 7 7 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 8 8 8 8 8 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 9 9 9 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 10 10 10 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 10 11 10 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 10 10 10 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 9 9 9 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 8 8 8 8 8 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 7 7 7 7 7 7 7 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0 0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0 0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0 0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0 0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 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 0 0 0 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 1 x 1 square: 0
Perl
use strict;
use warnings;
use List::Util qw( max min );
for my $N (0, 1, 2, 6, 9, 23) {
my $fmt = ('%' . (1+length int $N/2) . 'd') x $N . "\n";
print "$N x $N distance to nearest edge:\n";
for my $row ( 0 .. $N-1 ) {
my @cols = map { min $_, $row, $N-1 - max $_, $row } 0 .. $N-1;
printf $fmt, @cols;
}
print "\n";
}
- Output:
0 x 0 distance to nearest edge: 1 x 1 distance to nearest edge: 0 2 x 2 distance to nearest edge: 0 0 0 0 6 x 6 distance to nearest edge: 0 0 0 0 0 0 0 1 1 1 1 0 0 1 2 2 1 0 0 1 2 2 1 0 0 1 1 1 1 0 0 0 0 0 0 0 9 x 9 distance to nearest edge: 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 23 x 23 distance to nearest edge: 0 0 0 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 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0 0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0 0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0 0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0 0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 7 7 7 7 7 7 7 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 8 8 8 8 8 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 9 9 9 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 10 10 10 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 10 11 10 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 10 10 10 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 9 9 9 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 8 8 8 8 8 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 7 7 7 7 7 7 7 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0 0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0 0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0 0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0 0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 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 0 0 0
Phix
with javascript_semantics procedure distance_to_edge(integer n) printf(1,"Minimum number of cells after, before, above and below %d x %d square:\n",n) for r=1 to n do for c=1 to n do printf(1,"%2d",min({r-1,c-1,n-r,n-c})) end for printf(1,"\n") end for end procedure papply({23,10,9,2,1},distance_to_edge)
- Output:
Minimum number of cells after, before, above and below 23 x 23 square: 0 0 0 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 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0 0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0 0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0 0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0 0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 7 7 7 7 7 7 7 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 8 8 8 8 8 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 9 9 9 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9101010 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9101110 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9101010 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 9 9 9 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 8 8 8 8 8 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 7 7 7 7 7 7 7 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0 0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0 0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0 0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0 0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 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 0 0 0 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
Although I rather like it the way it is, you could argue there should be more spacing on the 23x23, if you insist do this before the loops and use fmt on the innermost line:
string fmt = sprintf("%%%dd",length(sprint(floor((n-1)/2)))+1)
or maybe just (good for n<=200 whereas the above goes on and on to "%4d", etc.)
string fmt = iff(n<=20?"%2d":"%3d")
PILOT
C :size=10
:y=0
*line
C :$l=
:x=0
*item
C :sy=(size-y)-1
:sx=(size-x)-1
:i=x
C (y<i):i=y
C (sy<i):i=sy
C (sx<i):i=sx
:$l=$l #i
:x=x+1
J (x<size):*item
T :$l
C :y=y+1
J (y<size):*line
E :- 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
Python
def min_cells_matrix(siz):
return [[min(row, col, siz - row - 1, siz - col - 1) for col in range(siz)] for row in range(siz)]
def display_matrix(mat):
siz = len(mat)
spaces = 2 if siz < 20 else 3 if siz < 200 else 4
print(f"\nMinimum number of cells after, before, above and below {siz} x {siz} square:")
for row in range(siz):
print("".join([f"{n:{spaces}}" for n in mat[row]]))
def test_min_mat():
for siz in [23, 10, 9, 2, 1]:
display_matrix(min_cells_matrix(siz))
if __name__ == "__main__":
test_min_mat()
- Output:
Minimum number of cells after, before, above and below 23 x 23 square: 0 0 0 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 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0 0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0 0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0 0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0 0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 7 7 7 7 7 7 7 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 8 8 8 8 8 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 9 9 9 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 10 10 10 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 10 11 10 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 10 10 10 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 9 9 9 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 8 8 8 8 8 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 7 7 7 7 7 7 7 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0 0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0 0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0 0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0 0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 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 0 0 0 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
Or, disentangling computation from IO (separating model from display), and composing from generics:
'''Distance to edge of matrix'''
from itertools import chain, product
# distancesToEdge :: Int -> [[Int]]
def distancesToEdge(n):
'''A square matrix of dimension n, in which each
value is the minimum distance from the matrix
position to the edge of the matrix.
'''
lastIndex = n - 1
axis = range(0, n)
return chunksOf(n)([
min(x, y, lastIndex - x, lastIndex - y)
for (x, y) in product(axis, axis)
])
# ------------------------- TEST -------------------------
# main :: IO ()
def main():
'''Square matrices of distances to the matrix edge.
Sample matrices of dimensions [10, 9, 2, 1].
'''
print('\n\n'.join([
showMatrix(distancesToEdge(n)) for n
in [10, 9, 2, 1]
]))
# ----------------------- DISPLAY ------------------------
# showMatrix :: [[Int]] -> String
def showMatrix(xs):
'''String representation of xs
as a matrix.
'''
def go():
rows = [[str(x) for x in row] for row in xs]
w = max(map(len, chain.from_iterable(rows)))
return "\n".join(
" ".join(k.rjust(w, ' ') for k in row)
for row in rows
)
return go() if xs else ''
# ----------------------- GENERIC ------------------------
# chunksOf :: Int -> [a] -> [[a]]
def chunksOf(n):
'''A series of lists of length n, subdividing the
contents of xs. Where the length of xs is not evenly
divisible, the final list will be shorter than n.
'''
def go(xs):
return [
xs[i:n + i] for i in range(0, len(xs), n)
] if 0 < n else None
return go
# MAIN ---
if __name__ == '__main__':
main()
- 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 0 0 0 0 0
and in terms of a generalized matrix function:
'''Minimum distances to edge of matrix'''
from itertools import chain
# distanceFromEdge :: Int -> [[Int]]
def distanceFromEdge(n):
'''A matrix of minimum distances to the
edge of the matrix.
'''
return matrix(n)(n)(
lambda row, col: min([
row - 1, col - 1,
n - row, n - col
])
)
# ------------------------- TEST -------------------------
# main :: IO ()
def main():
'''Test'''
for n in [10, 9, 2, 1]:
print(
showMatrix(
distanceFromEdge(n)
) + "\n"
)
# ----------------------- GENERIC ------------------------
# matrix :: Int -> Int -> ((Int, Int) -> a) -> [[a]]
def matrix(nRows):
'''A matrix of a given number of columns and rows,
in which each value is a given function over the
tuple of its (one-based) row and column indices.
'''
def go(nCols):
def g(f):
return [
[f(y, x) for x in range(1, 1 + nCols)]
for y in range(1, 1 + nRows)
]
return g
return go
# showMatrix :: [[Int]] -> String
def showMatrix(xs):
'''String representation of xs
as a matrix.
'''
def go():
rows = [[str(x) for x in row] for row in xs]
w = max(map(len, chain.from_iterable(rows)))
return "\n".join(
" ".join(k.rjust(w, ' ') for k in row)
for row in rows
)
return go() if xs else ''
# MAIN ---
if __name__ == '__main__':
main()
- 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 0 0 0 0 0
Raku
sub distance-to-edge (\N) {
my $c = ceiling N / 2;
my $f = floor N / 2;
my @ul = ^$c .map: -> $x { [ ^$c .map: { min($x, $_) } ] }
@ul[$_].append: reverse @ul[$_; ^$f] for ^$c;
@ul.push: [ reverse @ul[$_] ] for reverse ^$f;
@ul
}
for 0, 1, 2, 6, 9, 23 {
my @dte = .&distance-to-edge;
my $max = chars max flat @dte».Slip;
say "\n$_ x $_ distance to nearest edge:";
.fmt("%{$max}d").say for @dte;
}
- Output:
0 x 0 distance to nearest edge: 1 x 1 distance to nearest edge: 0 2 x 2 distance to nearest edge: 0 0 0 0 6 x 6 distance to nearest edge: 0 0 0 0 0 0 0 1 1 1 1 0 0 1 2 2 1 0 0 1 2 2 1 0 0 1 1 1 1 0 0 0 0 0 0 0 9 x 9 distance to nearest edge: 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 23 x 23 distance to nearest edge: 0 0 0 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 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0 0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0 0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0 0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0 0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 7 7 7 7 7 7 7 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 8 8 8 8 8 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 9 9 9 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 10 10 10 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 10 11 10 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 10 10 10 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 9 9 9 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 8 8 8 8 8 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 7 7 7 7 7 7 7 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0 0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0 0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0 0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0 0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 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 0 0 0
REXX
This REXX version automatically adjusts the width of each (cell) number displayed so that all displayed numbers are aligned.
/*REXX pgm finds the minimum# of cells after, before, above, & below a NxN square matrix*/
parse arg $ /*obtain optional arguments from the CL*/
if $='' | $="," then $= 21 10 9 2 1 /*Not specified? Then use the default.*/
@title= ' the minimum number of cells after, before, above, and below a '
do j=1 for words($); g= word($, j) /*process each of the squares specified*/
w= length( (g-1) % 2) /*width of largest number to be shown. */
say center(@title g"x"g ' square matrix ', 86) /*center title of output to be shown. */
say center('', 86, '─') /*display a separator line below title.*/
do r=0 for g /*process output for a NxN sq. matrix*/
_= left('', max(0, 85%(w+1) -g ) ) /*compute indentation output centering.*/
do c=0 for g
_= _ right( min(r, c, g-r-1, g-c-1), w) /*construct a row of the output matrix.*/
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. */
- output when using the default inputs:
the minimum number of cells after, before, above, and below a 21x21 square matrix
──────────────────────────────────────────────────────────────────────────────────────
0 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 1 1 1 1 1 1 1 1 1 1 1 1 0
0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0
0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0
0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0
0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0
0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0
0 1 2 3 4 5 6 7 7 7 7 7 7 7 6 5 4 3 2 1 0
0 1 2 3 4 5 6 7 8 8 8 8 8 7 6 5 4 3 2 1 0
0 1 2 3 4 5 6 7 8 9 9 9 8 7 6 5 4 3 2 1 0
0 1 2 3 4 5 6 7 8 9 10 9 8 7 6 5 4 3 2 1 0
0 1 2 3 4 5 6 7 8 9 9 9 8 7 6 5 4 3 2 1 0
0 1 2 3 4 5 6 7 8 8 8 8 8 7 6 5 4 3 2 1 0
0 1 2 3 4 5 6 7 7 7 7 7 7 7 6 5 4 3 2 1 0
0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0
0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0
0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0
0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0
0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0
0 1 1 1 1 1 1 1 1 1 1 1 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 0
the minimum number of cells after, before, above, and below a 10x10 square matrix
──────────────────────────────────────────────────────────────────────────────────────
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 minimum number of cells after, before, above, and below a 9x9 square matrix
──────────────────────────────────────────────────────────────────────────────────────
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 minimum number of cells after, before, above, and below a 2x2 square matrix
──────────────────────────────────────────────────────────────────────────────────────
0 0
0 0
the minimum number of cells after, before, above, and below a 1x1 square matrix
──────────────────────────────────────────────────────────────────────────────────────
0
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- 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...
Ruby
def dist2edge(n)
width = (n/2).to_s.size+1
m = n-1
(0..m).map do |x|
(0..m).map{|y| [x, y, m-x, m-y].min.to_s.center(width) }.join
end
end
puts dist2edge(10)
- 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
V (Vlang)
fn print_min_cells(n int) {
println("Minimum number of cells after, before, above and below $n x $n square:")
for r in 0..n {
mut cells := []int{len: n}
for c in 0..n {
nums := [n - r - 1, r, c, n - c - 1]
mut min := n
for num in nums {
if num < min {
min = num
}
}
cells[c] = min
}
println(cells)
}
}
fn main() {
for n in [23, 10, 9, 2, 1] {
print_min_cells(n)
println('')
}
}- Output:
Same as Go entry
Wren
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:")
var p = (n < 21) ? 1 : 2
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", p, cells)
}
}
for (n in [23, 10, 9, 2, 1]) {
printMinCells.call(n)
System.print()
}
- Output:
Minimum number of cells after, before, above and below 23 x 23 square: 0 0 0 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 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0 0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0 0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0 0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0 0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 7 7 7 7 7 7 7 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 8 8 8 8 8 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 9 9 9 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 10 10 10 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 10 11 10 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 10 10 10 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 9 9 9 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 8 8 8 8 8 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 7 7 7 7 7 7 7 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 6 6 6 6 6 6 6 6 6 6 5 4 3 2 1 0 0 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 0 0 1 2 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 3 2 1 0 0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 1 0 0 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 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 0 0 0 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
XPL0
func Min(A, B);
int A, B;
return if A<B then A else B;
def N=10, M=N-1, C=M/2;
int X, Y, VX, VY;
[for Y:= 0 to M do
[for X:= 0 to M do
[VX:= if X <= C then X else M-X;
VY:= if Y <= C then Y else M-Y;
IntOut(0, Min(VX, VY)); ChOut(0, ^ );
];
CrLf(0);
];
]- 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
Categories:
- Draft Programming Tasks
- 11l
- ALGOL 68
- ALGOL W
- APL
- AppleScript
- Arturo
- AutoHotkey
- AWK
- BASIC
- Applesoft BASIC
- BASIC256
- Chipmunk Basic
- FreeBASIC
- GW-BASIC
- Minimal BASIC
- QBasic
- RapidQ
- Tiny BASIC
- True BASIC
- Yabasic
- BCPL
- BQN
- C
- CLU
- COBOL
- Excel
- Delphi
- SysUtils,StdCtrls
- F Sharp
- Factor
- Fermat
- Go
- Haskell
- J
- Jq
- Julia
- MiniZinc
- Modula-2
- Nim
- PARI/GP
- Pascal
- Perl
- Phix
- PILOT
- Python
- Raku
- REXX
- Ring
- Ruby
- V (Vlang)
- Wren
- Wren-math
- Wren-fmt
- XPL0