Tantangan

Diberi angka (floating-point / desimal), kembalikan timbal baliknya, yaitu 1 dibagi dengan angka. Output harus berupa floating-point / angka desimal, bukan hanya bilangan bulat.

Spesifikasi detail

• Anda harus menerima input dalam bentuk angka floating-point / desimal ...
  • ... yang memiliki setidaknya 4 digit presisi signifikan (jika perlu).
  • Lebih banyak lebih baik, tetapi tidak diperhitungkan dalam skor.
• Anda harus mengeluarkan, dengan metode keluaran apa pun yang dapat diterima ...
  • ... kebalikan dari nomor tersebut.
  • Ini dapat didefinisikan sebagai 1 / x, x⁻¹.
  • Anda harus mengeluarkan setidaknya 4 digit presisi (jika perlu).

Input akan positif atau negatif, dengan nilai absolut dalam kisaran [0,0001, 9999] inklusif. Anda tidak akan pernah diberikan lebih dari 4 digit melewati titik desimal, atau lebih dari 4 digit mulai dari angka pertama yang bukan nol. Output harus akurat hingga digit ke-4 dari yang bukan nol pertama.

(Terima kasih @MartinEnder)

Berikut beberapa contoh input:

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

Perhatikan bahwa Anda tidak akan pernah diberi input yang memiliki presisi di atas 4 digit.

Berikut adalah contoh fungsi di Ruby:

def reciprocal(i)
    return 1.0 / i
end

Aturan

• Semua bentuk output yang diterima diizinkan
• Celah standar dilarang
• Ini adalah kode-golf , jawaban terpendek dalam byte menang, tetapi tidak akan dipilih.

Klarifikasi

• Anda tidak akan pernah menerima input 0.

Bounties

Tantangan ini jelas sepele di sebagian besar bahasa, tetapi dapat menawarkan tantangan yang menyenangkan dalam bahasa yang lebih esoteris dan tidak biasa, sehingga beberapa pengguna bersedia memberikan poin untuk melakukan hal ini dalam bahasa yang sangat sulit.

• @DJMcMayhem akan memberikan hadiah +150 poin untuk jawaban brain-flak terpendek, karena brain-flak terkenal sulit untuk angka floating-point

• @ L3viathan akan memberikan hadiah +150 poin untuk jawaban OIL terpendek . OIL tidak memiliki tipe floating point asli, juga tidak memiliki divisi.

• @Riley akan memberikan hadiah +100 poin untuk jawaban sed terpendek.

• @EriktheOutgolfer akan memberikan hadiah +100 poin untuk jawaban Sesos tersingkat. Pembagian dalam turunan brainfuck seperti Sesos sangat sulit, apalagi divisi titik-mengambang.

• Saya ( @Mendeleev ) akan memberikan hadiah +100 poin untuk jawaban Retina terpendek.

Jika ada bahasa yang Anda pikir akan menyenangkan untuk melihat jawabannya, dan Anda bersedia membayar perwakilan, jangan ragu untuk menambahkan nama Anda ke dalam daftar ini (diurutkan berdasarkan jumlah hadiah)

Papan peringkat

Berikut ini adalah Stack Snippet untuk menghasilkan ikhtisar pemenang berdasarkan bahasa.

Untuk memastikan bahwa jawaban Anda muncul, silakan mulai jawaban Anda dengan tajuk utama, menggunakan templat Penurunan harga berikut:

# Language Name, N bytes

di mana Nukuran kiriman Anda. Jika Anda meningkatkan skor Anda, Anda bisa menyimpan skor lama di headline, dengan mencoretnya. Contohnya:

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

Jika Anda ingin memasukkan beberapa angka dalam tajuk Anda (mis. Karena skor Anda adalah jumlah dari dua file atau Anda ingin membuat daftar hukuman penterjemah secara terpisah), pastikan bahwa skor sebenarnya adalah angka terakhir di tajuk:

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

Anda juga dapat membuat tautan nama bahasa yang kemudian akan muncul di cuplikan papan peringkat:

# [><>](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 byte

Karena Brain-Flak tidak mendukung angka floating point, saya harus menggunakan -cflag untuk input dan output dengan string, maka +1.

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

Cobalah online!

Penjelasan

Hal pertama yang perlu kita tangani adalah kasus negatif. Karena kebalikan dari angka negatif selalu negatif, kita bisa berpegangan pada tanda negatif sampai akhir. Kami mulai dengan membuat salinan bagian atas tumpukan dan mengurangi 45 (nilai ASCII -) dari itu. Jika ini yang kita masukkan nol di atas tumpukan, jika tidak kita tidak melakukan apa-apa. Kemudian kita mengambil bagian atas tumpukan untuk diletakkan di akhir program. Jika input dimulai dengan -ini masih -namun jika tidak kita akhirnya mengambil nol yang kita tempatkan.

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

Sekarang setelah keluar dari jalan, kita perlu mengubah realisasi ASCII dari setiap digit menjadi nilai aktual di sana (0-9). Kami juga akan menghapus titik desimal .untuk mempermudah perhitungan. Karena kita perlu tahu di mana titik desimal dimulai ketika kita memasukkan kembali nanti, kita menyimpan angka untuk melacak berapa digit di depan .offstack.

Berikut adalah bagaimana kode melakukan itu:

Kita mulai dengan mengurangi 46 (nilai ASCII .) dari setiap elemen di stack (secara bersamaan memindahkan semuanya ke offstack). Ini akan membuat setiap digit dua lebih dari yang seharusnya tetapi akan menghasilkan .nol.

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

Sekarang kita memindahkan semuanya ke tumpukan kiri sampai mencapai nol (mengurangi dua dari setiap digit saat kita pergi):

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

Kami merekam ketinggian tumpukan

([]<

Pindahkan segala sesuatu yang lain ke tumpukan kiri (sekali lagi kurangi dua terakhir dari setiap digit saat kita memindahkannya)

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

Dan menempatkan ketinggian tumpukan yang kami rekam

>)

Sekarang kami ingin menggabungkan digit ke dalam basis 10 nomor tunggal. Kami juga ingin membuat kekuatan 10 dengan dua kali digit sebagai angka untuk digunakan dalam perhitungan.

Kita mulai dengan mengatur 1 di atas tumpukan untuk menghasilkan kekuatan 10 dan mendorong tinggi tumpukan minus satu ke tumpukan di atas untuk penggunaan perulangan.

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

Sekarang kita memutar tinggi tumpukan minus 1 kali,

{
 ({}[()]<

Setiap kali kita mengalikan elemen teratas dengan 100 dan di bawahnya mengalikan elemen berikutnya dengan 10 dan menambahkannya ke nomor di bawah ini.

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

Kami mengakhiri lingkaran kami

 >)
}{}

Sekarang kita akhirnya selesai dengan pengaturan dan dapat memulai perhitungan yang sebenarnya.

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

Itu dia ...

Kami membagi kekuatan 10 oleh versi modifikasi dari masukan menggunakan 0 ' 's algoritma pembagian integer seperti yang ditemukan di wiki . Ini mensimulasikan pembagian 1 dengan input satu-satunya cara Brain-Flak tahu caranya.

Terakhir kita harus memformat output kita ke ASCII yang sesuai.

Sekarang kami telah menemukan nekami perlu mengambil e. Langkah pertama untuk ini adalah mengubahnya menjadi daftar digit. Kode ini adalah versi modifikasi dari 0 ' 's algoritma divmod .

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

Sekarang kita ambil nomornya dan tambahkan titik desimal kembali ke tempatnya. Hanya dengan memikirkan bagian kode ini akan memunculkan sakit kepala kembali, jadi untuk sekarang saya akan membiarkannya sebagai latihan bagi pembaca untuk mengetahui bagaimana dan mengapa ia bekerja.

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

Letakkan tanda negatif ke bawah atau karakter nol jika tidak ada tanda negatif.

>)

Python 2 , 10 byte

1..__div__

Cobalah online!

Retina , 99 91 byte

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

Cobalah online!

Woohoo, sub-100! Ini sangat efisien, mengingat ia menciptakan (dan kemudian cocok dengan) string dengan lebih dari 10 ⁷ karakter pada satu titik. Saya yakin itu belum optimal, tetapi saya cukup senang dengan skor saat ini.

Hasil dengan nilai absolut kurang dari 1 akan dicetak tanpa nol di depan, misalnya .123atau -.456.

Penjelasan

Ide dasarnya adalah menggunakan pembagian integer (karena itu cukup mudah dengan regex dan aritmatika unary). Untuk memastikan bahwa kami mendapatkan angka signifikan yang cukup, kami membagi input menjadi 10 ⁷ . Dengan begitu, setiap input hingga 9999 masih menghasilkan angka 4 digit. Secara efektif, itu berarti kita mengalikan hasilnya dengan 10 ⁷ sehingga kita perlu melacaknya ketika nanti masukkan kembali titik desimal.

1`\.|$
8$*;

Kita mulai dengan mengganti titik desimal, atau akhir string jika tidak ada titik desimal dengan 8 titik koma. Yang pertama dari mereka pada dasarnya adalah titik desimal itu sendiri (tapi saya menggunakan titik koma karena mereka tidak perlu melarikan diri), 7 lainnya menunjukkan bahwa nilai telah dikalikan dengan 10 ⁷ (ini belum terjadi, tapi kami tahu kami akan melakukannya nanti).

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

Kami pertama-tama mengubah input menjadi bilangan bulat. Selama masih ada digit setelah titik desimal, kami memindahkan satu digit ke depan dan menghapus salah satu dari titik koma. Ini karena memindahkan titik desimal ke kanan mengalikan input dengan 10 , dan karenanya membagi hasilnya dengan 10 . Karena batasan input, kami tahu ini akan terjadi paling banyak empat kali, jadi selalu ada cukup titik koma untuk dihapus.

\d+
$*1,10000000$*

Sekarang inputnya adalah integer, kami mengonversinya menjadi unary dan menambahkan 10 ⁷ 1 s (dipisahkan oleh a ,).

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

Kami membagi bilangan bulat menjadi 10 ⁷ dengan menghitung berapa banyak referensi yang cocok ( $#2). Ini adalah divisi integer standar unary a,b-> b/a. Sekarang kita hanya perlu memperbaiki posisi titik desimal.

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

Ini pada dasarnya kebalikan dari tahap kedua. Jika kita masih memiliki lebih dari satu titik koma, itu artinya kita masih perlu membagi hasilnya dengan 10 . Kami melakukan ini dengan memindahkan titik koma satu posisi ke kiri dan menjatuhkan satu titik koma hingga kami mencapai ujung kiri angka tersebut, atau kami hanya memiliki satu titik koma (yang merupakan titik desimal itu sendiri).

1`;
.

Sekarang adalah saat yang tepat untuk mengubah yang pertama (dan mungkin hanya) ;kembali ..

;
0

Jika masih ada titik koma yang tersisa, kami telah mencapai ujung kiri angka tersebut, jadi membaginya dengan 10 lagi akan memasukkan nol di belakang titik desimal. Ini mudah dilakukan dengan mengganti setiap sisa ;dengan 0, karena mereka tetap setelah titik desimal.

yup , 5 byte

|0~-e

Cobalah online! Ini mengambil input dari atas tumpukan dan meninggalkan output di atas tumpukan. TIO link mengambil input dari argumen baris perintah, yang hanya mampu mengambil input integer.

Penjelasan

yup hanya memiliki beberapa operator. Yang digunakan dalam jawaban ini adalah ln (x) (diwakili oleh |), 0 () (konstan, fungsi nilary kembali 0), - (pengurangan), dan exp (x) (diwakili oleh e). ~mengaktifkan dua anggota teratas di tumpukan.

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

Ini menggunakan identitas

yang menyiratkan itu

LOLCODE , 63 , 56 byte

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

7 byte disimpan berkat @devRicher!

Ini mendefinisikan fungsi 'r', yang dapat dipanggil dengan:

r 5.0

atau yang lainnya NUMBAR.

Cobalah online!

sed , 575 +1 ( -rbendera) = 723 718 594 588 576 byte

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/

Cobalah online!

Catatan: mengapung yang nilai absolut kurang dari 1 akan harus ditulis tanpa awalan 0 seperti .5bukan 0.5. Juga jumlah tempat desimal sama dengan , di mana njumlah tempat desimal dalam angka (jadi memberi13.0 sebagai input akan memberi lebih banyak tempat desimal daripada memberi 13sebagai input)

Ini adalah pengajuan sed pertama saya di PPCG. Gagasan untuk konversi desimal ke unaris diambil dari jawaban yang luar biasa ini . Terima kasih kepada @seshoumara karena membimbing saya melalui sed!

Kode ini melakukan pembagian panjang berulang untuk mendapatkan hasilnya. Divisi ini hanya membutuhkan ~ 150 byte. Konversi unimal-desimal mengambil sebagian besar byte, dan beberapa byte lainnya digunakan untuk mendukung angka negatif dan input floating-point

Penjelasan

Penjelasan tentang 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/

Suntingan

• s:s/(.)/(.)/g:y/\1/\2/g:g untuk menyimpan 1 byte di setiap substitusi (total 5)
• Menghemat satu ton byte dengan melihat konverter desimal ke unary yang bagus pada "Tips untuk bermain golf di sed"
• Saya mengubah beberapa pergantian di sekitar merawat tanda minus untuk menghemat 6 byte.
• Digunakan \nalih-alih ;sebagai pemisah, maka saya dapat mempersingkat substitusi "kalikan dengan 10" untuk menghemat 12 byte (terima kasih kepada @Riley dan @seshoumara karena menunjukkan kepada saya ini)

JSFuck , 3320 byte

JSFuck adalah gaya pemrograman esoterik dan pendidikan yang didasarkan pada bagian atom JavaScript. Hanya menggunakan enam karakter berbeda ()[]+!untuk menulis dan mengeksekusi kode.

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

Cobalah online!

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

MINYAK , 1428 1420 byte

Baiklah. Saya pikir saya mungkin juga mencobanya, dan pada akhirnya saya berhasil. Hanya ada satu kelemahan: Butuh waktu hampir lama untuk berjalan seperti yang dibutuhkan untuk menulis.

Program ini dipisahkan menjadi beberapa file, yang memiliki semua nama file 1-byte (dan menghitung satu byte tambahan dalam perhitungan byte saya). Beberapa file adalah bagian dari contoh file dari bahasa OIL, tetapi tidak ada cara nyata untuk memanggil mereka secara konsisten (belum ada jalur pencarian atau semacamnya di OIL, jadi saya tidak menganggapnya sebagai perpustakaan standar), tetapi itu juga berarti bahwa (pada saat memposting) beberapa file lebih bertele-tele daripada neccessary, tetapi biasanya hanya dengan beberapa byte.

Perhitungannya akurat hingga 4 digit presisi, tetapi menghitung bahkan timbal balik sederhana (seperti input 3) membutuhkan waktu yang sangat lama (lebih dari 5 menit) untuk diselesaikan. Untuk tujuan pengujian, saya juga membuat varian minor yang akurat hingga 2 digit, yang hanya membutuhkan beberapa detik untuk menjalankannya, untuk membuktikan bahwa itu berfungsi.

Maaf atas jawaban yang sangat besar, saya berharap saya bisa menggunakan semacam tag spoiler. Saya juga bisa meletakkan sebagian besar di gist.github.com atau yang serupa, jika diinginkan.

Kita mulai main:, 217 byte (nama file tidak masuk hitungan untuk byte):

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 (memeriksa apakah string yang diberikan dalam string lain yang diberikan), 74 + 1 = 75 byte:

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 (bergabung dengan dua string yang diberikan), 20 + 1 = 21 byte:

5
0
5
1
13
0
2
0
4
0

c (diberi simbol, pisahkan string yang diberikan pada kemunculannya yang pertama), 143 +1 = 144 byte (yang ini jelas masih golf):

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 (diberi string, dapatkan 4 karakter pertama), 22 + 1 = 23 byte:

5
0
12
0
20
13
21
4

4

e (divisi tingkat tinggi (tetapi dengan bahaya nol divisi)), 138 +1 = 139 byte:

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 (memindahkan posisi titik 4 ke kanan; "membagi" dengan 10.000), 146 +1 = 147 byte:

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 (memeriksa apakah sebuah string dimulai dengan karakter yang diberikan), 113 + 1 = 114 byte:

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 (mengembalikan semuanya kecuali karakter pertama dari string yang diberikan), 41 + 1 = 42 byte:

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

0
4
0

i (kurangi dua angka), 34 + 1 = 35 byte:

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

j (divisi tingkat rendah yang tidak berfungsi dalam semua kasus), 134 + 1 = 135 byte:

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 (penggandaan), 158 + 1 = 159 byte:

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 (kembalikan nilai absolut), 58 + 1 = 59 byte:

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

0
6
10

m (tambahan), 109 + 1 = 110 byte:

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

%

%adalah fungsi memberikan kebalikan dari inputnya. Anda bisa menjalankannya seperti ini

   % 2
0.5

Taksi , 467 byte

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.

Cobalah online!

Tidak Disatukan:

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 byte / penekanan tombol

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

Karena V kompatibel dari belakang, Anda dapat mencobanya secara online!

x86_64 Bahasa mesin Linux, 5 byte

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

Untuk menguji ini, Anda dapat mengkompilasi dan menjalankan program C berikut

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

Cobalah online!

C, 15 12 byte

#define f 1/

Cobalah online!

16 13 byte, jika perlu menangani input integer juga:

#define f 1./

Jadi Anda bisa menyebutnya dengan f(3)alih - alih f(3.0).

Cobalah online!

Terima kasih kepada @hvd untuk bermain golf 3 byte!

MATLAB / Oktaf, 4 byte

@inv

Membuat gagang fungsi (bernama ans) ke invfungsi bawaan

Demo online

05AB1E , 1 byte

z

Cobalah online!

z # pop a  push 1 / a

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

Peringatan: program akan memakan semua memori sistem yang mencoba dijalankan dan membutuhkan lebih banyak waktu untuk menyelesaikan daripada yang Anda tunggu! Lihat di bawah untuk penjelasan dan versi yang cepat, tetapi kurang tepat.

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:

Ini didasarkan pada jawaban Retina oleh Martin Ender. Saya menghitung \tdari baris 2 sebagai tab literal (1 byte).

Kontribusi utama saya adalah metode konversi dari desimal ke polos unary (baris 2), dan sebaliknya (baris 5). Saya berhasil secara signifikan mengurangi ukuran kode yang diperlukan untuk melakukan ini (gabungan ~ 40 byte), dibandingkan dengan metode yang ditunjukkan pada tip sebelumnya . Saya membuat jawaban tip terpisah dengan detail, tempat saya memberikan cuplikan yang siap pakai. Karena 0 tidak diizinkan sebagai input, beberapa byte lagi disimpan.

Penjelasan: untuk lebih memahami algoritma pembagian, baca jawaban Retina terlebih dahulu

Program ini secara teori benar, alasan mengapa ia menghabiskan begitu banyak sumber daya komputasi adalah bahwa langkah pembagian dijalankan ratusan ribu kali, lebih atau kurang tergantung pada input, dan regex yang digunakan menimbulkan mimpi buruk yang melenceng. Versi cepat mengurangi presisi (karenanya jumlah langkah pembagian), dan mengubah regex untuk mengurangi backtracking.

Sayangnya, sed tidak memiliki metode untuk secara langsung menghitung berapa kali backreference cocok dengan suatu pola, seperti di 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

Untuk versi program yang cepat dan aman, tetapi kurang tepat, Anda dapat mencoba ini secara online .

Japt , 2 byte

Solusi yang jelas akan menjadi

1/U

yang secara harfiah 1 / input,. Namun, kita dapat melakukan yang lebih baik:

pJ

Ini setara dengan input ** J, dan Jdiatur ke -1 secara default.

Cobalah online!

Fakta menyenangkan: seperti pfungsi daya, demikian qjuga fungsi root ( p2= **2, q2= **(1/2)); ini berarti bahwa qJakan bekerja juga, karena -1 == 1/-1, dan karena itu x**(-1) == x**(1/-1).

Javascript ES6, 6 byte

x=>1/x

Cobalah online!

Default Javascript untuk pembagian floating point.

APL, 1 byte

÷

÷Menghitung timbal balik saat digunakan sebagai fungsi monadik. Cobalah online!

Menggunakan set karakter Dyalog Classic.

Cheddar , 5 byte

1&(/)

Cobalah online!

Ini menggunakan &, yang mengikat argumen ke suatu fungsi. Dalam hal ini, 1terikat ke sisi kiri /, yang memberi kita 1/x, untuk sebuah argumen x. Ini lebih pendek dari kanon x->1/xsebesar 1 byte.

Atau, dalam versi yang lebih baru:

(1:/)

Java 8, 6 byte

x->1/x

Hampir sama dengan jawaban JavaScript .

MATL , 3 byte

l_^

Cobalah di MATL Online

Penjelasan

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

Python, 12 byte

lambda x:1/x

Satu untuk 13 byte:

(-1).__rpow__

Satu untuk 14 byte:

1 .__truediv__

Mathematica, 4 byte

1/#&

Memberi Anda rasional yang tepat jika Anda memberikan rasional yang tepat, dan dengan hasil floating-point jika Anda memberikannya hasil floating-point.

ZX Spectrum BASIC, 13 byte

1 INPUT A: PRINT SGN PI/A

Catatan:

• Setiap baris berharga 2 byte untuk nomor baris, 2 byte untuk panjang baris dan 1 byte untuk baris baru
• Numerik literal dikonversi menjadi biner pada waktu parse, dengan biaya tambahan 6 byte, sehingga penggunaan SGN PIbukannya literal1 .
• Kata kunci masing-masing mengambil 1 byte.

Versi ZX81 untuk 17 byte:

1 INPUT A
2 PRINT SGN PI/A

Haskell , 4 byte

(1/)

Cobalah online!

R, 8 byte

1/scan()

Cukup mudah. Langsung menampilkan kebalikan dari input.

Solusi lain, tetapi 1 byte lebih lama bisa:, scan()^-1atau bahkan scan()**-1untuk byte tambahan. Keduanya ^dan **simbol kekuatan.

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

Ans⁻¹

-1 byte terima kasih kepada Timtech .

-3 byte dengan Ansterima kasih kepada Григорий Перельман .

Ansdan ⁻¹merupakan token satu byte .

TI-Basic secara implisit mengembalikan nilai terakhir yang dievaluasi ( Ans⁻¹).

Jelly , 1 byte

İ

Cobalah online!

C, 30 byte

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