チャレンジ

（浮動小数点/ 10進数）数を指定して、その逆数、つまり1を数で割った値を返します。出力は、単なる整数ではなく、浮動小数点/ 10進数でなければなりません。

詳細仕様

• 入力を浮動小数点/ 10進数の形式で受け取る必要があります...
  • ...少なくとも有効数字4桁の精度が必要です（必要な場合）。
  • 多いほど良いですが、スコアには含まれません。
• 許容可能な出力方法で出力する必要があります...
  • ...数の逆数。
  • これは、1 / x、x⁻¹として定義できます。
  • 少なくとも有効数字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

ルール

• 受け入れられたすべての形式の出力が許可されます
• 禁止されている標準的な抜け穴
• これはcode-golfで、バイト単位の最短回答が勝ちますが、選択されません。

明確化

• 入力を受け取ることはありません0。

報奨金

この課題はほとんどの言語では明らかに些細なことですが、より難解で異常な言語では楽しい課題になる可能性があります。

• @DJMcMayhemは、ブレインフラックは浮動小数点数では難しいことで有名なので、最短のブレインフラックの回答に対して+150ポイントの賞金を授与します。

• @ L3viathanは、最短のOIL回答に対して+150ポイントの報奨金を授与します。OILにはネイティブの浮動小数点型はなく、除算もありません。

• @Rileyは、最短のsed回答に対して+100ポイントの報奨金を授与します。

• @EriktheOutgolferは、セソスの最短回答に対して+100ポイントの報奨金を授与します。浮動小数点除算はもちろん、セソスなどの頭脳派生物の除算は非常に困難です。

• I（@Mendeleev）はRetinaの最短回答に対して+100ポイントの報奨金を授与します。

回答を見るのが楽しいと思う言語があり、担当者に支払いを希望する場合は、お気軽にこのリストに名前を追加してください（賞金額でソート）

リーダーボード

これは、言語ごとに勝者の概要を生成するスタックスニペットです。

回答が表示されるようにするには、次のマークダウンテンプレートを使用して、見出しから回答を開始してください。

# Language Name, N bytes

N提出物のサイズはどこですか。スコアを改善する場合、古いスコアを打つことで見出しに残すことができます。例えば：

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

ヘッダーに複数の数字を含める場合（たとえば、スコアが2つのファイルの合計であるか、インタープリターフラグペナルティーを個別にリストする場合）、実際のスコアがヘッダーの最後の数字であることを確認します。

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

Brain-Flak、772 536 530 482 480 + 1 = 481バイト

Brain-Flakは浮動小数点数をサポートしていない-cので、文字列で入出力を行うためにフラグを使用する必要がありました。したがって、+ 1です。

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

オンラインでお試しください！

説明

最初に注意する必要があるのは否定的なケースです。負の数の逆数は常に負なので、最後まで負の符号を保持するだけです。まず、スタックの最上部のコピーを作成し、-そこから45（ASCII値）を減算します。これが1の場合、スタックの一番上にゼロを置き、そうでない場合は何もしません。次に、プログラムの最後に置くスタックの一番上を選択します。入力が-これで始まる場合、これはまだですが、-そうでない場合は、配置したゼロを拾います。

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

これで、各桁のASCII認識を実際の値（0〜9）に変換する必要がなくなりました。また.、計算を容易にするために小数点を削除します。後で再挿入するときに小数点がどこから始まったのかを知る必要があるため.、オフスタックの前の桁数を追跡するために数値を保存します。

コードの仕組みは次のとおりです。

.スタック上の各要素から46（ASCII値）を減算することから始めます（同時にすべてをオフスタックに移動します）。これにより、各桁が本来よりも2つ多くなりますが、.正確にゼロになります。

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

ここで、ゼロに達するまですべてを左スタックに移動します（移動中に各桁から2を引きます）。

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

スタックの高さを記録します

([]<

他のすべてを左のスタックに移動します（移動するたびに、すべての数字から最後の2を再び減算します）

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

そして、記録したスタックの高さを記録します

>)

次に、数字を1つの基数10の数値に結合します。また、計算で使用するために、その数の2桁の数字で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 ⁷文字を超える文字列を作成（および照合）することを考えると、驚くほど効率的です。まだ最適とは言えませんが、現時点では満足しています。

絶対値が1未満の結果は、先行ゼロなしで出力されます（例：.123または）-.456。

説明

基本的な考え方は、整数除算を使用することです（正規表現と単項算術ではかなり簡単だからです）。十分な数の有効数字を取得するために、入力を10 ^7に分割します。この方法では、最大9999までの入力でも4桁の数字になります。事実上、結果に10 ^7を掛けるので、後で小数点を再挿入するときにそれを追跡する必要があります。

1`\.|$
8$*;

小数点を置き換えることから始めます。8セミコロンの小数点がない場合は、文字列の末尾を置き換えます。最初の1つは本質的に小数点そのものです（ただし、エスケープする必要がないため、セミコロンを使用しています）。他の7は値に10 ⁷が乗算されたことを示します（まだそうではありませんが、ただし、後で行うことはわかっています）。

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

まず、入力を整数に変換します。小数点の後にまだ数字がある限り、1桁を前に移動し、セミコロンの1つを削除します。これは、小数点を右に移動すると入力が10倍され、結果が10で除算されるためです。入力制限により、これは最大4回発生することがわかっているため、削除するセミコロンは常に十分です。

\d+
$*1,10000000$*

入力が整数になったので、それを単項に変換し、10 ^7を 1（で区切って,）追加します。

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

それに適合する後方参照の数を数えることにより、整数を10 ^7に分割します（$#2）。これは標準の単項整数除算a,b-> b/aです。ここで、小数点の位置を修正するだけです。

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

これは基本的に第2段階の逆です。それでもセミコロンが複数ある場合、結果を10で割る必要があります。これを行うには、セミコロンを1ポジション左に移動し、数値の左端に達するか、セミコロン（小数点自体）が1つだけになるまでセミコロンを1つドロップします。

1`;
.

今が、最初の（そしておそらく唯一の）をに;戻す良い機会.です。

;
0

まだセミコロンが残っている場合は、数値の左端に到達しているため、10で再び割ると、小数点の後ろにゼロが挿入されます。とにかく小数点の直後にあるため、残り;をそれぞれに置き換えることで簡単に行え0ます。

うん、5バイト

|0~-e

オンラインでお試しください！これは、スタックの最上部から入力を受け取り、スタックの最上部に出力を残します。TIOリンクはコマンドライン引数から入力を取得します。コマンドライン引数は整数入力のみを取得できます。

説明

yupには少数の演算子しかありません。この回答で使用されるのは、ln（x）（で表される|）、0（）（定数、nilary関数が返す0）、-（減算）、およびexp（x）（で表されるe）です。~スタックの上の2つのメンバーを切り替えます。

|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より小さい浮動小数点数は、の.5代わりに0を先頭に付けずに記述する必要があり0.5ます。また、小数点以下の桁数はに等しくなります。ここnで、数値の小数点以下の桁数です（13.0入力として指定すると、入力として指定するよりも小数点以下の桁数が多くなり13ます）

これはPPCGに関する私の最初のsed提出です。小数から単数への変換のアイデアは、この驚くべき答えから得られました。sedを案内してくれた@seshoumaraに感謝します！

このコードは、結果を得るために繰り返し長い除算を実行します。分割には、〜150バイトしかかかりません。単項10進変換は、ほとんどのバイトを使用し、他のいくつかのバイトは、負の数と浮動小数点入力のサポートに使用されます

説明

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のアトミックな部分に基づいた難解で教育的なプログラミングスタイルです。()[]+!コードの記述と実行に使用するのは6つの異なる文字のみです。

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

オンラインでお試しください！

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

OIL、1428 1420バイト

しかたがない。私も試してみようと思ったのですが、最終的に成功しました。欠点が1つだけあります。実行にかかる時間は、書き込みにかかる時間とほぼ同じです。

プログラムは、すべて1バイトのファイル名を持つ複数のファイルに分割されます（そして、バイト計算で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 （指定された2つの文字列を結合）、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 （2つの数値を減算）、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)。

オンラインでお試しください！

3バイトのゴルフをしてくれた@hvdに感謝します！

MATLAB /オクターブ、4バイト

@inv

ans組み込み関数への関数ハンドル（名前付き）を作成しinvます

オンラインデモ

05AB1E、1バイト

z

オンラインでお試しください！

z # pop a  push 1 / a

GNU sed、377 362 + 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によるRetinaの回答に基づいています。\t行2からリテラルタブ（1バイト）としてカウントします。

私の主な貢献は、10進数から単純な単項への変換方法（行2）、およびその逆（行5）です。前のヒントで示した方法と比較して、これを行うのに必要なコードのサイズを（合計で〜40バイト）大幅に削減することができました。別のヒントの回答を作成しましたすぐに使用できるスニペットを提供する詳細を含む、。0は入力として許可されていないため、さらに数バイトが保存されました。

説明：除算アルゴリズムをよりよく理解するには、最初にRetinaの回答を読んでください

プログラムは理論的には正しいです。計算リソースを大量に消費する理由は、除算ステップが入力に応じて何十万回も実行され、使用される正規表現が悪夢を引き起こすことです。高速バージョンでは精度が低下するため（除算ステップの数）、正規表現が変更されてバックトラッキングが削減されます。

残念ながら、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つ：

(-1).__rpow__

14バイトに1つ：

1 .__truediv__

Mathematica、4バイト

1/#&

正確な有理数を与えると正確な有理数を提供し、浮動小数点数の結果を与えると浮動小数点数の結果を提供します。

ZX Spectrum BASIC、13バイト

1 INPUT A: PRINT SGN PI/A

ノート：

• 各行には、行番号に2バイト、行の長さに2バイト、改行に1バイトかかります。
• 数値リテラルは解析時にバイナリに変換されるため、6バイト余分にかかるため、SGN PIliteral の代わりに使用します1。
• キーワードはそれぞれ1バイトかかります。

17バイトのZX81バージョン：

1 INPUT A
2 PRINT SGN PI/A

Haskell、4バイト

(1/)

オンラインでお試しください！

R、8バイト

1/scan()

とても簡単です。入力の逆を直接出力します。

別の、ただし1バイト長いソリューションは、、scan()^-1またはscan()**-1追加のバイトの場合もあります。両方^と**力のシンボル。

TI-Basic（TI-84 Plus CE）、6 5 2バイト

Ans⁻¹

Timtechのおかげで-1バイト。

ГригорийПерельманのAnsおかげで-3バイト。

Ansおよび⁻¹は、1バイトのトークンです。

TI-Basicは、最後に評価された値（Ans⁻¹）を暗黙的に返します。

ゼリー、1バイト

İ

オンラインでお試しください！

C、30バイト

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