Data una stringa 2D come input, o come stringa con newline o un elenco di linee, genera le coordinate (x, y)di tutti gli hash ( #) nell'elenco. L'input conterrà solo hash e spazi. (e newline, se si sceglie di accettare input come stringa 2D)

Se non ci sono hash, puoi produrre qualsiasi cosa.

L'output dovrebbe essere inequivocabile su quali numeri sono associati a quali.

Esempio:

##

Dovrebbe produrre:

(0,0), (1,0)

Ciò presuppone l'indicizzazione basata su 0, a partire dall'angolo in alto a sinistra. È possibile iniziare da qualsiasi angolo, utilizzare l'indicizzazione basata su 0 o 1 e / o yprima l' output . (ad es. nel modulo y,x).

Altri casi di test (di nuovo, tutti usando l' (x, y)indicizzazione in alto a sinistra basata su 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)

Si noti che questi casi di test sono tutti elencati per righe, non seguendo il percorso.

Puoi supporre che gli hash formino una scia continua, cioè # #che non sarà mai l'input. (probabilmente non importerà, ma nel caso qualcuno voglia regex questo)

È inoltre possibile generare le coordinate nell'ordine desiderato, ad esempio colonne verticali, righe orizzontali o solo un elenco non ordinato.

Slip , 2 + 1 = 3 byte

+1 byte per la pbandiera. Codice:

`#

Spiegazione:

I prendimenti -Flag la posizione di ogni occorrenza dei seguenti elementi:

`#      // The character '#'

Provalo qui!

Grime , 5 byte

pa`\#

Provalo online! Il formato di output è un po 'strano, ma OP ha dichiarato che è valido.

Spiegazione

Grime è il mio linguaggio di corrispondenza dei motivi 2D. La parte dopo `è il modello , in questo caso un quadrato 1 × 1 contenente un #carattere. Grime cercherà una corrispondenza nella griglia di input e stamperà la prima trovata di default. La parte prima `contiene opzioni, in questo caso significa che tutte le corrispondenze ( a) devono essere stampate, insieme alle loro posizioni e dimensioni ( p).

MATL , 7 6 5 byte

Questo utilizza l'indicizzazione basata su 1 con (1,1)nell'angolo in alto a sinistra.

oo&fh

Spiegazione:

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

Grazie @DJMcMayhem e @LuisMendo per ogni -1 byte!

Provalo online!

Python , 67 byte

Questo è in realtà solo un campo da golf della mia risposta Stack Overflow su un argomento simile.

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

Provalo online!

Passa attraverso l'elenco 2D, registrando i caratteri hash e restituisce il risultato. Salviamo un byte usando char > '!'invece di char == '#', perché l'input consisterà solo di hash e spazi, e così hash ( 0x23) sarà l'unico carattere più grande dei punti esclamativi ( 0x21).

JavaScript (ES6), 70 67 byte

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

Emette un elenco di coordinate separato da nuova riga e spazio, ad es

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

Puoi ottenere molto più breve con uno strano formato di output:

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

Questo produce

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

per il secondo caso di test. È ancora chiaro quali numeri sono associati a quali ...

J , 12 byte

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

Provalo online!

Spiegazione

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

n⁶T€,€"J

Provalo online!

Dato un array di caratteri 2D (= un elenco di stringhe):

            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 caratteri = 9 byte o 6 caratteri = 8 byte

Fornisce un elenco di coppie (y, x) in alto a sinistra.

⍸⎕='#'

⍸ dove

⎕ ingresso

= è uguale a

'#' questo personaggio *

* È possibile salvare un carattere al costo di un byte sostituendolo '#'con ⍕#(formattare lo spazio dei nomi di root)

ProvaAPL online! Si noti che ⍸è stato emulato i perché TryAPL esegue la versione 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]]

Restituisce coordinate basate su 1. Facilmente commutabile tra [y, x]e l' [x, y]ordinazione. 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 byte

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

Poiché V è per lo più compatibile con le versioni precedenti, puoi provarlo online!

Una soluzione regex semplice, in cui sostituisce ogni '#' con la posizione in cui è stata trovata (indicizzazione su una base). Ero un po 'preoccupato mentre scrivevo che la posizione sarebbe cambiata dopo aver sostituito il primo su una riga, ma questo non sembra essere un problema. TBH Sono piacevolmente scioccato da quanto semplice sia stata questa soluzione.

Sfortunatamente, vimscript è molto dettagliato, quindi la maggior parte dei byte deriva dalla separazione dei risultati in modo che sia ancora leggibile. Altrimenti, potremmo fare

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

Ma questo crea un output piuttosto difficile da interpretare. Inoltre, funzionerà solo se la griglia è sempre 9x9 o più piccola.

Questa è una soluzione davvero divertente perché mostra ogni coppia di coordinate nella posizione dell'hash che rappresenta. Ad esempio, l'input

# ###
### #

uscite

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

Naturalmente, se stessimo usando V, potremmo rimuovere la nuova riga finale e comprimere la regex. Quindi potrebbe semplicemente essere

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

(32 byte)

Ma dato che questo è esattamente lo stesso approccio e ancora penosamente prolisso, non sembra valga la pena usare un linguaggio da golf.

Haskell, 53 byte

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

L'input viene considerato come un elenco di stringhe. L'output è un elenco di (x,y)coppie (0 indicizzate), ad es

*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

Sono le 2:30 del mattino, sono a letto, sul mio telefono. Perché lo sto facendo?

Mathematica, 12 byte

Position@"#"

Modulo operatore di Position. Presuppone una matrice 2D di caratteri. 1-indicizzato a partire dalla voce in alto a sinistra. Emette un elenco di coordinate nel modulo {row,column}.

PHP, 69 byte

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

Utilizza l'indicizzazione basata su 1 a partire dall'angolo in alto a sinistra.
Usa come:

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

Uscita:

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

Uscite da casi di test:

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 

Provalo online!

RBX.Lua, 131 byte

Deve presumere che l'input sia valido (Z è l'asse piatto, gli spazi bianchi sono Whitepiastrelle, gli hash possono essere di qualsiasi altro colore, la parte in alto a sinistra si trova in 0, 0, 0) e tutte le parti fanno parte dello stesso modello Me il modello è altrimenti vuoto.

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

Ingresso / uscita campione:

Perl 6 , 25 byte (22 caratteri)

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

Accetta input come un elenco di righe.
Emette un elenco per riga, ciascuno contenente tuple (y, x) per le coordinate.
Provalo online!

Come funziona

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

Esempio di input:

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

Esempio di output:

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

Rubino , 24 + 1 = 25 byte

+1 byte per -nflag. Le coordinate sono basate su 1, un numero per riga.

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

Provalo online!

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

Richiede input come array di caratteri delimitato da nuova riga, stampa l'output sullo schermo.

Ungolfed e utilizzo:

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