Edit: je publierai bientôt une version plus récente de cette question meta-golf. Restez sage!

Edit # 2: Je ne mettrai plus à jour le défi, mais le laisserai ouvert. La meta-golfversion est disponible ici: /codegolf/106509/obfuscated-number-golf

Contexte:

La plupart des nombres peuvent être écrits avec seulement 6 symboles différents:

• e (Constante d'Euler)
• - (Soustraction, pas négation)
• ^ (Exponentiation)
• (
• )
• ln (Un algorithme naturel)

Par exemple, vous pouvez convertir le nombre imaginaire en iutilisant cette équation:

(e-e-e^(e-e))^(e^(e-e-ln(e^(e-e)-(e-e-e^(e-e)))))

Objectif:

Étant donné n'importe quel entier kpar tout moyen raisonnable, affichez la représentation la plus courte possible de ce nombre en utilisant uniquement ces 6 symboles.

Exemples:

0 => "e-e"
1 => "ln(e)"
2 => "ln(ee)"
// Since - cannot be used for negation, this is not a valid solution: 
// ln(e)-(-ln(e))
-1 => "e-e-ln(e)"

Remarques:

• Les parenthèses de fin comptent pour le nombre total de caractères.
• ln( ne compte que pour 1 caractère.
• Tout le reste compte pour 1 caractère.
• n^0=1
• L'ordre des opérations s'applique
• Parenthesis multiplication est acceptable, par exemple (2)(8)=16, 2(5)=10eteln(e)=e .
• ln e n'est pas valide, vous devez faire ln(e)

Python 3, 402 octets

from itertools import*
from ast import*
from math import*
v,r=lambda x:'UnaryOp'not in dump(parse(x)),lambda s,a,b:s.replace(a,b)
def l(x,y):
    for s in product('L()e^-',repeat=x):
        f=r(r(r(''.join(s),'L','log('),')(',')*('),'^','**')
        g=r(f,'ee','e*e')
        while g!=f:f,g=g,r(g,'ee','e*e')
        try:
            if eval(g)==y and v(g):return g
        except:0
def b(v):
    i=1
    while 1:
        r=l(i,v)
        if r:return r
        i+=1

Exemple d'utilisation:

>>> b(1)
'log(e)'
>>> b(0)
'e-e'
>>> b(-3)
'e-log(e*e*e)-e'
>>> b(8)
'log(e*e)**log(e*e*e)'

Notez que bien que le format de sortie puisse ne pas le refléter, le code compte correctement toutes les longueurs selon les spécifications de la question.

Il s'agit d'une bruteforce stupide à travers toutes les longueurs possibles de chaînes. Ensuite, j'utilise des remplacements pour que Python puisse l'évaluer. Si c'est égal à ce que nous voulons, je vérifie également d'exclure les signes négatifs unaires en vérifiant l'AST.

Je ne suis pas très bon au golf en Python, alors voici le code semi-non-golfé si quelqu'un veut aider!

from itertools import*
from ast import*
from math import*

def valid(ev):
    return 'UnaryOp' not in dump(parse(ev))

def to_eval(st):
    f = ''.join(st).replace('L', 'log(').replace(')(', ')*(').replace('^', '**')
    nf = f.replace('ee', 'e*e')
    while nf != f:
        f, nf = nf, nf.replace('ee', 'e*e')
    return nf

def try_length(length, val):
    for st in product('L()e^-', repeat=length):
        ev = to_eval(st) 
        try:
            if eval(ev) == val and valid(ev):
                return st
        except:
            pass

def bruteforce(val):
    for i in range(11):
        res = try_length(i, val)
        if res:
            print(i, res)
            return res