Wise es un lenguaje simple bit a bit que diseñé hace un tiempo. Se basa en las operaciones bit a bit de Python . Tiene varias operaciones, la mayoría de estas son iguales o muy similares al símbolo equivalente en Python.

• : Duplicar la parte superior de la pila.

• ? Gire la parte superior de la pila hacia abajo

• ! Gire la parte inferior de la pila hacia arriba

• [ ] bucle mientras la parte superior de la pila no es cero

• ~no la parte superior de la pila ( -(n+1))

• -negar la parte superior de la pila ( -n)

• >Desplazar la parte superior de la pila una vez a la derecha ( n//2)

• <desplazar la parte superior de la pila una vez a la izquierda ( n*2)

• ^xo los dos primeros elementos de la pila ( igual que Python )

• |o los dos primeros elementos de la pila ( igual que Python )

• &y los dos primeros elementos de la pila ( igual que Python )

Hacer un número entero en Wise es bastante simple, puedes hacer cero con él ::^e incrementarlo ~-para que puedas hacer cero e incrementarlo varias veces. Sin embargo, si eliminamos las -cosas se vuelven un poco más interesantes.

Todavía podemos hacer cada número usando las operaciones restantes. Por ejemplo aquí hay 3

~<<~

TIO

Esto funciona porque ~convierte cero, una cadena infinita de 0bits, en uno negativo, una cadena infinita de 1bits, cada uno <agrega un 0bit al final, cuando terminamos hacemos lo ~que lo convierte en una cadena de 0s seguida de dos 1s , o como la mayoría de la gente lo llama 3.

Tarea

Escriba un programa que cuando se le dé un número entero positivo generará un programa Wise que creará el número nsin ninguno -en su fuente (la fuente de la salida, puede usarla -en su propia fuente). Puede suponer que ya hay un cero en la parte superior de la pila.

Este es el código de golf, no el meta-golf, por lo que debe intentar minimizar el código fuente de generación, no necesariamente la salida.

Salidas de ejemplo

Esta lista no es exhaustiva, simplemente son salidas posibles

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

Japt , 10 bytes

¤d0'<1"~<~

Pruébalo en línea!

Idea básica: tomar la representación binaria del número, y asignar 0a <y 1para ~<~. Salidas 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 cualquier número entero de 32 bits.

Haskell , 38 bytes

Siento que PPCG realmente está mejorando mi Haskell. Trazos de gato blanco.

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

ftoma un Inty devuelve un String.

Pruébalo en línea!

(Me refiero a eso <$fpor cierto. Salva a un personaje \_->).

En el Functorcaso de (->) a(funciones de tipo a), tenemos: x <$ f = fmap (const x) f = const x . f = const x. La única limitación es eso fy el final const xdebe usar el mismo tipo de fuente a. La instancia es completamente perezosa, por lo que nunca se evalúa f.

Alternativamente, la misma longitud pero menos malvada ( (l!!)es una función anónima):

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

Pruébalo en línea!

Ambos utilizan la misma representación que la respuesta Japt de @ETHproductions, aunque especialmente la primera puede dar algunas respuestas redundantes. < s al principio.

El primero calcula todas las combinaciones de n "<"y"~<~" cadenas, luego los indexa en la lista resultante.

El segundo calcula recursivamente una lista infinita formada al comenzar ""y luego construir nuevos elementos agregando "<"y "~<~"cadenas a cada elemento que ya está en la lista (en realidad, fue un poco más corto para permitir que ""se convirtiera "<").

Rubí , 118 116 109 107 105 91 bytes

¡Guardado 2 bytes gracias 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]}

Pruébalo en línea!

Esta es una función que toma el entero como entrada y devuelve la cadena que representa ese entero en Wise. Puedes encontrar una versión sin golf aquí , que prueba este programa en todos los enteros desde 1 en adelante.

La idea básica es registrar un "grupo" de constantes. Luego, con cada "paso", se agregan constantes al grupo para cada función posible. He elegido las funciones ~, <y >, que creo que son suficientes para representar cada número. (Al menos, cada número por debajo de 10,000).

Python2, 54 52 51 bytes.

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

¡Gracias a Wheat Wizard por guardar 2 bytes, y Ørjan Johansen por un byte! Esto usa la misma idea que la respuesta Japt de ETHproduction, pero con diferentes cadenas de reemplazo (es decir, usando la representación binaria)

05AB1E , 11 bytes

bS'<…~<~‚èJ

Pruébalo en línea!

Similar a la respuesta Japt de ETHproductions.

¡Guardado 4 bytes gracias a @Adnan!

Python 2 , 123110 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)+"<"

Pruébalo en línea!

También como un 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)+"<"

Pruébalo en línea!

Podría ser más corto pero aquí está mi solución. Toma la representación binaria y la convierte en el código.

Japt , 23 bytes

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

Pruébalo en línea!

Jalea, 11 10 bytes

Bị“~<~“<”F

Esta es una versión portada de la respuesta Japt de ETHproductions. Hablando de ETHproductions, ¡me salvaron un byte!