找到细胞的邻居

20

...或环形摩尔社区

由于正整数h，w和一个非负整数i，返回所有围绕着指数i。

您将假定一个矩阵，该矩阵由元素的h行w组成，从左上角的最低编号到右下角的最高编号，并以任何合理的格式返回将要使用的索引列表包围索引i。这个矩阵是一个圆环（环绕每个边缘的无限图）。

例如，输入h=4和w=4，将得出矩阵：

 0  1  2  3 
 4  5  6  7
 8  9 10 11
12 13 14 15

但更具体地说：

15 12 13 14 15 12
 3  0  1  2  3  0
 7  4  5  6  7  4
11  8  9 10 11  8
15 12 13 14 15 12
 3  0  1  2  3  0

因此如果i为was 0，则需要返回15, 12, 13, 3, 1, 7, 4, 5（从0开始）。

例子

从0开始：

h   w   i       Expected result

4   4   5       0, 1, 2, 4, 6, 8, 9, 10
4   4   0       15, 12, 13, 3, 1, 7, 4, 5
4   5   1       15, 16, 17, 0, 2, 5, 6, 7
1   3   2       1, 2, 0, 1, 0, 1, 2, 0
1   1   0       0, 0, 0, 0, 0, 0, 0, 0

基于1：

h   w   i       Expected result

4   4   6       1, 2, 3, 5, 7, 9, 10, 11
4   4   1       16, 13, 14, 4, 2, 8, 5, 6
4   5   2       16, 17, 18, 1, 3, 6, 7, 8
1   3   3       2, 3, 1, 2, 1, 2, 3, 1
1   1   1       1, 1, 1, 1, 1, 1, 1, 1

规则

  • 您的答案可能是0或1索引，请选择。
  • 您可以假设i < h * w（或i <= h * w针对1个索引的答案）。
  • 您可以假设i >= 0（或i > 0针对1个索引的答案）。
  • 返回值的顺序并不重要，只要仅包含八个期望值即可。
  • 禁止出现标准漏洞。
  • 这是代码高尔夫球，所以每种语言的最短答案就是成功！

感谢@Conor O'Brien提供更多技术性冠冕堂皇的东西，以及@ngm提供更多测试用例！

code-golf  matrix 
— 唐·黑斯廷斯
source
3
我们可以返回一个3×3的邻居矩阵吗？
— 亚当
@Adám如果可能的话，我希望列表不包含中心单元格。但是，感谢您已经有了答案。过滤出来很容易吗？
— Dom Hastings
顺序重要吗？
— 罗伯特·弗雷泽
@RobertFraser顺序并不重要。我将其添加到规则中。
— Dom Hastings
@DomHastings我将此评论解释为：不允许返回3 x 3矩阵或包含中心单元格？
— JungHwan Min

Answers:

8

JavaScript（ES6），75个字节

@KevinCruijssen节省了2个字节

期望从0开始的索引。

(h,w,i)=>[...'12221000'].map((k,j,a)=>(i+w+~-k)%w+~~(i/w+h+~-a[j+2&7])%h*w)

在线尝试！

周围的索引按以下顺序返回：

5436⋅2701个

怎么样？

每个周围单元在（x + d x ，y + d y ）处的索引由下式给出：一世dX，dÿ（X+dX，ÿ+dÿ）

一世dX，dÿ=（（X+dX）模w）+w（（ÿ+dÿ）模H）=（（ñ+dX）模w）+w（（⌊ñw⌋+dÿ）模H）

其中是目标单元格的索引。ñ=wÿ+X

我们遍历列表并减去得到的值，得出：1 d X[1,2,2,2,1,0,0,0]1dx

[0,1,1,1,0,−1,−1,−1]

对于的对应值，我们使用移了2个位置的相同列表，得出：dy

[1,1,0,−1,−1,−1,0,1]
— Arnauld
source
w*(~~(i/w+h+~-a[j+2&7])%h)~~(a[j+2&7]-1+i/w+h)%h*w通过消除一对括号来节省2个字节。
— 凯文·克鲁伊森
@KevinCruijssen不错。谢谢！
— Arnauld
6

APL（Dyalog Classic），27字节

{(⍺⊥⍺|(⍺⊤⍵)-⊢)¨1-1↓4⌽,⍳3 3}

在线尝试！

{ }是带有参数⍺（维h w）和⍵（索引i）的函数

⍳3 3都是2位数的三进制数的矩阵：0 0，0 1，...，2 2

, 将矩阵列为向量

1↓4⌽1 1通过向左旋转4（4⌽）并放下一个（1↓）来删除中心元素

1- 从1减去，得到所有8个邻居偏移量

( )¨ 将括号中的函数列应用于每个偏移量

⍺⊤⍵是- 矩阵中的坐标的基本⍺编码⍵⍵

(⍺⊤⍵)-⊢ 减去当前偏移量，得到邻居的坐标

⍺|修改为a环绕坐标并停留在矩阵内

⍺⊥ 从基础解码 ⍺

— ngn
source
5

APL（Dyalog Unicode），40 字节SBCS

匿名中缀函数。注意到h w左参数，i作为右边的参数。

{1↓4⌽,3 3↑,⍨⍣2⍪⍨⍣2⊃⊖∘⍉/(¯1+⍺⊤⍵),⊂⍺⍴⍳×/⍺}

在线尝试！

{…… } “ dfn”；⍺是左参数（尺寸），⍵是右参数（索引）。

 ×/⍺ 尺寸的乘积（减乘）

 ⍳ 众多指标中的第一个

 ⍺⍴ 采用的尺寸[R ESHAPE那

 ⊂ 将其封闭（将其视为单个元素）

 (… ), 附加以下内容：

  ⍺⊤⍵ 用混合基数对索引进行编码h w（这给了我们索引的坐标）

  ¯1+ 给那些坐标加上负数

 ⊖∘⍉/ 通过旋转转置减少，
  它等于y⊖⍉x⊖⍉…相当于y⊖x⌽……向左旋转i与向右偏移的步长（少一个），向上旋转与向左i偏移的步长（少一个），从而导致我们希望位于左上角的3×3矩阵

 ⊃ 披露（因为减少量通过封装将向量缩小为标量）

 ⍪⍨⍣2 在自身之上两次堆叠（对于单行矩阵，我们只需要三次）

 ,⍨⍣2 两次附加自身（对于单列矩阵，我们只需要三次）

 3 3↑ 取前三列的前三行

如果可以接受三乘三的矩阵，则可以省略以下两个步骤：

 , 拉平（拉平）

 4⌽ 向左旋转四步（将中心元素移到前面）

 1↓ 删除第一个元素

— 亚当
source
@Adám解决上述问题，并将其缩短：{,(⍺⊥⍺|(⍺⊤⍵)-⊢)¨1-⍳3 3}，我不确定您是否还应删除中间元素：{4⌽1↓4⌽...}
— ngn
@ngn嗯，这很原始。你张贴！
— 亚当
@亚当OK
— NGN
我认为输出不应该包含中心元素。
— JungHwan Min
1
最后一个测试用例仍然具有8个元素。我认为预期的输出结果是在相对位置打印邻居[-1, -1], [-1, 0], [-1, 1], [0, -1], [0, 1], [1, -1], [1, 0], [1, 1]
— JungHwan Min
4

R，125111108字节

function(x,i,m=array(1:prod(x),x),n=rbind(m,m,m),o=cbind(n,n,n),p=which(m==i,T)+x-1)o[p[1]+0:2,p[2]+0:2][-5]

在线尝试！

@JayCe和@Mark打高尔夫球的14和8字节。

输入是[w, h], i因为R首先填充数组列。

制作数组，然后将其按行和按列“三倍”。然后找到i原始数组并找到它的邻域。输出不带i。

— ngm
source
1
您可以保存14个字节。我不知道那有一个arr.ind的论点，今天学到了一些东西！
— JayCe
通过替换为seq()1:
— Mark
3

PHP，165字节

这是“从0开始”。PHP必须有更好的解决方案，但这是一个起点！

<?list(,$h,$w,$i)=$argv;for($r=-2;$r++<1;)for($c=-2;$c++<1;)$r||$c?print(($k=(int)($i/$w)+$r)<0?$h-1:($k>=$h?0:$k))*$w+(($l=$i%$w+$c)<0?$w-1:($l>=$w?0:$l))%$w.' ':0;

要运行它：

php -n <filename> <h> <w> <i>

例：

php -n cell_neighbours.php 4 5 1

或在线尝试！

— 晚2
source
3

K（ngn / k），27 24字节

{x/x!''(x\y)-1-3\(!9)^4}

在线尝试！

{ }是带有参数x（维h w）和y（索引i）的函数

(!9)^4是0 1 2 3 4 5 6 7 8没有4

3\ 三元编码： (0 0;0 1;0 2;1 0;1 2;2 0;2 1;2 2)

1-从中减去1，得到邻居偏移量：(1 1;1 0;1 -1;0 1;0 -1;-1 1;-1 0;-1 -1)

x\y是- 矩阵中的坐标的基本x编码yy

- 减去每个偏移量，得到8对邻居坐标

x!''x每个模块都是mod- 将坐标环绕以保留在矩阵内

x/从基解码x-将坐标对转换为单个整数

— ngn
source
出于好奇，您的K变体是否有“反向自变量”副词，例如J的副词~？
— 科纳·奥布莱恩
1
@ ConorO'Brien我所认识的ks（Kx的K，Kona，ok和我的）都不具备它，这对打高尔夫球是不幸的。内置副词只有6个：/ \'/：\：'：并且没有用户定义的副词机制。
— ngn
当然，我可以添加自拍副词，但是打高尔夫球本身并不是ngn / k的目的，它只是积累测试用例和经验的一种手段。
— ngn
这还算公平。当然，您可以将其视为该语言的潜在缺点。我已经使用PPCG来帮助开发Attache，并且意识到Attache缺少一些我本来不会包含的非常有用的功能。我不使用K，但是也许还有其他用例可以保证使用这种副词？
— 科纳·奥布莱恩
@ ConorO'Brien我⍨在APL中很熟悉，就像~在J中一样，并且我对它的效用深信不疑，但是，您知道，k限于可打印的ASCII，并且几乎没有二字，因此，一个新的副词意味着牺牲了一些其他有用的原语以及实现之间的更多不兼容性。我看不出有什么办法可以解决这个问题
— 。– ngn
2

MATL，24字节

*:2Geti=&fh3Y6&fh2-+!Z{)

输入是h，w，i。输出是带有数字的行向量或列向量。

输入i和输出基于1。

在线尝试！或验证所有测试用例。

说明

*     % Take two inputs implicitly. Multiply
      % STACK: 16
:     % Range
      % STACK: [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16]
2G    % Push second input again
      % STACK: [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16], 4
e     % Reshape with that number of rows, in column-major order
      % STACK: [1 5 9 13; 2 6 10 14; 3 7 11 15; 4 8 12 16]
t     % Duplicate
      % STACK: [1 5 9 13; 2 6 10 14; 3 7 11 15; 4 8 12 16],
      %        [1 5 9 13; 2 6 10 14; 3 7 11 15; 4 8 12 16]
i=    % Take third input and compare, element-wise
      % STACK: [1 5 9 13; 2 6 10 14; 3 7 11 15; 4 8 12 16],
      %        [0 0 0 0; 0 1 0 0; 0 0 0 0; 0 0 0 0]
&f    % Row and column indices of nonzeros (1-based)
      % STACK: [1 5 9 13; 2 6 10 14; 3 7 11 15; 4 8 12 16], 2, 2,
h     % Concatenate horizontally
      % STACK: [1 5 9 13; 2 6 10 14; 3 7 11 15; 4 8 12 16], [2 2]
3Y6   % Push Moore mask
      % STACK: [1 5 9 13; 2 6 10 14; 3 7 11 15; 4 8 12 16], [2 2],
      %        [1 1 1; 1 0 1; 1 1 1]
&f    % Row and column indices of nonzeros (1-based)
      % STACK: [1 5 9 13; 2 6 10 14; 3 7 11 15; 4 8 12 16], [2 2],
      %        [1; 2; 3; 1; 3; 1; 2; 3], [1; 1; 1; 2; 2; 3; 3; 3] 
h     % Concatenate horizontally
      % STACK: [1 5 9 13; 2 6 10 14; 3 7 11 15; 4 8 12 16], [2 2],
      %        [1 1; 2 1; 3 1; 1 2; 3 2; 1 3; 2 3; 3 3] 
2-    % Subtract 2, element-wise
      % STACK: [1 5 9 13; 2 6 10 14; 3 7 11 15; 4 8 12 16], [2 2],
      %        [-1 -1; 0 -1; 1 -1; -1 0; -1 0; -1 1; 0 1; 1 1] 
+     % Add, element-wise with broadcast
      % STACK: [1 5 9 13; 2 6 10 14; 3 7 11 15; 4 8 12 16],
      %        [1 1; 2 1; 3 1; 1 2; 3 2; 1 3; 2 3; 3 3]
!     % Transpose
      % STACK: [1 5 9 13; 2 6 10 14; 3 7 11 15; 4 8 12 16],
      %        [1 2 3 1 3 1 2 3; 1 1 1 2 2 3 3 3]
Z{    % Convert into a cell array of rows
      % STACK: [1 5 9 13; 2 6 10 14; 3 7 11 15; 4 8 12 16],
      %        {[1 2 3 1 3 1 2 3], [1 1 1 2 2 3 3 3]}
)     % Index. A cell array acts as an element-wise (linear-like) index
      % STACK: [1 2 3 5 7 9 10 11]
— 路易斯·门多
source
2

批次，105个字节

@for /l %%c in (0,1,8)do @if %%c neq 4 cmd/cset/a(%3/%2+%1+%%c/3-1)%%%1*%2+(%3%%%2+%2+%%c%%3-1)%%%2&echo.

0索引。通过窃取@ChasBrown的3模技巧，节省了23个字节。

— 尼尔
source
1

干净，85 83字节

import StdEnv
r=(rem)
$h w i=tl[r(n+i/w)h*w+r(r(m+i)w)w\\n<-[0,1,h-1],m<-[0,1,w-1]]

在线尝试！

黄柏i作为坐标(0 <= p < h, 0 <= q < w)，并且生成相邻元件，其中的值是的值p'w + q'。

— 巨大
source
1

果冻，20 字节

PRs©Ṫ{œi+€Ø-Ż¤ŒpḊœị®

双向链接接受左侧的尺寸列表[h,w]，而右侧的单元格为整数i，这将产生一个邻域列表。

注意：顺序与OP中允许的示例中的顺序不同

在线尝试！

怎么样？

PRs©Ṫ{œi+€Ø-Ż¤ŒpḊœị® - Link: [h,w], i
P                    - product -> h*w
 R                   - range -> [1,2,3,...,h*w]
    Ṫ{               - tail of left -> w
  s                  - split into chunks -> [[1,2,3,...w],[w+1,...,2*w],[(h-1)*w+1,...,h*w]]
   ©                 - ...and copy that result to the register
      œi             - multi-dimensional index of (i) in that list of lists, say [r,c]
             ¤       - nilad followed by link(s) as a nilad:
          Ø-         -   literal list -> [-1,1]
            Ż        -   prepend a zero -> [0,-1,1]
        +€           - addition (vectorises) for €ach -> [[r,r-1,r+1],[c,c-1,c+1]]
              Œp     - Cartesian product -> [[r,c],[r,c-1],[r,c+1],[r-1,c],[r-1,c-1],[r-1,c+1],[r+1,c],[r+1,c-1],[r+1,c+1]]
                Ḋ    - dequeue -> [[r,c-1],[r,c+1],[r-1,c],[r-1,c-1],[r-1,c+1],[r+1,c],[r+1,c-1],[r+1,c+1]]
                   ® - recall (the table) from the register
                 œị  - multi-dimensional index into (1-indexed & modular)
— 乔纳森·艾伦
source
1

附件，66字节

{a.=[]Moore[Integers@@__2,{Push[a,_]},cycle->1]Flat[a@_][0:3'5:8]}

在线尝试！

我仍然需要实现Moores和NMoore，但是我仍然具有将Moore其用作迭代功能的功能。本质上，Integers@@__2创建第一个整数的形状__2（最后两个参数）的Prod[__2]整数数组。这给了我们目标数组。然后，在每个Moore邻域大小（隐式参数）上Moore迭代该函数，并选择循环每个元素（）。这会将每个邻域添加到数组。然后，将的第th个成员展平，也就是以Moore邻域为中心（第一个参数）。从此展平的数组中获取除中心以外的所有成员。{Push[a,_]}1cycle->1aFlat[a@_]_a_[0:3'5:8]

通过对语言进行更新，该解决方案将类似于以下内容（49字节）：

{Flat[NMoore[Integers@@__2,_,cycle->1]][0:3'5:8]}
— 科纳·奥布莱恩
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.