शब्द खोज सॉल्वर

17

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

इनपुट हमेशा रहेगा: शब्दों की एक सूची, 1 प्रति पंक्ति, उसके बाद एक खाली लाइन, उसके बाद अक्षरों की ग्रिड।

उदाहरण

इनपुट

ADA
ALGOL
ASSEMBLY
BASIC
COBOL
DELPHI
FORTRAN
JAVA
LABVIEW
LOGO
PASCAL
PERL
PHP
PYTHON
SMALLTALK
VISUALC

LLJKCABLFCI
OROLOBOCOIM
GELACSAPRSX
LPSTAHWVTAV
ANRLXLXQRBI
IHPLEDOXAHS
KJYAPHPYNOU
FABMADANZJA
EVISNOHTYPL
AAYLBMESSAC
WEIVBALOGOM

उत्पादन

LL K    FC
OR LOBOCOI 
GELACSAPRS
LP T    TAV
A  L    RBI
IHPLED  A S
 J APHP N U
 A MADA   A
 V SNOHTYPL
 AYLBMESSAC
WEIVBALOGO

इनपुट

BACKSPACE
BOLD
CLOSE
COMPACTDISC
COPY
CPU
CURSOR
DELETE
DESKTOP
DVD
EDIT
ENTER
EXIT
FLOPPY
FONT
HARDWARE
INTERNET
KEYBOARD
MONITOR
MOUSE
PASSWORD
PASTE
RETURN
SAVE
SOFTWARE
START
TEXT
TOWER
WORDPROCESSING

IAUERAWTFOSICPN
DGZPFLOPPYARFLU
RSNOCURSORVZDBM
AMNIUOMRNHEGUIN
OTBNSRMONITORNT
BEYTTSGPJBOLDRT
YRQEAHEHARDWARE
EOGRRNECECLOSEP
KIONTYKTODTOWER
ELCENSUPERPDKNN
ATRTPRYKELPVIEJ
GIEANPOTKSEDUSL
NXCMPASSWORDRUC
TEDITAGVSWJCTOV
CWOYPGYQKNLVXMW

उत्पादन

  UERAWTFOS    
DG PFLOPPYA    
R NOCURSORV    
A NI O    E    
OT NS MONITOR  
B  TTS P BOLD  
Y  EA EHARDWARE
E  RRNECECLOSE
K  NT KTO TOWER
   E SUPER D   
 TRTPRY ELPVIE 
 IEANPOTKSED S 
 XC PASSWORDRUC
TEDITA       O 
    P        MW

यह कोड-गोल्फ है - सबसे छोटा समाधान जीतता है।

उदाहरण शब्द 1 और 2 से ।

code-golf  word-puzzle  crossword  word-search 
— गैरेथ
स्रोत
क्या हम मान सकते हैं कि ग्रिड हमेशा चौकोर होता है?
— स्कॉट लोगन
@Bunnit नहीं, मुझे ऐसा नहीं लगता। दिए गए दोनों उदाहरण हैं, लेकिन मुझे लगता है कि एक सॉल्वर को अन्य आयताकार ग्रिड को संभालने में सक्षम होना चाहिए।
— गारेथ
क्या हम मान सकते हैं कि सभी पत्र अपरकेस और AZ हैं?
— हावर्ड
@ हॉवर्ड हाँ आप कर सकते हैं।
— गारेथ
@ गैरेथ: आपके पहले उदाहरण में, नीचे की पंक्ति में "LABVIEW" है, लेकिन यह आउटपुट पर प्रदर्शित नहीं होता है।
— Briguy37

जवाबों:

3

रूबी 1.9, 214 210 206 182 177 173 172 166

s,G=$<.read.split$/*2
O=G.tr'^
',' '
(s+$/+s.reverse).split.map{|w|[0,l=G=~/$/,l+1,l-1].map{|d|(k=G=~/#{[*w.chars].*?.*d}/m)&&w.size.times{|i|O[k+d*i+i]=w[i]}}}
$><<O
— Lowjacker
स्रोत
अच्छी तरह से किया। आपका एल्गोरिथ्म मेरे उत्तर के समान ही प्रतीत होता है, लेकिन माणिक में काफी अधिक कॉम्पैक्ट है। आप मेरे विश्वास को मजबूत कर रहे हैं मुझे अपने कोड-गोल्फ बैग में माणिक को जोड़ना चाहिए।
— १०:१३ बजे डीसीएचनेस
6

पर्ल - 230 चार्ट

गणना में "-ln" कमांड-लाइन विकल्प के लिए 4 शामिल हैं।

if(1../^$/){push@w,$_,''.reverse if$_}else{$a.="$_\n"}END{$_=$a;/.+/;$W=$+[0];y/A-Z/ /;chomp;for$w(@w){for$n(0,$W-1..$W+1){$r=join".{$n}",map"($_)",(@l=split//,$w);if($i=$a=~/$r/s){substr($_,$-[$i++],1,shift@l)while@l}}}print}

Ungolfed:

# -n: implicitly loop over input lines
# -l: strip the newlines
if ( 1 .. /^$/ ) {              # from first line to empty line
  push @w,                      # record in @w
    $_,                         #   the word
      ''.reverse                #   and its reverse
        if $_                   #   if it's not the empty line
}
else {
  $a .= "$_\n"                  # otherwise, add to the search array
}

END {
  $_ = $a;                      # make a copy for the output
  /.+/; $W = $+[0];             # compute array width
  y/A-Z/ /;                     # blank the output board
  chomp;                        # and remove the trailing newline,
                                #  because -l will add it back for us
  for $w (@w) {                 # for each word
    for $n (0, $W-1 .. $W+1) {  # for each direction in E, SW, S, SE
      $r = join ".{$n}",        # form a regexp with an appropriate
                                #  number of characters skipped between letters
                                #  (0 -> adjacent, so E; $W -> next line, so S;
                                #   off by one from $W for the diagonals),
        map "($_)",             #  capturing the letters of the word (for their offsets),
          (@l=split//,$w);      #  which we split up here
      if ( $i = $a =~ /$r/s ) { # if the word matches in this orientation
        substr( $_,             # set the substring of the output
                $-[$i++],       #  at the offset this letter matched
                1,              #  length 1
                shift @l )      #  to the corresponding letter
          while @l              #  (for each letter)
      }
    }
  }
  print                         # and print the output
}
— DCharness
स्रोत
मैं पर्ल से बहुत परिचित नहीं हूं, इसलिए शायद मैं आपके समाधान में कुछ नहीं देख रहा हूं, लेकिन क्या आपका रेगेक्स विकर्णों के लिए चारों ओर नहीं लपेटता है?
— मिगिमारू
@migimaru मैच डायरेक्शन के डाउनवर्ड कंपोनेंट को लागू करने .{$n}के लिए regexp का हिस्सा ( /sविकल्प के साथ ) विकर्णों (और सीधे नीचे) के लिए चारों ओर लपेटता है। क्या आपकी चिंता एक झूठा मेल है जो लपेटता है? AFAICT, यह गलत मेल नहीं दे सकता है, क्योंकि स्ट्रिंग में नए सिरे से। मान लीजिए कि मैं एक शब्द के अक्षर i को सबसे दाहिने कॉलम में मैच करता हूं, और हम SE विकर्ण की जांच कर रहे हैं। यह .{$n}भाग अगले $ W + 1 वर्णों को छोड़ देता है, जो तुरंत अगले n और n अगली पंक्ति के होते हैं। पत्र i + 1 अगले \ n के खिलाफ बेमेल होगा, इस प्रकार कोई समग्र मैच नहीं होगा।
— डीसीहरेंस 19
ओह समझा। मैंने इस तथ्य को याद किया कि नई रूपरेखाएं शामिल हैं और झूठे मैचों को रोकेंगी। धन्यवाद!
— मिगिमारू
3

जावास्क्रिप्ट: 342 अक्षर

कोड-गोल्फ संस्करण:

function a(b){c='\n';d=b.split(c+c);e=d[1].split(c);for(f=-1,g=[];h=e[++f];)for(i=-1,g[f]=[];h[++i];)for(j=-2,g[f][i]=' ';2>++j;)for(l=-2;2>++l;)for(k=0;m=d[0].split(c)[k++];)for(n=-1;o=m[++n];)for(p=f-n*j-j,q=i-n*l-l,r=0;(s=m[r++])&&(t=e[p+=j])&&(u=t[q+=l])&&s==u;)if(r==m.length)g[f][i]=o;for(i=0;v=g[i];)g[i++]=v.join('');return g.join(c)}

प्रारूपित संस्करण:

function solveWordsearch(input){
    var lineBreak = '\n';
    var solver = input.split(lineBreak+lineBreak);
    var board = solver[1].split(lineBreak);

    for(row=-1,output=[]; line=board[++row];){
        for(col=-1,output[row]=[]; line[++col];){
            for(rowIncrement=-2,output[row][col]=' ';2>++rowIncrement;){
                for(colIncrement=-2;2>++colIncrement;){
                    for(k=0; word=solver[0].split(lineBreak)[k++];){
                        for(charPosition=-1; wordChar=word[++charPosition];){
                            var startRowIndex=row-charPosition*rowIncrement-rowIncrement;
                            var startColIndex=col-charPosition*colIncrement-colIncrement;
                            for(wordIndex=0;(compareWordChar=word[wordIndex++])&&(compareBoardRow=board[startRowIndex+=rowIncrement])&&(compareBoardChar=compareBoardRow[startColIndex+=colIncrement])&&compareWordChar==compareBoardChar;){
                                if(wordIndex == word.length){
                                    output[row][col]=wordChar;
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    for(i=0;outLine=output[i];){
        output[i++]=outLine.join('');
    }

    return output.join('\n');
}

इस समाधान के पीछे अवधारणा बोर्ड पर सभी पदों पर पुनरावृत्ति करना है, प्रत्येक स्थिति के लिए एक 2 डी-सरणी के मूल्यों को '' आरंभ करें और फिर सभी संभावित शब्द निर्देशों और शब्द ऑफसेट पर विचार करें। यदि एक मिलान शब्द पाया जाता है, तो उस स्थिति के लिए सरणी का मान सही अक्षर में अपडेट किया जाता है। अंत में, सरणी एक स्ट्रिंग में परिवर्तित हो जाती है और वापस आ जाती है।

— Briguy37
स्रोत
1

स्काला 697, 666 649

val(z,n)=io.Source.fromFile("F").getLines.toList.span(_.length>0)
val m=n.tail
val(w,h)=(m.head.length,m.size)
def g(d:Int,e:Int,k:Int,g:Int,h:Int,i:Int,s:String)={
def f(x:Int,y:Int):Seq[(Int,Int)]={
val q=for(c<-(0 to s.size-1))
yield (y+c*i,x+c*k)
if((q.map(p=>m(p._1)(p._2))).mkString==s)q else Nil}
val t=for(x<-(d to e);
y<-(g to h))yield f(x,y)
t.flatten}
def i(s:String)={val l=s.size
g(0,w-l,1,0,h-1,0,s)++ g(0,w-1,0,0,h-l,1,s)++ g(0,w-l,1,l-1,h-1,-1,s)++ g(0,w-l,1,0,h-l,1,s)}
def j(s: String)=i(s)++ i(s.reverse)
val k=z.map(j).flatten
(0 to h-1).map(r=>{(0 to w-1).map(c=>if(k.contains(r,c))print(""+m(r)(c))else print(" "));println()})

degolfed:

object Golf {

def main (args: Array[String]) = {
  val (words, matrix) = io.Source.fromFile ("./wordsearch.data").getLines.toList.span (_.length > 0)
  val m = matrix.tail
  val (w,h) = (m.head.length, m.size)

  // xi: x-increment, yi: y-increment
  def find (x: Int, y: Int, xi: Int, yi: Int, s: String): Seq [(Int, Int)] = {
    val points = for (c <- (0 to s.length-1))
       yield (y + c*yi, x + c * xi)
    if ((points.map (p => m (p._1)(p._2))).mkString == s) points else Nil
  }

  def findInScope (xS: Int, xD: Int, xi: Int, yS: Int, yD: Int, yi: Int, s: String): Seq [(Int, Int)] = {
    val ppoints = for (x <- (xS to xD);
          y <- (yS to yD)) yield find (x, y, xi, yi, s)
    ppoints.flatten 
  }

  def findRowColFallingClimbing (s: String) = {
    val l=s.length

    // horizontal:
      findInScope (0,   w-l,  1,   0, h-1,  0, s) ++
    // vertical: 
      findInScope (0,   w-1,  0,   0, h-l,  1, s) ++
    // climbing /:
      findInScope (0,   w-l,  1, l-1, h-1, -1, s) ++
    // falling \:
      findInScope (0,   w-l,  1,   0, h-l,  1, s)
  }

  def findBoth (s: String) = findRowColFallingClimbing (s) ++ findRowColFallingClimbing (s.reverse)
  val coords = words.map (findBoth).flatten

  (0 to h-1).map ( r => {
    (0 to w-1).map (c =>
      if (coords.contains (r, c))
       print ("" + m(r)(c)) 
      else print (" ")
     )
     println ()
   })
  }
}
— अज्ञात उपयोगकर्ता
स्रोत
के stdinबजाय का उपयोग करके आप कुछ वर्णों को सहेज सकते हैं fromFile। मैंने यह नहीं बताया कि इनपुट कहां से आता है।
— गैरेथ
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.