Натуральные числа, включая 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$_}{

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

Mathematica, 14 байтов

Array[#0,#,0]&

Mathematica, 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)

Попробуйте онлайн!

Программы с полной загрузкой не могут принимать входные данные с помощью любого из наших определенных методов, так что это функция, которая принимает входные данные из стека в виде чисел Черча (обычный способ определения целых чисел в недогрузке) и производит вывод в стек в виде строки. ,

Эти (…)группировки маркеров требуется , чтобы сделать эту функцию ( для повторного использования) , а не фрагмент (использоваться только один раз). Оболочка в ссылке TIO деструктивно использует данную функцию ^, но ее можно использовать повторно, сделав ее копию и использовав только одну из копий при ее вызове. Он также обеспечивает ввод в программу (здесь (:*:*), то есть 4), и печатает вывод, используяS .

объяснение

Underload неожиданно подходит для этой задачи, так как ходят по тарпингу Тьюринга, имея такие полезные примитивы, как «копировать» и «заключать в скобки». (Так или иначе, 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 определены как возведение в степень функции, специализированное для этого целого числа, поэтому для возведения в степень функции вы просто пытаетесь выполнить целое число, как если бы оно было функцией .)

Par / 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))

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

Тестирование (In Racket {} аналогично () и вывод по умолчанию ()):

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

Использует тот факт, что каждый ответ равен предыдущему ответу, вставленному в себя после ведущего {. Первые несколько выходов следующие:

{}

{{}}

{{{}}{}}

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

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

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