Если в качестве входных данных задана двумерная строка в виде строки с символами новой строки или списком строк, выведите координаты (x, y)всех хэшей (# ) в списке. Входные данные будут содержать только хэши и пробелы. (и переводы строки, если вы решили принять ввод как 2D-строку)

Если хэшей нет, вы можете вывести что угодно.

Вывод должен быть однозначным относительно того, какие номера связаны с каким.

Пример:

##

Должен вывести:

(0,0), (1,0)

Это предполагает индексирование на основе 0, начиная с верхнего левого угла. Вы можете начать с любого угла, использовать индексирование на основе 0 или 1 и / или yсначала выводить данные . (например, в формеy,x ).

Еще несколько тестов (опять же, все с использованием (x, y)индексации слева направо на основе 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)

Обратите внимание, что все эти тестовые примеры перечислены по строкам, а не по пути.

Вы можете предположить, что хэши образуют непрерывный след, т.е. # # никогда не будут входными данными. (вероятно, это не имеет значения, но в случае, если кто-то захочет переопределить это)

Вы также можете вывести координаты в любом порядке: вертикальные столбцы, горизонтальные строки или просто несортированный список.

слип , 2 + 1 = 3 байта

+1 байт за pфлаг. Код:

`#

Объяснение:

В p-flag возвращает позицию каждого совпадения следующих:

`#      // The character '#'

Попробуй это здесь!

Грязь , 5 байт

pa`\#

Попробуйте онлайн! Формат вывода немного прикольный, но OP заявил, что он действителен.

объяснение

Grime - мой язык сопоставления двухмерных шаблонов. Часть после `- это шаблон , в данном случае квадрат 1 × 1, содержащий #-символ. Grime найдет совпадения во входной сетке и распечатает первую найденную по умолчанию. Часть перед `содержит параметры, в этом случае означающие, что aдолжны быть напечатаны все match ( ), а также их позиции и размеры ( p).

MATL , 7 6 5 байт

Это использует индексирование на основе 1 (1,1)в верхнем левом углу.

oo&fh

Объяснение:

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

Спасибо @DJMcMayhem и @LuisMendo за каждый -1 байт!

Попробуйте онлайн!

Python , 67 байт

На самом деле это просто ответ на мой вопрос о переполнении стека на похожую тему.

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

Попробуйте онлайн!

Зацикливается на 2D-списке, записывает хэш-символы и возвращает результат. Мы сохраняем байт, используя char > '!'вместо char == '#', потому что входные данные будут состоять только из хэшей и пробелов, и поэтому хэши ( 0x23) будут единственными символами больше восклицательных знаков ( 0x21).

JavaScript (ES6), 70 67 байт

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

Вывод списка разделенных новой строкой и пробелом координат, например

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

Вы можете стать намного короче с помощью странного формата вывода:

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

Это выводы

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

для второго теста. До сих пор ясно, какие числа в паре с каким ...

J , 12 байт

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

Попробуйте онлайн!

объяснение

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

Желе , 8 байт

n⁶T€,€"J

Попробуйте онлайн!

Имеется двумерный массив символов (= список строк):

            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 символов = 9 байтов или 6 символов = 8 байтов

Дает список (y, x) пар слева сверху.

⍸⎕='#'

⍸ где

⎕ вход

= равно

'#' этот персонаж *

* Можно сохранить символ в стоимости одного байта, заменив '#'с ⍕#(форматом корневого пространства имен)

Попробуй APL онлайн! Обратите внимание, что ⍸эмулируется с, i потому что TryAPL работает версия 14.0.

JavaScript (Firefox 30-57), 61 байт

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

Возвращает 1 основанные координаты. Легко переключается между [y, x]и [x, y]заказа. 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 байт

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

Поскольку V в основном обратно совместим, вы можете попробовать его онлайн!

Простое решение для регулярных выражений, где оно заменяет каждое '#' на местоположение, в котором оно было найдено (индексация по одному). Когда я писал это, я немного волновался, что местоположение будет меняться после замены первого в строке, но это не проблема. TBH Я приятно удивлен тем, насколько простым оказалось это решение.

К сожалению, vimscript очень многословен, поэтому большая часть байтов получается путем разделения результатов, чтобы их можно было прочитать. В противном случае мы могли бы сделать

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

Но это создает результат, который довольно сложно интерпретировать. Кроме того, он будет работать только в том случае, если сетка всегда 9x9 или меньше.

Это действительно забавное решение, потому что оно показывает каждую пару координат в месте хеша, которое оно представляет. Например, вход

# ###
### #

выходы

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

Конечно, если бы мы использовали V, мы могли бы удалить завершающий символ новой строки и сжать регулярное выражение. Тогда это может быть просто

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

(32 байта)

Но так как это тот же самый подход и все еще мучительно многословный, кажется, не стоит использовать язык игры в гольф.

Haskell, 53 байта

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

Ввод принимается как список строк. Вывод представляет собой список (x,y)пар (0 проиндексирован), например

*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)]

Луа, 141 байт

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

Сейчас 2:30 утра, я в кровати, на моем телефоне. Почему я это делаю?

Mathematica, 12 байт

Position@"#"

Операторская форма Position. Предполагается двумерный массив символов. 1-индексированный, начиная с верхнего левого входа. Выводит список координат в форме {row,column}.

PHP, 69 байт

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

Использует индексирование на основе 1, начиная с верхнего левого угла.
Используйте как:

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

Будет выводить:

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

C 113 байтов

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

Выходы из тестовых случаев:

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 

Попробуйте онлайн!

RBX.Lua, 131 байт

Должен предполагать, что ввод действителен (Z - плоская ось, пробелы - это Whiteплитки, хэши могут быть любого другого цвета, верхняя левая часть расположена в 0, 0, 0), и все части являются частью той же модели M, а модель в противном случае пуста.

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

Пример ввода / вывода:

Perl 6 , 25 байт (22 символа)

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

Принимает ввод в виде списка строк.
Выводит по одному списку на строку, каждый из которых содержит (y, x) кортежи для координат.
Попробуйте онлайн!

Как это устроено

{                    }  # 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 байт

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

Пример ввода:

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

Пример вывода:

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

Рубин , 24 + 1 = 25 байт

+1 байт за -nфлаг. Координаты основаны на 1, по одному номеру в строке.

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

Попробуйте онлайн!

C, 80 байтов

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

Требует ввода в виде массива символов с разделителями новой строки, выводит вывод на экран.

Ungolfed & использование:

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