Wise est un langage simple au niveau du bit que j'ai conçu il y a quelque temps. Il est basé sur les opérations bit à bit de Python . Il a plusieurs opérations dont la plupart sont identiques ou très similaires au symbole équivalent en Python.

• : Dupliquez le haut de la pile

• ? Faire pivoter le haut de la pile vers le bas

• ! Faire pivoter le bas de la pile vers le haut

• [ ] boucle alors que le haut de la pile n'est pas nul

• ~pas le haut de la pile ( -(n+1))

• -annuler le haut de la pile ( -n)

• >décalage du bit une fois vers la droite en haut de la pile ( n//2)

• <décaler le haut de la pile une fois vers la gauche ( n*2)

• ^xou les deux premiers éléments de la pile ( Identique à Python )

• |ou les deux premiers éléments de la pile ( comme Python )

• &et les deux premiers éléments de la pile ( identiques à Python )

Faire un entier dans Wise est assez simple, vous pouvez faire zéro avec ::^et l'incrémenter avec ~-donc vous faites zéro et l'incrémentez un tas de fois. Cependant, si nous supprimons les -choses, cela devient un peu plus intéressant.

Nous pouvons toujours faire chaque numéro en utilisant les opérations restantes. Par exemple, voici 3

~<<~

TIO

Cela fonctionne parce que ~transforme zéro, une chaîne infinie de 0bits, en négatif, une chaîne infinie de 1bits, chacun <ajoute un 0bit à la fin, lorsque nous avons terminé, nous faisons ~ce qui le transforme en une chaîne de 0s suivie de deux 1s , ou comme la plupart des gens l'appellent 3.

Tâche

Écrivez un programme qui, lorsqu'il reçoit un entier positif, produira un programme Wise qui créera le nombre nsans aucun -dans sa source (la source de la sortie, vous pouvez l'utiliser -dans votre propre source). Vous pouvez supposer qu'il y a déjà un zéro en haut de la pile.

Il s'agit de code-golf et non de méta-golf , vous devez donc viser à minimiser le code source généré, pas nécessairement la sortie.

Exemples de sorties

Cette liste n'est pas exhaustive ce sont simplement des sorties possibles

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

Japt , 10 octets

¤d0'<1"~<~

Essayez-le en ligne!

Idée de base: prendre la représentation binaire du nombre et mapper 0vers <et 1vers ~<~. Sorties pour 1-10:

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

JavaScript (ES6), 34 33 octets

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

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

Fonctionne pour n'importe quel entier 32 bits.

Haskell , 38 octets

J'ai l'impression que PPCG améliore vraiment mon Haskell. Caresse le chat blanc.

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

fprend un Intet retourne un String.

Essayez-le en ligne!

(Je fais allusion à cela <$fen passant. Cela sauve un personnage \_->.)

Dans l' Functorexemple , pour (->) a(fonctions de genre a), nous avons: x <$ f = fmap (const x) f = const x . f = const x. La seule limitation est que fet la finale const xdoit utiliser le même type de source a. L'instance est complètement paresseuse, ce qui n'évalue même jamais f.

Alternativement, même longueur mais moins mal ( (l!!)est une fonction anonyme):

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

Essayez-le en ligne!

Les deux utilisent la même représentation que la réponse Japt de @ETHproductions, bien que surtout la première puisse donner quelques <s redondants au début.

Le premier calcule toutes les combinaisons de n "<"et "~<~"chaînes, puis indexe dans la liste résultante.

Le second calcule récursivement une liste infinie formée en commençant par ""puis en construisant de nouveaux éléments en ajoutant "<"et en "~<~"chaîne à chaque élément déjà dans la liste (en fait, il était légèrement plus court pour laisser le ""devenir se transformer en "<".)

Ruby , 118 116 109 107 105 91 bytes

Enregistré 2 octets grâce à 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]}

Essayez-le en ligne!

Il s'agit d'une fonction qui prend l'entier en entrée et renvoie la chaîne qui représente cet entier dans Wise. Vous pouvez trouver une version non golfée ici , qui teste ce programme sur tous les entiers à partir de 1.

L'idée de base est d'enregistrer un "pool" de constantes. Ensuite, à chaque "étape", des constantes sont ajoutées au pool pour chaque fonction possible. J'ai choisi les fonctions ~, <et >que je crois suffisent pour représenter chaque nombre. (Au moins, chaque nombre inférieur à 10 000.)

Python2, 54 52 51 octets.

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

Merci à Wheat Wizard pour avoir sauvé 2 octets, et Ørjan Johansen pour un octet! Cela utilise la même idée que la réponse Japt d'ETHproduction, mais avec des chaînes de remplacement différentes (c'est-à-dire en utilisant la représentation binaire)

05AB1E , 11 octets

bS'<…~<~‚èJ

Essayez-le en ligne!

Similaire à la réponse Japt d'ETHproductions.

4 octets enregistrés grâce à @Adnan!

Python 2 , 123 110 octets

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

Essayez-le en ligne!

Aussi en tant que 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)+"<"

Essayez-le en ligne!

Pourrait être plus court mais voici ma solution. Il prend la représentation binaire et la transforme en code.

Japt , 23 octets

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

Essayez-le en ligne!

Gelée, 11 10 octets

Bị“~<~“<”F

Il s'agit d'une version portée de la réponse Japt d'ETHproductions. En parlant de productions ETH, ils m'ont sauvé un octet!