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


13

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

शब्दों को वर्ग में रखा जाना चाहिए, प्रत्येक दिशा में कम से कम एक शब्द (क्षैतिज, ऊर्ध्वाधर और विकर्ण)। शब्दों को सिर्फ एक बार दिखाई देना चाहिए।

तो, इनपुट सिर्फ शब्दों की एक सूची है। उदाहरण के लिए CAT, TRAIN, CUBE, BICYCLE:। एक संभावित समाधान है:

B N * * * * *
* I * * C A T
* A C * * * *
* R * Y * * C
* T * * C * U
* * * * * L B
* * * * * * E

मैंने केवल स्पष्टता के लिए तारांकन के साथ पत्र भरने की जगह ली। वांछित आउटपुट में यादृच्छिक भरने वाले अक्षर शामिल होने चाहिए।


प्रत्येक शब्द को केवल एक ही स्थिति में पाया जाना चाहिए (जैसे कि विशिष्ट शब्द खोज)? उदाहरण के लिए, ACआपके उदाहरण में छोड़ दिया गया पत्र CATयदि ऐसा है तो एक और बना देगा T
भूतों का

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

हां, इसे केवल एक ही स्थिति में पाया जाना चाहिए।
मिग

1
नहीं वास्तव में कोई नहीं। मैं अभी भी स्पष्ट नहीं हूं कि उस स्थान से, जिसका उत्तर यादृच्छिक रूप से नमूना होना चाहिए, और न ही उस स्थान के तत्वों को भारित करने में कितना लचीलापन है।
पीटर टेलर

1
अब तक, प्रश्न में ऐसे इनपुट हैं जिन्हें हल नहीं किया जा सकता है, लेकिन इस बात का कोई उल्लेख नहीं किया गया है कि आप इससे कैसे निपटेंगे। उदाहरण के लिए सेट A B C D E F G H I J K L M N O P Q R S T U V W X Y Zका कोई हल नहीं है।
orlp

जवाबों:


6

जावास्क्रिप्ट (ईएस 6), 595 628 680

कुछ सफाई संपादित करें और मर्ज करें:
- फ़ंक्शन P को फ़ंक्शन के अंदर मर्ज किया गया है
- उसी .map में x और z
- जब समाधान मिला, बाहरी लूप से बाहर निकलने के लिए x को 0 पर सेट
करें - मर्ज किए गए निश्चितता और डब्ल्यू की कॉल

Edit2 अधिक गोल्फिंग, यादृच्छिक रूप से छोटा, बाहरी लूप संशोधित ... कुछ और पठनीय के लिए इतिहास देखें

स्वीकृत उत्तर के विपरीत, यह अधिकांश इनपुट के लिए काम करना चाहिए। सिर्फ एक अक्षर वाले शब्दों से बचें। यदि कोई आउटपुट पाया जाता है, तो यह इष्टतम है और सभी 3 दिशाओं का उपयोग कर रहा है।

शब्दों को दोहराने से बचने की बाधा बहुत कठिन है। मुझे प्रत्येक चरण में शब्द को ग्रिड में जोड़ने वाले शब्द और प्रत्येक यादृच्छिक भरण वर्ण पर देखना था।

मुख्य उपखंड:

  • P (w) सही है अगर पैलिंड्रोम शब्द। बार-बार शब्दों की जाँच करने पर एक दो बार एक पालिंड्रोम शब्द मिलेगा।

  • ग्रिड s पर दोहराए जाने वाले शब्दों की जाँच करें

  • Q (s) यादृच्छिक अक्षरों के साथ ग्रिड s भरें - यह दोहराए जाने वाले शब्द के मामले में पुनरावर्ती और बैकट्रैक है - और विफल हो सकता है।

  • डब्ल्यू () पुनरावर्ती, दिए गए आकार के एक ग्रिड को भरने की कोशिश करें, यदि कब्ज़ेदार हो।

आउटपुट फ़ंक्शन का उपयोग करने के लिए मुख्य फ़ंक्शन W () का उपयोग करता है, जो सभी शब्दों की लंबाई के योग तक इनपुट में सबसे लंबे शब्द के आकार से कोशिश कर रहा है।

F=l=>{
  for(z=Math.max(...l.map(w=>(w=w.length,x+=w,w),x=0));
      ++z<=x;
      (W=(k,s,m,w=l[k])=>w?s.some((a,p)=>!!a&&
            D.some((d,j,_,r=[...s],q=p-d)=>
              [...w].every(c=>r[q+=d]==c?c:r[q]==1?r[q]=c:0)
              &&R(r)&&W(k+1,r,m|1<<(j/2))
            )
          )
        :m>12&&Q(s)&&(console.log(''+s),z=x) 
      )(0,[...Array(z*z-z)+99].map((c,i)=>i%z?1:'\n'))
    )
    D=[~z,-~z,1-z,z-1,z,-z,1,-1]
    ,R=u=>!l.some(w=>u.map((a,p)=>a==w[0]&&D.map(d=>n+=[...w].every(c=>u[q+=d]==c,q=p-d)),
      n=~([...w]+''==[...w].reverse()))&&n>0)
    ,Q=(u,p=u.indexOf(1),r=[...'ABCDEFGHIJHLMNOPQRSTUVWXYZ'])=>
      ~p?r.some((v,c)=>(r[u[p]=r[j=0|c+Math.random()*(26-c)],j]=v,R(u)&&Q(u)))||(u[p]=1):1
    //,Q=u=>u.map((c,i,u)=>u[i]=c!=1?c:' ') // uncomment to avoid random fill
}

अधूरा और समझाया (अधूरा, माफ करना, लोगों को यह बहुत काम है)

F=l=>
{
  var x, z, s, q, D, R, Q, W;
  // length of longest word in z
  z = Math.max( ... l.map(w => w.length))
  // sum of all words length in x
  x = 0;
  l.forEach(w => x += w.length);

  for(; ++z <= x; ) // test square size from z to x
  {
    // grid in s[], each row of len z + 1 newline as separator, plus leading and trailing newline
    // given z==offset between rows, total length of s is z*(z-1)+1
    // gridsize: 2, z:3, s.length: 7 
    // gridsize: 3, z:4, s.length: 13
    // ...
    // All empty, nonseparator cells, filled with 1, so
    // - valid cells have a truthy value (1 or string)
    // - invalid cells have falsy value ('\n' or undefined)
    s = Array(z*z-z+1).fill(1) 
    s = s.map((v,i) => i % z != 0 ? 1 : '\n');

    // offset for 8 directions 
    D = [z+1, -z-1, 1-z, z-1, z, -z, 1, -1]; // 4 diags, then 2 vertical, then 2 horizontal 

    // Function to check repeating words
    R = u => // return true if no repetition
      ! l.some( w => // for each word (exit early when true)
      {
          n = -1 -([...w]+''==[...w].reverse()); // counter starts at -1 or -2 if palindrome word
          u.forEach( (a, p) => // for each cell if grid 
          {
            if (a == [0]) // do check if cell == first letter of word, else next word
               D.forEach( d => // check all directions 
                 n += // word counter
                   [...w].every( c => // for each char in word, exit early if not equal
                     u[q += d] == c, // if word char == cell, continue to next cell using current offset
                     q = p-d  // starting position for cell
                   )
               ) // end for each direction
          } ) // end for each cell
          return n > 0 // if n>0 the word was found more than once
      } ) // end for each word

    // Recursive function to fill empty space with random chars
    // each call add a single char
    Q = 
    ( u, 
      p = u.indexOf(1), // position of first remaining empty cell 
      r = [...'ABCDEFGHIJHLMNOPQRSTUVWXYZ'] // char array to be random shuffled
    ) => {
      if (~p) // proceed if p >= 0
        return r.some((v,c)=>(r[u[p]=r[j=0|c+Math.random()*(26-c)],j]=v,R(u)&&Q(u)))||(u[p]=1)
      else 
        return 1; // when p < 0, no more empty cells, return 1 as true
    }
    // Main working function, recursive fill of grid          
    W = 
    ( k, // current word position in list
      s, // grid
      m, // bitmask with all directions used so far (8 H, 4V, 2 or 1 diag)
      w = l[k] // get current word
    ) => {
      var res = false
      if (w) { // if current word exists
        res = s.some((a,p)=>!!a&&
            D.some((d,j,_,r=[...s],q=p-d)=>
              [...w].every(c=>r[q+=d]==c?c:r[q]==1?r[q]=c:0)
              &&R(r)&&W(k+1,r,m|1<<(j/2))
            )
          )
      } 
      else 
      { // word list completed, check additional constraints
        if (m > 12 // m == 13, 14 or 15, means all directions used
            && Q(s) ) // try to fill with random, proceed if ok
        { // solution found !!
          console.log(''+s) // output grid
          z = x // z = x to stop outer loop
          res = x//return value non zero to stop recursion
        }
      }
      return res
    };
    W(0,s)
  }    
}

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

F (['TRAIN', 'CUBE', 'BOX', 'BICYCLE'])

,T,C,B,O,X,B,H,  
,H,R,U,H,L,I,H,  
,Y,A,A,B,E,C,B,  
,D,H,S,I,E,Y,I,  
,H,E,R,L,N,C,T,  
,G,S,T,Y,F,L,U,  
,H,U,Y,F,O,E,H,  

नहीं भरा

,T,C,B,O,X,B, ,
, ,R,U, , ,I, ,
, , ,A,B, ,C, ,
, , , ,I,E,Y, ,
, , , , ,N,C, ,
, , , , , ,L, ,
, , , , , ,E, ,

F (['TRAIN', 'ARTS', 'RAT', 'CUBE', 'BOX', Y BICYCLE ',' STORM ', IN BRAIN ’, P DEPTH’, UT MOUTH ’, SL SLAB’]]

,T,A,R,C,S,T,H,
,S,R,R,L,U,D,T,
,T,B,A,T,N,B,P,
,O,B,O,I,S,A,E,
,R,B,A,X,N,H,D,
,M,R,M,O,U,T,H,
,B,I,C,Y,C,L,E,

एफ ([ 'एए', 'एबी', 'एसी', 'ई', 'एई', 'वायु सेना', 'एजी'])

,A,U,B,C,
,T,A,E,Z,
,C,D,O,F,
,Q,C,G,A,

एफ ([ 'एए', 'एबी', 'एसी', 'ई', 'एई', 'वायु सेना'])

आउटपुट भरा नहीं - @ नथन: अब आप पुनरावृत्ति के बिना एक और एक्स नहीं जोड़ सकते । आपको एक बड़ी ग्रिड की आवश्यकता होगी।

,A, ,C,
, ,A,F,
,D,E,B,

आपके अंतिम परीक्षण के मामले में, क्या यह 3x3 ग्रिड में संभव नहीं है?
नाथन मेरिल

@NathanMerrill सं। उत्तर पाठ में अधिक विवरण
edc65

पूरी तरह से अपठनीय कोड :) लेकिन अच्छा है कि बाइट / पॉइंट "अवार्ड" का नकारात्मक पक्ष मानव कंपाइलर नहीं है
फायरफिल

1
@firephil एक स्पष्टीकरण जोड़ने की कोशिश कर रहा है, यह आसान नहीं है ...
edc65

1

सी#

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

class Tile
{
    public char C;
    public int X, Y;
}

class Grid
{
    List<Tile> tiles;

    public Grid()
    {
        tiles = new List<Tile>();
    }
    public int MaxX()
    {
        return tiles.Max(x => x.X);
    }
    public int MaxY()
    {
        return tiles.Max(x => x.Y);
    }
    public void AddWords(List<string> list)
    {
        int n = list.Count;
        for (int i = 0; i < n; i++)
        {
            string s = list[i];
            if(i==0)
            {
                Vert(s, 0, 0);
            }
            else if(i==n-1)
            {
                int my = MaxY();
                Diag(s, 0, my+1);
            }
            else
            {
                Horiz(s, 0, i);
            }
        }

    }
    private void Vert(string s, int x, int y)
    {
        for (int i = 0; i < s.Length; i++)
        {
            Tile t = new Tile();
            t.C = s[i];
            t.X = x+i;
            t.Y = y;
            tiles.Add(t);
        }
    }
    private void Horiz(string s, int x, int y)
    {
        for (int i = 0; i < s.Length; i++)
        {
            Tile t = new Tile();
            t.C = s[i];
            t.X = x+i;
            t.Y = y;
            tiles.Add(t);
        }
    }
    private void Diag(string s, int x, int y)
    {
        for (int i = 0; i < s.Length; i++)
        {
            Tile t = new Tile();
            t.C = s[i];
            t.X = x++;
            t.Y = y++;
            tiles.Add(t);
        }
    }
    public void Print()
    {
        int mx = this.MaxX();
        int my = this.MaxY();
        int S = Math.Max(mx, my) + 1;
        char[,] grid = new char[S, S];
        Random r = new Random(DateTime.Now.Millisecond);
        //fill random chars
        for (int i = 0; i < S; i++)
        {
            for (int j = 0; j < S; j++)
            {
                grid[i, j] = (char)(r.Next() % 26 + 'A');
            }
        }
        //fill words
        tiles.ForEach(t => grid[t.X, t.Y] = t.C);
        //print
        for (int i = 0; i < S; i++)
        {
            for (int j = 0; j < S; j++)
            {
                Console.Write("{0} ", grid[i,j]);
            }
            Console.WriteLine();
        }
    }
}

class WordSearch
{
    public static void Generate(List<string>list)
    {
        list.Sort((x, y) =>
        { int s = 0; if (x.Length < y.Length)s = -1; else if (y.Length < x.Length)s = 1; return s; });
        list.Reverse();
        Grid g = new Grid();
        g.AddWords(list);
        g.Print();
    }

}

परीक्षा

class Program
{
    static void Main(string[] args)
    {
        string words = "CAT, TRAIN, CUBE, BICYCLE";
        string comma=",";
        List<string> w = words.Split(comma.ToArray()).ToList();
        List<string> t = new List<string>();
        foreach(string s in w)
        {
           t.Add(s.Trim());
        }
        WordSearch.Generate(t);

        Console.ReadKey();
    }
}

यह काम करता है लेकिन इसका इष्टतम नहीं: नमूना स्ट्रिंग शब्द = "कैट, डीओजी, एचआर, आरयूएन, सीएमडी";
फायरफिल

क्या आप जाँचते हैं कि क्या यादृच्छिक भरण वर्ण ग्रिड में किसी शब्द की पुनरावृत्ति का कारण बनते हैं?
edc65

-1 ने कोशिश की। ऐनक का पालन नहीं करता है at least one word in each direction (horizontal, vertical and diagonal)। परीक्षण कार्यक्रम चलाना, कोई क्षैतिज शब्द (3 ऊर्ध्वाधर, 1
डायग

3
यह सवाल कोड-गोल्फ है , इसलिए आपको शीर्षक में कितने बाइट्स पोस्ट करने चाहिए, और शायद यह आपके प्रोग्राम को एक गुच्छा बना देगा। धन्यवाद।
mbomb007

@ edc65 यह एक ऊर्ध्वाधर, एक विकर्ण और अन्य सभी क्षैतिज करता है। जैसा कि मैंने सही समाधान प्राप्त करने के लिए टिप्पणी की है, प्रश्न की विशिष्टताओं के साथ-साथ जांच के लिए बड़ी संख्या में संयोजन की आवश्यकता होगी।
bacchusbeale
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.