Đưa ra một chuỗi 2D làm đầu vào, dưới dạng một chuỗi có dòng mới hoặc danh sách các dòng, xuất ra tọa độ (x, y)của tất cả các giá trị băm ( #) trong danh sách. Đầu vào sẽ chỉ chứa băm và dấu cách. (và dòng mới, nếu bạn chọn lấy đầu vào dưới dạng chuỗi 2D)

Nếu không có băm, bạn có thể xuất bất cứ thứ gì.

Đầu ra phải rõ ràng về việc các số được ghép với số nào.

Thí dụ:

##

Nên đầu ra:

(0,0), (1,0)

Giả sử lập chỉ mục dựa trên 0, bắt đầu từ trên cùng bên trái. Bạn có thể bắt đầu từ bất kỳ góc nào, sử dụng lập chỉ mục dựa trên 0 hoặc 1 và / hoặc đầu ra ytrước. (ví dụ dưới dạng y,x).

Nhiều trường hợp thử nghiệm (một lần nữa, tất cả đều sử dụng (x, y)lập chỉ mục trên cùng bên trái dựa trên 0 ):

    #
#####
#

(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)

Lưu ý rằng tất cả các trường hợp kiểm tra liệt kê theo hàng, không theo đường dẫn.

Bạn có thể giả sử băm sẽ tạo thành một dấu vết liên tục, tức là # #sẽ không bao giờ là đầu vào. (có lẽ sẽ không thành vấn đề, nhưng trong trường hợp ai đó muốn regex điều này)

Bạn cũng có thể xuất tọa độ theo bất kỳ thứ tự nào bạn muốn, tức là cột dọc, hàng ngang hoặc chỉ là một danh sách chưa được sắp xếp.

Trượt , 2 + 1 = 3 byte

+1 byte cho pcờ. Mã số:

`#

Giải trình:

Các plợi nhuận -flag vị trí của mỗi sự xuất hiện của những điều sau đây:

`#      // The character '#'

Hãy thử nó ở đây!

Vết bẩn , 5 byte

pa`\#

Hãy thử trực tuyến! Định dạng đầu ra hơi thú vị, nhưng OP đã tuyên bố rằng nó hợp lệ.

Giải trình

Grime là ngôn ngữ phù hợp với mô hình 2D của tôi. Phần sau `là mẫu , trong trường hợp này là hình vuông 1 × 1 chứa a #-character. Grime sẽ tìm kiếm lưới đầu vào cho một trận đấu và in cái đầu tiên mà nó tìm thấy theo mặc định. Phần trước `chứa các tùy chọn, trong trường hợp này biểu thị rằng tất cả các kết quả khớp ( a) phải được in, cùng với vị trí và kích thước của chúng ( p).

MATL , 7 6 5 byte

Điều này đang sử dụng lập chỉ mục dựa trên 1 (1,1)ở góc trên bên trái.

oo&fh

Giải trình:

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

Cảm ơn @DJMcMayhem và @LuisMendo cho mỗi byte -1!

Hãy thử trực tuyến!

Python , 67 byte

Đây thực sự chỉ là một câu trả lời trong câu trả lời Stack Overflow của tôi về một chủ đề tương tự.

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

Hãy thử trực tuyến!

Các vòng lặp thông qua danh sách 2D, ghi lại các ký tự băm và trả về kết quả. Chúng tôi lưu một byte bằng cách sử dụng char > '!'chứ không phải char == '#', bởi vì đầu vào sẽ chỉ bao gồm các giá trị băm và dấu cách, và do đó, băm ( 0x23) sẽ là các ký tự duy nhất lớn hơn dấu chấm than ( 0x21).

JavaScript (ES6), 70 67 byte

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

Xuất ra một danh sách tọa độ phân cách dòng và không gian, ví dụ

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

Bạn có thể rút ngắn hơn nhiều với định dạng đầu ra kỳ lạ:

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

Đầu ra này

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

cho trường hợp thử nghiệm thứ hai. Vẫn còn rõ những con số nào được ghép nối với ...

J , 12 byte

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

Hãy thử trực tuyến!

Giải trình

$#:'#'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.

Thạch , 8 byte

n⁶T€,€"J

Hãy thử trực tuyến!

Cho một mảng các ký tự 2D (= danh sách các chuỗi):

            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 ký tự = 9 byte hoặc 6 ký tự = 8 byte

Đưa ra danh sách các cặp (y, x) từ trên cùng bên trái.

⍸⎕='#'

⍸ Ở đâu

⎕ đầu vào

= bằng

'#' nhân vật này*

* Có thể lưu một ký tự với chi phí một byte bằng cách thay thế '#'bằng ⍕#(định dạng không gian tên gốc)

Dùng thử trực tuyến! Lưu ý rằng ⍸đã được mô phỏng với i vì TryAPL chạy phiên bản 14.0.

JavaScript (Firefox 30-57), 61 byte

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

Trả về tọa độ 1 dựa trên. Dễ dàng chuyển đổi giữa [y, x]và [x, y]đặt hàng. Ung dung:

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 byte

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

Vì V chủ yếu tương thích ngược, bạn có thể dùng thử trực tuyến!

Một giải pháp regex đơn giản, trong đó giải pháp thay thế từng '#' bằng vị trí được tìm thấy (lập chỉ mục một lần). Tôi đã có một chút lo lắng khi viết điều này rằng vị trí sẽ thay đổi sau khi thay thế vị trí đầu tiên trên một dòng, nhưng dường như đó không phải là một vấn đề. TBH Tôi bị sốc một cách thú vị bởi giải pháp đơn giản này đã kết thúc như thế nào.

Thật không may, vimscript rất dài dòng, vì vậy hầu hết các byte đến từ việc tách các kết quả sao cho vẫn còn rõ ràng. Nếu không, chúng ta có thể làm

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

Nhưng điều này tạo ra đầu ra khá khó để giải thích. Ngoài ra, nó sẽ chỉ hoạt động khi lưới luôn là 9x9 hoặc nhỏ hơn.

Đây là một giải pháp thực sự thú vị vì nó hiển thị từng cặp tọa độ tại vị trí của hàm băm mà nó đại diện. Ví dụ: đầu vào

# ###
### #

đầu ra

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

Tất nhiên, nếu chúng ta đang sử dụng V, chúng ta có thể xóa dòng mới và nén regex. Sau đó, nó có thể chỉ đơn giản là

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

(32 byte)

Nhưng vì đây là cách tiếp cận chính xác và vẫn còn dài dòng, nên dường như không đáng để sử dụng ngôn ngữ chơi gôn.

Haskell, 53 byte

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

Đầu vào được lấy dưới dạng danh sách các chuỗi. Đầu ra là danh sách các (x,y)cặp (0 được lập chỉ mục), vd

*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 byte

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

Bây giờ là 2:30 sáng, tôi đang ở trên giường, trên điện thoại của tôi. Tại sao tôi làm điều này?

Toán học, 12 byte

Position@"#"

Hình thức khai thác của Position. Giả sử một mảng 2D của các ký tự. 1 chỉ mục bắt đầu từ mục trên cùng bên trái. Xuất ra một danh sách các tọa độ trong mẫu {row,column}.

PHP, 69 byte

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

Sử dụng lập chỉ mục dựa trên 1 bắt đầu từ trên cùng bên trái.
Sử dụng như:

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

Sẽ xuất:

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

C, 113 byte

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);}

Đầu ra từ các trường hợp thử nghiệm:

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 

Hãy thử trực tuyến!

RBX.Lua, 131 byte

Phải giả sử đầu vào là hợp lệ (Z là trục phẳng, khoảng trắng là Whitegạch, băm có thể là bất kỳ màu nào khác, phần trên cùng bên trái được đặt tại 0, 0, 0) và tất cả các phần là một phần của cùng một mô hình Mvà mô hình thì trống.

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

Mẫu đầu vào / đầu ra:

Perl 6 , 25 byte (22 ký tự)

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

Lấy đầu vào là một danh sách các dòng.
Xuất ra một danh sách trên mỗi dòng, mỗi dòng chứa (y, x) bộ cho các tọa độ.
Hãy thử trực tuyến!

Làm thế nào nó hoạt động

{                    }  # 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 byte

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

Ví dụ đầu vào:

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

Kết quả ví dụ:

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

Ruby , 24 + 1 = 25 byte

+1 byte cho -ncờ. Tọa độ là 1 dựa trên, một số trên mỗi dòng.

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

Hãy thử trực tuyến!

C, 80 byte

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

Yêu cầu đầu vào là mảng char được phân tách bằng dòng mới, in đầu ra ra màn hình.

Ungolfed & cách sử dụng:

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### #");
}