Non sarebbe pulito se le funzioni di programmazione potessero essere invertite, proprio come la funzione matematica che implementano?

Scrivi una funzione (o programma) che accetta un input xin qualsiasi forma, che genera ln(x).
Quando i byte del programma vengono riordinati / invertiti in modo che il primo byte sia ora l'ultimo byte, dovrebbe invece assumere un input xin qualsiasi forma e e^xinvece output .

• La tua risposta deve contenere almeno 3 cifre significative corrette.
• Le approssimazioni vanno bene, purché abbiano almeno 3 cifre significative corrette.
• Il codice deve essere nello stesso linguaggio di programmazione sia in avanti che all'indietro.

Diciamo che questo programma implementa ln(x):

abc你好

Quindi questo programma deve implementare e^x:

\xBD\xA5\xE5\xA0\xBD\xE4cba

Stella d'oro se usi una lingua senza supporto float.

Questa è una strana forma di code-golf, quindi vince il programma più breve.

Haskell, 11 byte

f=log
pxe=f

e in ordine inverso:

f=exp
gol=f

Funziona senza il trucco "comment". Invece ogni versione definisce una funzione aggiuntiva, ma non utilizzata ( pxe/ gol).

APL, 3 byte

*⊣⍟

Questo è un treno di funzioni. * Ritorni monadici e^x, ⍟ritorni monadici ln(x). ⊣è una funzione diadica che restituisce l'argomento sinistro. Pertanto, *⊣⍟equivale a just *e il contrario ⍟⊣*equivale a just ⍟.

Gelatina, 5 4 byte

Yay, la mia prima risposta Jelly. :) L'input avviene tramite argomento della riga di comando.

Jelly ha una sua tabella codici quindi ogni carattere è un byte.

eÆÆl

Provalo online!

invertito:

lÆÆe

Provalo online!

Spiegazione

Di Æper sé è un token non riconosciuto, quindi si comporta come un avanzamento di riga. Ciò significa che in entrambi i casi il collegamento principale è solo Ælo Æeche è incorporato a 2 caratteri per exp()o ln()ed è eseguito per impostazione predefinita sul primo argomento della riga di comando.

Javascript, 18 byte

Math.log//pxe.htaM

Scherzi a parte, 5 byte

,_.e,

Input, ln, output, quindi exp su uno stack vuoto (non fa nulla) e input (non fa nulla poiché l'input è esaurito). Provalo online!

invertito:

,e._,

Provalo online!

Julia, 7 byte

log#pxe

Questa è una funzione anonima. Assegnalo a una variabile per chiamarlo. Valuta i builtin logo exppiù un commento.

Mathematica, 19 byte

1&#@pxE+0&0+Log@#&1

invertito:

1&#@goL+0&0+Exp@#&1

Questo è stato interessante per il golf! Mathematica non ha commenti di riga / terminazioni di stringa implicite, quindi non ho potuto seguire il percorso semplice. Invece, ho usato il fatto che 0 + x == x, 0 x == 0e che 1 x == x, non importa che cosa xè! test:

In[1]:= (1&#@pxE+0&0+Log@#&1)[x]

Out[1]= Log[x]

In[2]:= (1&#@goL+0&0+Exp@#&1)[x]

         x
Out[2]= E

Python2, 73 byte

io: stdin / stdout

from math import*;print log(input())#))(tupni(pxe tnirp;*tropmi htam morf

inverso:

from math import*;print exp(input())#))(tupni(gol tnirp;*tropmi htam morf

CJam, 11 byte

rdmle#eemdr

Provalo qui.

invertito:

rdmee#elmdr

Provalo qui.

Fondamentalmente lo stesso trucco-commento della risposta Python dell'OP. e#inizia un commento. rdlegge l'input e mlo mecalcola il logaritmo o esponenziale.

Brachylog , 3 byte

*₁≡

Provalo online!

Inizialmente, avevo sperato di usare ~*, ma sebbene *~calcoli e^xe ignori con successo la tilde finale, ~*fallisce per tutti gli input interi e colpisce un overflow float sulla maggior parte degli input non interi.

Attaccanti:

       The output
  ≡    is
*₁     the natural logarithm of
       the input.

Indietro:

       The output is
  *    Euler's number to the power of
       the input
≡      passed through the identity predicate
 ₁     with an extraneous subscript.

Questo utilizza il predicato di identità perché, sebbene le tilde finali siano tollerate, gli indici principali non lo sono. (Se lo fossero, la risposta di Brachylog sarebbe *₁sola, che è solo la normale funzione di log naturale).

Vitsy, 5 byte

Questo è un programma che esce in caso di errore.

EL^rE
E   E  Push java.lang.Math.E
 L     Push log_(top) (input) (ln(input))
  ^    Push (top)^(input)  (e^(input))
   r   Reverse the stack

Questo programma termina con un errore con ln (input) nello stack.

Provalo online! (nota che ho messo Nper avere un output visibile)

Quindi è inverso:

Er^LE

Questo programma esce in caso di errore con e ^ (input) nello stack.

Provalo online!

Fuzzy Octo Guacamole, 7 byte

_{non competitiva, FOG è più recente della sfida}

EZO@pZE

Questo è l'equivalente di una funzione in FOG. Presuppone che l'input sia nello stack. Questo può essere assegnato a una funzione dal codice "EZO@pZE""f"o, dove si ftrova qualsiasi nome a carattere singolo che si desidera assegnare. Quindi usalo come qualsiasi altro comando. Esempio: "EZO@pZE"'f'o^f.

Spiegazione:

EZO@pZE
E       # Push E (2.718....)
 Z      # Reverse stack (it is now [e, input])
  O     # log(x, y) which is ln(input)
   @    # Exit. (implicit output) Nothing after this gets run.
    p   # x^y (power function)
     Z  # Reverse stack
      E # Push E.

invertito:

EZp@OZE
E       # Push E (2.718....)
 Z      # Reverse stack (it is now [e, input])
  O     # x^y (power function)
   @    # Exit. (implicit output) Nothing after this gets run.
    p   # log(x, y) which is ln(input)
     Z  # Reverse stack
      E # Push E.

Matl, 5 byte

Yl%eZ

Yl: log Ze: exp %: commento

Pyth, 12 byte

reperti ln(input())

.lQ) " Q1n.^

reperti e^input()

^.n1Q " )Ql.

Gli spazi interrompono la stampa implicita di stringhe, ogni versione la calcola e quindi crea una stringa con i caratteri rimanenti.

ln(x) modalità qui

e^x modalità qui

𝔼𝕊𝕄𝕚𝕟, 8 caratteri / 10 byte

МŬï//ïŦМ

Try it here (Firefox only).Try reverse here (Firefox only).

Solo 2 builtin separati da un commento.

Jolf, 9 byte

Programma 1: expdi input

amoj"jOma
a         print
 moj      e^j
    "jOma  the rest of the line is captured as a string; implicit printing is restricted.

Programma 2: lndi input

amOj"joma
a         print
 mOj      ln(j)
    "joma  the rest of the line is captured as a string; implicit printing is restricted.

Punti bonus per essere un palindromo senza distinzione tra maiuscole e minuscole? Provalo qui!

J, 8 byte

Il logaritmo naturale è ^.ed esponenziale ^. Il problema è che .può solo modificare un verbo valido, altrimenti si verificherà un errore di ortografia. Pertanto, non possiamo usare il trucco dell'argomento sinistro nella risposta APL, perché ^.[^causerebbe un errore quando invertito, in quanto ^[.^crea un verbo non valido. Quindi, dobbiamo usare i commenti; ma NB.è così lungo :( Fortunatamente, entrambi finiscono con ., quindi & ldots; c'è quello.

Logaritmo:

^.NB.BN^

esponenziale:

^NB.BN.^

Puoi inserirli per te online !

Java 8, 198 182 30 byte

d->Math.log(d)//)d(pxe.htaM<-d

Provalo online.

e invertito:

d->Math.exp(d)//)d(gol.htaM<-d

Provalo online.

Usa il trucco dei commenti ( //) con built-in per Math.loge Math.exp.

Incantesimi runici , 9 byte

i'lA@Ae'i

Provalo online!

Un programma empio e poco interessante. @assicura la chiusura del punto di ingresso implicito a sinistra, tutto ciò che segue è non eseguito. Ho provato davvero a riutilizzare le istruzioni 'o A, ma senza risultati, anche con programmi di dimensioni maggiori. Il punto di ingresso esplicito richiesto per i programmi multilinea lo preclude essenzialmente.