Dati 3 elementi di input, un elenco di coppie di coordinate, una stringa 2D e una stringa a carattere singolo, indica se il carattere in corrispondenza di ciascuna coordinata della stringa 2D è uguale al singolo carattere. Puoi prendere l'input in qualsiasi ordine e le coordinate possono essere 1-indicizzate.

È possibile prendere la stringa 2D come un elenco 2D, un elenco di linee o una stringa 2D.

Esempio: (0,0), "#_\n__", "#" -> True

La stringa è

#_
__

Il carattere alla coordinata (0,0)(in alto a sinistra) è #. Ciò equivale al terzo elemento di input #, quindi l'output True(o qualsiasi valore true)

Esempio: [(0,0), (1,1)], "#_\n_#", "#" -> True

La stringa è

#_
_#

I caratteri alle coordinate di (0,0)e (1,1)sono entrambi #, quindi l'output è vero.

L'output è vero solo se ogni coordinata corrisponde a un hash. Tuttavia, non tutti gli hash devono avere una coordinata corrispondente. Se non ci sono occorrenze del singolo carattere ( #in alcuni dei casi di test) nella stringa 2D, l'output è ancora errato.

Puoi presumere che le coordinate rimarranno sempre entro i limiti della stringa 2D.

Altri casi di test: (metto il secondo carattere singolo per facilità di leggibilità)

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

Si noti che l'ultimo caso di test utilizza gli spazi come singola stringa di caratteri e hash attorno agli spazi.

Relazionato. (inverso di questa sfida)

Dyalog APL , 8 byte

Richiede un elenco di coppie di coordinate (riga, colonna), quindi matrice 2D, quindi carattere.

∧/⎕=⎕[⎕]

[⎕] richiedere le coordinate e usarle per spargere il pick da

⎕ input richiesto (array 2D)

= confronta gli elementi selezionati con

⎕ input (il personaggio)

∧/ controlla se tutti sono veri (riduzione AND)

Casi di test ( ⎕IO←0per abbinare esempi, ma questo non è necessario):

Primo esempio

Secondo esempio

Terzo esempio

Quarto esempio

Quinto esempio

Python, 39 byte

Prende gli input:

1. aelenco di (x, y)coordinate intere
2. b elenco di stringhe
3. c stringa di caratteri singoli

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

JavaScript (ES6), 37 byte

Prende gli input:

1. amatrice di [x, y]coordinate intere
2. s matrice di stringhe
3. c stringa di caratteri singoli

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

Ottava, 45 38 29 byte

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

Una funzione che accetta una matrice 2D di caratteri come Ae coordinate (in base 0) Bcome una matrice a due colonne [col row]e il carattere corrispondente come C. Le coordinate di due elementi (utilizzando la moltiplicazione della matrice) convertite in indice lineare.

Nota: la risposta precedente che utilizzava la matrice sparsa era errata.

Altri collaboratori:

Stewie Griffin per aver salvato 5 byte rilevando che [0 1 0] può essere considerato un valore falso !!

Luis Mendo per aver salvato 2 byte ~0 == truee notifica della matrice sparsa.

Provalo online

Mathematica, 28 byte

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

1-indicizzati. A causa di come sono strutturate le matrici in Mathematica, le coordinate di input devono essere invertite (es. (row, column))

uso

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

True

Haskell, 27 byte

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

Esempio di utilizzo: ( ["#_##","#_##"] ! '#' ) [(0,0), (2,1), (3,0)]-> True.

Gelatina , 10 byte

ịṪ⁸ịḢð€Q⁼⁵

Funziona solo come un programma completo. L'ordine di input è indici, array di stringhe, stringa singleton.

Provalo online!

Come funziona

ịṪ⁸ịḢð€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]]}}

Si aspetta che la stringa 2D sia un elenco 2D.

Grazie a b2gills per -1 byte.

C #, 80 77 byte

Salvato 3 byte, grazie a pinkfloydx33

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

a è la coppia di coordinate, b è l'elenco di linee e c è la stringa a carattere singolo.

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

Ingresso di c [(0,0), (1,0), (3,0)] "#_##\n#_##" '#' uscite False

Ingresso 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 # " ' '

Produzione True

UnGolfed

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))%))

Esempio (l'input della stringa è un vec di vec di caratteri):

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