给定2D字符串作为输入，可以是带有换行符的字符串，也可以是行列表，输出列表(x, y)中所有哈希（#）的坐标。输入将仅包含哈希和空格。（和换行符，如果您选择将输入作为2D字符串）

如果没有哈希，则可以输出任何内容。

输出应该明确地确定哪些数字与哪些配对。

例：

##

应该输出：

(0,0), (1,0)

假定从左上方开始基于0的索引。您可以从任何角度开始，使用基于0或1的索引，和/或y首先输出。（例如形式y,x）。

更多测试用例（同样，全部使用基于0的左上(x, y)索引）：

    #
#####
#

(4, 0), (0, 1), (1, 1), (2, 1), (3, 1), (4, 1), (0, 2)


# ###
### #

(0, 0), (2, 0), (3, 0), (4, 0), (0, 1), (1, 1), (2, 1), (4, 1)

请注意，这些测试用例全部按行列出，而不是按照路径列出。

您可以假设哈希将形成连续的轨迹，即# #永远不会成为输入。（可能无关紧要，但如果有人要对此进行正则表达式）

您还可以按任意顺序输出坐标，即垂直列，水平行或仅是未排序的列表。

滑动，2 +1 = 3字节

+1字节的p标志。码：

`#

说明：

所述p-flag返回以下的每次出现的位置：

`#      // The character '#'

在这里尝试！

污垢，5个字节

pa`\#

在线尝试！ 输出格式有点时髦，但是OP声明它是有效的。

说明

Grime是我的2D模式匹配语言。后面的部分`是图案，在这种情况下为1×1的正方形，其中包含- #字符。Grime将在输入网格中搜索匹配项，并默认打印找到的第一个网格。前面的部分`包含选项，在这种情况下，表示a应打印所有匹配项（）及其位置和大小（p）。

MATL，7 6 5字节

这是(1,1)在左上角使用基于1的索引。

oo&fh

说明：

o        % convert char to double 
 o       % remainder mod 2 ('#' == 35, ' '==32) makes spaces falsy
  &f     % apply `find` with 2d-output 
    h   % concatenate outputs to display x- and y-coordinates side by side

感谢@DJMcMayhem和@LuisMendo的每个-1个字节！

在线尝试！

Python，67字节

实际上，这只是我对类似主题的Stack Overflow答案的一招。

lambda a,e=enumerate:[[(i,j)for j,B in e(A)if'!'<B]for i,A in e(a)]

在线尝试！

循环浏览2D列表，记录哈希字符，然后返回结果。我们使用char > '!'而不是来保存一个字节char == '#'，因为输入将仅由哈希和空格组成，因此哈希（0x23）将是唯一大于感叹号（0x21）的字符。

JavaScript（ES6），70 67字节

s=>s.replace(/./g,(c,i)=>c>' '?[i%l,i/-l|0]+' ':'',l=~s.indexOf`
`)

输出以换行符和空格分隔的坐标列表，例如

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

使用奇怪的输出格式，您可以得到更短的输出：

s=>s.replace(/#/g,(c,i)=>[i%l,i/-l|0]+c,l=~s.indexOf`
`)

这个输出

    4,0#
0,1#1,1#2,1#3,1#4,1#
0,2#

对于第二个测试用例。仍然清楚哪些数字与哪些配对

J，12个字节

$#:'#'I.@:=,

在线尝试！

说明

$#:'#'I.@:=,  Input is y.
           ,  Flatten y
   '#'    =   and form bit vector of equality with #.
      I.@:    Compute positions of 1s
 #:           and convert each to base
$             shape of y.

果冻，8字节

n⁶T€,€"J

在线尝试！

给定一个二维字符数组（=字符串列表）：

            Implicit input (example):
               [[' ', ' ', ' ', ' ', '#']
               ,['#', '#', '#', '#', '#']
               ,['#', ' ', ' ', ' ', ' ']]
n⁶          Not-equal to space (⁶).
               [[0, 0, 0, 0, 1]
               ,[1, 1, 1, 1, 1]
               ,[1, 0, 0, 0, 0]]
  T€        Indices of 1s in each row
               [[5], [1,2,3,4,5], [1]]
    ,€"J    Pair each, vectorizing, with y-indices
               [[[5,1]], [[1,2],[2,2],[3,2],[4,2],[5,2]], [[1,3]]]

Dyalog APL 16.0,5个字符= 9 个字节或6个字符= 8 个字节

从左上方给出（y，x）对的列表。

⍸⎕='#'

⍸ 哪里

⎕ 输入

= 等于

'#' 这个角色*

*通过替换'#'为⍕#（格式化根名称空间）可以节省一个字节的字符。

在线尝试APL！注意，由于TryAPL运行版本14.0 ，⍸因此已对此进行了仿真i 。

JavaScript（Firefox 30-57），61个字节

s=>[for(c of(x=0,y=1,s))if(c<' '?(y++,x=0):(x++,c>' '))[y,x]]

返回从1开始的坐标。之间轻松地转换[y, x]和[x, y]排序。取消高尔夫：

function coords(s) {
    var x = 0;
    var y = 1;
    for (Var c of s) {
        if (c == "\n") {
            y++;
            x=0;
        } else {
            x++;
        }
        if (c == "#") {
            console.log(y, x);
        }
    }
}

Vim，37个字节

:%s/#/\=line('.').','.col('.').' '/g<cr>

由于V主要是向后兼容的，所以您可以 在线尝试！

一个简单的正则表达式解决方案，它将每个“＃”替换为在其中找到的位置（基于索引的索引）。写这篇文章时，我有点担心，将第一个替换为一行后，位置会发生变化，但这似乎不是问题。TBH我很高兴这个解决方案最终变得如此简单。

不幸的是，vimscript非常冗长，因此大多数字节来自分隔结果，因此仍然清晰可见。否则，我们可以做

:%s/#/\=line('.').col('.')/g

但这会产生很难解释的输出。此外，它只能在网格始终为9x9或更小的情况下工作。

这是一个非常有趣的解决方案，因为它在其表示的哈希值位置显示了每对坐标。例如，输入

# ###
### #

输出

1,1  1,3 1,4 1,5 
2,1 2,2 2,3  2,5 

当然，如果使用的是V，则可以删除尾随的换行符并压缩正则表达式。那可能就是

Í#/½line('.').','.col('.').' '/g

（32字节）

但是由于这是完全相同的方法，但仍然很麻烦，因此使用高尔夫语言似乎并不值得。

Haskell，53个字节

concat.zipWith(\y l->[(x,y)|(x,'#')<-zip[0..]l])[0..]

输入被视为字符串列表。输出是(x,y)成对列表（索引为0），例如

*Main> concat.zipWith(\y l->[(x,y)|(x,'#')<-zip[0..]l])[0..] $ ["# ###","### #"]
[(0,0),(2,0),(3,0),(4,0),(0,1),(1,1),(2,1),(4,1)]

Lua，141个字节

w=io.read()x=w:sub(1,w:find("\n")-1):len()_,c=w:gsub("\n","")for i=0,x do for j=0,c+1 do if w:sub(c*x+i,c*x+i)=="#"then print(i,j)end end end

现在是凌晨2:30，我在床上躺在手机上。我为什么要这样做？

Mathematica，12个字节

Position@"#"

的运算符形式Position。假定一个二维字符数组。1索引从左上角开始。以形式输出坐标列表{row,column}。

PHP，69字节

for(;$a=$argv[++$i];)for($j=0;""<$c=$a[$j++];)echo$c>" "?"$j $i,":"";

从左上角开始使用基于1的索引。
使用方式如下：

php -r 'for(;$a=$argv[++$i];)for($j=0;""<$c=$a[$j++];)if($c>" ")echo"$j $i,";' '    #' '#####' '#    '

将输出：

5 1,1 2,2 2,3 2,4 2,5 2,1 3,

C，113字节

i,j,k,l;f(char**p){i=strlen(*p);l=strlen(p);for(j=0;j<l;j++)for(k=0;k<i;k++)if(p[j][k]==35)printf("%d,%d ",k,j);}

测试用例的输出：

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

在线尝试！

RBX.Lua，131个字节

必须假设输入有效（Z是平轴，空白是White图块，哈希可以是任何其他颜色，左上角的部分位于0, 0, 0），并且所有部分都是同一模型的一部分，M否则该模型为空。

for k,v in pairs(workspace.M:GetChildren())do if v.BrickColor~=BrickColor.new("White")then print(v.Position.X,-v.Position.Y)end end

样本输入/输出：

Perl 6，25个字节（22个字符）

{^∞ZX@_».indices("#")}

将输入作为行列表。
每行输出一个列表，每个列表包含坐标的（y，x）元组。
在线尝试！

怎么运行的

{                    }  # A lambda.
{    @_»             }  # For each input line:
        .indices("#")   #    get x-coordinates.  (4) (0 1 2 3 4) (0)
 ^∞                     # Range from 0 to Inf.    0   1           2 ...
   Z                    # Zip with:              (0 (4)) (1 (0 1 2 3 4)) (2 (0))
    X                   #    Cartesian product.  ((0 4)) ((1 0) (1 1) (1 2) (1 3) (1 4)) ((2 0))

Groovy，80 68字节

{y=0;it.each{it.eachWithIndex{x,i->print(x=='#'?"($i,$y)":"")};y++}}

输入示例：

[#   #,#   #,#####]

示例输出：

(0,0)(4,0)(0,1)(4,1)(0,2)(1,2)(2,2)(3,2)(4,2)

红宝石，24 +1 = 25字节

+1字节的-n标志。坐标是从1开始的，每行一个数字。

gsub(/#/){p$`.size+1,$.}

在线尝试！

C，80字节

x,y;f(char*s){for(x=y=0;*s;printf(*s-35?"":"%d,%d ",x,y),*s++==10?++y,x=0:++x);}

需要输入为以换行符分隔的char数组，将输出打印到屏幕上。

脱胶和用法：

x,y;

f(char*s){
 for(
  x = y = 0;             //init coordinates
  *s;                //iterate until end
  printf(*s-35 ? "" : "%d,%d ", x, y),     //print coordinates or empty string
  *s++==10 ? ++y, x=0 : ++x              //advance to the right or the next line
 );
}


main(){
 f("    #\n#####\n#    ");
 puts("");
 f("# ###\n### #");
}