Geben Sie bei einer 2D-Zeichenfolge als Eingabe, entweder als Zeichenfolge mit Zeilenumbrüchen oder als Liste mit Zeilen, die Koordinaten (x, y)aller Hashes ( #) in der Liste aus. Die Eingabe enthält nur Hashes und Leerzeichen. (und Zeilenumbrüche, wenn Sie Eingaben als 2D-Zeichenfolge übernehmen möchten)

Wenn keine Hashes vorhanden sind, können Sie alles ausgeben.

Die Ausgabe sollte eindeutig sein, welche Nummern mit welchen gepaart werden.

Beispiel:

##

Sollte ausgeben:

(0,0), (1,0)

Dies setzt eine 0-basierte Indizierung voraus, beginnend von links oben. Sie können an jeder Ecke beginnen, die 0- oder 1-basierte Indizierung verwenden und / oder yzuerst ausgeben . (zB im Formular y,x).

Weitere Testfälle (wiederum alle mit 0-basierter (x, y)Indizierung oben links ):

    #
#####
#

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

Beachten Sie, dass diese Testfälle alle zeilenweise aufgelistet sind und nicht dem Pfad folgen.

Sie können davon ausgehen, dass die Hashes einen kontinuierlichen Pfad bilden, dh # #niemals die Eingabe sein werden. (Wahrscheinlich spielt es keine Rolle, aber für den Fall, dass jemand dies regulieren möchte)

Sie können die Koordinaten auch in beliebiger Reihenfolge ausgeben, z. B. vertikale Spalten, horizontale Zeilen oder nur eine unsortierte Liste.

Beleg , 2 + 1 = 3 Bytes

+1 Byte für das pFlag. Code:

`#

Erläuterung:

Das p-Flag gibt die Position jedes Vorkommens von Folgendem zurück:

`#      // The character '#'

Probieren Sie es hier aus!

Schmutz , 5 Bytes

pa`\#

Probieren Sie es online! Das Ausgabeformat ist ein bisschen funky, aber OP hat angegeben, dass es gültig ist.

Erläuterung

Schmutz ist meine 2D-Pattern-Matching-Sprache. Der folgende Teil `ist das Muster , in diesem Fall ein 1 × 1-Quadrat, das ein #-Zeichen enthält. Grime durchsucht das Eingaberaster nach einer Übereinstimmung und druckt das erste, das es standardmäßig findet. Der `vorherige Teil enthält Optionen. In diesem Fall bedeutet dies, dass alle Übereinstimmungen ( a) mit ihren Positionen und Größen ( p) gedruckt werden sollen .

MATL , 7 6 5 Bytes

Hierbei wird die 1-basierte Indizierung mit (1,1)in der oberen linken Ecke verwendet.

oo&fh

Erläuterung:

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

Vielen Dank an @DJMcMayhem und @LuisMendo für jedes -1 Byte!

Probieren Sie es online!

Python , 67 Bytes

Dies ist eigentlich nur ein Golf meiner Stack Overflow-Antwort zu einem ähnlichen Thema.

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

Probieren Sie es online!

Die Schleife durchläuft die 2D-Liste, zeichnet die Hash-Zeichen auf und gibt das Ergebnis zurück. Wir sparen ein Byte, indem wir char > '!'anstatt verwenden char == '#', da die Eingabe nur aus Hashes und Leerzeichen besteht und daher Hashes ( 0x23) die einzigen Zeichen sind, die größer als Ausrufezeichen ( 0x21) sind.

JavaScript (ES6), 70 bis 67 Byte

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

Gibt eine durch Zeilenumbrüche und Leerzeichen getrennte Liste von Koordinaten aus, z

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

Sie können mit einem seltsamen Ausgabeformat viel kürzer werden:

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

Dies gibt aus

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

für den zweiten Testfall. Es ist immer noch klar, welche Nummern mit welchen gepaart sind ...

J , 12 Bytes

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

Probieren Sie es online!

Erläuterung

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

Gelee , 8 Bytes

n⁶T€,€"J

Probieren Sie es online!

Gegeben ein 2D-Array von Zeichen (= eine Liste von Zeichenfolgen):

            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 Zeichen = 9 Byte oder 6 Zeichen = 8 Byte

Gibt eine Liste von (y, x) Paaren von oben links.

⍸⎕='#'

⍸ woher

⎕ Eingang

= gleich

'#' dieser Charakter*

* Es ist möglich, ein Zeichen zum Preis von einem Byte zu speichern, indem Sie es '#'durch ⍕#(Formatieren des Stammnamensraums) ersetzen.

TryAPL online! Beachten Sie, dass ⍸mit emuliert wurde, i da TryAPL Version 14.0 ausführt.

JavaScript (Firefox 30-57), 61 Byte

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

Gibt 1-basierte Koordinaten zurück. Leicht umschaltbar zwischen [y, x]und [x, y]Bestellung. 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>

Da V überwiegend abwärtskompatibel ist, können Sie es online ausprobieren!

Eine einfache Regex-Lösung, bei der jedes '#' durch die Position ersetzt wird, an der es gefunden wurde (einseitige Indizierung). Ich war ein bisschen besorgt, als ich dies schrieb, dass sich die Position nach dem Ersetzen der ersten Zeile in einer Zeile ändern würde, aber das scheint kein Problem zu sein. TBH Ich bin angenehm schockiert, wie einfach diese Lösung letztendlich war.

Leider ist Vimscript sehr ausführlich, daher stammen die meisten Bytes aus der Trennung der Ergebnisse, sodass sie noch lesbar sind. Ansonsten könnten wir tun

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

Dies erzeugt jedoch eine Ausgabe, die ziemlich schwer zu interpretieren ist. Außerdem funktioniert es nur, wenn das Raster immer 9x9 oder kleiner ist.

Dies ist eine wirklich unterhaltsame Lösung, da jedes Koordinatenpaar an der Position des Hashs angezeigt wird, den es darstellt. Zum Beispiel die Eingabe

# ###
### #

Ausgänge

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

Wenn wir V verwenden würden, könnten wir natürlich die abschließende Newline entfernen und den regulären Ausdruck komprimieren. Dann könnte es einfach sein

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

(32 Bytes)

Aber da dies genau derselbe Ansatz ist und immer noch schmerzhaft wortreich, scheint es sich nicht zu lohnen, eine Golfsprache zu verwenden.

Haskell, 53 Bytes

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

Die Eingabe wird als Liste von Zeichenfolgen verwendet. Die Ausgabe ist eine Liste von (x,y)Paaren (0 indiziert), z

*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

Es ist halb drei, ich bin im Bett und telefoniere. Warum mache ich das?

Mathematica, 12 Bytes

Position@"#"

Betreiberformular von Position. Nimmt ein 2D-Array von Zeichen an. 1-indiziert ab dem linken oberen Eintrag. Gibt eine Liste der Koordinaten im Formular aus {row,column}.

PHP, 69 Bytes

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

Verwendet 1-basierte Indizierung, beginnend von links oben.
Verwenden Sie wie:

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

Wird ausgeben:

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

Ausgaben von Testfällen:

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 

Probieren Sie es online!

RBX.Lua, 131 Bytes

Es muss davon ausgegangen werden, dass die Eingabe gültig ist (Z ist die flache Achse, Leerzeichen sind WhiteKacheln, Hashes können jede andere Farbe haben, der linke obere Teil befindet sich bei0, 0, 0 ) und alle Teile sind Teil desselben Modells M, und das Modell ist ansonsten leer.

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

Beispiel Input / Output:

Perl 6 , 25 Bytes (22 Zeichen)

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

Nimmt die Eingabe als eine Liste von Zeilen.
Gibt eine Liste pro Zeile aus, die jeweils (y, x) Tupel für die Koordinaten enthält.
Probieren Sie es online!

Wie es funktioniert

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

Beispiel Eingabe:

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

Beispielausgabe:

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

Rubin , 24 + 1 = 25 Bytes

+1 Byte für -nFlag. Koordinaten sind 1-basiert, eine Zahl pro Zeile.

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

Probieren Sie es 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);}

Erfordert die Eingabe als durch Zeilenumbrüche getrenntes Zeichen-Array und druckt die Ausgabe auf dem Bildschirm.

Ungolfed & Nutzung:

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