आपकी भूमि कितनी महान है?

Question

इस चुनौती में, आप गणना करेंगे कि आपकी भूमि कितनी महान है।

---

एक कार्यक्रम या फ़ंक्शन लिखें जो आपकी जमीन के आकार की गणना करता है, जिसे आपके द्वारा बनाई गई दीवार दी गई है। आपको एक गैर-रिक्त इनपुट स्ट्रिंग दी जाती है जिसमें आपकी पसंद के 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

आपको विवरण बदलना चाहिए ताकि यह गणना करे कि आपने कितने

— क्लोवर

कुछ हद तक संबंधित

— अरनुलद

सम्बंधित?

— मैथ्यू रो

@ मैथ्यू रो, हम्म ।

— स्टीवी ग्रिफिन

@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)

@ Lanlock4 के गणितज्ञ उत्तर के दृष्टिकोण का उपयोग करते हुए इनपुट की लंबाई को जोड़ने के लिए निर्देशांक से गैर सकारात्मक निर्देशांक से बचने के लिए, बजाय उनसे निर्देशांक के न्यूनतम घटाकर। बचा 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 बाइट्स

आपको शायद यह जानकर आश्चर्य नहीं होगा कि एक दीवार से घिरे क्षेत्र को मापने के लिए गणितज्ञ के पास एक अंतर्निहित फ़ंक्शन है। दुर्भाग्य से, यह काफी बाइटी है 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] इन निर्देशांकों को जटिल संख्याओं से पूर्णांक के जोड़े में बदल देता है, और 1s के साथ एक सरणी बनाता है जहां दीवार और 0s कहीं और है।
• 1/.ComponentMeasurements[...,"FilledCount",CornerNeighbors->1<0]& दीवार से घिरे क्षेत्र को मापने के लिए अंतर्निहित मैथेमेटिका जादू का उपयोग करता है।

Comments

"हमें हास्यास्पद बड़े समन्वय पर शुरू करना होगा ..." अच्छी चाल!

— rahnema1

Answer 5

PHP> = 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

आप जानते हैं कि आपको केवल भूमि के आकार का ही उत्पादन करना था, न कि भूमि का ही सही? :)

— स्टीवी ग्रिफ़िन

@StewieGriffin यह ´echo $ g; भूमि का आउटपुट है। मुझे यह दृष्टिकोण मिला और हो सकता है कि यह दूसरे तरीके से मौजूद हो। अगर मुझे इस तरह से मिला तो मैं इस पोस्ट को बेहतर कर सकता हूं

— जोर्ग ह्यूल्सरमैन