text:
Reciprocal of a number (1/x)
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 code-golf, 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="
"+e.body.replace(OVERRIDE_REG,"")+"
")});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;/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}
 <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=617d0685f6f3">

Winners by Language

Language	User	Score

{{LANGUAGE}}	{{NAME}}	{{SIZE}}

Please stop upvoting trivial answers

@KritixiLithos People can vote as they see fit. Given the simplicity of this challenge, most, if not all answers are something like 1/x.

@NoOneIsHere ...until people have had enough time to implement the reciprocal in languages without floating point numbers and/or division.

This isn't objectively specified without very clear detail on accuracy and precision.

@PeterTaylor Different languages implement floating point numbers very differently. I can't think of a good way to write a spec. I would really appreciate help.

Related

Regarding sed and Retina, there is a meta consensus that the input can be in unary. For floating point input I guess '3.5' can be given as '000.00000'. Do you allow it?

@MartinEnder What I am saying is using most languages make the answer "uninteresting", but in any other language, the answer is bounty-worthy.

@seshoumara How would you enter 3.1415 in unary?

@DigitalTrauma 000.<1415 zeroes>

@seshoumara I guess... Would make it uninteresting though. I would prefer the (much harder) decimal alternative

What about 3.05 then? That needs to be distinguishable for 3.5, they can’t both be 000.00000.

@Lynn idea: the part after the decimal is reversed. So 3.5 is 000.00000, 1.15 is 0.0<51 zeroes>, 3.05 is 000.<50 zeroes>

@ГригорийПерельман That is interesting, but now the point of saving bytes is defeated, so I might as well take the input in decimal, as the OP prefers.

So how exactly does the input format work for very large or small numbers? Do we assume that there's always a . somewhere, at least one digit before and one digit after, and we ignore the exact value of all digits past the fourth from the first non-zero one? So input 123400.0 would be treated identically to 123456.78?

And then can we assume that we'll always do get 4 significant digits? I.e. can we assume that 12.3 won't be given as input, but at least 12.30 instead?

@MartinEnder No

@MartinEnder  All numbers you will be given are 4 significant or less. they can be given in 0.x, x, x.y, but not x.0 or .x

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.

@MendeleevLemon Don't be so stringent on input format. A language can have different data types, making x an integer, and x.0 a decimal/float. A language should be able to use its native representation of a floating point number, if it has one.

This is still really underspecified and shouldn't have been re-opened.

@MendeleevLemon Can we choose how to round?

@MendeleevLemon May the output have leading zeroes? (e.g. 000.3333 or 024.424)

@MartinEnder Please clarify.

@L3viathan Yes.

@MendeleevLemon Can we e.g. choose to round 0.12345 as 0.1234?

Can we have our input padded with extra zeros.  E.g. instead of 5 we take 5.00000 as input?

@L3viathan Sure, I guess

@WheatWizard Yeah

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

Can we output results below 1 as .123 (i.e. without the leading zero)?

Can scientific notation be used for output?

As a bonus, your title contains a huge part of the solution for dozens of languages.

Can we round the answer? Say for input 11 we output .090909091

@KritixiLithos Sure...

Those bounties are not able to be given. You cannot do arbitrary amounts repeatedly. You can do 50, 100, 200, 400 then 500

Can we output with trailing zeroes? For example, outputting .5000000000 for input 2

@Tim I believe that is only the case for a single user.  Separate users can bounty how they see fit.

@MartinEnder Yes

Argh, all the languages on bounty has no division at all!

@SIGSEGV That's precisely why there are bounties for these languages

@DJMcMayhem Your bounty can now be assigned

And what has to happen with input 0.0000001?

@RosLuP 4 significant digits, that input will never occur because it is basically 0

I'm assuming that fraction number formats cannot be outputted?

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

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

This doesn't seem to work for input 1.0 or 10

Can anybody else read this code? Is Brain-Flak meant to be write-only?

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

@ThisGuy It requires the -c flag to be run with ASCII in and out.  Since Brain-Flak doesn't support floating numbers I need to take IO as a string.

I was going to do this :( Now I am sad

Python 2, 10 bytes
1..__div__

Try it online!

Dot. Dot. Div. +1 :)

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.

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?

@seshoumara No because of negative inputs, where there's a - in front of the ;.

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

which implies that

I'd love to improve my content, so if you'd explain your downvote, that would really help and I would appreciate that :)

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!

I guess you could use ITZ A NUMBAR in the assignment of I?

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.

You can use IZ instead of DUZ because of interpreter rule

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

You made it! +1

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
-

J, 1 byte
%

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

Vim, 10 8 bytes/keystrokes
C<C-r>=1/<C-r>"

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

@NonlinearFruit No, it didn't. Turns out, I was overthinking it, and supporting that is actually less bytes, not more. Thanks!

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.

If input is 6431, the output should be 0.0001554, or more precise, but not 0.

@seshoumara I think you need to input 6431.0 so it's treated as a floating point number

@Poke I tried it and it works, but the output is in scientific notation. Is that allowed?

@seshoumara I don't see anything against it and it does still have 4 significant figures. I'll ask in a comment

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

This language-subset is hard to golf by hand but easy to automate (as a conversion from ordinary JavaScript).

True, but the character count of the source doesn't directly relate to the output length.

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.

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

[].fill.constructor('alert(1/prompt())') 2929 bytes https://paste.ubuntu.com/p/5vGTqw4TQQ/  add () 2931

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.

Would you mind adding a non-golfed version for easier readability?

@KevinCruijssen Sure, it's just that when I answered this it was late night.

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!

The original version of your program has been lost to the consecutive-edit merger, so the ---17--- is a little meaningless.

Could you change the language name to "C Preprocessor?"

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.

Also this won't work if x is an expression that includes other operators (e.g. 5+3)

@fluffy That's not relevant.

It doesn't work with integer inputs, however.

@pipe It doesn't need to work with integer inputs. From the question: "Given a (floating-point/decimal) number"

@Steadybox It's also clear from the examples that 2 and -5 are a valid inputs, which will be treated as an integers here.

@pipe That's because they are integer literals. Using 2.0 and -5.0 instead will work.

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

There is no need for a function-like macro: #define f 1./ works too.

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

@HWalters That's why the language name in the answer originally was C, not C preprocessor. I think I'll change it back.

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!

We might want to add that rcpss only calculates an approximate reciprocal (around 12 bit precision). +1

05AB1E, 1 byte
z

Try it online!
z # pop a  push 1 / a

MATLAB / Octave, 4 bytes
@inv

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

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.

Javascript ES6, 6 bytes
x=>1/x

Try it online!
Javascript defaults to floating point division.

I am unfamiliar with the way your created and called f(). Can you explain that a little, or suggest a reference?

@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

Shouldn't your total be 8 Bytes then?

@TecBrat The anonymous function is an answer without having to assign it.

I'm not trying to argue. I'm trying to learn. How does this work?

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

I was not familiar with arrow functions. I see there is a proposal for them in PHP. I hope it goes through. #ilearnedsomethingtoday

APL, 1 byte
÷

÷ Computes reciprocal when used as monadic function. Try it online!
Uses the Dyalog Classic character set.

Encoding.

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

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:/)

New version lets this become (1:/) for same byte count

Python, 12 bytes
lambda x:1/x

One for 13 bytes:
(-1).__rpow__

One for 14 bytes:
1 .__truediv__

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

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.

TI-Basic is allowed to take input from Ans, so you can replace this with Ans⁻¹

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

Java 8, 6 bytes
x->1/x

Almost the same as the JavaScript answer.

Would this encounter any issues with integer division?

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.

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

Where can I find more specific information about how to score ZX Spectrum BASIC?

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

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.

Haskell, 4 bytes
(1/)

Try it online!

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.

C, 30 bytes
float f(float x){return 1./x;}

You can remove the trailing 0 to save one byte. With 1. it will still be compiled as a double.

@PatrickRoberts Not in my testing. 1. is still treated like an integer.

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

@PatrickRoberts Oh crap, I mixed this up with my Ruby answer. Sorry!

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.

@Steadybox woops

No need for the trailing . - C will happily implicitly convert (int)1 to (float)1 because of the type of x.

Jelly, 1 byte
İ

Try it online!

That's actually 2 bytes.

In UTF-8, sure. By default, Jelly uses a custom SBCS though.

@Dennis the wiki you linked says Jelly programs consist of up to 257 different Unicode characters.

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

dc, 7 6 bytes
Edit: saved 1 byte thanks to Digital Trauma
7k1?/p

Try it online!
Because dc treats the input as commands, negative numbers are recognized using _ as the negative sign, instead of -, which is interpreted as the subtraction command. This is allowed by this meta consensus.
Explanation:
7k           # set precision to 7 digits. This is needed to output at least 4
             #significant figures when the input is '6431' for example)
1?           # push 1, then push input number
/p           # divide and print result

The r is unnecessary with a slight change: 4k1?/p

@DigitalTrauma You're right, thanks. I rushed it. I updated the answer.

Perl 6, 3 bytes
1/*

Try it
This also works, but is 5 or 6 bytes
You can use ⁻ (superscript minus) at 3 bytes, or ¯ (macron) which is 2 bytes
*⁻¹

Try it

C++ lambda function, 24 bytes
[](float x){return 1/x;}

Full program
#include <iostream>

void main()
{
    auto y = [](float x){return 1/x;} ;
    std::cout << y(5) << std::endl;
}

In C++14 you can use auto x instead of float x to save a byte. Additionally, main should be declared as returning an int.

Rogex, 15 bytes
701300001600200

Try it online!
 The actual language isn't on TIO yet, so a python 3.8 interpreter with the program in the code section and the python interpreter split in the header and footer is provided
Rogex is a newly developed language that I've recently discovered, so I though I'd give it a crack and write an answer.
Explained
701 300 # Set the buffer to 1 and place it in cell 0
001     # Get numeric input and place it into the buffer
600 200 # Divide cell 0 (1) by the buffer (input) and print

(╭☞´• ᗜ •`)╭☞ 100 answers! Woot! (⌐■◡■)

Ruby, 10 bytes
->x{1.0/x}

Very simple

Quetzalcoatl, 3 bytes
cfI

c takes input, f converts to a float, and I takes the inverse.

Actually, 1 byte
ì

From the docs:
8D (ì): pop a: push 1/a

Try It Online
In Seriously, it would be two bytes:
,ì

This doesn't work in Seriously because Seriously doesn't do implicit input. You should also provide a TIO link.

Huh. I must have misremembered. Feel free to edit.

Actually, this is 2 bytes.

It's one Seriously/Actually byte. See the docs.

@Coder-256 Actually :P

Julia, 3 bytes
3 bytes saved thanks to @gggg
inv

Try it online!
Returns the matrix inverse.

inv is just 3 bytes

Bean, 7 6 bytes
Equivalent JavaScript:
(1/A)

Bean xxd-style hexdump:
00000000: 4ca5 3a8e 2043                           L¥:. C

Explanation
A is auto-initialized with the 1st input line JSON-parsed. (e.g. 5 is interpreted as JSON and becomes a number), and the program implicitly outputs 1/A.
Edit The "hack" I just realized is that removing the first byte of the AST binary doesn't seem to affect the compilation of the program...
Try the demo here.

Interesting, what's the main cause of this being longer than vanilla JS even though it's basically compressed JS?

@ETHproductions The overhead of the block scope and I believe binary operators are each 2 bytes (This is due to the binary directly representing the AST of the equivalent JavaScript). Bean really shines with challenges that would typically require several calls to builtins, or when interpreting input as objects automatically saves bytes, or when having a program implicitly input and output is smaller than writing answer as a function where you explicitly input and output.

Weird... I just found an interesting hack.

Forth, 3 bytes
1/f

Try it online
Takes a floating point literal, which in Forth must be in scientific notation, like 5e-4 for 0.0005 or 2e3 for 2000.0. The result will be left on the floating point stack.
Reference on number conversion in Forth.

C#, 7 6 bytes
Saved a byte thanks to David Conrad.
x=>1/x;

Anonymous function which returns the inverse of a number.
Full program with test cases:
using System;

public class Program
{
    public static void Main()
    {
        Func<double, double> f =
        x=>1/x;

        // test cases:
        Console.WriteLine(f(0.5134));
        Console.WriteLine(f(0.5));
        Console.WriteLine(f(2));
        Console.WriteLine(f(2.0));
        Console.WriteLine(f(0.2));
        Console.WriteLine(f(51.2));
        Console.WriteLine(f(113.7));
        Console.WriteLine(f(1.337));
        Console.WriteLine(f(-2.533));
        Console.WriteLine(f(-244.1));
        Console.WriteLine(f(-0.1));
        Console.WriteLine(f(-5));
    }
}

I don't think you need to count the semicolon in C#. Imagine that the lambda was being passed to a function that took a Func<double, double> as a parameter; in that case, it wouldn't be followed immediately by a semicolon.

AFAIK you should submit separate languages as separate answers. This helps the leaderboard userscript detect them as separate posts.

Brachylog, 2 bytes
/₁

Try it online!
For the sake of completeness…
Explanation
/, by default, takes a list of 2 numbers [A, B] as input and unify its output with A divided by B.
When / has a subscript, it takes a single number as input unify its output with that number divided by the subscript. For example, /₄₂ will divide the input number by 42.
The only exception is if the subscript is 1 (because dividing by 1 is kind of useless). In that case, it unifies its output with the inverse of its input.

Java 7, 29 bytes
Golfed:
float i(float x){return 1/x;}

Ungolfed:
float i(float x)
{
    return 1 / x;
}

Pretty straight forward.

bc + sh, 14 10 bytes
1/read()<NEWLINE>
Run bc with -l which sets the default scale to 20. That way both input and output have 20 digits after the decimal point.
Edit:
Thanks DigitalTrauma for a tip on changing the answer from bc + sh to pure bc. Saved 4 bytes.

Welcome to PPCG!.  I think you can claim 1/read()<NEWLINE> as a 10-scoring pure bc answer.  This would include +1 for the use of the -l flag to bc, as per standard rules

@DigitalTrauma Thanks for the tip! I'll change the answer. I've never used bc by itself, only inside sh scripts, so I didn't know it is possible to use read() to enter variables. Just found an example in bc man page that does something similar.

Why is it 10 bytes?  I count only 8 visible (one-byte) characters and one newline (of you really insist that this be part of the program).  Makes 9 bytes.  Where's the tenth?

@Alfe Yes, newline counts, since a number can't be read from stdin without it. The 10th byte comes from -l flag that is needed to achieve the required precision.

OCaml, 12
fun x->1./.x

The division of floats is done with the operator /..

PHP, 24 bytes
echo(1/(float)$argv[1]);

This is my first answer, tell me if I can somehow shorten it!
Try it online!
When trying it online, just change the argument to the desired number n of which you want to get 1/n
Very straightforward approach.

I think you can replace 1 with 1.0 and then remove the (float) for some savings. I tried it in your TIO link and it seemed to work.

@Malivil but isn't $argv[1] originally a string and therefore has to be casted to a float?

I think it's doing implicit type casting. I tried it out in your TIO link and it was working. I also read though the PHP manual a bit (http://php.net/manual/en/language.types.type-juggling.php) and it seems like it just changes based on context.

Common Lisp, 1 byte
/

Try it online!

Vyxal, 1 byte
Ė

Try it Online!

Kotlin, 6 bytes
{1/it}

Attempt This Online!
Simple anonymous function.

CJam, 4 bytes
1rd/

Try it online!
1     e# Push 1
 rd   e# Push input as a double
   /  e# Divide

Alternate solution:
rdW#

rd    e# Push input as a double
  W   e# Push -1
   #  e# Exponentiation

Pyth, 3 2 bytes
-1 byte thanks to Steven  Hewitt
c1

c is float division, with 1 and implicit input.

Pyth can fill in the Q implicitly, so c1 works just as well.

Fortran 95, 23 bytes
function f(x)
f=1/x
end

Elixir, 7 bytes
&(1/&1)

Anonymous function defined using the capture operator.
Full program:
f=
&(1/&1)

IO.inspect(f.(0.5134))  # 1.94779898714453

Try it online!

Mathics, 4 bytes
1/#&

Try it online!

QBIC, 5 bytes
:?1/a

Explanation:
:    get input from the cmd line, named 'a'
?    PRINT
1/a  1/a

Scala, 3 bytes
1/_

This defines a lambda equivalent to x => 1/x (_ is a placeholder for the argument). Use by assigning it to a variable, then calling it, like this:
val f: Double => Double = 1/_
f(5) // 0.2

Excel VBA, 7 Bytes
Anonymous VBE immediates window function that takes input from cell [A1] of type variantand expecting a (floating-point) number and outputs its inverse to the VBE immediates window. Does not handle improperly formatted input.
?1/[A1]

Racket, 11 bytes
(/ 1(read))

Try it online!

Hello and welcome to the site! It looks like the .0  is not really necessary (tio).  You can assume that the input is a float so you don't need to go through the trouble of having the 1 be a float.

@WheatWizard thanks, and does that mean fractions are acceptable output (eg. 1/5 vs 0.2)?

No, fractions are still not allowed its just that instead of doing (/ 1.0 -33) you can do (/ 1 -33.0) that is put the burden of float casting onto the input instead of your code.  If you look at the modified version of your code I provided you will see it still does output a float.

Thanks @WheatWizard, made the edit above. Just realized OP allowed x.0 input format after reading the last three comments under main question.

PHP, 11
<?=1/$argn;

Run with echo <n> | php -nR '1/x

Don't think there's a shorter way to do this in Scala.

The input isn't limited to ints.

Oops. That's what happens when you write code golf solutions at 5 in the morning. Fixed!

TI-Basic, 2 bytes
Ansֿֿ ¹

You could also do 1/Ans (3) or Ans^~1 (4).

Noodel, 1 byte
ẹ

A command that takes the first character of a string and places at the end, for numbers takes the reciprocal of the number. The interpreter for Noodel is written in JavaScript which has double precision floating point numbers.
Try it:)

How it works
  # Implicitly pushes the number onto the stack.
ẹ # Takes the reciprocal of the input.
  # Implicitly prints the top of the stack to the screen.

HODOR, 100 bytes
Walder
Hodor?!
Hodor, Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor, Hodor,
HODOR!!
HODOR!!!

If you must know how it works, I'll tell you.
Explanation
Walder                                                                       Hodor hodor
Hodor?!                                                                     Hodor hodor hodor HODOR
Hodor, Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor, Hodor,        Hodor hodor hodor hodor hodor hodor
HODOR!!                                                                     Hodor hodor hodor hodor hodor
HODOR!!!                                                                    Hodor hodor (Hodor hodor hodor)

 Walder - Start program

 Hodor?! - Take input from STDIN

 Hodor, Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor Hodor, Hodor, - Change accumulator value to it's reciprocal

 HODOR!! - Output accumulator value as number

 HODOR!!! - Kill Hodor (End the program)

"Wylis"? Someone didn't read the books. ;)

@MartinEnder I read them but couldn't be bothered to look for his name in them. They are other 4000 pages long altogether.

http://awoiaf.westeros.org/index.php/Hodor :)

@MartinEnder I can't believe I have defiled Hodor's memory like this! (Now I've got to go change all the answers!)

NO!, 31 bytes
NO! has 6 valid tokens: NOno!? and commands are made up of NO with the number of O determining the command.
NOOOOO?no!NOOOOOOOOOOO
NOOOOOOOO?no

###More readable
NOOOOO?                 NOOOOO is the divide command and ? starts the arguments
       no!              no is 1 and ! separates the arguments
          NOOOOOOOOOOO  This takes input from STDIN.

NOOOOOOOO?              This outputs the result of the       line
          no                                           first

The equivalent pseudocode:

output divide 1, input

Emacs Lisp, 11 bytes

(/ 1(read))

Elisp defaults to integer division, so the input will have to be given as floating point, e.g. 1.0 instead of 1. The engine evaluates the (read) statement to get the input and then evaluates the (/ ...) statement, and outputs the answer to stdout.

Bash + bc, 12 bytes
bc -l<<<1/$1

bc defaults to integer division, which would be a problem, but running bc with the -l flag loads a math library that allows for floating point division. The $1 takes the first command line argument passed to the Bash script and the <<< passes the string with the expanded argument to bc.

8087 machine code, 4 bytes
d9 e8   |   fld1
d8 f1   |   fdiv st0, st1

The obvious/trivial solution. Expects input in register st0.

SenseTalk, 16 bytes
params r
put 1/r

Explanation
params r # accept input
put 1/r  # get the reciprocal

Keg, 1 byte
⑱

Try it online!
Keg, 3 bytes(SBCS)
1¿/

TIO
Divide 1 by friendly input

⑱ for 1 byte.

W, 3 bytes
You know, we can't beat the built-ins.
1S/

Explanation
a1S  % Stack : 1 a
   / % Divide.(1/a)
     % Output.

Go, 34 bytes
func(a float64)float64{return 1/a}

Attempt This Online!

Factor, 5 bytes
recip

Try it online!

Pyt, 1 byte
⅟

Try it online!
Just another language with a built-in one-byte reciprocal function

Pascal, 40 bytes
The built-in data type real provides an implementation-defined approximation.
function f(x:real):real;begin f:=1/x end

Jellyfish, 3 bytes
p%i

Try it online!
Unary % computes the reciprocal. i is input, p is output.

Gol><>, 4 bytes
1I,h

Online interpreter link

Dyvil, 5 Bytes
1 / _

Unfortunately we need the extra white space because /_ would be a single operator, and 1/ _ would parse differently
Usage:
let f: double -> double = 1 / _
print(f(2)) // 0.5

Racket 7 bytes
(/ 1 x)

Full function:
(define (f x)
  (/ 1 x))

Testing:
(f 1.56)

Output:
0.641025641025641

JavaScript(ES7), 8 bytes
x=>x**-1

f=x=>x**-1;
console.log(f(0.5134));

@fəˈnɛtɪk Oh dammit. Now I have to rollback to x**-1.

** does not exist in ES6, it was added in ES7, which is why I specified your answer was ES7

The Seventh Edition, also known as ECMAScript 2016, intended to continue the themes of language reform, code isolation, control of effects and library/tool enabling from ES2015, includes two new features: the exponentiation operator (**) and Array.prototype.includes.

REXX, 12 bytes
say 1/arg(1)

Divides 1 by first argument. Precision is decided by NUMERIC DIGITS but defaults to at least 9 decimals.

AWK, 10 7 bytes
$0=1/$0

Usage:
awk '$0=1/$1' <<< "some number here"

or use the TIO link : Try it online!
Explanation:
Replace the input line with its reciprocal.  This is then evaluated and the entire line is printed if the evaluation in non-zero. Since the result can't be 0 we don't need to worry about not receiving output.

Python 2.7, 17 25 bytes
Full program:
print'%.4f'%(1.0/input())

Batch, 69 67 + 39 (vbs section) = 106 bytes
a.bat
@for /f "skip=1" %%n in ('cscript //nologo b.vbs 1/%1')do @echo %%n

Explanation:

call VBScript to calculate 1/argument
return the result

b.vbs
WScript.Echo Eval(WScript.Arguments(0))

Explanation:(my guess, I'm not good at VBS)

return the result calculated by Eval

Test cases
called from command line:
>a.bat 0.5134
1.94779898714453

>a.bat -0.5
-2

Batch can't handle floating point division....

I can't test VBScript, but my feeling is, that if you change the VBS to WScript.Echo 1/WScript.Arguments(0), and change "1/%1" into  "%1", you could save some bytes.

Aceto 1.0, 4 3 bytes non-competing
Non-competing because the challenge predates Aceto. Assumes input number is on the stack, and leaves it on the stack.
1s:

1 pushes 1 on the stack, s swaps the top two values, and : does floating point division.
Also, this is the first Aceto answer!
edit: Saved 1 byte

Haskell, 4 bytes
(/)1

Currying FTW!

alternatively (1/)

Axiom, 57 bytes
f(x)==(y:=abs(x);y>9999 or y<0.0001=>"ObjFloatErr ";1./x)

test code and results
(21) -> [[i,f(i)] for i in [-2,-1,-0.0001,-0.00001,9999,10000]]
   (21)
   [[- 2.0,- 0.5], [- 1.0,- 1.0], [- 0.0001,- 10000.0],
    [- 0.00001,"ObjError 1/x"], [9999.0,0.0001000100 0100010001],
    [10000.0,"ObjError 1/x"]]

CGL (CGL Golfing Language), 6 bytes (non-competing)
This language postdates this challenge.
-÷Ⓧ

Explanation:
- decrements the current stack, so it is now -1, where input is placed
÷ Divides the first element of the stack by the second if it exists, otherwise (this case) it divides 1 by the first (reciprocal)
Ⓧ Output the last stack item (the result of ÷) and exit

Jelly , 11 Bytes
²Nṭ1,0ÆrḢ×Ṡ

This works without the built-in inverse function Ị. (Who uses that anyway?).
Try it online!
How it works
²Nṭ1,0ÆrḢ×Ṡ
   1,0      # Look at the list [1,0]
  ṭ         # Append (to the end)
²N          #  the negative of the square of the input
      Ær    # Find the roots to the polynomial with coefficients corresponding to the list as [greater root,lower root] pair
        Ḣ   # Head; get the first element of the roots (always positive)
         ×Ṡ # Multiply by the sign of the input (to accommodate negative input)

Perl 5, 7 bytes
The obvious subroutine.
{1/pop}

I was under the impression that you could only omit the sub when passing it to a subroutine with a & prototype.

@quartata, perldoc perlsub says: "The signature is part of a subroutine's body. Normally the body of a subroutine is simply a braced block of code."

Still, the result is not something that is callable as it stands. I would say it is invalid.

Fourier (Non-Competing), 79 bytes
1~RI~X<0{1}{0-1~R45a}X*R~XL*2+2/2~UX{1}{0~U}10P10/X~DL+U~p10Pp~TD/To*T~A46aD-Ao

Try it online!
This is non-competing for two reasons:

Firstly, it does not fulfil the spec (it only works for inputs in the range -10 <= x <= 10
Secondly, it uses the functions L and P which were added after the writing of this challenge

So, this answer poses a challenge: can you complete this challenge in Fourier in the range -9999 <= x <= 9999? There are two bounties up for grabs:

100 Rep Bounty for the first solution to complete this task without using the new functions L (log 10) and P (power)
50 Rep Bounty for the shortest solution to complete this task using the new functions L (log 10) and P (power)

Note that on the Fourier github repo (https://github.com/beta-decay/Fourier/tree/master/fourIDE/editor) the FourIDE is up to date with L and P.
To-do list

Add explanation of code

For x=0 the 1/x=1/0 is not possible so the domain of function 1/x has to be [-a, -e] [e,a] for some 'a' big enough for them and 'e' little enough...

Convex, 1 byte
¹

Try it online!

Bash, 15 bytes
dc -e"Fk$1_1^p"

Try it online!
dc               ::Use dc calculation
   -e            ::Evaluate argument as dc code
     "         " ::Quote
      Fk         ::F sig-figs (F is hex for 15)
        $1       ::$1 is initial value (the first argument)
           _1^   ::Raise $1 to power of -1
              p  ::Print result

Groovy, 9 bytes
{1.0g/it}

Needs the .0g to denote big decimal notation on the 1, making the it unbox itself as a BigDecimal.
Input of 7.29349129124513204632593467635245678734521456789
Results in 0.13710854789123656486815482305643737234188188122
If you use an input of 214700000000000, however, without the .0g...
You get an error or nothing.

ARBLE, 3 bytes
1/x

Try it online!

Attache, 4 bytes
1&`/

Try it online!
This is division (`/) left-bonded with 1, which is equivalent to reciprocal.

KoopaScript, 48 bytes
def a i inp;setath o 1 / \%vuserInput;print \%vo

And how it works (KS isn't really golfable yet but it's fun nonetheless):
def a i                                          - define a function and call it a lot
        inp;                                     - pause execution until input
            setath o 1 / \%vuserInput;           - set 'o' to 1 / the input
                                      print \%vo - output 'o'

Try it online (paste the code into the left-hand box, press enter, then type a number, press enter, etc)
Now that KS has input, I can finally start using it for stuff that involves interaction :D
(Tell me if this should be non-competing :P)

Thunno, \$ 1 \log_{256}(96) \approx \$ 0.82 bytes
o

Attempt This Online!
Built-in solution.

Thunno 2, 1 byte
Ị

Attempt This Online!
Built-in.
Thunno 2, 8 bytes
ÆtÆCÆsÆT

Attempt This Online!
Uses the fact that: $$\tan(\arcsin(\cos(\arctan(x)))) \equiv {{1} \over {x}}$$


text:
March Madness - When Will Two Seeds Meet?
Each March in the United States, the NCAA holds a 68-team tournament for both men's and women's college basketball. Here's what the bracket looks like:

There are four regions, each with 16 teams seeded from 1-16.
Each region is seeded the same way, and across the four regions, the same matchups occur between seeds. For example, in the first round, #1 plays #16 and #8 plays #9, then the winners of those games play in the second round. So, possible options for the second round matchup are #1 vs #8, #1 vs #9, #16 vs #8, and #16 vs #9.
Teams with the same seed can only meet in two ways: the first is in the semifinals (round 5), where the champion of each of the four regions plays another regional champion.
The second has to do with a wrinkle in the tournament. There are also 4 "play-in" games, where two teams with the same seed play each other to enter the "true" game in the round of 64 teams. As you can see in the bracket, this only happens for seeds 11 and 16, so those seeds can play another team in the same seed in the play-in games (round 0).
The Challenge
Given two seeds from 1 to 16, inclusive, in any standard format, output the number of the earliest round a matchup between two teams with those integers as seeds could occur in the NCAA basketball tournament.
Test Cases
Input  Output
1,16   1
1,8    2
1,9    2
9,16   2
3,11   2
3,14   1
1,2    4
5,5    5
11,11  0
16,16  0
15,16  4
3,4    4
6,7    3
6,10   3
6,11   1
10,11  3
1,6    4
1,11   4
4,5    2
4,6    4
4,7    4
4,8    3
4,9    3
5,8    3
5,9    3
2,7    2

This is code-golf, so the submission with the fewest bytes wins.

My initial submission missed a bunch of cases in the middle because the test cases covered are pretty much entirely extreme cases. Could you please add more central cases, such as 3,4, 6,7, and 1,6? (Nice first challenge, btw)

Thanks for the feedback! I've added more test cases and can certainly add more.

Mathematica, 79 bytes
o={r=1,1}
Which[#==11o||#==16o,0,Tr@#==(c=32/2^r+1),r,0<r++,#0[Min[#,c-#]&/@#]]&

The second line defines a pure function taking a pair of numbers as input and returning the appropriate nonnegative integer. Inside the Which (which is an "if-then-else" construct): #==11o||#==16o,0, deals with the play-in special cases; Tr@#==(c=32/2^r+1),r, checks whether the sum of the two team seeds is equal to the magic number that means they could be matched up in round r; and 0<r++,#0[Min[#,c-#]&/@#] is the "else" clause (since 0<r++ will always be true here) which recursively calls the function on Min[#,c-#]&/@#, which replaces any lower seed with the seed of the higher-ranked team it would have beaten to get to the next round.

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
Lists and arrays, part by part
In this challenge, you'll get four different but somewhat related tasks that must be solved in a specific manner. First, I'll explain the tasks, then follows an explanation of how you must solve it.
Your code should for all four tasks take two positive integers as input: n,m, where n<m. All tasks must be solved in the same language. The orientation of matrices are optional (n-by-m may be interpreted as "n rows, m columns", or "n columns, m rows").
Task 1:
Create (and output/print) a vector / list consisting of the elements: n, n+1 ... m-1, m. So, for n=4, m=9, you should output: 4,5,6,7,8,9.
Task 2:
Create (and output/print) a matrix / array / list of lists (or equivalent) looking like this:
n,   n+1, ... m-1, m
n+1, n+2, ... m-1, m+1
...
n+m, n+m+1, ... 2*m-1, 2*m

For n=4, m=9 you should output:
4, 5, 6, 7, 8, 9
5, 6, 7, 8, 9, 10
...
13, 14, 15, 16, 17, 18

Task 3:
Create (and output/print) an n-by-m multiplication table (on any suitable format). Example for n=4, m=9:
1   2   3  4
2   4   6  8
3   6   9  12
4   8  12  16
5  10  15  20
6  12  18  24
7  14  21  28
8  16  24  32
9  18  27  36

Task 4:
Output / print a vector / list consisting of the elements in the multiplication table from task 3, sorted in ascending order, keeping duplicate values. For n=4, m=9, you should output: 1, 2, 2, 3, 3, 4, 4, 4, 5, 6, 6, 6, 7, 8, 8, 8, 9, 9, 10, 12, 12, 12, 14, 15, 16, 16, 18, 18, 20, 21, 24, 24, 27, 28, 32, 36.
The challenge:
Now, all the tasks above are quite trivial. The real challenge here is that the code for task 2 must start with the code for task 1, the code for task 3 must start with the code for task 2 and the code for task 4 must start with the code for task 3.
To make it more clear:
Suppose the code for Task 1 is (works in Octave):
@(n,m)(n:m)

Then your code for Task 2 could be (works in Octave):
@(n,m)(n:m)+(0:m)'

The code for task Task 3 must be (doesn't work in Octave):
@(n,m)(n:m)+(0:m)'"Code_for_task_3"

And finally, the code for Task 4 must be (doesn't work in Octave):
@(n,m)(n:m)+(0:m)'"Code_for_task_3""Code_for_task_4"

This is code-golf, so the submission with the shortest code for task 4 in each language wins. As always: Explanations are highly encouraged.

Just to be clear, I'm going to guess that this is against the spirit of the challenge, but is it permissible to start the next task's code with a redirect to STDERR >2; so that the previous task's code is essentially rendered a no-op?

@AdmBorkBork, there's no such thing as "the spirit of the challenge" on PPCG :P Yes, that's OK.

Does the multiplication table need to be padded nicely?

@HyperNeutrino, no.

When you say "positive integer", do you mean 0<n<m or 0<=n<m?

0<n<m @valueink

Jelly, 12 bytes
Task 1
r

Try it online!
Task 2
r+þ0r$}

Try it online!
Task 3
r+þ0r$}
×þ

Try it online!
Task 4
r+þ0r$}
×þFṢ

Try it online!
How it works
Task 1
r is the dyadic range atom and does exactly what the task asks for.
Task 2
A dyadic chain that begins with three dyadic links is a fork; the outmost links get evaluated first, then the middle link is called with the results to both sides as arguments.

r behaves as before, yielding [n, …, m].
0r$} is a quicklink (or quickquicklink, if you will).
The quick $ (monadich chain) consumes the links 0 (yield 0) and r (dyadic range) and turns them into a monadic chain. When called with argument k, this will yield [0, …, k].
The quick } (right argument) takes the quicklink created by $ and turns it into a dyadic link that calls 0r$ with 0r$}'s right argument.
0r$} will be called with left argument n and right argument m, so 0r$ is alled with argument m and yields [0, …, m].
+þ is another quicklink. þ (table) will call + (addition) for every element in its left argument and any element in its right argument, grouping the results for each right argument into a single row.
+þ will be called with left argument [n, …, m] and right argument [0, …, m], yielding the desired table.

Task 3
Every line in a Jelly program defines a different link. The last one is the main link and, like C's main function, is the only link that is executed by default. The remaining links can be called from the main link, but we won't do this here.
As before, þ (table) will call × (addition) for every element in its left argument and any element in its right argument, grouping the results for each right argument into a single row.
Since both arguments to ×þ are integers, þ casts them to ranges, transforming the arguments n and m into [1, …, n] and [1, …, m].
Task 4
×þ works as before. The following links are monadic, making them atops, i.e., they are applied on top of the previous ones.
After executing ×þ, F flattens the resulting 2D array, and Ṣ sorts the resulting 1D array.

05AB1E, 18 17 bytes
Task 1
Ÿ

Try it online
Task 2
Ÿ²FD>})

Try it online
Task 3
Ÿ²FD>})v¹LN*})¦

Try it online
Task 4
Ÿ²FD>})v¹LN*})¦˜{

Try it online
Explanations
Task 1
Ÿ     # range[n ... m]

Task 2
Ÿ        # range[n ... m]
 ²F      # m times do:
   D     # duplicate
    >    # increment
     }   # end loop
      )  # wrap in list

Task 3
v          # for each list in result of Task 2 do
 ¹L        # push range[1 ... n]
   N*      # multiply by index
     }     # end loop
      )    # wrap in list
       ¦   # discard first element

Task 4
˜          # flatten the result from Task 3
 {         # sort

MATL, 18 17 bytes
Task 1
&:

Try it online!
Task 2
&:O2G:h!+

Try it online!
Task 3
&:O2G:h!+:7M!*

Try it online!
Task 4
&:O2G:h!+:7M!*1eS

Try it online!
Explanation
Task 1
&:    % Binary range [n n+1 ... m] from implicit inputs n, m

Task 2
      % ... Stack contains [n n+1 ... m]
O     % Push 0
2G    % Push second input, m
:     % Unary range: gives [1 2 ... m]
h     % Concatenate horizontally: gives [0 1 2 ... m]
!     % Transpose into a column vector
+     % Add with broadcast

Task 3
      % ... Stack contains matrix from task 2
:     % Unary range. For matrix input it uses its (1,1) entry. So this gives [1 2 ... n]
7M    % Push [1 2 ... m] again
!     % Transpose into a column vector
*     % Multiply with broadcast

Task 4
      % ... Stack contains matrix from task 3
1e    % Linearize into a row vector
S     % Sort

Mathematica, 84 77 bytes
Edit: Thanks to Martin Ender for saving 7 bytes.
Task 1:
{n,m}n~Range~m

Pure Function with arguments n and m which outputs n~Range~m, the infix form of Range[n,m].
Task 2:
{n,m}n~Range~m~Table~(m+1)//0~Range~m+#&

n~Range~m~Table~(m+1) creates a 2D array with m+1 rows, where each row is the output of the previous task. Then //0~Range~m+#& is postfix application of the function 0~Range~m+#& which effectively adds 0 to the first row, 1 to the second row, and so on up to m for the m+1-th row.
Task 3:
{n,m}n~Range~m~Table~(m+1)//0~Range~m+#&//1##&~Array~{n,m}&

This just applies the constant function 1##&~Array~{n,m}& to the output of the previous task.
Task 4:
{n,m}n~Range~m~Table~(m+1)//0~Range~m+#&//1##&~Array~{n,m}&//Flatten//Sort

Flattens and Sorts the multiplication table.

Python, 183 bytes
Task 1, 29 bytes
r=range
a=lambda n,m:r(n,m+1)

Try it online!
Task 2, 84 bytes
r=range
a=lambda n,m:r(n,m+1)
s=lambda n,m:[[w+i for w in r(n,m)] for i in a(0,m+1)]

Try it online!
Task 3, 137 bytes
r=range
a=lambda n,m:r(n,m+1)
s=lambda n,m:[[w+i for w in r(n,m)] for i in a(0,m+1)]
d=lambda n,m:[[w*i for w in a(1,n)] for i in a(1,m)]

Try it online!
Task 4, 183167 bytes
r=range
a=lambda n,m:r(n,m+1)
s=lambda n,m:[[w+i for w in r(n,m)] for i in a(0,m+1)]
d=lambda n,m:[[w*i for w in a(1,n)] for i in a(1,m)]
f=lambda(z):sorted(sum(z,[]))

Try it online!
Explanation:
Task 1:
Simple enough, it generates a n to m list using Python's built-in range function.
Task 2:
For every number 0 to m+1, it adds that number to each item of a list from n to m.
Task 3:
For each number from 1 to m, it multiplies that number by every number in a list from 1 to n.
Task 4:
This uses Python's built in sorted function which sorts a list from least to greatest. The list comprehension in the function is used to flatten the list. It creates a list of every item in every item of the list given to it by task 3.

Saved very many bytes thanks to @math_junkie.
Saved 16 bytes thanks to @ThisGuy

Saved very many bytes thanks to @math_junkie.

Can you not use anonymous functions or are lambdas not actually shorter? (by my count it seems they are)

Is this generally acceptable for Python asnwers? The code for task 2, for instance, isn't a full program with input and output, and it's also not a function or function definition.

@Cole I had to use non-anonymous functions so that I could use them in the later code.

@ngenisis I think it is okay, because the OP said the code for task 2 must start with the code for task 1, and the code for task 2, def s(n,m):return [[w+i for w in r(n,m)] for i in a(0,m+1)], is a complete function when the code for task 1 defined.

You can do something like a=lambda n,m:... for each of your function definitions. Anonymous function are always shorter in python

It would save a few bytes (17) if you changed the list comprehension in 4 to sum(w,[])

Since 0<n<m is a guarantee, the result from Task 1 is always truthy, meaning that Task 2 can attach itself using an and: r=range;a=lambda n,m:r(n,m+1)and[[w+i for w in r(n,m)] for i in r(0,m+1)] for -9 bytes. Taking it further, Task 3 tacks itself onto the end of that with and[[w*i for w in r(1,n+1)] for i in r(1,m+1)]! Task 4's addition stays about the same, although lambda z: is shorter than lambda(z):

@ValueInk Wow, I never would have thought of that. Ill make the changes when I get access to s computer.

PHP 7, 200 bytes
Uses the output buffer to clear previous output.
Task 1
[,$n,$m]=$argv;ob_start();eval($s='echo join(" ",$v?:range($n+$i,$m+$i)),"
";');

Saves the code in $s to reuse it later. The $v variable is for the last task.
Task 2
[,$n,$m]=$argv;ob_start();eval($s='echo join(" ",$v?:range($n+$i,$m+$i)),"
";');for(;++$i<=$m;)eval($s);

Prints the remaining lines.
Task 3
[,$n,$m]=$argv;ob_start();eval($s='echo join(" ",$v?:range($n+$i,$m+$i)),"
";');for(;++$i<=$m;)eval($s);for(($c=ob_clean)();++$j<=$m;print"
")for(;++$$j<=$n;sort($v))echo$v[]=$j*$$j,' ';

Clears the output buffer and prints the multiplication table, saving the numbers to $v.
Task 4
[,$n,$m]=$argv;ob_start();eval($s='echo join(" ",$v?:range($n+$i,$m+$i)),"
";');for(;++$i<=$m;)eval($s);for(($c=ob_clean)();++$j<=$m;print"
")for(;++$$j<=$n;sort($v))echo$v[]=$j*$$j,' ';$c();eval($s);

Clears the output buffer again and prints $v.

PowerShell, 126 bytes
Task 1
param($n,$m)$n..$m

Try it online!
Uses the .. built-in range operator. The default behavior for the implied Write-Output inserts a newline between elements, so that's why the output shows as newline separated.

Task 2
param($n,$m)$n..$m>2;0..$m|%{$i=$_;($n..$m|%{$_+$i})-join','}

Try it online!
Dumps the first task to STDERR with >2;, then loops from 0 to $m, each iteration setting helper $i before looping again from $n to $m and incrementing each number by $i. Those are -joined together with commas, else this would be an ambiguous gigantic long one-element-per-line output.

Task 3
param($n,$m)$n..$m>2;0..$m|%{$i=$_;($n..$m|%{$_+$i})-join','}>2;(1..$m|%{$i=$_;(1..$n|%{$_*$i})-join' '})

Try it online!
Same sort of thing >2; to dump the previous to STDERR. Then we simply double-loop from 1 to $m then 1 to $n, setting helper $i along the way, multiply the values, and -join with a space to make it tabular. Note the encapsulating parens -- they'll come into play on the next task -- but here they just ensure that the output is put onto the pipeline (which it already would be, so they're redundant).

Task 4
param($n,$m)$n..$m>2;0..$m|%{$i=$_;($n..$m|%{$_+$i})-join','}>2;(1..$m|%{$i=$_;(1..$n|%{$_*$i})-join' '})-split' '|%{+$_}|sort

Try it online!
Aha! Finally some redundancy. Since the previous task has parens, we can tack on the -split on whitespace without worry, cast each one to an integer |%{+$_}, and then |sort. The output is again newline separated.

I think there are some ways to better leverage the redundancy between tasks -- still golfing it some.

ES2016-ish, 401 384 chars
Here's a first try. I'm sure it could be condensed a bit, but it's pretty short. Arrow functions FTW! (Love those implicit return statements.) New and improved with template strings!
Task 1
var a=Array,l=console.log,f=(n,m)=>a.from(a(1+m-n),(w,i)=>n+i),z=(n,m)=>l(f(n,m).join`, `)

Call z(n,m) for the log output. (I'm aliasing console.log for later golfing.)
Task 2
Second verse... expands on the first.
var a=Array,l=console.log,f=(n,m)=>a.from(a(1+m-n),(w,i)=>n+i),z=(n,m)=>l(f(n,m).join`, `),p,o,g=(n,m)=>{p=n,o=m;return [...a(m+1).keys()].map((d)=>f(d+p,d+o))},y=(n,m)=>l(g(n,m).join`\n`

Now call y(n,m). Pretty, no?
Task 3
Have to bypass most of the existing functionality <sadface />.
var a=Array,l=console.log,f=(n,m)=>a.from(a(1+m-n),(w,i)=>n+i),z=(n,m)=>l(f(n,m).join`, `),p,o,g=(n,m)=>{p=n,o=m;return [...a(m+1).keys()].map((d)=>f(d+p,d+o))},y=(n,m)=>l(g(n,m).join`\n`,h=(n,m)=>[...a(m).keys()].map((d)=>(d+1)*n).join`\t`,i=(n,m)=>[...a(n).keys()].map((d)=>h((d+1),m)),v=(n,m)=>i(n,m).join`\n`

Now the method name is v. Call it the same way.
Task 4
And now we can reuse again.
var a=Array,l=console.log,f=(n,m)=>a.from(a(1+m-n),(w,i)=>n+i),z=(n,m)=>l(f(n,m).join`, `),p,o,g=(n,m)=>{p=n,o=m;return [...a(m+1).keys()].map((d)=>f(d+p,d+o))},y=(n,m)=>l(g(n,m).join`\n`,h=(n,m)=>[...a(m).keys()].map((d)=>(d+1)*n).join`\t`,i=(n,m)=>[...a(n).keys()].map((d)=>h((d+1),m)),v=(n,m)=>i(n,m).join`\n`,t=(n,m)=>l(v(n,m).match(/\d+/g).sort((a,b)=>+a>+b||+(a===b)*2-1).join(`, `)

Had to skip u for my method, so it's t. Bummed that I had to put in that sort function, because the String.match returns values as... strings.

Ruby, 121 103 bytes
Everything in Ruby is truthy except for nil and false, which means that the tasks can be set up to ignore previous input with naught but a well-placed and/&&.
Task 1
Try it online!
n,m=$*.map &:to_i
p [*n..m]

Task 2
Try it online!
n,m=$*.map &:to_i
p [*n..m]&&(0..m).map{|i|[*n+i..m+i]}

Task 3
Try it online!
n,m=$*.map &:to_i
p [*n..m]&&(0..m).map{|i|[*n+i..m+i]}&&(1..m).map{|i|(1..n).map{|j|i*j}}

Task 4
Try it online!
n,m=$*.map &:to_i
p [*n..m]&&(0..m).map{|i|[*n+i..m+i]}&&(1..m).map{|i|(1..n).map{|j|i*j}}.flatten.sort

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
Divide one number by another
Challenge
Given two numbers, output their quotient. In other words, integer divide one number by another.
Both divisor/dividend will be under 10001. Division must be performed using integer division, rounding down.
Here are some example inputs and outputs:
5       1       5
-4      2       -2
4       -2      -2
6       2       3
16      4       4
36      9       4
15      2       7
17      3       5
43      5       8
500     5       100
500     100     5
10000   2       5000

Or as CSV:
5,1,5
-4,2,-2
4,-2,-2
6,2,3
16,4,4
36,9,4
15,2,7
17,3,5
43,5,8
500,5,100
500,100,5
10000,2,5000

Rules

Standard loopholes not allowed
You must use integer division, not floating point division
This is code-golf. Shortest answer wins, but will not be selected.
The second input (denominator) will never be equal to 0.

Why?
I'm interested in seeing answers in esoteric languages, like Brainfuck and Retina. Answers in regular languages will be trivial, however I would really like to see answers in these languages.
I will be giving a bounty of +50 reputation to a Retina answer.

Possible duplicate of Multiply two numbers

@ГригорийПерельман THis is differennt. integer multiplication does not translate well into integer division

Closely related: Division and remainder

@LuisMendo No remainder, expanded number range

Can we assume input is not 0?

@ГригорийПерельман Yes

Can we take input in binary or unary, or must it be decimal?

@ETHproductions Decimal.

Why the downvote?

Yes, this could only be considered a dupe for languages which have an easy way to perform multiplication and integer division (then again, that's most languages...)

Do we need to handle negative numbers? None of the test cases are negative, but the question only specifies denominator != 0.

Well, good luck getting a valid answer in BF. It's easy for positive integers, but negatives aren't possible without taking input as strings or something ugly.

You just invalidated almost all the interesting approaches...

-1 Challenge is lame when negatives are required.

The whole reason that the division and remainder challenge was on a restricted number range is because that allows more languages to compete.

That's why there's a Retina bounty...

I would recommend to allow people to use any base such as unary (if you want Retina/esoteric solutions), and only supply positive integers as input (for a similar reason).

I can't tell you the reason for the other downvotes, but mine is because I firmly believe that trivial questions like this are bad for the site.

-1 Challenge is lame when negatives are required as noted by @mbomb007, AND test cases were all positive!

JavaScript, 11 bytes
JavaScript doesn't have integers but using a bitwise or parses a float as a signed 32 bit integer.
a=>b=>a/b|0

Try it online

const f = a=>b=>a/b|0
alert(f(prompt())(prompt()))

Mathematica, 8 bytes
Quotient

Thanks to @JungHwanMin for reminding me there's a builtin.

Python 2, 14 11 bytes
int.__div__

Try it online

C (GCC), 13 bytes
Doesn't work on all implementations, but that's OK.
f(a,b){a/=b;}

Try it on TIO!

QBIC, 8 bytes
::?a'\`b

Explanation:
::    get a and b from the cmd line
?     Print
a \ b the backslash does integer division, (opposed to the forward slash / for float div)
  ' ` however, the same symbol is used for ELSE. We need to escape it with ' and `

Note that the latest version of QBIC allows for an inline use of the : function, saving two bytes:
?:'\`:

Pip, 4 bytes
a//b

Try it online!
Explanation:
      A and B are read implicitly from the cmd line
a//b  Calculate the int div of a and b (double slash == int div)
      Results of the last expression are printed implicitly.

CJam, 3 bytes
q~/

Try it online!

아희(Aheui), 15 bytes
방방나망희

Try it here! (please copy and paste the code manually)

Bash, 25 22 15 bytes
echo $(($1/$2))

Save to script, input numbers given at command line
Saved 3 bytes thanks to @betseg

Welcome to Programming Puzzles and Code Golf StackExchange! Nice first answer. Also, you can remove the space after the semicolon and the spaces inside parentheses.

Aceto, 6 bytes
riri/p

ri takes input as integer
/ does integer division
p prints it
Try it online!

PHP, 23 Bytes
<?=$argv[1]/$argv[2]^0;

or
<?=$argv[1]/$argv[2]|0;

and for 29 Bytes
<?=intdiv($argv[1],$argv[2]);

Jelly, 1 byte
:

Try it online!

05AB1E, 3 bytes
II÷
Try online
If you can reverse the input, it would work in 1 byte: ÷

Decimal, 12 bytes
81D81D44D301

Ungolfed:
81D   ; builtin 1 - read INT to stack
81D   ; builtin 1 - read INT to stack
44D   ; math divide (postfix /)
301   ; print from stack to output

Try it online!

Triangular, 6 bytes
$.$%_<

Try it online!
Formats into this triangle:
  $
 . $
% _ <

Without directionals and no-ops, the code looks like this: $$_%

$ - read input as integer
_ - divide
% - print

Retina, 28 bytes
\d+
*
~`(_+) (_+)
K`$1$nC`$2

Try it online!
I'm quite new to Retina; I probably could have golfed this more.
Explanation:
Let's start with an input: 38 4
\d+
*

This turns the numbers into unary, so 4 is represented as ____, and 38 with 38 underscores.
~`...

This marks a stage that generates code to run afterwards
(_+) (_+)
K`$1$nC`$2

This is a replace stage to generate the division code; Firstly, it splits the string into the dividend (referenced as $1) and divisor (referenced as $2). Then, it returns the string:
K`{dividend as unary}
C`{divisor as unary}

The returned string is evaluated and the answer implicitly printed. It sets the working string to the dividend, and counts the matches of the divisor in it.

20 bytes after golfing: Try it online!

Nice! I'd completely forgotten about this but that's an interesting golf

Keg, 3 bytes
¿¿/

Simply 2 nice inputs and then divides them.
TIO

Batch, 16 bytes
@cmd/cset/a%1/%2

set/a doesn't print its output inside a batch script, so we have to fake it out by starting a new copy of the command processor.

GML, 30 bytes
return argument0 div argument1

TI-Basic, 6 bytes
Input :iPart(X/Y

Retina, 40 38 bytes
\d+
*
(-?)(_+);(-?)(\2)*_*
$1$3$#4
--

Takes input in the format denominator;numerator. Also works for negative integers after the specs got changed, unlike the existing Retina answer.
-2 bytes thanks to @FryAmTheEggman thanks to a golf suggested in another Retina answer of mine.
Try it online.
Explanation:
Convert all numbers in the input to unary, replacing them with that amount of underscores:
\d+
*

Integer divide the two unary numbers (but with a decimal numbers as result), and filter all - to the front at the same time:
(-?)(_+);(-?)(\2)*_*
$1$3$#4

Remove any -- if present:
--

J-uby, 2 bytes

:/

Attempt This Online!

Ruby, 10 bytes
->i,j{i/j}

Extremely simple. Lambda function that returns the value i/j.

-1, if an answer is extremely short and boring with just the code, you should add a link, or an explanation, or a comment on the code or something other than My answer's really boring, so blah blah blah.

@DJMcMayhem Fixed

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/