Подавши 2D рядок як вхідний текст, або як рядок з новими рядками або списком рядків, виведіть координати (x, y)всіх хешів ( #) у списку. Вхід буде містити лише хеші та пробіли. (і нові рядки, якщо ви вирішили приймати введення як двовимірний рядок)

Якщо хешів немає, ви можете вивести що завгодно.

Вихід повинен бути однозначним щодо того, з якими числами спарені.

Приклад:

##

Потрібно вивести:

(0,0), (1,0)

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

Більше тестових випадків (знову ж, усі, які використовують 0-базовану вгорі ліву (x, y)індексацію):

    #
#####
#

(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`\#

Спробуйте в Інтернеті! Вихідний формат трохи фанк, але ОП заявив, що він дійсний.

Пояснення

Grime - це моя 2D-відповідна модель. Частина після `- це шаблон , в даному випадку 1 × 1 квадрат, що містить #-символ. Grime буде шукати вхідну сітку для відповідності та друкує першу, яку знайде за замовчуванням. Частина раніше `містить параметри, в цьому випадку означає, що всі сірники ( a) повинні бути надруковані разом з їх положеннями та розмірами ( 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 за кожен байт!

Спробуйте в Інтернеті!

Пітон , 67 байт

Це насправді лише гольф моєї відповіді Stack Overflow на подібну тему.

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

Спробуйте в Інтернеті!

Дано 2D масив символів (= список рядків):

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

Діалог APL 16.0, 5 символів = 9 байт або 6 символів = 8 байт

Надає список (у, х) пар зліва вгорі.

⍸⎕='#'

⍸ де

⎕ вхід

= дорівнює

'#' цей персонаж *

* Можна зберегти символ ціною одного байта, замінивши '#'на ⍕#(відформатувати простір імен кореня)

Спробуйте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]замовляти. Безголівки:

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, я в ліжку, по телефону. Чому я це роблю?

Математика, 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);}

Потрібен вхід у вигляді обмеженого рядка діаграм для рядків, що друкує вихід на екран.

Безголовки та використання:

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