क्या यह शब्द दलदल बोर्ड पर है?

Question

परिचय

एक दिन पीने और विश्व कप देखने के बाद, आप बोगल के अनुकूल खेल खेलने के लिए बैठ जाते हैं। जब आप बोर्ड पर नहीं होते हैं, तो आप सभी के समय को बकवास शब्दों के साथ बर्बाद करने का आरोप लगाते हैं, टेंपरिंग बढ़ जाती है! आप डबल देख रहे होंगे, लेकिन निश्चित रूप से आप सीधे एक प्रोग्राम लिखने के लिए पर्याप्त सोच रहे हैं जो यह सत्यापित करेगा कि आपके शब्द बोर्ड पर हैं।

आपका कार्य

एक प्रोग्राम, स्क्रिप्ट, या फ़ंक्शन लिखें जो एक बोगल बोर्ड और एक शब्द को इनपुट के रूप में लेता है, और सही है अगर शब्द बोर्ड पर है और यदि शब्द नहीं है तो गलत है।

इनपुट छह \nसीमांकित लाइनों के रूप में होगा। पहली पांच पंक्तियों में 5x5 बोगल बोर्ड शामिल होगा और प्रत्येक में पाँच कैपिटल अक्षर होंगे। छठी पंक्ति में शब्द-में-प्रश्न शामिल होगा, सभी बड़े अक्षरों में भी।

नमूना इनपुट:

AJNES
TNFTR
LSAIL
UDNEX
EQGMM
DAFTER

आउटपुट कुछ भी हो सकता है जो स्पष्ट रूप से आपकी पसंद की प्रोग्रामिंग भाषा में True या False को दर्शाता है और शून्य, शून्य और खाली हस्ताक्षर करने वाले False के मानक सम्मेलनों का पालन करता है।

उपरोक्त इनपुट के लिए नमूना आउटपुट:

1

I / O दिशानिर्देश

• इनपुट को स्टडिन से पढ़ा जा सकता है, और आउटपुट को स्टडआउट करने के लिए उत्तर दिया जा सकता है।

या

• इनपुट एक फ़ंक्शन के लिए एक एकल स्ट्रिंग तर्क हो सकता है, और उत्तर उस फ़ंक्शन का रिटर्न मान हो सकता है।

बोगल नियम

• एक शब्द 'बोर्ड पर' है यदि आप बोर्ड पर लगातार, आसन्न, गैर-दोहराई जाने वाली टाइलों के माध्यम से शब्द का निर्माण कर सकते हैं।
• एक टाइल को आठ टाइलों के निकट माना जाता है जो इसे घेरती हैं (विकर्ण पथ की अनुमति है)। बोर्ड के किनारे पर टाइलें केवल पांच टाइलों से सटे हैं। कोने में टाइलें केवल तीन से सटे हैं।
• शब्द में लगातार अक्षरों को आसन्न होना चाहिए, शब्द में iवें अक्षर को i-1वें और i+1वें के समीप होना चाहिए ।
• एक अक्षर एक से अधिक बार एक शब्द में प्रकट हो सकता है, लेकिन आप प्रति शब्द एक से अधिक बार बोगल बोर्ड पर एक ही वर्ग का उपयोग नहीं कर सकते।
• ऑनलाइन बोगल साइट wordplay.net उपयोगी हो सकता है यदि आपने पहले कभी भी दलदल नहीं खेला है, लेकिन इन नियमों के लिए एक महसूस करना चाहते हैं।

नियमित दलदल के विपरीत:

• आपको एक वैध अंग्रेजी शब्द होने के बारे में चिंता करने की ज़रूरत नहीं है।
• कोई Quएकल टाइल नहीं होगी ।
• शब्द-में-प्रश्न किसी भी लम्बाई का हो सकता है> 0

उदाहरण

के बोर्ड में

AJNES
TNFTR
LSAIL
UDNEX
EQGMM

ये शब्द सही होने चाहिए: FATE, DATING, STANDS, LIFTS।

इन शब्दों को गलत लौटना चाहिए: SADDEN, SULTANS, EXIST, SUEDE, QUEST

यह एक कोड-गोल्फ चुनौती है, इसलिए सबसे छोटा कोड जीतता है!

Comments

क्या बोर्ड चारों ओर लपेटता है? मुझे याद नहीं आ

— Claudiu

नहीं, यह लपेटता नहीं है, मैंने इसे प्रतिबिंबित करने के लिए आसन्नता के बारे में स्पष्टीकरण को अपडेट किया।

— टर्बुलेंसेटू

क्या रास्ता खुद को (तिरछे) पार कर सकता है?

— मार्टिन एंडर

@ m.buettner Yep

— टर्बुलेंसेटू

आम तौर पर बोगल एक 4x4 बोर्ड है।

— mbomb007

Answer 1

GolfScript, 74 वर्ण

:^n%5>)]){{^@==}+29,\,{{+}+1$/}%\;}/{:s$..&=[s{.@-\}*;]1567`{7&.~)}%-!&},,

इनपुट STDIN पर दिया जाना चाहिए। बोर्ड पर वैध रास्तों की संख्या को मुद्रित करता है, अर्थात 0कोई भी नहीं और एक सकारात्मक संख्या (सत्य)।

आप ऑनलाइन उदाहरण का परीक्षण कर सकते हैं ।

कुछ टिप्पणियों के साथ कोड:

:^              # assign the input to variable ^
n%              # split at newlines
5>              # truncate array such that [WORD] remains
)])             # prepares [[]] and WORD on the stack

# the following loop generates all possible paths (valid and invalid ones)
# by looking up all index combinations which yield the correct word
{               # loop over all characters
  {^@==}+29,\,  # get all indices of current character in the board
  {{+}+1$/}%\;  # append any index to all lists in the result set
}/              # end loop

# filter the results list for valid paths
{               # {...}, -> apply filter
  :s            # save path to variable s
  $..&=         # check if all numbers in path are unique
  [s{.@-\}*;]   # calculate differences along the path
  1567`{7&.~)}% # generate the array [1 -1 5 -5 6 -6 7 -7] of valid
                # differences
  -!            # check if all differences were valid
  &             # are both conditions fulfilled?
},              # end of filter block

,               # count the number of remaining paths

Answer 2

जावास्क्रिप्ट (E6) 137 160 175 190

2 से कम * गोल्फस्क्रिप्ट। नैतिक जीत ...

F=a=>[...a].some((e,p,b)=>(Q=(p,n)=>p>29||b[p]!=b[n]||(b.r|=!b[++n])||(b[p]=b[n+~[1,5,6,7].map(q=>Q(p+q,n)|Q(p-q,n),b[p]=0)]))(p,30)&b.r)

संपादित गोल्फ कोड पुनर्गठन। बार बार

अंतिम संस्करण को अनगॉल्फ किया गया , जिसका अनुसरण करने के लिए थोड़ा मुश्किल है

F = a => 
  [...a] // input string to array, 30 chars of board then the target word
  .some ( // use some to scan the board, return true when found
      (e,p,b)=> // params to callback: element, position, complete array 
      (         // NB array b has no .r property, so use it for return value (it's undefined at start) 
        Q = (p,n) =>         // Scan function, p=position in board, n=nth char of target word
          p > 29 ||          // Chaek if going outside the board to the target word
          b[p] != b[n] ||    // if invalid char at current position, return
          (b.r |= !b[++n]) ||  // if at end of target, set r to 1 and return (also increment n )
          (                  // else... (NB next tree lines are coalesced in golfed code)
            b[p] = 0,        // remove current char (to avoid reusing) 
            [1,5,6,7].map( q => Q(p+q,n)|Q(p-q,n)), // recursive call for + - 1,5,6,7
            b[p] = b[n-1]    // put current char into array again 
          )
      )(p,30) & b.r // initial position 0 in target word is 30 in the array
  ) 

Ungolfed पहला संस्करण, स्पष्ट होना चाहिए

F = a => (
  b = a.split('\n'),
  w = b.pop(),
  r = 0,
  Q = (p, n) => 
    (r |= !w[n]) || 
    (
      b[p] = 0,
      [1,5,6,7,-1,-5,-6,-7].map( q => b[q+=p]==w[n] && Q(q,n+1)),
      b[p] = w[n-1]
    ),
  b = [...b+''],
  b.map((e, p) => e==w[0] && Q(p,1)),
  r
)

प्रयोग

F("AJNES\nTNFTR\nLSAIL\nUDNEX\nEQGMM\nLIFTS\nDAFTER")

परीक्षा

['DAFTER', 'STANDS', 'LIFTS', 'FATE', 'DATING' ,
 'SADDEN','SULTANS', 'EXIST', 'SUEDE', 'QUEST']
.map(w => [w, F("AJNES\nTNFTR\nLSAIL\nUDNEX\nEQGMM\n" +w)])

आउटपुट:

[["DAFTER", true], ["STANDS", true], ["LIFTS", true], ["FATE", true], ["DATING", true], 
["SADDEN", false], ["SULTANS", false], ["EXIST", false], ["SUEDE", false], ["QUEST", false]]

Comments

कुछ छोटी F=a=>(b=a.split('\n'),w=b.pop(Q=(p,n)=>((R|=!w[n])||(b[p]=0)||[1,5,6,7,-1,-5,-6,-7].map(q=>b[q+=p]==w[n]&&Q(q,n+1,b[q]=w[n])))),[Q(~~p,1)for(p in b=[...b.join(R=0)])if(b[p]==w[0])],R)

— आशाएँ

क्या यह माना जाता है w = a.pop()(गोल्फ) या w = b.pop()(अनगुल्ड, लाइन 2)? (शायद बाद वाला, मुझे लगता है)

— बजे

@androyd मैंने पुनर्गठन के बाद, स्पष्टता के लिए पुराने ungolfed कोड को छोड़ दिया। लेकिन यह सिंक में 100% नहीं है। मैं स्पष्ट करने की कोशिश

— करूंगा

मेरा बुरा, नहीं देखा था आप के लिए इसे बदल a=a.pop()के बजाय b=a.pop()...

— hlt

Answer 3

पायथन, 207 204 203

g=raw_input
r=range
b=''.join(g()for _ in r(5))
w=g()
s=lambda b,w,i:0<=i<25and(not w or(b[i]==w[0])*any(s(b[:i]+'_'+b[i+1:],w[1:],i+j+k*5-6)for j in r(3)for k in r(3)))
print any(s(b,w,i)for i in r(25))

जगह ... (b[i]==w[0])*any ...के साथ ... b[i]==w[0]and any ...2 पात्रों की कीमत पर बेहतर प्रदर्शन देता है।

Comments

जब आप संख्याओं और आदेशों के बीच रिक्त स्थान को शेव कर सकते हैं; 0<=i<25and

— देखिए

Answer 4

जे - 75 चार

Eugh, यह एक बुरा लग रहा है। और गोल्फस्क्रिप्ट के साथ बांधना भी नहीं! यह एक फ़ंक्शन है जो अपने एकमात्र तर्क के रूप में एक स्ट्रिंग ले रहा है। आप किसी भी एक वर्ण परिसीमनक का उपयोग तब तक कर सकते हैं जब तक कि वह अंतिम सहित प्रत्येक पंक्ति के अंत में न मिल जाए।

+/@([:*/"1^:2(2(=*)@-/\>@~.)S:1)@{@(((<@#:i.)5 5)<@#~&,"2{:=/&:>}:)@(<;._2)

एक स्पष्टीकरण इस प्रकार है। ध्यान दें कि फ़ंक्शन को 5 अलग-अलग शीर्ष-स्तरीय भागों में विभाजित किया जा सकता है, प्रत्येक अलग-अलग होते हैं @, इसलिए हम उन हिस्सों में से प्रत्येक को दाएं से बाएं तक अलग-अलग व्यवहार करेंगे।

• (<;._2)- यह newlines / विभाजक पात्रों पर लाइनों को विभाजित करता है। यह स्ट्रिंग के अंत में चरित्र का उपयोग करता है जिस पर चरित्र को विभाजित करना है। हम सब कुछ बक्से में डालते हैं ( <) क्योंकि अगर हमें कुछ पैडिंग मुद्दे नहीं मिलते हैं जब जे हमें परिणाम वापस देता है।

• (((<@#:i.)5 5)<@#~&,"2{:=/&:>}:) - जाँच करने के लिए शब्द में प्रत्येक अक्षर के लिए, बोगल बोर्ड में सूचकांकों की एक सूची बनाएं जहाँ कोई भी उस पत्र को पा सकता है।

  • {:अंतिम स्प्लिट पीस (चेक करने के लिए शब्द) और }:सब कुछ है लेकिन अंतिम (बोगल बोर्ड) है।

  • &:>हमारे द्वारा पहले बनाए गए बॉक्सों को खोलता है, }:पात्रों के 2 डी सरणी में बदलने के उपयोगी उपोत्पाद के साथ । =/तब शब्द में प्रत्येक पत्र के लिए इस बोगल बोर्ड की एक प्रति बनाता है, और पदों के बूलियंस में बदल जाता है, इस पर निर्भर करता है कि क्या बोर्ड ने उस पत्र को शब्द में मेल किया है।

  • ((<@#:i.)5 5)सूचकांकों के 5x5 सरणी को व्यक्त करने का एक छोटा तरीका है। आधार निरूपण की एक सरणी में x#:yपरिवर्तित yहोता है x। (खैर, लगभग। सत्य अधिक जटिल है, लेकिन यह हमारे उद्देश्यों के लिए काम करता है।)

  • <@#~&,"2- प्रत्येक अक्षर के परिणामस्वरूप बूलियन मैट्रिक्स के लिए, सभी समान रूप से सही सूचकांकों को एक साथ इकट्ठा करें। "2सब कुछ सही परिणामों पर काम #~&,करता है, चयन करता है, और <@अगले चरण की तैयारी के लिए प्रत्येक परिणाम को एक बॉक्स में इकट्ठा करता है।

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

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

• ([:*/"1^:2(2(=*)@-/\>@~.)S:1) - यहां हम यह देखने के लिए कि क्या यह वैध है, प्रत्येक पथ की जाँच करें।

  • (...)S:1(...)प्रत्येक पथ पर लागू होता है और एक फ्लैट सूची में परिणाम एकत्र करता है। यह महत्वपूर्ण है क्योंकि परिणाम {एक बहुआयामी सरणी है, और हम उस सरणी की संरचना के बारे में परवाह नहीं करते हैं, बस प्रत्येक बॉक्स में इसकी सामग्री।

  • 2(=*)@-/\>1 देता है यदि प्रत्येक सूचकांक का प्रत्येक समन्वय इसके बाद वाले भाग से अधिकतम एक पर हो, और अन्यथा 0। 2और /\इस जोड़ो में करने के लिए जिम्मेदार हैं।

  • */"1^:2तार्किक-एंड्स इन सभी को एक साथ अंत में। [:भाग जम्मू में एक संरचनात्मक बात है, इसके बारे में चिंता नहीं है।

  • जोड़ने के @~.लिए >वास्तव में दोहराया प्रविष्टियों के साथ रास्तों को बाहर करने का एक चतुर तरीका है। ~.किसी सूची के अनूठे आइटम को लेता है, इसलिए सूची को छोटा कर दिया जाता है यदि यह स्व-प्रतिच्छेदन करता है, और छोटी सूची 0s के साथ स्वचालित रूप से गद्देदार हो जाती है जब उन्हें एक साथ रखा जाता है, जिस तरह से परिणाम संयुक्त होते हैं जैसे वे बाहर आते हैं S:। यह अंतत: स्व-प्रतिच्छेद पथों को स्पष्ट रूप से बाहर रखने से कम है।

• +/- अंत में, हम अंत में सब कुछ एक साथ जोड़ते हैं। परिणाम मान्य पथों की संख्या है जो बोर्ड पर शब्द बनाते हैं, जिसका अर्थ 0 पथ नहीं है, अर्थात यह शब्द बोर्ड पर नहीं है। एक वर्ण की लागत के लिए, हम +./इसके बजाय (तार्किक-सब कुछ एक साथ) लिख सकते हैं , जो स्पष्ट रूप से एक बूलियन 1 या 0 देगा।

यहाँ कुछ उदाहरण रन हैं। आप j दुभाषिया को jsoftware.com पर प्राप्त कर सकते हैं या इसे tryj.tk पर ऑनलाइन आज़मा सकते हैं ।

   NB. the  0 : 0 ... )  thing is how you do multiline strings in J
   +/@([:*/"1^:2(2(=*)@-/\>@~.)S:1)@{@(((<@#:i.)5 5)<@#~&,"2{:=/&:>}:)@(<;._2) 0 : 0
AJNES
TNFTR
LSAIL
UDNEX
EQGMM
DAFTER
)
1
   b =: +/@([:*/"1^:2(2(=*)@-/\>@~.)S:1)@{@(((<@#:i.)5 5)<@#~&,"2{:=/&:>}:)@(<;._2)
   b 'AJNES TNFTR LSAIL UDNEX EQGMM FATE '    NB. any separator will do
1
   b 'AJNES TNFTR LSAIL UDNEX EQGMM SADDEN '  NB. not on the board
0
   b 'AJNES TNFTR LSAIL UDNEX EQGMM SANDS '   NB. self-intersecting path
0
   b 'AJNES TNFTR LSAIL UDNEX EQGMM MEND '    NB. multiple paths
2

Comments

विवरण के लिए +1। मैं इस तरह से अधिक जवाब देखना चाहते हैं!

— edc65

Answer 5

प्रस्तावना - 315

r(L):-get_char(C),(C='\n',!,L=[];r(T),L=[C|T]).
b(0,[]):-!.
b(N,[R|T]):-M is N-1,r(R),b(M,T).
d(-1). d(0). d(1).
d([A,B],[C,D]):-d(X),C is A+X,d(Y),D is B+Y.
f([L|W],B,P,U):-P=[X,Y],nth(Y,B,R),nth(X,R,L),\+member(P,U),(W=[];d(P,Q),f(W,B,Q,[P|U])).
m:-b(5,B),r(W),f(W,B,_,[]),write(t);write(f).
:-initialization(m).

मुझे लगा कि प्रोलॉग इसके लिए एक अच्छी भाषा हो सकती है, बिल्ट-इन बैकट्रैकिंग सपोर्ट के साथ, लेकिन मुझे लगता है कि यह लगभग हर कम्प्यूटेड वैल्यू के लिए वैरिएबल की जरूरत से ज्यादा हैंडिकैप्ड है।

जीएनयू प्रोलॉग के साथ परीक्षण किया गया; आईएसओ प्रोलॉग के अनुरूप होना चाहिए।

Ungolfed:

get_line(Line) :-
    get_char(C),
    (   C='\n', !, Line=[]
    ;   get_line(Tail), Line=[C|Tail]
    ).

% The cut prevents recursion to help_get_board(-1, MoreRows)
% (and golfs one character shorter than putting N>0 in the second rule).
help_get_board(0, []) :- !.
help_get_board(N, [Row|Tail]) :-
    M is N-1, get_line(Row), help_get_board(M, Tail).

% The golfed version doesn't define an equivalent to get_board/1.
% help_get_board(5,Board) is used directly instead.
get_board(Board) :- help_get_board(5,Board).

small(-1). small(0). small(1).
step([X1,Y1],[X2,Y2]) :-
    small(DX), X2 is X1+DX,
    small(DY), Y2 is Y1+DY.

% The golfed version doesn't define an equivalent to letter_at/3.
% See find_word/4.
letter_at([X,Y], Letter, Board) :-
    nth(Y, Board, Row),
    nth(X, Row, Letter).

find_word([Letter|Word], Board, Pos1, Used) :-
%    letter_at(Pos1, Letter, Board),  % "inlined" to next three lines:
    ( Pos1 = [X,Y],
      nth(Y, Board, Row),
      nth(X, Row, Letter) ),
    \+member(Pos1, Used),
    (   Word=[]
    ;
        step(Pos1, Pos2),
        find_word(Word, Board, Pos2, [Pos1|Used])
    ).

main :-
    get_board(Board),
    get_line(Word),
    % Begin at any position. Initially no positions are "Used".
    find_word(Word, Board, _, []).