Ця конструкція є способом представлення природних чисел.

У цьому поданні 0 визначається як порожній набір, а для всіх інших чисел n - об'єднання {0} і {n-1}.

Наприклад, для побудови 3 ми можемо слідувати алгоритму:

3 =
{ø, 2} =
{ø, {ø, 1}} =
{ø, {ø, {ø}}}

Завдання

Як ви, напевно, здогадалися, ваше завдання - прийняти натуральне число (включаючи нуль) і вивести його конструкцію.

Ви можете виводити як рядок, так і як заданий об'єкт, якщо ваша обрана мова підтримує такі об'єкти.

Якщо ви вирішили вивести як рядок, ви повинні представити набір з фігурними дужками ( {}). Ви можете необов'язково представляти порожній набір як ø(інакше це повинен бути набір без записів {}). Ви також можете додати коси та пробіли між записами та після них у наборі.

Порядок не важливий, однак у наборах, що виводяться, можливо, у вас немає повторених елементів (наприклад {ø,ø})

Це код-гольф, тому мета - мати найменше байтів

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

Ось кілька тестових випадків з деякими прикладами виходів.

0 -> {}
1 -> {{}}
2 -> {{}{{}}}
3 -> {{}{{}{{}}}}
4 -> {{}{{}{{}{{}}}}}

Пітон , 28 байт

lambda x:"{{}"*x+x*"}"or"{}"

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

Це досить сміливе рішення проблеми. Для чисел, більших за нуль, ви можете отримати представлення за допомогою рядкової формули "{{}"*x+"}"*x. Однак це не працює для нуля, де це порожня рядок. Цей факт ми можемо використати для короткого замикання та orповернення порожнього набору.

Я хотів використати вбудований набір python для вирішення цієї проблеми, але, на жаль:

TypeError: unhashable type: 'set'

Ви не можете ставити набори всередині множин у python.

Хаскелл , 37 байт

f 0="{}"
f n=([1..n]>>)=<<["{{}","}"]

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

До 10 хвилин тому така відповідь не мала б для мене сенсу. Усі кредити йдуть на цю відповідь .

В основному, ми використовуємо >>як concat $ replicate(але передаючи йому список з n елементів, а не просто n), і =<<як concatMap, реплікуючи потім n разів кожний з рядків у списку, і об'єднуючи результат в один рядок.

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

JavaScript, 28 байт

f=n=>n?--n?[[],f(n)]:[[]]:[]

Представляє набори за допомогою масивів. 38-байт нерекурсивного рішення:

n=>'{{}'.repeat(n)+'}'.repeat(n)||'{}'

Повертає приклад вихідних рядків.

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

У цього байта є два рішення:

Nest[{{}}~Union~{#}&,{},#]&
Union//@Nest[{{},#}&,{},#]&

Perl 6 , 37 байт

{('{}','{{}}',{q:s'{{}$_}'}...*)[$_]}

Спробуй це

Розширено:

{   # bare block lambda with implicit parameter ｢$_｣

  (
    # generate a sequence

    '{}',   # seed it with the first two values
    '{{}}',

    {   # bare block lambda with implicit parameter ｢$_｣

      q         # quote
      :scalar   # allow scalar values

      '{{}$_}'  # embed the previous value ｢$_｣ in a new string

    }

    ...         # keep using that code block to generate values

    *           # never stop

  )[ $_ ] # get the value at the given position in the sequence
}

05AB1E , 6 5 байт

Код

ƒ)¯sÙ

Використовує кодування CP-1252 . Спробуйте в Інтернеті! або Перевірте всі тестові випадки! .

Пояснення

ƒ       # For N in range(0, input + 1)..
 )      #   Wrap the entire stack into an array
  ¯     #   Push []
   s    #   Swap the two top elements
    Ù   #   Uniquify the array

Сітківка , 22 байти

.+
$*
\`.
{{}
{

^$
{}

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

Пояснення

.+
$*

Перетворити вхід в одинаковий.

\`.
{{}

Замініть кожну одинарну цифру на {{}та надрукуйте результат без зворотного подання рядка ( \).

{

Вийміть отвір {s, щоб залишилися }саме ті, які нам ще потрібно роздрукувати, щоб закрити всі набори. Однак вищевказана процедура не вдається 0, коли ми нічого не надрукували. Так...

^$
{}

Якщо рядок порожній, замініть його порожнім набором.

Мозок-Флак , 135 байт

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

(({}())<{({}[()]<((((((()()()()()){}){}){}())()){}{})>)}{}({}[()()])>)(({})<{({}[()]<(((({}()())[()()])))>)}{}>[()]){(<{}{}{}>)}{}{}{}

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

(({}())<                 # Replace Input with input + 1 and save for later
  {({}[()]<              # For input .. 0
    (...)                # Push '}'
  >)}{}                  # End for and pop counter
  ({}[()()])             # change the top '}' to '{'. This helps the next stage
                         # and removes the extra '}' that we got from incrementing input
>)                       # Put the input back on

(({})<                   # Save input
  {({}[()]<              # For input .. 0
    (((({}()())[()()]))) # Replace the top '{' with "{{{}"
  >)}{}                  # end for and pop the counter
>[()])                   # Put down input - 1
{(<{}{}{}>)}             # If not 0, remove the extra "{{}"
{}{}{}                   # remove some more extras

Рода , 37 байт

f n{[[[],f(n-1)]]if[n>1]else[[[]]*n]}

CJam , 11 байт

Lri{]La|}*p

Друкує об'єкт схожий на набір, що складається із списків списків. CJam друкує порожні списки як порожні рядки, оскільки списки та рядки майже взаємозамінні.

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

Пояснення

L            Push an empty array 
 ri          Read an integer from input
   {    }*   Run this block that many times:
    ]          Wrap the entire stack in an array
     La        Wrap an empty list in an array, i.e. [[]]
       |       Set union of the two arrays
          p  Print the result

Стара відповідь, 21 18 байт

Це було раніше, ніж було підтверджено, що було нормально надрукувати вкладену структуру списку. Використовується алгоритм повторення рядків.

Збережено 3 байти завдяки Мартіну Ендеру!

ri{{}}`3/f*~_{{}}|

Пояснення

ri                  Read an integer from input
  {{}}`             Push the string "{{}}"
       3/           Split it into length-3 subtrings, gives ["{{}" "}"]
         f*         Repeat each element of that array a number of times equal to the input
           ~_       Dump the array on the stack, duplicate the second element
             {{}}|  Pop the top element, if it's false, push an empty block, which gets 
                      printed as "{}". An input of 0 gives two empty strings on the 
                      repetition step. Since empty strings are falsy, we can correct the 
                      special case of 0 with this step.

Желе , 6 байт

⁸,⁸Q$¡

Це niladic-посилання, яке зчитує ціле число з STDIN і повертає розірваний масив.

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

Як це працює

⁸,⁸Q$¡  Niladic link.

⁸       Set the return value to [].
    $   Combine the three links to the left into a monadic chain.
 ,⁸     Pair the previous return value with the empty array.
   Q    Unique; deduplicate the result.
     ¡  Read an integer n from STDIN and call the chain to the left n times.

Python 3 , 32 байти

f=lambda n:[[],n and f(n-1)][:n]

Не найкоротший шлях, але мені довелося це робити з рекурсією.

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

Кардинал , 51 50 байт

%:#>"{"#? v
x  ^?-"}{"<
v <8/ ?<
>  8\
v"}"<
>?-?^

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

Пояснення

%:#
x

Отримуйте введення та надсилайте вниз та вліво від #

   >"{" ? v
   ^?-"}{"<

Друкуйте "{" один раз, тоді надрукуйте "{} {" n-1 раз, якщо n> 1, тоді надрукуйте "{}", якщо n> 0

       #

v <8/ ?<
>  8\

Утримуйте вхідне значення, поки не завершиться перший цикл

v"}"<
>?-?^

Надрукуйте "}" один раз, потім повторіть n-1 рази, якщо n> 1

AHK, 55 байт

IfEqual,1,0
s={{}{}}
Loop,%1%
s={{ 2}{}}%s%{}}
Send,%s%

Це не найкоротша відповідь, але мені це сподобалось, оскільки ідіосинкразії AutoHotkey роблять цей метод рекурсії виглядати надзвичайно неправильним. Ifі Loopзаяви припускають, що наступний рядок є єдиним, що включається, якщо дужки не використовуються. Фігурні дужки - це символи втечі, тому вам доведеться уникати їх за допомогою інших фігурних дужок, щоб використовувати їх як текст. Також змінна 1є першим переданим аргументом. Коли я читаю код, не знаючи цих примх, логіка виглядає приблизно так:

• Якщо 1 = 0, то встановіть sрівну неправильну відповідь
• Петля і додайте купу дужок на початок і кілька в кінець кожного разу
• Повернення, відправивши отриманий рядок у поточне вікно

Без усіх символів втечі дужки, це виглядатиме так:

IfEqual,1,0
   s={}
Loop,%1%
   s={{}%s%}
Send,%s%

JavaScript 50 байт

g=n=>n==0?"":"{{}"+g(n-1)+"}"
z=m=>m==0?"{}":g(m)

тинілісп , 52 байти

(d f(q((n)(i n(i(e n 1)(c()())(c()(c(f(s n 1))())))(

Спробуйте в Інтернеті!(тестовий джгут).

Пояснення

Зауважте, (cons x (cons y nil))саме так ви створюєте список, що містить xі yв Lisp.

(d f           Define f to be
 (q(           a quoted list of two items (which acts as a function):
  (n)           Arglist is a single argument n
  (i n          Function body: if n is truthy (i.e. nonzero)
   (i(e n 1)     then if n equals 1
    (c()())       then cons nil to nil, resulting in (())
    (c            else (if n > 1) cons
     ()            nil to
     (c            cons
      (f(s n 1))    (recursive call with n-1) to
      ())))         nil
   ()))))        else (if n is 0) nil

C (gcc) , 52 байти

n(i){putchar(123);i>1&&n(0);i&&n(i-1);putchar(125);}

Користуючись деякою оцінкою короткого замикання та рекурсією.

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

Чистий Баш , 49 48 41 байт

for((;k++<$1;)){ s={{}$s};};echo ${s-{\}}

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

постійного струму , 46 байт

[[{}]]sx256?^dd3^8d^1-/8092541**r255/BF*+d0=xP

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

Вхід на stdin, вихід на stdout.

Це працює, обчислюючи формулу для потрібного виводу у вигляді базового числа 256. Команда P у dc використовується для друку номера базового 256 у вигляді рядка.

Подальше пояснення:

Нехай n - вхід n. Програма dc обчислює суму

A = підлога (256 ^ n / 255) * 125 (BF трактується dc як 11 * 10 + 15 = 125)

і

B = підлога ((256 ^ n) ^ 3 / (8 ^ 8-1)) * 8092541 * (256 ^ n).

Для:

Зауважте, що 1 + 256 + 256 ^ 2 + ... + 256 ^ (n-1) дорівнює (256 ^ n-1) / 255 за формулою геометричної прогресії, і це дорівнює підлозі (256 ^ n / 255 ). Отже, це число, що складається з n 1 в базовому 256.

Коли ви помножите його на 125, щоб отримати A, результат - це число, що складається з n 125's в базі 256 (звичайно, 125 - це однозначна цифра в базі 256). Напевно, краще записати цифри в базу 256 як шістнадцяткові числа; 125 - це шістнадцятковий 7D, тому A - це базове число-256, що складається з n 7D в ряд.

B подібний:

Цього разу зауважте, що 1 + 16777216 + 16777216 ^ 2 + ... + 16777216 ^ (n-1) дорівнює (16777216 ^ n - 1) / 16777215, і це дорівнює підлозі (16777216 ^ n / 16777215).

Тепер 256 ^ 3 = 16777216 і 8 ^ 8-1 = 16777215, тому це те, що ми обчислюємо як підлогу ((256 ^ n) ^ 3 / (8 ^ 8-1)).

З подання геометричних рядів, це число в базовій частині 256 становить 100100100 ... 1001, з n цифр - 1, а решта цифр - 0.

Це множимо на 8092541, що в шістнадцятці - 7B7B7D. У базі 256 - це трицифрове число, що складається з цифр 7В, 7В та 7Д (записування цих цифр у шістнадцятковій кількості для зручності).

Звідси випливає, що добуток, записаний у базі 256, є 3-розрядним числом, що складається з 3-х цифр 7B 7B 7D, повторених n разів.

Це множиться на 256 ^ n, в результаті чого 4-розрядне базове число-256, що складається з 3-х цифр 7B 7B 7D, повторених n разів, а потім n 0-х. Це Б.

Додавання A + B тепер дає 4n-розрядне базове-256 число, що складається з 3-х цифр 7B 7B 7D, повторених n разів, а потім n 7D. Так як 7В і 7D є ASCII коди для {і }, відповідно, це рядок , що складається з п копій з {{}подальшим п примірників} , що є саме те , що ми хочемо , щоб при п> 0. Команда P в постійному друкує число базових 256 як струна, як саме нам потрібно.

На жаль, n = 0 слід розглядати як особливий випадок. Розрахунки, що наведені вище, дають результат 0 при n = 0; у такому випадку я щойно зашифрував друк рядка {}.

Java 7, 61 байт

String p(int p){return p<1?"{}":p<2?"{{}}":"{{}"+p(p-1)+"}";}

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

Пакетна, 88 байт

@set s={}
@if %1 gtr 0 set s=&for /l %%i in (1,1,%1)do @call set s={{}%%s%%}
@echo %s%

Brainf *** , 99 байт

>+>+>+>+<[>[-<+++++>]<-<]>--[->+>+<<]
>[-<+>]>++<,[[->>+>+<<<]>>[-<<<..>>.>]>[-<<.>>]+[]]<.>>.

(новий рядок для естетики) Оскільки це brainf ***, він приймає введення як ascii char коди (вхід "a" відповідає 96)

Braineasy, 60 байт

Також моєю спеціальною мовою (на базі brainf **, перекладач тут ):

#123#[->+>+<<]>++<,[[-<+<+>>]<[->>>..<.<<]<[->>>.<<<]!]>>.<.

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

05AB1E , 5 3 байти

F¯)

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

Ця версія є після того, як він уточнив, що набори добре.

F   # From 1 to input...
 ¯  # Push global array (default value is []).
  ) # Wrap stack to array.

Стара версія (яка використовує ø):

05AB1E , 5 4 байти

FX¸)

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

Де 1еквівалентно ø.

F    # From 1 to input...
 X   # Push value in register X (default is 1).
  ¸  # Wrap pushed value into an array.
   ) # Wrap whole stack into an array.
     # Implicit loop end (-1 byte).
     # Implicit return.