Натуральні числа, включаючи 0, формально визначаються як множини наступним чином :

• Число 0 визначається як порожній набір, {}
• Для n ≥ 0 число n +1 визначається як n ∪ { n }.

Як наслідок, n = {0, 1, ..., n -1}.

Першими числами, визначеними цією процедурою, є:

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

Виклик

Дано n, виведіть його подання у вигляді набору.

Правила

Вихід може послідовно використовувати будь-який кронштейн символ , такі як {}, [], ()або <>. Довільні символи (такі як 01) не допускаються.

Замість коми, як зазначено вище, роздільником може бути будь-який розділовий знак; або це може бути відсутнім.

Пробіли (а не нові рядки) можуть бути включені довільно та непослідовно.

Наприклад, число 2 з квадратними дужками і крапкою з комою як роздільник є [[]; [[]]], або рівнозначно [ [ ]; [ [ ] ] ], або парним[ [ ] ;[ []]]

Порядок , в якому елементи множини визначається не має значення. Таким чином, ви можете використовувати будь-яке замовлення в представництві. Наприклад, це кілька дійсних результатів для 3:

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

Ви можете написати програму або функцію . Вихідним може бути рядок, або, використовуючи функцію, ви можете повернути вкладений список або масив, представлення якого рядка відповідає вищезазначеному.

Тестові справи

0  ->  {}
1  ->  {{}}
2  ->  {{},{{}}}
3  ->  {{},{{}},{{},{{}}}}
4  ->  {{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}}
5  ->  {{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}}}
6  ->  {{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}}}}
7  ->  {{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}}}}}

Желе , 3 байти

Ḷ߀

Це монадичне посилання. Спробуйте в Інтернеті!

Як це працює

Кожне натуральне число - це сукупність усіх попередніх натуральних чисел, тобто n = {0,…, n-1} . Оскільки немає натуральних чисел, що передують 0 , маємо, що 0 = {} .

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

Ḷ    Unlength; yield [0, ..., n-1].
 ߀  Recursively map this link over the range.

Python 2, 26 байт

f=lambda n:map(f,range(n))

Перевірте це на Ideone .

JavaScript (ES6), 32 байти

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

Досить просто.

Perl 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

}

Рубі, 27 21 байт

Я новачок у рубіновому гольфі, але тут нічого не йде. Дякуємо Йордану за збереження 6 байт!

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

Це рекурсивна функція f(конкретно, конкретно) і бере аргументи s. Він відображає процедурний fнад 0...s, що діапазон [0, s).

Haskell, 32 27 байт

p n='{':(p=<<[0..n-1])++"}"

Спробуйте це на Ideone.

CJam , 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. Після виписки \(своп) вона містить "[[]", "[[]]","]"
6. Після оператора ](упаковка в масив) він містить ["[[]" "[[]]" "]"], який буде відображатися як рядок "[[][[]]]".

Чеддар, 17 байт

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

Коротка рекурсія + Короткий діапазон + Коротка ітерація = Проблема, коли чеддер справляється дуже добре

Без конкуренції, 11 байт

n f->|>n=>f

=>Оператор був доданий після того, як цей виклик був випущений зробити цю відповідь , не конкуруємо.

Це може виглядати заплутано, але дозвольте спростити:

n f -> |> n => f

в основному nце вхід і fє самою функцією. |>nгенерує [0, n) та =>карти, які закінчуються f.

05AB1E , 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 байт завдяки Аднану.

Pyth, 4 байти

LyMb

Тестовий набір

L: Визначте функцію за yдопомогою вводуb

yMb: yвідображено по діапазону0, 1, ..., b-1

На вході 0 ця карта повертається []. В іншому випадку він повертається, yвідображений на всіх номерах до b.

MATL , 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

Perl, 27 байт

Включає +1 для -p

Багато різних методів, схоже, закінчуються 27 або 28 байтами. напр

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

Найкраще, що я міг знайти

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

оскільки на старих перлах ви можете пропустити пробіл до forта отримати 26 байт

Математика, 14 байт

Array[#0,#,0]&

Математика, 31 байт

Безпосередньо реалізує визначення як вкладений список. Використовує неназвану функцію, яка рекурсивно викликає себе за допомогою #0.

If[#<1,{},Join[t=#0[#-1],{t}]]&

Сітківка , 24 18 байт

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

Спробуйте в Інтернеті! (Перший рядок включає тестовий набір, відокремлений виведенням ліній.)

Пояснення

.+
$*1<>

Це перетворює вхід в одинарне і додає <>, представлення 0.

+`1<
<<$'

Тут +вказується, що цю заміну слід запускати в циклі, поки рядок не перестане змінюватися. Простіше пояснити це, пройшовши окремі кроки, якими я займався гольфу. Давайте з цією версією заміни:

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

Це відповідає останньому 1з одинарного подання решти вводу (для видалення та зменшення введення), а також до вмісту поточного набору в кінці. Потім він замінюється новим набором, що містить попередній, а також його вміст. Однак ми можемо помітити, що $1за ним слідують >в обох випадках, і тому ми можемо включити його в самому захопленні та опустити його із схеми заміщення. Це призводить до форми

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

Однак зараз ми можемо спостерігати, що (.*)після цього фіксується суфікс рядка після, 1<і ми навіть знову вставляємо цей суфікс в кінці з $1. Оскільки синтаксис підстановки дає нам спосіб посилатися на частину рядка після відповідності, $'ми можемо просто опустити обидві ці частини та закінчити версію, використану у відповіді:

1<
<<$'

Низький навантаження , 14 байт

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

Спробуйте в Інтернеті!

Повне програмне завантаження не може приймати дані за допомогою будь-якого з визначених нами методів, тому це функція, яка приймає вхід із стека як номер церкви (звичайний спосіб визначення цілих чисел у Underload) і видає вихід у стек як рядок .

Ці (…)угруповання маркерів потрібно , щоб зробити цю функцію ( для повторного використання) , а не фрагмент (використовуватися тільки один раз). Обгортка в TIO-посиланні викликає цю проблему руйнівно ^, але її можна повторно використовувати, зробивши її копію і споживаючи лише одну з копій при її виклику. Він також забезпечує введення програми (тут (:*:*), тобто 4), і друкує вихід, використовуючи S.

Пояснення

Андерлауз напрочуд підходить для цього завдання, оскільки Тюрпінг Тьюрінга має такі корисні примітиви, як "копіювати" та "оточувати дужками". (Якось "Underload", як правило, дуже багатослівна мова, б'є Mathematica, як правило, мова, яка виграє завдяки наявності величезного набору вбудованих модулів через наявність більш відповідних вбудованих програм!) Ось як працює програма:

((: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*). Це ідіоматичний спосіб написання циклу, який повторюється задану кількість разів у Underload. (Ви можете зауважити, що ~^описано вище два різні способи; це тому, що цілі числа в Underload визначаються як експоненціація функції, спеціалізована для цього цілого числа, тому для того, щоб зробити експоненцію функції, ви просто намагаєтеся виконати ціле число, як би це було функцією .)

Парі / GP , 23 байти

f(n)=[f(i)|i<-[0..n-1]]

Спробуйте в Інтернеті!

APL (NARS), 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
└∊────────────────────────────────────────────────────┘

Я не знаю, чи було б це прийнято ... Zilde є ⍬ тут він являє собою набір пустот {}, якщо я хочу надрукувати елемент Zilde або один елемент, повний Zilde, і Zilde додає все, що відбувається, нічого не друкує ... тому для дивіться Zilde потрібно визначити одну функцію, яку я називаю o ( o←⎕fmt) Я не вставляю в рахунок, оскільки елемент та його структура існують, навіть якщо sys не надрукує її ... Можливо, якщо io 0

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

може бути також 12 символів рішення ...

Брахілог , 14 байт

yk:{,[]:?:gi}a

Спробуйте в Інтернеті!

Пояснення

yk                The range [0, ..., Input - 1]
  :{        }a    Apply on each element of the range
    ,[]:?:gi      Group the empty list [] in a list Input times

GAP , 22 байти

f:=n->Set([0..n-1],f);

Наприклад:

gap> f(3);                            
[ [  ], [ [  ] ], [ [  ], [ [  ] ] ] ]

Ракетка 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))

Безголівки:

(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)))

Тестування (У ракетці {} те саме, що (), а вихід за замовчуванням - ()):

(f 4)

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

Щоб чітко побачити кожне число (від 0 до 3):

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

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

Пакет, 74 байти

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

Використовує той факт, що кожна відповідь дорівнює попередній відповіді, вставленій у себе після ведучої {. Перші кілька результатів такі:

{}

{{}}

{{{}}{}}

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

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

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