मैच उनके मूल्यों के साथ समन्वय करता है

Question

3 इनपुट आइटम को देखते हुए, समन्वित जोड़े, एक 2 डी स्ट्रिंग और एक एकल-वर्ण स्ट्रिंग की एक सूची, आउटपुट कि क्या 2 डी स्ट्रिंग के प्रत्येक समन्वय पर चरित्र एकल चरित्र के बराबर है। आप किसी भी क्रम में इनपुट ले सकते हैं और निर्देशांक 1-अनुक्रमित हो सकते हैं।

आप 2D स्ट्रिंग को 2D सूची, लाइनों की सूची या 2D स्ट्रिंग के रूप में ले सकते हैं।

उदाहरण: (0,0), "#_\n__", "#" -> True

तार है

#_
__

समन्वित (0,0)(ऊपर बाईं ओर से) चार है #। यह तीसरे इनपुट आइटम के बराबर है #, इसलिए आप आउटपुट True(या कोई भी सत्य मूल्य)

उदाहरण: [(0,0), (1,1)], "#_\n_#", "#" -> True

तार है

#_
_#

के निर्देशांक पर वर्ण (0,0)और (1,1)दोनों हैं #, इसलिए आउटपुट सत्य है।

आउटपुट केवल सही है अगर हर निर्देशांक एक हैश से मेल खाता है। हालांकि हर हैश का मिलान समन्वय नहीं होना चाहिए। यदि #2 डी स्ट्रिंग में सिंगल चार ( कुछ परीक्षण मामलों में) की घटनाएं नहीं होती हैं , तो आउटपुट अभी भी मिथ्या है।

आप मान सकते हैं कि निर्देशांक हमेशा 2 डी स्ट्रिंग की सीमा के भीतर होंगे।

अधिक परीक्षण के मामले: (मैंने पठनीयता में आसानी के लिए एकल चार सेकंड डाला)

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

ध्यान दें कि आखिरी टेस्ट केस रिक्त स्थान को सिंगल चार स्ट्रिंग के रूप में उपयोग करता है, और रिक्त स्थान के आसपास हैश करता है।

सम्बंधित। (इस चुनौती का उलटा)

Comments

क्या हम मान सकते हैं कि इनपुट "\ n" के बजाय 2d सरणी है?

— rahnema1

@ rahnema1 एक 2 डी सरणी नहीं है, लेकिन एक सरणी / लाइनों की सूची हाँ।

— R

@EasterlyIrk मुझे विश्वास है कि यह बोझिल I / O प्रारूपों

— JungHwan Min

आपके पहले उदाहरण में निर्देशांक प्रारूप (row, column) में हैं, लेकिन अंतिम उदाहरण में निर्देशांक प्रारूप में हैं (column, row)।

— rahnema1

क्या निर्देशांक 1-अनुक्रमित हो सकते हैं?

— user41805

Answer 1

दिल्लोग एपीएल , 8 बाइट्स

समन्वित जोड़े (पंक्ति, स्तंभ) की सूची के लिए संकेत, फिर 2 डी सरणी, फिर चरित्र।

∧/⎕=⎕[⎕]

[⎕] निर्देशांक के लिए संकेत और उन्हें तितर बितर करने के लिए उपयोग करें

⎕ संकेतित इनपुट (2D सरणी)

= चयनित तत्वों की तुलना करें

⎕ इनपुट (चरित्र)

∧/ जांचें कि क्या सभी सत्य हैं (और कमी)

परीक्षण के मामले ( ⎕IO←0उदाहरणों के मिलान के लिए, लेकिन यह आवश्यक नहीं है):

पहला उदाहरण

दूसरा उदाहरण

तीसरा उदाहरण

चौथा उदाहरण

पाँचवाँ उदाहरण

Answer 2

पायथन, 39 बाइट्स

इनपुट्स लेता है:

1. a(x, y)पूर्णांक निर्देशांक की सूची
2. b तार की सूची
3. c एकल चरित्र स्ट्रिंग

---

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

Comments

इस साइट पर, आपको अपने कार्यों को नाम देने की आवश्यकता नहीं है। आप निकाल सकते हैं f=। PPCG में आपका स्वागत है!

— R

PPCG में आपका स्वागत है, अच्छा पहला जवाब!

— FlipTack

Answer 3

जावास्क्रिप्ट (ईएस 6), 37 बाइट्स

इनपुट्स लेता है:

1. a[x, y]पूर्णांक निर्देशांक की सरणी
2. s तार की सरणी
3. c एकल चरित्र स्ट्रिंग

---

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

Answer 4

ऑक्टेव, 45 38 29 बाइट्स

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

एक फ़ंक्शन जो वर्णों के 2 डी सरणी लेता है Aऔर ( Bदो आधारित) के रूप में समन्वय करता है ( दो आधारित) मैट्रिक्स के दो कॉलम के रूप में [col row]और मिलान वर्ण C। दो तत्व निर्देशांक (मैट्रिक्स गुणा का उपयोग करते हुए) रैखिक सूचकांक में परिवर्तित हो जाते हैं।

नोट: पिछला उत्तर जो विरल मैट्रिक्स का उपयोग करता था वह गलत था।

अन्य योगदानकर्ता:

5 बाइट्स को बचाने के लिए स्टेवी ग्रिफ़िन ने ध्यान दिया कि [0 1 0] को गलत मूल्य माना जा सकता है !!

लुइस मेंडू 2 बाइट्स बचाने के लिए ~0 == trueऔर विरल मैट्रिक्स के बारे में सूचना देता है।

इसे ऑनलाइन आज़माएं

Comments

नाइस :) आप allतीन बाइट्स को छोड़ और बचा सकते हैं । 1 1 1सच है, और 1 0 1ऑक्टेव में गलत है, इसलिए यह ठीक होना चाहिए। :)

— स्टीवी ग्रिफिन

महान दृष्टिकोण! मुझे यह पसंद है कि यह कैसे इस तथ्य का फायदा उठाता है कि तार्किक सूचकांकों को अनुक्रमित सरणी के समान आकार की आवश्यकता नहीं है

— लुइस मेंडो

Stewie के सुझाव के अलावा, आप बदल सकते हैं trueद्वारा ~0करने के लिए सेव 2 बाइट्स

— लुइस Mendo

@StewieGriffin धन्यवाद यह वास्तव में ठीक है :)

— rahnema1

@LuisMendo अच्छी बात

— rahnema1

Answer 5

गणितज्ञ, 28 बाइट्स

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

1 अनुक्रमित। Mathematica में सरणियों को कैसे संरचित किया जाता है, इसके कारण इनपुट निर्देशांकों को उलट करना चाहिए (अर्थात (row, column))

प्रयोग

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

True

Answer 6

हास्केल, 27 बाइट्स

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

प्रयोग उदाहरण: ( ["#_##","#_##"] ! '#' ) [(0,0), (2,1), (3,0)]-> True।

Answer 7

जेली , 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.

Answer 8

पर्ल 6 , 41 40 बाइट्स

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

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

एक 2 डी सूची के रूप में 2 डी स्ट्रिंग की उम्मीद है।

-1 बाइट के लिए b2gills का धन्यवाद।

Comments

यदि आप के $_बजाय \cआप का उपयोग .map:{…}एक बाइट की बचत का उपयोग कर सकते हैं

— ब्रैड गिल्बर्ट b2gills

@ BradGilbertb2gills: ओह, मुझे महसूस नहीं हुआ कि अंतरिक्ष वैकल्पिक था .map: {…}। यह जानना उपयोगी है। इसके अलावा, यह एक शर्म की बात है कि उपसर्ग ||अभी तक लागू नहीं किया गया है, यह आंतरिक n eq h[||$_]

— लैंबडा को

Answer 9

सी #, 80 77 बाइट्स

सहेजे गए 3 बाइट्स, Pinkfloydx33 के लिए धन्यवाद

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

a, निर्देशांक के जोड़े हैं, b लाइनों की सूची है, और c एकल-वर्ण स्ट्रिंग है।

Comments

आप बदल सकते हैं falseके साथ 1<0और trueसाथ 1>0और 3 बाइट्स सहेजें।

— Pinkfloydx33

Answer 10

हास्केल, 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

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

Comments

अभी भी अनावश्यक c[]_ _=1<2;c((f,s):t)m n|n/=lines m!!s!!f=1>2|1>0=c t m n

— व्हाट्सएप

जैसा कि आप बूलियन तर्क कर रहे हैं, अंतर्निहित सशर्त if n/=lines m!!s!!f then False else c t m nको प्रतिस्थापित किया जा सकता है n/=lines m!!s!!f&&c t m n।

— लैकोनी

अंत में, जैसा कि ओपी कहता है कि You may take the 2D string as a 2D list, a list of lines, or a 2D string.आप ड्रॉप कर सकते हैं linesऔर सीधे इनपुट के रूप में लाइनों की एक सूची ले सकते हैं।

— लकोनी

Answer 11

स्काला, 68 बाइट्स

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

Answer 12

क्लोजर, 39 बाइट्स

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

उदाहरण (स्ट्रिंग इनपुट वर्णों का एक प्रकार है):

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