यदि हम प्राकृतिक संख्या लेते हैं और उन्हें काउंटर-वार में एक सर्पिल में रोल करते हैं, तो हम निम्नलिखित अनंत सर्पिल के साथ समाप्त होते हैं:

                  ....--57--56
                             |
36--35--34--33--32--31--30  55
 |                       |   |
37  16--15--14--13--12  29  54
 |   |               |   |   |
38  17   4---3---2  11  28  53
 |   |   |       |   |   |   |
39  18   5   0---1  10  27  52
 |   |   |           |   |   |
40  19   6---7---8---9  26  51
 |   |                   |   |
41  20--21--22--23--24--25  50
 |                           |
42--43--44--45--46--47--48--49

उस सर्पिल में कुछ संख्या को देखते हुए आपका कार्य अपने पड़ोसियों को निर्धारित करना है - जिसका अर्थ है ऊपर, बाएँ, दाएँ और नीचे का तत्व।

उदाहरण

यदि हमारी नज़र है तो 27हम देख सकते हैं कि इसके निम्न पड़ोसी हैं:

ऊपर: 28
बाएं: 10
सही: 52
नीचे: 26

तो उत्पादन होगा: [28,10,52,26]

नियम

इनपुट एक संख्या हो जाएगा किसी में डिफ़ॉल्ट आई / ओ प्रारूप $n \geq 0$
आउटपुट किसी भी संख्या में (4) पड़ोसियों की सूची / मैट्रिक्स / .. होगी (सुसंगत!) क्रम
आप एक सर्पिल के साथ काम कर सकते हैं जो 0 के बजाय 1 से शुरू होता है, हालांकि आपको अपने उत्तर में यह निर्दिष्ट करना चाहिए

उदाहरण

आउटपुट प्रारूप में है [above,left,right,below]और 0-आधारित सर्पिल का उपयोग करता है:

0  ->  [3,5,1,7]
1  ->  [2,0,10,8]
2  ->  [13,3,11,1]
3  ->  [14,4,2,0]
6  ->  [5,19,7,21]
16  ->  [35,37,15,17]
25  ->  [26,24,50,48]
27  ->  [28,10,52,26]
73  ->  [42,72,74,112]
101  ->  [100,146,64,102]
2000  ->  [1825,1999,2001,2183]
1000000  ->  [1004003,1004005,999999,1000001]

code-golf integer

— ბიმო
स्रोत

आर , 156 बाइट्स

function(n){g=function(h)c(0,cumsum(h((4*(0:(n+2)^2)+1)^.5%%4%/%1/2)))
x=g(sinpi)
y=g(cospi)
a=x[n]
b=y[n]
which(x==a&(y==b+1|y==b-1)|y==b&(x==a+1|x==a-1))}

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

@ngn की तुलना में थोड़ा अलग दृष्टिकोण के बाद से एक और आर उत्तर पोस्ट किया
1 अनुक्रमित
पड़ोसियों को हमेशा आरोही मान द्वारा क्रमबद्ध किया जाता है
आधी संख्याओं ( , आदि ...) की तुलना में अधिक सटीक roundऔर उपयोग करने वाले 6 बाइट्स को सहेजनाcospi(x)/sinpi(x)cos(x*pi)/sin(x*pi)0.51.5
परिणाम के समान होने के बाद से y निर्देशांक पर माइनस को हटाते हुए एक और बाइट को बचाया (बस ऊपर / नीचे पड़ोसियों को उलट दिया जाता है)

स्पष्टीकरण:

यदि हम मूल्यों के मैट्रिक्स निर्देशांक को देखते हैं, तो पहले मूल्य को देखते 0हुए x=0, y=0, वे हैं:

x = [0,  1,  1,  0, -1, -1, -1,  0,  1,  2,  2,  2,  2,  1,  0, ...] 
y = [0,  0,  1,  1,  1,  0, -1, -1, -1, -1,  0,  1,  2,  2,  2, ...]

xनिर्देशांक का पालन A174344 OEIS अनुक्रम पुनरावर्ती फार्मूले के साथ:

a(1) = 0, a(n) = a(n-1) + sin(mod(floor(sqrt(4*(n-2)+1)),4)*pi/2)

एक ही सूत्र yमैट्रिक्स निर्देशांक के लिए रखता है , लेकिन cosइसके बजाय sinऔर नकारात्मक:

a(1) = 0, a(n) = a(n-1) - cos(mod(floor(sqrt(4*(n-2)+1)),4)*pi/2)

तो, आर में हम sinpi/cospiपैरामीटर के रूप में लेते हुए, इस फ़ंक्शन के सूत्र का अनुवाद कर सकते हैं :

g=function(h)c(0,cumsum(h((4*(0:(n+2)^2)+1)^.5%%4%/%1/2)))

और हम दो निर्देशांक वैक्टर उत्पन्न करते हैं (हम वाई कोर्ड्स की उपेक्षा नहीं करते हैं क्योंकि हम एक ही परिणाम प्राप्त करेंगे, बस ऊपर / नीचे पड़ोसियों के साथ उलटा हो जाता है):

x=g(sinpi)
y=g(cospi)

ध्यान दें कि हमने (n+2)^2निर्देशांक उत्पन्न किए हैं, जो न्यूनतम आवश्यक निर्देशांक से अधिक हैं जिनमें दोनों nऔर उनके पड़ोसी शामिल हैं (एक तंग बाध्य होगा (floor(sqrt(n))+2)^2लेकिन दुर्भाग्य से "गोल्फ" कम है)।

इसलिए, अब जब हमारे पास सभी निर्देशांक हैं, तो हम सबसे पहले a,bअपने से संबंधित निर्देशांक खोजते हैं n:

a=x[n]
b=y[n]

अंत में हम उनके पड़ोसियों के पदों का चयन करते हैं, अर्थात:

अप / डाउन पड़ोसी where x == a and y == b+1 or b-1
दाएं / बाएं पड़ोसी where y == b and x == a+1 or a-1

का उपयोग कर:

which(x==a&(y==b+1|y==b-1)|y==b&(x==a+1|x==a-1))

— digEmAll
स्रोत

"थोड़ा अलग" :)

— एनजी

@ngm: ईहे ... चूंकि आपके द्वारा उपयोग किए गए रौसेट्टा कोड मेरे लिए बहुत "अस्पष्ट" है, मैंने माना कि किसी तरह मैट्रिक्स की स्थिति सूचकांक मेरे OEIS अनुक्रमों की तुलना में एक अलग लेकिन इसी तरह के फैशन में पैदा कर रहा है: डी

— डिक्जेक्टेल

4

पर्ल 6 , 94 83 बाइट्स

~~{मेरे \ _ = 0; | [+] फ्लैट (1) i ... ) Zxx फ्लैट (1.Inf Z 1..Inf)); नक्शा {पहला: k, s [$ _] + $ ^ घ, एस}, मैं, -1,1, मैं}~~

{my \s=0,|[\+] flat((1,*i...*)Zxx(1,1.5...*));map {first :k,s[$_]+$^d,s},i,-1,1,-i}

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

sसर्पिल निर्देशांक की एक आलसी, अनंत सूची है, जिसे जटिल संख्याओं के रूप में दर्शाया गया है। यह दो अन्य अनंत सूचियों से निर्मित है: 1, *i ... *सूची बनाती है 1, i, -1, -i ...। 1, 1.5 ... *सूची बनाता है 1, 1.5, 2, 2.5, 3, 3.5 ...। इन दो सूचियों को सूची प्रतिकृति के साथ जोड़कर प्रत्येक सर्पिल से अगले तक चरणों की सूची तैयार की जाती है 1, i, -1, -1, -i, -i, 1, 1, 1, i, i, i ...:। (सूची प्रतिकृति ऑपरेटर के दाहिने हाथ के तर्कों के आंशिक भागों को छोड़ दिया जाता है।) [\+]इस सूची पर त्रिकोणीय जोड़ घटाना ( ) और (आगे की तरफ 0 चिपकाना) सर्पिल निर्देशांक की सूची का उत्पादन करता है।

अंत में, जटिल संख्या से शुरू s[$_]( $_कार्य करने के लिए एकमात्र तर्क किया जा रहा है), हम अनुक्रमित (देखो first :k) जटिल संख्याओं के सर्पिल है जिसके द्वारा उस नंबर से ऑफसेट कर रहे हैं में i, -1, 1, और -i।

— शॉन
स्रोत

4

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

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

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

आउटपुट बाएं, ऊपर, दाएं, नीचे क्रम में है।

व्याख्या

# If n is nonzero:
((){[()]<

  ((

    # Push 1 twice, and push n-1 onto other stack.
    ({}[((()))]<>)

    # Determine how many times spiral turns up to n, and whether we are on a corner.
    # This is like the standard modulus algorithm, but the "modulus" used
    # increases as 1, 1, 2, 2, 3, 3, ...
    <<>{((([{}]({}))([{}]{})())[()]){({}[()])<>}{}}>

  # Push n-1: this is the number behind n in the spiral.
  )<

    # While maintaining the "modulus" part of the result:
    <>({}<

      # Push n+2k+1 and n+2k+3 on top of n-1, where k is 3 more than the number of turns.
      # n+2k+1 is always the number to the right in the direction travelled.
      # If we are on a corner, n+2k+3 is the number straight ahead.
      (((({}{})()){}<>({}))()())<>

    >)<>

  # Push n+1.  If we are on a corner, we now have left, front, right, and back
  # on the stack (from top to bottom)
  >()())

  # If not on a corner:
  <>{{}

    # Remove n+2k+3 from the stack entirely, and push 6-2k+(n+1) on top of the stack.
    ((()()()[({})]){}<>({}<{}>))

  (<>)}

>}{})

# If n was zero instead:
{

  # Push 1, 3, 5, 7 on right stack, and implicitly use 1 (from if/else code) as k.
  <>((((())()())()())()())

(<>)}{}

# Roll stack k times to move to an absolute reference frame
# (switching which stack we're on each time for convenience)
{({}[()]<<>({}<>)<>({}<({}<({}<>)>)>)<>>)}<>

— Nitrodon
स्रोत

बहुत प्रभावशाली! मुझे लगता है कि आप पूरे सर्पिल पैदा नहीं कर रहे हैं जैसा कि अन्य करते हैं, क्या आप हैं?

— ბიმო

3

MATL , 15 बाइट्स

2+1YLtG=1Y6Z+g)

इनपुट और आउटपुट 1-आधारित हैं।

आउटपुट उस क्रम में बाएं, नीचे, ऊपर और दाएं पड़ोसी देता है।

इसे ऑनलाइन आज़माएं! या पिछले दो को छोड़कर सभी परीक्षण मामलों को सत्यापित करें , जो TIO पर टाइम आउट करते हैं।

2+      % Implicit input: n. Add 2. This is needed so that
        % the spiral is big enough
1YL     % Spiral with side n+2. Gives a square matrix
t       % Duplicate
G=      % Compare with n, element-wise. Gives 1 for entry containing n
1Y6     % Push 3×3 mask with 4-neighbourhood
Z+      % 2D convolution, keeping size. Gives 1 for neighbours of the
        % entry that contained n
g       % Convert to logical, to be used as an index
)       % Index into copy of the spiral. Implicit display

— लुइस मेंडो
स्रोत

2

1YL- MATLAB का एक spiralफंक्शन है? जब MATLAB गणितज्ञ में बदल गया है ?!

— सूंदर -

हाँ, मैंने इसे 1 -LL का मतलब देखने के बाद duckduckgo-ed किया, और यह रोसेटा कोड प्रविष्टि एकमात्र जगह थी जो मुझे पुष्टि करने के लिए मिल सकती थी कि यह एक MATLAB बात है और न कि केवल MATL सुविधा फ़ंक्शन। मुझे लगता है कि यह कुछ आप गोल्फ के लिए MATL में जोड़ा जा सकता है, जब तक मैं उस प्रविष्टि देखा था।

— सूंदर -

@ सूंदर अजीब है कि यह अब और प्रलेखित नहीं है

— लुइस मेंडो

3

आर , 172 बाइट्स

function(x,n=2*x+3,i=cumsum(rep(rep(c(1,n,-1,-n),l=2*n-1),n-seq(2*n-1)%/%2))){F[i]=n^2-1:n^2
m=matrix(F,n,n,T)
j=which(m==x,T)
c(m[j[1],j[2]+c(-1,1)],m[j[1]+c(-1,1),j[2]])}

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

यह आर है, इसलिए स्पष्ट रूप से उत्तर 0-अनुक्रमित है।

अधिकांश कार्य मैट्रिक्स का निर्माण कर रहे हैं। कोड से प्रेरित: https://rosettacode.org/wiki/Spiral_matrix#R

— एन जी एम
स्रोत

2

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

के साथ सूचकांक प्रिंट करता है alert()।

f=(n,x=w=y=n+2)=>y+w&&[0,-1,0,1].map((d,i)=>(g=(x,y,A=Math.abs)=>(k=A(A(x)-A(y))+A(x)+A(y))*k+(k+x+y)*(y>=x||-1))(x+d,y+~-i%2)-n||alert(g(x,y)))|f(n,x+w?x-1:(y--,w))

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

कैसे?

$x, y \in \mathbb{Z}$ $I_{x,y}$

ए_{एक्स, y} = | | एक्स | - | y | | + | एक्स | + | y |

$A_{x,y}=||x|-|y||+|x|+|y|$

{एस}_{एक्स, y} = {\begin{cases} 1, & अगर y \geq एक्स \\ - 1, & अगर y < एक्स \end{cases}

$S_{x,y}=\begin{cases}1,&\text{if }y\ge x\\-1,&\text{if }y<x\end{cases}$

{मैं}_{एक्स, y} = ए_{एक्स, y}^{2} + (ए_{एक्स, y} + एक्स + y) \times {एस}_{एक्स, y}

$I_{x,y}=A_{x,y}^2+(A_{x,y}+x+y)\times S_{x,y}$

( math.stackexchange से इस उत्तर से अनुकूलित)

— Arnauld
स्रोत

यह छोटी संख्या के साथ ठीक काम करने लगता है, लेकिन मुझे 2000 जैसी बड़ी संख्या के साथ परीक्षण करते समय एक त्रुटि मिलती है। tio.run पर त्रुटि: RangeError: Maximum call stack size exceededऔर ब्राउज़र कंसोल में त्रुटि InternalError: too much recursion:। क्या मुझसे कुछ ग़लत हो रहा है?

— नाइट २

1

4 n^{2}

$4n^2$

2

पायथन 2 , 177 164 1 46 144 बाइट्स

def f(n):N=int(n**.5);S=N*N;K=S+N;F=4*N;return[n+[F+3,[-1,1-F][n>K]][n>S],n+[F+5,-1][n>K],n+[[1,3-F][n<K],-1][0<n==S],n+[F+7,1][n<K]][::1-N%2*2]

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

u,l,r,dसे सीधे गणना करता है n।

— चास ब्राउन
स्रोत

1

PHP (> = 5.4), 208 बाइट्स

<?$n=$argv[1];for(;$i++<($c=ceil(sqrt($n))+($c%2?2:3))**2;$i!=$n?:$x=-$v,$i!=$n?:$y=+$h,${hv[$m&1]}+=$m&2?-1:1,$k++<$p?:$p+=$m++%2+$k=0)$r[-$v][+$h]=$i;foreach([0,1,0,-1]as$k=>$i)echo$r[$x+$i][$y+~-$k%2].' ';

इसे चलाने के लिए:

php -n -d error_reporting=0 <filename> <n>

उदाहरण:

php -n -d error_reporting=0 spiral_neighbourhoods.php 2001

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

टिप्पणियाँ:

-d error_reporting=0विकल्प नहीं उत्पादन नोटिस / चेतावनी के लिए प्रयोग किया जाता है।
यह सर्पिल 1 से शुरू होता है।

कैसे?

मैं इस उत्तर के संशोधित संस्करण के साथ सर्पिल पैदा कर रहा हूं 2 आयामी सरणी ।

मैं nएक सूत्र के साथ इनपुट के आधार पर सर्पिल के आकार पर निर्णय लेता हूं, हमेशा सर्पिल में संख्याओं का एक अतिरिक्त दौर प्राप्त करने के लिए (ऊपर / नीचे / बाएं / दाएं के अस्तित्व की गारंटी)। संख्याओं का एक अतिरिक्त दौर +2ऊंचाई में और मतलब है+2 2 आयामी सरणी की चौड़ाई में ।

तो अगर nअधिकतम आकार के साथ एक सर्पिल में स्थित होगा 3*3, तो उत्पन्न सर्पिल होगा5*5 ।

सर्पिल आकार c*cजहां है c = ceil(sqrt(n)) + k, यदि ceil(sqrt(n))विषम है, तो k2 है और यदि ceil(sqrt(n))है, तोk 3 है।

उदाहरण के लिए, उपरोक्त सूत्र में परिणाम होगा:

यदि n = 1तब c = 3और सर्पिल आकार होगा3*3
यदि n <= 9तब c = 5और सर्पिल आकार होगा5*5
यदि n <= 25तब c = 7और सर्पिल आकार होगा7*7
यदि n <= 49तब c = 9और सर्पिल आकार होगा9*9
और इसी तरह ...

सर्पिल पैदा करते हैं, मैं स्टोर xऔर yका nऔर पीढ़ी के बाद, मैं उत्पादन ऊपर / तत्वों नीचे / इसके बारे में दाएँ से बाएँ /।

— Night2
स्रोत

सर्पिल पड़ोस

उदाहरण

नियम

उदाहरण

आर , 156 बाइट्स

स्पष्टीकरण:

पर्ल 6 , 94 83 बाइट्स

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

व्याख्या

MATL , 15 बाइट्स

आर , 172 बाइट्स

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

कैसे?

पायथन 2 , 177 164 1 46 144 बाइट्स

PHP (> = 5.4), 208 बाइट्स

कैसे?