31
\$\begingroup\$

Wouldn't it be neat if programming functions could be inverted, just like the mathematical function they implement?

Write a function (or program) that takes one input x in any form, that outputs ln(x).
When the bytes of the program are reordered/reversed so that the first byte now is the last byte, it should take one input x in any form and output e^x instead.

  • Your answer must have at least 3 correct significant figures.
  • Approximations are fine, as long as they have at least 3 correct significant figures.
  • Your code must be in the same programming language both forwards and backwards.

Let's say this program implements ln(x):

abc你好

Then this program has to implement e^x:

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

Gold star if you use a language without float support.

This is a weird form of code-golf, so the shortest program wins.

\$\endgroup\$
  • 4
    \$\begingroup\$ "Wouldn't it be neat if programming functions could be inverted, just like the mathematical function they implement?" Some languages (e.g. J and Mathematica) can actually do this for some functions. \$\endgroup\$ – Martin Ender Feb 6 '16 at 11:29
  • \$\begingroup\$ Additionally, K2 could approximate an inverse for an arbitrary monadic pure function via its "function inverse" overload of dyadic and triadic ?, which used the secant method. \$\endgroup\$ – JohnE Feb 6 '16 at 15:19
  • 1
    \$\begingroup\$ "at least 3 correct significant figures" - over what range? \$\endgroup\$ – TLW Feb 6 '16 at 16:48
  • 4
    \$\begingroup\$ I realize it's far too late now, but I think this would have been a really nice challenge had comments been disallowed. \$\endgroup\$ – Alex A. Feb 6 '16 at 21:45
  • \$\begingroup\$ I actually thought of that when I came up with this challenge @AlexA. but forgot about it while writing the post :P Also that would've made "normal" languages like java, c++ etc basically impossible. \$\endgroup\$ – Filip Haglund Feb 7 '16 at 12:59

19 Answers 19

75
\$\begingroup\$

Haskell, 11 bytes

f=log
pxe=f

and in reverse order:

f=exp
gol=f

This works without the "comment" trick. Instead each version defines an additional, but unused function (pxe/ gol).

\$\endgroup\$
  • 49
    \$\begingroup\$ +1 for gol=f. \$\endgroup\$ – Leif Willerts Feb 6 '16 at 13:22
  • 2
    \$\begingroup\$ This is also a valid solution in Julia. \$\endgroup\$ – Rainer P. Feb 6 '16 at 23:28
44
\$\begingroup\$

APL, 3 bytes

*⊣⍟

This is a function train. Monadic * returns e^x, monadic returns ln(x). is a dyadic function that returns its left argument. Thus, *⊣⍟ is equivalent to just *, and the reverse ⍟⊣* is equivalent to just .

\$\endgroup\$
22
\$\begingroup\$

Jelly, 5 4 bytes

Yay, my first Jelly answer. :) Input is via command-line argument.

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.

\$\endgroup\$
9
\$\begingroup\$

Javascript, 18 bytes

Math.log//pxe.htaM
\$\endgroup\$
  • \$\begingroup\$ Don't you need a return() or console.log() around it? \$\endgroup\$ – OldBunny2800 Feb 6 '16 at 20:32
  • 2
    \$\begingroup\$ @OldBunny2800 It evaluates to a function, which should be permissible. \$\endgroup\$ – Neil Feb 6 '16 at 20:50
  • 5
    \$\begingroup\$ Math.ln||pxe.htaM will probably also work. \$\endgroup\$ – SuperJedi224 Feb 7 '16 at 12:35
  • \$\begingroup\$ @SuperJedi224 Thanks, that helped me spot the error in my answer! \$\endgroup\$ – Neil Feb 7 '16 at 12:50
  • \$\begingroup\$ @Neil I hadn't even noticed that \$\endgroup\$ – SuperJedi224 Feb 7 '16 at 18:09
7
\$\begingroup\$

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!

\$\endgroup\$
5
\$\begingroup\$

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.

\$\endgroup\$
  • 1
    \$\begingroup\$ Same answer works for R \$\endgroup\$ – Dason Feb 6 '16 at 20:30
5
\$\begingroup\$

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
\$\endgroup\$
4
\$\begingroup\$

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
\$\endgroup\$
  • \$\begingroup\$ You can shave 10 characters off by using __import__("math"). instead of \$\endgroup\$ – TLW Feb 6 '16 at 16:43
3
\$\begingroup\$

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.

\$\endgroup\$
3
\$\begingroup\$

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

\$\endgroup\$
2
\$\begingroup\$

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!

\$\endgroup\$
2
\$\begingroup\$

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.
\$\endgroup\$
1
\$\begingroup\$

Matl, 5 bytes

Yl%eZ

Yl: log Ze: exp %: comment

\$\endgroup\$
1
\$\begingroup\$

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

\$\endgroup\$
1
\$\begingroup\$

𝔼𝕊𝕄𝕚𝕟, 8 chars / 10 bytes

МŬï//ïŦМ

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

Just 2 builtins separated by a comment.

\$\endgroup\$
1
\$\begingroup\$

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!

\$\endgroup\$
1
\$\begingroup\$

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!

\$\endgroup\$
0
\$\begingroup\$

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.

\$\endgroup\$
0
\$\begingroup\$

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.

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.