ในการท้าทายนี้คุณจะคำนวณว่าที่ดินของคุณดีแค่ไหน

เขียนโปรแกรมหรือฟังก์ชั่นที่คำนวณขนาดที่ดินของคุณจากกำแพงที่คุณสร้างขึ้น คุณได้รับสตริงป้อนข้อมูลที่ไม่ว่างประกอบด้วยชุดอักขระ 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ฯลฯ

นี่คือรหัส - กอล์ฟดังนั้นรหัสที่สั้นที่สุดในแต่ละภาษาชนะ โปรดจำไว้ว่าคำอธิบายมีความสำคัญแม้ในภาษา "ปกติ"!

Python 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]

อ็อกเทฟ, 83 85 83 79 ไบต์

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

ลองใช้กับ Octave Online!

ฟังก์ชั่นที่ใช้เป็นอินพุตเวกเตอร์คอลัมน์ที่มี (1, -1, i, -i)

การใช้วิธีการของ Mathematica ของ @ lanlock4 คำตอบจะเป็นการเพิ่มความยาวของอินพุตให้กับพิกัดเพื่อหลีกเลี่ยงพิกัดที่ไม่เป็นบวกแทนที่จะลบค่าพิกัดขั้นต่ำจากพิกัด บันทึก 4 ไบต์

คำตอบก่อนหน้า:

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

ลองใช้กับ Octave Online!

เปลี่ยนเพื่อให้มองเห็นได้ดีขึ้น

คำอธิบาย:

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

Haskell, 579 530 bytes

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

Mathematica, 124 ไบต์

คุณอาจไม่แปลกใจที่รู้ว่า Mathematica มีฟังก์ชั่นในตัวสำหรับวัดพื้นที่ที่ล้อมรอบด้วยกำแพง แต่น่าเสียดายที่มันค่อนข้าง ComponentMeasurements[..., "FilledCount", CornerNeighbors -> False]bytey:

โดยที่ในใจนี่คือคำตอบทั้งหมดของฉัน มันเป็นฟังก์ชั่นที่รับรายการ 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]& ใช้เวทมนตร์ Mathematica ในตัวเพื่อวัดพื้นที่ที่ล้อมรอบด้วยกำแพง

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," ");