একটি ভোরোনাই চিত্রটি তৈরি করুন (এএসসিআইআই বৈকল্পিক)


24

মনে করুন আপনাকে অন্য কোনও ফাঁকা কোষের আয়তক্ষেত্রাকারে ছড়িয়ে ছিটিয়ে কিছু আলাদা বড় হাতের অক্ষর দেওয়া হয়েছে। অ্যারের মধ্যে প্রতিটি সেল জন্যে চিঠির নিকটতম কোন তির্যক পদক্ষেপ - এটা করার জন্য, অনুভূমিক এবং / অথবা উল্লম্ব পদক্ষেপ ক্ষুদ্রতম সংখ্যা পৌঁছানো চিঠি হিসাবে সংজ্ঞায়িত করা। (যদি কোনও ঘর দুটি বা ততোধিক নিকটবর্তী অক্ষর থেকে সমতুল্য হয়, তবে সেই অক্ষরগুলির যে কোনও একটির বর্ণমালা অনুসারে এটি অন্তর্ভুক্ত it এতে একটি বড় হাতের অক্ষরযুক্ত একটি ঘর সেই অক্ষরের অন্তর্গত)) সীমানা- ঘরগুলি হ'লগুলি অনুভূমিকভাবে বা উল্লম্বভাবে এক বা একাধিক কোষ সংলগ্ন যা তারা নিজেরাই যে চিঠির সাথে সম্পর্কিত তা নয়।

নিম্নলিখিত আচরণের সাথে একটি পদ্ধতি সাবপ্রগ্রাম লিখুন , এক ধরণের ভোরোনাই চিত্র তৈরি করুন ...

ইনপুট : যে কোনও এএসসিআইআই স্ট্রিং কেবল বিন্দু, বড় হাতের অক্ষর এবং নিউলাইনগুলির সমন্বয়ে গঠিত, যেমন এটি মুদ্রিত হলে উপরের বর্ণিত একটি আয়তক্ষেত্রাকার অ্যারে প্রদর্শিত হয়, বিন্দুগুলি ফাঁকা হিসাবে অভিনয় করে।

আউটপুট : প্রতিটি ফাঁকা সীমানা-কক্ষের সাথে ইনপুট স্ট্রিংয়ের একটি প্রিন্ট আউট যার সাথে সম্পর্কিত তা অক্ষরের ছোট হাতের সংস্করণ দ্বারা প্রতিস্থাপিত হয়। (সাবপ্রগ্রাম মুদ্রণটি করে।

উদাহরণ 1

ইনপুট:

......B..
.........
...A.....
.........
.......D.
.........
.C.......
.....E...
.........

আউটপুট:

...ab.B..
....ab.bb
...A.abdd
aa...ad..
cca.ad.D.
..caeed..
.C.ce.edd
..ce.E.ee
..ce.....

সীমানা তুলে ধরে একটি স্কেচ:

সীমানা হাইলাইট করে একটি স্কেচ

উদাহরণ 2

ইনপুট:

............................U...........
......T.................................
........................................
.....................G..................
..R.......S..........F.D.E............I.
.........................H..............
.....YW.Z...............................
......X.................................
........................................
........................................
......MN...........V....................
......PQ................................
........................................
.............L...............J..........
........................................
........................................
....C...........K.......................
........................................
..................................A.....
...........B............................

আউটপুট:

..rt.....ts...sg......gduu..U.....ui....
..rt..T..ts...sg......gddeu......ui.....
...rt...ts....sg......gddeeu....ui......
....rttts.....sggggggGgdde.euuuui.......
..R.rywss.S....sfffffFdDdEeeeeeei.....I.
...ryywwzs.....sf....fddhHhhhhhhhi......
..ryyYWwZzs..sssffff.fddh.......hi......
..rxxxXxzzs.sllvvvvvffddh....hhhhi......
rrrxxxxnzzssl.lv....vfddh...hjjjjii.....
mmmmmmmnnnnnl.lv.....vvdh..hj....jai....
mmmmmmMNnnnnl.lv...V...vvhhj.....jaai...
ppppppPQqqql...lv.......vhj......ja.ai..
ppppp.pq.ql....lkv.....vjj.......ja..aii
cccccppqql...L.lkkv...vj.....J...ja...aa
.....cpqqlll..lk..kvvvvj........ja......
......cccbbbllk....kkkkj.......ja.......
....C...cb..bk..K......kj.....ja........
.......cb....bk........kjjjjjja.........
......cb......bk.......kaaaaaa....A.....
.....cb....B...bk......ka...............

রঙ বৃদ্ধি:

রঙ বৃদ্ধি


1
+1 টি; মজাদার; তবে আমি লক্ষ্য করেছি যে স্যাম্পল ইনপুট এবং আউটপুটে থাকা কোষগুলির প্রতিটি চরিত্রের মধ্যে প্যাডিংয়ের একটি জায়গা রয়েছে। এটি কি প্রয়োজন?
ডোরকনবব

@ ডুরকনোবফসনো - ওফ, আমার ভুল - এটি অনিচ্ছাকৃত ছিল। এগুলি সরাতে আমি সম্পাদনা করব।
মাঝামাঝি

সুতরাং পরিষ্কার হয়ে উঠতে এটি ম্যানহাটনের মেট্রিক ডায়াগ্রাম, ইউক্লিডিয়ান নয়? ভোরোনাই ডায়াগ্রামগুলি ইউক্লিডিয়ান মেট্রিক জায়গাগুলিতে বেশ শীতল হতে পারে ( এখানে দেখুন , বা যদি আপনার অনুলিপি থাকে তবে ব্লেন্ডার ফায়ার আপ করুন; এতে কিছু আকর্ষণীয় মেট্রিক রয়েছে)।
wchargin

@WChargin - মূলত, হ্যাঁ এখানে দুটি কক্ষের মধ্যে "দূরত্ব" হ'ল এক কক্ষ থেকে অন্য কোষে চলার জন্য প্রয়োজনীয় ন্যূনতম পদক্ষেপগুলি, কেবল পথে অনুভূমিকভাবে বা উল্লম্বভাবে সংলগ্ন কোষের মধ্যে পা রেখে। (এটা সবসময় নন-নেগেটিভ পূর্ণসংখ্যা।) এইরকম ট্যাক্সিক্যাব মেট্রিক যদি আমরা একটি শহর যার রাস্তায় শূন্য-চওড়া এবং যার ব্লক ইউনিট স্কোয়ার হয় রাস্তায়-ছেদ যেমন কোষ কল্পনা।
মাঝামাঝি

উত্তর:


5

গল্ফস্ক্রিপ্ট, 138 144 137 টি অক্ষর

:^n%,,{{^n/1$=2$>1<.'.'={;{@~@+@@+\{^3$?^<n/),\,@-abs@@-abs+99*+}++^'.
'-\$1<{32+}%}++[0..1.0..(.0]2/%..&,(\0='.'if}{@@;;}if}+^n?,%puts}/

স্ট্যাকের একক স্ট্রিং হিসাবে সাবপ্রোগ্রামকে ইনপুট দেওয়া হয়। দুর্ভাগ্যক্রমে আমাকে প্রয়োজন ব্যবহারের putsকারণে রুটিনের ফলাফল মুদ্রণ করতে হয়েছিল।

কোড ব্যাখ্যা

বাইরের ব্লকটি ইনপুট আয়তক্ষেত্রগুলির আকার অনুসারে মূলত সমস্ত অবস্থানের (x, y) উপরে লুপ করে। লুপের মধ্যে স্থানাঙ্কগুলি x এবং y প্রতিটি বার স্ট্যাকের উপর রেখে দেওয়া হয়। প্রতিটি লাইন শেষ হওয়ার পরে ফলাফলটি কনসোলে মুদ্রিত হয়।

:^              # save input in variable ^
n%,,{{          # split along newlines, count rows, make list [0..rows-1] 
    ???             # loop code, see below
}+^n?,%puts}/       # ^n?, count columns, make list [0..cols-1], loop and print

লুপের মধ্যে সম্পাদিত কোডটি প্রথমে ইনপুটটির সংশ্লিষ্ট চরিত্রটি গ্রহণ করে।

^n/                 # split input into lines
1$=                 # select the corresponding row
2$>1<               # select the corresponding col

তারপরে মূলত আমরা যাচাই করি, যদি আমাদের কাছে একটি থাকে ., তবে যদি আমাদের (সম্ভবত) চরিত্রটি প্রতিস্থাপন করতে হয়।

.'.'={              # if the character is '.'
    ;               # throw away the '.'
    ???             # perform more code (see below)
}{                  # else
    @@;;            # remove coordinates, i.e. keep the current character 
                    # (i.e. A, B, ... or \n)
}if                 # end if

আবার, অভ্যন্তরীণ কোডটি একটি লুপ দিয়ে শুরু হয়, এখন সমস্ত স্থানাঙ্কের (x, y) (x, y + 1) (x + 1, y) (x, y-1) (x-1, y) এর মাধ্যমে

{                   
    @~@+@@+\        # build coordinates x+dx, y+dy
    ???             # loop code
}++                 # push coordinates before executing loop code
[0..1.0..(.0]2/%    # loop over the coordinates [0 0] [0 1] [1 0] [0 -1] [-1 0]

সাম্প্রতিক অভ্যন্তরীণ কোড স্নিপেট দুটি স্থানাঙ্কের ভিত্তিতে কেবল নিকটতম বিন্দুর (লোয়ার কেস) চিঠিটি দেয়।

{                   # loop
    ^3$?^<          # find the current letter (A, B, ...) in the input string, 
                    # take anything before
    n/              # split at newlines
    ),              # from the last part take the length (i.e. column in which the letter is)
    \,              # count the number of lines remaining (i.e. row in which the letter is)
    @-abs@@-abs+    # calculate distance to the given coordinate x, y
    99*+            # multiply by 99 and add character value (used for sorting
                    # chars with equal distance)
}++                 # push the coordinates x, y
^'.
'-                  # remove '.' and newline
\$                  # now sort according to the code block above (i.e. by distance to letter)
1<{32+}%            # take the first one and make lowercase

স্থানাঙ্কগুলির জন্য নিকটস্থ পাঁচটি অক্ষর (x, y) (x, y + 1) (x + 1, y) (x, y-1) (x-1, y) এর মধ্যে প্রথমটি নিন, যদি সমস্ত না থাকে সমান, অন্যথায় নিতে .

.                   # copy five letter string
.&,(                # are there distinct letters?
\0=                 # first letter (i.e. nearest for coordinate x,y)
'.'                 # or dot
if                  # if command

আপনার কোডটি উদাহরণ 1 এর সাথে ঠিক আছে, তাই যখন আমি উদাহরণ 2-তে কিছু কোষগুলি ভুলভাবে করেছিলাম তখন আমি অবাক হয়েছিলাম: প্রথম তিনটি লাইনের প্রত্যেকটিতে এটি ".ui" কে যেখানে "ইউআই" রাখে। হওয়া উচিত এবং চতুর্থ লাইনে এটি "zs" যেখানে "গুলি" রাখে। হওয়া উচিত, এবং "ইউআইআই" রাখুন যেখানে "i।" হওয়া উচিত, ইত্যাদি ইত্যাদি
মাঝামাঝি

@res "সমানুক্রমিক - প্রথম বর্ণানুক্রমিক ক্রমে" অংশটি মিস করেছেন। দুর্ভাগ্যক্রমে, বাছাই অপারেশন স্থিতিশীল নয়। এটি ঠিক করার জন্য কয়েকটি অক্ষর যুক্ত হয়েছে।
হাওয়ার্ড

7

পাইথন 3 - 424 422 417 332 295 টি অক্ষর:

def v(s):
 w=s.find("\n")+1;n=(-1,1,-w,w);r=range(len(s));x=str.replace;s=x(x(s,*".~"),*"\n~")+"~"*w;t=0
 while s!=t:t=s;s=[min(s[i+j]for j in n).lower()if"~"==s[i]and(i+1)%w else s[i]for i in r]+["~"]*w
 print(x("".join(s[i]if any(s[i]!=s[i+j].lower()!="~"for j in n)else"."for i in r),*"~\n"))

পাইথনের সিনট্যাক্সের কারণে তিনটি অংশ রয়েছে যার প্রত্যেকটির নিজস্ব লাইনে থাকা দরকার:

  1. প্রথম লাইনটি ভেরিয়েবল সেট আপ করে। wবোর্ডের একটি সারির প্রস্থ (শেষের দিকে নিউলাইন সহ যা প্যাডিং কলাম হিসাবে পুনর্ব্যবহার করা হবে)। rএমন একটি rangeবস্তু যা সমস্ত অক্ষরকে সূচক করে snকোনও চরিত্রের প্রতিবেশীদের কাছে পেতে সূচি অফসেটগুলির একটি দ্বিচার (তাই যদি আপনি বর্ণগুলি তির্যকভাবে ছড়িয়ে দেওয়ার অনুমতি দিতে চান, তবে -w-1,-w+1,w-1,w+1আপনাকে কেবল টিপলটিতে যুক্ত করতে হবে)। পদ্ধতির xএকটি সংক্ষিপ্ত নাম str.replace, যা পরবর্তী কোডে বেশ কয়েকবার ব্যবহৃত হয় (প্রচলিতের x(s,*"xy")পরিবর্তে আমি অক্ষরগুলি সংরক্ষণ করতে ব্যবহার করি কারণ কলগুলি অদ্ভুত দেখাবে s.replace("x", "y"))। sপরামিতি স্ট্রিং পাশাপাশি এই সময়ে সামান্য রুপান্তরিত করা হয়েছে, তার .অক্ষর এবং নতুন লাইন দিয়ে প্রতিস্থাপিত হচ্ছে~অক্ষর (কারণ তারা সমস্ত অক্ষরের অনুসারে বাছাই করে)। একটি সারির মূল্যবান প্যাডিং ~অক্ষরও শেষে যুক্ত করা হয়। tপরে "পুরাতন" সংস্করণের রেফারেন্স হিসাবে ব্যবহৃত হবে s, তবে এটি sশুরুতে সমান নয় এমন কিছুতে সূচনা করা দরকার এবং শূন্যটি কেবল একটি অক্ষর গ্রহণ করে (আরও পাইথোনিক মান হবে None, তবে এটি তিনটি অতিরিক্ত অক্ষর) ।
  2. দ্বিতীয় লাইনে একটি লুপ রয়েছে যা sতালিকা বোঝার সাহায্যে বারবার আপডেট করে। ধী ইনডেক্স উপর iterates হিসাবে s, ~অক্ষর দ্বারা প্রতিস্থাপিত হয় minতাদের প্রতিবেশীদের। কোনও ~চরিত্র যদি অন্যের দ্বারা সম্পূর্ণরূপে ঘিরে থাকে ~তবে এটি কিছুই করবে না। এটি যদি এক বা একাধিক বর্ণের পাশে থাকে তবে এটি তাদের মধ্যে সবচেয়ে ছোট হয়ে যাবে (পক্ষপাতী "a"হওয়া "b"ইত্যাদি)। ~অক্ষরগুলিতে পরিবর্তিত নতুন লাইনেরগুলি মডুলাস অপারেটরের সাথে তাদের সূচিগুলি সনাক্ত করে সংরক্ষণ করা হয়। শেষের প্যাডিং সারিটি তালিকা বোধগমিতে আপডেট হয় না (কারণ সূচকের পরিসর, rতাদের যোগ করার আগে গণনা করা হয়েছিল s)। পরিবর্তে, একটি নতুন সারি~অক্ষরগুলি উপলব্ধি করার পরে যুক্ত করা হয় characters নোটটি sলুপের প্রথম পাসের পরে স্ট্রিংয়ের পরিবর্তে অক্ষরের তালিকায় পরিণত হয় (তবে পাইথন প্রকারের ক্ষেত্রে নমনীয় কারণ আমরা অক্ষরগুলি একইভাবে পেতে সূচক করতে পারি)।
  3. শেষ লাইনটি ডায়াগ্রামের অভ্যন্তরটি ফাঁকা করে এবং মুদ্রণের জন্য অক্ষরগুলিকে পুনরায় তৈরি করে। প্রথমত, কেবল নিজের নিজের অনুলিপি (বা ~প্যাডিংয়ের অক্ষর) দ্বারা ঘিরে থাকা কোনও অক্ষর প্রতিস্থাপন করে .। এরপরে, অক্ষরগুলি সমস্ত একত্রে একক স্ট্রিংয়ে সংমিশ্রিত হয়। পরিশেষে, প্যাডিং ~অক্ষরগুলি নতুন লাইনে ফিরে রূপান্তরিত হয় এবং স্ট্রিংটি মুদ্রিত হয়।

সম্ভবত r=rangeএকটি কলযোগ্য পদ্ধতির অংশ হিসাবে বিবেচনা করার জন্য ফাংশন বডির অভ্যন্তরে থাকা উচিত, তবে আপনি লেখার মাধ্যমে অক্ষরগুলি সংরক্ষণ করতে পারেন r=range;s=[l.replace। এছাড়া আপনি আরো অক্ষর লেখা দ্বারা আলিঙ্গন করতে পারেন if"~"==s[y][x]elseএবং if"~"==s[y][x]else(এই দৌড়ে আমার জন্য পাইথন 2.7 সঙ্গে BTW,) 422. মোট জন্য,
মাঝামাঝি

@ রিস: এই পরামর্শগুলির জন্য ধন্যবাদ। আমি r=rangeফাংশনটির প্রথম লাইনটির শেষে রেখেছি (যেখানে আমি অন্যান্য ভেরিয়েবলগুলি সেট আপ করেছি) এবং কয়েকটা স্পেস শেভ করেছিলাম যা আমি আগে মিস করেছি before আপনি যে বিষয়টি উল্লেখ করছেন সেটি দু'জনেই পেয়েছি কিনা তা আমি নিশ্চিত নই, যেমন আপনি দু'বার একই জিনিস উল্লেখ করেছেন বলে মনে হয়। এবং পাইথন ২.7 এ এটি আরও দুটি অক্ষর আরও ছোট হতে পারে, যেহেতু পরে আপনার প্রথম বন্ধনী প্রয়োজন হয় না print(সাধারণত এটি কেবলমাত্র 1 অক্ষর সংরক্ষণ করে, তবে print"\n".join(...)কাজ করে)।
ব্ল্যাককিংহিট

ওহো, আমি দ্বিতীয়টি ভুল-পেস্ট করেছি। এটি s[y][x]for(কোনও স্থান অপসারণ) করার কথা ছিল তবে আপনি যেভাবেই এটি খুঁজে পেয়েছেন বলে মনে হয়।
মাঝামাঝি

হ্যাঁ, আমি পেয়েছি এটি অন্য এক। আমি কেবলমাত্র একটি বৃহত্তর পরিবর্তনের চেষ্টা করার সিদ্ধান্ত নিয়েছি এবং 2 ডি তালিকার চেয়ে 1 ডি তে চলেছি, যা একগুচ্ছ অক্ষর সংরক্ষণ করেছে!
ব্ল্যাককিংহাট

3

পাইথন, 229 226 অক্ষর

def F(s):
 e,f,b='~.\n';N=s.index(b)+1;s=s.replace(f,e)
 for i in 2*N*e:s=''.join(min([x[0]]+[[y.lower()for y in x if y>b],all(y.lower()in f+b+x[0]for y in x)*[f]][x[0]!=e])for x in zip(s,s[1:]+b,s[N:]+b*N,b+s,b*N+s))
 print s

F("""......B..
.........
...A.....
.........
.......D.
.........
.C.......
.....E...
.........
""")

ফলাফল গণনা করতে একটি বন্যা পূরণ করে। পিছনে for/ zipকম্বো xপ্রতিটি কক্ষের জন্য একটি অ্যারে উত্পন্ন করে যা সেই ঘরে এবং এর চারটি প্রতিবেশীর মান ধারণ করে। তারপরে আমরা ব্ল্যাককিংহিটের কৌশল এবং minপ্রতিটি কক্ষের জন্য সম্ভাবনার একগুচ্ছ ব্যবহার করি । সেগুলি আসল কক্ষের মান, যে কোনও প্রতিবেশী সেলটি এখনও পরিদর্শন না করা .হলে , বা যদি এটি পরিদর্শন করা হয়েছে এবং সমস্ত প্রতিবেশী .সেলে তার নিজের বা তার সমান।


যেহেতু সাবপ্রগ্রামটি মুদ্রণ করার কথা, তাই আপনি কেবল এতে পরিবর্তন return sকরতে পারেন print s। এছাড়াও, এ y!=bপরিবর্তন করা যাবে না y>b? আমার মনে হয় এটি 226 টি চরিত্র তৈরি করবে।
মাঝামাঝি

3

এটা এখানে. এটি আমার প্রথম এফ # প্রোগ্রাম। যদি আমি ভাষার কোনও বৈশিষ্ট্যটি মিস করি তবে দয়া করে আমাকে সতর্ক করুন কারণ আমি এখনও শিখছি।

এখানে আমার নমুনা ইনপুট

 . . . . . . . . . . . . . . . . . . . . . . . . .
 . . . . . . . . . . . . B . . . . . . . . . . . .
 . . . . . . . . . . . . . . . . . . . . . . . . .
 . . . . . . . . A . . . . . . . . . . . . . . . .
 . . . . . . . . . . . . . . . . . . . . . . . . .
 . . . . . . . . . . . . . . . . C . . . . . . . .
 . . . . . . . . . . . . . . . . . . . . . . . . .
 . . . . . . . . . . . . . . . . . . . G . . . . .
 . . . . . . . D . . . . . . . . . . . . . . . . .
 . . . . . . . . F . . . . . . . . . . . . . . . .
 . . . . . . . E . . . . . . . . . . . . . . . . .
 . . . . . . . . . . . . . . . . . . . . . . . . .
 . . . . . . . . . . . . . . . . . . . . . . . . .
 . . . . . . . . . . . . . . . . . . . . . . . . .

এখানে আউটপুট

 . . . . . . . . . a b . . . . . . . b g . . . . .
 . . . . . . . . . a b . B . . . b b b g . . . . .
 . . . . . . . . . . a b . . . b c c c g . . . . .
 . . . . . . . . A . . a b . b c . . c g . . . . .
 . . . . . . . . . . . a b b c . . . c g . . . . .
 a a a a a a a a . . . a b c . . C . c g . . . . .
 d d d d d d d d a a a a b c . . . c g . . . . . .
 . . . . . . . . d d d d b c . . c g . G . . . . .
 . . . . . . . D d d d d d c . . c g . . . . . . .
 d d d d d d d d f f f f f f c . c g . . . . . . .
 e e e e e e e e e e e e e e c . c g . . . . . . .
 . . . . . . . . . . . . . e c . c g . . . . . . .
 . . . . . . . . . . . . . e c . c g . . . . . . .
 . . . . . . . . . . . . . e c . c g . . . . . . .

কোডটি এখানে। উপভোগ করুন।

// The first thing that we need is some data. 
let originalData = [
     "........................."
     "............B............" 
     "........................." 
     "........A................" 
     "........................." 
     "................C........"          
     "........................." 
     "...................G....." 
     ".......D................." 
     "........F................"           
     ".......E................."          
     "........................."
     "........................."
     "........................."
     ]

এখন আমাদের সেই ডেটাটিকে একটি দ্বৈত মাত্রার অ্যারে রূপান্তর করতে হবে যাতে আমরা সূচকগুলির মাধ্যমে এটি অ্যাক্সেস করতে পারি।

let dataMatrix = 
    originalData
    |> List.map (fun st -> st.ToCharArray())
    |> List.toArray

// We are going to need a concept of ownership for each
// cell. 
type Owned = 
    | Unclaimed
    | Owner of char
    | Claimed of char
    | Boundary of char

আসুন প্রতিটি কক্ষের মালিকানা উপস্থাপন করে একটি ম্যাট্রিক্স তৈরি করি

let claims =
    dataMatrix
    |> Array.map (fun row ->
        row
        |> Array.map (function
            | '.' -> Owned.Unclaimed
            | ch -> Owned.Owner(ch))
        )

কী ঘটেছে তা দেখার জন্য আমাদের একটি ইউটিলিটি পদ্ধতি থাকা উচিত।

let printIt () =
    printfn ""
    claims
    |> Array.iter (fun row ->
        row |> Array.iter (function
            | Owned.Claimed(ch) -> printf " ." 
            | Owned.Owner(ch) -> printf " %c" ch
            | Owned.Boundary(ch) -> printf " %c" ch
            | _ -> printf " ." )
        printfn "")            

আসুন যেখানে একটি নির্দিষ্ট মূলধন চিঠি থাকে সেখানে উপস্থাপনের জন্য একটি রেকর্ড তৈরি করি।

type CapitalLocation = { X:int; Y:int; Letter:char }

এখন আমরা সমস্ত বড় বড় অক্ষর খুঁজে পেতে চাই।

let capitals = 
    dataMatrix
    |> Array.mapi (fun y row -> 
        row 
        |> Array.mapi (fun x item -> 
            match item with
            | '.' -> None
            | _ -> Some({ X=x; Y=y; Letter=item }))
        |> Array.choose id
        |> Array.toList
        )
    |> Array.fold (fun acc item -> item @ acc) List.empty<CapitalLocation>
    |> List.sortBy (fun item -> item.Letter)

আমরা যেমন এগিয়ে চলেছি ততই আমাদের দিকনির্দেশনার ধারণা দরকার।

type Direction =
    | Left = 0
    | Up = 1
    | Right = 2
    | Down = 3   

// Function gets the coordinates of the adjacent cell. 
let getCoordinates (x, y) direction =
    match direction with
    | Direction.Left -> x-1, y
    | Direction.Up -> x, y-1
    | Direction.Right -> x+1, y
    | Direction.Down -> x, y+1
    | _ -> (-1,-1) // TODO: Figure out how to best throw an error here. 

আমরা যেমন এগিয়ে চলেছি, আমাদের আকার সম্পর্কে জানতে হবে। এটি আমাদের সীমা ছাড়িয়ে যাচ্ছে কিনা তা নিরীক্ষণে সহায়তা করবে।

type Size = { Width:int; Height: int }    

// Get the size of the matrix. 
let size = {Width=originalData.Head.Length; Height=originalData.Length}

অ্যাক্টিভ প্যাটার্ন: প্রদত্ত ঘরের মানদণ্ডের সাথে মেলে।

let (|OutOfBounds|UnclaimedCell|Claimed|Boundary|) (x,y) =
    match (x,y) with 
    | _,_ when x < 0 || y < 0 -> OutOfBounds
    | _,_ when x >= size.Width || y >= size.Height -> OutOfBounds
    | _ ->                     
        match claims.[y].[x] with
        | Owned.Unclaimed -> UnclaimedCell(x,y)
        | Owned.Claimed(ch) -> Claimed(x,y,ch)
        | Owned.Boundary(ch) -> Boundary(x,y,ch)
        | Owned.Owner(ch) -> Claimed(x,y,ch)

এখন আমরা ব্রাস ট্যাক্স নেমে যাচ্ছি। এটি সেল দাবি!

let claimCell letter (x, y) =         
    // Side effect: Change the value of the cell
    (claims.[y].[x] <- Owned.Claimed (System.Char.ToLower letter)) |> ignore

সক্রিয় প্যাটার্ন ব্যবহার করে, দাবিবিহীন থাকলে এই কক্ষটি দাবি করুন এবং সংলগ্ন ঘরগুলির স্থানাঙ্কগুলি ফিরিয়ে দিন।

let claimAndReturnAdjacentCells (letter, coordinates, direction) =
    match coordinates with 
    | UnclaimedCell (x,y) ->         
        // Claim it and return the Owned object.
        claimCell letter coordinates // meaningful side effect
        // use Direction as int to allow math to be performed. 
        let directionInt = int direction;            
        Some(
            // [counter-clockwise; forward; clockwise]
            [(directionInt+3)%4; directionInt; (directionInt+1)%4]                 
            |> List.map enum<Direction>                 
            |> List.map (fun newDirection -> 
                (
                    letter, 
                    getCoordinates coordinates newDirection, 
                    newDirection
                ))
        )
    | Claimed(cx,cy,cch) when cch <> System.Char.ToLower letter-> 
        // If we find a "Claimed" element that is not our letter, we have 
        // hit a boundary. Change "Claimed" to "Boundary" and return the 
        // element that led us to evaluating this element. It is also a 
        // boundary. 
        (claims.[cy].[cx] <- Owned.Boundary (System.Char.ToLower cch)) |> ignore
        let reverseDirection = enum<Direction>(((int direction)+2)%4)
        Some[(
            cch,
            getCoordinates (cx, cy) reverseDirection,
            reverseDirection
        )]
    | _ -> None

আমরা এই ডেটা ব্যাগের তালিকা তৈরি শুরু করছি, আসুন বিষয়গুলি আরও পরিষ্কার করার জন্য একটি প্রকার তৈরি করি।

type CellClaimCriteria = (char * (int * int) * Direction)

দাবী কক্ষগুলির জন্য সমালোচনার তালিকা দেওয়া, আমরা পরবর্তী কোষগুলিকে দাবী করতে ফিরে আসছি এবং সেই তালিকাটিতে পুনরাবৃত্তি করব over

let rec claimCells (items:CellClaimCriteria list) =
    items
    |> List.fold (fun acc item ->
        let results = claimAndReturnAdjacentCells item 
        if Option.isSome(results) 
        then (acc @ Option.get results) 
        else acc
        ) List.empty<CellClaimCriteria> 
    |> (fun l ->            
        match l with
        | [] -> []
        | _ -> claimCells l)

প্রতিটি মূলধনের জন্য, প্রতিটি দিকে একটি দাবির মানদণ্ড তৈরি করুন এবং তারপরে পুনরাবৃত্তভাবে সেগুলি দাবি করুন।

let claimCellsFromCapitalsOut ()=
    capitals
    |> List.fold (fun acc capital ->
        let getCoordinates = getCoordinates (capital.X, capital.Y)
        [Direction.Left; Direction.Up; Direction.Right; Direction.Down]
        |> List.map (fun direction ->                
            (
                capital.Letter, 
                getCoordinates direction, 
                direction
            ))
        |> (fun items -> acc @ items)) List.empty<CellClaimCriteria>
    |> claimCells

প্রতিটি প্রোগ্রামের একটি প্রধান প্রয়োজন।

[<EntryPoint>]
let main args = 
    printIt()
    claimCellsFromCapitalsOut()
    printIt()
    0

আপনার সাথে পরিচিত না এমন ভাষায় কাজের সমাধান পাওয়ার জন্য ভাল। যাইহোক, আপনি চূড়ান্ত পদক্ষেপ মিস করেছি: এই হল কোড-গলফ , যার মানে লক্ষ্য সম্ভাব্য স্বল্পতম প্রোগ্রাম লিখতে হয়: একক-অক্ষর শনাক্তকারী, শুধুমাত্র হোয়াইটস্পেস যা কঠোরভাবে কম্পাইল করার প্রয়োজন বোধ করা হয়, ইত্যাদি
পিটার টেলর

3
পিটারটেলর আপনি ঠিক বলেছেন। আমি সেটা মিস করছিলাম. এই সাইটের আরও "প্রোগ্রামিং ধাঁধা" এবং কম "কোড গল্ফ" প্রয়োজন।
ফিলিপ স্কট
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.