Cho 3 mục đầu vào, danh sách các cặp tọa độ, chuỗi 2D và chuỗi ký tự đơn, xuất ra liệu ký tự ở mỗi tọa độ của chuỗi 2D có bằng ký tự đơn hay không. Bạn có thể lấy đầu vào theo bất kỳ thứ tự nào và tọa độ có thể được lập chỉ mục 1.

Bạn có thể lấy chuỗi 2D làm danh sách 2D, danh sách các dòng hoặc chuỗi 2D.

Thí dụ: (0,0), "#_\n__", "#" -> True

Chuỗi là

#_
__

Các char ở tọa độ (0,0)(từ trên cùng bên trái) là #. Điều này bằng với mục đầu vào thứ ba #, vì vậy bạn xuất ra True(hoặc bất kỳ giá trị trung thực nào)

Thí dụ: [(0,0), (1,1)], "#_\n_#", "#" -> True

Chuỗi là

#_
_#

Các ký tự tại tọa độ của (0,0)và (1,1)là cả hai #, vì vậy đầu ra là đúng.

Đầu ra chỉ đúng nếu mỗi tọa độ khớp với hàm băm. Không phải mọi băm đều phải có tọa độ khớp. Nếu không có sự xuất hiện của char đơn ( #trong một số trường hợp thử nghiệm) trong chuỗi 2D, thì đầu ra vẫn chỉ là giả.

Bạn có thể giả sử tọa độ sẽ luôn nằm trong giới hạn của chuỗi 2D.

Thêm trường hợp kiểm tra: (Tôi đặt char thứ hai để dễ đọc)

[(0,0), (2,1), (3,0)], #

#_##
#_##

True


[(0,0), (1,1), (3,0)], #

#_##
#_##

False (1,1 is not a hash)



[(1,1)], a

#a##
#a##

True


[(4, 0), (3, 0), (2, 0), (1, 0), (0, 0), (0, 1), (0, 2), (0, 3), (1, 3), (2, 3), (2, 2), (3, 2), (4, 2), (4, 3)], ' '


 ####
 #   
   # 

True

Lưu ý trường hợp thử nghiệm cuối cùng sử dụng khoảng trắng làm chuỗi char đơn và băm xung quanh khoảng trắng.

Liên quan. (nghịch đảo của thử thách này)

APL Dyalog , 8 byte

Nhắc cho danh sách các cặp tọa độ (hàng, cột), rồi mảng 2D, rồi ký tự.

∧/⎕=⎕[⎕]

[⎕] nhắc nhở tọa độ và sử dụng chúng để phân tán chọn từ

⎕ đầu vào được nhắc (mảng 2D)

= so sánh các yếu tố được chọn với

⎕ đầu vào (ký tự)

∧/ kiểm tra xem tất cả có đúng không (AND-giảm)

Các trường hợp thử nghiệm ( ⎕IO←0để khớp với các ví dụ, nhưng điều này là không cần thiết):

Ví dụ đầu tiên

Ví dụ thứ hai

Ví dụ thứ ba

Ví dụ thứ tư

Ví dụ thứ năm

Python, 39 byte

Có đầu vào:

1. adanh sách (x, y)tọa độ nguyên
2. b danh sách các chuỗi
3. c chuỗi ký tự đơn

lambda a,b,c:{b[y][x]for x,y in a}=={c}

JavaScript (ES6), 37 byte

Có đầu vào:

1. amảng [x, y]tọa độ nguyên
2. s mảng dây
3. c chuỗi ký tự đơn

(a,s,c)=>a.every(([x,y])=>s[y][x]==c)

Octave, 45 38 29 byte

@(A,B,C)A(1+B*[rows(A);1])==C

Một hàm lấy một mảng 2D của ký tự là Avà tọa độ (dựa trên 0) Blàm ma trận hai cột [col row]và ký tự trùng khớp là C. Hai tọa độ phần tử (sử dụng phép nhân ma trận) được chuyển đổi thành chỉ số tuyến tính.

Lưu ý: Câu trả lời trước đó sử dụng ma trận thưa thớt là sai.

Những người đóng góp khác:

Stewie Griffin để lưu 5 byte lưu ý rằng [0 1 0] có thể được coi là giá trị sai !!

Luis Mendo để lưu 2 byte đó ~0 == truevà thông báo về ma trận thưa thớt.

Dùng thử trực tuyến

Toán học, 28 byte

#3~Extract~#~MatchQ~{#2...}&

1 chỉ mục. Do cách các mảng được cấu trúc trong Mathicala, tọa độ đầu vào phải được đảo ngược (nghĩa là (row, column))

Sử dụng

#3~Extract~#~MatchQ~{#2...}&[{{1, 1}, {2, 3}, {1, 4}}, "#", {{"#", "_", "#", "#"}, {"#", "_", "#", "#"}}]

True

Haskell, 27 byte

s!c=all(\(x,y)->s!!y!!x==c)

Ví dụ sử dụng: ( ["#_##","#_##"] ! '#' ) [(0,0), (2,1), (3,0)]-> True.

Thạch , 10 byte

ịṪ⁸ịḢð€Q⁼⁵

Điều này chỉ hoạt động như một chương trình đầy đủ. Thứ tự đầu vào là các chỉ số, mảng chuỗi, chuỗi đơn.

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

ịṪ⁸ịḢð€Q⁼⁵  Main link.
            Left argument:  P (array of coordinate pairs)
            Right argument: S (array of strings)
            Third argument: C (singleton string)

     ð€     Combine the links to the left into a dyadic chain and call it with each
            p = (x, y) in P as left argument and S as the right one.
ị             Unindex; retrieve the strings of S at indices x and y.
 Ṫ            Tail; yield s, the string of S at index y.
  ⁸ị          Unindex; retrieve the characters of s at indices x and y.
    Ḣ         Head; yield the character of s at index x.
       Q    Unique; deduplicate the resulting string/array of characters.
        ⁼⁵  Compare the result with the third argument.

Perl 6 , 41 40 byte

->\c,\h,\n{all map {n eq h[.[0];.[1]]},c}

->$_,\h,\n{all .map:{n eq h[.[0];.[1]]}}

Mong đợi chuỗi 2D dưới dạng danh sách 2D.

Cảm ơn b2gills cho -1 byte.

C #, 80 77 byte

Đã lưu 3 byte, nhờ Pinkfloydx33

a=>b=>c=>{foreach(var i in a){if(b[i[0]][i[1]]!=c){return 1<0;}}return 1>0;};

a là các cặp tọa độ, b là danh sách các dòng và c là chuỗi ký tự đơn.

Haskell, 72 63 byte

c [] _ _ =1<2;c ((f,s):t) m n |n/=lines m!!s!!f=1>2|1>0=c t m n

Đầu vào của c [(0,0), (1,0), (3,0)] "#_##\n#_##" '#' đầu ra False

Đầu vào c [(4, 0), (3, 0), (2, 0), (1, 0), (0, 0), (0, 1), (0, 2), (0, 3), (1, 3), (2, 3), (2, 2), (3, 2), (4, 2), (4, 3)] " \n ####\n # \n # " ' '

Đầu ra True

Vô duyên

checkfunc :: [(Int,Int)] -> String -> Char -> Bool
checkfunc [] _ _ = True
checkfunc (x:xs) string char | char /= ((lines string)!!(snd x))!!(fst x)= False  -- Checks first coordinates and returns False if no match
                             | otherwise = checkfunc xs string char --Otherwise iterate over remaining coordinate pairs

Scala, 68 byte

def f(l:(Int,Int)*)(s:String*)(c:Char)=l forall{x=>s(x._2)(x._1)==c}

Clojure, 39 byte

#(apply = %3(map(fn[[x y]]((%2 y)x))%))

Ví dụ (đầu vào chuỗi là vec của vec ký tự):

(def f #(apply = %3(map(fn[[x y]]((%2 y)x))%)))
(f [[0 0] [1 1] [3 0]] (mapv vec ["#_##" "#_##"]) \#)