Biorąc pod uwagę ciąg 2D jako dane wejściowe, albo jako ciąg z nowymi liniami, albo z listą linii, wypisz współrzędne (x, y)wszystkich skrótów ( #) na liście. Dane wejściowe będą zawierać tylko skróty i spacje. (i znaki nowej linii, jeśli wybierzesz opcję wprowadzania jako ciąg 2D)

Jeśli nie ma skrótów, możesz wydać wszystko.

Dane wyjściowe powinny być jednoznaczne, z którymi liczbami są powiązane.

Przykład:

##

Powinien generować:

(0,0), (1,0)

To zakłada indeksowanie oparte na 0, zaczynając od lewego górnego rogu. Możesz zacząć od dowolnego rogu, użyć indeksowania opartego na 0 lub 1 i / lub wyjść y. (np. w formie y,x).

Więcej przypadków testowych (znowu wszystkie wykorzystujące (x, y)indeksowanie w lewym górnym rogu na podstawie 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)

Zauważ, że te przypadki testowe wszystkie są wyświetlane według wierszy, a nie według ścieżki.

Możesz założyć, że skróty utworzą ciągły ślad, tj # # Nigdy nie będą wejściowe. (prawdopodobnie nie będzie to miało znaczenia, ale na wypadek, gdyby ktoś zechciał to regexować)

Możesz także wyprowadzać współrzędne w dowolnej kolejności, tj. Pionowe kolumny, poziome rzędy lub po prostu nieposortowana lista.

Poślizg , 2 + 1 = 3 bajty

+1 bajt dla pflagi. Kod:

`#

Wyjaśnienie:

W pFLAG Zwraca pozycję każdego wystąpienia z następujących powodów:

`#      // The character '#'

Wypróbuj tutaj!

Brud , 5 bajtów

pa`\#

Wypróbuj online! Format wyjściowy jest nieco funky, ale OP stwierdził, że jest poprawny.

Wyjaśnienie

Grime to mój język dopasowywania wzorów 2D. Część po `jest wzorem , w tym przypadku kwadratem 1 × 1 zawierającym #znak. Grime przeszuka siatkę wejściową pod kątem dopasowania i wydrukuje pierwszą, którą znajdzie domyślnie. Poprzednia część `zawiera opcje, w tym przypadku oznaczające, że wszystkie dopasowania ( a) powinny zostać wydrukowane, wraz z ich pozycjami i rozmiarami ( p).

MATL , 7 6 5 bajtów

Jest to oparte na indeksowaniu 1 (1,1)w lewym górnym rogu.

oo&fh

Wyjaśnienie:

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

Dzięki @DJMcMayhem i @LuisMendo za każde -1 bajt!

Wypróbuj online!

Pyton , 67 bajtów

To właściwie tylko golf mojej odpowiedzi Stack Overflow na podobny temat.

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

Wypróbuj online!

Pętle przechodzą przez listę 2D, rejestrując znaki skrótu i ​​zwracając wynik. Zapisujemy bajt za pomocą char > '!'zamiast char == '#', ponieważ dane wejściowe będą składały się wyłącznie z skrótów i spacji, a więc hashes ( 0x23) będą jedynymi znakami większymi niż wykrzykniki ( 0x21).

JavaScript (ES6), 70 67 bajtów

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

Tworzy listę współrzędnych oddzielonych znakiem nowej linii i spacji, np

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

Możesz uzyskać znacznie krótszy z dziwnym formatem wyjściowym:

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

To wychodzi

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

dla drugiego przypadku testowego. Nadal jest jasne, które numery są sparowane z którymi ...

J , 12 bajtów

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

Wypróbuj online!

Wyjaśnienie

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

Galaretka , 8 bajtów

n⁶T€,€"J

Wypróbuj online!

Biorąc pod uwagę tablicę znaków 2D (= listę ciągów znaków):

            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 znaków = 9 bajtów lub 6 znaków = 8 bajtów

Podaje listę par (y, x) od lewego górnego rogu.

⍸⎕='#'

⍸ gdzie

⎕ wkład

= równa się

'#' ta postać*

* Można zapisać znak kosztem jednego bajtu, zastępując '#'go ⍕#(sformatuj główną przestrzeń nazw)

Wypróbuj APL online! Zauważ, że ⍸został emulowany, i ponieważ TryAPL działa w wersji 14.0.

JavaScript (Firefox 30-57), 61 bajtów

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

Zwraca współrzędne oparte na 1. Łatwe przełączanie [y, x]i [x, y]zamawianie. Nie golfowany:

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 bajtów

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

Ponieważ V jest w większości kompatybilny wstecz, możesz wypróbować online!

Proste rozwiązanie wyrażenia regularnego, w którym zamienia każdy „#” na lokalizację, w której został znaleziony (indeksowanie oparte na jednym). Trochę się martwiłem, pisząc to, że lokalizacja zmieni się po zastąpieniu pierwszego w linii, ale to nie wydaje się problemem. TBH Jestem mile zaskoczony, jak proste stało się to rozwiązanie.

Niestety, vimscript jest bardzo szczegółowy, więc większość bajtów pochodzi z rozdzielenia wyników, dzięki czemu jest nadal czytelna. W przeciwnym razie moglibyśmy zrobić

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

Ale tworzy to wynik, który jest dość trudny do interpretacji. Dodatkowo zadziała tylko wtedy, gdy siatka jest zawsze 9 x 9 lub mniejsza.

To naprawdę fajne rozwiązanie, ponieważ pokazuje każdą parę współrzędnych w lokalizacji reprezentowanego przez siebie hasha. Na przykład dane wejściowe

# ###
### #

wyjścia

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

Oczywiście, gdybyśmy używali V, moglibyśmy usunąć końcowy znak nowej linii i skompresować wyrażenie regularne. To może po prostu być

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

(32 bajty)

Ale ponieważ jest to dokładnie to samo podejście i wciąż bolesnie gadatliwe, nie warto używać języka golfowego.

Haskell, 53 bajty

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

Dane wejściowe są traktowane jako lista ciągów. Dane wyjściowe to lista (x,y)par (indeksowanych 0), np

*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 bajtów

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

Jest 02:30, leżę w łóżku na telefonie. Dlaczego to robię?

Mathematica, 12 bajtów

Position@"#"

Formularz operatora Position. Zakłada tablicę znaków 2D. 1-indeksowany, zaczynając od lewego górnego wpisu. Wyświetla listę współrzędnych w formularzu {row,column}.

PHP, 69 bajtów

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

Używa indeksowania opartego na 1, zaczynając od lewego górnego rogu.
Użyj jak:

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

Wyjdzie:

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

C, 113 bajtów

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

Dane wyjściowe z przypadków testowych:

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 

Wypróbuj online!

RBX.Lua, 131 bajtów

Musi zakładać, że dane wejściowe są prawidłowe (Z to płaska oś, białe spacje to Whitekafelki, skróty mogą mieć dowolny inny kolor, górna lewa część znajduje się w 0, 0, 0) i wszystkie części są częścią tego samego modelu M, a model jest inaczej pusty.

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

Przykładowe wejście / wyjście:

Perl 6 , 25 bajtów (22 znaków)

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

Pobiera dane wejściowe jako listę linii.
Wyprowadza jedną listę na linię, każda zawierająca krotki (y, x) dla współrzędnych.
Wypróbuj online!

Jak to działa

{                    }  # 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 bajtów

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

Przykładowe dane wejściowe:

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

Przykładowe dane wyjściowe:

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

Rubin , 24 + 1 = 25 bajtów

+1 bajt dla -nflagi. Współrzędne są oparte na 1, jedna liczba na linię.

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

Wypróbuj online!

C, 80 bajtów

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

Wymaga wprowadzania w postaci znaku rozdzielanego znakami nowej linii, wypisuje dane wyjściowe na ekran.

Niegolfowane i użytkowanie:

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