এটা এখানে. এটি আমার প্রথম এফ # প্রোগ্রাম। যদি আমি ভাষার কোনও বৈশিষ্ট্যটি মিস করি তবে দয়া করে আমাকে সতর্ক করুন কারণ আমি এখনও শিখছি।
এখানে আমার নমুনা ইনপুট
. . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . 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
