Wise - простой побитовый язык, который я разработал некоторое время назад. Он основан на побитовых операциях Python . Он имеет несколько операций, большинство из которых совпадают или очень похожи на эквивалентные символы в Python.

• : Дублируйте вершину стека

• ? Поверните верх стопки к низу

• ! Поверните дно стека к вершине

• [ ] цикл в то время как вершина стека не равна нулю

• ~не вершина стека ( -(n+1))

• -отрицать вершину стека ( -n)

• >сдвиг вершины стека один раз вправо ( n//2)

• <сдвиг вершины стека один раз влево ( n*2)

• ^xor два верхних элемента стека (такие же как Python )

• |или два верхних элемента стека (такие же как Python )

• &и два верхних элемента стека (такие же как Python )

Сделать целое число в Wise довольно просто, вы можете сделать ноль с помощью ::^и увеличить его, ~-чтобы сделать ноль и увеличить его несколько раз. Однако если мы уберем -вещи, станет немного интереснее.

Мы все еще можем сделать каждое число, используя оставшиеся операции. Например вот 3

~<<~

TIO

Это работает, потому что ~превращает ноль, бесконечную строку 0битов, в отрицательную, бесконечную строку 1битов, каждый <добавляет 0бит до конца, когда мы закончим, мы делаем, ~который превращает каждый его в строку 0s, за которой следуют два 1s или, как большинство людей называют это 3.

задача

Напишите программу, которая при получении положительного целого числа выведет программу Wise, которая создаст число nбез какого-либо -источника (источник вывода вы можете использовать -в своем собственном источнике). Вы можете предположить, что на вершине стека уже есть ноль.

Это код-гольф, а не мета-гольф, поэтому вы должны стремиться минимизировать генерацию исходного кода, а не обязательно вывод.

Пример выходов

Этот список не является исчерпывающим, они просто возможные выводы

1  -> ~<~
2  -> ~<~<
3  -> ~<<~
4  -> ~<~<<
5  -> ~<~:<<|
6  -> ~<<~<
7  -> ~<<<~
8  -> ~<~<<<
9  -> ~<~:<<<|
10 -> ~<~:<<|<
11 -> ~<<~:><<<|
12 -> ~<<~<<
13 -> ~<<~:<<<|>
14 -> ~<<<~<
15 -> ~<<<<~
16 -> ~<~<<<<

Japt , 10 байт

¤d0'<1"~<~

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

Основная идея: взять двоичное представление числа, и карты 0в <и 1к ~<~. Выходы на 1-10:

 1: ~<~
 2: ~<~<
 3: ~<~~<~
 4: ~<~<<
 5: ~<~<~<~
 6: ~<~~<~<
 7: ~<~~<~~<~
 8: ~<~<<<
 9: ~<~<<~<~
10: ~<~<~<~<

JavaScript (ES6), 34 33 байта

f=n=>n?f(n&1?~n:n/2)+'<~'[n&1]:''

<input type=number oninput=o.textContent=f(this.value)><pre id=o>

Работает для любого 32-разрядного целого числа.

Haskell , 38 байт

Я чувствую, что PPCG действительно улучшает мой Haskell. Поглаживает белого кота.

f n=mapM(["<","~<~"]<$f)[1..n]!!n>>=id

fпринимает Intи возвращает String.

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

( <$fКстати, я имею в виду это . Это спасает персонажа \_->).

В Functorслучае для (->) a(функций от типа a), мы имеем: x <$ f = fmap (const x) f = const x . f = const x. Единственным ограничением является то, что fи финал const xдолжен использовать тот же тип источника a. Экземпляр полностью ленив, так что это никогда не оценивается f.

Альтернативно, такой же длины, но меньше зла ( (l!!)это анонимная функция):

(l!!)
l=(++)<$>"":tail l<*>["<","~<~"]

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

Оба из них используют то же представление, что и ответ @ETHproductions 'Japt, хотя особенно первый может дать несколько избыточных <s в начале.

Первый вычисляет все комбинации n "<"и "~<~"строки, затем индексирует в результирующий список.

Второй рекурсивно вычисляет бесконечный список, сформированный, начиная с, ""а затем создавая новые элементы, добавляя "<"и добавляя "~<~"строки к каждому элементу, уже находящемуся в списке (на самом деле, он был немного короче, чтобы можно ""было превратить в "<").

Рубин , 118 116 109 107 105 91 байт

Сохранено 2 байта благодаря Cyoce!

->n{o={0=>""}
o.dup.map{|c,k|["~~c","<c*2"].map{|t|o[eval t[1..9]]=k+t[0]}}until o[n]
o[n]}

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

Это функция, которая принимает целое число в качестве входных данных и возвращает строку, которая представляет это целое число в Wise. Вы можете найти ungolfed версию здесь , которая проверяет эту программу на всех целых чисел от 1 до.

Основная идея состоит в том, чтобы записать «пул» констант. Затем, с каждым «шагом», константы добавляются в пул для каждой возможной функции. Я выбрал функции ~, <и >, которые я считаю достаточными для представления каждого числа. (По крайней мере, каждое число до 10000).

Python2, 54 52 51 байт.

lambda x:'<'.join('>~<~'*int(i)for i in bin(x)[2:])

Спасибо Wheat Wizard за сохранение 2 байта и Орджану Йохансену за один байт! При этом используется та же идея, что и в ответе Japt ETHproduction, но с другими заменяемыми строками (т. Е. Используется двоичное представление)

05AB1E , 11 байт

bS'<…~<~‚èJ

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

Аналогично ответу ETHproductions 'Japt.

Сохранено 4 байта благодаря @Adnan!

Python 2 , 123 110 байт

def w(x):a=map(int,bin(x)[2:]);return x%2*("~<~:<"+"<".join(":"*e for e in a[-2::-1])+"|"*sum(a))or w(x/2)+"<"

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

Также как lambda

w=lambda x:x%2*("~<~:<"+"<".join(":"*int(e)for e in bin(x)[-2:2:-1])+"|"*sum(map(int,bin(x)[2:])))or w(x/2)+"<"

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

Может быть короче, но вот мое решение. Он принимает двоичное представление и превращает его в код.

Japt , 23 байта

?Uu ?ß~U +'~:ßU/2 +'<:P

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

Желе, 11 10 байт

Bị“~<~“<”F

Это портированная версия ответа ETHproductions 'Japt. Говоря о продуктах ETH, они спасли мне один байт!