O Wise é uma linguagem bit a bit simples que projetei há um tempo. É baseado nas operações bit a bit do Python . Possui várias operações, a maioria delas é igual ou muito semelhante ao símbolo equivalente no Python.

• : Duplique a parte superior da pilha

• ? Gire a parte superior da pilha para baixo

• ! Gire a parte inferior da pilha para o topo

• [ ] enquanto o topo da pilha não é zero

• ~não é o topo da pilha ( -(n+1))

• -negar o topo da pilha ( -n)

• >mova a parte superior da pilha uma vez para a direita ( n//2)

• <deslocar o topo da pilha uma vez para a esquerda ( n*2)

• ^xou os dois principais itens da pilha (o mesmo que Python )

• |ou os dois principais itens da pilha (o mesmo que Python )

• &e os dois principais itens da pilha (o mesmo que Python )

Criar um número inteiro no Wise é bastante simples: você pode zerar ::^e incrementá-lo ~-para que você faça zero e aumente várias vezes. No entanto, se removermos as -coisas se tornam um pouco mais interessantes.

Ainda podemos fazer todos os números usando as operações restantes. Por exemplo, aqui está 3

~<<~

TIO

Isso funciona porque ~transforma zero, uma sequência infinita de 0bits, em negativo, uma sequência infinita de 1bits, cada <um acrescenta um 0pouco ao final; quando terminamos, o que faz com ~que cada um seja uma sequência de 0s seguida por dois 1s ou como a maioria das pessoas chama 3

Tarefa

Escreva um programa que, quando determinado um número inteiro positivo, produzirá um programa Wise que criará o número nsem nenhum -em sua fonte (a fonte da saída, você pode usar -em sua própria fonte). Você pode assumir que já existe um zero no topo da pilha.

Como código-golfe e não meta-golfe , você deve tentar minimizar o código-fonte de geração e não necessariamente a saída.

Saídas de exemplo

Esta lista não é exaustiva, são simplesmente saídas possíveis

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

Japonês , 10 bytes

¤d0'<1"~<~

Experimente online!

Ideia básica: pegue a representação binária do número e mapeie 0para <e 1para ~<~. Saídas para 1-10:

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

JavaScript (ES6), 34 33 bytes

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

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

Funciona para qualquer número inteiro de 32 bits.

Haskell , 38 bytes

Eu sinto que o PPCG está realmente melhorando meu Haskell. Acaricia o gato branco.

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

fpega um Inte retorna um String.

Experimente online!

(A <$fpropósito, estou me referindo a isso . Ele salva um personagem \_->.)

No Functorexemplo, para (->) a(funções de tipo a), temos: x <$ f = fmap (const x) f = const x . f = const x. A única limitação é essa fe a final const xdeve usar o mesmo tipo de fonte a. A instância é completamente preguiçosa, portanto isso nunca é avaliado f.

Como alternativa, o mesmo comprimento, mas menos maligno ( (l!!)é uma função anônima):

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

Experimente online!

Ambos usam a mesma representação que a resposta Japt da @ETHproductions, embora especialmente o primeiro possa fornecer algumas redundantes < s no início.

O primeiro calcula todas as combinações de n "<"e"~<~" strings e depois indexa a lista resultante.

O segundo calcula recursivamente uma lista infinita formada iniciando ""e construindo novos elementos anexando "<"e "~<~"strings a cada elemento que já está na lista (na verdade, era um pouco menor para permitir que as coisas ""se transformassem "<").

Ruby , 118 116 109 107 105 91 bytes

Guardado 2 bytes graças a 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]}

Experimente online!

Esta é uma função que recebe o número inteiro como entrada e retorna a string que representa esse número inteiro no Wise. Você pode encontrar uma versão não destruída aqui , que testa este programa em todos os números inteiros de 1 em diante.

A idéia básica é registrar um "conjunto" de constantes. Em seguida, com cada "etapa", as constantes são adicionadas ao pool para cada função possível. Eu escolhi as funções ~, <e >, que, creio, são suficientes para representar cada número. (Pelo menos, todo número abaixo de 10.000.)

Python2, 54 52 51 bytes.

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

Agradecimentos ao Assistente de Trigo por salvar 2 bytes e Ørjan Johansen por um byte! Isso usa a mesma idéia que a resposta Japt da ETHproduction, mas com cadeias de substituição diferentes (ou seja, usando a representação binária)

05AB1E , 11 bytes

bS'<…~<~‚èJ

Experimente online!

Semelhante à resposta japonesa da ETHproductions.

Guardado 4 bytes graças a @Adnan!

Python 2 , 123 110 bytes

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

Experimente online!

Também como 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)+"<"

Experimente online!

Poderia ser mais curto, mas aqui está a minha solução. Ele pega a representação binária e a transforma no código.

Japonês , 23 bytes

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

Experimente online!

Geléia, 11 10 bytes

Bị“~<~“<”F

Esta é uma versão portada da resposta Japt da ETHproductions. Por falar em produtos ETH, eles me salvaram um byte!