शब्द खोज पहेली

29

शब्द खोज पहेली और खोज स्ट्रिंग के रूप में एक आयताकार पाठ को देखते हुए, यह निर्धारित करें कि क्या पाठ में खोज स्ट्रिंग शामिल है। खोज स्ट्रिंग दिखाई दे सकती है:

  • क्षैतिज, लंबवत या तिरछे
  • आगे या पीछे

आप एक फ़ंक्शन या प्रोग्राम लिख सकते हैं और फ़ंक्शन तर्क, ARGV या STDIN के माध्यम से इनपुट के रूप में दो तार ले सकते हैं। आउटपुट एक सत्य या गलत परिणाम होना चाहिए जिसे या तो फ़ंक्शन से वापस किया जा सकता है या STDOUT को लिखा जा सकता है।

मान लें कि पाठ में मनमाने ढंग से मुद्रण योग्य ASCII वर्ण (हेक्स कोड 20 से 7E) और लाइन ब्रेक वर्ण होंगे। पत्र मामला संवेदनशील हैं। आप मान सकते हैं कि इनपुट टेक्स्ट आयताकार है, अर्थात सभी लाइनों की लंबाई समान है। हो सकता है कि इनपुट एक अनुगामी न्यूलाइन के साथ समाप्त हो या नहीं (यदि यह आपके सबमिशन के लिए मायने रखता है)।

यह कोड गोल्फ है, सबसे छोटा उत्तर (बाइट्स में) जीतता है।

उदाहरण

विकिपीडिया के लेख से इस ग्रिड का उपयोग शब्द इनपुट पर पहले इनपुट के रूप में करता है:

WVERTICALL
ROOAFFLSAB
ACRILIATOA
NDODKONWDC
DRKESOODDK
OEEPZEGLIW
MSIIHOAERA
ALRKRRIRER
KODIDEDRCD
HELWSLEUTH

निम्नलिखित खोज के तार क्रमशः सत्य या गलत परिणाम देने चाहिए:

Truthy: RANDOM, VERTICAL, HORIZONTAL, WORDSEARCH, WIKIPEDIA, TAIL
Falsy:  WordSearch, CODEGOLF, UNICORN

वैकल्पिक रूप से, इस इनपुट पाठ का उपयोग करते हुए

Lorem ipsum dolor sit amet consectetu
r adipisicing elit sed do eiusmod tem
por incididunt ut labore et dolore ma
gna aliqua. Ut enim ad minim veniam, 
quis nostrud exercitation ullamco lab
oris nisi ut aliquip ex ea commodo co
nsequat. Duis aute irure dolor in rep
rehenderit in voluptate velit esse ci
llum dolore eu fugiat nulla pariatur.

हमें निम्नलिखित खोज परिणाम मिलते हैं (अब उद्धरणों का उपयोग करते हुए, क्योंकि कुछ खोज स्ट्रिंग्स में स्थान हैं):

Truthy: "Lorem", "mine", "uma bop", "tuetdod", "snol,a", "texas", "pii.d  v", "vexta"
Falsy:  "lorem", "wordsearch", "pii.d v", "mute"
code-golf  string  decision-problem  word-search 
— मार्टिन एंडर
स्रोत
2
— edc65

जवाबों:

7

CJam, 46 37 बाइट्स

qN%{_zW%__,N**2$2$+,)/z\}4*]:+N*eas#)

एसटीडीआईएन से ग्रिड और शब्द को कमांड-लाइन तर्क के रूप में पढ़ता है। मैचों के लिए सकारात्मक पूर्णांक और गैर-मैचों के लिए 0 प्रिंट करता है।

दो अतिरिक्त बाइट्स की कीमत पर, दोनों तार (शब्द, लाइनफीड, ग्रिड) STDIN से पढ़े जा सकते हैं:

qN%(\{_zW%__,N**2$2$+,)/z\}4*](\:+N*\#)

आप इस संस्करण को CJam दुभाषिया के साथ ऑनलाइन आज़मा सकते हैं ।

उदाहरण चलाते हैं

$ for W in Lorem mine uma\ bop tuetdod snol,a texas pii.d\ \ v vexta WordSearch CODEGOLF UNICORN; do echo -e "$(cjam wordsearch.cjam "$W" < grid)\t$W"; done
1       Lorem
3085    mine
2055    uma bop
5142    tuetdod
3878    snol,a
1426    texas
5371    pii.d  v
2536    vexta
0       WordSearch
0       CODEGOLF
0       UNICORN

पृष्ठभूमि

मान लें कि इनपुट निम्न ग्रिड था:

ABCD
EFGH
IJKL

लाइनफ़ीड में विभाजित होने पर, हम निम्नलिखित सरणी प्राप्त करते हैं:

A := [
         "ABCD"
         "EFGH"
         "IJKL"
     ]

इसमें पूर्व शब्द (बाएं से दाएं जाने वाले शब्द) शामिल हैं।

अब, हम विभाजक के रूप Aमें len(A)लाइनफ़ीड की एक स्ट्रिंग का उपयोग करने के तत्वों में शामिल होते हैं :

"ABCD⏎⏎⏎EFGH⏎⏎⏎IJKL"

फिर, हम परिणामस्वरूप स्ट्रिंग को लंबाई के टुकड़ों में काटते हैं len(A) + len(A[0]) + 1:

[
    "ABCD⏎⏎⏎E"
    "FGH⏎⏎⏎IJ"
    "KL"
]

यदि हम सरणी को "ज़िप" करते हैं (पंक्तियों और स्तंभों को स्थानांतरित करें), तो हम प्राप्त करते हैं:

[
    "AFK"
    "BGL"
    "CH"
    "D⏎"
    "⏎⏎"
    "⏎⏎"
    "I⏎"
    "EJ"
]

इसमें दक्षिण पूर्व के शब्द शामिल हैं।

यदि हम A को ज़िप करते हैं और परिणाम की पंक्तियों के क्रम को उलट देते हैं, तो हम प्राप्त करते हैं:

[
    "DHL"
    "CGK"
    "BFJ"
    "AEI"
]

कि दक्षिण और - विकर्णों के लिए प्रक्रिया को दोहराने के बाद - दक्षिण पश्चिम शब्द शामिल हैं।

फिर से भरना और उलटना, हम प्राप्त करते हैं:

[
    "LKJI"
    "HGFE"
    "DCBA"
]

यह पश्चिम को शामिल करता है और - विकर्णों के लिए प्रक्रिया को दोहराने के बाद - उत्तर पश्चिम शब्द।

एक बार फिर से पलट कर देखना, हमें प्राप्त होता है:

[
    "IEA"
    "JFB"
    "KGC"
    "LHD"
]

यह उत्तर को कवर करता है और - विकर्णों के लिए प्रक्रिया को दोहराने के बाद - उत्तर पूर्व शब्द।

यह काम किस प्रकार करता है

कोड पिछले अनुभाग में दो मामूली अंतरों के साथ समझाया गया है:

  • यह बहुत शुरुआत में एक बार ज़िप करता है और पलटता है।
  • यह गणना len(A) + len(A[0])करता है len(A + zip(A))।

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

qN%                                   " A := split(input(),'\n')                          ";
   {                    }4*           " Do 4 times:                                       ";
    _zW%                              "   B := reverse(zip(A))                            ";
        __,N**                        "   C := B.join(len(B) * '\n')                      ";
              2$2$+,)/z               "   D := zip(C.chunks(len(A + B) + 1))              ";
                       \              "   A := B                                          ";
                           ]          " Collect all values of A and D in an array R.      ";
                            :+        " R := flatten(R)                                   ";
                              N*      " R := R.join('\n')                                 ";
                                eas   " I := flatten(ARGV)                                ";
                                   #) " print R.index(I) + 1                              ";
— डेनिस
स्रोत
7

जावा: 183 211 321

boolean s(char[]w,char[]s){int j,z,a=s.length,i=a*9,f=1,q=0;for(;s[q++]>10;);for(;i-->0;)for(j=w.length,z=i/9;i%9!=4&j-->0&z>=0&z<a&&s[z]==w[j];z+=q*(i/3%3)+i%3-q-1)f*=j;return f==0;}

एक बुनियादी पाशविक बल। मेरे कहने का और कुछ नहीं है। इनपुट में सुई पहली और हैस्टैक दूसरी है। ग्रिड को न्यूलाइन-टर्मिनेट किया जाता है ।

दिखाया गया मामला परीक्षण के साथ थोड़ा अधिक पठनीय संस्करण:

public class WordSearch {
    static String grid = "WVERTICALL\nROOAFFLSAB\nACRILIATOA\nNDODKONWDC\nDRKESOODDK\nOEEPZEGLIW\nMSIIHOAERA\nALRKRRIRER\nKODIDEDRCD\nHELWSLEUTH";
    static String search = "RANDOM";

    public static void main(String[] args) {
        System.out.println(new WordSearch().s(search.toCharArray(),grid.toCharArray()));
    }

    boolean s(char[]w,char[]s){
        int j,z,a=s.length,i=a*9,f=1,q=0;
        for(;s[q++]>10;);
        for(;i-->0;)
            for(j=w.length,z=i/9;
                i%9!=4&j-->0&z>=0&z<a&&s[z]==w[j];
                z+=q*(i/3%3)+i%3-q-1)
                f*=j;
        return f==0;
    }
}
— Geobits
स्रोत
if(e<1)return 1>0;return e<1;यह नहीं हो सकता है?
— FryAmTheEggman
@FryAmTheEggman नहीं, यह पहली विफलता खोजने के बाद वापस आ जाएगी, इसलिए यह पूरे ग्रिड की खोज नहीं करेगा।
— Geobits
1
क्षमा करें, वहाँ थोड़े खो गया; _;
— FryAmTheEggman
4
बाहर छोरों के लिए दो में से एक में ढह किया जा सकता है बजाय तो तुम क्या चाहते हैं i=a*9,और for(;i-->0;)और उसके बाद z=i/9;और i%a!=4&पर और इतने?
— विल
1
वाह, यह मेरे लिए समान है। और मैं केवल उस पर नज़र रखता था जब मैं पहले ही शुरू कर चुका था। मैंने यह देखने के लिए समय नहीं लिया कि यह कैसे काम करता है। +1।
— लेवल रिवर सेंट
6

जावास्क्रिप्ट (E6) 111 116

जानवर बल हर दिशा में हर चरित्र की खोज करता है - जैसा कि मैं कर सकता हूँ

F=(b,w)=>
  [1,-1,r=b.search('\n'),-r,++r,-r,++r,-r].some(d=>
    [...b].some((_,p)=>
      [...w].every(c=>c==b[p+=d],p-=d)
    )
  )

फायरफॉक्स / फायरबग कंसोल में टेस्ट

;["RANDOM", "VERTICAL", "HORIZONTAL", "WORDSEARCH", "WIKIPEDIA", "TAIL",
"WordSearch", "CODEGOLF", "UNICORN"]
.forEach(w=>console.log('\n'+ w +' -> '+
  F("WVERTICALL\nROOAFFLSAB\nACRILIATOA\nNDODKONWDC\nDRKESOODDK\nOEEPZEGLIW\nMSIIHOAERA\nALRKRRIRER\nKODIDEDRCD\nHELWSLEUTH",w)))

उत्पादन

RANDOM -> true
VERTICAL -> true
HORIZONTAL -> true
WORDSEARCH -> true
WIKIPEDIA -> true
TAIL -> true
WordSearch -> false
CODEGOLF -> false
UNICORN -> false
— edc65
स्रोत
5

पायथन, 175

बहुत प्रेरित नहीं है, लेकिन यहाँ जाता है:

def s(h,n):
 l=h.find('\n')+2;h+='\n'*l;L=i=len(h)
 while i>0:
  i-=1
  for d in[-l,1-l,2-l,-1,1,l-2,l-1,l]:
    j=i;m=len(n)
    for c in n:m-=c==h[j%L];j+=d
    if m<1:i=-1
 return-i

पहला तर्क हैस्टैक, दूसरा सुई है।

— पक्ष
स्रोत
मुझे लगता है कि आप 6 अक्षरों का उपयोग करके बचा सकते हैं h,n=input()और print। इसके अलावा, क्या यह गैर-वर्ग इनपुट के साथ काम करता है? (m = len (n); मैं पूरी तरह से समझने के लिए स्वीकार करता हूं कि आप क्या कर रहे हैं, इसलिए मैं पूरी तरह से गलत हो सकता हूं!)
— FryAmTheEggman
@FryAmTheEggman: हाँ, यह nonsquare आदानों के साथ काम करता है।
— एलए
1
कुछ मानक पायथन अनुकूलन: while i>0से while i:(क्योंकि iकभी नकारात्मक नहीं बन सकते हैं), if m<1:i=-1को i-=m<1।
— xnor
1
@xnor मुझे लगता है कि आप पढ़ने में भूलना हो सकता है if m<1:i=-1के रूप में if m<1:i-=1के रूप में उन में से कोई भी, क्योंकि वह स्थापित कर रही है काम करेंगे iनकारात्मक होने के लिए।
— FryAmTheEggman
@FryAmTheEggman ओह, हाँ, मैंने पूरी तरह से गलत किया था।
— xnor
5

बैश + कोरुटिल्स, 214 169 बाइट्स

r()(tee >(rev) $@)
t()(eval paste -d'"\0"' `sed 's/.*/<(fold -1<<<"&")/'`)
d()(while IFS= read l;do echo "$a$l";a+=_;done|t)
r<<<"$2"|r >(d) >(r|t) >(r|d)|r|grep -q "$1"

सभी आवश्यक संयोजनों में 3 ट्रांसफ़ॉर्म फ़ंक्शंस r, tऔर dरिवर्स, ट्रांज़ोज़ और विकर्ण शिफ्ट का उपयोग करता है ।

अपडेट - rफ़ंक्शन अब अतिरिक्त गोल्फ के लिए उलट और गैर-उलट आउटपुट का उत्पादन करता है

कमांडलाइन तर्कों के माध्यम से इनपुट - खोज स्ट्रिंग, इसके बाद (न्यूलाइन अलग) आयताकार शब्द खोज ब्लॉक।

आउटपुट एक आदर्श रूप से सही शेल एग्जिट स्टेटस कोड है - 0 का अर्थ TRUE और 1 का अर्थ FALSE।

आउटपुट:

$ for w in "Lorem" "mine" "uma bop" "tuetdod" "snol,a" "texas" "pii.d  v" "vexta" ; do ./ws.sh "$w" "Lorem ipsum dolor sit amet consectetu
r adipisicing elit sed do eiusmod tem
por incididunt ut labore et dolore ma
gna aliqua. Ut enim ad minim veniam, 
quis nostrud exercitation ullamco lab
oris nisi ut aliquip ex ea commodo co
nsequat. Duis aute irure dolor in rep
rehenderit in voluptate velit esse ci
llum dolore eu fugiat nulla pariatur."; echo $?; done
0
0
0
0
0
0
0
0
$ for w in WordSearch CODEGOLF UNICORN ; do ./ws.sh "$w" "Lorem ipsum dolor sit amet consectetu
r adipisicing elit sed do eiusmod tem
por incididunt ut labore et dolore ma
gna aliqua. Ut enim ad minim veniam, 
quis nostrud exercitation ullamco lab
oris nisi ut aliquip ex ea commodo co
nsequat. Duis aute irure dolor in rep
rehenderit in voluptate velit esse ci
llum dolore eu fugiat nulla pariatur."; echo $?; done
1
1
1
$
— डिजिटल आघात
स्रोत
1. मैं सुझाव देने वाला था T()(tee >(r) $@), लेकिन यह और भी बेहतर है। 2. मुझे नहीं लगता कि मैंने पहले कभी उस फ़ंक्शन सिंटैक्स को देखा है। 3. गैर-खाली तारों को सत्य और खाली तारों को झूठा मानते हुए, मुझे लगता है कि आप छोड़ सकते हैं -q।
— डेनिस
यदि आप परिभाषित करते हैं r()(tee >(rev) $@), r<<<"$2"|r >(d) >(r|t) >(r|d)|r|grep "$1"तो भी काम करना चाहिए।
— डेनिस
मैंने कुछ और परीक्षण नहीं किया है, लेकिन जब मैंने कोशिश की तो दो परीक्षण मामलों की जाँच की।
— डेनिस
@ डेनिस नाइस - अब यह काम करता है। मैंने मार्टिन के साथ जाँच की - वह चाहता है कि वह -qबना रहे।
— डिजिटल ट्रॉमा
5

सी, 163

f(char*h,char*n){int i,j,d,p,y=0,l=strlen(h),w=strchr(h,10)-h+1;for(i=l*9;i--;y+=d&&!n[j]){p=i/9;d=i%9/3*w-w+i%3-1;for(j=0;p>=0&p<l&h[p]==n[j];j++)p+=d;}return y;}

ग्रिड का कोई पुनर्व्यवस्था नहीं है, मैं बस हर शुरुआती अक्षर को हर दिशा में आज़माता हूं, और जब तक मैं ग्रिड से बाहर नहीं निकलता या बेमेल नहीं होता, तब तक साथ चलता हूं।

मैं इस तथ्य का लाभ उठाता हूं कि एक शून्य स्ट्रिंग में एक सी स्ट्रिंग समाप्त हो जाती है। चूंकि ग्रिड में कोई शून्य बाइट्स नहीं हैं, इसलिए हमेशा एक बेमेल होगा। लेकिन अगर बेमेल शून्य बाइट में होता है, तो हम जानते हैं कि हमने स्ट्रिंग का अंत खोजा है, और इसे एक मैच के रूप में रिकॉर्ड किया है।

एक परीक्षण कार्यक्रम में अनगढ़

char h[]="WVERTICALL\nROOAFFLSAB\nACRILIATOA\nNDODKONWDC\nDRKESOODDK\nOEEPZEGLIW\nMSIIHOAERA\nALRKRRIRER\nKODIDEDRCD\nHELWSLEUTH\n";

f(char*h,char*n){                                   //haystack,needle
  int i,j,d,p,y=0,l=strlen(h),w=strchr(h,10)-h+1;   //l=length of whole grid. w=width of row, including terminal newline ASCII 10
  for(i=l*9;i--;){                                  //for each start letter and direction
    p=i/9;                                          //pointer to start letter
    d=i%9/3*w-w+i%3-1;                              //9 possible values of direction vector {-w,0,w}+{-1,0,1}
    for(j=0;p>=0&p<l&h[p]==n[j];j++)p+=d;           //walk p in the direction defined by d until we walk off the top or bottom of the grid or a mismatch is fount
    y+=d&&!n[j];                                    //if we got all the way to the terminal 0, record it as a hit. If d=0, don't record as this is an invalid direction.
  }
  return y;   
}

main(int c, char**v){
  printf("%d",f(h,v[1]));  
}

उत्पादन

ध्यान दें कि फ़ंक्शन ग्रिड में खोजे गए स्ट्रिंग की घटनाओं की कुल संख्या वापस कर देगा। इस प्रकार ODयह रिटर्न के लिए 6. अगर कोई भी गलतियां नहीं पाई जाती हैं, तो यह 0 रिटर्न होता है जो कि सी में एकमात्र गलत मूल्य है। y|=d*!n[j]एक चरित्र को बचाने के लिए बदलना लेकिन इस कार्यक्षमता को खोना है।

$ ./a UNICORN
0

$ ./a CODEGOLF
0

$ ./a WordSearch
0

$ ./a RANDOM
1

$ ./a WORDSEARCH
1

$ ./a VERTICAL
1

$ ./a HORIZONTAL
1

$ ./a WIKIPEDIA
1

$ ./a TAIL
1

$ ./a OD
6
— स्तर नदी सेंट
स्रोत
5

सी # - 218 197 186 बाइट्स

C # फ़ंक्शन जो 2 स्ट्रिंग्स लेता है, खोज करने वाला पहला शब्द, बाद में लाइन के साथ ग्रिड ( \nपंक्तियों के बीच) फ़ीड । चीजें अब हताश हो रही हैं ... इतना हताश -तथ्य यह है कि मेरा पिछला संपादन काम नहीं आया!

गोल्फ कोड:

bool F(string D,string S){int l=S.Length,i=l*13,r,p;for(S+="\n";i-->l*5;i=r<0?r:i)for(r=D.Length,p=i%l;p>-1&p<l&r-->0&&D[r]==S[p];p+=(S.IndexOf('\n')+1)*(i/l%9/3-1)+i/l%3-1);return i<0;}

परीक्षण कोड के साथ कम गोल्फ:

class P
{
    static void Main()
    {
        System.Console.WriteLine(new P().F(System.Console.ReadLine(),System.Console.In.ReadToEnd())?"Truthy":"Falsy"); // because why not
    }

    bool F(string D,string S)
    {
        int l=S.Length,i=l*13,r,p;

        for(S+="\n";i-->l*5;i=r<0?r:i) // for each cell/direction
            for(r=D.Length,p=i%l;p>-1&p<l&r-->0&&D[r]==S[p];p+=(S.IndexOf('\n')+1)*(i/l%9/3-1)+i/l%3-1); // test against string (backwards)

        return i<0;
    }
}
— VisualMelon
स्रोत
4

हास्केल - 173

सीधे ग्रिड पर खोज करने के बजाय, मैं ग्रिड को अलग-अलग तरीकों से बदल देता हूं और नए ग्रिड की प्रत्येक पंक्ति के साथ शब्द का मिलान करता हूं।

उदाहरण के लिए, 

G1    G2    G3       G4   G5

abcd  aA1   abcd     a..  ..1
ABCD  bB2   .ABCD    bA.  .A2
1234  cC3   ..1234   cB1  aB3
      dD4            dC2  bC4
                      D3  cD
                       4  d

G1, G2, G4 और G5 की प्रत्येक पंक्ति में शब्द खोजें, फिर हम कर रहे हैं। ध्यान दें कि G3 का उपयोग नहीं किया गया है, मैं इसे केवल चित्रण के लिए यहां पोस्ट करता हूं।

आगे और पीछे की खोज करने के लिए एक समान विचार लागू किया जाता है: बस मूल शब्द और उलट शब्द खोजें।

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

import Data.List
v=reverse
t=transpose
y=any
d r=zipWith(++)(scanr(\_->('\n':))[]r)r
g r w=y(y$y((==w).take(length w)).tails)[r,t r,t.d$r,t.d.v$r]
f r w=y(g(lines r))[w,v w]

फ़ंक्शन fवह है जो हम चाहते हैं और इसका तर्क rआयत स्ट्रिंग है, wखोज करने के लिए शब्द है।

— रे
स्रोत
4

अजगर 2 - 246 259 275 308 298 297 294 313 322

w,s=input()
r=range
d='\n'
I=''.join
w=w.split(d)
t,u=len(w),len(w[0])
v=d.join([I(x)for x in zip(*w)]+[d]+[I([w[i+j][i]for i in r(min(u,t-j))])+d+I([w[i][i+j]for i in r(min(t,u-j))])for j in r(max(t,u))]+[d]+w)
print s in v or s[::-1]in v

प्रिंट से निपटने और जुड़ने में मदद करने के लिए विल की मदद के लिए धन्यवाद।

भूमिगत रेलमार्गों को ठीक से याद दिलाने के लिए भूमिगत रेल के लिए धन्यवाद; पी

खराब मिलान के लिए निश्चित है ',' को सीमांकक के रूप में उपयोग करने के लिए।

जाहिरा तौर पर गोल्फ के लिए सबसे अच्छा तरीका क्षैतिज स्क्रॉलिंग के टन को जोड़ना है।

के रूप में इनपुट खाली स्थान के धमाके न्यू लाइन सीमांकित उद्धरण में लाइनों: "WVERTICALL \ nROOAFFLSAB \ nACRILIATOA \ nNDODKONWDC \ nDRKESOODDK \ nOEEPZEGLIW \ nMSIIHOAERA \ nALRKRRIRER \ nKODIDEDRCD \ nHELWSLEUTH", "यादृच्छिक"

— FryAmTheEggman
स्रोत
1
L=len;J=''.joinआदि और print any(s in(v,d,w,r...))? मैं उसी तर्ज पर जा रहा था जब मैंने देखा कि आप पोस्ट :)
— विल
@ मदद के लिए धन्यवाद! लेन की लागत को परिभाषित करना, जितने ही पात्रों को बचाता है, उतना ही खर्च होता है, और मुझे यकीन नहीं है कि कैसे इसमें शामिल होने को परिभाषित किया जाए (कुछ में अल्पविराम), इसलिए मैं इसे थोड़ा सा करूँगा।
— FryAmTheEggman
आपके पास )या ]किसी स्थान का अनुसरण करने वाला कोई भी स्थान हो, आप उस स्थान को निकाल सकते हैं।
— भूमिगत
2

APL (Dyalog Classic) , 44 बाइट्स

1∊⍞⍷↑{⍉0,⍵,↑(0,⊢)\↓0,⍵}¨{⍉⌽⍵}\4⍴⊂↑a⊆⍨a≠⊃⌽a←⎕

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

— NGN
स्रोत
उम, मुझे क्षमा करें, लेकिन ऐसा लगता है कि आप यहां उस तरह का इनपुट प्राप्त नहीं कर सकते हैं, इसे \n-सेपरेटेड (यानी ⎕TC[2]विभाजक के रूप में होने ) की आवश्यकता है।
— एरिक आउटलेगर
@EriktheOutgolfer ओह बकवास ... मैं इसे बाद में ठीक कर दूँगा। धन्यवाद।
— ngn
अब तय हो गई, दुर्भाग्य से बहुत लंबे समय तक
— NGN
0

जे , 60 53 बाइट्स

<@[e.[:,[:(;|.)@>[:<\\.@>[:(<"1,</.)@>@(;|.@|:)[;.2@]

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

पहले इनपुट की आवश्यकता है जिसमें कोई नया अंक न हो।

स्पष्टीकरण:

linkrotate=: ;|.@|:     NB. link with itself rotated 90° ccw
infixes   =: <\\.       NB. list of boxes containing the infixes
lines     =: <"1 , </.  NB. horizontal and diagonal lines, boxed
linkrev   =: ;|.        NB. link with itself reversed
appearin  =: <@[ e. [: , [: linkrev@> [: infixes@> [: lines@>@linkrotate [;.2@]

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

हुक उपयोगी हैं।

— user202729
स्रोत
ऐसा लगता है कि यह भी काम करता है। (51 बाइट्स)
— user202729
0

जेली , 16 बाइट्स

कोड के मूल के रूप में इन 16 बाइट्स में से 15 के साथ एक संबंधित (संभवतः एक डुप्लिकेट) चुनौती का हल ...

ỴZU$3С;ŒD$€Ẏw€Ẹ

बाईं ओर वर्णों की सूची और दाईं ओर वर्णों की एक सूची को स्वीकार करते हुए एक डाइएडिक लिंक जो 1 पाया जाता है और यदि नहीं तो 0।

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

कैसे?

ZU$3С;ŒD$€Ẏw€Ẹ - Link: words, grid
   3С          - repeat three times and collect the results (inc input):
  $             -   last two links as a monad:
Z               -     transpose
 U              -     upend     (together these rotate by a quarter)
          €     - for €ach:
         $      -   last two links as a monad:
       ŒD       -     get forward-diagonals
      ;         -     concatenate
           Ẏ    - tighten (to get all the runs across the grid) 
             €  - for €ach run:
            w   -   sublist-index (0 if not found)
              Ẹ - any truthy? (i.e. was the word found?)
— जोनाथन एलन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.