ও (লগ এন) মেমরিতে একটি এ্যাস্কিআই সর্পিল প্রিন্ট করুন

Question

আপনি এমন একটি প্রোগ্রাম বা ফাংশন লিখতে পারেন যা একটি বিজোড়, ধনাত্মক পূর্ণসংখ্যার প্রাপ্ত হয় n , যেখানে n >= 3কোনও ফাংশন আর্গুমেন্ট হিসাবে, কমান্ড লাইন আর্গুমেন্ট হিসাবে, বা এসটিডিআইএন (বা আপনার সিস্টেমের সমতুল্য) হিসাবে, এবং এসএসডিআই (বা সিস্টেমের সমতুল্য) এ ASCII সর্পিল প্রিন্ট করে এটি ঘড়ির কাঁটার দিকে স্পিন করে যেখানে শীর্ষ প্রান্তটি হ'ল nঅক্ষর দীর্ঘ। প্রথম ডান প্রান্তটি n+1অবশ্যই অক্ষরে লম্বা হওয়া উচিত । এই ক্ষেত্রে,

ইনপুট:

11

আউটপুট:

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

ক্যাচ:

• আপনার প্রোগ্রামটি অবশ্যই O(log n)মেমরির চেয়ে বেশি ব্যবহার করবে না ।
• আপনার প্রোগ্রামটি কেবল অক্ষর *(ASCII 42), (ASCII 32), <CR>(ASCII 13) এবং <LF>(ASCII 10) মুদ্রণ করতে পারে ।
• আপনার প্রোগ্রামটি অবশ্যই স্ট্রিংটি মুদ্রণ করবে, এটি ফাংশন থেকে ফিরিয়ে দেবে না।
• বিগ-ও-বাধা কেবল মেমোরিতে , রানটাইমটিতে কোনও বিধিনিষেধ নেই ।
• একটি ট্রেলিং নিউলাইন optionচ্ছিক।
• আপনার ভাষা যদি বড় সংখ্যার প্রকারকে সমর্থন করে না, আপনাকে যা সমর্থন করে তার চেয়ে বেশি সমর্থন করতে হবে না, তবে আপনি এটিকে ট্রিক হিসাবে ব্যবহার করতে পারেন না "ওহ, ভাল, আমাকে এক্স এর উপরে সমর্থন করতে হবে না তাই আমি প্রতিটি সময় সর্বাধিক আকারে কেবল একটি বিশাল অ্যারে তৈরি করতে পারে "

যথারীতি স্ট্যান্ডার্ড লুফোলগুলি নিষিদ্ধ করা হয়েছে।

Comments

আমি বিশ্বাস করি না এটি সম্ভব। nও (1) মেমরিতে কোনও ইনপুট সঞ্চয় করতে পারে না ।

— xnor

@xnor "O (1) একটি ধ্রুবক মেমরি ব্যবহার গঠন করে So সুতরাং ইনপুটের পরিমাণটি অসংলগ্ন" - যদি ইনপুট এন পূর্ণসংখ্যার সাথে ফিট করে, তবে আমি নিশ্চিত যে এটি একটি ধ্রুবক মেমরির ব্যবহারে কোড করা যেতে পারে।

— আন্দ্রে

ইনপুট সংরক্ষণ করতে বিট nলাগে log n। হিসাবে nবৃহত্তর পায়, তাই স্থান সঞ্চয় করা প্রয়োজন আছে। আপনি কি সম্ভবত সীমিত সংখ্যক ভেরিয়েবলের সাথে এটি করতে বলছেন?

— xnor

বা, বিকল্পভাবে, কোন সীমা আছে n?

— Sp3000

আমি মনে করি তিনি বলছেন আপনি একবারে পুরো আউটপুট সংরক্ষণ করতে পারবেন না, তবে কেবল একবারে এটি মুদ্রণ করুন কারণ এটি আরও বড় হবে। আপনাকে সম্ভবত এটি পুনরাবৃত্তভাবে মুদ্রণ করতে হবে।

— জ্যাকব

Answer 1

সি, 125 121 বাইট

গল্ফযুক্ত সংস্করণ এর কোনও পরিবর্তনশীল নেই k। ভেরিয়েবলটি কেবল kপাঠযোগ্যতার জন্য সহায়তার জন্য অসম্পূর্ণ সংস্করণে ব্যবহৃত হয়। এছাড়াও 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(নিচে rounding) এবং দুটি loops সঞ্চালন করুন: একটি বাইরের এক 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 iহয় n/2+1এবং এটি 1 এর থেকে পরিসরের পরম মানগুলি যখন j0 থেকে বিস্তারের পরম মানের হয় এর জন্য একটি সমন্বয় সরবরাহ করে n/2। যদি kসর্বদা 1 হত তবে আমরা কেন্দ্রীভূত আয়তক্ষেত্র পেয়ে যাব, তবে এটি 0 টিতে বিপরীত হয় i==j&i<=0যাতে কোষগুলির একটি তির্যক সারি উল্টো হয় এবং সর্পিল উত্পাদন করে।

পরীক্ষা প্রোগ্রামে ungolfed

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 এটি ক্ষিপ্ত!

— sudo 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-আকারের চেয়ে বড় one নিম্ন অর্ধের জন্য y থেকে 1 বিয়োগ করে এটি সংশোধন করা হয়েছে, যা মূলত মধ্য সারিটি পুনরাবৃত্তি করে।
• আয়তক্ষেত্রগুলিকে একটি সর্পিলে পরিণত করতে, y = x + 1ত্রিভুজ বরাবর পিক্সেলগুলি আকারের মাঝামাঝি পর্যন্ত উল্টানো উচিত।

বাকী ক্ষেত্রে, কোডটি সমস্ত পজিশনের উপর কেবল লুপিং করা হয়, প্রতিটি পজিশনের জন্য কেন্দ্র থেকে চেবিশেভ দূরত্ব গণনা করে এবং দূরত্বটি সমান বা বিজোড় হওয়ার উপর নির্ভর করে দুটি চরিত্রের একটি নির্গত করে। এবং প্রতিটি লাইনের শেষ অবস্থানের জন্য একটি নতুন লাইন নির্গমন করা হচ্ছে।

যেহেতু শুধুমাত্র কয়েকটি স্কেলার ভেরিয়েবল রয়েছে এবং অক্ষরগুলি একে একে নির্গত হয়, তাই মেমরির ব্যবহার অবশ্যই স্পষ্টভাবে স্থির থাকে।

Comments

দুর্দান্ত উত্তর, তবে আপনি আরম্ভ না করায় pআমার মনে হয় আপনি meta.codegolf.stackexchange.com/q/4939/15599 এর বদনাম হবেন । কোনও ফাংশন জমা দেওয়ার সময় আমি গ্লোবাল ভেরিয়েবলগুলি ঘোষণা করার বিষয়েও নিশ্চিত নই। স্পষ্টতই আমার উত্তরটি যদি আমি এটি করি তবে 4 বাইট কম হবে। আমি একটি মেটা পোস্ট মেটা কোড কোডেগল্ফ.স্ট্যাকেক্সেঞ্জার.কুই

— স্তরের নদী সেন্ট

হ্যাঁ, এটি আমার মনের দিক দিয়ে গেছে যে আমার সম্ভবত আরম্ভ করা উচিত 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;}

এটি মার্জিত নয়, তবে এটি বড় এন এর জন্য খুব বেশি স্মৃতি গ্রহণ করে না। তদুপরি, প্রায় 20 টি চরিত্র রয়েছে যা আরও গল্ফ করা যেতে পারে তবে আমি আর এটি দেখার পক্ষে দাঁড়াতে পারি না।

সংক্ষিপ্ত বিবরণ:

এটি সর্পিলরেখার রেখাগুলিকে দুটি প্রকারে বিভক্ত করে: মাঝখানে ****** সহ এবং মাঝখানে \ s \ s \ s \ s \ s সহ একটি। তারপরে এটি স্পষ্ট যে প্রতিটি লাইন বেশ কয়েকটি "*" গুলি, মাঝারি এবং কিছু "*" দ্বারা গঠিত। আপনি যদি দীর্ঘক্ষণ ধরে প্যাটার্নটি দেখেন তবে প্রতিটি জিনিসের ঠিক কতটি সহজ তা নির্ণয় করা। ছদ্মবেশী জিনিসটি সর্পিলটির কেন্দ্রস্থলটি মুদ্রণ করছিল যা আমি মূলত কঠোর শর্তসাপেক্ষে ব্যবহার করে কোড করেছিলাম। এটি দরকারী হিসাবে শেষ হয়েছে কারণ *** এবং \ s \ s \ s এর লাইনগুলি বিজোড় / এমনকি সেখানে স্যুইচ হচ্ছে।

পরীক্ষা:

ইনপুট: 55 (আমি মনে করি বড়গুলি দেখতে দুর্দান্ত দেখায়)

আউটপুট:

************************************************** *****
                                                      *
************************************************** *** *
* * *
* *********************************************** * *
* * * * * *
* * ******************************************* * * *
* * * * * * * *
* * * *************************************** * * * * *
* * * * * * * * * *
* * * * ************************************* * * * * * *
* * * * * * * * * * * * *
* * * * * ********************************* * * * * * * *
* * * * * * * * * * * * * * *
* * * * * * ***************************** * * * * * * * *
* * * * * * * * * * * * * * * * *
* * * * * * * ************************* * * * * * * * * *
* * * * * * * * * * * * * * * * * *
* * * * * * * * * ********************* * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * ***************** * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * ************* * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * ********* * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * ***** * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * {- আমার প্রোগ্রামটি এখানে বিটিডব্লু যোগ করেছে
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * ******* * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * *********** * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * *************** * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * ******************* * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * *
* * * * * * * * * *********************** * * * * * * * * *
* * * * * * * * * * * * * * * * *
* * * * * * * *************************** * * * * * * * *
* * * * * * * * * * * * * * * *
* * * * * * ******************************* * * * * * * *
* * * * * * * * * * * * * *
* * * * * *********************************** * * * * * *
* * * * * * * * * * *
* * * * ************************************* * * * * *
* * * * * * * * *
* * * ***************************************** * * *
* * * * * * *
* * ********************************************* * *
* * * *
* *********************************************** ** *
* *
************************************************** *****

ইনপুট: 3

আউটপুট:

***
  *
* * 
***

দ্রষ্টব্য: আমি কম্পিউটার বিজ্ঞানী / সিএস শিক্ষার্থী নই এবং এটি কীভাবে প্রমাণ করতে হয় যে এটি ও (লগ এন) মেমরি ব্যবহার করে তা আমি জানি না। আমি কেবল প্রশ্নের লিঙ্কগুলির ভিত্তিতে কী করতে হবে তা নিয়ে কাজ করতে পারি। এই উত্তরটি বৈধ হলে কেউ নিশ্চিত / অস্বীকার করতে পারলে আমি কৃতজ্ঞ হব। এই উত্তরটির বৈধতার জন্য আমার যুক্তিটি হ'ল এটি কখনও ইনপুট ব্যতীত n এর উপর ভিত্তি করে আকারের কোনও পরিবর্তনশীল সঞ্চয় করে না। পরিবর্তে, এমন একটি লুপ যা n বার চালিত হয় n এর উপর ভিত্তি করে পূর্ণসংখ্যার মানগুলি গণনা করে। ইনপুট নির্বিশেষে values ​​মানগুলির একই সংখ্যা রয়েছে।

নোট 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মধ্যে নির্বাচন *এবং , তার উপর নির্ভর করে

• যদি বর্তমান অবস্থানটি তির্যকের উপরে বা নীচে থাকে
• xরেস্প। 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 পর্যন্ত সমস্ত ইনপুট মানগুলির আউটপুট ।

ডিবাগিং তথ্য সহ আসল পুনরাবৃত্ত সংস্করণ

(দ্রষ্টব্য: 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 পর্যন্ত সমস্ত ফলাফলের সাথে এই পেস্টটিও দেখুন (উপরের মতো নয়, এটি আরও ভার্বোস)।

ডিবাগিং তথ্য সহ আইট্রেটিভ সংস্করণ

(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

আপনি কী ব্যাখ্যা করতে পারেন এটি কীভাবে মেমরির সীমাবদ্ধতা পূরণ করে? আমি কেবল একটি পুনরাবৃত্তি পয়েন্ট দেখতে পাচ্ছি, যা ভাল, তবে আপনি কি আরও কিছুটা বিশদে যেতে পারেন?

— durron597

@ durron597 হ্যাঁ, আমি এটি নিয়ে কাজ করছি। এটি বর্তমানে ও (এন) কারণ আমরা ক্রিয়াকলাপকে পুনরাবৃত্তভাবে সংখ্যক সময়ের সাথে আনুপাতিক nকল করি এবং কল স্ট্যাক সেই অনুযায়ী বাড়তে থাকে তবে এই ক্ষেত্রে আমরা দুটি লুপের সাহায্যে পুনরাবৃত্তি অনুকরণ করতে পারি: একটি nহ্রাস এবং dবৃদ্ধি সহ (এন <= 3 অবধি) ), এবং অন্যটি dশূন্যে হ্রাস সহ । এই মুহূর্তে আমার কাজ করার জন্য আমার খুব বেশি সময় নেই, তবে আমি সেই অনুযায়ী উত্তরটি আপডেট করার চেষ্টা করব। তবে, সর্পিলটি মুদ্রণের আরও প্রত্যক্ষ উপায় রয়েছে তবে এটি পুনরাবৃত্তভাবে সংজ্ঞায়নের চেষ্টা করে মজাদার হয়েছিল।

— coredump

Answer 6

সিজেম, 72 বাইট

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

এটি আমার সি সলিউশনটি সিজোমে মোটামুটি সরাসরি রূপান্তর। আপনি সাধারণত কোনও সিজেএম সমাধান থেকে আশা করবেন তত সংক্ষিপ্ত নয়, তবে এটি সত্যিই মেমরির সীমাবদ্ধতায় ভুগছে। শেষের দিকে স্বয়ংক্রিয়ভাবে ডাম্প হয়ে যাওয়া স্ট্যাকের উপর ফল তৈরির সাধারণ সুবিধা এবং অভিনব তালিকা / স্ট্রিং ক্রিয়াকলাপগুলি ব্যবহার করে সমস্ত উইন্ডোতে চলে যায়। এটি সমাধান একবারে একটি অক্ষর উত্পন্ন এবং আউটপুট করে। স্ট্যাকটিতে রানটাইমের সময় কয়েকটি সংখ্যক পূর্ণসংখ্যা থাকে এবং শেষে খালি থাকে।

যদিও এটি গল্ফিং ভাষা ব্যবহারের দুর্দান্ত প্রদর্শন নয় তবে এটি স্বীকৃতিটি আরও কমপ্যাক্ট হওয়ায় কেবল সি কোডের তুলনায় যথেষ্ট ছোট।

ব্যাখ্যা:

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.