Edycja: meta-golfWkrótce opublikuję nowszą wersję tego pytania . Trzymaj toon!

Edycja nr 2: Nie będę już aktualizować wyzwania, ale pozostawię je otwarte. meta-golfWersja dostępna jest tutaj: /codegolf/106509/obfuscated-number-golf

Tło:

Większość liczb można zapisać tylko za pomocą 6 różnych symboli:

• e (Stała Eulera)
• - (Odejmowanie, nie negacja)
• ^ (Potęgowanie)
• (
• )
• ln (Naturalny logarytm)

Na przykład możesz przekonwertować liczbę urojoną iza pomocą tego równania:

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

Cel:

Biorąc pod uwagę liczbę całkowitą kza pomocą dowolnych rozsądnych środków, wyprowadzaj możliwie najkrótszą reprezentację tej liczby, używając tylko tych 6 symboli.

Przykłady:

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

Uwagi:

• Końcowy nawias liczy się do całkowitej liczby znaków.
• ln( liczy się tylko jako 1 znak.
• Cała reszta liczy się jako 1 postać.
• n^0=1
• Obowiązuje kolejność operacji
• Nawias namnażania jest do przyjęcia, na przykład (2)(8)=16, 2(5)=10i eln(e)=e.
• ln e nie jest ważne, musisz to zrobić ln(e)

Python 3, 402 bajty

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

Przykładowe użycie:

>>> 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)'

Zauważ, że chociaż format wyjściowy może go nie odzwierciedlać, kod poprawnie zlicza wszystkie długości zgodnie ze specyfikacją pytania.

To głupie okrucieństwo na wszystkich możliwych długościach strun. Następnie używam zamienników, aby Python mógł to ocenić. Jeśli jest równy temu, czego chcemy, zaznaczam również, aby wykluczyć jednoargumentowe znaki ujemne, sprawdzając AST.

Nie jestem zbyt dobry w golfie w Pythonie, więc oto częściowo nieuczesany kod, jeśli ktoś chce pomóc!

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