मुझे एक नंबर सांप हवा दो!

Question

एक इनपुट पूर्णांक को देखते हुए n, एक संख्या सांप को आकर्षित करें, अर्थात, एक ग्रिड माप n x nजिसमें संख्याओं 1से युक्त होता n^2है जो निम्नलिखित फैशन में एक दूसरे के आसपास घाव होते हैं:

इनपुट n = 3:

7 8 9
6 1 2
5 4 3

इनपुट n = 4:

 7  8  9 10
 6  1  2 11
 5  4  3 12
16 15 14 13

इनपुट n = 5:

21 22 23 24 25
20  7  8  9 10
19  6  1  2 11
18  5  4  3 12
17 16 15 14 13

( प्रोजेक्ट यूलर की इस समस्या से प्रेरित है ।)

यह कोड-गोल्फ है , बाइट्स जीत में सबसे छोटा जवाब!

Comments

उदाहरण: 4? या कोई भी संख्या।

— TheLethalCoder

क्या हम मान सकते हैं कि इनपुट विषम है?

— श्री एक्सकोडर

सम्बंधित

— Emigna

संभव डुबकी ?

— शैगी

उत्तरों में कई समाधान और लिंक के साथ perlmonks.com/?node_id=487200 भी देखें ।

— b_jonas

Answer 1

MATL , 3 बाइट्स

1YL

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

व्याख्या

अंतर्निहित ...-\ _ (ツ) _ / ¯

Comments

क्यों ... यह एक अंतर्निहित क्यों है?

— द लीथलकोडर

मुझे लगता है कि यह "मैजिक स्क्वायर" सामान के साथ कुछ करना है?

— मैजिक ऑक्टोपस Urn

@TheLethalCoder क्योंकि मैटलैब यह था और मैंने सोचा कि यह उपयोगी होगा ( जो यह है वास्तव में )

— लुइस Mendo

Answer 2

सी #, 203 202 196 193 178 बाइट्स

n=>{var r=new int[n,n];for(int o=n-2+n%2>>1,i=r[o,o]=1,c=2,w=o,h=o,b=1-2*(i%2),j;n>i++;){r[h,w+=b]=c++;for(j=0;j<i-1;++j)r[h+=b,w]=c++;for(j=0;j<i-1;++j)r[h,w-=b]=c++;}return r;}

@StefanDelport के लिए बाइट धन्यवाद दिया।
सहेजे गए 22 बाइट्स @FelipeNardiBatista का धन्यवाद।

यह निम्नलिखित अवलोकन द्वारा काम करता है कि वर्गों का निर्माण कैसे किया जाता है:

जैसा कि आप देख सकते हैं कि प्रत्येक बिट पिछले वर्ग में जोड़ा गया है। यहां तक ​​कि संख्याओं के लिए हम सही हैं जहां हम थे, नीचे तक एक से कम थे जहां वर्ग था और फिर अंत तक छोड़ दिया गया था। विषम संख्याएं अनिवार्य रूप से विपरीत हैं, हम बाईं ओर एक जाते हैं, जब तक कि वर्तमान ऊंचाई से एक ऊपर और फिर दाएं अंत तक नहीं।

पूर्ण / प्रारूपित संस्करण:

using System;
using System.Linq;

class P
{
    static void Main()
    {
        Func<int, int[,]> f = n =>
        {
            var r = new int[n, n];
            for (int o = n - 2 + n % 2 >> 1, i = r[o, o] = 1, c = 2, w = o, h = o, b = 1 - 2 * (i % 2), j; n > i++;)
            {
                r[h, w += b] = c++;

                for (j = 0; j < i - 1; ++j)
                    r[h += b, w] = c++;

                for (j = 0; j < i - 1; ++j)
                    r[h, w -= b] = c++;
            }

            return r;
        };

        Console.WriteLine(String.Join("\n", f(3).ToJagged().Select(line => String.Join(" ", line.Select(l => (l + "").PadLeft(2))))) + "\n");
        Console.WriteLine(String.Join("\n", f(4).ToJagged().Select(line => String.Join(" ", line.Select(l => (l + "").PadLeft(2))))) + "\n");
        Console.WriteLine(String.Join("\n", f(5).ToJagged().Select(line => String.Join(" ", line.Select(l => (l + "").PadLeft(2))))) + "\n");

        Console.ReadLine();
    }
}

public static class ArrayExtensions
{
    public static T[][] ToJagged<T>(this T[,] value)
    {
        T[][] result = new T[value.GetLength(0)][];

        for (int i = 0; i < value.GetLength(0); ++i)
            result[i] = new T[value.GetLength(1)];

        for (int i = 0; i < value.GetLength(0); ++i)
            for (int j = 0; j < value.GetLength(1); ++j)
                result[i][j] = value[i, j];

        return result;
    }
}

Comments

++i<=n;बन सकता है n>++i, और कुछ नहीं मैं देख सकता हूँ, +1।

— LiefdeWen

n%2<1?2:1को 2-x%2? मैंने इसे C # में परीक्षण नहीं किया है, लेकिन C और Python में इसने काम किया है।

— फेलिप नार्दी बतिस्ता

for(int o=n-2+n%2>>1,i=r[o,o]=1,c=2,w=o,h=o,j;n>i++;){var b=i%2<1; ....थोड़ा सा गोल्फ

— फेलिप

@FelipeNardiBatista बहुत बढ़िया कभी उन दोनों के बारे में नहीं सोचा होगा! धन्यवाद।

— TheLethalCoder

var b=1-2*(i%2);r[h,w+=b]=c++;for(j=0;j<i-1;++j)r[h+=b,w]=c++;for(j=0;j<i-1;++j)r[h,w-=b]=c++;

— फेलिप नारदी बतिस्ता

Answer 3

डायलॉग एपीएल, 70 56 45 41 बाइट्स

,⍨⍴∘(⍋+\)×⍨↑(⌈2÷⍨×⍨),(+⍨⍴1,⊢,¯1,-)(/⍨)2/⍳

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

कैसे?

(+⍨⍴1,⊢,¯1,-)(/⍨)2/⍳

सूचकांकों के बीच अंतर की गणना करता है; 1और ¯1दाएं और बाएं के लिए, ¯⍵और ⍵ऊपर और नीचे के लिए।

1,⊢,¯1,-के रूप में आता है 1 ⍵ ¯1 ¯⍵, +⍨⍴इस सरणी को लंबाई तक बढ़ाता है ⍵×2, इसलिए अंतिम 2/⍳उनमें से प्रत्येक को दोहरा सकता है, प्रत्येक दूसरे तत्वों में दोहराव की गिनती बढ़ जाती है:

      (1,⊢,¯1,-) 4
1 4 ¯1 ¯4
      (+⍨⍴1,⊢,¯1,-) 4
1 4 ¯1 ¯4 1 4 ¯1 ¯4
      (2/⍳) 4
1 1 2 2 3 3 4 4
      ((+⍨⍴1,⊢,¯1,-)(/⍨)2/⍳) 4
1 4 ¯1 ¯1 ¯4 ¯4 1 1 1 4 4 4 ¯1 ¯1 ¯1 ¯1 ¯4 ¯4 ¯4 ¯4

फिर,

(⌈2÷⍨×⍨),

सर्पिल के ऊपरी-बाएँ तत्व को प्रस्तुत करता है,

×⍨↑

इस दूरी सूची के पहले the ² तत्वों को सीमित करें ,

+\

संचयी योग करता है,

⍋

⍵[i] = ⍵[⍵[i]]प्रत्येक तत्व के सूचकांक के साथ मूल मैट्रिक्स का अनुवाद करने के लिए, और अंत में ग्रेड ( ), और अंत में

,⍨⍴

एक ⍵×⍵मैट्रिक्स के रूप में आकार ।

Comments

रुचि रखने वालों के लिए, इस उत्कृष्ट लेख में इस तकनीक पर चर्चा की गई है ।

— योना

Answer 4

सी, 321 307 295 284 283 282 बाइट्स

एक बाइट को गोल करने के लिए @Zachary T और @Jonathan Frech दोनों को धन्यवाद!

#define F for(b=a;b--;)l
i,j,k,a,b,m;**l;f(n){n*=n;l=calloc(a=m=3*n,4);F[b]=calloc(m,4);for(l[i=j=n][j]=a=k=1;n>k;++a){F[i][++j]=++k;F[++i][j]=++k;++a;F[i][--j]=++k;F[--i][j]=++k;}for(i=0;i<m;++i,k&&puts(""))for(j=k=0;j<m;)(a=l[i][j++])>0&&a<=n&&printf("%*d ",(int)log10(n)+1,k=a);}

शून्य के दो आयामी सरणी आवंटित करता है, फिर इसे बीच में कहीं से भरना शुरू कर देता है। अंत में वे मान जो शून्य से बड़े होते हैं, लेकिन इनपुट के वर्ग के बराबर या उससे छोटे होते हैं, मुद्रित होते हैं।

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

प्रारूपित:

#define F for(b=a; b--;)l
i, j, k, a, b, m; **l;
f(n)
{
    n *= n;
    l = calloc(a=m=3*n, 4);

    F[b] = calloc(m, 4);

    for(l[i=j=n][j]=a=k=1; n>k; ++a)
    {
        F[i][++j] = ++k;
        F[++i][j] = ++k;
        ++a;

        F[i][--j] = ++k;
        F[--i][j] = ++k;
    }

    for(i=0; i<m; ++i, k&&puts(""))
        for(j=k=0; j<m;)
            (a=l[i][j++])>0 && a<=n && printf("%*d ", (int)log10(n)+1, k=a);
}

Comments

क्या बाइट को बचाने के i,j,k,a,b,m;f(n){n*=n;int**l=calloc(a=m=3*n,4);साथ बदलना संभव है i,j,k,a,b,m,**l;f(n){n*=n;l=calloc(a=m=3*n,4);?

— ज़ाचारि

आप एक बाइट को बचाने के k<=n;साथ बदलने में सक्षम हो सकते हैं n>k;।

— जोनाथन फ्रेच

Answer 5

PHP , 192 बाइट्स

for($l=strlen($q=($a=$argn)**2)+$d=1,$x=$y=$a/2^$w=0;$i++<$q;${yx[$w%2]}+=$d&1?:-1,$i%$d?:$d+=$w++&1)$e[$x-!($a&1)][$y]=sprintf("%$l".d,$i);for(;$k<$a;print join($o)."\n")ksort($o=&$e[+$k++]);

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

उसी तरह एक सरणी के बजाय एक स्ट्रिंग का निर्माण

PHP , 217 बाइट्स

for($l=strlen($q=($a=$argn)**2)+$d=1,$x=$y=($a/2^$w=0)-!($a&1),$s=str_pad(_,$q*$l);$i++<$q;${yx[$w%2]}+=$d&1?:-1,$i%$d?:$d+=$w++&1)$s=substr_replace($s,sprintf("%$l".d,$i),($x*$a+$y)*$l,$l);echo chunk_split($s,$a*$l);

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

Comments

[-1,1][$d&1]->$d&1?:-1

— टाइटस

@ टिट्स थैंक यू मैंने इसे नहीं देखा है

— Jörg Hülsermann

यहाँ एक और बाइट है: for(;$k<$a;print join($o)."\n")ksort($o=&$e[+$k++]);। और एक अन्य "%$l".d:। और एक और: $x*$l*$a+$y*$l-> ($x*$a+$y)*$l।

— टाइटस

और मुझे लगता है कि दूसरे संस्करण में आप $sएक गद्देदार अंडरस्कोर (या पत्र या अंक) को इनिशियलाइज़ कर सकते हैं ; उस चरित्र को अधिलेखित कर दिया जाएगा।

— टाइटस

@Titus धन्यवाद और आप .d2 बाइट्स बचाने के लिए अपने स्वयं के दृष्टिकोण में उपयोग कर सकते हैं

— Jörg Hülsermann

Answer 6

PHP, 185 176 174 बाइट्स

for(;$n++<$argn**2;${xy[$m&1]}+=$m&2?-1:1,$k++<$p?:$p+=$m++%2+$k=0)$r[+$y][+$x]=$n;ksort($r);foreach($r as$o){ksort($o);foreach($o as$i)printf(" %".strlen($n).d,$i);echo"
";}

ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया इसका परीक्षण करें ।

टूट - फूट

for(;$n++<$argn**2;     # loop $n from 1 to N squared
    ${xy[$m&1]}+=$m&2?-1:1, # 2. move cursor
    $k++<$p?:               # 3. if $p+1 numbers have been printed in that direction:
        $p+=$m++%2+             # increment direction $m, every two directions increment $p
        $k=0                    # reset $k
)$r[+$y][+$x]=$n;           # 1. paint current number at current coordinates

ksort($r);              # sort grid by indexes
foreach($r as$o){       # and loop through it
    ksort($o);              # sort row by indexes
    foreach($o as$i)        # and loop through it
        printf(" %".strlen($n).d,$i);   # print formatted number
    echo"\n";               # print newline
}

Answer 7

APL (Dyalog Classic) , 32 29 बाइट्स

1+×⍨-{⊖∘⌽⍣⍵⌽{⌽⍉,⌸⍵+≢⍵}⍣2⍣⍵⍪⍬}

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

उपयोग करता है ⎕io←1। 0-बाय -1 मैट्रिक्स के साथ शुरू होता है ( ⍪⍬)। 2N बार ( ⍣2⍣⍵) ≢⍵अपने प्रत्येक तत्व में मैट्रिक्स की ऊंचाई ( ) जोड़ता है , 1 2...heightइसके दाईं ओर डालता है ( ,⌸), और घूमता है ( ⌽⍉)। जब वह समाप्त हो जाता है, तो परिणाम के उन्मुखीकरण को सही करता है ( ⊖∘⌽⍣⍵⌽) और संख्याओं को एन ² +1 ( 1+×⍨-) से घटाकर उलट देता है ।

Answer 8

गणितज्ञ, १ 17 by बाइट्स

(n=#;i=j=Floor[(n+1)/2];c=1;d=0;v={{1,0},{0,-1},{-1,0},{0,1}};a=Table[j+n(i-1),{i,n},{j,n}];Do[Do[Do[a[[j,i]]=c++;{i,j}+=v[[d+1]], {k,l}];d=Mod[d+1,4],{p,0,1}],{l,n-1}];Grid@a)&

Comments

मैथेमैटिका में इसके लिए वायात, कोई बिल्ट-इन नहीं?

— श्री एक्सकोडर

Answer 9

सी ++, 245 228 बाइट्स

void f(){for(int i=0,j=-1,v,x,y,a,b;i<n;i++,j=-1,cout<<endl)while(++j<n){x=(a=n%2)?j:n-j-1;y=a?i:n-i-1;v=(b=y<n-x)?n-1-2*(x<y?x:y):2*(x>y?x:y)-n;v=v*v+(b?n-y-(y>x?x:y*2-x):y+1-n+(x>y?x:2*y-x));cout<<setw(log10(n*n)+1)<<v<<' ';}}

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

फ़ंक्शन इस तर्क को लागू करके अपने x, y स्थिति के आधार पर मैट्रिक्स की प्रत्येक संख्या के मूल्य की गणना और प्रिंट करता है:

प्रारूपित संस्करण :

#include <iostream>
#include <iomanip>
#include <math.h>

using namespace std;

void f(int n)
{
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            int value = 0;

            // Invert x and y when n is even
            int x = n % 2 == 0 ? n - j - 1 : j;
            int y = n % 2 == 0 ? n - i - 1 : i;
            if (y < (n - x))
            {
                // Left-top part of the matrix
                int padding = x < y ? x : y;
                value = n - 1 - padding * 2;
                value *= value;
                value += y >= x ? n - x - y : n + x - y - (y * 2);
            }
            else
            {
                // Right-bottom part of the matrix
                int padding = x > y ? n - x : n - y;
                value = n - padding * 2;
                value *= value;
                value += x > y ? y - padding + 1 : n + y - x - (padding * 2) + 1;
            }

            cout << setw(log10(n * n) + 1);
            cout << value << ' ';
        }

        cout << endl;
    }
}

int main()
{
    int n;
    while (cin >> n && n > 0)
    {
        f(n);
        cout << endl;
    }
}

Answer 10

अजगर 3 , 249 247 बाइट्स

मैं एक 2 डी सरणी को इनिशियलाइज़ करता हूं और शुरुआती बिंदु को ढूंढता हूं, जो विषम n या ऑफसेट (-1, -1) के लिए केंद्र है, यहां तक ​​कि n के लिए फिर फिल / कर्सर पैटर्न को स्केल करें। मुझे लगता है कि मैं दिशाओं की व्याख्या करने के लिए एक चाल याद कर रहा हूं, लेकिन मैं कुछ भी सस्ता नहीं आया हूं।

def f(n):
 M=[n*[0]for a in range(n)]
 x=y=n//2-1+n%2
 M[x][y]=i=s=1
 while 1:
  t=s*2
  for d in'R'+'D'*(t-1)+'L'*t+'U'*t+'R'*t:
   if i==n*n:print(*M,sep='\n');return
   v=[1,-1][d in'LU']
   if d in'UD':x+=v
   else:y+=v
   M[x][y]=i=i+1
  s+=1

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

-2 Zachary टी के लिए धन्यवाद!

Comments

आपने अपनी बाइट्स कैसे गिना? टैब, स्पेस और न्यूलाइन्स भी मायने रखते हैं

— फेलिप नारदी बतिस्ता

मैंने हर \ n और \ t को "" से बदल दिया और एक लेन () ले लिया। मैंने सिर्फ ऊपर की नकल की और यह सुनिश्चित करने के लिए इसे फिर से तैयार किया कि मैं कुछ भी नहीं बदलूं और याद करना भूल जाऊं लेकिन मुझे वही नंबर मिला। क्या मैं कुछ भुल गया?

— रात्रि

मैं गिन रहा हूँ \tऔर \n1 बाइट के रूप में और अभी भी 249 बाइट्स प्राप्त कर रहा हूँ

— फेलिप नारदी बतिस्ता

ई: ^ ^ ^ एक बेहतर / आसान तरीका है जिसका मुझे उपयोग करना चाहिए? वे हमेशा मेरे लिए इंटरचेंज के रूप में उपयोग किए गए दिखाई देते हैं। ^ ^ ^ ^ अजीब बात है, यह वही है जो मुझे len("def f(n): M=[n*[0]for a in range(n)] x=y=n//2-(n%2<1) M[x][y]=i=s=1 while 1: t=s*2 for d in'R'+'D'*(t-1)+'L'*t+'U'*t+'R'*t: if i==n*n:print(*M,sep='\n');return v=[1,-1][d in'LU'] if d in'UD':x+=v else:y+=v M[x][y]=i=i+1 s+=1") 223

— आईडीएल

आमतौर पर टेक्स्ट एडिटर आपको बताते हैं कि कितने वर्ण चुने गए हैं, इसलिए CTRL + A और पढ़ें कि यह क्या कहता है

— फेलिप नारदी बतिस्ता

Answer 11

वोल्फ्राम लैंग्वेज (मैथेमेटिका) , (...) 83 बाइट्स

UTF8 में मापी गई बाइट, \[LeftFloor]( ⌊) और \[RightFloor]( ⌋) प्रत्येक में 3 बाइट्स खर्च होते हैं। Mathematica में कोई विशेष बाइट कैरेक्टर सेट नहीं है।

Table[Max[4x^2-Max[x+y,3x-y],4y
y-{x+y,3y-x}]+1,{y,b+1-#,b=⌊#/2⌋},{x,b+1-#,b}]&

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

---

4 मामलों में से प्रत्येक के लिए बंद फॉर्म का उपयोग करता है, फिर वांछित परिणाम प्राप्त करने के लिए अधिकतम सावधानी से लेता है।

पूर्णांक का 2 डी सरणी देता है। मुझे यकीन नहीं है कि अगर इसकी अनुमति है, और यद्यपि यह टिप्पणियों में पूछा गया है , तो ओपी ने जवाब नहीं दिया।

Answer 12

क्लोजर, 206 बाइट्स

(defmacro F[s]`(if(~'r(+ ~'p ~'v ~s))~'v ~s))
#(loop[i 1 p(*(quot(dec %)2)(inc %))v 1 r{}](if(<(* % %)i)(partition %(map r(range i)))(recur(inc i)(+ p v)({1(F %)-1(F(- %))%(F -1)(- %)(F 1)}v)(assoc r p i))))

मुझे लगता है कि यह एक अच्छी शुरुआत है, एक हैश-मैप के क्रम में बोर्ड बनाता है और फिर इसे n x nसूचियों में विभाजित करता है। यह defmacroकाफी लंबा हो गया, लेकिन कोड अभी भी बिना इसके साथ कम है। क्या इसका वर्णन करने के लिए एक अधिक उपयुक्त वाक्यविन्यास है?

बाइट्स के थोक प्रारंभिक बिंदु की गणना करते हैं, और अगले वेग के लुक-अप तर्क का निर्माण करते हैं v। शायद एक नेस्टेड vecबेहतर होगा, लेकिन फिर आपको ट्रैक रखने के लिए दो अनुक्रमित और वेग मिले हैं।

Answer 13

जे , 41 बाइट्स

(]|.@|:@[&0](|.@|:@,.*/@$+#\)@]^:[1:)2*<:

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

Ngn's APL सबमिशन जैसी ही बात करता है लेकिन 1-बाय -1 मैट्रिक्स से शुरू होता है और 2 × N। 2 बार दोहराता है।

Comments

क्या आप अपने आप को हरा देने के लिए मेरे वैकल्पिक दृष्टिकोण (अब 41 से बंधे) में सुधार कर सकते हैं ? मैंने इसे अपना अब तक का सबसे अच्छा गोल्फ दिया है, लेकिन मुझे संदेह है कि कम से कम कुछ और बाइट्स का मुंडन हो सकता है।

— योना

Answer 14

पायथन 165 (या 144)

from pylab import *
def S(n):
 a=r_[[[1]]];r=rot90;i=2
 while any(array(a.shape)<n):
  q=a.shape[0];a=vstack([range(i,i+q),r(a)]);i+=q
 if n%2==0:a=r(r(a))
 print(a)

यह एक सुव्यवस्थित सरणी बनाता है, फिर इसे घुमाता है और एक पक्ष जोड़ता है जब तक कि सही आकार तक नहीं पहुंच जाता है। यह प्रश्न निर्दिष्ट नहीं करता है कि क्या समान स्टार्ट पॉइंट का उपयोग सम और विषम संख्याओं के लिए किया जाना चाहिए, यदि ऐसा नहीं है तो लाइन if n%2==0:a=r(r(a))को हटाया जा सकता है, जिससे 21 बाइट्स बचती हैं।

Comments

यह पायथन नहीं है, यह अजगर + सुन्न है

— केवल

@ ASCII- केवल कहीं स्वीकार्य भाषा के नामों की एक मास्टर सूची है? यह पूरी तरह से वैध अजगर है।

— user2699

यह एक पुस्तकालय का उपयोग करता है, इसलिए आपको पुस्तकालय का नाम भी शामिल करने की आवश्यकता है ... अनुमत भाषाओं के लिए, सार्वजनिक रूप से उपलब्ध कार्यान्वयन के साथ किसी भी भाषा को चलाने के लिए आप अनुमति दे सकते हैं

— ASCII-only

@ ASCII- केवल वह कहां लिखा है? मैंने इसे अधिकांश अजगर जवाबों के साथ नहीं देखा है।

— user2699

हां, क्योंकि उनमें से अधिकांश सुन्न का उपयोग नहीं करते हैं ... और stdlib एक बाहरी पुस्तकालय के रूप में नहीं गिना जाता है

— केवल

Answer 15

जे , 41 बाइट्स

,~$[:/:[:+/\_1|.1&,(]##@]$[,-@[)2}:@#1+i.

मानक स्वरूपण

,~ $ [: /: [: +/\ _1 |. 1&, (] # #@] $ [ , -@[) 2 }:@# 1 + i.

यह दृष्टिकोण प्ले विथ जे विलेट्स पर आधारित है (Uriel's APL एक समान तकनीक का उपयोग करता है) पर आधारित है।

यह अप्रत्याशित और सुरुचिपूर्ण है एक 2 जे उत्तर को सही ठहराने के लिए, मैंने सोचा।

अनिवार्य रूप से, हम कुछ प्रक्रियात्मक या यहां तक ​​कि ज्यामितीय भी नहीं करते हैं। इसके बजाय, हम अंकगणितीय रूप से एक सरल अनुक्रम बनाते हैं, जब स्कैन किया जाता है और वर्गीकृत किया जाता है, तो सर्पिल नंबर की सही क्रम बाएं से दाएं, ऊपर से नीचे तक देता है। फिर हम एक मैट्रिक्स में आकार लेते हैं और किया जाता है।

जब समय अनुमति देता है, तो मैं एक अधिक विस्तृत विवरण जोड़ूंगा, लेकिन जुड़ा हुआ लेख इसे गहराई से बताता है।

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

Answer 16

पायथन 3 (स्टैकलेस) , 192 188 179 150 बाइट्स

lambda n:[list(map(v,list(range(t-n,t)),[y]*n))for t in[1+n//2]for y in range(n-t,-t,-1)]
v=lambda x,y,r=0:y>=abs(x)and(3-2*r+4*y)*y+x+1or v(y,-x,r+1)

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

एल्गोरिथ्म यहाँ ग्रिड में प्रत्येक समन्वय के लिए एक चरणबद्ध बनाने के लिए है, और फिर इसे 90 डिग्री पर दक्षिणावर्त घुमाएं जब तक कि चरण ऊपरी विकर्णों के बीच स्थित न हो। एक सरल सूत्र का उपयोग निर्देशांक और घड़ी की घुमाव की संख्या के आधार पर मूल्य की गणना करने के लिए किया जा सकता है:

$$(2y+1)^2-(y-x)-2yr$$

सहेजे गए 4-बाइट्स चूंकि 90-डिग्री फ़ासर रोटेशन आसानी से जटिल संख्याओं के बिना किया जाता है

Answer 17

आर , 183 बाइट्स

x=scan()
b=t(d<-1)
while(2*x-1-d){m=max(b)
y=(m+1):(m+sum(1:dim(b)[2]|1))
z=d%%4
if(z==1)b=cbind(b,y)
if(z==2)b=rbind(b,rev(y))
if(z==3)b=cbind(rev(y),b)
if(z==0)b=rbind(y,b)
d=d+1}
b

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

आउटपुट एक मैट्रिक्स साँप है (या साँप मैट्रिक्स, जो भी हो)। यह शायद सबसे कुशल तरीका नहीं है, और यह संभवतः गोल्फ हो सकता है, लेकिन मुझे लगा कि यह दिखाने लायक है। मुझे इस पर वास्तव में गर्व है!

विधि अंदर से बाहर मैट्रिक्स का निर्माण करती है, हमेशा एक अतिरिक्त संख्या में पूर्णांकों को जोड़ने से पहले मैट्रिक्स में स्तंभों की संख्या के बराबर होती है। इसके बाद का पैटर्न या तो स्तंभों या पंक्तियों द्वारा बाध्यकारी होता है, जबकि कुछ मानों को उलट भी देता है ताकि उन्हें सही क्रम में जोड़ा जाए।

193 बाइट्स

उपरोक्त के समान ही, लेकिन अंतिम bहै

matrix(b,x)

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

जो थोड़ा क्लीनर आउटपुट देता है, लेकिन मैंने आउटपुट के लिए कोई विशेष मानदंड नहीं देखा है, इसलिए यदि मैं गलत नहीं हूं तो पहला उत्तर काम करना चाहिए।