프로그래밍 함수가 구현하는 수학 함수와 같이 프로그래밍 함수를 뒤집을 수 있다면 깔끔하지 않습니까?

x어떤 형태로든 하나의 입력을 받아 출력 하는 함수 (또는 프로그램)를 작성하십시오 ln(x).
프로그램의 바이트가 재정렬 / 역순으로 바뀌면 첫 번째 바이트가 이제 마지막 바이트가되고, 대신 x어떤 형태로든 하나의 입력 을 받아서 출력해야 e^x합니다.

• 귀하의 답변에는 최소 3 개의 정확한 유효 숫자가 있어야합니다.
• 최소 3 개의 정확한 유효 숫자가있는 한 근사값은 양호합니다.
• 코드는 앞뒤로 동일한 프로그래밍 언어로되어 있어야합니다.

이 프로그램이 다음을 구현한다고 가정 해 봅시다 ln(x).

abc你好

그런 다음이 프로그램은 다음을 구현해야합니다 e^x.

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

플로트 지원없이 언어를 사용하는 경우 금색 별표.

이것은 이상한 형태의 코드 골프이므로 가장 짧은 프로그램이 승리합니다.

하스켈, 11 바이트

f=log
pxe=f

그리고 역순으로 :

f=exp
gol=f

이것은 "코멘트"트릭없이 작동합니다. 대신 각 버전은 사용되지만 사용되지 않는 추가 기능 ( pxe/ gol)을 정의합니다 .

APL, 3 바이트

*⊣⍟

이것은 기능 기차입니다. Monadic * 는 반환 e^x하고 monadic ⍟는 반환합니다 ln(x). ⊣왼쪽 인수를 반환하는 2 차원 함수입니다. 따라서 *⊣⍟just *와 ⍟⊣*같고 그 반대 는 just와 같습니다 ⍟.

젤리, 5 4 bytes

예, 첫 번째 젤리 답변입니다. :) 입력은 명령 행 인수를 통해 이루어집니다.

Jelly has its own code page so each character is one byte.

eÆÆl

Try it online!

Reversed:

lÆÆe

Try it online!

Explanation

The Æ on its own is an unrecognised token, so it acts the same as a linefeed. That means in either case the main link is only Æl or Æe which is the 2-character built-in for exp() or ln() and is by default performed on the first command-line argument.

Javascript, 18 bytes

Math.log//pxe.htaM

Seriously, 5 bytes

,_.e,

Input, ln, output, then exp on an empty stack (does nothing), and input (does nothing since input is exhausted). Try it online!

Reversed:

,e._,

Try it online!

Julia, 7 bytes

log#pxe

This is an anonymous function. Assign it to a variable to call it. Evaluates to builtins log or exp plus a comment.

Mathematica, 19 bytes

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

Reversed:

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

This was interesting to golf! Mathematica has no line comments / implicit string endings, so I couldn't take the simple route. Instead, I used the fact that 0 + x == x, 0 x == 0, and that 1 x == x, no matter what x is! Testing:

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 bytes

io: stdin/stdout

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

inverse:

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

CJam, 11 bytes

rdmle#eemdr

Test it here.

Reversed:

rdmee#elmdr

Test it here.

Basically the same comment-trick as the OP's Python answer. e# starts a comment. rd reads the input and ml or me computes the logarithm or exponential.

Brachylog, 3 bytes

*₁≡

Try it online!

Initially, I had hoped to use ~*, but although *~ computes e^x and successfully ignores the trailing tilde, ~* fails for all integer inputs and hits a float overflow on most non-integer inputs.

Forwards:

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

Backwards:

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

This uses the identity predicate because, although trailing tildes are tolerated, leading subscripts are not. (If they were, the Brachylog answer would be *₁ alone, which is just the normal builtin for natural log.)

Vitsy, 5 bytes

This is a program that exits on an error.

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

This program exits on an error with ln(input) on the stack.

Try it online! (note that I have put N to have visible output)

Then it's inverse:

Er^LE

This program exits on an error with e^(input) on the stack.

Try it online!

Fuzzy Octo Guacamole, 7 bytes

_{non-competing, FOG is newer than the challenge}

EZO@pZE

This is the equivalent of a function in FOG. It assumes the input is on the stack. This can be assigned to a function by the code "EZO@pZE""f"o, where f is any single-char name you want to assign. Then use it like any other command. Example: "EZO@pZE"'f'o^f.

Explanation:

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.

Reversed:

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 bytes

Yl%eZ

Yl: log Ze: exp %: comment

Pyth, 12 bytes

Finds ln(input())

.lQ) " Q1n.^

Finds e^input()

^.n1Q " )Ql.

Spaces stop implicit printing of strings, each version calculates it then creates a string with the remaining characters.

ln(x) mode here

e^x mode here

𝔼𝕊𝕄𝕚𝕟, 8 chars / 10 bytes

МŬï//ïŦМ

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

Just 2 builtins separated by a comment.

Jolf, 9 bytes

Program 1: exp of input

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

Program 2: ln of input

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

Bonus points for being a case-insensitive palindrome? Try it here!

J, 8 bytes

The natural logarithm is ^., and exponential ^. The problem is, . can only modify a valid verb, otherwise, a spelling error will occur. Thus, we can't use the left argument trick in the APL answer, becuase ^.[^ would cause an error when reversed, as ^[.^ creates an invalid verb. So, we must use comments; but NB. is so long :( Fortunately, they both end with ., so&ldots; there's that.

Logarithm:

^.NB.BN^

Exponential:

^NB.BN.^

You can enter them for yourself online!

Java 8, 198 182 30 bytes

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

Try it online.

and reversed:

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

Try it online.

Uses the comment trick (//) with built-ins for Math.log and Math.exp.

Runic Enchantments, 9 bytes

i'lA@Ae'i

Try it online!

An ungodly uninteresting program. @ insures termination of the implied entry point at the left, everything after is unexecuted. I tried really hard to re-use the ' or A instructions, but to no avail, even at larger program sizes. The required explicit entry point for multi-line programs essentially precludes it.