প্রাকৃতিক নির্মাণ

27

0 সহ প্রাকৃতিক সংখ্যাগুলি নিম্নলিখিতভাবে আনুষ্ঠানিকভাবে সেট হিসাবে সংজ্ঞায়িত হয় :

  • নম্বর 0 খালি সেট হিসাবে সংজ্ঞায়িত করা হয়েছে, {}
  • জন্য এন ≥ 0, সংখ্যা এন + 1 হিসাবে সংজ্ঞায়িত করা হয় এন ∪ { এন }।

ফলস্বরূপ, এন = {0, 1, ..., এন -1}}

এই পদ্ধতি দ্বারা সংজ্ঞায়িত প্রথম সংখ্যাগুলি হ'ল:

  • 0 = {}
  • 1 = {{}
  • 2 = {{}, {{}}
  • 3 = {{}, {{}}, {{}, {{}}}

চ্যালেঞ্জ

দেওয়া হয়েছে n, সেট হিসাবে তার উপস্থাপনা আউটপুট।

বিধি

আউটপুট ধারাবাহিকভাবে কোনো ব্যবহার করতে পারেন বন্ধনী যেমন চরিত্র {}, [], ()বা <>। যথেচ্ছ অক্ষর (যেমন 01) অনুমোদিত নয়।

উপরের মত একটি কমা পরিবর্তে পৃথককারী যে কোনও বিরাম চিহ্ন হতে পারে; অথবা এটি অস্তিত্বহীন হতে পারে।

স্পেসস (নিউলাইন নয়) স্বেচ্ছাসেবী এবং অসঙ্গতভাবে অন্তর্ভুক্ত করা যেতে পারে।

উদাহরণস্বরূপ, বর্গাকার বন্ধনী এবং সেমিকোলন সহ বিভাজক হিসাবে 2 নম্বর [[]; [[]]], বা সমতুল্য [ [ ]; [ [ ] ] ], বা এমনকি[ [ ] ;[ []]]

অর্ডার যা একটি সেট উপাদান কোন ব্যাপার না নির্দিষ্ট আছে। সুতরাং আপনি উপস্থাপনে যে কোনও আদেশ ব্যবহার করতে পারেন। উদাহরণস্বরূপ, এগুলির জন্য কিছু বৈধ আউটপুট 3:

{{},{{}},{{},{{}}}}
{{{}},{{},{{}}},{}}
{{{}},{{{}},{}},{}}

আপনি কোনও প্রোগ্রাম বা ফাংশন লিখতে পারেন । আউটপুট একটি স্ট্রিং হতে পারে বা, যদি কোনও ফাংশন ব্যবহার করা হয় তবে আপনি কোনও নেস্টেড তালিকা বা অ্যারে ফিরতে পারেন যার স্ট্রিং প্রতিনিধিত্ব উপরের সাথে মানায়।

পরীক্ষার মামলা

0  ->  {}
1  ->  {{}}
2  ->  {{},{{}}}
3  ->  {{},{{}},{{},{{}}}}
4  ->  {{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}}
5  ->  {{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}}}
6  ->  {{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}}}}
7  ->  {{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}}}}}
code-golf  math  number  set-theory 
— লুইস মেন্ডো
সূত্র
— লুইস মেন্ডো

উত্তর:

8

জেলি , 3 বাইট

Ḷ߀

এটি একটি monadic লিঙ্ক। এটি অনলাইন চেষ্টা করুন!

কিভাবে এটা কাজ করে

প্রতিটি প্রাকৃতিক সংখ্যা আগের সব প্রাকৃতিক সংখ্যা, অর্থাত সেট করা হয়, এন = {0, ..., N-1} । যেহেতু পূর্ববর্তী কোন প্রাকৃতিক সংখ্যা 0 , আমরা যে আছে 0 = {} ।

Ḷ߀  Monadic link. Argument: n (natural number)

Ḷ    Unlength; yield [0, ..., n-1].
 ߀  Recursively map this link over the range.
— ডেনিস
সূত্র
3
"আনলেন্থ" আমি জেলির বিপরীত ফাংশন পছন্দ করি।
— ETH প্রোডাকশনস
1
আমি যদি সঠিকভাবে বুঝতে পারি, তবে দৈর্ঘ্যটি মূলতঃ [0, n)?
— ডাউনগোট
5
পছন্দ করুন আমি নীচের দিকের বিপরীত হিসাবে বিন্দু সহ অক্ষর এবং অক্ষরগুলি রাখার চেষ্টা করি। যেহেতু ḶLকোনও অনিঃপ্রযুক্তি, স্মৃতিসৌধটি দৈর্ঘ্যের নয়। সেখানেও অসাধারণ, অপ্রচলিত, আনহালভ, আনসাইন, আনকারকোসিন ইত্যাদি রয়েছে
— ডেনিস
1
অপেক্ষা কর, আনারকসোসিন? এটা কি শুধু কোসাইন হবে না?
— ইটিএইচ প্রডাকশনগুলি
পছন্দ করুন নীচে বিন্দু সহ কোনও সি নেই।
— ডেনিস
10

জাভাস্ক্রিপ্ট (ES6), 32 বাইট

f=n=>[...Array(n).keys()].map(f)

যথেষ্ট সহজ।

— ETHproductions
সূত্র
1
@ ডাওনগোট আমি মনে করি এটি প্রথমবারের মধ্যে .map()কোনও তীর ফাংশন ছাড়াই ব্যবহার করলাম :-)
— ETH প্রোডাকশনগুলি
ভাল টেকনিক্যালি পি: F একটি তীর ফাংশন
— Downgoat
@ ইথ প্রডাকশন সত্যিই? .map(Number)এটি বেশ সাধারণ ঘটনা।
— সেবাস্তিয়ান সাইমন 0
@ শুফফক্স ভাল কথা, আমি মনে করি আমি এটি কমপক্ষে একবার করে ফেলেছি।
— ইটিএইচ প্রোডাকশনস
4
@ এক্সুফক্স যদিও .map(e=>+e)বাইট করে খাটো।
— কনর ও'ব্রায়েন
7

পার্ল 6 , 16 বাইট

{({@_}…*)[$_]}

নেস্টেড ডেটা স্ট্রাকচার ফিরিয়ে দেয়।

উদাহরণ:

say {({@_}…*)[$_]}( 4 );
# [[] [[]] [[] [[]]] [[] [[]] [[] [[]]]]]

ব্যাখ্যা:

{   # lambda with implicit parameter ｢$_｣

  (


    # produce a lazy infinite sequence of all results

    {       # lambda with implicit parameter ｢@_｣
      @_    # array containing all previously seen values in the sequence
    }

    …       # keep repeating that block until:

    *       # Whatever ( never stop )


  )[ $_ ]   # use the outer block's argument to index into the sequence

}
— ব্র্যাড গিলবার্ট বি 2 গিলস
সূত্র
এটি ... চিত্তাকর্ষক।
— কনর ও'ব্রায়েন
6

রুবি, 27 21 বাইট

আমি রুবি গল্ফিংয়ে নতুন, কিন্তু এখানে কিছুই হয় না। জর্দানকে 6 বাইট বাঁচানোর জন্য ধন্যবাদ!

f=->s{(0...s).map &f}

এটি একটি পুনরাবৃত্ত ফাংশন f(নির্দিষ্ট হওয়া একটি প্রকল্প) এবং একটি আর্গুমেন্ট নেয় s। এটি প্রোক ওভারকে মানচিত্র fকরে 0...s, যা পরিসীমা [0, s)।

— কনর ও ব্রায়ান
সূত্র
আপনি প্রতিস্থাপন করতে পারেন map{|e|f[e]}সঙ্গে map &f।
— জর্দান
@ জর্ডান বাহ, সুন্দর!
— কনর ও'ব্রায়েন
4

সিজেম , 14 বাইট

"[]"{_)@\]}ri*

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

"[]"            e# Push this string. It is the representation of 0, and also serves
                e# to initialize
    {     }ri*  e# Repeat this block as many times as the input number
     _          e# Duplicate
      )         e# Uncons: split into array without the last element, and last element
       @\       e# Rotate, swap
         ]      e# Pack stack contents into an array
                e# Implicitly display

প্রতিটি পুনরাবৃত্তিতে, ব্লকটি পূর্ববর্তীটির থেকে একটি সংখ্যার উপস্থাপনা তৈরি করে। আঁকা, দ্বিতীয় পুনরাবৃত্তির, যেখানে সংখ্যাকে প্রতিনিধিত্ব বিবেচনা করি 2যে থেকে নির্মিত হয় 1, স্ট্রিং যা "[[]]"।

  1. স্ট্যাকের মধ্যে রয়েছে "[[]]"
  2. বিবৃতি _(সদৃশ) এর পরে এতে রয়েছে "[[]]","[[]]"
  3. বিবৃতির পরে )(uncons) এটা রয়েছে "[[]]", "[[]","]"
  4. বিবৃতির পরে @(ঘোরান) এটা রয়েছে "[[]", "]","[[]]"
  5. বিবৃতির পরে \(swap 'র) এটা রয়েছে "[[]", "[[]]","]"
  6. স্টেটমেন্ট হিসাবে প্রদর্শিত হবে ](অ্যারে মধ্যে প্যাক) বিবৃতি পরে ।["[[]" "[[]]" "]"]"[[][[]]]"
— লুইস মেন্ডো
সূত্র
4

চেদার, 17 বাইট

n f->(|>n).map(f)

সংক্ষিপ্ত পুনরাবৃত্তি + সংক্ষিপ্ত পরিসর + সংক্ষিপ্ত পুনরাবৃত্তি = একটি চ্যালেঞ্জ যেখানে চেডার খুব ভাল করে

অ-প্রতিযোগী, 11 বাইট

n f->|>n=>f

=>পরে এই চ্যালেঞ্জ এই উত্তরটি অ প্রতিদ্বন্দ্বী উপার্জন মুক্তি অপারেটর যোগ করা হয়েছিল।

এটি বিভ্রান্তিকর লাগতে পারে তবে আমাকে এটি সহজ করতে দিন:

n f -> |> n => f

মূলত nইনপুট এবং fএটি নিজেই ফাংশন। |>n[0, n) এবং =>এটির উপরে মানচিত্র উত্পন্ন করে f।

— Downgoat
সূত্র
1
প্রতিদ্বন্দ্বিতাকারীটিকে খুব সুন্দর দেখাচ্ছে: ডি
— কনর ও'ব্রায়ান
4

05 এ বি 1 ই , 8 7 বাইট

)IF)©`®

ব্যাখ্যা

)         # wrap stack in a list, as stack is empty this becomes the empty list []
 IF       # input number of times do:
   )      # wrap stack in list
    ©     # store a copy of the list in the register
     `    # flatten the list
      ®   # push the copy from the register
          # implicitly print top value of stack after the last loop iteration

এটি অনলাইন চেষ্টা করুন!

আদনানকে ধন্যবাদ 1 বাইট সংরক্ষিত

— Emigna
সূত্র
2 মিনিটেরও কম এলএল
— লুইস মেন্ডো
@ লুইস মেন্ডো চ্যালেঞ্জটি পোস্ট করার সময় আমি আক্ষরিক অর্থে লগইন করেছি :)
— এমিগিনা
আমি বিশ্বাস করি আপনি শেষ বন্ধনীটি সরিয়ে ফেলতে পারেন: পি
— আদনান
@ আদনান: ওফ! আমি জানি না কীভাবে আমি এটি মিস করেছি :)
— এমিগানা
3

পাইথ, 4 বাইট

LyMb

পরীক্ষা স্যুট

L: yইনপুট সহ ফাংশনটি সংজ্ঞায়িত করুনb

yMb: yপরিসীমা উপর ম্যাপ করা0, 1, ..., b-1

ইনপুট 0 এ, এই মানচিত্রটি ফিরে আসে []। অন্যথায়, এটি yসমস্ত সংখ্যার উপরে ম্যাপযুক্ত প্রদান করে b।

— isaacg
সূত্র
3

এমএটিএল , 13 বাইট

Xhi:"tY:Xh]&D

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

Xh              % Concatenate the stack contents into cell array. Since the stack
                % is empty, this produces the empty cell array, {}
  i:"     ]     % Take input number. Repeat that many times
     t          % Duplicate the cell array that is at the top of the stack
      Y:        % Unbox it, i.e., push its contents onto the stack
        Xh      % Concatenate the stack contents into a cell array
           &D   % String representation. Implicitly display
— লুইস মেন্ডো
সূত্র
2
খুব চালাক উত্তর
— Suever
@ তবুও ধন্যবাদ! যদিও অনেক দীর্ঘ ...
— লুইস মেন্ডো
3

পার্ল, 27 বাইট

এর জন্য +1 অন্তর্ভুক্ত -p

অনেকগুলি বিভিন্ন পদ্ধতি 27 বা 28 বাইট হিসাবে শেষ হয় বলে মনে হয়। যেমন

#!/usr/bin/perl -p
$\=$_="{@F}"for@F[0..$_]}{

আমি খুঁজে পেতে পারেন সেরা

#!/usr/bin/perl -p
s/./{$_/ for($\="{}")x$_}{

যেহেতু পুরানো পার্লসের উপর আপনি স্থানটি ড্রপ করতে পারেন forএবং 26 বাইট পেতে পারেন

— টন হসপেল
সূত্র
2

গণিত, 31 বাইট

সোজাভাবে সংজ্ঞাটিকে নেস্টেড তালিকা হিসাবে কার্যকর করে। একটি নামহীন ফাংশন ব্যবহার করে যা পুনরাবৃত্তি করে নিজেকে কল করে #0।

If[#<1,{},Join[t=#0[#-1],{t}]]&
— গ্রেগ মার্টিন
সূত্র
4
Unionপরিবর্তে পরিবর্তে নামকরণ করা অপারেটর ব্যবহার করে আপনি প্রচুর সাশ্রয় করতে পারবেন Join: ±0={};±n_:={t=±(n-1)}⋃t... তবে, এই ক্ষেত্রে এটি পুনরাবৃত্তি সমাধানের জন্য আরও ছোটও হবে:Nest[{#}⋃#&,{},#]&
— মার্টিন ইন্ডার
2

রেটিনা , 24 18 বাইট

.+
$*1<>
+`1<
<<$'

এটি অনলাইন চেষ্টা করুন! (প্রথম লাইন একটি লাইনফিড-বিচ্ছিন্ন পরীক্ষা স্যুট সক্ষম করে))

ব্যাখ্যা

.+
$*1<>

এটি ইনপুটটিকে অবিচলিত করে এবং সংযোজনে রূপান্তর করে <>, এর উপস্থাপনা 0।

+`1<
<<$'

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

1<(.*)>
<<$1>$1>

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

1<(.*)
<<$1$1

যাইহোক, আমরা এখন পর্যবেক্ষণ করতে পারি যে (.*)কেবল স্ট্রিংয়ের প্রত্যয়টি ক্যাপচার করে 1<এবং আমরা এমনকি শেষে দিয়ে এই প্রত্যয়টি পুনরায় সন্নিবেশ করি $1। যেহেতু প্রতিস্থাপন সিনট্যাক্স আমাদের সাথে একটি ম্যাচের পরে একটি স্ট্রিংয়ের অংশটি উল্লেখ করার একটি উপায় দেয় $'আমরা কেবল সেই দুটি অংশই বাদ দিতে পারি এবং উত্তরে ব্যবহৃত সংস্করণটি শেষ করতে পারি:

1<
<<$'
— মার্টিন ইন্ডার
সূত্র
আপনি কি নিশ্চিত যে এটি রেটিনা এবং> <> ভাষা নয়? :
— লুইস মেন্ডো
@ লুইস মেন্ডো আমার ধারণা আমি ব্যবহার করতে পারতাম {}, তবে <>একমাত্র জুটি যা কখনও পালানোর দরকার পড়ে না, তাই আমি ভেবেছিলাম যে আমি এই সাথে যাব। ;)
— মার্টিন ইন্ডার
2

আন্ডারলোড , 14 বাইট

((:a*)~^()~^a)

এটি অনলাইন চেষ্টা করুন!

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

(…)গোষ্ঠীবদ্ধ চিহ্নিতকারী বরং একটি স্নিপেট (শুধুমাত্র ব্যবহারযোগ্য একবার) তুলনায় এই একটি ফাংশন (পুনর্ব্যবহারযোগ্য) করতে প্রয়োজন হয়। টিআইও লিঙ্কের মোড়কটি ফাংশনটিকে ধ্বংসাত্মকভাবে ব্যবহার করে প্রশ্ন করে ^, তবে এটির অনুলিপি তৈরি করার মাধ্যমে এবং এটির কল করার সময় কেবল একটি অনুলিপি ব্যবহারের মাধ্যমে এটি পুনরায় ব্যবহার করা যেতে পারে। এটি প্রোগ্রামটিতে ইনপুট সরবরাহ করে (এখানে (:*:*), অর্থাত্ 4), এবং ব্যবহার করে আউটপুট প্রিন্ট করে S।

ব্যাখ্যা

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

((:a*)~^()~^a)
(            )   Make a snippet into a function
 (   )~^         Exponentiate the following function by the top of stack:
  :                Copy the top stack element
   a               Surround the copy in parentheses
    *              Append the copy to the original, popping the copy
          ~^     Run the resulting function, with the following argument on its stack:
        ()         Empty string
            a    Surround the result in parentheses

ফাংশন এক্সপেনসিয়েশন কার্যকরভাবে ফাংশনের পদক্ষেপগুলিকে বহুবার পুনরাবৃত্তি করে, তাই, উদাহরণস্বরূপ, (:a*)³ হবে (:a*:a*:a*)। আন্ডারলোডে প্রদত্ত সংখ্যার পুনরাবৃত্তি করে এমন লুপটি লেখার মুশকিল উপায়। (আপনি লক্ষ করতে পারেন যে ~^উপরে বর্ণিত দুটি পৃথক উপায়ে বর্ণিত হয়েছে; কারণ আন্ডারলোডের পূর্ণসংখ্যাগুলি সেই পূর্ণসংখ্যার সাথে বিশেষত ফাংশন ক্ষয় হিসাবে সংজ্ঞায়িত করা হয়, সুতরাং একটি ফাংশন ক্ষতিকারক করার জন্য, আপনি কেবল একটি পূর্ণসংখ্যা কার্যকর করার চেষ্টা করেন যেমন এটি কোনও ফাংশন ছিল ।)

— ais523
সূত্র
2

এপিএল (এনএআরএস), 15 টি চর, 30 বাইট

{⍵=0:⍬⋄∇¨¯1+⍳⍵}

পরীক্ষা:

  f←{⍵=0:⍬⋄∇¨¯1+⍳⍵}
  o←⎕fmt
  o f 0
┌0─┐
│ 0│
└~─┘
  o f 1
┌1───┐
│┌0─┐│
││ 0││
│└~─┘2
└∊───┘
  o f 2
┌2──────────┐
│┌0─┐ ┌1───┐│
││ 0│ │┌0─┐││
│└~─┘ ││ 0│││
│     │└~─┘2│
│     └∊───┘3
└∊──────────┘
  o f 3
┌3────────────────────────┐
│┌0─┐ ┌1───┐ ┌2──────────┐│
││ 0│ │┌0─┐│ │┌0─┐ ┌1───┐││
│└~─┘ ││ 0││ ││ 0│ │┌0─┐│││
│     │└~─┘2 │└~─┘ ││ 0││││
│     └∊───┘ │     │└~─┘2││
│            │     └∊───┘3│
│            └∊──────────┘4
└∊────────────────────────┘
  o f 4
┌4────────────────────────────────────────────────────┐
│┌0─┐ ┌1───┐ ┌2──────────┐ ┌3────────────────────────┐│
││ 0│ │┌0─┐│ │┌0─┐ ┌1───┐│ │┌0─┐ ┌1───┐ ┌2──────────┐││
│└~─┘ ││ 0││ ││ 0│ │┌0─┐││ ││ 0│ │┌0─┐│ │┌0─┐ ┌1───┐│││
│     │└~─┘2 │└~─┘ ││ 0│││ │└~─┘ ││ 0││ ││ 0│ │┌0─┐││││
│     └∊───┘ │     │└~─┘2│ │     │└~─┘2 │└~─┘ ││ 0│││││
│            │     └∊───┘3 │     └∊───┘ │     │└~─┘2│││
│            └∊──────────┘ │            │     └∊───┘3││
│                          │            └∊──────────┘4│
│                          └∊────────────────────────┘5
└∊────────────────────────────────────────────────────┘

আমি জানি না এটি গ্রহণ করা হবে কিনা ... জিলড এখানে the এটি শূন্য সেটটিকে উপস্থাপন করে I I যদি আমি জিল্ড উপাদান বা জিলডে পূর্ণ একটি উপাদান মুদ্রণ করতে চাই এবং জিল্ড যা ঘটেছিল তা মুদ্রিত কিছুই নয় ... সুতরাং জিল্ডের জন্য একটি ফাংশন সংজ্ঞায়িত করতে হবে আমি এটিকে বলি ও ( o←⎕fmt) আমি গণনায় সন্নিবেশ করি না কারণ এসিগুলি প্রিন্ট না করেও উপাদান এবং এর কাঠামো বিদ্যমান রয়েছে ... io 0 হলে এটি সম্ভব

{⍵=0:⍬⋄∇¨⍳⍵}

12 টি অক্ষরের সমাধানও হতে পারে ...

— RosLuP
সূত্র
1

রেকেট 119 বাইট

(λ(n)(define ll(list'()))(for((i(range 1 n)))(set! ll(cons ll(for/list((j(length ll)))(list-ref ll j)))))(reverse ll))

Ungolfed:

(define f
  (λ (n)
    (define ll (list '()))
    (for ((i (range 1 n)))
      (set! ll
            (cons ll
                  (for/list ((j (length ll)))
                    (list-ref ll j)
                    ))))
    (reverse ll)))

পরীক্ষা (র‌্যাকেটে {same () এর মতো এবং ডিফল্ট আউটপুট ()):

(f 4)

'(() (()) ((()) ()) (((()) ()) (()) ()))

প্রতিটি সংখ্যা পরিষ্কারভাবে দেখতে (0 থেকে 3): 

(for((i (f 4)))  (println (reverse i)))

'()
'(())
'(() (()))
'(() (()) ((()) ()))
— rnso
সূত্র
1

ব্যাচ, 74 বাইট

@set s={}
@for /l %%i in (1,1,%1)do @call set s={%%s%%%%s:~1%%
@echo %s%

প্রতিটি উত্তর অগ্রণীর পরে নিজের মধ্যে previousোকানো পূর্ববর্তী উত্তরের সমান হয় তা ব্যবহার করে {। প্রথম কয়েকটি ফলাফল নিম্নরূপ:

{}

{{}}

{{{}}{}}

{{{{}}{}}{{}}{}}

{{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}

{{{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}
— নিল
সূত্র
আপনি কি ইনপুট এবং আউটপুট ফর্ম্যাটগুলি দেখিয়ে একটি উদাহরণ পোস্ট করতে পারেন?
— লুইস মেন্ডো
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.