Wise è un semplice linguaggio bit per bit che ho progettato qualche tempo fa. Si basa sulle operazioni bit per bit di Python . Ha diverse operazioni la maggior parte di queste sono uguali o molto simili al simbolo equivalente in Python.

• : Duplica la parte superiore della pila

• ? Ruota la parte superiore della pila verso il basso

• ! Ruota la parte inferiore della pila verso l'alto

• [ ] loop mentre la parte superiore dello stack non è zero

• ~non in cima allo stack ( -(n+1))

• -annulla la parte superiore dello stack ( -n)

• >sposta la parte superiore dello stack una volta verso destra ( n//2)

• <sposta la parte superiore dello stack una volta a sinistra ( n*2)

• ^xo i primi due elementi dello stack ( uguale a Python )

• |o i primi due elementi dello stack ( uguale a Python )

• &e i primi due elementi dello stack ( uguale a Python )

Creare un numero intero in Wise è abbastanza semplice con cui puoi fare zero ::^e incrementare con, ~-quindi fai zero e incrementalo un sacco di volte. Tuttavia se rimuoviamo le -cose diventano un po 'più interessanti.

Possiamo ancora fare ogni numero usando le restanti operazioni. Ad esempio qui è 3

~<<~

TIO

Questo funziona perché ~trasforma zero, una stringa infinita di 0bit, in negativa, una stringa infinita di 1bit, ognuno <aggiunge un 0po 'alla fine, quando abbiamo finito facciamo ciò ~che lo trasforma in una stringa di 0s seguita da due 1s , o come la maggior parte delle persone lo chiama 3.

Compito

Scrivi un programma che quando viene dato un numero intero positivo produrrà un programma Wise che creerà il numero nsenza alcuno -nella sua fonte (la fonte dell'output, che puoi usare -nella tua fonte). Si può presumere che ci sia già uno zero nella parte superiore della pila.

Questo è code-golf non meta-golf, quindi dovresti mirare a minimizzare il codice sorgente di generazione, non necessariamente l'output.

Esempi di output

Questo elenco non è esaustivo, sono semplicemente uscite possibili

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

Japt , 10 byte

¤d0'<1"~<~

Provalo online!

Idea di base: prendere la rappresentazione binaria del numero e mappare 0su <e 1verso ~<~. Uscite per 1-10:

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

JavaScript (ES6), 34 33 byte

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

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

Funziona con qualsiasi numero intero a 32 bit.

Haskell , 38 byte

Sento che PPCG sta davvero migliorando il mio Haskell. Colpo di gatto bianco.

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

fprende un Inte restituisce un String.

Provalo online!

(A <$fproposito, mi riferisco a questo . Salva un personaggio \_->.)

Nel Functorcaso di (->) a(funzioni di tipo a), abbiamo: x <$ f = fmap (const x) f = const x . f = const x. L'unica limitazione è quella fe il finale const xdeve usare lo stesso tipo di sorgente a. L'istanza è completamente pigra, quindi non viene nemmeno valutata f.

In alternativa, stessa lunghezza ma meno male ( (l!!)è una funzione anonima):

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

Provalo online!

Entrambi usano la stessa rappresentazione della risposta Japt di @ETHproductions, anche se in particolare il primo può dare alcuni ridondanti <all'inizio.

Il primo calcola tutte le combinazioni di n "<"e "~<~"stringhe, quindi indicizza nell'elenco risultante.

Il secondo calcola ricorsivamente una lista infinita formata partendo da ""e quindi la costruzione di nuovi elementi aggiungendo "<"e "~<~"stringhe per ciascun elemento già presente nella lista (in realtà era leggermente più corta per consentire anche l' ""arrivare trasformato in "<".)

Rubino , 118 116 109 107 105 91 byte

Salvato 2 byte grazie 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]}

Provalo online!

Questa è una funzione che accetta l'intero come input e restituisce la stringa che rappresenta quell'intero in Wise. Puoi trovare una versione non golfata qui , che testa questo programma su tutti i numeri interi da 1 in su.

L'idea di base è quella di registrare un "pool" di costanti. Quindi, con ogni "passaggio", le costanti vengono aggiunte al pool per ogni possibile funzione. Ho scelto le funzioni ~, <e >, che credo siano sufficienti per rappresentare ogni numero. (Almeno, ogni numero inferiore a 10.000.)

Python2, 54 52 51 byte.

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

Grazie a Wheat Wizard per aver salvato 2 byte e Ørjan Johansen per un byte! Questo utilizza la stessa idea della risposta Japt di ETHproduction, ma con stringhe di sostituzione diverse (ovvero utilizzando la rappresentazione binaria)

05AB1E , 11 byte

bS'<…~<~‚èJ

Provalo online!

Simile alla risposta Japt di ETHproductions.

4 byte salvati grazie a @Adnan!

Python 2 , 123 110 byte

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

Provalo online!

Anche come a 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)+"<"

Provalo online!

Potrebbe essere più breve ma ecco la mia soluzione. Prende la rappresentazione binaria e la trasforma in codice.

Japt , 23 byte

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

Provalo online!

Gelatina, 11 10 byte

Bị“~<~“<”F

Questa è una versione con porting della risposta Japt di ETHproductions. Parlando di ETHproductions, mi hanno salvato un byte!