Girdi olarak 2B dizesi verildiğinde, ya yeni satırlı bir dize ya da satır listesi olarak, listedeki (x, y)tüm karma değerlerin ( #) koordinatlarını çıkar . Girdi yalnızca kareler ve boşluklar içerecektir. (ve yeni satırlar, 2B dizge olarak girdi almayı seçerseniz)

Herhangi bir karma yoksa, her şeyi çıkarabilirsiniz.

Çıktı hangi sayılarla eşleştirildiği konusunda net olmalıdır.

Örnek:

##

Çıkması gerekir:

(0,0), (1,0)

Üst soldan başlayarak, 0 tabanlı dizinlemeyi varsayar. Herhangi bir köşeden başlayabilir, 0 veya 1 tabanlı indeksleme kullanabilir ve / veya yönce çıktı alabilirsiniz . (örneğin, formda y,x).

Daha fazla test durumu (yine, tümü 0 tabanlı üst sol (x, y)indeksleme kullanarak):

    #
#####
#

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

Bu sınamaların, yolu izleyerek değil, tüm listeleri satırlar halinde sunduğunu unutmayın.

Hash'lerin sürekli bir iz oluşturacağını, yani # #hiçbir zaman girdi olmayacağını varsayabilirsiniz . (Muhtemelen önemli değil, ama birisinin bunu telafi etmek istemesi durumunda)

Ayrıca koordinatları istediğiniz herhangi bir sırayla, örneğin dikey sütunlar, yatay satırlar veya yalnızca sıralanmamış bir liste halinde de yazdırabilirsiniz.

Kayma , 2 + 1 = 3 bayt

pBayrak için +1 bayt . Kod:

`#

Açıklama:

p-Flag döner aşağıdakilerden her bulunduğu pozisyonu:

`#      // The character '#'

Burada dene!

Kir , 5 bayt

pa`\#

Çevrimiçi deneyin! Çıkış formatı biraz korkak ama OP geçerli olduğunu belirtti.

açıklama

Grime benim 2B kalıp eşleştirme dilimim. Bundan sonraki `kısım, kalıptır , bu durumda, bir #karakter içeren 1 x 1 kare . Grime bir giriş için giriş ızgarasını arayacak ve varsayılan olarak bulduğu ilki yazdırır. Daha önceki `bölüm seçenekler içerir, bu durumda tüm eşleşmelerin ( a) konum ve boyutlarıyla ( p) birlikte yazdırılması gerektiğini belirtir .

MATL , 7 6 5 bayt

Bu, (1,1)sol üst köşede bulunan 1 tabanlı endekslemeyi kullanıyor .

oo&fh

Açıklama:

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

Her -1 bayt için @DJMcMayhem ve @LuisMendo teşekkürler!

Çevrimiçi deneyin!

Python , 67 bayt

Bu aslında benzer bir konuda Stack Overflow cevabım sadece bir golf .

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

Çevrimiçi deneyin!

2B liste boyunca dolaşır, karma karakterleri kaydeder ve sonucu döndürür. Girdi yalnızca karma ve boşluktan oluşacağı için, char > '!'yerine bir bayt kullanırız char == '#'; bu nedenle hash ( 0x23) ünlem işaretlerinden ( 0x21) daha büyük olan tek karakter olacaktır .

JavaScript (ES6), 70 67 bayt

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

Yeni ve boşlukla ayrılmış bir koordinat listesi yazdırır, örn.

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

Tuhaf bir çıktı formatıyla çok daha kısa sürede alabilirsiniz:

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

Bu çıkışlar

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

ikinci test durumu için. Hangi rakamların hangi rakamlarla eşleştiği hala belli ...

J , 12 bayt

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

Çevrimiçi deneyin!

açıklama

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

Jöle , 8 bayt

n⁶T€,€"J

Çevrimiçi deneyin!

2B karakter dizisi verilir (= dizelerin listesi):

            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 karakter = 9 bayt veya 6 karakter = 8 bayt

Üst soldan (y, x) çiftlerinin listesini verir.

⍸⎕='#'

⍸ nerede

⎕ giriş

= eşittir

'#' bu karakter*

* Bu değiştirerek bir bayt pahasına bir karakter kaydetmek mümkündür '#'ile ⍕#(kök ad biçimlendirmek)

TryAPL çevrimiçi! Not ⍸ile taklit edilmiş i TryAPL sürüm 14.0 çalıştığından.

JavaScript (Firefox 30-57), 61 bayt

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

1 tabanlı koordinatları döndürür. [y, x]Ve [x, y]sipariş arasında kolayca değiştirilebilir . Ungolfed:

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 bayt

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

V çoğunlukla geriye dönük uyumlu olduğundan, çevrimiçi olarak deneyebilirsiniz!

Basit bir regex çözümü, her '#' yerini bulunduğu konumla (tek tabanlı indeksleme) değiştirir. Bu yazarken, bir satırdaki ilk yeri değiştirdikten sonra konumun değişeceği konusunda biraz endişelendim ama bu bir sorun gibi görünmüyor. TBH Bu çözümün sonuçunun ne kadar basit olduğu beni çok şaşırttı.

Ne yazık ki, vimscript çok ayrıntılı, bu nedenle baytların çoğu sonuçları ayırmaktan geliyor, bu yüzden hala okunabilir. Aksi takdirde yapabiliriz

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

Ancak bu yorumlanması oldukça zor olan çıktılar yaratır. Ayrıca, sadece ızgara her zaman 9x9 veya daha küçük olduğu için çalışacaktır.

Bu gerçekten eğlenceli bir çözüm, çünkü her bir koordinat çiftini temsil ettiği hashın bulunduğu yerde gösteriyor . Örneğin, giriş

# ###
### #

çıktılar

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

Elbette, eğer V kullanıyor olsaydık, takip eden yeni satırı kaldırabilir ve regex'i sıkıştırabilirdik. O zaman sadece olabilir

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

(32 bayt)

Ancak bu tam olarak aynı yaklaşım ve hala acı verici bir şekilde ayrıntılı olduğu için, bir golf dili kullanmaya değmez.

Haskell, 53 bayt

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

Giriş, dizelerin bir listesi olarak alınır. Çıktı bir (x,y)çiftler listesidir (0 indekslenmiş), örn.

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

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

Saat 2:30, yataktayım, telefonumdayım. Bunu neden yapıyorum?

Mathematica, 12 bayt

Position@"#"

Operatör şekli Position. 2B karakter dizisini varsayar. Sol üst girişten başlayarak 1 indeksli. Formdaki koordinatların bir listesini verir {row,column}.

PHP, 69 bayt

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

Üst soldan başlayarak 1 tabanlı indeksleme kullanır.
Gibi kullanın:

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

Çıkacak:

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

C, 113 bayt

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

Test senaryolarından elde edilen çıktılar:

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 

Çevrimiçi deneyin!

RBX.Lua, 131 bayt

Girişin geçerli olduğunu kabul etmek zorundadır (Z, düz eksendir, boşluklar Whitefayanstır, hash'ler başka herhangi bir renkte olabilir, sol üst kısımda bulunur 0, 0, 0) ve tüm parçalar aynı modelin bir parçasıdır Mve model aksi takdirde boş kalır.

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

Örnek giriş / çıkış:

Perl 6 , 25 bayt (22 karakter)

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

Satır listesi olarak girdi alır.
Her satır için birer liste çıkarır, her biri koordinatlar için (y, x) tupler içerir.
Çevrimiçi deneyin!

Nasıl çalışır

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

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

Örnek giriş:

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

Örnek çıktı:

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

Ruby , 24 + 1 = 25 bayt

-nBayrak için +1 bayt . Koordinatlar 1 tabanlıdır, satır başına bir sayıdır.

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

Çevrimiçi deneyin!

C, 80 bayt

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

Yeni satır sınırlı karakter dizisi olarak giriş yapılmasını gerektirir, çıktıyı ekrana yazdırır.

Ungolfed ve kullanım:

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