Dada una cadena 2D como entrada, ya sea como una cadena con nuevas líneas o una lista de líneas, genera las coordenadas (x, y)de todos los hashes (# ) en la lista. La entrada solo contendrá hashes y espacios. (y nuevas líneas, si elige tomar la entrada como una cadena 2D)

Si no hay hashes, puede generar cualquier cosa.

La salida no debe ser ambigua en cuanto a qué números están emparejados con cuáles.

Ejemplo:

##

Debería dar salida:

(0,0), (1,0)

Eso supone una indexación basada en 0, comenzando desde la parte superior izquierda. Puede comenzar desde cualquier esquina, usar indexación basada en 0 o 1, y / o salida yprimero. (por ejemplo, en el formulario y,x).

Más casos de prueba (de nuevo, todos usando (x, y)indexación superior izquierda basada en 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)

Tenga en cuenta que todos estos casos de prueba se enumeran por filas, no siguiendo la ruta.

Puede suponer que los hashes formarán un rastro continuo, es decir # #, nunca serán la entrada. (probablemente no importará, pero en caso de que alguien quiera expresar esto)

También puede generar las coordenadas en el orden que desee, es decir, columnas verticales, filas horizontales o simplemente una lista sin clasificar.

Resbalón , 2 + 1 = 3 bytes

+1 byte para la pbandera. Código:

`#

Explicación:

La pbandera-devuelve la posición de cada ocurrencia de lo siguiente:

`#      // The character '#'

Pruébalo aquí!

Grime , 5 bytes

pa`\#

Pruébalo en línea! El formato de salida es un poco raro, pero OP ha declarado que es válido.

Explicación

Grime es mi lenguaje de coincidencia de patrones 2D. La parte posterior `es el patrón , en este caso un cuadrado de 1 × 1 que contiene un carácter #. Grime buscará una coincidencia en la cuadrícula de entrada e imprimirá la primera que encuentre por defecto. La parte anterior `contiene opciones, en este caso significa que se adeben imprimir todas las coincidencias ( ), junto con sus posiciones y tamaños ( p).

MATL , 7 6 5 bytes

Esto está utilizando la indexación basada en 1 con (1,1)en la esquina superior izquierda.

oo&fh

Explicación:

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

¡Gracias @DJMcMayhem y @LuisMendo por cada -1 byte!

Pruébalo en línea!

Python , 67 bytes

Esto es en realidad solo un golf de mi respuesta de Stack Overflow sobre un tema similar.

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

Pruébalo en línea!

Recorre la lista 2D, registra los caracteres hash y devuelve el resultado. Guardamos un byte usando en char > '!'lugar de char == '#', porque la entrada solo consistirá en hashes y espacios, por lo que los hashes ( 0x23) serán los únicos caracteres más grandes que los signos de exclamación ( 0x21).

JavaScript (ES6), 70 67 bytes

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

Da como resultado una lista de coordenadas separadas por líneas y espacios, por ejemplo

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

Puede acortarse mucho con un formato de salida extraño:

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

Esto salidas

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

para el segundo caso de prueba. Todavía está claro qué números están emparejados con qué ...

J , 12 bytes

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

Pruébalo en línea!

Explicación

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

Jalea , 8 bytes

n⁶T€,€"J

Pruébalo en línea!

Dada una matriz 2D de caracteres (= una lista de cadenas):

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

Da una lista de pares (y, x) desde la parte superior izquierda.

⍸⎕='#'

⍸ dónde

⎕ entrada

= es igual

'#' Este personaje*

* Es posible guardar un carácter a costa de un byte reemplazándolo '#'con ⍕#(formatear el espacio de nombres raíz)

TryAPL en línea! Tenga en cuenta que ⍸se ha emulado i porque TryAPL ejecuta la versión 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]]

Devuelve coordenadas basadas en 1. Fácilmente conmutable entre [y, x]y [x, y]pedidos. Sin golf:

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 V es en su mayoría compatible con versiones anteriores, ¡puede probarlo en línea!

Una solución directa de expresiones regulares, donde reemplaza cada '#' con la ubicación en la que se encontró (indexación basada en uno). Mientras escribía esto, estaba un poco preocupado porque la ubicación cambiaría después de sustituir la primera en una línea, pero eso no parece ser un problema. TBH Estoy gratamente sorprendido por lo simple que terminó siendo esta solución.

Desafortunadamente, vimscript es muy detallado, por lo que la mayoría de los bytes provienen de la separación de los resultados para que todavía sea legible. De lo contrario, podríamos hacer

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

Pero esto crea resultados que son bastante difíciles de interpretar. Además, solo funcionará si la cuadrícula es siempre 9x9 o menor.

Esta es una solución realmente divertida porque muestra cada par de coordenadas en la ubicación del hash que representa. Por ejemplo, la entrada

# ###
### #

salidas

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

Por supuesto, si estuviéramos usando V, podríamos eliminar la nueva línea final y comprimir la expresión regular. Entonces podría ser simplemente

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

(32 bytes)

Pero dado que este es exactamente el mismo enfoque y sigue siendo dolorosamente detallado, no parece que valga la pena usar un lenguaje de golf.

Haskell, 53 bytes

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

La entrada se toma como una lista de cadenas. La salida es una lista de (x,y)pares (0 indexados), p. Ej.

*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

Son las 2:30 a.m., estoy en la cama, en mi teléfono. ¿Por qué estoy haciendo esto?

Mathematica, 12 bytes

Position@"#"

Operador de forma Position. Asume una matriz 2D de caracteres. 1 indexado a partir de la entrada superior izquierda. Emite una lista de coordenadas en el formulario {row,column}.

PHP, 69 bytes

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

Utiliza indexación basada en 1 a partir de la esquina superior izquierda.
Usar como:

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

Saldrá:

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

Salidas de casos de prueba:

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 

Pruébalo en línea!

RBX.Lua, 131 bytes

Debe suponer que la entrada es válida (Z es el eje plano, los espacios en blanco son Whitemosaicos, los hash pueden ser de cualquier otro color, la parte superior izquierda se encuentra en 0, 0, 0) y todas las partes son parte del mismo modelo M, y el modelo está vacío.

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 / salida de muestra:

Perl 6 , 25 bytes (22 caracteres)

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

Toma la entrada como una lista de líneas.
Emite una lista por línea, cada una de las cuales contiene (y, x) tuplas para las coordenadas.
Pruébalo en línea!

Cómo 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++}}

Entrada de ejemplo:

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

Salida de ejemplo:

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

Rubí , 24 + 1 = 25 bytes

+1 byte para -nbandera. Las coordenadas están basadas en 1, un número por línea.

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

Pruébalo en línea!

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

Requiere entrada como matriz de caracteres delimitada por nueva línea, imprime la salida a la pantalla.

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