24
\$\begingroup\$

Challenge

Given a (floating-point/decimal) number, return its reciprocal, i.e. 1 divided by the number. The output must be a floating-point/decimal number, not just an integer.

Detailed specification

  • You must receive input in the form of a floating-point/decimal number...
    • ...which has at least 4 significant digits of precision (if needed).
    • More is better, but does not count in the score.
  • You must output, with any acceptable output method...
    • ...the reciprocal of the number.
    • This can be defined as 1/x, x⁻¹.
    • You must output with at least 4 significant digits of precision (if needed).

Input will be positive or negative, with absolute value in the range [0.0001, 9999] inclusive. You will never be given more than 4 digits past the decimal point, nor more than 4 starting from the first non-zero digit. Output needs to be accurate up to the 4th digit from the first non-zero one.

(Thanks @MartinEnder)

Here are some sample inputs:

0.5134
0.5
2
2.0
0.2
51.2
113.7
1.337
-2.533
-244.1
-0.1
-5

Note that you will never be given inputs which have above 4 digits of precision.

Here is a sample function in Ruby:

def reciprocal(i)
    return 1.0 / i
end

Rules

  • All accepted forms of output are allowed
  • Standard loopholes banned
  • This is , shortest answer in bytes wins, but will not be selected.

Clarifications

  • You will never receive the input 0.

Bounties

This challenge is obviously trivial in most languages, but it can offer a fun challenge in more esoteric and unusual languages, so some users are willing to award points for doing this in unusually difficult languages.

  • @DJMcMayhem will award a +150 points bounty to the shortest brain-flak answer, since brain-flak is notoriously difficult for floating-point numbers

  • @L3viathan will award a +150 points bounty to the shortest OIL answer. OIL has no native floating point type, nor does it have division.

  • @Riley will award a +100 points bounty to the shortest sed answer.

  • @EriktheOutgolfer will award a +100 points bounty to the shortest Sesos answer. Division in brainfuck derivatives such as Sesos is very difficult, let alone floating-point division.

  • I (@Mendeleev) will award a bounty of +100 points to the shortest Retina answer.

If there's a language you think would be fun to see an answer in, and you're willing to pay the rep, feel free to add your name into this list (sorted by bounty amount)

Leaderboard

Here is a Stack Snippet to generate an overview of winners by language.

To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:

# Language Name, N bytes

where N is the size of your submission. If you improve your score, you can keep old scores in the headline, by striking them through. For instance:

# Ruby, <s>104</s> <s>101</s> 96 bytes

If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the last number in the header:

# Perl, 43 + 2 (-p flag) = 45 bytes

You can also make the language name a link which will then show up in the leaderboard snippet:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

var QUESTION_ID=114544,OVERRIDE_USER=62393;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={};e.forEach(function(e){var o=e.language;/<a/.test(o)&&(o=jQuery(o).text().toLowerCase()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link,uniq:o}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.uniq>s.uniq?1:e.uniq<s.uniq?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
body{text-align:left!important}#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=617d0685f6f3"> <div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr></tbody> </table>

\$\endgroup\$
  • 23
    \$\begingroup\$ Please stop upvoting trivial answers \$\endgroup\$ – Cows quack Mar 30 '17 at 18:04
  • 14
    \$\begingroup\$ @KritixiLithos People can vote as they see fit. Given the simplicity of this challenge, most, if not all answers are something like 1/x. \$\endgroup\$ – NoOneIsHere Mar 30 '17 at 18:08
  • 9
    \$\begingroup\$ This isn't objectively specified without very clear detail on accuracy and precision. \$\endgroup\$ – Peter Taylor Mar 30 '17 at 18:10
  • 6
    \$\begingroup\$ What about accuracy? Presumably you want 4 sf of accuracy too, but then there's the issue of rounding. Floating point questions are hard to get right and very worth sandboxing. \$\endgroup\$ – Peter Taylor Mar 30 '17 at 20:27
  • 10
    \$\begingroup\$ -1, this is a poor challenge because using a builtin is the ONLY way to do it and know you have satisfied the "specification". If you have a standard floating point implementation, you can use it and tell yourself this is standard floating point, it must be ok. If you have to implement it yourself, there is no specification so you can't sensibly try to golf it. \$\endgroup\$ – feersum Mar 31 '17 at 5:12

88 Answers 88

57
+250
\$\begingroup\$

Brain-Flak, 772 536 530 482 480 + 1 = 481 bytes

Since Brain-Flak does not support floating point numbers I had to use the -c flag in order input and output with strings, hence the +1.

(({})[((((()()()()())){}{})){}{}]){((<{}>))}{}({}<{({}[((((()()()){}())()){}{}){}]<>)<>}<>{({}<>[()()])<>}{}([]<{({}<>[()()])<>}>)<>([[]](())){({}()<((((((({}<(((({})({})){}{}){}{})>)({})){}{}){})({})){}{}){})>)}{}({}(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><{}{}>){({}<((()()()()()){})>(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><([{}()]{})>)}{}<>({}()<<>([]){{}({}<>)<>([])}{}<>>){({}[()]<({}<>((((()()()){}){}){}){})<>>)}{}([()()])([]){{}({}<>((((()()()){}){}){}){})<>([])}<>>)

Try it online!

Explanation

The first thing we need to take care of is the negative case. Since the reciprocal of a negative number is always negative we can simply hold on to the negative sign until the end. We start by making a copy of the top of the stack and subtracting 45 (the ASCII value of -) from it. If this is one we put a zero on the top of the stack, if not we do nothing. Then the we pick up the top of the stack to be put down at the end of the program. If the input started with a - this is still a - however if it is not we end up picking up that zero we placed.

(({})[((((()()()()())){}{})){}{}]){((<{}>))}{}
({}<

Now that that is out of the way we need to convert the ASCII realizations of each digit into there actual values (0-9). We also are going to remove the decimal point . to make computations easier. Since we need to know where the decimal point started when we reinsert it later we store a number to keep track of how many digits were in front of the . on the offstack.

Here is how the code does that:

We start by subtracting 46 (the ASCII value of .) from each element on the stack (simultaneously moving them all onto the offstack). This will make each digit two more than should be but will make the . exactly zero.

{({}[((((()()()){}())()){}{}){}]<>)<>}<>

Now we move everything onto the left stack until we hit a zero (subtracting two from each digit while we go):

{({}<>[()()])<>}{}

We record the stack height

([]<

Move everything else onto the left stack (once again subtracting the last two from every digit as we move them)

  {({}<>[()()])<>}

And put the stack height we recorded down

>)

Now we want to combine the digits into a single base 10 number. We also want to make a power of 10 with twice the digits as that number for use in the calculation.

We start by setting up a 1 on top of the stack to make the power of 10 and pushing the stack height minus one to the on stack for the use of looping.

<>([][(())])

Now we loop the stack height minus 1 times,

{
 ({}[()]<

Each time we multiply the top element by 100 and underneath it multiply the next element by 10 and add that to the number below.

 ((((((({}<(((({})({})){}{}){}{})>)({})){}{}){})({})){}{}){})

We end our loop

 >)
}{}

Now we are finally done with the set up and can begin the actual calculation.

({}(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><{}{}>)

That was it...

We divide the power of 10 by the modified version of the input using 0 ''s integer division algorithm as found on the wiki. This simulates the division of 1 by the input the only way Brain-Flak knows how.

Lastly we have to format our output into the appropriate ASCII.

Now that we have found ne we need to take out the e. The first step to this is converting it to a list of digits. This code is a modified version of 0 ''s divmod algorithm.

{({}<((()()()()()){})>(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><([{}()]{})>)}{}

Now we take the number and add the decimal point back where it belongs. Just thinking about this part of the code brings back headaches so for now I will leave it as an exercise for the reader to figure out how and why it works.

<>({}()<<>([]){{}({}<>)<>([])}{}<>>){({}[()]<({}<>((((()()()){}){}){}){})<>>)}{}([()()])([]){{}({}<>((((()()()){}){}){}){})<>([])}<>

Put the negative sign down or a null character if there is no negative sign.

>)
\$\endgroup\$
  • 18
    \$\begingroup\$ +1, I love how much of this explanation is I don't know what this does or why I need it, but I promise it's important. \$\endgroup\$ – DJMcMayhem Mar 31 '17 at 4:31
  • \$\begingroup\$ This doesn't seem to work for input 1.0 or 10 \$\endgroup\$ – Poke Mar 31 '17 at 13:11
  • 3
    \$\begingroup\$ Can anybody else read this code? Is Brain-Flak meant to be write-only? \$\endgroup\$ – Eric Duminil Mar 31 '17 at 21:54
  • 1
    \$\begingroup\$ @EricDuminil Brain-flak is an esoteric language so it is very hard to read at a glance. People who are well versed in Brain-Flak can read it to some degree of fluency. But this task in incredibly complex and Brain-Flak is not really designed with readability in mind. \$\endgroup\$ – Sriotchilism O'Zaic Mar 31 '17 at 22:43
  • \$\begingroup\$ What is the +3 in the byte count for? \$\endgroup\$ – caird coinheringaahing Apr 1 '17 at 20:24
47
\$\begingroup\$

Python 2, 10 bytes

1..__div__

Try it online!

\$\endgroup\$
36
+100
\$\begingroup\$

Retina, 99 91 bytes

1`\.|$
8$*;
+`;(;*)(\d)
$2$1
\d+
$*1,10000000$*
(1+),(\1)+1*
$#2
+`(\d)(;+);
$2$1
1`;
.
;
0

Try it online!

Woohoo, sub-100! This is surprisingly efficient, considering that it creates (and then matches against) a string with more than 107 characters at one point. I'm sure it's not optimal yet, but I'm quite happy with the score at the moment.

Results with absolute value less than 1 will be printed without the leading zero, e.g. .123 or -.456.

Explanation

The basic idea is to using integer division (because that's fairly easy with regex and unary arithmetic). To ensure that we get a sufficient number of significant digits, we divide the input into 107. That way, any input up to 9999 still results in a 4-digit number. Effectively, that means we're multiplying the result by 107 so we need to keep track of that when later reinsert the decimal point.

1`\.|$
8$*;

We start by replacing the decimal point, or the end of the string if there is no decimal point with 8 semicolons. The first one of them is essentially the decimal point itself (but I'm using semicolons because they don't need to be escaped), the other 7 indicate that value has been multiplied by 107 (this isn't the case yet, but we know we will do that later).

+`;(;*)(\d)
$2$1

We first turn the input into an integer. As long as there are still digits after the decimal point, we move one digit to the front and remove one of the semicolons. This is because moving the decimal point right multiplies the input by 10, and therefore divides the result by 10. Due to the input restrictions, we know this will happen at most four times, so there are always enough semicolons to be removed.

\d+
$*1,10000000$*

Now that the input is an integer, we convert it to unary and append 107 1s (separated by a ,).

(1+),(\1)+1*
$#2

We divide the integer into 107 by counting how many backreferences to it fit ($#2). This is standard unary integer division a,b --> b/a. Now we just need to correct the position of the decimal point.

+`(\d)(;+);
$2$1

This is basically the inverse of the second stage. If we still have more than one semicolon, that means we still need to divide the result by 10. We do this by moving the semicolons one position to the left and dropping one semicolon until we either reach the left end of the number, or we're left with only one semicolon (which is the decimal point itself).

1`;
.

Now is a good time to turn the first (and possibly only) ; back into ..

;
0

If there are still semicolons left, we've reached the left end of the number, so dividing by 10 again will insert zeros behind the decimal point. This is easily done by replacing each remaining ; with a 0, since they're immediately after the decimal point anyway.

\$\endgroup\$
  • \$\begingroup\$ A very short algorithm, +1. I bet the sed translation would be the shortest as well. Can you replace \B; with ^; to save 1 byte? \$\endgroup\$ – seshoumara Mar 31 '17 at 16:11
  • \$\begingroup\$ @seshoumara No because of negative inputs, where there's a - in front of the ;. \$\endgroup\$ – Martin Ender Mar 31 '17 at 16:17
31
\$\begingroup\$

yup, 5 bytes

|0~-e

Try it online! This takes input from the top of the stack and leaves output on the top of the stack. The TIO link takes input from command line arguments, which is only capable of taking integer input.

Explanation

yup only has a few operators. The ones used in this answer are ln(x) (represented by |), 0() (constant, nilary function returning 0), (subtraction), and exp(x) (represented by e). ~ switches the top two members on the stack.

|0~-e     top of the stack: n    stack: [n]
|         pop n, push ln(n)      stack: [ln(n)]
 0        push 0                 stack: [ln(n), 0]
  ~       swap                   stack: [0, ln(n)]
   -      subtract               stack: [-ln(n)]
    e     exp                    stack: [exp(-ln(n))]

This uses the identity

x/y = e^(ln(x)-ln(y))

which implies that

\$\endgroup\$
  • 3
    \$\begingroup\$ I'd love to improve my content, so if you'd explain your downvote, that would really help and I would appreciate that :) \$\endgroup\$ – Conor O'Brien Apr 2 '17 at 19:58
20
\$\begingroup\$

LOLCODE, 63, 56 bytes

HOW DUZ I r YR n 
VISIBLE QUOSHUNT OF 1 AN n
IF U SAY SO

7 bytes saved thanks to @devRicher!

This defines a function 'r', which can be called with:

r 5.0

or any other NUMBAR.

Try it online!

\$\endgroup\$
  • \$\begingroup\$ I guess you could use ITZ A NUMBAR in the assignment of I? \$\endgroup\$ – ckjbgames Mar 31 '17 at 0:01
  • 1
    \$\begingroup\$ HOW DUZ I r YR n VISIBLE QUOSHUNT OF 1 AN n IF U SAY SO (add newlines) is a few bytes shorter and can be called with r d, where d is any NUMBAR. \$\endgroup\$ – devRicher Mar 31 '17 at 7:19
  • \$\begingroup\$ You can use IZ instead of DUZ because of interpreter rule \$\endgroup\$ – OldBunny2800 Apr 2 '17 at 22:29
17
\$\begingroup\$

sed, 575 + 1 (-r flag) = 723 718 594 588 576 bytes

s/$/\n0000000000/
tb
:b
s/^0+//
s/\.(.)(.*\n)/\1.\2/
tD
bF
:D
s/.*/&&&&&&&&&&/2m
tb
:F
s/\.//
h
s/\n.+//
s/-//
:
s/\b9/;8/
s/\b8/;7/
s/\b7/;6/
s/\b6/;5/
s/\b5/;4/
s/\b4/;3/
s/\b3/;2/
s/\b2/;1/
s/\b1/;0/
s/\b0//
/[^;]/s/;/&&&&&&&&&&/g
t
y/;/0/
x
G
s/[^-]+(\n0+)\n(0+)/\2\1/
s/\n0+/&&\n./
:a
s/^(-?)(0*)0\n0\2(.*)$/\10\2\n\30/
ta
s/.*/&&&&&&&&&&/2m
s/\n0(0*\n\..*)$/\n\1 x/
Td
s/x//
ta
:d
s/[^-]+\n//
s/-(.+)/\1-/
s/\n//
:x
s/^0{10}/0x/
s/(.)0{10}/0\1/
tx
s/00/2/g
s/22/4/g
y/0/1/
s/41/5/g
s/21/3/g
s/45/9/g
s/44/8/g
s/43/7/g
s/42/6/g
y/ /0/
s/([1-9])0/\1/g
y/x/0/
s/(.+)-/-\1/

Try it online!

Note: floats for which the absolute value is less than 1 will have to be written without a leading 0 like .5 instead of 0.5. Also the number of decimal places is equal to enter image description here, where n is the number of decimal places in the number (so giving 13.0 as input will give more decimal places than giving 13 as input)

This is my first sed submission on PPCG. Ideas for the decimal-to-unary conversion were taken from this amazing answer. Thanks to @seshoumara for guiding me through sed!

This code performs repeated long division to get the result. The division only takes ~150 bytes. The unary-decimal conversions take the most bytes, and a few other bytes go to supporting negative numbers and floating-point inputs

Explanation

Explanation on TIO

#Append 10 0's. This is the dividend, I think
s/$/\n0000000000/
tb

#This branch moves the decimal point 1 to the right
:b
#Remove leading 0's (such as from numbers like .05 => 0.5)
s/^0+//
#Move the decimal point 1 to the right
s/\.(.)(.*\n)/\1.\2/
#If the above has resulted in a successful substitution, go to branch D
tD
#else go to branch F
bF

#Multiply the dividend by 10; also keeps the mood positive
:D
s/.*/&&&&&&&&&&/2m
#Then go back to branch b
tb

:F
#Remove decimal point since it is all the way to the right now
s/\.//
h
#Remove "unnecessary" things
s/\n.+//
s/-//

#Convert to unary
:
s/\b9/;8/
s/\b8/;7/
s/\b7/;6/
s/\b6/;5/
s/\b5/;4/
s/\b4/;3/
s/\b3/;2/
s/\b2/;1/
s/\b1/;0/
s/\b0//
/[^;]/s/;/&&&&&&&&&&/g
t
y/;/0/

#Append the unary number to the pattern space
x
G
s/[^-]+(\n0+)\n(0+)/\2\1/

### END Decimal-to-Unary conversion
### BEGIN Division

#Performs Long Division
#Format looks something like this (can't remember): divisor\ndividend\ncount\nresult
#Count controls how many decimal places the answer should have; dp => 10^numDigits(n)
#Removes divisor from dividend and then add a 0 to result
#Once the dividend becomes too small, append a space to result and remove a zero from count
#Rinse and repeat
s/\n0+/&&\n./
:a
s/^(-?)(0*)0\n0\2(.*)$/\10\2\n\30/
ta
s/.*/&&&&&&&&&&/2m
s/\n0(0*\n\..*)$/\n\1 x/
Td
s/x//
ta

### END DIVISION
### BEGIN Unary-to-Decimal conversion

:d
s/[^-]+\n//
s/-(.+)/\1-/
s/\n//

#"carry over"-ing; .0000000000 => 0.
:x
s/^0{10}/0x/
s/(.)0{10}/0\1/
tx

#Convert each pair of unary 0s to their decimal counterparts
s/00/2/g
s/22/4/g
y/0/1/
s/41/5/g
s/21/3/g
s/45/9/g
s/44/8/g
s/43/7/g
s/42/6/g
y/ /0/
s/([1-9])0/\1/g
y/x/0/
s/(.+)-/-\1/

Edits

  • s:s/(.)/(.)/g:y/\1/\2/g:g to save 1 byte at each substitution (5 in total)
  • Saved a ton of bytes by looking at a nice decimal-to-unary converter on "Tips for golfing in sed"
  • I changed around some substitutions revolved around taking care of the minus sign to save 6 bytes.
  • Used \n instead of ; as the separator, then I was able to shorten the "multiply by 10" substitutions to save 12 bytes (thanks to @Riley and @seshoumara for showing me this)
\$\endgroup\$
  • \$\begingroup\$ You made it! +1 \$\endgroup\$ – seshoumara Apr 1 '17 at 18:51
16
\$\begingroup\$

JSFuck, 3320 bytes

JSFuck is an esoteric and educational programming style based on the atomic parts of JavaScript. It uses only six different characters ()[]+! to write and execute code.

[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+(+!+[]+(!+[]+[])[!+[]+!+[]+!+[]]+[+!+[]]+[+[]]+[+[]])+[])[!+[]+!+[]]+[+!+[]]+(![]+[+![]])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+[+[]]]+(!![]+[])[+[]]+(+(+!+[]+[+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+[+!+[]])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]+!+[]])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]

Try it online!

alert(
  /* empty array       */ []
  /* ['fill']          */ [(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]
  /* ['constructor']   */ [([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]
  /* ('return+1/this') */ ((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+(+!+[]+(!+[]+[])[!+[]+!+[]+!+[]]+[+!+[]]+[+[]]+[+[]])+[])[!+[]+!+[]]+[+!+[]]+(![]+[+![]])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+[+[]]]+(!![]+[])[+[]]+(+(+!+[]+[+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+[+!+[]])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]+!+[]])
  /* ['call']          */ [([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]
  (prompt())
)

\$\endgroup\$
  • 1
    \$\begingroup\$ This language-subset is hard to golf by hand but easy to automate (as a conversion from ordinary JavaScript). \$\endgroup\$ – wizzwizz4 Mar 30 '17 at 20:41
  • \$\begingroup\$ True, but the character count of the source doesn't directly relate to the output length. \$\endgroup\$ – powelles Mar 30 '17 at 20:49
  • 4
    \$\begingroup\$ I was trying to convey that, if you have a source, it's easier to automate the golfy conversion than do a golfy version by hand. \$\endgroup\$ – wizzwizz4 Mar 30 '17 at 20:52
  • 4
    \$\begingroup\$ @wizzwizz4 Even when it's automated, it's also tricky to find out which "core" JavaScript code actually produces the shortest program. In this particular case, return 1/this would be about 76 bytes longer than return+1/this. \$\endgroup\$ – ETHproductions Mar 31 '17 at 0:43
  • \$\begingroup\$ [].fill.constructor('alert(1/prompt())') 2929 bytes paste.ubuntu.com/p/5vGTqw4TQQ add () 2931 \$\endgroup\$ – l4m2 Mar 18 '18 at 15:55
16
\$\begingroup\$

OIL, 1428 1420 bytes

Oh well. I thought I might as well try it, and I did in the end succeed. There's just one downside: It takes almost as long to run as it took to write.

The program is separated into multiple files, which have all 1-byte-filenames (and count for one additional byte in my byte calculation). Some of the files are part of the example files of the OIL language, but there's no real way to consistently call them (there's no search path or anything like that in OIL yet, so I don't consider them a standard library), but that also means that (at the time of posting) some of the files are more verbose than neccessary, but usually only by a few bytes.

The computations are accurate to 4 digits of precision, but calculating even a simple reciprocal (such as the input 3) takes a really long time (over 5 minutes) to complete. For testing purposes, I've also made a minor variant that's accurate to 2 digits, which takes only a few seconds to run, in order to prove that it does work.

I'm sorry for the huge answer, I wish I could use some kind of spoiler tag. I could also put the bulk of it on gist.github.com or something similar, if desired.

Here we go: main, 217 bytes (file name doesn't count for bytes):

5
1
1
4
-
14
a
5
Y
10
5
8
14
29
12
1
97
1
97
24
9
24
13
99

1
1
4
31
1
35

14
a
32
.
10
32
8
50
41
1
53
2
14
b
1
1
6
72
14
c
5
0000
14
d
6
6
10
74
5
63
68
1
6
1
6
72
14
b
1
5
1
77
0
14
e
1
0
14
f
1
1
1
31
0
14
b
0
0
4

a (checks if a given string is in a given other string), 74+1 = 75 bytes:

5
0
5
1
14
g
2
0
10
2
30
24
13
10
1
31
27
18
14
h
1
1
6
4
4
30
3
4
29
N
Y

b (joins two given strings), 20+1=21 bytes:

5
0
5
1
13
0
2
0
4
0

c (given a symbol, splits the given string at its first occurrence), 143+1=144 bytes (this one is obviously still golfable):

5
0
5
83
12
83
83





10
84
0
21
17
8
13
6
12
1
13
1
1
5
2
14
i
45
1
1
83
1
1
45
2
14
i
57
1
9
45
13
84

1



8
13
1
13
56
13
13

2
4
1
11
4
2

d (given a string, gets the first 4 characters), 22+1=23 bytes:

5
0
12
0
20
13
21
4

4

e (high-level division (but with zero division danger)), 138+1=139 bytes:

5
0
5
1
.
.
1
1
6
14
j
0
0
1
0
4
10
11
1
58
21
14
b
4
4
1
1
15
14
k
0
15
1
6
1
14
j
0
0
1
0
5
14
b
4
4
9
8
10
8
11
58
53
10
11
1
58
25
4
4

f (moves a dot 4 positions to the right; "divides" by 10000), 146+1=147 bytes:

5
.
12
0
100
10
101
1
14
10
8
6
6
5
1
6
34
1
6
33
8
33
1
6
37
8
37
10
55
3
48
32
1
102
101
1
1
102
9
55
8
34
8
33
8
37
6
27
1
100
53
13
101


4

4

g (checks if a string starts with a given character), 113+1=114 bytes:

5
0
5
1
12
0
100
12
1
200
1
6
2
1
9
3
8
2
8
3
9
100
9
200
1
2
31
1
3
32
10


39
35
4
38
3
N
10
100
5
44
16
4
46
Y

h (returns everything but the first character of a given string), 41+1=42 bytes:

5
0
12
0
100
9
100
1
100
12
13
102

0
4
0

i (subtracts two numbers), 34+1=35 bytes:

5
0
5
1
10
16
1
14
9
9
0
9
1
6
4
0

j (low-level division that doesn't work in all cases), 134+1=135 bytes:

5
0
5
2
10
2
19
52
9
1
2
3
10
23
2
28
17
10
23
0
35
22
9
0
9
2
6
12
8
1
1
3
2
6
17
10
23
2
46
40
9
2
9
3
6
35
4
1
11
4
3
3
4
19
11
4
0

k (multiplication), 158+1=159 bytes:

5
0
5
1
8
0
9
0
8
1
9
1
1
5
2
12
0
68
10
69
66
23
29
8
7
14
l
0
0
12
1
68
10
69
66
37
43
8
7
14
l
1
1
10
0
5
56
48
9
0
14
m
2
1
6
43
10
7
3
61
63
4
66
4
2
3
-

l (return absolute value), 58+1=59 bytes:

5
-
12
0
24
10
25
1
13
10
4
0
3
9
24
1
24
20
13
26

0
6
10

m (addition), 109+1=110 bytes:

5
0
5
1
8
0
9
0
8
1
9
1
12
1
46
10
47
45
31
20
10
1
43
42
25
9
1
8
0
6
20
10
1
43
42
36
8
1
9
0
6
31
4
0
3
-
\$\endgroup\$
15
\$\begingroup\$

J, 1 byte

%

% is a function giving the reciprocal of its input. You can run it like this

   % 2
0.5
\$\endgroup\$
15
\$\begingroup\$

Taxi, 467 bytes

Go to Starchild Numerology:w 1 l 2 r 1 l 1 l 2 l.1 is waiting at Starchild Numerology.Pickup a passenger going to Divide and Conquer.Go to Post Office:w 1 r 2 r 1 r 1 l.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:s 1 l 1 r.Pickup a passenger going to Divide and Conquer.Go to Divide and Conquer:e 4 l.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:e 1 r.Pickup a passenger going to Post Office.Go to Post Office:e 1 l 1 r.

Try it online!

Ungolfed:

Go to Starchild Numerology:west 1 left, 2 right, 1 left, 1 left, 2 left.
1 is waiting at Starchild Numerology.
Pickup a passenger going to Divide and Conquer.
Go to Post Office:west 1 right, 2 right, 1 right, 1 left.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery:south 1 left, 1 right.
Pickup a passenger going to Divide and Conquer.
Go to Divide and Conquer:east 4 left.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery:east 1 right.
Pickup a passenger going to Post Office.
Go to Post Office:east 1 left, 1 right.
\$\endgroup\$
  • \$\begingroup\$ Would you mind adding a non-golfed version for easier readability? \$\endgroup\$ – Kevin Cruijssen Mar 31 '17 at 7:07
  • \$\begingroup\$ @KevinCruijssen Sure, it's just that when I answered this it was late night. \$\endgroup\$ – Erik the Outgolfer Mar 31 '17 at 7:08
15
\$\begingroup\$

Vim, 10 8 bytes/keystrokes

C<C-r>=1/<C-r>"

Since V is backwards compatible, you may Try it online!

\$\endgroup\$
  • \$\begingroup\$ @NonlinearFruit No, it didn't. Turns out, I was overthinking it, and supporting that is actually less bytes, not more. Thanks! \$\endgroup\$ – DJMcMayhem Mar 30 '17 at 18:29
  • \$\begingroup\$ This is really interesting. I wonder if it's possible to do the same thing without using the =. Solely relying on other macros, registers for holding memory, and keys to navigate and modify data. Would be much more complex but I think it would be so cool! I think f would play a huge role as a conditional test. \$\endgroup\$ – Stefan Aleksić Mar 31 '17 at 8:33
  • \$\begingroup\$ If input is 6431, the output should be 0.0001554, or more precise, but not 0. \$\endgroup\$ – seshoumara Mar 31 '17 at 9:19
  • 1
    \$\begingroup\$ @seshoumara I think you need to input 6431.0 so it's treated as a floating point number \$\endgroup\$ – Poke Mar 31 '17 at 13:04
  • \$\begingroup\$ @Poke I tried it and it works, but the output is in scientific notation. Is that allowed? \$\endgroup\$ – seshoumara Mar 31 '17 at 13:39
11
\$\begingroup\$

x86_64 Linux machine language, 5 bytes

0:       f3 0f 53 c0             rcpss  %xmm0,%xmm0
4:       c3                      retq

To test this, you can compile and run the following C program

#include<stdio.h>
#include<math.h>
const char f[]="\xf3\xf\x53\xc0\xc3";
int main(){
  for( float i = .1; i < 2; i+= .1 ) {
    printf( "%f %f\n", i, ((float(*)(float))f)(i) );
  }
}

Try it online!

\$\endgroup\$
  • 1
    \$\begingroup\$ We might want to add that rcpss only calculates an approximate reciprocal (around 12 bit precision). +1 \$\endgroup\$ – Christoph Mar 31 '17 at 6:28
11
\$\begingroup\$

C, 15 12 bytes

#define f 1/

Try it online!

16 13 bytes, if it needs to handle integer input also:

#define f 1./

So you can call it with f(3) instead of f(3.0).

Try it online!

Thanks to @hvd for golfing 3 bytes!

\$\endgroup\$
  • 2
    \$\begingroup\$ Could you change the language name to "C Preprocessor?" \$\endgroup\$ – ckjbgames Mar 30 '17 at 23:58
  • 4
    \$\begingroup\$ Being very picky, this doesn't "compute" the value; it just replaces f(x) with 1/x. When the "function" is executed, which can happen as late as runtime or as early as your compiler feels like (and can prove correct), is technically not the preprocessor step. \$\endgroup\$ – CAD97 Mar 31 '17 at 5:46
  • 1
    \$\begingroup\$ @Steadybox I'm literally quoting from the sample input section in the challenge description. Your code will get 2 and -5 as input. Both 2 and -5 are decimals, containing digits in the range 0 to 9. \$\endgroup\$ – pipe Mar 31 '17 at 12:28
  • 2
    \$\begingroup\$ There is no need for a function-like macro: #define f 1./ works too. \$\endgroup\$ – hvd Apr 1 '17 at 16:09
  • 2
    \$\begingroup\$ "Being very picky, this doesn't "compute" the value; it just replaces f(x) with 1/x." I'm that picky. This is entirely possible to do using the C preprocessor, but one shouldn't claim to have done something in the C preprocessor if one requires C or C++ to actually do it. \$\endgroup\$ – H Walters Apr 2 '17 at 23:42
10
\$\begingroup\$

MATLAB / Octave, 4 bytes

@inv

Creates a function handle (named ans) to the built-in inv function

Online Demo

\$\endgroup\$
8
\$\begingroup\$

05AB1E, 1 byte

z

Try it online!

z # pop a  push 1 / a
\$\endgroup\$
8
+100
\$\begingroup\$

GNU sed, 377 362 + 1(r flag) = 363 bytes

Warning: the program will eat all the system memory trying to run and require more time to finish than you'd be willing to wait! See below for an explanation and a fast, but less precise, version.

s:\.|$:,,,,,,,,:;:i;s:,(,+)(\w):\2\1:;ti
h;:;s:\w::2g;y:9876543210:87654321\t :;/ /!s:,:@,:;/\s/!t;x;s:-?.::;x;G;s:,.*::m;s:\s::g;/\w/{s:@+:&&&&&&&&&&:;t}
/@,-?@/!{s:^:10000000,:;h;t}
:l;s:(@+)(,-?\1):\2;:;tl;s:,::;s:@+;?@+::
s:-?:&0:;:c;s:\b9+:0&:;s:.9*;:/&:;h;s:.*/::;y:0123456789:1234567890:;x;s:/.*::;G;s:\n::;s:;::;/;/tc
:f;s:(\w)(,+),:\2\1:;tf;s:,:.:;y:,:0:

This is based on the Retina answer by Martin Ender. I count \t from line 2 as a literal tab (1 byte).

My main contribution is to the conversion method from decimal to plain unary (line 2), and vice versa (line 5). I managed to significantly reduce the size of code needed to do this (by ~40 bytes combined), compared to the methods shown in a previous tip. I created a separate tip answer with the details, where I provide ready to use snippets. Because 0 is not allowed as input, a few more bytes were saved.

Explanation: to better understand the division algorithm, read the Retina answer first

The program is theoretically correct, the reason why it consumes so much computational resources is that the division step is run hundred of thousands of times, more or less depending on the input, and the regex used gives rise to a backtracking nightmare. The fast version reduces the precision (hence the number of division steps), and changes the regex to reduce the backtracking.

Unfortunately, sed doesn't have a method to directly count how many times a backreference fits into a pattern, like in Retina.

s:\.|$:,,,,,,,,:             # replace decimal point or end of string with 8 commas
:i                           # loop to generate integer (useful for unary division)
  s:,(,+)(\w):\2\1:          # move 1 digit in front of commas, and delete 1 comma
ti                           # repeat (':i')
h;:                          # backup pattern and start decimal to unary conversion
  s:\w::2g                   # delete decimal digits, except the first (GNU magic)
  y:9876543210:87654321\t :; # transliterate characters
  / /!s:,:@,:                # if no space is present, append a unary digit ('@')
  /\s/!t                     # if no whitespace is present, go back to ':'
  x;s:-?.::;x                # delete first digit and the negative sign from backup
  G;s:,.*::m;s:\s::g         # append backup, delete whitespace and duplicate stuff
/\w/{s:@+:&&&&&&&&&&:        # if decimal digit left, multiply unary number by 10
t}                           # and repeat (':')
/@,-?@/!{                    # if only one unary number found (the input)
  s:^:10000000,:             # prepend decimal 10^7 separated by a comma
h;t}                         # backup pattern and convert new number to unary also
:l                           # start unary division loop (tons of RAM and time!!!)
  s:(@+)(,-?\1):\2;:         # delete as many '@'s from 10^7, as found in unary
                             #input, and add one ';' (new unary digit)
tl                           # repeat (':l')
s:,::;s:@+;?@+::             # delete leftover stuff
s:-?:&0:;:c                  # prepend zero and start unary to decimal conversion
  s:\b9+:0&:                 # if only 9s found, prepend zero to them
  s:.9*;:/&:                 # separate the digit(s) that would change on increment
  h;s:.*/::                  # backup, delete all (non-changing) digits (till '/')
  y:0123456789:1234567890:   # increment changing digit(s)
  x;s:/.*::                  # delete changing digits from backup
  G;s:\n::                   # append backup, delete newline
  s:;::                      # delete one unary digit (';')
/;/tc                        # if unary portion left, repeat (':c')
:f                           # loop to generate floating-point number
  s:(\w)(,+),:\2\1:          # move 1 digit after the commas, and delete 1 comma
tf                           # repeat (':f')
s:,:.:                       # turn first comma into a decimal point
y:,:0:                       # turn the rest of commas into zeroes (final result)
                             # implicit printing

For a fast and safe version of the program, but less precise, you can try this online.

\$\endgroup\$
7
\$\begingroup\$

Japt, 2 bytes

The obvious solution would be

1/U

which is, quite literally, 1 / input. However, we can do one better:

pJ

This is equivalent to input ** J, and J is set to -1 by default.

Try it online!

Fun fact: as p is the power function, so q is the root function (p2 = **2, q2 = **(1/2)); this means that qJ will work as well, since -1 == 1/-1, and therefore x**(-1) == x**(1/-1).

\$\endgroup\$
7
\$\begingroup\$

Javascript ES6, 6 bytes

x=>1/x

Try it online!

Javascript defaults to floating point division.

\$\endgroup\$
  • \$\begingroup\$ I am unfamiliar with the way your created and called f(). Can you explain that a little, or suggest a reference? \$\endgroup\$ – TecBrat Mar 31 '17 at 13:46
  • \$\begingroup\$ @TecBrat This is an anonymous function. In the try it online link I have f= in the header to assign the anonymous function so that it can be called. In the footer I have console.log(f(whatever number)) to output the result of calling the function \$\endgroup\$ – fəˈnɛtɪk Mar 31 '17 at 14:02
  • \$\begingroup\$ Shouldn't your total be 8 Bytes then? \$\endgroup\$ – TecBrat Mar 31 '17 at 14:08
  • \$\begingroup\$ @TecBrat The anonymous function is an answer without having to assign it. \$\endgroup\$ – fəˈnɛtɪk Mar 31 '17 at 14:15
  • 1
    \$\begingroup\$ @TecBrat The function is x=>1/x, which is equivalent to function(x){return 1/x}. As according to this answer in meta, which is referencing this consensus, anonymous functions that will perform the requested task are a valid answer to the challenge. \$\endgroup\$ – fəˈnɛtɪk Mar 31 '17 at 14:31
7
\$\begingroup\$

APL, 1 byte

÷

÷ Computes reciprocal when used as monadic function. Try it online!

Uses the Dyalog Classic character set.

\$\endgroup\$
  • \$\begingroup\$ Encoding. \$\endgroup\$ – Adám May 25 '17 at 14:34
6
\$\begingroup\$

Cheddar, 5 bytes

1&(/)

Try it online!

This uses &, which bonds an argument to a function . In this case, 1 is bound to the left hand side of /, which gives us 1/x, for an argument x. This is shorter than the canonical x->1/x by 1 byte.


Alternatively, in the newer versions:

(1:/)
\$\endgroup\$
  • \$\begingroup\$ New version lets this become (1:/) for same byte count \$\endgroup\$ – Downgoat Apr 13 '17 at 13:22
4
\$\begingroup\$

Java 8, 6 bytes

x->1/x

Almost the same as the JavaScript answer.

\$\endgroup\$
  • \$\begingroup\$ Would this encounter any issues with integer division? \$\endgroup\$ – kamoroso94 Feb 9 '18 at 1:02
4
\$\begingroup\$

MATL, 3 bytes

l_^

Try it at MATL Online

Explanation

    % Implictily grab input
l_  % Push -1 to the stack
^   % Raise the input to the -1 power
    % Implicitly display the result
\$\endgroup\$
4
\$\begingroup\$

Python, 12 bytes

lambda x:1/x

One for 13 bytes:

(-1).__rpow__

One for 14 bytes:

1 .__truediv__
\$\endgroup\$
4
\$\begingroup\$

Mathematica, 4 bytes

1/#&

Provides you with an exact rational if you give it an exact rational, and with a floating-point result if you give it a floating-point result.

\$\endgroup\$
4
\$\begingroup\$

ZX Spectrum BASIC, 13 bytes

1 INPUT A: PRINT SGN PI/A

Notes:

  • Each line costs 2 bytes for the line number, 2 bytes for the length of the line and 1 byte for the newline
  • Numeric literals are converted into binary at parse time, costing an extra 6 bytes, thus the use of SGN PI instead of literal 1.
  • Keywords take 1 byte each.

ZX81 version for 17 bytes:

1 INPUT A
2 PRINT SGN PI/A
\$\endgroup\$
  • 1
    \$\begingroup\$ Where can I find more specific information about how to score ZX Spectrum BASIC? \$\endgroup\$ – Luis Mendo Mar 31 '17 at 9:48
  • \$\begingroup\$ @LuisMendo You can find the character set (including keywords) on Wikipedia, but apart from that I don't know whether there is a consensus on scoring ZX Basic. (For instance, the ZX81 version must be a full program, but the ZX Spectrum supports INPUT as an immediate command.) \$\endgroup\$ – Neil Mar 31 '17 at 10:23
  • \$\begingroup\$ To save program listing bytes on the ZX81, you can do LET A=17 and refactor your application to one line to 1 PRINT SGN PI/A, you will need to change the value of A with more typing each time you want to run your program though. \$\endgroup\$ – Shaun Bebbers Mar 31 '17 at 13:39
4
\$\begingroup\$

Haskell, 4 bytes

(1/)

Try it online!

\$\endgroup\$
4
\$\begingroup\$

R, 8 bytes

1/scan()

Pretty straightforward. Directly outputs the inverse of the input.

Another, but 1 byte longer solution can be : scan()^-1, or even scan()**-1 for an additional byte. Both ^ and ** the power symbol.

\$\endgroup\$
4
\$\begingroup\$

TI-Basic (TI-84 Plus CE), 6 5 2 bytes

Ans⁻¹

-1 byte thanks to Timtech.

-3 bytes with Ans thanks to Григорий Перельман.

Ans and ⁻¹ are one-byte tokens.

TI-Basic implicitly returns the last value evaluated (Ans⁻¹).

\$\endgroup\$
  • \$\begingroup\$ Input also implicitly gets coordinate input into X and Y, but you couldn't use that since you need to be able to accept floating point numbers. Remember that X^-1 is only two bytes so you could save one there. \$\endgroup\$ – Timtech Mar 31 '17 at 12:29
  • \$\begingroup\$ TI-Basic is allowed to take input from Ans, so you can replace this with Ans⁻¹ \$\endgroup\$ – Pavel Mar 31 '17 at 16:57
3
\$\begingroup\$

Jelly, 1 byte

İ

Try it online!

\$\endgroup\$
  • \$\begingroup\$ That's actually 2 bytes. \$\endgroup\$ – Coder256 Apr 17 '17 at 18:39
  • \$\begingroup\$ In UTF-8, sure. By default, Jelly uses a custom SBCS though. \$\endgroup\$ – Dennis Apr 17 '17 at 19:33
  • \$\begingroup\$ @Dennis the wiki you linked says Jelly programs consist of up to 257 different Unicode characters. \$\endgroup\$ – Khaled.K Apr 19 '17 at 10:03
  • \$\begingroup\$ @Khaled.K Yes, it also says The character and the linefeed character can be used interchangeably, so while Unicode mode "understands" 257 different characters, they map to 256 tokens. \$\endgroup\$ – Dennis Apr 19 '17 at 18:16
3
\$\begingroup\$

C, 30 bytes

float f(float x){return 1./x;}
\$\endgroup\$
  • \$\begingroup\$ You can remove the trailing 0 to save one byte. With 1. it will still be compiled as a double. \$\endgroup\$ – Patrick Roberts Mar 30 '17 at 18:20
  • \$\begingroup\$ @PatrickRoberts Not in my testing. 1. is still treated like an integer. \$\endgroup\$ – dkudriavtsev Mar 30 '17 at 18:24
  • \$\begingroup\$ Works for me using echo -e "#include <stdio.h>\nfloat f(x){return 1./x;}main(){printf(\"%f\\\\n\",f(5));}" | gcc -o test -xc - Output of ./test is 0.200000 \$\endgroup\$ – Patrick Roberts Mar 30 '17 at 18:33
  • 1
    \$\begingroup\$ Doesn't this take input as an integer instead of a float? It doesn't work for floats, at least on gcc. float f(float x){return 1/x;} would work correctly. \$\endgroup\$ – Steadybox Mar 30 '17 at 18:41
  • 2
    \$\begingroup\$ No need for the trailing . - C will happily implicitly convert (int)1 to (float)1 because of the type of x. \$\endgroup\$ – fluffy Mar 31 '17 at 8:10

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.