আপনার জমি কত মহান?

Question

এই চ্যালেঞ্জের মধ্যে, আপনি জমিটি কত দুর্দান্ত তা গণনা করবেন।

---

এমন একটি প্রোগ্রাম বা ফাংশন লিখুন যা আপনার জমির আকার নির্ধারণ করে দেয়াল দিয়ে দেয় given আপনাকে একটি খালি খালি ইনপুট স্ট্রিং দেওয়া হয়েছে যা আপনার পছন্দের 4 টি স্বতন্ত্র অক্ষরের একটি সেট রয়েছে যা "উপরে", "নীচে", "বাম" এবং "ডান" ( ^ v < >এই চ্যালেঞ্জটিতে আমি ব্যবহার করব ) চার দিককে উপস্থাপন করে । 180 ডিগ্রি টার্ন ( <>বা ^v) নেওয়া সম্ভব নয় তবে আপনি নিজের প্রাচীরটি অতিক্রম করতে পারেন।

আপনি যেভাবে জমিটি "ক্যাপচার" করেছেন তা এটি আপনার প্রাচীর দিয়ে ঘিরে রাখা। প্রাচীর নিজেই আপনার জমির অংশ হিসাবে বিবেচিত হয়। কয়েকটি উদাহরণ এটি আরও পরিষ্কার করে দেবে। আমি oপ্রাচীর দ্বারা বেষ্টিত ভূমির xজন্য, প্রাচীর নিজেই এবং প্রাচীরের Sপ্রারম্ভিক পয়েন্টের জন্য কেবল প্রাচীরটি কীভাবে নির্মিত তা চিত্রিত করার জন্য ব্যবহার করব। আউটপুট তোমাদেরকে তোমাদের দেশ থেকে মোট আকার হওয়া উচিত (সংখ্যা o, xএবং Sনিচে পরীক্ষা ক্ষেত্রেই)।

Input: >>>>
Land: Sxxxx
Output: 5

Input: <<<^^^>>>vv
Land:
xxxx
xoox
xoox
xxxS
Output: 16

Input: <<<^^^>>>v
Land:
xxxx
x  x
x  
xxxS 
Output: 11

Input: <
Land: xS
Output: 2 

Input: >>>>>>vvvvvvvvv<<<<<^^^^>>>>>>>>vvvvvvvvvv<<<<<<<<<<<<<<<^^^^^^^^^>>>vvvvvv<<<<<
Land:
        Sxxxxxx
              x
              x
              x
              x  
         xxxxxxxxx
  xxxx   xoooox  x
  xoox   xoooox  x
  xoox   xoooox  x
  xoox   xxxxxx  x
  xoox           x
  xoox           x
xxxxxx           x
  x              x
  x              x
  xxxxxxxxxxxxxxxx
Output: 101

Input: >>vvvv>>^^<<<<^
Land:
Sxx
xox
xxxxx
  xox
  xxx
Output: 17

Input: <<^^^>>>vv
Land:
xxxx
x  x
x  x
xxS
Output: 11   <- Note, diagonal edges do not close the "loop"

ব্যাখ্যা:

• আপনার প্রাচীর আঁকার দরকার নেই, আউটপুট কেবলমাত্র পূর্ণসংখ্যা হওয়া উচিত
• ইনপুট ফর্ম্যাট .চ্ছিক। আপনার সাথে একটি স্ট্রিং সময় লাগতে পারে <>^v, সংখ্যা একটি তালিকা (1, -1, i, -i), অক্ষরের একটি তালিকা ABCDইত্যাদি

---

এটি কোড-গল্ফ তাই প্রতিটি ভাষার সংক্ষিপ্ততম কোড জিততে পারে। মনে রাখবেন, ব্যাখ্যাগুলি এমনকি "নিয়মিত" ভাষায় গুরুত্বপূর্ণ!

Comments

আপনার বিবরণটি পরিবর্তন করা উচিত যাতে এটি গণনা করে যে আপনি কতগুলি ক্লোভার বন্ধ করেছেন: P

— fəˈnɛtɪk

কিছুটা সম্পর্কিত

— অ্যারনল্ড

সম্পর্কিত?

— ম্যাথু রোহ

@ ম্যাথেরহোহ, হুম্ম্ম ।

— স্টিভি গ্রিফিন

ওহ @Stewie হ্যাঁ, তাও আবার সাথে সম্পর্কিত হচ্ছে

— ম্যাথু রোহ

Answer 1

পাইথন 2 , 385 345 332 বাইট

A,I,R=max,min,range
a=b=0
p=[[a,b]]
for i in input():a+=i%2*(2-i);b+=(1-i%2)*(1-i);p+=[a,b],
k,l=zip(*p)
x=A(k)-I(k)+3
y=A(l)-I(l)+3
o=[[1]*y for _ in' '*x]
def g(m,n):
 if 0<o[m][n]and[m+I(k)-1,n+I(l)-1]not in p:o[m][n]=0;[g(i,j)for i in R(A(0,m-1),I(x,m+2))for j in R(A(0,n-1),I(y,n+2))if(i,j)!=(m,n)]
g(0,0)
print sum(map(sum,o))

এটি অনলাইন চেষ্টা করুন! বা সমস্ত পরীক্ষার কেস চেষ্টা করে দেখুন

ইনপুটটি সংখ্যাগত, 0 ~ 3, প্রতীকগুলির 0-সূচক এখানে: >v<^

#starting position
a,b=0
#new list to hold the wall coordinates
p=[[a,b]]

#iterate over the input calculating
#the next coordinate and storing on p
for i in input():
 a=a+i%2*(2-i)
 b=b+(1-i%2)*(1-i)
 p+=[[a,b]]
#i%2*(2-i) and (1-i%2)*(1-i) generate the increment
#of each symbol from last position 
# >/0 : (0,1)
# v/1 : (1,0)
# </2 : (0,-1)
# ^/3 : (-1,0)

#transpose the coordinate list
k,l=zip(*p)
#calculate the difference between the max and min values
#to generate the total land size
#adding a border to avoid dead-ends
x=max(k)-min(k)+3
y=max(l)-min(l)+3

#create a matrix of 1's with the total land size
o=[([1]*y) for _ in ' '*x]

#recursive function that sets a cell to 0
#and call itself again on all surrounding cells
def g(m,n):
 #correct the indexes (like negative ones)
 a,b=m+min(k)-1,n+min(l)-1
 #if this cell contains 1 and don't belong to the wall
 if o[m][n]>0 and (a,b) not in p:
  #sets to 0
  o[m][n]=0
  #call again on surrounding cells
  for i in range(max(0,m-1),min(x,m+2)):
   for j in range(max(0,n-1), min(y,n+2)):
    if (i,j)!=(m,n):g(i,j)

#call the recursive function o origin
g(0,0)
#print the sum of the cells
print sum(map(sum,o))

এটি ফলাফল ম্যাট্রিক্স:

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0]
[0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0]
[0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0]
[0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0]
[0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0]
[0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
[0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
[0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

Answer 2

অক্টাভা, 83 85 83 79 বাইট

@(p)nnz(bwfill(accumarray([real(c=cumsum([0;p])) imag(c)]+nnz(p)+1,1),"holes"))

অষ্টাভে অনলাইন এ চেষ্টা করুন!

এমন একটি ফাংশন যা কলাম ভেক্টরযুক্ত ইনপুট হিসাবে নেয় (1, -1, i, -i)

@ ল্যানলক ৪ এর ম্যাথমেটিকা ​​উত্তরের পদ্ধতির ব্যবহার করে তাদের থেকে স্থানাঙ্কের মিনিট বিয়োগের পরিবর্তে ধনাত্মক স্থানাঙ্কগুলি এড়াতে স্থানাঙ্কগুলিতে ইনপুটটির দৈর্ঘ্য যোগ করা। 4 টি বাইট সংরক্ষণ করা হয়েছে।

পূর্ববর্তী উত্তর:

@(p)nnz(bwfill(accumarray((k=[real(c=cumsum([0;p])) imag(c)])-min(k)+1,1),"holes"))

অষ্টাভে অনলাইন এ চেষ্টা করুন!

আরও ভাল ভিজ্যুয়ালাইজেশনের জন্য পরিবর্তন করা হয়েছে।

ব্যাখ্যা:

%compute position of walls
c= cumsum([0;p]) % p should be top padded with a 0
row = real(c);
col = imag(c);
k = [row col];

%offset positions so all positions become positive
pos = k - min(k) +1;
%create a binary array that is 1 for walls and 0 elsewhere
bin = ~~accumarray(pos,1);

        *******   
              *   
              *   
              *   
              *   
         *********
  ****   *    *  *
  *  *   *    *  *
  *  *   *    *  *
  *  *   ******  *
  *  *           *
  *  *           *
******           *
  *              *
  *              *
  ****************

%use flood fill to fill holes
filled = bwfill(bin, 'holes');

        *******   
              *   
              *   
              *   
              *   
         *********
  ****   ******  *
  ****   ******  *
  ****   ******  *
  ****   ******  *
  ****           *
  ****           *
******           *
  *              *
  *              *
  ****************

%count number of ones in the filled image 
result = nnz(filled) 

Answer 3

হাস্কেল, 579 530 বাইট

y=length
i=filter
u i e l=take i l++[e]++drop(i+1)l
k v(r,c)g=u r(u c v(g!!r))g
b(r,c)g=g!!r!!c
w(r,c)s g=case s of{""->j;'<':t->w(r,c-1)t j;'>':t->w(r,c+1)t j;'v':t->w(r+1,c)t j;'^':t->w(r-1,c)t j}where j=k 2(r,c)g
e[]v g=g;e(x:d)v g|elem x v||b x g/=1=e d v g|b x g==1=e(d++(i(\x->notElem x v)$i(\(r,c)->r>=0&&c>=0&&r<y g&&c<y(g!!0))$a x))(x:v)(k 0 x g)
a(r,c)=[(r+1,c+1),(r+1,c),(r+1,c-1),(r,c+1),(r,c-1),(r-1,c+1),(r-1,c),(r-1,c-1)]
m s=(y.i(/=0).concat.e[(0,0)][])(w(l+1,l+1)s(map(\_->map(\_->1)q)q))where l=y s;q=[0..2*l+2]

mএটি হ'ল মূল ফাংশন, যা একটি স্ট্রিং নিয়ে যায় v^<>এবং উপযুক্ত পূর্ণসংখ্যা প্রদান করে।

Ungolfed:

import Data.Set hiding (map, filter)

-- Generate a grid full of ones, of width and height 2x+1. We pass the length of
-- the input, and get back a grid that we could never go out of bounds from,
-- even when the input is a straight wall in any direction.
genGrid :: Int  -> [[Int]]
genGrid x = map (\_->map(\_->1) [0..2*x+2]) [0..2*x+2]

-- Update the value of a list l, such that index i now contains the value e
update :: Int -> a -> [a] -> [a]
update i e l = take i l ++ [e] ++ drop (i+1) l

-- scale update to two dimensions
set :: a -> (Int, Int) -> [[a]] -> [[a]]
set val (r,c) g = update r (update c val (g !! r)) g

-- index into a 2D array
at :: (Int, Int) -> [[a]] -> a
at (r,c) g = g !! r !! c

-- Walk the wall path. Replace any 1 we step on with a 2. Start walking from
-- given coordinates, recursively updating the spot we step on as we process
-- the input string.
walk :: (Int, Int) -> String -> [[Int]] -> [[Int]]
walk (r,c) s g = case s of
    "" -> set 2 (r,c) g
    '<':t -> walk (r,c-1) t (set 2 (r,c) g)
    '>':t -> walk (r,c+1) t (set 2 (r,c) g)
    'v':t -> walk (r+1,c) t (set 2 (r,c) g)
    '^':t -> walk (r-1,c) t (set 2 (r,c) g)

-- Given an input string, generate a grid of appropriate size and walk out the
-- wall path starting at the center.
sketch :: String -> [[Int]]
sketch s = let l = length s in walk (l+1,l+1) s (genGrid l)

-- Breadth-first exploration of the 2D grid, but do not pass through walls.
-- Will touch everything that's not part of the land, and mark it as not part
-- of the land. We use a set (a list in the golfed version) to keep track
-- of which coordinates we've already explored.
explore :: [(Int, Int)] -> Set (Int, Int) -> [[Int]] -> [[Int]]
explore [] v g = g
explore (x:cs) v g
    | member x v  = explore cs v g
    | at x g == 2 = explore cs v g
    | at x g == 0 = explore cs v g
    | at x g == 1 =
        explore (cs ++ (filter (\x-> notMember x v) $ filtBound g $ adj x))
            (insert x v) (set 0 x g)

-- Count everything marked as land to get the final total
countLand :: [[Int]] -> Int
countLand = length . filter (/=0) . concat

-- for a given list of coordinates and a 2D grid, filter those coordinates that
-- are within the grid's bounds
filtBound :: [[Int]] -> [(Int, Int)] -> [(Int, Int)]
filtBound g = filter (\(r,c) -> r >= 0 && c >= 0 && r < length g && c < length (g !! 0))

-- Given a coordinate, get all the adjacent coordinates, including diagonally
-- adjacent coordinates.
adj :: (Int, Int) -> [(Int, Int)]
adj (r,c) = [(r+1,c+1),(r+1,c),(r+1,c-1),(r,c+1),(r,c-1),(r-1,c+1),(r-1,c),(r-1,c-1)]

-- The main function
runMain :: String -> Int
runMain = countLand . explore [(0,0)] empty . sketch

-- Print a grid (for debugging & REPL convenience)
printG :: [[Int]] -> String
printG = concat . map ('\n':) . map show

Answer 4

গণিত, 124 বাইট

আপনি সম্ভবত জেনে অবাক হবেন না যে ম্যাথামেটিকার প্রাচীর দ্বারা ঘেরা অঞ্চলটি পরিমাপের জন্য একটি বিল্ট-ইন ফাংশন রয়েছে। দুর্ভাগ্যবশত, এটা বেশ bytey আছে: ComponentMeasurements[..., "FilledCount", CornerNeighbors -> False]।

এটি মাথায় রেখে, এখানে আমার পুরো উত্তর। এটি এমন একটি ফাংশন যা 1, i, -1 বা -i এর তালিকা নেয়:

1/.ComponentMeasurements[SparseArray[{Re@#,Im@#}&/@FoldList[#+#2&,2(1+I)Length@#,#]->1],"FilledCount",CornerNeighbors->1<0]&

ব্যাখ্যা:

• FoldList[#+#2&,2(1+I)Length@#,#]স্থানাঙ্ক 2 (1 + i) (প্রাচীরের দৈর্ঘ্য) এ শুরু করে এবং ক্রমান্বয়ে ইনপুট তালিকার উপাদানগুলি যুক্ত করে প্রাচীর তৈরি করে। (প্রাচীরের স্থানাঙ্কগুলি ইতিবাচক থাকবে কিনা তা নিশ্চিত করার জন্য আমাদের হাস্যকরভাবে বড় সমন্বয় 2 (1 + i) (প্রাচীরের দৈর্ঘ্য) থেকে শুরু করতে হবে))
• SparseArray[{Re@#,Im@#}&/@...->1] এই সমন্বয়গুলি জটিল সংখ্যার জোড় জোড়গুলিতে পরিণত করে এবং প্রাচীর যেখানে রয়েছে সেদিকে 1 সে 0 এবং অন্য কোথাও 0 টি দিয়ে একটি অ্যারে তৈরি করে।
• 1/.ComponentMeasurements[...,"FilledCount",CornerNeighbors->1<0]& প্রাচীর দ্বারা আবদ্ধ অঞ্চল পরিমাপ করতে অন্তর্নির্মিত গাণিতিক যাদু ব্যবহার করে।

Comments

"আমাদের হাস্যকরভাবে বড় সমন্বয় থেকে শুরু করতে হবে ..." ভাল কৌশল!

— rahnema1

Answer 5

পিএইচপি> = 5.6.2, 888 বাইট

অনলাইন সংস্করণ

<?$h=$v=0;
s($v,$h,S);
for($z=0;$z<strlen($i=$_GET[0]);){
2<($b=$i[$z++])?$h--:($b>1?$v++:($b?$h++:$v--));
$e=max($h,$e);
$w=min($h,$w);
$n=min($v,$n);
$s=max($v,$s);
s($v,$h,X);}
$f=($e-$w+1)*($s-$n+1);
ksort($a);
function i($v,$h){global$a;return isset($a[$v][$h])&&$a[$v][$h]==" ";}
function s($v,$h,$l=" "){global$a;$a[$v][$h]=$l;}
function c($v,$h,$n=1){global$a;
foreach($r=range(-1,$n)as$i)
foreach($r as$j)
if(($i+$j)&&i($v+$i,$h+$j)){if($n)s($v,$h);return 1;}return;}
foreach($a as$v=>$z){
foreach(range($w,$e)as$h){
if(!isset($a[$v][$h])){
if(($v==$s)||($v==$n)||($h==$e)||($h==$w)||c($v,$h,0))s($v,$h);
else$c[]=[$v,$h];}
}ksort($a[$v]);}
while($z){$z=0;
foreach($c as$b=>$w){if(c(...$w)){$z++;unset($c[$b]);}}};
foreach($c as$b=>$w)$a[$w[0]][$w{1}]=O;
foreach($a as $k=>$v){ksort($a[$k]);$g.=join($a[$k])."\n";}echo $g;
echo $f-substr_count($g," ");

Comments

আপনি জানেন যে আপনাকে কেবল জমির আকার দিতে হবে, জমি নিজেই ঠিক নয়? :)

— স্টিভি গ্রিফিন

@ স্টেভিগ্রিফিন এটি জমির আউটপুট ´echo $ g;।। আমি এই পদ্ধতির সন্ধান পেয়েছি এবং এটি সম্ভবত অন্য একটি ছোট উপায়ে রয়েছে। যদি আমি এইভাবে খুঁজে পাই তবে আমি এই পোস্টটিকে উন্নত করতে পারি

— J:13rg Hülsermann