एक बिसात बच गई

आप अपने आप को एक शतरंज की बिसात पर पाते हैं, जैसा कि एक करता है। आप बाहर निकल कर देख सकते हैं लेकिन यह बहुत दूर है और आप पूरे रास्ते नहीं चलेंगे। सौभाग्य से कुछ स्थानीय लोगों ने आपको एक सवारी की पेशकश की है। एक नाइट, एक रूक, एक बिशप और एक राजा, सभी आपको अपनी मंजिल तक ले जाने के लिए तैयार हैं, लेकिन यह देखते हुए कि यह एक शतरंज की बिसात है, जो आपके गंतव्य के रास्ते पर शतरंज के नियमों का पालन करना चाहिए। आप जल्द से जल्द यहां से निकलना चाहेंगे, किसकी पेशकश स्वीकार करते हैं?

कार्य

मनमाने ढंग से आकार और आकार में शतरंज की बिसात और शतरंज के बोर्ड पर दो बिंदुओं को देखते हुए, शतरंज के टुकड़े को आउटपुट करें जो दो स्थानों के बीच संभव के रूप में कुछ चालों में आगे बढ़ सकता है। बोर्ड जरूरी नहीं होगा कि बोर्ड के वर्गों के बीच अंतराल हो। चार टुकड़ों में से प्रत्येक (राजा, रूक, नाइट और बिशप) शतरंज में अपने मानक नियमों के अनुसार आगे बढ़ सकते हैं। रानी और मोहरे के टुकड़े जानबूझकर इस चुनौती से बचे हैं।

आई / ओ

आप किसी भी उचित प्रारूप में इनपुट ले सकते हैं और आप जो भी प्रारूप चुनते हैं उसमें भी आउटपुट कर सकते हैं। आपका इनपुट और आउटपुट आत्मनिर्भर होना चाहिए। यदि एकाधिक टुकड़े एक ही संख्या में चलकर गंतव्य तक पहुँच सकते हैं, तो आपको उन सभी टुकड़ों का उत्पादन करना होगा जो न्यूनतम समय में वहाँ पहुँच सकते हैं। यदि चार टुकड़ों में से कोई भी इसे अंत तक नहीं बना सकता है तो आप कुछ भी आउटपुट कर सकते हैं जब तक कि यह अन्य सभी संभावित आउटपुट से अलग हो। इसमें कुछ भी आउटपुट नहीं किया जा सकता है या कोई त्रुटि नहीं हो सकती है।

परीक्षण के मामलों

एक वर्ग प्रारंभिक बिंदु को इंगित करता है और एक चक्र समाप्ति बिंदु को इंगित करता है।

बिशप

शूरवीर

राजा

कौआ

किंग, नाइट

कोई नहीं

code-golf chess

— गेहूं का जादूगर
स्रोत

अच्छा लगा। मुझे यह पसंद है लेकिन एक एकल इकाई के रूप में "मनमाने ढंग से आकार और आकार की बिसात" नहीं है? मैं वास्तव में नहीं देखता कि कैसे उदाहरण 2 और 6 इस के साथ फिट होते हैं क्योंकि ऐसा लगता है कि वे दो अलग-अलग बोर्ड हैं जो केवल नाइट के बीच कूद सकते हैं। हो सकता है कि मुझसे कुछ छूट रहा हो?

— एलपेड्रो

@ElPedro वे अभी भी एक एकल बोर्ड हैं, यह सिर्फ एक निरंतर बोर्ड नहीं है। मनमाने आकार का हिस्सा यह है कि बोर्ड गैर-निरंतर हो सकते हैं।

— गेहूं जादूगर

उदाहरण 3 के लिए, क्या यह "राजा, रानी" नहीं होना चाहिए?

— क्रिकटी लिथोस

शुक्रिया @Wheat। निश्चित नहीं है कि प्रश्न से स्पष्ट था, लेकिन मैं अब समझता हूं।

— एलपेड्रो

@KritiiLithos चीजों को दिलचस्प रखने के लिए कोई रानी या प्यादा नहीं है।

— गेहूं जादूगर

जवाबों:

हास्केल , 447 439 437 432 बाइट्स

t=[1,2]
p=[(+),(-)]
f=filter
a=abs
(#)=elem
x?y=[min x y..max x y]
f&g=(\x->g x>>=f)
(b!1)(c,r)=f(#b)[(c!d,r#s)|(!)<-p,(#)<-p,d<-t,s<-t,d/=s]
(b!2)(c,r)=f(\(d,s)->(c==d&&all(#b)[(c,z)|z<-r?s])||r==s&&all(#b)[(z,r)|z<-c?d])b
(b!3)(c,r)=f(\(d,s)->a(c-d)==a(r-s)&&all(#b)(zip(c?d)$r?s))b
(b!4)(c,r)=f(\(d,s)->a(c-d)<2&&a(r-s)<2)b
(b%p)n s=[s]>>=foldr(&)(:[])(replicate n$b!p)
g b s e=head$f(not.null)[[p|p<-[1..4],e#(b%p)n s]|n<-[0..]]

g <board> <start> <end>जहां <board> :: [(Int, Int)], <start> :: (Int, Int)और , का उपयोग करके कॉल करें <end> :: (Int, Int)। 1नाइट के लिए, 2रूक के लिए, 3बिशप के 4लिए और राजा के लिए एक सूची देता है । यदि कोई समाधान नहीं मिलता है, तो यह लगातार स्टैक को ओवरफ्लो करता है (जो कि त्रुटि को फेंकने के रूप में गिना जाता है, सही?)।

मोनाड्स पर LYAH के अध्यायों से ली गई प्रेरणा - (%)केवल एक सामान्यीकृत और गोल्फ वाली है inMany, जिसके (&)समकक्ष है (Control.Monad.<=<)। बाकी सब कुछ कमोबेश स्व-व्याख्यात्मक होना चाहिए।

यह शायद बहुत अधिक गोल्फ हो सकता है, लेकिन मैंने अभी के लिए पर्याप्त मज़ा लिया है।

Ungolfed:

data Piece = Knight | Rook | Bishop | King deriving (Show)
type Place = (Int, Int)
type Board = [Place]

x `to` y = [min x y..max x y]

f <=< g = (\x -> g x >>= f)

moves
    :: Board    -- available spaces
    -> Piece    -- type of piece
    -> Place    -- starting place
    -> [Place]  -- places available in one move
moves b Knight (c,r) =
    filter (`elem` b) [(c!d, r#s) |
                       (!) <- [(+),(-)], (#) <- [(+),(-)],
                       d <- [1,2], s <- [1,2], d/=s]
moves b Rook   (c,r) =
    filter (\(d,s) -> (c == d && all (`elem` b) [(c,z) | z <- r `to` s])
                    || r == s && all (`elem` b) [(z,r) | z <- c `to` d]) b
moves b Bishop (c,r) =
    filter (\(d,s) -> abs(c-d) == abs(r-s)
                && all (`elem` b) (zip (c `to` d) (r `to` s))) b
moves b King   (c,r) =
    filter (\(d,s) -> abs(c-d) <= 1 && abs(r-s) <= 1) b

canGoIn
    :: Board    -- available spaces
    -> Piece    -- type of piece
    -> Int      -- number of moves
    -> Place    -- starting place
    -> [Place]  -- places available in the specified number of moves
canGoIn b p n s =
    return s >>= foldr (<=<) return (replicate n (moves b p))

quickestPieces
    :: Board    -- available spaces
    -> Place    -- starting place
    -> Place    -- ending place
    -> [Piece]  -- quickest pieces
quickestPieces b s e =
        head $ filter (not.null)
            [[p | p <- [Knight, Rook, Bishop, King], elem e (canGoIn b p n s)] |
                n<-[0..]]

— जूलियन वुल्फ
स्रोत

कार्यात्मक प्रोग्रामिंग का अच्छा उपयोग!

— गेहूं जादूगर

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

एक बाइट बचत को इंगित करने के लिए masterX224 के लिए धन्यवाद!

f[g_,w_,x_]:=(c={{1,1},{-1,1}};s=c.c/2;e=#<->#2&@@@#&;j=Join;h=FindShortestPath;t=#~Tuples~2&;a@d_:=e@Select[t@g,#-#2&@@#==d&];y@k=j@@(a/@j[s,c]);y@n=j@@(a/@{{1,2},{2,1},{-2,1},{-1,2}});v=Flatten[e@t@#&/@ConnectedComponents@a@#&/@#]&;y@r=v@s;y@b=v@c;Pick[p={b,k,n,r},z=Length[h[y@#,w,x]/.h@__->0]&/@p,Min[z~Complement~{0}]]);

एक समारोह को परिभाषित करता है fतीन तर्कों लेने: gबोर्ड का प्रतिनिधित्व पूर्णांकों का आदेश दिया जोड़े की एक सूची है, और wऔर xआरंभ और अंत वर्गों का प्रतिनिधित्व जोड़े का आदेश दिया। आउटपुट {b, k, n, r}क्रमशः (बिशप, किंग, नाइट और रॉक का प्रतिनिधित्व) का सबसेट है , जिसमें दो वर्गों के बीच न्यूनतम चाल है। उदाहरण के लिए, तीसरे परीक्षण के मामले को f[{{0, 0}, {1, 1}, {1, 2}, {0, 3}}, {0, 0}, {0, 3}]रिटर्न और रिटर्न द्वारा लागू किया जाता है {k}; पिछले दो टेस्ट केस वापसी {k, n}और {}क्रमश:।

रणनीति बोर्ड के वर्गों को एक ग्राफ के कोने में अनुवाद करना है, जहां किनारों को प्रत्येक टुकड़े की चाल से निर्धारित किया जाता है, और फिर अंतर्निहित ग्राफ़ दिनचर्या का उपयोग करते हैं।

कोड का अधिक उपयोगकर्ता के अनुकूल संस्करण:

 1  f[g_, w_, x_] := ( c = {{1, 1}, {-1, 1}}; s = c.c/2;
 2    e = # <-> #2 & @@@ # &; j = Join; h = FindShortestPath; t = #~Tuples~2 &; 
 3    a@d_ := e@Select[t@g, # - #2 & @@ # == d &]; 
 4    y@k = j @@ (a /@ j[s, c]); 
 5    y@n = j @@ (a /@ {{1, 2}, {2, 1}, {-2, 1}, {-1, 2}}); 
 6    v = Flatten[e@t@# & /@
 7         ConnectedComponents@a@# & /@ #] &;
 8    y@r = v@s; y@b = v@c; 
 9    Pick[p = {b, k, n, r}, 
10      z = Length[h[y@#, w, x] /. h@__ -> 0] & /@ p, 
11      Min[z~Complement~{0}]]
12  );

पंक्ति 3 में, Select[g~Tuples~2, # - #2 & @@ # == dउन सभी लंबित जोड़ियों का पता लगाता है जिनका अंतर वेक्टर है d; eफिर इस तरह के प्रत्येक जोड़े को एक अप्रत्यक्ष ग्राफ़ एज में बदल देता है। तो aएक ऐसा फंक्शन है जो सभी वर्टिकल के बीच किनारों को बनाता है जो एक निश्चित वेक्टर द्वारा भिन्न होता है।

यही कारण है, परिभाषित करने के लिए काफी है लाइनों 4 और 5, राजा के ग्राफ में y@k(जो वैक्टर द्वारा उत्पन्न किनारों के मिलन लेता है {1, 1}, {-1, 1}, {0, 1}, और {-1, 0}) और सामंती ग्राफ y@n(जो के साथ एक ही करता है {1, 2}, {2, 1}, {-2, 1}, और {-1, 2})।

पंक्ति 7 में, ConnectedComponents@a@#इन पड़ोसी रेखांकन में से एक लेता है और फिर इसके जुड़े घटकों को ढूंढता है; यह दी गई दिशा में कोने के सभी लाइन खंडों को समूहीकृत करने से मेल खाती है (ताकि एक बदमाश या बिशप को उनके द्वारा एक-एक करके आगे बढ़ना न पड़े)। फिर e@t@#लाइन 6 पर एक ही जुड़े घटक में कोने के प्रत्येक जोड़े के बीच किनारों को रखा जाता है, जो तब Flattenएकल ग्राफ में एड होते हैं । इस प्रकार 8 के माध्यम से 6 पंक्तियाँ बदमाश के ग्राफ y@rऔर बिशप के ग्राफ को परिभाषित करती हैं y@b।

अंत में, 11 के माध्यम से 9 की रेखाएं {b, k, n, r}उस लक्ष्य के तत्वों को चुनती हैं जो दो लक्ष्य कोणों के बीच सबसे छोटा रास्ता बनाते हैं। FindShortestPathयदि कोई त्रुटि त्रुटि ग्राफ में दिखाई नहीं देती है (जो कि कोई किनारा इससे निकलती है तो नहीं होगी), तो हम एक त्रुटि को फेंक देंगे और वापस लौटा देंगे, इसलिए हम इसके बजाय उन मामलों में h@__ -> 0लौटने का उपयोग करते हैं 0। और वैध कोने के बीच के रास्ते की कमी से लंबाई की एक सूची वापस आ जाती है 0, इसलिए Min[z~Complement~{0}]सबसे छोटे पथ की लंबाई की गणना करता है जो वास्तव में मौजूद है, ऊपर के बुरे मामलों की अनदेखी करता है।

— ग्रेग मार्टिन
स्रोत

फ़ंक्शन नाम में डबल च के लिए कोई कारण? या यह एक गणित की सीमा है?

— मास्टरएक्स २४४

ओह, हाहा, नहीं, यह मेरी ओर से एक मानसिक सीमा है :) मेरे पास fउस सत्र में पहले से ही था, लेकिन मुझे इसे प्रस्तुत करने से पहले बदलना चाहिए था!

— ग्रेग मार्टिन