Dada uma string 2D como entrada, como uma string com novas linhas ou uma lista de linhas, produza as coordenadas (x, y)de todos os hashes ( #) na lista. A entrada conterá apenas hashes e espaços. (e novas linhas, se você optar por receber a entrada como uma sequência 2D)

Se não houver hashes, você pode produzir qualquer coisa.

A saída deve ser inequívoca quanto a quais números estão emparelhados com os quais.

Exemplo:

##

Saída deve:

(0,0), (1,0)

Isso pressupõe a indexação baseada em 0, iniciando no canto superior esquerdo. Você pode começar de qualquer canto, usar indexação com base em 0 ou 1 e / ou saíday primeiro. (por exemplo, no formulário y,x).

Mais casos de teste (novamente, todos usando o canto superior esquerdo com base em 0 (x, y) indexação ):

    #
#####
#

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

Observe que todos esses casos de teste são listados por linhas, não seguindo o caminho.

Você pode assumir que os hashes formarão uma trilha contínua, ou seja, # # , nunca será a entrada. (provavelmente não importará, mas caso alguém queira regexar isso)

Você também pode produzir as coordenadas na ordem que desejar, como colunas verticais, linhas horizontais ou apenas uma lista não classificada.

Deslizamento , 2 + 1 = 3 bytes

+1 byte para o psinalizador. Código:

`#

Explicação:

O p-flag retorna a posição de cada ocorrência do seguinte:

`#      // The character '#'

Experimente aqui!

Grime , 5 bytes

pa`\#

Experimente online! O formato de saída é um pouco descolado, mas o OP afirmou que é válido.

Explicação

Grime é minha linguagem de correspondência de padrões 2D. A parte depois `é o padrão , neste caso, um quadrado 1 × 1 contendo um #caractere. O Grime procurará uma correspondência na grade de entrada e imprimirá a primeira que encontrar por padrão. A parte anterior `contém opções, neste caso, significando que todas as correspondências ( a) devem ser impressas, juntamente com suas posições e tamanhos ( p).

MATL , 7 6 5 bytes

Isso está usando a indexação baseada (1,1)em 1 no canto superior esquerdo.

oo&fh

Explicação:

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

Obrigado @DJMcMayhem e @LuisMendo por cada -1 byte!

Experimente online!

Python , 67 bytes

Na verdade, este é apenas um argumento da minha resposta do Stack Overflow sobre um tópico semelhante.

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

Experimente online!

Os loops na lista 2D, gravando os caracteres hash, e retornam o resultado. Salvamos um byte usando, em char > '!'vez de char == '#', porque a entrada consistirá apenas de hashes e espaços e, portanto, hashes ( 0x23) serão os únicos caracteres maiores que pontos de exclamação ( 0x21).

JavaScript (ES6), 70 67 bytes

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

Gera uma lista de coordenadas separadas por nova linha e espaço, por exemplo

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

Você pode ficar muito mais curto com um formato de saída estranho:

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

Isso gera

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

para o segundo caso de teste. Ainda está claro quais números estão emparelhados com quais ...

J , 12 bytes

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

Experimente online!

Explicação

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

Gelatina , 8 bytes

n⁶T€,€"J

Experimente online!

Dada uma matriz 2D de caracteres (= uma lista de cadeias):

            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 caracteres = 9 bytes ou 6 caracteres = 8 bytes

Fornece uma lista de (y, x) pares do canto superior esquerdo.

⍸⎕='#'

⍸ Onde

⎕ entrada

= é igual a

'#' esse personagem*

* É possível salvar um caractere ao custo de um byte, substituindo '#'por ⍕#(formate o espaço para nome raiz)

TryAPL online! Observe que ⍸foi emulado i porque o TryAPL executa a versão 14.0.

JavaScript (Firefox 30-57), 61 bytes

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

Retorna coordenadas com base em 1. Facilmente selecionável entre [y, x]e [x, y]pedidos. 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 bytes

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

Como o V é principalmente compatível com versões anteriores, você pode experimentá-lo online!

Uma solução simples de regex, em que substitui cada '#' pelo local em que foi encontrado (indexação baseada em um). Ao escrever isso, fiquei um pouco preocupado que o local mudaria depois de substituir o primeiro de uma linha, mas isso não parece ser um problema. TBH Estou agradavelmente chocado com o quão simples essa solução acabou sendo.

Infelizmente, o vimscript é muito detalhado, portanto, a maioria dos bytes vem da separação dos resultados, para que ainda seja legível. Caso contrário, poderíamos fazer

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

Mas isso cria uma saída que é bastante difícil de interpretar. Além disso, ele funcionará apenas na grade sempre 9x9 ou menor.

Essa é uma solução realmente divertida, pois mostra cada par de coordenadas no local do hash que representa. Por exemplo, a entrada

# ###
### #

saídas

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

Obviamente, se estivéssemos usando V, poderíamos remover a nova linha à direita e compactar a regex. Então poderia ser simplesmente

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

(32 bytes)

Mas como essa é exatamente a mesma abordagem e ainda é dolorosamente detalhada, não parece valer a pena usar uma linguagem de golfe.

Haskell, 53 bytes

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

A entrada é tomada como uma lista de cadeias. A saída é uma lista de (x,y)pares (0 indexado), por exemplo

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

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

São duas e meia da manhã, estou na cama, no meu telefone. Por que estou fazendo isto?

Mathematica, 12 bytes

Position@"#"

Forma do operador de Position. Assume uma matriz 2D de caracteres. Indexado em 1 a partir da entrada superior esquerda. Produz uma lista de coordenadas no formulário {row,column}.

PHP, 69 bytes

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

Usa indexação baseada em 1, começando no canto superior esquerdo.
Use como:

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

Saída:

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

C, 113 bytes

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

Saídas de casos de teste:

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 

Experimente online!

RBX.Lua, 131 bytes

Tem que assumir que a entrada é válida (Z é o eixo plano, os espaços em branco são Whiteladrilhos, os hashes podem ser de qualquer outra cor, a parte superior esquerda está localizada em 0, 0, 0) e todas as partes fazem parte do mesmo modelo Me o modelo está vazio.

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

Entrada / saída de amostra:

Perl 6 , 25 bytes (22 caracteres)

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

Recebe a entrada como uma lista de linhas.
Gera uma lista por linha, cada uma contendo tuplas (y, x) para as coordenadas.
Experimente online!

Como funciona

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

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

Exemplo de entrada:

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

Saída de exemplo:

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

Ruby , 24 + 1 = 25 bytes

+1 byte para -nsinalizador. As coordenadas são baseadas em 1, um número por linha.

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

Experimente online!

C, 80 bytes

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

Requer entrada como matriz de caracteres delimitada por nova linha, imprime a saída na tela.

Ungolfed & uso:

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