90 derece dönüş sırası olarak çevre döngüsü verilen birim hücrelerin bir bölgesini bulun.

Örneğin, üç hücreli bölgeyi ele alalım.

XX
X

kimin çevre döngüsünü çiziyoruz

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

Her tur sol (L), düz (S) veya sağ (R) olarak işaretlenir. R'den başlayarak, dönüşler RLLSLSLL. Bu nedenle, girdi verildiğinde RLLSLSLL, alan için 3 çıktı almalıyız.

Giriş dizisinin, solunda tek bir bölgeyi çevreleyen bir döngüyü izlemesi garanti edilir.

• Yol, başlangıç ​​noktasında geriye doğru, ilk yöne bakar ve bir halka oluşturur.
• Döngü kendi kendine geçmez veya kendisine dokunmaz.
• Döngü bir bölge çevresinde saat yönünün tersine gider.

I / O

Girdiyi bir liste veya karakter dizisi olarak LSRveya -1, 0, 1sol, düz, sağ için sayılar olarak alabilirsiniz . Çıktı pozitif bir tamsayıdır. Şamandıralar iyi.

Test senaryoları

Girişler her iki formatta ve ardından ilgili çıkışlarla verilir.

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 bayt

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

Çevrimiçi deneyin!

Bu program alanı hesaplamak için Green teoremini kullanır

Geçerli konum sağ yığın üzerinde, karşılaşılan yöne bağlı bir biçimde saklanır.

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

Her durumda, yığındaki ikinci değer 1 artar ve alanın çizgi integrali yığının üstündeki değerin yarısı kadar azalır. Telafi etmek için, programın sonu çalışan toplamı -2'ye böler.

# 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 Klasik) , 30 28 19 bayt

@ Adám sayesinde -2

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

Çevrimiçi deneyin!

koordinatları hesaplamak için karmaşık sayılarla hileler kullanır

alan horizontal (x _i -x _{i + 1} ) (y _i + y _{i + 1} ) veya eşdeğer Σ (x _i -x _{i + 1} ) y _i şeklindedir, çünkü çizgiler yalnızca yatay veya dikeydir

JavaScript (ES6), 52 50 bayt

@Neil sayesinde 2 bayt kaydedildi

İkinci giriş formatını bekler.

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

Çevrimiçi deneyin!

Nasıl?

^{Bu açıklama önceki sürüm için geçerlidir : x ve y o zamandan beri ters çevrilmiştir.}

Bu, @ngn : A = Σ (x _i - x _{i + 1} ) y _i tarafından daha önce sözü edilen formüle dayanmaktadır; bu formül , xdx _i y _i olarak da yazılabilir; burada dx _i , -1, 0 veya 1'dir.

R = y = 0 ile başlıyoruz .

Biz mevcut yön izlemek tutmak bir :

          | 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

İle güncellenir a = a + k & 3, burada k giriş dizisinin geçerli öğesidir.

Çünkü bir ilk giriş dizi içeren, bir + k zorlanır olan NaN sonra birinci tekrar ve 0 lojik AND uygulandığı zaman. Bu, ilk yön değişikliğinin aslında göz ardı edildiği ve her zaman Doğu'ya gitmeye başladığımız anlamına gelir. Önemli değil, çünkü son şeklin yönü ne olursa olsun alan aynı kalır.

Ardından, y'yi ile güncelleriz y += (2 - a) % 2.

Son olarak, hesaplama -dx ile ~-a % 2ve çıkarma y * -dx gelen r , - sürecin sonunda - bizim nihai sonucudur.

Python 2 , 64 bayt

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

Çevrimiçi deneyin!

Karmaşık sayılar kullanarak ∑xΔy hesaplar.

Haskell , 71 70 69 bayt

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çıklama: Green Teoremi, A = ½∑ (x _{k + 1} + x _k ) (y _{k + 1} -y _k ) alanı için formülü verir: A = ½∑ _{Δx = 0} 2x _k Δy + ½∑ _{Δy = 0} (x _{k + 1} + x _k ) * 0 = ∑xΔy, eksenler boyunca 90 derece olduğunda. X konumunu ve yönünü takip eden tekrarlayan bir dönüş-globbing işlevi için aşağıdaki sahte kodumuz var:

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

burada yeni yön, ΔA ve Δx aşağıdaki tablolardan görülebilir. Modüler aritmetik yerine dir+turnuygulanan diyagonal eksen boyunca hem A hem de Δx'te dört uzunluktaki sinüzoidal periyodikliği görebiliriz 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

Çevrimiçi deneyin!

Wolfram Dili (Mathematica) , 36 30 bayt

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

Eğer Mathematica (~ v10) eski bir sürümünü varsa gerekir Most@önünde AnglePathçokgen kapanış önlemek için. (İpuçları için @ user202729'a teşekkürler).

orijinal: Çevrimiçi deneyin!

güncellendi: Çevrimiçi deneyin!

Jöle , 15 11 bayt

@Xnor'a 2 bayt tasarruf ederek gereksiz bir adımı işaret ettiği için
teşekkürler Başka bir baytı kaydettiği için @dylnan'a teşekkürler

İkinci giriş formatını bekler. Bir şamandıra döndürür.

+\ı*Ḟ_\×ƊĊS

Çevrimiçi deneyin! veya tüm test senaryolarını çalıştırın

Yorumlananlar

+\ı*Ḟ_\×ƊĊ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 bayt

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

Çevrimiçi deneyin!

Lynn'in çözümüne benzer , ancak bir seferde karmaşık sayının doğru bileşenini çıkarmak için bazı karmaşık aritmetik kullanma.

Pyth , 25 bayt

-1, 0, 1Giriş formatını kullanır .

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

Burada deneyin!

Pyth , 14 bayt

_smec^.j)sd2.:

Test odası

_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

Bu, alanı giriş -1/2 * g(sum(l))üzerindeki tüm bitişik alt listelerin toplamı olarak ifade eder ve lburada gmodüler indeksleme yapar [0,1,0,-1]. Kod uygular golarak g(x)=imag(1j**x). Doğrudan modüler indeksleme, kullanma sinveya aritmetik fonksiyon ile daha kısa bir yöntem olabilir x%4.