ค้นหาพื้นที่ของส่วนหนึ่งของเซลล์หน่วยที่มีขอบเขตวนรอบเป็นลำดับ 90 องศา

ตัวอย่างเช่นใช้พื้นที่สามเซลล์

XX
X

เส้นรอบวงของเส้นรอบวงที่เราวาด

L<S<L
v   ^
S R>L
v ^
L>L

การเลี้ยวแต่ละครั้งจะถูกทำเครื่องหมายเป็นซ้าย (L), ตรง (S) หรือขวา (R) เริ่มต้นจาก R หันRLLSLSLLมา ดังนั้นอินพุตที่กำหนดRLLSLSLLเราควรเอาท์พุท 3 สำหรับพื้นที่

ลำดับการป้อนข้อมูลรับประกันว่าจะติดตามลูปที่ล้อมรอบพื้นที่เดียวทางด้านซ้าย

• เส้นทางสิ้นสุดที่จุดเริ่มต้นหันหน้าไปทางทิศทางเริ่มต้นก่อตัวเป็นวง
• ห่วงไม่ข้ามหรือสัมผัสตัวมันเอง
• วนรอบทวนเข็มนาฬิการอบภูมิภาค

I / O

คุณสามารถรับอินพุตเป็นรายการหรือสตริงอักขระLSRหรือเป็นตัวเลข-1, 0, 1สำหรับซ้าย, ตรง, ขวา เอาต์พุตเป็นจำนวนเต็มบวก ลอยตัวก็โอเค

กรณีทดสอบ

อินพุตจะถูกกำหนดในทั้งสองรูปแบบตามด้วยเอาต์พุตที่เกี่ยวข้อง

RLLSLSLL
LLLL
SLLSLL
LSRRSLLSSLSSLSSL
SSSSSLSSSSSLSSSSSLSSSSSL

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

3
1
2
7
36

Brain-Flakขนาด 112 ไบต์

(([]){[{}]<{({}()){{}<>([{}]<([{}])>)(<>)}<>(({}[({})])[({}{})])<>}{}<>>({}<({}())>)<>([])}{})({()<({}()())>}{})

ลองออนไลน์!

โปรแกรมนี้ใช้ทฤษฎีบทของกรีนเพื่อคำนวณพื้นที่

ตำแหน่งปัจจุบันจะถูกเก็บไว้ในสแต็คด้านขวาในรูปแบบที่ขึ้นอยู่กับทิศทางที่ต้องเผชิญ

Direction  top  second
north       -x       y
west        -y      -x
south        x      -y
east         y       x

ในทุกกรณีค่าที่สองบนสแต็กจะเพิ่มขึ้น 1 และอินทิกรัลบรรทัดสำหรับพื้นที่จะลดลงครึ่งหนึ่งโดยค่าที่ด้านบนของสแต็ก เพื่อชดเชยจุดสิ้นสุดของโปรแกรมจะหารผลรวมของการรันด้วย -2

# For each number in input
(([]){[{}]

  # Evaluate turn-handling to zero
  <

    # If turn:
    {

      # If right turn:
      ({}()){{}

        # Negate both values on other stack (reverse direction)
        <>([{}]<([{}])>)

      (<>)}

      # Swap the two stack elements and negate the new top of stack
      # This performs a left turn.
      <>(({}[({})])[({}{})])<>

    }{}

  <>>

  # Evaluate as top of stack and...
  ({}<

    # increment the number below it
    ({}())

  >)<>

([])}{})

# Divide total by -2
({()<({}()())>}{})

APL (Dyalog Classic) , 30 28 19 ไบต์

-2 ขอบคุณ @ Adám

(+/9∘○×11○+\)0j1*+\

ลองออนไลน์!

ใช้เทคนิคที่มีตัวเลขที่ซับซ้อนเพื่อคำนวณพิกัด

พื้นที่คือ½Σ (x _ฉัน -x _{ฉัน + 1} ) (y _ฉัน + y _{ฉัน + 1} ) หรือเท่ากันΣ (x _ฉัน -x _{ฉัน + 1} ) y _ฉันเป็นเส้นเป็นแนวนอนหรือแนวตั้งเท่านั้น

JavaScript (ES6), 52 50 ไบต์

บันทึก 2 ไบต์ขอบคุณ @Neil

คาดว่ารูปแบบอินพุตที่สอง

a=>a.map(k=>r+=(2-(a=a+k&3))%2*(y+=~-a%2),r=y=0)|r

ลองออนไลน์!

อย่างไร?

^{คำอธิบายนี้ใช้กับเวอร์ชันก่อนหน้านี้ : xและyได้รับการคว่ำลง}

สิ่งนี้ขึ้นอยู่กับสูตรที่กล่าวถึงโดย @ngn : A = Σ (x _i - x _{i + 1} ) y _iซึ่งสามารถเขียนเป็นΣdx _i y _iโดยที่dx _iเป็น -1, 0 หรือ 1

เราเริ่มต้นด้วยr = y = 0

เราติดตามทิศทางในปัจจุบัน:

          | a = 0 | a = 1 | a = 2 | a = 3
----------+-------+-------+-------+-------
direction | East  | South | West  | North
       dx |  +1   |   0   |  -1   |   0     <--  -(~-a % 2)
       dy |   0   |  +1   |   0   |  -1     <--  (2 - a) % 2

มันถูกอัพเดตด้วยa = a + k & 3โดยที่kคือองค์ประกอบปัจจุบันของอาร์เรย์อินพุต

เนื่องจากในตอนแรกมีอาร์เรย์อินพุต, a + kจะถูกบังคับกับNaNในการวนซ้ำครั้งแรกและจากนั้นเป็น0เมื่อใช้ค่าบิตและ AND ซึ่งหมายความว่าการเปลี่ยนทิศทางแรกนั้นจะถูกเพิกเฉยจริง ๆ และเราก็เริ่มมุ่งหน้าไปทางตะวันออกเสมอ มันไม่สำคัญเพราะพื้นที่ยังคงเหมือนเดิมไม่ว่าการวางแนวของรูปร่างสุดท้ายจะเป็นอย่างไร

จากนั้นเราจะอัปเดตYy += (2 - a) % 2กับ

สุดท้ายเราคำนวณ-dxด้วย~-a % 2และลบy * -dxจากrซึ่งเมื่อสิ้นสุดกระบวนการ - เป็นผลลัพธ์สุดท้ายของเรา

Python 2 , 64 ไบต์

f=lambda c,d=1,x=0:c>[]and f(c[1:],d*1j**c[0],x+d.real)-x*d.imag

ลองออนไลน์!

คำนวณ ∑xΔy โดยใช้จำนวนเชิงซ้อน

Haskell , 71 70 69 ไบต์

a 0 0
a x d(t:r)|k<-t+d=x*g k+a(x+g(k-1))k r
a _ _ _=0
g a=sin$a*pi/2

คำอธิบาย: ทฤษฎีบทกรีนให้สูตรสำหรับพื้นที่: A = ½∑ (x _{k + 1} + x _k ) (y _{k + 1} -y _k ) ซึ่งลดความซับซ้อนของ A = ½∑ _{Δx = 0} 2x _k Δy + ½∑ _{Δy = 0} (x _{k + 1} + x _k ) * 0 = ∑xΔy เมื่อมีการหมุน 90 องศาตามแกน เรามี pseudocode ต่อไปนี้สำหรับฟังก์ชั่นเลี้ยวแบบหมุนวนซ้ำที่ติดตามตำแหน่ง x และทิศทาง:

A x dir (turn:turns) = ΔA + A (x+Δx) (dir+turn) turns

โดยที่ทิศทางใหม่สามารถเห็นΔAและΔxได้จากตารางต่อไปนี้ เราสามารถดูระยะเวลาไซน์ของความยาวสี่ทั้งในΔAและ alongx ตามแนวแกนในแนวทแยงdir+turnซึ่งใช้งานsinแทนการใช้เลขคณิตแบบแยกส่วน

  ↔|L S R ΔA| L  S  R  Δx| L  S  R 
←   ↓ ← ↑    -x  0  x      0 -1  0  
↑   ← ↑ →     0  x  0     -1  0  1
→   ↑ → ↓     x  0 -x      0  1  0
↓   → ↓ ←     0 -x  0      1  0 -1

ลองออนไลน์!

ภาษา Wolfram (Mathematica) , 36 30 ไบต์

Area@Polygon@AnglePath[.5Pi#]&

หากคุณมี Mathematica รุ่นเก่ากว่า (~ v10) คุณจะต้องใช้Most@หน้าAnglePathเพื่อหลีกเลี่ยงการปิดรูปหลายเหลี่ยม (ขอบคุณที่ @ user202729 สำหรับคำแนะนำ)

เดิม: ลองออนไลน์!

อัปเดต: ลองออนไลน์!

เยลลี่ , 15 11 ไบต์

ขอบคุณ @xnor ที่ชี้ให้เห็นถึงขั้นตอนที่ไร้ประโยชน์ประหยัด 2 ไบต์
ขอบคุณ @dylnan สำหรับการบันทึกไบต์อื่น

คาดว่ารูปแบบอินพุตที่สอง ส่งคืนทุ่น

+\ı*Ḟ_\×ƊĊS

ลองออนไลน์! หรือเรียกใช้กรณีทดสอบทั้งหมด

แสดงความคิดเห็น

+\ı*Ḟ_\×ƊĊS  - main link, taking the input list   e.g. [1, -1, -1, 0, -1, 0, -1, -1]
+\           - cumulative sum                     -->  [1, 0, -1, -1, -2, -2, -3, -4]
  ı*         - compute 1j ** d,                   -->  [(0+1j), (1+0j), (0-1j), (0-1j),
               which gives a list of (-dy + dx*j)       (-1+0j), (-1+0j), (0+1j), (1+0j)]
         Ċ   - isolate the imaginary part (dx)    -->  [1, 0, -1, -1, 0, 0, 1, 0] (floats)
        Ɗ    - invoke the last 3 links as a monad
    Ḟ        - isolate the real part (-dy)        -->  [0, 1, 0, 0, -1, -1, 0, 1] (floats)
     _\      - negated cumulative sum (gives y)   -->  [0, -1, -1, -1, 0, 1, 1, 0]
       ×     - compute dx * y                     -->  [0, 0, 1, 1, 0, 0, 1, 0]
          S  - sum                                -->  3

Python 2 , 62 ไบต์

f=lambda l,p=0,s=1:l>[]and(p/s).imag/2+f(l[1:],p+s,s*1j**l[0])

ลองออนไลน์!

คล้ายกับโซลูชันของ Lynnแต่ใช้เลขคณิตที่ซับซ้อนเพื่อแยกส่วนประกอบที่ถูกต้องของจำนวนเชิงซ้อนในครั้งเดียว

Pyth , 25 ไบต์

ใช้-1, 0, 1รูปแบบอินพุต

s*Vm_sd._sMKm^.j)sd._QeMK

ลองที่นี่!

Pyth , 14 ไบต์

_smec^.j)sd2.:

ชุดทดสอบ

_smec^.j)sd2.:
              Q     implicit input
            .:      take all non-empty contiguous sublists
  m                map this operation onto each one:
   ec^.j)sd2
         s           the sum of the sublist
     ^.j)            raise it to the complex unit 1j to that power
    c      2         halve it
   e                take the imaginary part
_s                take the negated sum of the result

นี้เป็นการแสดงออกถึงพื้นที่ในขณะที่ผลรวมของ-1/2 * g(sum(l))มากกว่ารายการย่อยที่ต่อเนื่องกันทั้งหมดlกว่าการป้อนข้อมูลที่gไม่จัดทำดัชนี modular [0,1,0,-1]เข้า ดำเนินรหัสเป็นg g(x)=imag(1j**x)อาจจะมีวิธีการที่สั้นกว่าที่มีการจัดทำดัชนีโดยตรง modular ใช้หรือฟังก์ชั่นทางคณิตศาสตร์ในsinx%4