Взаимное число (1 / х)


25

Вызов

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



14
@KritixiLithos Люди могут голосовать так, как считают нужным. Учитывая простоту этой задачи, большинство , если не все ответы являются чем-то вроде 1/x.
NoOneIsHere

9
Это не определено объективно без четких деталей о точности и точности.
Питер Тейлор

6
Как насчет точности? Предположительно, вы тоже хотите 4 sf точности, но есть проблема округления . Вопросы с плавающей запятой трудно получить правильные и очень стоит песочница .
Питер Тейлор

10
-1, это плохая задача, потому что использование встроенного является ЕДИНСТВЕННЫМ способом сделать это и знать, что вы удовлетворили «спецификацию». Если у вас есть стандартная реализация с плавающей запятой, вы можете использовать ее и сказать себе, что это стандартная с плавающей запятой, все должно быть в порядке. Если вам нужно реализовать это самостоятельно, спецификации нет, поэтому вы не можете разумно попытаться сыграть в гольф.
feersum

Ответы:


58

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 .

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

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

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

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

>)

18
+1, мне нравится, как много в этом объясненииI don't know what this does or why I need it, but I promise it's important.
DJMcMayhem

Кажется, это не работает для ввода 1.0или10
Poke

3
Кто-нибудь еще может прочитать этот код? Brain-Flak предназначен только для записи?
Эрик

1
@EricDuminil Brain-flak - эзотерический язык, поэтому его очень сложно читать с первого взгляда. Люди, которые хорошо разбираются в Brain-Flak, могут читать его до некоторой степени свободно. Но эта задача невероятно сложна и Brain-Flak на самом деле не предназначена для удобства чтения.
Wheat Wizard

@ThisGuy Требуется, чтобы -cфлаг запускался с входом и выходом ASCII. Поскольку Brain-Flak не поддерживает плавающие числа, мне нужно взять IO в качестве строки.
Wheat Wizard


37

Retina , 99 91 байт

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

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

Woohoo, суб-100! Это удивительно эффективно, учитывая, что он создает (а затем сопоставляет) строку с более чем 10 7 символами в одной точке. Я уверен, что это еще не оптимально, но сейчас я доволен счетом.

Результаты с абсолютным значением меньше 1 будут напечатаны без начального нуля, например, .123или -.456.

объяснение

Основная идея заключается в использовании целочисленного деления (потому что это довольно легко с регулярным выражением и унарной арифметикой). Чтобы получить достаточное количество значащих цифр, мы делим ввод на 10 7 . Таким образом, любой ввод до 9999 по- прежнему приводит к 4-значному числу. По сути, это означает, что мы умножаем результат на 10 7, поэтому нам нужно отслеживать это, когда позже снова вставлять десятичную точку.

1`\.|$
8$*;

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

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

Сначала мы превращаем ввод в целое число. До тех пор, пока после запятой остаются цифры, мы перемещаем одну цифру вперед и удаляем одну из точек с запятой. Это потому, что перемещение десятичной запятой вправо умножает ввод на 10 , и, следовательно, делит результат на 10 . Из-за ограничений ввода мы знаем, что это будет происходить не более четырех раз, поэтому всегда достаточно точек с запятой для удаления.

\d+
$*1,10000000$*

Теперь, когда входные данные являются целыми числами, мы конвертируем их в унарные и добавляем 10 7 1 с (разделенные символом a ,).

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

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

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

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

1`;
.

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

;
0

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


Очень короткий алгоритм +1. Могу поспорить, что перевод sed будет самым коротким. Вы можете заменить \B;с , ^;чтобы сохранить 1 байт?
сешумара

@seshoumara Нет из-за отрицательных входов, где есть -перед ;.
Мартин Эндер

31

да , 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))]

Это использует личность

x / y = e ^ (ln (x) -ln (y))

что подразумевает, что


3
Я бы хотел улучшить мой контент, так что если вы объясните свое отрицательное мнение, это действительно поможет, и я был бы признателен за это :)
Конор О'Брайен,

20

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.

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


Я думаю, вы могли бы использовать ITZ A NUMBARв назначении I?
ckjbgames

1
HOW DUZ I r YR n VISIBLE QUOSHUNT OF 1 AN n IF U SAY SO(добавить символы новой строки) на несколько байтов короче и может вызываться с помощью r d, где dэто возможно NUMBAR.
devRicher

Вы можете использовать IZвместо DUZиз-за правила интерпретатора
OldBunny2800

17

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 за то, что показали мне это)

Ты сделал это! +1
сешумара

16

JSFuck , 3320 байт

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

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

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

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


1
Это подмножество языков трудно освоить вручную, но легко автоматизировать (как преобразование из обычного JavaScript).
wizzwizz4

Верно, но количество символов источника не имеет прямого отношения к длине вывода.
Пауэлл

4
Я пытался передать, что, если у вас есть источник, легче автоматизировать преобразование в гольф, чем делать версию для гольфа вручную.
wizzwizz4

4
@ wizzwizz4 Даже когда это автоматизировано, сложно также определить, какой «основной» код JavaScript на самом деле создает самую короткую программу. В этом конкретном случае return 1/thisбудет примерно на 76 байтов больше, чем return+1/this.
ETHproductions

[].fill.constructor('alert(1/prompt())')2929 байт paste.ubuntu.com/p/5vGTqw4TQQ add ()2931
l4m2

16

НЕФТЬ , 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
-

15

J, 1 байт

%

%является функцией, дающей обратную величину входных данных Вы можете запустить это так

   % 2
0.5

15

Такси , 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.

Не могли бы вы добавить версию без гольфа для удобства чтения?
Кевин Круйссен

@KevinCruijssen Конечно, просто когда я ответил на это, была поздняя ночь.
Эрик Outgolfer

15

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

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

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


@ NonlinearFruit Нет, это не так. Оказывается, я обдумывал это и поддерживал это на самом деле меньше байтов, а не больше. Благодарность!
DJMcMayhem

Это действительно интересно. Интересно, возможно ли сделать то же самое без использования =. Исключительно полагаясь на другие макросы, регистры для хранения памяти и клавиши для навигации и изменения данных. Было бы намного сложнее, но я думаю, что это было бы так здорово! Я думаю, fбудет играть огромную роль в качестве условного теста.
Стефан Алексич,

Если входное значение равно 6431, выходное значение должно быть 0,0001554 или более точным, но не 0.
seshoumara

1
@seshoumara Я думаю, что вам нужно ввести, 6431.0чтобы он воспринимался как число с плавающей запятой
Poke

@Poke Я попробовал это, и это работает, но вывод в научной нотации. Это разрешено?
сешумара

11

Машинный язык 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) );
  }
}

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


1
Мы могли бы добавить, что это rcpssвычисляет только приблизительную обратную величину (около 12 бит). +1
Кристоф

11

C, 15 12 байт

#define f 1/

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

16 13 байт, если он должен обрабатывать также целочисленный ввод:

#define f 1./

Таким образом, вы можете позвонить с помощью f(3)вместо f(3.0).

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

Спасибо @hvd за игру в гольф 3 байта!


2
Не могли бы вы изменить название языка на «Препроцессор C»?
ckjbgames

4
Будучи очень разборчивым, это не «вычисляет» значение; он просто заменяется f(x)на 1/x. Когда «функция» выполняется, что может произойти уже во время выполнения или когда ваш компилятор чувствует (и может оказаться правильным), технически это не шаг препроцессора.
CAD97

1
@Steadybox Я буквально цитирую пример раздела ввода в описании задачи. Ваш код будет получить 2и в -5качестве входных данных. Обе 2и -5десятичные дроби, содержащие цифры в диапазоне от 0 до 9.
труба

2
Нет необходимости в функциональном макросе: #define f 1./тоже работает.
17

2
«Будучи очень разборчивым, это не« вычисляет »значение; оно просто заменяет f (x) на 1 / x». Я такой привередливый. Это вполне возможно сделать с помощью препроцессора C, но не следует утверждать, что он что-то сделал в препроцессоре C, если для этого требуется C или C ++.
H Уолтерс



8

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

Для быстрой и безопасной версии программы, но менее точной, вы можете попробовать это онлайн .


7

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


7

Javascript ES6, 6 байтов

x=>1/x

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

Javascript по умолчанию использует деление с плавающей точкой.


Я незнаком с тем, как вы создали и назвали f (). Можете ли вы объяснить это немного, или предложить ссылку?
TecBrat

@TecBrat Это анонимная функция. В ссылке «Попробуй онлайн» у меня в заголовке f =, чтобы назначить анонимную функцию для вызова. В нижнем колонтитуле у меня есть console.log (f (любое число)), чтобы вывести результат вызова функции
fəˈnɛtɪk

Разве ваш общий размер не должен быть 8 байт?
TecBrat

@TecBrat Анонимная функция - это ответ без необходимости его назначения.
fəˈn 14:tɪk

1
@TecBrat Функция x => 1 / x, что эквивалентно функции (x) {return 1 / x}. Как и в случае этого ответа в мета, который ссылается на этот консенсус , анонимные функции, которые будут выполнять запрошенную задачу, являются верным ответом на вызов.
fəˈnɛtɪk


6

Чеддер , 5 байт

1&(/)

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

Это использует &, который связывает аргумент с функцией. В этом случае 1привязывается к левой части /, что дает нам 1/xаргумент x. Это короче канонического x->1/xна 1 байт.


Кроме того, в более новых версиях:

(1:/)

Новая версия позволяет этому быть (1:/)для того же количества байтов
Downgoat


4

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

4

Python, 12 байт

lambda x:1/x

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

(-1).__rpow__

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

1 .__truediv__

4

Mathematica, 4 байта

1/#&

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


4

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

1
Где я могу найти более конкретную информацию о том, как оценивать ZX Spectrum BASIC?
Луис Мендо

@LuisMendo Вы можете найти набор символов (включая ключевые слова) в Википедии, но кроме этого я не знаю, есть ли консенсус по поводу оценки ZX Basic. (Например, версия ZX81 должна быть полной программой, но ZX Spectrum поддерживает INPUT как непосредственную команду.)
Нейл

Чтобы сохранить байты с перечнем программ на ZX81, вы можете выполнить LET A=17и рефакторизовать ваше приложение в одну строку 1 PRINT SGN PI/A, хотя вам нужно будет менять значение A, вводя больше символов при каждом запуске программы.
Шон Бебберс


4

R, 8 байт

1/scan()

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

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


4

TI-Basic (TI-84 Plus CE), 6 5 2 байта

Ans⁻¹

-1 байт благодаря Timtech .

-3 байта с Ansблагодарностью Григорию Перельман .

Ansи ⁻¹являются однобайтовыми токенами .

TI-Basic неявно возвращает последнее оцененное значение ( Ans⁻¹).


Ввод также неявно получает координаты ввода в X и Y, но вы не можете использовать это, так как вы должны иметь возможность принимать числа с плавающей запятой. Помните, что X ^ -1 составляет всего два байта, поэтому вы можете сохранить один там.
Timtech

TI-Basic разрешено принимать данные Ans, поэтому вы можете заменить это наAns⁻¹
Pavel

3

Это на самом деле 2 байта.
Кодер-256

В UTF-8, конечно. По умолчанию Jelly использует собственный SBCS .
Деннис

@ Денис вики, на которую вы ссылаетесь, говорит Jelly programs consist of up to 257 different Unicode characters.
Khaled.K

@ Khaled.K Да, это также говорит символ и символ перевода строки могут использоваться взаимозаменяемо , поэтому, хотя режим Unicode «понимает» 257 различных символов, они сопоставляются с 256 токенами.
Деннис

3

C, 30 байтов

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

Вы можете удалить трейлинг, 0чтобы сохранить один байт. При этом 1.он все равно будет скомпилирован как двойной.
Патрик Робертс

@PatrickRoberts Не в моем тестировании. 1.до сих пор рассматривается как целое число.
дкудрявцев

Работает для меня, используя echo -e "#include <stdio.h>\nfloat f(x){return 1./x;}main(){printf(\"%f\\\\n\",f(5));}" | gcc -o test -xc -Вывод ./testis0.200000
Патрик Робертс

1
Разве это не принимает входные данные как целое число вместо числа с плавающей точкой? Это не работает для поплавков, по крайней мере, на GCC. float f(float x){return 1/x;}будет работать правильно.
Steadybox

2
Нет необходимости в отстающей .- C удовольствием неявно преобразовать (int)1в (float)1силу типа x.
пушистый
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.