Étant donné une chaîne 2D en entrée, sous la forme d'une chaîne avec des sauts de ligne ou une liste de lignes, sortez les coordonnées (x, y)de tous les hachages ( #) de la liste. L'entrée ne contiendra que des hachages et des espaces. (et les sauts de ligne, si vous choisissez de prendre l'entrée comme une chaîne 2D)

S'il n'y a pas de hachage, vous pouvez tout afficher.

La sortie doit être sans ambiguïté quant à quels numéros sont associés à quels.

Exemple:

##

Devrait produire:

(0,0), (1,0)

Cela suppose une indexation basée sur 0, en partant du coin supérieur gauche. Vous pouvez commencer à partir de n'importe quel coin, utiliser une indexation basée sur 0 ou 1, et / ou produire en ypremier. (par exemple dans le formulaire y,x).

Plus de cas de test (encore une fois, tous utilisant l' (x, y)indexation en haut à gauche basée sur 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)

Notez que ces cas de test sont tous listés par lignes, pas en suivant le chemin.

Vous pouvez supposer que les hachages formeront une trace continue, c'est-à-dire # #ne seront jamais l'entrée. (probablement pas d'importance, mais au cas où quelqu'un voudrait regex cela)

Vous pouvez également sortir les coordonnées dans n'importe quel ordre, c'est-à-dire des colonnes verticales, des lignes horizontales ou simplement une liste non triée.

Glissement , 2 + 1 = 3 octets

+1 octet pour le pdrapeau. Code:

`#

Explication:

Le p-flag renvoie la position de chaque occurrence des éléments suivants:

`#      // The character '#'

Essayez-le ici!

Grime , 5 octets

pa`\#

Essayez-le en ligne! Le format de sortie est un peu génial, mais OP a déclaré qu'il était valide.

Explication

Grime est mon langage de correspondance de motifs 2D. La partie après `est le motif , dans ce cas un carré 1 × 1 contenant un #caractère. Grime recherchera une correspondance dans la grille d'entrée et imprime la première qu'il trouve par défaut. La partie précédente `contient des options, dans ce cas signifiant que toutes les correspondances ( a) doivent être imprimées, ainsi que leurs positions et tailles ( p).

MATL , 7 6 5 octets

Il s'agit d'une indexation basée sur 1 avec (1,1)dans le coin supérieur gauche.

oo&fh

Explication:

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

Merci @DJMcMayhem et @LuisMendo pour chaque -1 octet!

Essayez-le en ligne!

Python , 67 octets

Ceci est en fait juste un golf de ma réponse Stack Overflow sur un sujet similaire.

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

Essayez-le en ligne!

Les boucles à travers la liste 2D, enregistrant les caractères de hachage, et renvoie le résultat. Nous enregistrons un octet en utilisant char > '!'plutôt que char == '#', car l'entrée ne sera composée que de hachages et d'espaces, et donc hashes ( 0x23) sera les seuls caractères plus grands que les points d'exclamation ( 0x21).

JavaScript (ES6), 70 67 octets

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

Affiche une liste de coordonnées séparées par des sauts de ligne et des espaces, par exemple

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

Vous pouvez devenir beaucoup plus court avec un format de sortie étrange:

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

Cette sorties

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

pour le deuxième cas de test. Il est toujours clair quels numéros sont associés à quels ...

J , 12 octets

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

Essayez-le en ligne!

Explication

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

Gelée , 8 octets

n⁶T€,€"J

Essayez-le en ligne!

Étant donné un tableau 2D de caractères (= une liste de chaînes):

            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 caractères = 9 octets ou 6 caractères = 8 octets

Donne la liste des paires (y, x) en haut à gauche.

⍸⎕='#'

⍸ où

⎕ contribution

= équivaut à

'#' ce personnage*

* Il est possible d'enregistrer un caractère au prix d'un octet en le remplaçant '#'par ⍕#(formater l'espace de noms racine)

TryAPL en ligne! Notez que cela ⍸a été émulé avec i car TryAPL exécute la version 14.0.

JavaScript (Firefox 30-57), 61 octets

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

Renvoie les coordonnées basées sur 1. Commutateur [y, x]et [x, y]commande faciles. Non 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 octets

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

Puisque V est principalement rétrocompatible, vous pouvez l' essayer en ligne!

Une solution regex simple, où il remplace chaque «#» par l'emplacement dans lequel il a été trouvé (indexation sur une base). J'étais un peu inquiet en écrivant ceci que l'emplacement changerait après avoir remplacé le premier sur une ligne, mais cela ne semble pas être un problème. TBH Je suis agréablement choqué par la simplicité de cette solution.

Malheureusement, vimscript est très verbeux, donc la plupart des octets proviennent de la séparation des résultats, ce qui est toujours lisible. Sinon, on pourrait faire

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

Mais cela crée une sortie assez difficile à interpréter. De plus, cela ne fonctionnera que si la grille est toujours 9x9 ou plus petite.

C'est une solution vraiment amusante car elle montre chaque paire de coordonnées à l'emplacement du hachage qu'elle représente. Par exemple, l'entrée

# ###
### #

les sorties

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

Bien sûr, si nous utilisions V, nous pourrions supprimer la nouvelle ligne de fin et compresser l'expression régulière. Alors ça pourrait être simplement

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

(32 octets)

Mais puisque c'est exactement la même approche et toujours douloureusement verbeux, il ne semble pas utile d'utiliser un langage de golf.

Haskell, 53 octets

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

L'entrée est considérée comme une liste de chaînes. La sortie est une liste de (x,y)paires (0 indexées), par exemple

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

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

Il est 2h30 du matin, je suis au lit, sur mon téléphone. Pourquoi est-ce que je fais cela?

Mathematica, 12 octets

Position@"#"

Forme d'opérateur de Position. Suppose un tableau 2D de caractères. 1 indexé à partir de l'entrée en haut à gauche. Affiche une liste de coordonnées dans le formulaire {row,column}.

PHP, 69 octets

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

Utilise l'indexation basée sur 1 en partant du coin supérieur gauche.
Utilisez comme:

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

Sortira:

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

C, 113 octets

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

Sorties des cas de 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 

Essayez-le en ligne!

RBX.Lua, 131 octets

Doit supposer que l'entrée est valide (Z est l'axe plat, les espaces blancs sont des Whitetuiles, les hachages peuvent être de toute autre couleur, la partie supérieure gauche est située à 0, 0, 0) et toutes les parties font partie du même modèle M, et le modèle est par ailleurs vide.

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

Exemple d'entrée / sortie:

Perl 6 , 25 octets (22 caractères)

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

Prend l'entrée comme une liste de lignes.
Produit une liste par ligne, chacune contenant (y, x) des tuples pour les coordonnées.
Essayez-le en ligne!

Comment ça marche

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

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

Exemple d'entrée:

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

Exemple de sortie:

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

Ruby , 24 + 1 = 25 octets

+1 octet pour le -ndrapeau. Les coordonnées sont basées sur 1, un nombre par ligne.

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

Essayez-le en ligne!

C, 80 octets

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

Nécessite une entrée sous forme de tableau de caractères délimité par des sauts de ligne, imprime la sortie à l'écran.

Non golfé et utilisation:

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