Виклик

Враховуючи (з плаваючою комою / десятковим) число, поверніть його зворотну, тобто 1, поділену на число. Вихід повинен бути числом з плаваючою комою / десятковим числом, а не лише цілим числом.

Детальна специфікація

• Ви повинні отримати введення у вигляді плаваючої крапки / десяткового числа ...
  • ... який має щонайменше 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

Правила

• Усі прийняті форми виводу дозволені
• Стандартні лазівки заборонені
• Це код-гольф , найкоротша відповідь у байтових перемогах, але не буде обрана.

Роз'яснення

• Ви ніколи не отримаєте вклад 0.

Bounties

Це завдання, очевидно, банальне для більшості мов, але може запропонувати цікаве завдання на більш езотеричних та незвичних мовах, тому деякі користувачі готові присуджувати бали за це на незвично складних мовах.

• @DJMcMayhem присвоїть +150 балів за найкоротший відповідь, що відповідає мозку, оскільки мозок-лунатик важко для цифр з плаваючою комою

• @ L3viathan присвоїть +150 балів за найкоротший відповідь про масло . Нафта не має власного типу з плаваючою точкою, і не має поділу.

• @Riley присудить +100 балів за найкоротший відповідь.

• @EriktheOutgolfer присудить +100 балів за найкоротший відповідь Сесоса. Поділ у таких похідних, як Sesos, дуже важкий, не кажучи вже про поділ з плаваючою комою.

• Я ( @ Менделєєв ) за найкоротшу відповідь Retina присуджує суму +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 -). Якщо це один, ми ставимо нуль у верхній частині стека, якщо ні, ми нічого не робимо. Тоді ми підбираємо верхню частину стека, яку потрібно виставити в кінці програми. Якщо введення почалося з -цього, це все-таки, -але якщо це не так, ми в кінцевому підсумку набираємо той нуль, який ми розмістили.

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

Тепер, коли це неможливо, нам потрібно перетворити ASCII реалізацію кожної цифри в фактичні значення (0-9). Ми також будемо видаляти десяткову точку, .щоб полегшити обчислення. Оскільки нам потрібно знати, з чого починається десяткова крапка, коли ми її знову вставляємо пізніше, ми зберігаємо число, щоб відслідковувати, скільки цифр було перед .знаком на офстаку.

Ось як це робить:

Почнемо з віднімання 46 (значення ASCII .) від кожного елемента стека (одночасно перемістивши їх усі на офстак). Це зробить кожну цифру на дві більше, ніж повинна бути, але зробить .рівно нуль.

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

Тепер ми переміщуємо все на лівий стек, поки не досягнемо нуля (віднімаючи два з кожної цифри, поки ми йдемо):

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

Записуємо висоту стека

([]<

Перемістіть все інше на лівий стек (ще раз віднімаючи останні дві з кожної цифри під час їх переміщення)

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

І відкласти висоту стека, яку ми записали

>)

Тепер ми хочемо об'єднати цифри в єдине базове 10 число. Ми також хочемо зробити потужність 10 з подвоєними цифрами, як це число для використання в обчисленні.

Почнемо, встановивши 1 на вершині стека, щоб зробити потужність 10, і висунувши висоту стека мінус одна до групи on для використання циклічного циклу.

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

Тепер ми петлю висоту стека мінус 1 рази,

{
 ({}[()]<

Кожен раз, коли ми множимо верхній елемент на 100, а під ним множимо наступний елемент на 10 і додаємо його до числа нижче.

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

Закінчуємо нашу петлю

 >)
}{}

Тепер ми, нарешті, закінчимо з налаштуванням і можемо розпочати фактичний розрахунок.

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

Це було все ...

Ми ділимо потужність 10 на модифіковану версію введення, використовуючи алгоритм поділу 0 ' ' на цілі числа, як це знайдено у вікі . Це імітує поділ 1 на вході - єдиний спосіб, як це знає Мозг-Флак.

Нарешті, ми повинні відформатувати свій вихід у відповідний ASCII.

Тепер, коли ми виявили, neнам потрібно вийняти e. Перший крок до цього - перетворення його на список цифр. Цей код є модифікованою версією 0 's алгоритм divmod .

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

Тепер беремо число і додаємо десяткову точку назад, куди воно належить. Поміркування про цю частину коду повертає головні болі, тому поки що я залишу це читачеві вправою зрозуміти, як і чому він працює.

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

Поставте негативний знак або нульовий символ, якщо немає негативного знаку.

>)

Пітон 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 ⁷ . Таким чином, будь-який вхід до 9999 все одно призводить до 4-розрядного числа. Ефективно, це означає, що ми множимо результат на 10 ^7, тому нам потрібно буде це відслідковувати, коли пізніше вставити десяткову точку.

1`\.|$
8$*;

Почнемо з заміни десяткової крапки або кінця рядка, якщо немає десяткової крапки з 8 крапками з комою. Перший з них по суті є десятковою точкою (але я використовую крапки з комою, тому що їх не потрібно уникати), інші 7 вказують, що значення було помножено на 10 ⁷ (це ще не так, але ми знаємо, що зробимо це пізніше).

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

Спочатку перетворюємо вхід на ціле число. Поки ще залишаються цифри після десяткової крапки, ми переносимо одну цифру на передню частину і видаляємо один з крапків з комою. Це відбувається тому, що переміщення десяткової крапки справа множує вхід на 10 , а тому ділить результат на 10 . Зважаючи на обмеження введення, ми знаємо, що це відбудеться не більше чотирьох разів, тому завжди буде достатньо крапки з комою.

\d+
$*1,10000000$*

Тепер, коли вхід є цілим числом, ми перетворюємо його в одинарне і додаємо 10 ⁷ 1 s (розділене a ,).

(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 () (константа, функція, що повертається в нижній частині 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

7 байт збережено завдяки @devRicher!

Це визначає функцію '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. Ідеї ​​для перетворення десятичного в одинарне були взяті з цієї дивовижної відповіді . Дякую @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)
• Зберегли тонну байтів, переглянувши приємний перетворювач від десятки до одинарного на "Поради щодо гольфу в седі"
• Я змінив навколо деяких підстановок, що обертаються навколо піклування про знак мінус, щоб зберегти 6 байт.
• Використовуючи \nзамість ;цього розділювача, мені вдалося скоротити заміну "помножити на 10", щоб зберегти 12 байт (завдяки @Riley та @seshoumara, що показали мені це)

JSFuck , 3320 байт

JSFuck - це езотеричний та навчальний стиль програмування, заснований на атомних частинах JavaScript. ()[]+!Для написання та виконання коду використовується лише шість різних символів .

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

Спробуйте в Інтернеті!

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

МАСЛО , 1428 1420 байт

Ну добре. Я думав, що, можливо, спробую це зробити, і в підсумку мені все вдалося. Є лише один недолік: пробіг займає майже стільки ж часу, скільки потрібно було написати.

Програма розділена на кілька файлів, у яких є всі 1-байт-імена файлів (і нараховується один додатковий байт у моєму обчисленні байтів). Деякі файли є частиною прикладних файлів мови OIL, але немає реального способу послідовно їх називати (ще немає шляху пошуку чи подібного в OIL, тому я не вважаю їх стандартною бібліотекою), але це також означає, що (на момент публікації) деякі файли є більш багатослівними, ніж необхідні, але зазвичай лише на кілька байтів.

Обчислення точні до 4-х цифр точності, але обчислення навіть простої зворотної (наприклад, введення) 3 ) потрібно дуже багато часу (більше 5 хвилин). Для тестування я також створив мінорний варіант, точний до 2 цифр, на що потрібно лише кілька секунд, щоб довести, що він працює.

Вибачте за величезну відповідь, я б хотів, щоб я міг використовувати якийсь тег спойлера. Я також міг би помістити основну частину на gist.github.com або щось подібне, якщо бажаєте.

Ось ми:, main217 байт (ім'я файлу не вважається байтами):

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

Це ґрунтується на відповіді Retina від Мартіна Ендера. Я рахую \tз рядка 2 як буквальну вкладку (1 байт).

Мій головний внесок полягає в методі перетворення від десяткових до звичайних одинарних (рядок 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/xна 1 байт.

Або в нових версіях:

(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

Пітон, 12 байт

lambda x:1/x

Один на 13 байт:

(-1).__rpow__

Один на 14 байт:

1 .__truediv__

Математика, 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-Basic (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;}