ওয়ার্ডসার্ক সলভার

17

শব্দের একটি তালিকা এবং অক্ষরের একটি গ্রিড দেওয়া, গ্রিডে সমস্ত শব্দ সন্ধান করুন এবং শব্দের অংশ নয় এমন কোনও অক্ষর মুছে ফেলুন। শব্দগুলি এগিয়ে, পিছনে, উপরে, নীচে বা তির্যক হতে পারে। আপনি ধরে নিতে পারেন তালিকার কোনও শব্দই গ্রিডের একাধিক স্থানে ঘটবে না।

ইনপুট সর্বদা থাকবে: প্রতি লাইনের শব্দের একটি তালিকা, পরে একটি ফাঁকা রেখা, তারপরে অক্ষরের গ্রিড।

উদাহরণ

ইনপুট

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 
— গ্যারেথ
সূত্র
আমরা গ্রিড সবসময় বর্গক্ষেত্র ধরে নিতে পারি?
— স্কট লোগান
@ বুনিট না, আমার মনে হয় না। প্রদত্ত উদাহরণ দুটিই, তবে আমি মনে করি যে কোনও দ্রাবক অন্য আয়তক্ষেত্রাকার গ্রিডগুলি পরিচালনা করতে সক্ষম হওয়া উচিত।
— গ্যারেথ
আমরা কি সব অক্ষর বড় হাতের এবং এজেড ধরে নিতে পারি?
— হাওয়ার্ড
@ হওয়ার্ড হ্যাঁ আপনি পারেন
— গ্যারেথ
@ গ্যারেথ: আপনার প্রথম উদাহরণে নীচের সারিতে এটিতে "LABVIEW" রয়েছে তবে এটি আউটপুটে প্রদর্শিত হয় না।
— ব্রিগ্যুই 37

উত্তর:

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
সূত্র
পার্লের সাথে আমি খুব বেশি পরিচিত নই, তাই সম্ভবত আমি আপনার সমাধানে কিছু দেখছি না, তবে কি আপনার রেজেক্সটি তির্যকগুলির জন্য চারপাশে মোড়ানো নয়?
— মাইগিমারু
@ মিগিমারু ম্যাচের দিকের নিচের দিকের উপাদানটি বাস্তবায়নের জন্য রেজিএক্সএক্সের .{$n}অংশটি ( /sবিকল্পের সাথে বরাবর ) চারপাশে জড়ান । আপনার উদ্বেগ একটি মিথ্যা ম্যাচ যে মোড়? আফিক্স, স্ট্রিংয়ের নতুন লাইনের কারণে এটি মিথ্যা ম্যাচগুলি দিতে পারে না। ধরা যাক কোনও শব্দের i এর অক্ষরটি ডানদিকের কলামে মেলে এবং আমরা এসই তির্যকটি পরীক্ষা করছি। .{$n}অংশ পরবর্তী $ ওয়াট + 1 টি অক্ষর, যা অগ্রাহ্য অবিলম্বে নিম্নলিখিত \ N এবং পরবর্তী লাইন সব। চিঠি আই +1 পরবর্তী against n এর বিপরীতে মিলবে না, সুতরাং সামগ্রিক কোনও মিল নেই।
— ডিসচারনেস 12:58
আহ আমি দেখি. নতুন লাইনের অন্তর্ভুক্ত রয়েছে এবং মিথ্যা ম্যাচগুলি রোধ করবে এই বিষয়টি আমি মিস করেছি। ধন্যবাদ!
— মাইগিমারু
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' তে 2D-অ্যারের মানগুলি আরম্ভ করা এবং তারপরে সমস্ত সম্ভাব্য শব্দের দিকনির্দেশ এবং শব্দ অফসেট বিবেচনা করা। যদি কোনও মিলে যাওয়া শব্দটি পাওয়া যায়, তবে সেই অবস্থানের জন্য অ্যারের মানটি সঠিক অক্ষরে আপডেট হয়। অবশেষে অ্যারেটি স্ট্রিংয়ে রূপান্তরিত হয়ে ফিরে আসবে।

— 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। ইনপুট কোথা থেকে আসে তা নির্দিষ্ট করেছিলাম না।
— গ্যারেথ
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.