挑战

给定一个（浮点数/小数）数字，返回其倒数，即1除以该数字。输出必须是浮点数/十进制数，而不仅仅是整数。

详细规格

• 您必须以浮点数/十进制数的形式接收输入...
  • ...具有至少4位有效数字（如果需要）。
  • 越多越好，但不计入分数。
• 您必须使用任何可接受的输出方法进行输出...
  • ...数字的倒数
  • 可以定义为1 / x，x -1。
  • 您必须输出至少4位有效数字精度（如果需要）。

输入为正或负，绝对值在[0.0001，9999]范围内。小数点后的位数永远不会超过4位，从第一个非零位数开始，位数也不会超过4位。输出必须精确到第一个非零数字的第4位。

（感谢@MartinEnder）

以下是一些示例输入：

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

请注意，永远不会为您提供精度超过4位数字的输入。

这是Ruby中的示例函数：

def reciprocal(i)
    return 1.0 / i
end

规则

• 允许所有接受的输出形式
• 禁止标准漏洞
• 这是代码高尔夫球，以字节为单位的最短答案将获胜，但不会被选择。

澄清说明

• 您将永远不会收到输入0。

赏金

在大多数语言中，这一挑战显然是微不足道的，但是在更加深奥和不寻常的语言中，它却可以提供一个有趣的挑战，因此，一些用户愿意为在异常困难的语言中做到这一点而加分。

• @DJMcMayhem将对最短的大脑Flak答案奖励+150点奖励，因为众所周知，对于浮点数来说，大脑Flak非常困难

• @ L3viathan将为最短的OIL答案奖励+150积分。OIL没有本机浮点类型，也没有除法。

• @Riley将为最短的sed答案奖励+100积分。

• @EriktheOutgolfer将为最短的Sesos答案奖励+100积分。在诸如Sesos这样的fuckfuck衍生产品中进行除法非常困难，更不用说浮点除法了。

• 我（@Mendeleev）将为最短的视网膜答案奖励+100积分。

如果您认为有一种语言会很有趣，并且愿意支付代表的酬劳，请随时在此列表中添加您的名字（按奖励金额排序）

排行榜

这是一个堆栈片段，用于按语言生成获奖者概览。

为确保您的答案显示出来，请使用以下Markdown模板以标题开头。

# Language Name, N bytes

N您提交的文件大小在哪里。如果您提高了分数，则可以通过打败旧分数来保持标题。例如：

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

如果要在标头中包含多个数字（例如，因为您的分数是两个文件的总和，或者您想单独列出解释器标志罚分），请确保实际分数是标头中的最后一个数字：

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

您还可以将语言名称设置为链接，然后该链接将显示在页首横幅代码段中：

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

var QUESTION_ID=114544,OVERRIDE_USER=62393;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={};e.forEach(function(e){var o=e.language;/<a/.test(o)&&(o=jQuery(o).text().toLowerCase()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link,uniq:o}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.uniq>s.uniq?1:e.uniq<s.uniq?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=617d0685f6f3"> <div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr></tbody> </table>

脑高射炮，772 536 530 482 480 + 1 = 481个字节

由于Brain-Flak不支持浮点数-c，因此我不得不使用该标志来按顺序输入和输出字符串，因此需要+1。

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

在线尝试！

说明

我们需要注意的第一件事是否定情况。由于负数的倒数始终为负，因此我们可以简单地保持负号直到结束。我们首先制作堆栈顶部的副本，然后-从中减去45（的ASCII值）。如果这是1，我们将零放在栈顶，否则，我们什么也不做。然后，我们拿起要放到程序末尾的堆栈顶部。如果输入以a开头，-则仍然是a，-但是如果不是，那么我们最终选择放置的零。

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

既然这样，我们就需要将每个数字的ASCII实现转换为实际值（0-9）。我们还将删除小数点.以简化计算。由于我们需要知道稍后在重新插入小数点时从何处开始，因此我们存储一个数字来跟踪.堆栈外小数点之前的位数。

代码是这样的：

我们.从堆栈中的每个元素减去46（的ASCII值）开始（同时将它们全部移至堆栈外）。这将使每个数字多于两个，但将.恰好为零。

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

现在，我们将所有内容移到左侧堆栈，直到命中零（走时从每个数字中减去两个）：

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

我们记录纸叠高度

([]<

将其他所有内容移到左侧堆栈（再次移动时，从每个数字中减去最后两位）

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

然后把我们记录下来的纸叠高度放下来

>)

现在，我们想将数字组合成一个基数为10的数字。我们还希望将10的幂乘以该数字的两倍来进行计算。

我们首先在堆栈顶部设置一个1，以使其为10的幂，然后将堆栈高度减去1推到堆栈上以进行循环使用。

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

现在，我们将堆栈高度减去1次循环，

{
 ({}[()]<

每次我们将最上面的元素乘以100，并将其下面的下一个元素乘以10，然后将其添加到下面的数字中。

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

我们结束循环

 >)
}{}

现在我们终于完成了设置，可以开始实际计算了。

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

就是这样

我们使用wiki上的0的整数除法算法，将10的幂除以输入的修改版本。这是Brain-Flak知道的唯一方式，可以模拟输入除以1。

最后，我们必须将输出格式化为适当的ASCII。

现在，我们已经找到了ne需要删除的文件e。第一步是将其转换为数字列表。该代码是0的divmod算法的修改版本。

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

现在我们获取数字并将小数点添加回其所属的位置。仅仅考虑代码的这一部分会让人头疼，因此，现在我将其作为练习让读者弄清楚它的工作原理和原因。

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

放下负号，如果没有负号，则放一个空字符。

>)

Python 2，10个字节

1..__div__

在线尝试！

视网膜，99 91字节

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

在线尝试！

Woohoo，低于100！考虑到它一次创建（然后匹配）一个包含10 ^7个以上字符的字符串，这是令人惊讶的高效。我确定这还不是最佳，但是我对目前的成绩感到非常满意。

绝对值小于1的结果将在打印时不带前导零，例如.123或-.456。

说明

基本思想是使用整数除法（因为使用正则表达式和一元算术相当容易）。为了确保获得足够数量的有效数字，我们将输入分为10 ⁷。这样，直到9999的任何输入仍会产生4位数字。有效地，这意味着我们将结果乘以10 ^7，因此在以后重新插入小数点时需要跟踪该结果。

1`\.|$
8$*;

我们从替换小数点开始，如果没有小数点，则以8个分号代替字符串的结尾。其中第一个实质上是小数点本身（但我使用分号是因为不需要转义），其他7表示该值已乘以10 ⁷（这不是事实，但我们知道以后会做）。

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

我们首先将输入转换为整数。只要小数点后仍然有数字，我们将一位移到最前面并删除其中一个分号。这是因为向右移动小数点会将输入乘以10，因此将结果除以10。由于输入限制，我们知道这种情况最多会发生四次，因此总有足够多的分号可以删除。

\d+
$*1,10000000$*

现在输入是整数，我们将其转换为一元并附加10 ⁷ 1 s（以分隔,）。

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

通过计算适合多少个反向引用（），我们将该整数分为10 ⁷$#2。这是标准的一元整数除法a,b-> b/a。现在我们只需要更正小数点的位置即可。

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

这基本上是第二阶段的逆过程。如果我们还有不止一个分号，那意味着我们仍然需要将结果除以10。为此，我们将分号向左移动一个位置，然后放下一个分号，直到到达数字的左端，或者只剩下一个分号（即小数点本身）为止。

1`;
.

现在是将第一个（也可能是唯一一个）转换;回的好时机.。

;
0

如果还剩下分号，我们已经到达数字的左端，因此再次除以10将在小数点后插入零。这是很容易替换每个其余做;了0，因为小数点后是反正。

yup，5个字节

|0~-e

在线尝试！这从堆栈的顶部获取输入，而将输出留在堆栈的顶部。TIO链接从命令行参数获取输入，该命令行参数只能接受整数输入。

说明

yup只有几个运算符。此答案中使用的是ln（x）（由表示|），0（）（常数，nilary函数返回0），-（减法）和exp（x）（由表示e）。~切换堆栈中的前两个成员。

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

这使用身份

这意味着

LOLCODE，63，56个字节

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

@devRicher节省了7个字节！

这定义了一个函数“ r”，可以使用以下函数调用它：

r 5.0

或任何其他NUMBAR。

在线尝试！

sed的，575 + 1（-r标志）= 723个 718 594 588 576字节

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/

在线尝试！

注意：绝对值小于1的浮点数必须写成前导0 .5而不是0.5。小数位数也等于，其中n是数字中的小数位数（因此，13.0作为输入给出的位数比13作为输入给出的位数多）

这是我在PPCG上的第一个sed提交。从这个惊人的答案中得出了十进制转换为一元的想法。感谢@seshoumara指导我完成sed！

该代码执行重复的长除法以获得结果。该划分仅占用约150个字节。一进制十进制转换占用最多字节，而其他几个字节则用于支持负数和浮点输入

说明

关于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/

编辑

• s:s/(.)/(.)/g:y/\1/\2/g:g 每次替换节省1个字节（总共5个）
• 通过在“ sed高尔夫技巧”中查看一个不错的十进制到一元转换器，节省了一吨字节
• 我改变了一些替换方法，围绕替换负号节省了6个字节。
• 使用\n而不是;用作分隔符，然后我能够缩短“乘以10”的替换以节省12个字节（感谢@Riley和@seshoumara向我展示了这一点）

JSFuck，3320字节

JSFuck是基于JavaScript原子部分的深奥和教育性编程风格。它仅使用六个不同的字符()[]+!来编写和执行代码。

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

在线尝试！

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

OIL，1428 1420字节

那好吧。我认为我不妨尝试一下，最终我成功了。有一个缺点：运行所需的时间几乎与编写所需的时间相同。

该程序分为多个文件，这些文件具有所有1字节的文件名（并在我的字节计算中计入一个额外的字节）。其中一些文件是OIL语言示例文件的一部分，但没有真正的方法可以一致地调用它们（OIL中尚无搜索路径或类似内容，因此我不认为它们是标准库），但是这也意味着（在发布时）某些文件比必要的文件更冗长，但通常只有几个字节。

计算精确到4位精度，但是即使是简单的倒数（例如input 3）也要花费很长时间（超过5分钟）来完成。为了进行测试，我还做了一个较小的变体，精确到2位数字，只需几秒钟即可运行，以证明它确实有效。

对于这个巨大的答案，我感到抱歉，我希望我可以使用某种破坏标签。如果需要，我也可以将其大部分放到gist.github.com或类似的东西上。

我们开始：main，217个字节（文件名不计字节）：

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 （检查给定的字符串是否在给定的其他字符串中），74 + 1 = 75字节：

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 （连接两个给定的字符串），20 + 1 = 21个字节：

5
0
5
1
13
0
2
0
4
0

c （给出一个符号，在给定的字符串首次出现时将其拆分），143 + 1 = 144个字节（显然，这个仍然可以打高尔夫球）：

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 （给定一个字符串，获取前4个字符），22 + 1 = 23个字节：

5
0
12
0
20
13
21
4

4

e （高级分割（但零分割危险）），138 + 1 = 139字节：

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 （将点向右移动4个位置；“除以10000”），146 + 1 = 147字节：

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 （检查字符串是否以给定字符开头），113 + 1 = 114个字节：

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 （返回给定字符串的第一个字符以外的所有内容），41 + 1 = 42个字节：

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

0
4
0

i （减去两个数字），34 + 1 = 35个字节：

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

j （在所有情况下均无效的低级划分），134 + 1 = 135字节：

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 （乘法），158 + 1 = 159字节：

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 （返回绝对值），58 + 1 = 59字节：

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

0
6
10

m （加法），109 + 1 = 110字节：

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个字节

%

%是给出其输入的倒数的函数。你可以这样运行

   % 2
0.5

出租车，467字节

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.

在线尝试！

取消高尔夫：

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.

Vim，10 8字节/击键

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

由于V向后兼容，因此您可以在线尝试！

x86_64 Linux机器语言，5个字节

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

要对此进行测试，您可以编译并运行以下C程序

#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) );
  }
}

在线尝试！

C，15 12字节

#define f 1/

在线尝试！

16 13字节，如果还需要处理整数输入：

#define f 1./

因此，您可以使用f(3)代替调用它f(3.0)。

在线尝试！

感谢@hvd打高尔夫球3个字节！

MATLAB /八度，4字节

@inv

创建一个功能手柄（命名ans）的内置inv功能

在线演示

05AB1E，1个字节

z

在线尝试！

z # pop a  push 1 / a

GNU sed，377362 + 1（r标志）= 363字节

警告：程序将耗尽所有试图运行的系统内存，并且需要比您愿意等待的时间更多的时间来完成！请参阅下面的说明和快速但不太精确的版本。

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:

这是基于马丁·恩德（Martin Ender）对视网膜的回答。我\t从第2行算起文字标签（1个字节）。

我的主要贡献是从十进制到普通一元数的转换方法（第2行），反之亦然（第5行）。与上一个技巧中显示的方法相比，我设法大大减少了执行此操作所需的代码大小（减少了约40个字节）。我用详细信息创建了一个单独的提示答案，在其中提供了可供使用的摘要。由于不允许输入0，因此节省了更多字节。

说明：为了更好地理解除法算法，请先阅读视网膜答案

该程序在理论上是正确的，之所以要消耗大量的计算资源，是因为除法步骤要运行数十万次，或多或少取决于输入，并且所使用的正则表达式引起了回溯的噩梦。快速版本会降低精度（因此会增加除法步数），并更改正则表达式以减少回溯。

不幸的是，sed没有像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

要获得该程序的快速和安全版本，但要降低精度，可以在线进行尝试。

Japt，2个字节

显而易见的解决方案是

1/U

从字面上看，这就是1 / input。但是，我们可以做得更好：

pJ

这等效于input ** J，J默认情况下设置为-1。

在线尝试！

有趣的事实：p幂函数q也是如此，根函数（p2= **2，q2= **(1/2)）也是如此；这意味着qJ，由于-1 == 1/-1，因此也将起作用x**(-1) == x**(1/-1)。

Javascript ES6，6个字节

x=>1/x

在线尝试！

JavaScript默认为浮点除法。

APL，1个字节

÷

÷用作单数函数时计算倒数。在线尝试！

使用Dyalog Classic字符集。

切达 5字节

1&(/)

在线尝试！

这使用&将参数绑定到函数。在这种情况下，1绑定到的左侧/，这给了我们1/x一个参数x。比标准规范短x->1/x1个字节。

或者，在较新的版本中：

(1:/)

Java 8，6字节

x->1/x

几乎与JavaScript答案相同。

MATL，3个字节

l_^

在MATL Online上尝试

说明

    % Implictily grab input
l_  % Push -1 to the stack
^   % Raise the input to the -1 power
    % Implicitly display the result

Python，12个字节

lambda x:1/x

13个字节中的一个：

(-1).__rpow__

14个字节中的一个：

1 .__truediv__

Mathematica，4个字节

1/#&

如果提供精确的有理数，则为您提供精确的有理数；如果提供精确的有理数，则为您提供浮点数的结果。

ZX Spectrum BASIC，13个字节

1 INPUT A: PRINT SGN PI/A

笔记：

• 每行的行号费用为2个字节，行的长度为2个字节，换行符为1个字节
• 数值文字会在解析时转换为二进制，这会花费额外的6个字节，因此使用了SGN PI代替文字1。
• 关键字每个占用1个字节。

ZX81版本的17个字节：

1 INPUT A
2 PRINT SGN PI/A

Haskell，4个字节

(1/)

在线尝试！

R，8个字节

1/scan()

非常简单。直接输出输入的逆。

另一个但长1个字节的解决方案可以是：scan()^-1，甚至scan()**-1可以再增加一个字节。两者^和**电源符号。

TI基本（TI-84 Plus CE），6 5 2字节

Ans⁻¹

-1个字节感谢Timtech。

-3个字节，Ans感谢ГригорийПерельман。

Ans和⁻¹是一字节令牌。

TI-Basic隐式返回最后计算的值（Ans⁻¹）。

果冻，1字节

İ

在线尝试！

C，30个字节

float f(float x){return 1./x;}