ओ (लॉग एन) मेमोरी में एक एससीआई सर्पिल प्रिंट करें

Question

आप एक प्रोग्राम या फ़ंक्शन लिख सकते हैं जो एक विषम, सकारात्मक पूर्णांक प्राप्त करता है n, जहां n >= 3, एक फ़ंक्शन तर्क, कमांड लाइन तर्क, या STDIN (या आपके सिस्टम के लिए समकक्ष) के रूप में, और ASDII सर्पिल STDOUT (या सिस्टम समकक्ष) को प्रिंट करता है। यह भीतर की ओर घूमता है जहां शीर्ष किनारे बिल्कुल nवर्ण लंबा होता है। पहला दाहिना किनारा n+1स्पष्ट रूप से वर्ण लंबा होना चाहिए । उदाहरण के लिए,

इनपुट:

1 1

आउटपुट:

***********
          *
********* *
*       * *
* ***** * *
* *   * * *
* * * * * *
* * *** * *
* *     * *
* ******* *
*         *
***********

कैच:

• आपके प्रोग्राम को O(log n)मेमोरी से अधिक उपयोग नहीं करना चाहिए ।
• आपका प्रोग्राम केवल अक्षर *(ASCII 42), (ASCII 32), <CR>(ASCII 13) और <LF>(ASCII 10) प्रिंट कर सकता है ।
• आपके प्रोग्राम को स्ट्रिंग प्रिंट करना होगा, इसे फ़ंक्शन से वापस नहीं करना चाहिए।
• बिग-ओ प्रतिबंध केवल स्मृति पर है , रनटाइम पर कोई प्रतिबंध नहीं है ।
• एक अनुगामी न्यूलाइन वैकल्पिक है।
• यदि आपकी भाषा बड़े पूर्णांक प्रकारों का समर्थन नहीं करती है, तो आपको इसका समर्थन करने की तुलना में अधिक समर्थन करने की आवश्यकता नहीं है, लेकिन आप इसे "ओह" कहने के लिए एक चाल के रूप में उपयोग नहीं कर सकते हैं, ठीक है, मुझे एक्स के ऊपर समर्थन करने की आवश्यकता नहीं है इसलिए मैं हर बार एक विशाल सरणी को अधिकतम आकार बना सकते हैं "

मानक खामियों पर प्रतिबंध लगा दिया जाता है, हमेशा की तरह।

Comments

मुझे विश्वास नहीं होता कि यह संभव है। कोई इनपुट nको O (1) मेमोरी में स्टोर नहीं कर सकता है ।

— xnor

@xnor "O (1) एक निरंतर मेमोरी उपयोग करता है। इसलिए इनपुट की मात्रा असंगत है" - यदि इनपुट n पूर्णांक में फिट बैठता है, तो मुझे यकीन है कि इसे एक निरंतर मेमोरी उपयोग में कोडित किया जा सकता है।

— एंड्रे

इनपुट संग्रहीत करना बिट्स nलेता log nहै। जैसा कि nबड़ा होता है, इसलिए इसे स्टोर करने के लिए आवश्यक स्थान की आवश्यकता होती है। क्या आप शायद सीमित संख्या में चर के साथ ऐसा करने के लिए कह रहे हैं?

— xnor

या, वैकल्पिक रूप से, क्या इसकी कोई सीमा है n?

— Sp3000

मुझे लगता है कि वह कह रहा है कि आप एक ही बार में पूरे आउटपुट को स्टोर नहीं कर सकते हैं, तो बस इसे एक बार में ही प्रिंट कर लें क्योंकि यह बड़ा हो जाएगा। आपको संभवतः इसे पुन: मुद्रित करना होगा।

— जैकब

Answer 1

सी, 125 121 बाइट्स

गोल्फ संस्करण यह कोई चर नहीं है k। चर kका उपयोग केवल पठनीयता की सहायता के लिए ungolfed संस्करण में किया जाता है। इसके अलावा forलूप कंडीशन को फिर से व्यवस्थित किया जाता है और अनावश्यक {}हटाए जाने का एक सेट किया जाता है। प्रारंभिक स्थिति में लूप के ब्रैकेट के अंदर {}माइग्रेट करके एक और सेट को हटाया जा सकता है , लेकिन इसका मतलब आउटपुट की शुरुआत में एक नई रेखा होगा, इसलिए मैंने ऐसा नहीं किया है।puts("")j

f(n){int i,j;n/=2;for(i=-n-2;i++-n-1;){if(i){for(j=-n-1;j++-n;)putchar(32+10*(n+(j*j<i*i?i:j+(i!=j|i>0))&1));puts("");}}}

उदाहरण की तरह उच्च सर्पिल nद्वारा एक विस्तृत प्रिंट n+1।

व्याख्या

मूल रूप से मैं के मूल्य को आधा n(नीचे गोलाई) और दो छोरों चलाएँ: एक बाहरी एक iसे -n/2-1करने के लिए n/2+1पंक्तियों मुद्रित करने के लिए ( i=0दबा दिया जाता है तो हम मिल n+1पंक्तियाँ) और एक आंतरिक एक jसे ( -n/2करने के लिए n/2हम का उपयोग वर्ण मुद्रित करने के लिए।) expression & 1धारियों मुद्रित करने के लिए , और यह j*j<i*iतय करने की स्थिति है कि ऊर्ध्वाधर या क्षैतिज पट्टियों को प्रिंट करना है (ऊर्ध्वाधर जहां पक्षों की पूर्ण परिमाण iबड़ी है, और ऊपर और नीचे क्षैतिज है।) एक समायोजन +nकी आवश्यकता है कि क्या n/2विषम है या नहीं इसके आधार पर सही समाप्ति के साथ मदद करने के लिए यहाँ तक की।

kआम तौर पर 1 है, और इस तथ्य के लिए एक समायोजन प्रदान करता है कि i1 से सीमा n/2+1के पूर्ण मान जबकि j0 से सीमा तक के निरपेक्ष मान n/2। यदि kहमेशा 1 था तो हमें गाढ़ा आयताकार मिलेगा, लेकिन यह 0 से उल्टा है, i==j&i<=0ताकि कोशिकाओं की एक विकर्ण पंक्ति उलट हो, सर्पिल का उत्पादन हो।

परीक्षण कार्यक्रम में अपुष्ट

f(n){
  int i,j,k;
  n/=2;
  for(i=-n-1;i<=n+1;i++){
    if(i){
       for(j=-n;j<=n;j++){
           k=i!=j|i>0;
           putchar(32+10*(n+(j*j<i*i?i:k+j)&1));
         }
       puts("");
     }
  }
} 

int m;
main(){
  scanf("%d",&m);
  f(m);
}

उत्पादन

11
***********
          *
********* *
*       * *
* ***** * *
* *   * * *
* * * * * *
* * *** * *
* *     * *
* ******* *
*         *
***********

9
*********
        *
******* *
*     * *
* *** * *
* * * * *
* *   * *
* ***** *
*       *
*********

3
***
  *
* *
***

1
*
*

Comments

मुझे एक बिट से मारो ... +1 यह पागल कम है!

— सूदो rm -rf स्लैश

114 बाइट्स

— सीलिंगकैट

Answer 2

सी, 118 बाइट्स

m,p,x,y,d;f(n){for(m=n++/2;p<n*n;x=p%n-m,y=p++/n-m,d=y==x+1&x<0,y-=y>0,d+=x*x>y*y?x:y,putchar(x>m?10:(d+m)%2?32:42));}

अंतिम गोल्फिंग से पहले कोड:

#include <stdio.h>

int m, p, x, y, d;

int f(int n) {
    for (m = n++ / 2; p < n * n; ) {
        x = p % n - m;
        y = p++ / n - m;
        d = y == x + 1 && x < 0;
        y -= y > 0;
        d += x * x > y * y ? x : y;
        if (x > m) {
            putchar(10);
        } else if ((d + m) % 2) {
            putchar(32);
        } else {
            putchar(42);
        }
    }

    return 0;
}

मुख्य अवलोकन यह है कि पैटर्न लगभग सांद्र वर्गों की एक श्रृंखला है। थोड़ी सी झुर्रियों के साथ:

• Y- आकार x- आकार से एक बड़ा है। यह निचले आधे के लिए y से 1 घटाकर सही किया जाता है, जो अनिवार्य रूप से मध्य पंक्ति को दोहराता है।
• आयतों को एक सर्पिल में बदलने के लिए, y = x + 1विकर्ण के साथ पिक्सेल को आकार के बीच में उल्टा करने की आवश्यकता होती है।

बाकी के लिए, कोड सभी पदों पर बस लूपिंग है, प्रत्येक स्थिति के लिए केंद्र से चेबीशेव दूरी की गणना, और दूरी या विषम होने के आधार पर दो वर्णों में से एक का उत्सर्जन करना। और प्रत्येक पंक्ति की अंतिम स्थिति के लिए एक नई रेखा का उत्सर्जन।

चूँकि कुछ ही स्केलर वैरिएबल हैं, और कैरेक्टर एक-एक करके उत्सर्जित होते हैं, इसलिए मेमोरी का उपयोग स्पष्ट रूप से स्थिर है।

Comments

बहुत बढ़िया जवाब है, लेकिन जैसा pकि आपने शुरू नहीं किया है मुझे लगता है कि आप मेटा . codegolf.stackexchange.com/q/4939/15599 की बेईमानी करते हैं । मैं एक फ़ंक्शन सबमिट करते समय वैश्विक चर घोषित करने के बारे में निश्चित नहीं हूं। अगर मैंने ऐसा किया तो जाहिर तौर पर मेरा जवाब 4 बाइट्स वाला होगा। मैंने एक मेटा पोस्ट meta.codegolf.stackexchange.com/q/5532/15599

— लेवल रिवर सेंट

हां, इसने मेरे दिमाग को पार कर दिया कि मुझे शायद इनिशियल करना चाहिए p।

— रेटो कोराडी

Answer 3

सी ++, 926 बाइट्स

#include<iostream>
#include<string>
#include<math.h>
#define S string
using namespace std;S N(S x,int y){S z="";for(int q=0;q<y;q++){z+=x;}return z;}int main(){int n=0,t=0,g=0,fi=1;cin>>n;int t1[]={0,0,n,0};int t2[]={0,n-2,n-2,1};for(int k=0;k<n+1;k++){if((k>(n-2)/2)&&(k<(n+5)/2)){if(g==0){S d,e;if(!((n+1)%4)){cout<<N("* ",t2[0])<<"  *"<<N(" *",t2[0])<<endl<<N("* ",(n+1)/2)<<endl<<N("* ",t2[0])<<"***"<<N(" *",t2[0])<<endl;t2[2]=n-8-(n-11);t1[2]=n-4-(n-11);t1[0]--;t2[3]--;t1[3]-=2;}else{cout<<N("* ",t1[0])<<"***"<<N(" *",t2[0])<<endl<<N("* ",(n+1)/2)<<endl<<N("* ",t1[0])<<"*  "<<N(" *",t2[0])<<endl;t2[0]--;t1[2]+=2;t2[2]+=6;t1[3]--;t2[1]-=2;t2[3]-=2;}fi=0;}g=5;}else{t=1-t;int*tR;tR=t?t1:t2;cout<<N("* ",tR[0])<<N(t?"*":" ",tR[2])<<N(" *",tR[3])<<endl;if(fi){if(t){t1[0]+=k==0?0:1;t1[2]-=k==0?2:4;t1[3]++;}else{t2[0]++;t2[2]-=4;t2[3]++;}}else{if(t){t1[0]--;t1[2]+=4;t1[3]--;}else{t2[0]--;t2[2]+=4;t2[3]--;}}}}return 0;}

यह सुरुचिपूर्ण नहीं है, लेकिन यह बड़े n के लिए ज्यादा मेमोरी नहीं लेता है। इसके अलावा, वहाँ लगभग (लगभग निश्चित रूप से) कर रहे हैं कि लगभग 20 वर्णों आगे गोल्फ हो सकता है, लेकिन मैं अब इसे देखने के लिए खड़े नहीं हो सकते।

संक्षिप्त विवरण:

यह सर्पिलों में लाइनों को दो प्रकारों में विभाजित करता है: बीच में ****** वाले और बीच में \ _ s \ s \ s \ s वाले। फिर यह स्पष्ट है कि प्रत्येक रेखा कई "*", मध्य और कुछ "*" से बनी है। यदि आप पैटर्न को लंबे समय तक देखते हैं तो वास्तव में यह पता लगाना कि प्रत्येक चीज कितनी सरल है। मुश्किल चीज सर्पिल के केंद्र को प्रिंट कर रही थी जिसे मैं मूल रूप से एक सशर्त का उपयोग करके कोडित करता था। यह समाप्त होने के कारण उपयोगी हो गया क्योंकि *** और \ s \ s की रेखाएँ विषम / यहाँ तक कि स्विच हैं।

टेस्ट:

इनपुट: 55 (मुझे लगता है कि बड़े लोग सबसे अच्छे लगते हैं)

आउटपुट:

************************************************** *****
                                                      *
************************************************** *** *
* * *
* ************************************* * *
* * * * *
* * ***************************************
* * * * * * *
* * * ***************************************
* * * * * * * * *
* * * * *************************************
* * * * * * * * * * *
* * * * * *********************************
* * * * * * * * * * * * *
* * * * * * *********************************
* * * * * * * * * * * * * * *
* * * * * * * *********************************
* * * * * * * * * * * * * * * * *
* * * * * * * * ***********************************
* * * * * * * * * * * * * * * * * * * *
* * * * * * * * * ***************** * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * ************* * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * ********* * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * ***** * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * मेरा कार्यक्रम यहाँ एक जगह जोड़ता है btw
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * ******* * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * *********** * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * *************** * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * *********************************
* * * * * * * * * * * * * * * * * * *
* * * * * * * * *********************************
* * * * * * * * * * * * * * * *
* * * * * * * *******************************
* * * * * * * * * * * * * *
* * * * * * *********************************
* * * * * * * * * * * *
* * * * * *********************************
* * * * * * * * * *
* * * * ***********************************
* * * * * * * *
* * * *********************************
* * * * * *
* * *********************************** *
* * * *
* ************************************* ** *
* *
************************************************** *****

इनपुट: 3

आउटपुट:

***
  *
* * 
***

नोट: मैं एक कंप्यूटर वैज्ञानिक / सीएस छात्र नहीं हूं, और मुझे नहीं पता कि यह कैसे साबित किया जाए कि यह O (log n) मेमोरी का उपयोग करता है। मैं केवल प्रश्न में लिंक के आधार पर क्या कर सकता हूं, इस पर काम कर सकता हूं। यदि कोई व्यक्ति इस उत्तर को मान्य करता है तो मैं उसकी पुष्टि / इनकार कर सकता / सकती हूं। इस उत्तर की वैधता के लिए मेरा तर्क यह है कि यह कभी भी इनपुट के अलावा n के आधार पर आकार के किसी भी चर को संग्रहीत नहीं करता है। इसके बजाय, एन के लिए चलने वाला लूप एक एन के आधार पर पूर्णांक मानों की गणना करता है। इनपुट की परवाह किए बिना उन मानों की समान संख्या है।

नोट 2: मध्य से निपटने के मेरे तरीके के कारण यह n = 1 के लिए काम नहीं करता है। यह सशर्त के साथ ठीक करना आसान होगा, इसलिए यदि कोई मेरे जवाब के कुछ पात्रों के भीतर है, तो मैं इसे ठीक कर दूंगा;)

इसके साथ विचारधारा पर खेलते हैं।

Comments

मेरा मानना ​​है कि यह मान्य है, भले ही एक लाइन पर इतना सी ++ कोड पढ़ने के लिए है। ;) आपकी समझ सही है। आप किसी भी मेमोरी का उपयोग उस आकार के साथ नहीं कर सकते जो निर्भर करता है n। एक विशिष्ट उदाहरण जो आवश्यकता को पूरा नहीं करता है वह कुछ प्रकार के स्ट्रिंग / बफर / सरणी होगा जो आउटपुट की पूरी रेखा रखता है।

— रीटो कोराडी जूल

चूंकि इस एकमात्र उत्तर में, मैंने इस सवाल को समायोजित करने की आवश्यकता है कि हैंडलिंग की आवश्यकता नहीं है n=1, क्योंकि मैं ऐसे विशेष आवरण को दिलचस्प नहीं मानता।

— Durron597

Answer 4

हास्केल, 151 बाइट्स

(#)=mod
f n=[[if y<= -(abs$x+1)||y>abs x then r$y#2/=n#2 else r$x#2==n#2|x<-[-n..n]]|y<-[-n-1..n+1],y/=0]
r b|b='*'|1<2=' '
p=putStr.unlines.f.(`div`2)

उपयोग उदाहरण:

*Main> p 9
*********
        *
******* *
*     * *
* *** * *
* * * * *
* *   * *
* ***** *
*       *
*********

*Main> p 11
***********
          *
********* *
*       * *
* ***** * *
* *   * * *
* * * * * *
* * *** * *
* *     * *
* ******* *
*         *
***********

हास्केल के आलस्य के लिए धन्यवाद यह निरंतर स्मृति के भीतर चलता है। यह स्पष्ट दृष्टिकोण का उपयोग करता है, यानी लूपिंग ओवर yऔर के xबीच चयन करता है *और , पर निर्भर करता है

• यदि वर्तमान स्थिति एक विकर्ण के ऊपर या नीचे है
• xresp। yसम या विषम है
• n/2 सम या विषम है

Answer 5

आम लिस्प - 346

(lambda(n &aux(d 0))(tagbody $ #6=(#7=dotimes(i n)#4=(princ"*"))#2=(#7#(i d)#5=(princ" ")#4#)#3=(terpri)#1=(#7#(i d)#4##5#)(when(> n 0)(#7#(i(1- n))#5#)#4#)#2##3#(when(> n 3)#1##4##4#(incf d)(decf n 4)(go $))(go /)@(decf d)(incf n 4)(when(> n 3)#2##5##4##3#)/ #1#(when(> n 0)#4#)(when(> n 1)(#7#(i(- n 2))#5#)#4#)#2##3##1##6#(when(> d 0)(go @))))

निरंतर मेमोरी उपयोग के साथ Iterative समाधान। ऊपर #n=और #n#पाठक चर का भारी उपयोग करता है । भले ही अधिक प्रत्यक्ष दृष्टिकोण हैं, यहां मैंने एक पुनरावर्ती कार्य के साथ शुरू किया और gotoबयानों के साथ पुनरावृत्ति को संशोधित करने के लिए इसे संशोधित किया : यह संभवतः अपठनीय है।

0 से 59 तक सभी इनपुट मूल्यों के लिए आउटपुट ।

डिबगिंग informations के साथ मूल पुनरावर्ती संस्करण

(नोट: terpriसाधन newline)

(defun spiral (n &optional (d 0) )
  (flet ((prefix ()
           (format t "~4d~4d | " n d)
           (dotimes (i d)
             (princ "a ")))
         (postfix ()
           (dotimes (i d)
             (princ " b"))))
    (when (= d 0) (prefix))
    (dotimes (i n) (princ "c"))
    (postfix)
    (terpri)

    (prefix)
    (when (> n 0)
      (dotimes (i (1- n)) (princ " "))
      (princ "d"))
    (postfix)
    (terpri)

    (when (> n 3)
      (prefix)
      (princ "**")
      (spiral (- n 4) (1+ d))
      (postfix)
      (princ " f")
      (terpri))

    (prefix)
    (when (> n 0)
      (princ "g"))

    (when (> n 1)
      (dotimes (i (- n 2)) (princ " "))
      (princ "h"))
    (postfix)
    (terpri)

    (prefix)
    (dotimes (i n) (princ "i"))
    ))

उदाहरण के लिए:

(spiral 8)

   8   0 | cccccccc
   8   0 |        d
   8   0 | **cccc b
   4   1 | a    d b
   4   1 | a ** b b
   0   2 | a a  b b
   0   2 | a a  b b
   0   2 | a a  b f
   4   1 | a g  h b
   4   1 | a iiii f
   8   0 | g      h
   8   0 | iiiiiiii

0 से 59 तक सभी परिणामों के साथ इस पेस्ट को भी देखें (ऊपर जैसा नहीं, यह एक और क्रिया है)।

डिबगिंग informations के साथ Iterative संस्करण

(defun spiral (n &aux (d 0) )
  (flet ((prefix ()
           (format t "~4d~4d | " n d)
           (dotimes (i d)
             (princ "a ")))
         (postfix ()
           (dotimes (i d)
             (princ " b"))))
    (tagbody
     step-in
       (when (= d 0) (prefix))
       (dotimes (i n) (princ "c"))
       (postfix)
       (terpri)

       (prefix)
       (when (> n 0)
         (dotimes (i (1- n)) (princ " "))
         (princ "d"))
       (postfix)
       (terpri)

       (when (> n 3)
         (prefix)
         (princ "**")

         (incf d)
         (decf n 4)
         (go step-in))

       (go skip)

     step-out
       (decf d)
       (incf n 4)
       (when (> n 3)
         (postfix)
         (princ " f")
         (terpri))

     skip
       (prefix)
       (when (> n 0)
         (princ "g"))

       (when (> n 1)
         (dotimes (i (- n 2)) (princ " "))
         (princ "h"))
       (postfix)
       (terpri)

       (prefix)
       (dotimes (i n) (princ "i"))
       (when(> d 0)(go step-out)))))

Comments

क्या आप बता सकते हैं कि यह स्मृति प्रतिबंध से कैसे मिलता है? मैं केवल एक पुनरावृत्ति बिंदु देखता हूं, जो अच्छा है, लेकिन क्या आप बस थोड़ा और विस्तार में जा सकते हैं?

— डुर्रोन 597

@ durron597 हां, मैं इस पर काम कर रहा हूं। यह वर्तमान में O (n) है क्योंकि हम फ़ंक्शन को पुनरावर्ती रूप से कई बार आनुपातिक nकहते हैं और कॉल स्टैक उसी के अनुसार बढ़ता है, लेकिन इस मामले में, हम दो छोरों के साथ पुनरावृत्ति का अनुकरण कर सकते हैं: एक nघटने और dबढ़ने के साथ (जब तक n </ 3) ), और dशून्य को कम करने के साथ एक और एक । मेरे पास इस समय काम करने के लिए अधिक समय नहीं है, लेकिन मैं तदनुसार उत्तर अपडेट करने का प्रयास करूंगा। Btw, सर्पिल को मुद्रित करने के लिए और अधिक प्रत्यक्ष तरीके हैं, लेकिन इसे पुनरावर्ती रूप से परिभाषित करने में मज़ा आया।

— coredump

Answer 6

CJam, 72 बाइट्स

li_2/:M;)__*{1$mdM-\M-_2$)=2$0<*@_*@_0>-_*e>mQ_M>2*@@+M+2%+'#S+N+N+=o}/;

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

भले ही यह एक गोल्फ भाषा का उपयोग करने का एक महान प्रदर्शन नहीं है, यह अभी भी सी कोड की तुलना में काफी कम है, क्योंकि अंकन अधिक कॉम्पैक्ट है।

स्पष्टीकरण:

li    Get input n.
_2/   Calculate n/2.
:M;   Store it in variable M
)__*  Calculate (n+1)*(n+1), which is the total number of output characters.
      Also keep a copy of n+1 on the stack.
{     Start loop over output character positions.
  1$md  Calculate divmod of position with n+1. This gives y and x of position.
  M-    Subtract M from x.
  \M-   Subtract M from y.
  _     Copy y.
  2$)   Calculate x+1.
  =     Check if y == x+1
  2$0<  Check if x < 0.
  *     Multiply the two check results. This is the result of the flip
        condition for the top-left diagonal to turn the rectangles into a spiral.
  @_*   Calculate x*x.
  @_    Get y to top of stack, and copy it.
  0>-   Subtract 1 from y if it is in the bottom half.
  _*    Calculate y*y.
  e>    Take maximum of x*x and y*y...
  mQ    ... and calculate the square root. This is the absolute value of the
        larger of the two.
  _M>   Check if the value is greater M, which means that this is the
        position of a line end.
  2*    Multiply by 2 so that we can add another condition to it later.
  @     Get result of diagonal flip condition to the stack top.
  @     Get max(x,y) to the top.
  +M+   Add the two, and add M to the whole thing. This value being even/odd
        determines if the output is a # or a space.
  2%    Check if value is odd.
  +     Add to line end condition to get a single ternary condition result.
  '#S+N+N+
        Build string "# \n\n".
  =     Use the condition result to pick the output character out of the string.
  o     Output the character.
}/    End loop over output characters.
;     Pop n+1 value off stack, to leave it empty.