পুনরাবৃত্তির ASCII সর্পিল

Question

এই প্রতিযোগিতা শেষ। আকর্ষণীয় নন-এসোলাং এন্ট্রিগুলির জন্য ধন্যবাদ, এবং জাকুজেকে জয়যুক্ত জাভাস্ক্রিপ্ট জমা দেওয়ার জন্য অভিনন্দন ।

এই সাইটে এএসসিআইআই আর্ট চ্যালেঞ্জগুলির দুর্দান্ত traditionতিহ্যে, এখানে আরও একটি। একটি ইনপুট দেওয়া হয়েছে, একটি সর্পিল আঁকুন।

&>----v
||>--v|
|||>v||
|||@|||
||^-<||
|^---<|
^-----<

সোজা, তাই না? হি, হি, হি ... হ্যাঁ ...

( এএসসিআইআই ড্রাগন কার্ভ পোস্ট, এবং অপ্টিমাইজারের এএসসিআইআই আর্ট অফ দ্য পোস্ট দ্বারা অনুপ্রাণিত )

ইনপুট

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

• একটি পূর্ণসংখ্যা 2 ≤ x ≤ 20যা প্রতিটি স্ক্রিনযুক্ত অক্ষর আকারে একটি "স্কোয়ার" উপস্থাপন করে "স্কোয়ার" এর ক্ষেত্রে সর্পিলটির আকার নির্দিষ্ট করে। তাত্ত্বিকভাবে এটি স্কোপটিতে প্রচুর পরিমাণে হতে পারে তবে আমরা ASCII আর্ট আঁকছি, এটির একটি নিরাপদ উপরের সীমা 20 হবে যাতে এটি স্ক্রিনে কিছুটা শালীনভাবে ফিট করে।
• d u rবা এর একটি একক চিঠি, lপ্রারম্ভিক "বর্গ" (নীচে, উপরে, ডান, বাম) থেকে প্রাথমিক আন্দোলনের ইঙ্গিত দিচ্ছে।
• একটি বিকল্প c, "ঘড়ির কাঁটার বিপরীতে" নির্দেশ করে। যদি cবাদ দেওয়া হয় তবে সর্পিলটির জন্য ঘড়ির কাঁটার ঘোরান।
• একটি চূড়ান্ত পূর্ণসংখ্যা 1 ≤ y ≤ 10যা সর্পিল অঙ্কনকে কতবার পুনরাবৃত্তি করতে হবে তা নির্দিষ্ট করে, পূর্বের সর্পিলটির সমাপ্তি "বর্গক্ষেত্র "টিকে নতুনটির প্রারম্ভিক" বর্গ "হিসাবে ব্যবহার করে। আমি 10 এর উপরের সীমাটি বাছাই করছি কারণ আমি চাই যে কোনও সময়ে অঙ্কনটি শেষ হয়।
• কয়েকটি উদাহরণ ইনপুট: 20lc5 13d2 2rc1

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

ইনপুট যা ইনপুট স্পেসিফিকেশন (উদাহরণস্বরূপ 11q#s) অনুসরণ করে না তা অপরিজ্ঞাত এবং আমি পুরোপুরি প্রত্যাশা করি যে প্রোগ্রামটি যথাযথভাবে কাটাবে। :)

আউটপুট

আউটপুট নিম্নলিখিত স্পেসিফিকেশন সহ ভাষা সমতুল্য STDOUT এর মাধ্যমে একটি ASCII মুদ্রণযোগ্য আউটপুট:

• প্রারম্ভিক "বর্গ" (প্রতিটি পুনরাবৃত্তির) অবশ্যই একটি স্বাক্ষর সহ চিহ্নিত করতে হবে @।
• চূড়ান্ত "বর্গ" অবশ্যই একটি এম্পারস্যান্ড দিয়ে চিহ্নিত করা উচিত &। একাধিক পুনরাবৃত্তির ক্ষেত্রে কেবলমাত্র চূড়ান্ত "স্কয়ার" চিহ্নিত করা উচিত &।
• সর্পিল পথের কোণগুলি ব্যবহার করে, ভ্রমণের দিকে "পয়েন্ট" করতে হবে < > v ^।
• পাইপ দ্বারা উল্লম্ব ভ্রমণ আঁকা প্রয়োজন |।
• অনুভূমিক ভ্রমণ ড্যাশ দিয়ে আঁকতে হবে -।
• "স্কয়ারগুলি" যেগুলি পরে পুনরাবৃত্তিগুলি ওভাররাইট করা হয় সেগুলি ভ্রমণের সর্বাধিক সাম্প্রতিক দিকটি প্রদর্শন করা উচিত। এর ফলে "নতুন" পুনরাবৃত্তিগুলি "পুরানো" পুনরাবৃত্তির শীর্ষে স্তরযুক্ত বলে মনে হচ্ছে। দেখুন 4rc3নীচের উদাহরণে।
• একটি চূড়ান্ত ট্রেলিং নিউলাইন ঠিক আছে, নেতৃস্থানীয় স্পেসগুলি আবশ্যক হতে পারে এবং তাই অনুমোদিত হতে পারে, তবে পিছনের স্থানগুলি অনুমোদিত নয়।
• আপনি এসসিআইআই আর্ট স্টুডউটে আঁকতে যদি পালানোর সিকোয়েন্সগুলি ব্যবহার করেন তবে আমি আপনাকে ডক করব না, তবে আমি আপনাকে নিঃশব্দে হতাশ করব। (আপনি যদি এগুলি ব্যবহার করেন তবে আপনি এখনও অনুগ্রহের যোগ্য হয়ে উঠবেন)

উদাহরণ

2d4 = 2 এর ব্যাস, নীচে, ঘড়ির কাঁটা দিয়ে, 4 টি পুনরাবৃত্তি দ্বারা শুরু হবে

&@@@@
^<<<<

এই উদাহরণে, অঙ্কনটি উপরের-ডানদিকে শুরু হয় @, নীচে নেমে যায়, একটি বামে, একটি উপরে। এই মুহুর্তে, আমরা 2dঅংশটি শেষ করেছি , এবং তাই ২ য় পুনরাবৃত্তি শুরু করব, যাতে আমাদের আরও একটি @, নীচে, একটি বাম, একটি উপরে রয়েছে; তারপরে তৃতীয় পুনরাবৃত্তি; তারপরে চতুর্থ এবং অবশেষে আমাদের &।

4rc3 = 4 এর ব্যাস, ডানদিকে যেতে, ঘড়ির কাঁটার বিপরীতে, 3 পুনরাবৃত্তি থেকে শুরু হয়

&--<
v-<|
|@^|<
>--^|
 |@^|<
 >--^|
  |@^|
  >--^

এই উদাহরণস্বরূপ, অঙ্কনটি নীচে থেকে শুরু হয় @, ডানদিকে যায়, একটি উপরে যায়, চারপাশে সর্পিল হয়, যতক্ষণ না এটি মাঝখানে পৌঁছায় @এবং 4rcঅংশটি শেষ না করে । এরপরে অনুরোধ করা সম্পূর্ণ 3 পুনরাবৃত্তি পেতে এটি আরও দু'বার পুনরাবৃত্তি করে। মনে রাখবেন যে 4rc1এই উদাহরণের কেবল উপরের-বাম 4x4 ব্লক হবে।

7u1 = এর ব্যাস 7, ঘড়ির কাঁটার দিকে, 1 পুনরাবৃত্তি দিয়ে শুরু হবে (নোটটি ইন্ট্রোর মতো একই)

&>----v
||>--v|
|||>v||
|||@|||
||^-<||
|^---<|
^-----<

বিজয়ীকরণ এবং বিধিনিষেধগুলি

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

Comments

নির্দিষ্টকরণগুলি বেশ আলাদা, তবে কেবল রেফারেন্সের জন্য, এখানে পূর্বের সর্পিল অঙ্কন চ্যালেঞ্জ রয়েছে: কোডগল্ফ.স্ট্যাকেক্সেক্সঞ্জ / প্রশ্নগুলি / ৫৪৪৯৪/২ ।

— রেটো কোরাডি

দুর্দান্ত চ্যালেঞ্জ। "ক্লোজড কোর্সে প্রফেশনাল ড্রাইভার"

— ৩৩

এটি একটি> <> উত্তর চাইবে।

— দি_বাসেট_হাউন্ড

"কমন, ছেলেরা ... আপনি কি কমন লিস্পকে জিততে দিচ্ছেন? ;-)" এটি আমার দেখা অনুগ্রহের পক্ষে সবচেয়ে হাসিখুশি কারণ। ধন্যবাদ

— coredump

আমি এখানে বসে আড্ডা দিচ্ছি যে কমন লিস্প এবং লুয়া হ'ল দুটি ভাষা যা কোনও কোড-গল্ফ প্রশ্নের শীর্ষ স্থানের জন্য লড়াই করে। :)

— অ্যাডমবর্কবার্ক

Answer 1

জাভাস্ক্রীপ্ট, 578, 575, 553, 478, 377 বাইট

মারধর করা লুয়ার পরে আমি আরও কিছু সংক্ষিপ্ত ভাষাতে চলে এসে জাভাস্ক্রিপ্টে প্রতিযোগিতা সরিয়ে নিয়েছি:

s=function(w,d,c,r){d="dlur".indexOf(d)
j=i=G=H=I=J=w*r;o=[];for(x=0;x<J*2;x++){o[x]=[]
for(y=0;y<J*2;)o[x][y++]=' '}for(;r--;){a=d;m=l=z=1;o[i][j]="@"
for(k=w*w-1;k--;){G=G<i?G:i;H=H>i?H:i;I=I<j?I:j;J=J>j?J:j
o[i+=(1-a)%2][j+=a?a-2:0]=l++==m?(a+=c=="c"?3:1,m+=z=!z,l=1,"v<^>"[a%=4]):k?"|-"[a%2]:"&"}}for(i=G;i<=H;)console.log(o[i++].slice(I,J+1).join("").replace(/\s+$/g,''))}

অ্যালগরিদম একই, তবে আরও সংক্ষিপ্ত ভাষায় রচিত তাই আমি খারাপ লিপ্পকে পরাজিত করতে সক্ষম হয়েছি :)

সম্পাদনা করুন: আবার লিস্পের অধীনে পৌঁছানোর জন্য এবং পূর্ববর্তী শ্বেত স্পেসগুলি অপসারণের জন্য কিছু কাঠামোগত পরিবর্তন প্রয়োজন। তবে আমরা আবার এখানে আছি।

সম্পাদনা 2: কিছু বিমূর্ততা 500 এর নিচে পাওয়ার জন্য অ্যাকাউন্টে নেওয়া হয়েছে Hope আশা করি এটি যথেষ্ট হবে :)

সম্পাদনা 3: ধন্যবাদ @ টিমউই, কোডটি আরও একটি 100 চর স্লিমার। আমি এখনও ব্যাখ্যা আপডেট হয়নি।

পরীক্ষা ( অনলাইন সংস্করণ , ক্রোমে পরীক্ষিত):

----| 2d4 |---
s.js:9 &@@@@
s.js:9 ^<<<<
ss.html:7 ----| 4rc3 |---
s.js:9 &--<
s.js:9 v-<|
s.js:9 |@^|<
s.js:9 >--^|
s.js:9  |@^|<
s.js:9  >--^|
s.js:9   |@^|
s.js:9   >--^
ss.html:9 ----| 7u1 |---
s.js:9 &>----v
s.js:9 ||>--v|
s.js:9 |||>v||
s.js:9 |||@|||
s.js:9 ||^-<||
s.js:9 |^---<|
s.js:9 ^-----<
ss.html:11 ----| 8r3 |---
s.js:9       >------v
s.js:9       |>----v|
s.js:9       ||>--v||
s.js:9       |||@v|||
s.js:9    >------v|||
s.js:9    |>----v|<||
s.js:9    ||>--v||-<|
s.js:9    |||@v|||--<
s.js:9 >------v|||
s.js:9 |>----v|<||
s.js:9 ||>--v||-<|
s.js:9 |||@v|||--<
s.js:9 ||^-<|||
s.js:9 |^---<||
s.js:9 ^-----<|
s.js:9 &------<
ss.html:13 ----| 8rc3 |---
s.js:9 &------<
s.js:9 v-----<|
s.js:9 |v---<||
s.js:9 ||v-<|||
s.js:9 |||@^|||--<
s.js:9 ||>--^||-<|
s.js:9 |>----^|<||
s.js:9 >------^|||
s.js:9    |||@^|||--<
s.js:9    ||>--^||-<|
s.js:9    |>----^|<||
s.js:9    >------^|||
s.js:9       |||@^|||
s.js:9       ||>--^||
s.js:9       |>----^|
s.js:9       >------^

এবং ন্যায়সঙ্গত হওয়ার জন্য, এখানে ন্যায্য ব্যাখ্যা রয়েছে:

s = function(w, d, c, r) {
    // width, direction, "c" as counter-clockwise and number of repetition
    // transfer direction to internal numerical representation
    d=d=="d"?0:d=="u"?2:d=="l"?1:3;
    // output strings
    x="v<^>"
    y="|-"
    // this is size of our canvas. Could be smaller, but this is shorter
    M = w * r * 2;
    // fill canvas with spaces to have something to build upon
    o = [];
    for (i = 0; i < M; i++) {
        o[i] = [];
        for (j = 0; j < M; j++)
            o[i][j] = ' '
    }
    // i,j is starting position
    // G,H,I,J are current boundaries (maximum and minimum values of i and j during the time)
    j = i = G = H = I = J = M / 2
    for (q = 0; q < r; q++) { // number of repeats
        a = d; // reset original direction
        // m is the expected length of side
        // l counts the of current side length
        m = l = 1;
        z = 0; // counts occurrences of the length
        o[i][j] = "@" // write initial character
        for (k = w * w; k > 1; k--) { // cycle over the whole spiral
            // update boundaries
            G = G < i ? G : i;
            H = H > i ? H : i;
            I = I < j ? I : j;
            J = J > j ? J : j;
            // move to the next position according to direction
            i+=a<3?1-a:0;
            j+=a>0?a-2:0
            if (k == 2) // we reached the end
                o[i][j] = "&"
            else if (l == m) {
                // we reached the corner so we need to count next direction
                a=(c=="c"?a+3:a+1)%4;
                // and write according sign
                o[i][j]=x[a]
                // first occurrence of this length
                if (z == 0)
                    z = 1; // wait for finish of the other
                else {
                    m++; // increase length of side
                    z = 0 // wait again for the first one
                }
                l = 1 // start the side counter over
            } else {
                l++ // another part of this side
                // according side character
                o[i][j] = y[a%2]
            }
        }
    }
    // blow it all out
    for (i = G; i <= H; i++)
        console.log(o[i].slice(I, J + 1).join("").replace(/\s+$/g, ''))
}

Comments

খুব সুন্দর. নিয়ম অনুসারে এবং আপনার উদাহরণ অনুসরণ করে, আমি &optional10 বাইট সংরক্ষণ করার জন্য কীওয়ার্ডটি (এবং একটি স্থান) সরিয়ে ফেলার সিদ্ধান্ত নিয়েছি , যা 576 দেয় ... দুষ্ট হাসি (ভাল, আপনি বলেছিলেন আপনি আরও কিছুটা গল্ফ করতে পারেন, তাই এটি) মারতে অসুবিধা হওয়া উচিত নয়; যতক্ষণ না কেউ পাইথে অবশ্যই 60-বাইট উত্তর না লিখে)।

— coredump

@ কর্ড্প্প চ্যালেঞ্জ গ্রহণ করা হয়েছে :) এটি আমার প্রত্যাশার চেয়ে বেশি কঠিন, তবে এখনও সম্ভব :) আমি বিশ্বাস করি আপনি এটি অজগরতে করতে পারবেন, তবে কেউ কখনও এটি বুঝতে পারবেন না তাই আমি বিশ্বাস করি যে এই জাতীয় ভাষার সম্ভাবনার উপর জটিলতা রয়েছে।

— জাকুজে

আপনি বরাদ্দকরণ চেইন তাহলে i=M/2;j=i;G=i;H=i;I=i;J=i;মধ্যে i=j=G=H=I=J=M/2;এবং m=1;l=1;মধ্যে m=l=1;আপনি 12 বাইট সংরক্ষণ করতে পারবেন

— SLuck49

এই সমাধানটি বেশ চালাক। তবে, আমি আরও বেশ কয়েকটি জায়গা পেয়েছি যা গল্ফ করা যেতে পারে: ৩ :7 বাইট

— টিমভি

@ জাকুজে আমি বিশ্বাস করি যে আপনি ৩ Tim7 বাইট সংস্করণ গ্রহণ করবেন এবং এটি ব্যবহারের জন্য আপনার উত্তরটি সম্পাদনা করাই তিম্বির উদ্দেশ্য। ;) (অন্যথায় তিনি সবে একটি পৃথক উত্তর পোস্ট করতেন))

— মার্টিন ইন্ডার

Answer 2

সাধারণ লিপ, 649 617 605 586 576 565 554 527 518

(lambda(r v z c &aux(m 0)s(c(if c 1 -1))o p(x 0)i(y 0)j u)(#8=dotimes(_ z)(#7=setf p(aref"ruld"v)i(1-(abs(- p 2)))j(- 1(abs(1- p)))s'@)(#8#($(1- r))#5=(#7#m(min m x)o(cons`(,x,y,s)o)s(aref"-|-|"p)x(+ x i)y(+ y j))#2=(#7#s(*(- c)j)j(* i c)i s p(mod(+ p c)4)s(aref">^<v"p)u(#8#(_(1+ $))#5#))#2#))(#7#s'& u #5#o(#4=stable-sort(#4#o'< :key'car)'> :key'cadr)y(cadar o)x m)(dolist(k o)(do()((>=(cadr k)y))(#7#y(1- y)x m)(terpri))(do()((<=(car k)x))#9=(incf x)(princ" "))(and(=(cadr k)y)(=(car k)x)#9#(princ(caddr k)))))

সমস্ত পরীক্ষা এখনও পাস। মন্তব্যগুলি হিসাবে পরিবর্তনগুলি প্রতিবিম্বিত করতে অদলিত ফাংশনটিও আপডেট করা হয়েছিল। remove-duplicatesকোডটি সংক্ষিপ্ত করার জন্য আমি অবশেষে মুক্তি পেয়েছি , তবে এখন আরও বাইট কোথায় পাব জানি না। ভালই হয়েছে জাকুজে।

উদাহরণ

(funcall *fun* 8 #\r 3 nil)

      >------v
      |>----v|
      ||>--v||
      |||@v|||
   >------v|||
   |>----v|<||
   ||>--v||-<|
   |||@v|||--<
>------v|||
|>----v|<||
||>--v||-<|
|||@v|||--<
||^-<|||
|^---<||
^-----<|
&------<

(funcall *fun* 8 #\r 3 t) ;; counter-clockwise

&------<
v-----<|
|v---<||
||v-<|||
|||@^|||--<
||>--^||-<|
|>----^|<||
>------^|||
   |||@^|||--<
   ||>--^||-<|
   |>----^|<||
   >------^|||
      |||@^|||
      ||>--^||
      |>----^|
      >------^

(funcall *fun* 7 #\u 1 nil)

&>----v
||>--v|
|||>v||
|||@|||
||^-<||
|^---<|
^-----<

(funcall *fun* 2 #\d 4 nil)

&@@@@
^<<<<

এছাড়াও দেখুন 20lc10(পেস্টবিন)

Ungolfed

এখানে কোনও পুনরাবৃত্তি জড়িত নেই, লুপগুলির সাথে কেবল একটি প্রাথমিক টার্টল গ্রাফিক্স পদ্ধতির:

1. (x y char)স্ট্যাকের মধ্যে ট্রিপল সংরক্ষণ করে স্মৃতিতে সর্পিলগুলি আঁকুন ।
2. স্থিতিশীল সাজান উপাদান yএবং অনুযায়ীx
3. সদৃশগুলি (পূর্ববর্তী ট্রেসগুলি) এড়িয়ে গিয়ে তালিকার উপরে আইট্রেট করুন এবং উপরের বাম থেকে নীচে-ডানদিকে মুদ্রণ করুন।

(lambda
    (r v z c
     &aux
       (m 0)       ; minimal x
       s           ; symbol to print (a character)
       (c          ; 1 if clockwise, -1 otherwise
        (if c
            1
            -1))
       o           ; stack of (x y char) traces
       p           ; position of s in ">^<v"
       i           ; move direction of x
       j           ; move direction of y
       (x 0)       ; position in x
       (y 0)       ; position in y
       u           ; auxiliary variable
       )
  ;; repeat for each recursive step
  (dotimes (_ z)
    ;; initialize spiral parameters
    (setf s '@            ; start spiral with @
          p (position v"ruld") ; initialize p according to input V

          ;; Set initial direction in I and J.
          i (1-(abs(- p 2))) ; i(0..3) = ( 1, 0, -1, 0 )
          j (- 1(abs(1- p))) ; j(0..3) = ( 0, 1, 0, -1 )

    ;; Iterate with increasing diameter $. For each iteration, draw a
    ;; "L"-shape that extends previous shape. Here is roughly what
    ;; happens at each step:
    ;;
    ;;   3334
    ;;   3124
    ;;   3224
    ;;   4444
    ;;
    (dotimes($(1- r))

      ;;
      ;; Assign the form to the reader variable #1# in order to
      ;; copy-paste later. This is like declaring a local function,
      ;; but shorter: push trace into list O and move forward.
      ;;
      #1=(setf m (min m x)
               o (cons `(,x ,y ,s) o)
               s (aref "-|-|" p)
               x (+ x i)
               y (+ y j))

      ;;
      ;; Helper function #2#: rotate and draw a line of length $.
      ;;

      #2=(setf u (* (- c) j) ; rotation as a vectorial                   
               j (* i c)     ; product of (i j 0) with (0 0 c).
               u i           ; At first I used PSETF, but now I reuse
                             ; the existing SETF with an auxiliary 
                             ; variable U to shorten the code and get
                             ; rid of PROGN. That's also why I affect
                             ; the result of DOTIMES to U (no need
                             ; for two forms and a PROGN, just SETF).

               p (mod(+ p c)4)   ; ">^<v" is sorted counter-clockwise, which 
               s (aref ">^<v" p) ; means that adding P and C (modulo 4) gives 
                                 ; the next symbol after rotation.

               ;; trace a line by repeatedly invoking code snippet #1#
               u (dotimes(_(1+ $)) #1#))
      ;; 
      ;; Rotate and draw a second line, hence drawing a "L"-shape.
      ;;
      #2#))

  ;; Finally, draw the final symbol &
  (setf s '&)
  #1#

  (setf o

        ;; From inside-out:
        ;;
        ;; - stable sort O according to X
        ;;   (from lowest (left) to highest (right))
        ;;
        ;; - stable sort the result according to Y
        ;;   (from highest (top) to lowest (bottom))
        ;;
        (stable-sort (stable-sort o '< :key 'car) '> :key 'cadr)

        ;; initialize Y with the first Y in O, which is also the
        ;; minimum of all Y.
        y (cadar o)

        ;; initialize X with the minimum of all X
        x m) 

  ;; For each trace in O
  (dolist (k o)

    ;; Add as many lines as needed to advance Y to current trace's Y.
    (do ()
      ((<= y (cadr k)))
      (setf y (1- y)
            x m)
      (terpri))

    ;; Add as many spaces as needed to advance X to current trace's X.
    (do () ((>= x (car k))) (incf x) (princ " "))

    ;; Then, print current trace's character and increment X.
    ;; This happens only when we have a "new" trace, not another
    ;; trace at the same point (which was being overwritten).
    (and(=(car k)x)(=(cadr k)y)(incf x)(princ(caddr k)))

Answer 3

লুয়া 5.2, 740 বাইট

s=io.read W=io.write Z=math.max A=math.min
D="d"U="u"L="l"R="r"function n()G=A(G,i)H=Z(H,i)I=A(I,j)J=Z(J,j)i=(a==D and i+1 or a==U and i-1 or i)j=(a==R and j+1 or a==L and j-1 or j)end
w=s"*n"d=s(1)c=s(1)r=(c=="c")and s"*n"or c
c=c=="c"M=w*(r+1)o={}for i=1,M do o[i]={}for j=1,M do o[i][j]=" "end end
i=M/2 j=i G=i H=i I=i J=i
for q=1,r do a=d m=1 l=1 z=0
o[i][j]="@"for k=3,w^2 do
n()if l==m then
a=c and(a==D and R or a==U and L or a==L and D or a==R and U)or(a==D and L or a==U and R or a==L and U or a==R and D)o[i][j]=(a==D and"v"or a==U and"^"or a==L and"<"or a==R and">")
if z==0 then z=1 else m=m+1;z=0 end
l=1
else
l=l+1
o[i][j]=(a==D or a==U)and"|"or"-"end end
n()o[i][j]="&"end
for i=G,H do for j=I,J do
W(o[i][j])end W("\n")end

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

পরীক্ষার ফলাফল:

jakuje@E6430:/tmp$ echo "2d4" | lua s.lua 
&@@@@
^<<<<
jakuje@E6430:/tmp$ echo "4rc3" | lua s.lua 
&--<  
v-<|  
|@^|< 
>--^| 
 |@^|<
 >--^|
  |@^|
  >--^
jakuje@E6430:/tmp$ echo "7u1" | lua s.lua 
&>----v
||>--v|
|||>v||
|||@|||
||^-<||
|^---<|
^-----<

Answer 4

পিএইচপি, 524 বাইট

আমি এই পার্টিতে দেরিতে পৌঁছেছি। আমার পিএইচপি সমাধানটি সবচেয়ে ছোট নয়, সবচেয়ে স্মার্টও। এটা ঠিক কাজ করে।

$a=$argv;
$b=[['|','^',0,-1],['-','>',1,0],['|',v,0,1],['-','<',-1,$x=$y=$o=$p=$q=$r=0]];
for($t=$a[4];$t;$t--){$d=strpos(urdl,$a[2]);$c=$b[$d];$m[$y][$x]='@';
for($s=0;++$s<$a[1];){for($k=3;--$k;){for($i=$s;--$i;)
$m[$y+=$c[3]][$x+=$c[2]]=$c[0];$x+=$c[2];$y+=$c[3];$c=$b[$d=($d+($a[3]==c?3:1))%4];
$m[$y][$x]=$c[1];}$o=min($x,$o);$p=max($p,$x);$q=min($y,$q);$r=max($r,$y);}
for($i=$s;--$i;)$m[$y+=$c[3]][$x+=$c[2]]=$c[0];$m[$y][$x]='&';}
for($y=$q;$y<=$r;$y++){$l='';for($x=$o;$x<=$p;$x++)$l.=$m[$y][$x]?:' ';
echo rtrim($l)."\n";}

কীভাবে এটি চালাবেন:

$ php -d error_reporting=0 recursive-ascii-spirals.php 4 r c 3
&--<
v-<|
|@^|<
>--^|
 |@^|<
 >--^|
  |@^|
  >--^
$ php -d error_reporting=0 recursive-ascii-spirals.php 7 u '' 1
&>----v
||>--v|
|||>v||
|||@|||
||^-<||
|^---<|
^-----<

পরীক্ষা, ব্যাখ্যা এবং অন্যান্য গুডিসহ বিশদ সংস্করণটি গিথুবে পাওয়া যাবে ।