14

90 डिग्री के क्रम के अनुक्रम के रूप में इसकी परिधि पाश को देखते हुए इकाई कोशिकाओं के क्षेत्र का क्षेत्रफल ज्ञात करें।

उदाहरण के लिए, तीन-सेल क्षेत्र को लें

XX
X

जिसकी परिधि पाश हम खींचते हैं

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

प्रत्येक मोड़ को बाएं (L), स्ट्रेट (S), या राइट (R) के रूप में चिह्नित किया गया है। आर से शुरू, मोड़ हैं RLLSLSLL। इसलिए, इनपुट को देखते हुए RLLSLSLL, हमें क्षेत्र के लिए 3 आउटपुट चाहिए।

इनपुट अनुक्रम की गारंटी दी जाती है कि वह अपने बाईं ओर एक क्षेत्र को घेरते हुए लूप का पता लगाए।

पथ प्रारंभिक बिंदु का सामना करते हुए, प्रारंभिक छोर पर वापस समाप्त होता है, एक लूप बनाता है।
पाश स्वयं को पार या स्पर्श नहीं करता है।
लूप एक क्षेत्र के चारों ओर वामावर्त जाता है।

आई / ओ

आप एक सूची या पात्रों के स्ट्रिंग के 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

code-golf geometry grid

— XNOR
स्रोत

10

ब्रेन-फ्लैक , 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
({()<({}()())>}{})

— Nitrodon
स्रोत

7

एपीएल (डायलॉग क्लासिक) , 30 28 19 बाइट्स

-2 @ Adám को धन्यवाद

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

इसे ऑनलाइन आज़माएं!

निर्देशांक की गणना करने के लिए जटिल संख्या के साथ चाल का उपयोग करता है

क्षेत्र ½Σ (एक्स है _मैं -x _{i + 1} ) (y _मैं + y _{i + 1} ) या समतुल्य रूप Σ (एक्स _मैं -x _{i + 1} ) y _मैं लाइनें हैं के रूप में केवल क्षैतिज या लम्बवत

— NGN
स्रोत

ट्रेडफ़न बॉडी में कनवर्ट करके सहेजें।

— अदम

@ ठीक है, मैं एक ट्रेन के लिए उम्मीद कर रहा था और किसी तरह यह करना भूल गया ...

— ngn

@ Adám आह! मैंने ट्रेन :)

— ngn

6

जावास्क्रिप्ट (ईएस 6), 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 (x _i - x _{i + 1} ) y _i द्वारा उल्लिखित सूत्र पर आधारित है , जिसे Σdx _i y _{i के} रूप में भी लिखा जा सकता है जहां dx _i या तो -1, 0 या 1 है।

हम आर = 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 इनपुट ऐरे का वर्तमान तत्व है।

क्योंकि एक शुरू में इनपुट सरणी शामिल है, एक + K करने के लिए मजबूर कर रहा है NaN करने के लिए पहली यात्रा पर और फिर 0 जब बिटवाइज़ और लागू किया जाता है। इसका अर्थ है कि पहले दिशा परिवर्तन को वास्तव में अनदेखा किया जाता है और हम हमेशा पूर्व की ओर बढ़ना शुरू करते हैं। इससे कोई फर्क नहीं पड़ता क्योंकि क्षेत्र समान रहता है, कोई फर्क नहीं पड़ता कि अंतिम आकार का उन्मुखीकरण।

फिर, हम y के साथ अपडेट करते हैं y += (2 - a) % 2।

अंत में, हम गणना -dx साथ ~-a % 2और घटाने के y * -dx से आर , जो - प्रक्रिया के अंत में - हमारे अंतिम परिणाम है।

— Arnauld
स्रोत

1

a=>a.map(k=>r+=(2-(a=a+k&3))%2*(y+=~-a%2),r=y=0)|r2 बाइट्स बचाता है।

— नील

4

पायथन 2 , 64 बाइट्स

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

इसे ऑनलाइन आज़माएं!

जटिल संख्याओं का उपयोग करके ∑xutesy की गणना करता है।

— लिन
स्रोत

3

हास्केल , 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 (x _{k + 1} + x _k ) (y _{k + 1} -y _k ), जो A = ½∑ =x _{= 0} 2x _k_Δx + ifies को सरल बनाता है कुल्हाड़ियों के साथ 90 डिग्री होने पर _{Δy = 0} (x _{k + 1} + x _k ) * 0 = Δx wheny। हमारे पास पुनरावर्ती मोड़-ग्लोबिंग फ़ंक्शन के लिए निम्नलिखित छद्मकोड है जो x स्थिति और दिशा का ट्रैक रखता है:

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

जहां नई दिशा, andA और newx को निम्न तालिकाओं से देखा जा सकता है। हम विकर्ण अक्ष के साथ ΔA और thex दोनों में लंबाई चार की एक sinusoidal आवधिकता देख सकते हैं 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

इसे ऑनलाइन आज़माएं!

— Angs
स्रोत

2

वोल्फ्राम भाषा (गणितज्ञ) , ३६ ३० बाइट्स

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

यदि आपके पास Mathematica (~ v10) का पुराना संस्करण है, तो आपको बहुभुज को बंद करने से बचने Most@की आवश्यकता होगी AnglePath। (सुझावों के लिए @ user202729 पर धन्यवाद)।

मूल: यह ऑनलाइन की कोशिश करो!

अद्यतन: इसे ऑनलाइन आज़माएं!

— केली लोवदर
स्रोत

#.5Piकाम करने लगता है।

— user202729

ऐसा लगता है कि इसे Mostभी गिराना संभव है।

— user202729

2

जेली , 15 11 बाइट्स

@Xnor को एक बेकार कदम बताने के लिए धन्यवाद , 2 बाइट की
बचत

दूसरे इनपुट प्रारूप की अपेक्षा करता है। एक फ्लोट देता है।

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

— Arnauld
स्रोत

क्या केवल कम से कम 2 महत्वपूर्ण बिट्स रखना आवश्यक है?

— xnor

+\ı*Ḟ_\×ƊĊSएक बाइट बचाता है

— dylnan

@xnor और dylnan मुझे इस सबमिशन में गोल्फ की मदद करने के लिए धन्यवाद। और इनाम के लिए xnor के लिए अतिरिक्त धन्यवाद!

— अरनौलद

2

पायथन 2 , 62 बाइट्स

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

इसे ऑनलाइन आज़माएं!

लिन के समाधान के समान , लेकिन एक ही बार में जटिल संख्या के सही घटक को निकालने के लिए कुछ जटिल अंकगणित का उपयोग करना।

— XNOR
स्रोत

1

पायथ , 25 बाइट्स

-1, 0, 1इनपुट प्रारूप का उपयोग करता है ।

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

यहाँ यह कोशिश करो!

— मिस्टर एक्सकोडर
स्रोत

0

अजगर , 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मॉड्यूलर अनुक्रमण करता है [0,1,0,-1]। कोड के gरूप में लागू करता है g(x)=imag(1j**x)। प्रत्यक्ष मॉड्यूलर अनुक्रमण के साथ एक छोटी विधि हो सकती है, का उपयोग कर sin, या एक अंकगणितीय कार्य पर x%4।

— XNOR
स्रोत

परिधि पाश द्वारा संलग्न क्षेत्र

ब्रेन-फ्लैक , 112 बाइट्स

एपीएल (डायलॉग क्लासिक) , 30 28 19 बाइट्स

जावास्क्रिप्ट (ईएस 6), 52 50 बाइट्स

कैसे?

पायथन 2 , 64 बाइट्स

हास्केल , 71 70 69 बाइट्स

वोल्फ्राम भाषा (गणितज्ञ) , ३६ ३० बाइट्स

जेली , 15 11 बाइट्स

टिप्पणी की गई

पायथन 2 , 62 बाइट्स

पायथ , 25 बाइट्स

अजगर , 14 बाइट्स