Вызов

Если задано число (с плавающей запятой / десятичное число), вернуть его обратное значение, т. Е. 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.

щедроты

Эта задача, очевидно, тривиальна на большинстве языков, но она может предложить интересную задачу на более эзотерических и необычных языках, поэтому некоторые пользователи готовы начислять баллы за это на необычно сложных языках.

• @DJMcMayhem присудит премию в +150 баллов за самый короткий ответ «мозговая шутка», поскольку «мозговая шутка» общеизвестно трудна для чисел с плавающей запятой

• @ L3viathan присуждает премию +150 баллов за самый короткий ответ НЕФТЬ . НЕФТЬ не имеет собственного типа с плавающей запятой и не имеет деления.

• @Riley присудит +100 баллов за самый короткий ответ.

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

• Я ( @Mendeleev ) наградит +100 баллов за самый короткий ответ Retina.

Если есть язык, который, по вашему мнению, было бы интересно увидеть ответ, и вы готовы платить за него, не стесняйтесь добавлять свое имя в этот список (отсортировано по сумме вознаграждения)

Leaderboard

Вот фрагмент стека, чтобы составить обзор победителей по языкам.

Чтобы убедиться, что ваш ответ обнаружен, начните его с заголовка, используя следующий шаблон уценки:

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

Brain-Flak , 772 536 530 482 480 + 1 = 481 байт

Поскольку Brain-Flak не поддерживает числа с плавающей запятой, мне пришлось использовать -cфлаг для ввода и вывода порядка со строками, следовательно, +1.

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

Попробуйте онлайн!

объяснение

Первое, о чем мы должны позаботиться, это отрицательный случай. Поскольку обратная величина отрицательного числа всегда отрицательна, мы можем просто удерживать отрицательный знак до конца. Мы начнем с того, что сделаем копию вершины стека и вычтем -из нее 45 (значение ASCII ). Если это один, мы ставим ноль на вершине стека, если нет, мы ничего не делаем. Затем мы подбираем верхнюю часть стека, которую нужно положить в конце программы. Если ввод начался с a, то -это все равно a. -Если это не так, мы заканчиваем тем, что взяли тот ноль, который мы поместили.

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

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

Вот как код делает это:

Мы начинаем с вычитания 46 (значение ASCII .) из каждого элемента в стеке (одновременно перемещая их все в стек). Это сделает каждую цифру на два больше, чем должно быть, но сделает .ровно ноль.

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

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

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

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

([]<

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

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

И поместите высоту стека, которую мы записали

>)

Теперь мы хотим объединить цифры в один базовый номер 10. Мы также хотим сделать число 10 с двойными цифрами в качестве этого числа для использования в расчете.

Мы начнем с установки 1 на вершине стека, чтобы получить степень 10, и толкания высоты стека минус один к стеку для использования в цикле.

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

Теперь мы зациклили высоту стека минус 1 раз,

{
 ({}[()]<

Каждый раз мы умножаем верхний элемент на 100, а под ним умножаем следующий элемент на 10 и добавляем его к числу ниже.

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

Мы заканчиваем наш цикл

 >)
}{}

Теперь мы, наконец, закончили с настройкой и можем начать фактический расчет.

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

Это было это ...

Разделим мощность 10 с помощью модифицированного варианта ввода , используя 0 ' алгоритм деления целого числа «s , как найти на вики . Это имитирует деление 1 на вход только так, как умеет Brain-Flak.

Наконец, мы должны отформатировать наш вывод в соответствующий ASCII.

Теперь, когда мы нашли, neнам нужно убрать e. Первым шагом к этому является преобразование его в список цифр. Этот код представляет собой модифицированную версию 0 ' «s алгоритм divmod .

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

Теперь мы берем число и добавляем к нему десятичную точку. Одно только размышление об этой части кода вызывает головную боль, поэтому пока я оставлю читателю в качестве упражнения выяснить, как и почему он работает.

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

Положите отрицательный знак или нулевой символ, если нет отрицательного знака.

>)

Python 2 , 10 байт

1..__div__

Попробуйте онлайн!

Retina , 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 с (разделенные символом a ,).

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

Разобьем целое число на 10 ⁷ , посчитав, сколько обратных ссылок на него помещается ( $#2). Это стандартное унарное целочисленное деление a,b-> b/a. Теперь нам просто нужно исправить положение десятичной точки.

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

Это в основном обратное второй стадии. Если у нас еще есть несколько точек с запятой, это означает, что нам все равно нужно разделить результат на 10 . Мы делаем это, перемещая точки с запятой на одну позицию влево и опуская одну точку с запятой до тех пор, пока мы не достигнем левого конца числа или не останемся только с одной точкой с запятой (которая является самой десятичной точкой).

1`;
.

Сейчас хорошее время, чтобы превратить первый (и, возможно, единственный) ;обратно в ..

;
0

Если еще остались точки с запятой, мы достигли левого конца числа, поэтому при делении на 10 снова вставляются нули за десятичной точкой. Это легко сделать, заменив все оставшиеся ;на a 0, так как они в любом случае сразу после десятичной точки.

да , 5 байт

|0~-e

Попробуйте онлайн! Это берет ввод с вершины стека и оставляет вывод на вершине стека. Ссылка TIO получает данные из аргументов командной строки, которые могут принимать только целочисленные данные.

объяснение

у да есть только несколько операторов. Используемые в этом ответе 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 минут). В целях тестирования я также сделал небольшой вариант, который точен до двух цифр, что занимает всего несколько секунд, чтобы доказать, что он работает.

Я прошу прощения за огромный ответ, я хотел бы использовать какой-то тег спойлера. Я мог бы также разместить большую часть этого на 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.

Попробуйте онлайн!

Ungolfed:

Go to Starchild Numerology:west 1 left, 2 right, 1 left, 1 left, 2 left.
1 is waiting at Starchild Numerology.
Pickup a passenger going to Divide and Conquer.
Go to Post Office:west 1 right, 2 right, 1 right, 1 left.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery:south 1 left, 1 right.
Pickup a passenger going to Divide and Conquer.
Go to Divide and Conquer:east 4 left.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery:east 1 right.
Pickup a passenger going to Post Office.
Go to Post Office:east 1 left, 1 right.

Vim, 10 8 байт / нажатий клавиш

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

Поскольку V имеет обратную совместимость, вы можете попробовать это онлайн!

Машинный язык Linux x86_64, 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 / Octave, 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

Python, 12 байт

lambda x:1/x

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

(-1).__rpow__

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

1 .__truediv__

Mathematica, 4 байта

1/#&

Предоставляет вам точное рациональное значение, если вы даете ему точное рациональное значение, и результат с плавающей запятой, если вы даете ему результат с плавающей запятой.

ZX Spectrum BASIC, 13 байтов

1 INPUT A: PRINT SGN PI/A

Заметки:

• Каждая строка стоит 2 байта для номера строки, 2 байта для длины строки и 1 байт для новой строки
• Числовые литералы преобразуются в двоичный файл во время синтаксического анализа, что требует дополнительных 6 байтов, что позволяет использовать SGN PIвместо литерала 1.
• Ключевые слова занимают 1 байт каждое.

Версия ZX81 для 17 байтов:

1 INPUT A
2 PRINT SGN PI/A

Haskell , 4 байта

(1/)

Попробуйте онлайн!

R, 8 байт

1/scan()

Довольно просто. Непосредственно выводит обратный вход.

Другое, но более длинное решение на 1 байт может быть: scan()^-1или даже scan()**-1для дополнительного байта. Оба ^и **символ власти.

TI-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;}