给定3个输入项，一个坐标对列表，一个2D字符串和一个单字符字符串，输出2D字符串的每个坐标处的字符是否等于单个字符。您可以按任何顺序输入，并且坐标可以为1索引。

您可以将2D字符串作为2D列表，线列表或2D字符串。

例： (0,0), "#_\n__", "#" -> True

字符串是

#_
__

坐标处(0,0)（从左上角开始）的字符是#。这等于第三个输入项#，因此您输出True（或任何真实值）

例： [(0,0), (1,1)], "#_\n_#", "#" -> True

字符串是

#_
_#

(0,0)和坐标处的字符(1,1)均为#，因此输出为true。

仅当每个坐标都匹配哈希时，输出才为true。但是，并非每个哈希都必须具有匹配的坐标。如果#在2D字符串中没有出现单个字符（在某些测试用例中），则输出仍然是虚假的。

您可以假设坐标将始终在2D字符串的范围内。

更多测试用例：（为了便于阅读，我将单个字符放在第二位）

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

请注意，最后一个测试用例使用空格作为单个char字符串，并在空格周围散列。

有关。（与此挑战相反）

Dyalog APL，8 字节

提示输入坐标对（行，列）的列表，然后是2D数组，然后是字符。

∧/⎕=⎕[⎕]

[⎕] 提示输入坐标，并使用它们分散从中挑选

⎕ 提示输入（二维数组）

= 比较所选元素

⎕ 输入（字符）

∧/ 检查是否都正确（AND减法）

测试用例（⎕IO←0与示例匹配，但这不是必需的）：

第一个例子

第二个例子

第三个例子

第四个例子

第五例

Python，39个字节

接受输入：

1. a(x, y)整数坐标列表
2. b 字符串列表
3. c 单个字符串

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

JavaScript（ES6），37个字节

接受输入：

1. a 的数组 [x, y]整数坐标
2. s 字符串数组
3. c 单个字符串

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

八度，45 38 29字节

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

该函数将char的2D数组作为A和坐标（基于0）B作为的两列矩阵，[col row]而匹配字符作为C。将两个元素的坐标（使用矩阵乘法）转换为线性索引。

注意：先前使用稀疏矩阵的答案是错误的。

其他贡献者：

斯蒂夫·格里芬保存了5个字节，并指出[0 1 0]可以视为错误值！

路易斯·门多（Luis Mendo）保存了2个字节，~0 == true并通知了稀疏矩阵。

在线尝试

Mathematica，28个字节

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

1个索引。由于Mathematica中数组的结构方式，输入坐标必须反转（即(row, column)）

用法

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

True

Haskell，27个字节

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

用法示例：( ["#_##","#_##"] ! '#' ) [(0,0), (2,1), (3,0)]-> True。

果冻，10字节

ịṪ⁸ịḢð€Q⁼⁵

这仅作为完整程序工作。输入顺序为索引，字符串数组，单例字符串。

在线尝试！

怎么运行的

ịṪ⁸ịḢð€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个字节

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

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

期望将2D字符串作为2D列表。

感谢b2gills -1个字节。

C＃，80 77字节

由于pinkfloydx33，节省了3个字节

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

a是坐标对，b是行列表，c是单字符字符串。

Haskell，72 63字节

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

输入 c [(0,0), (1,0), (3,0)] "#_##\n#_##" '#' 输出 False

输入值 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 # " ' '

输出量 True

松散

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个字节

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

Clojure，39个字节

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

示例（字符串输入是字符vec的vec）：

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