도전

(부동 소수점 / 소수) 숫자가 주어지면 그 역수를 반환합니다. 즉, 1을 숫자로 나눈 값을 반환합니다. 출력은 정수가 아니라 부동 소수점 / 소수 여야합니다.

상세 사양

• 부동 소수점 / 10 진수 형식으로 입력을 받아야합니다.
  • ... 4 자리 이상의 유효 자릿수가 필요합니다 (필요한 경우).
  • 많을수록 좋지만 점수에는 포함되지 않습니다.
• 허용 가능한 출력 방법으로 출력해야합니다 ...
  • ... 숫자의 역수.
  • 이것은 1 / x, x⁻¹로 정의 될 수 있습니다.
  • 4 자리 이상의 유효 자릿수 (필요한 경우)로 출력해야합니다.

입력은 [0.0001, 9999] 범위의 절대 값으로 양수 또는 음수입니다. 소수점 이후 4 자리를 초과하거나 0이 아닌 첫 번째 숫자부터 시작하여 4 자리를 넘지 않습니다. 출력은 0이 아닌 첫 번째 숫자부터 최대 4 번째 숫자까지 정확해야합니다.

(감사합니다 @MartinEnder)

샘플 입력은 다음과 같습니다.

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

4 자리 이상의 정밀도를 가진 입력은 절대 제공되지 않습니다.

다음은 Ruby의 샘플 함수입니다.

def reciprocal(i)
    return 1.0 / i
end

규칙

• 허용되는 모든 출력 형식이 허용됩니다
• 금지 된 표준 허점
• 이것은 code-golf 이며 바이트 단위의 최단 답변이지만 선택되지는 않습니다.

설명

• 입력을받지 못할 것 0입니다.

바운티

이 과제는 대부분의 언어에서 사소한 것이지만 좀 더 난해하고 특이한 언어에서는 재미있는 도전을 제공 할 수 있으므로, 일부 사용자는 매우 어려운 언어로이 작업에 대한 포인트를 기꺼이받을 수 있습니다.

• @DJMcMayhem 은 가장 짧은 뇌- 플래그 답변 에 +150 포인트 현상금을 수여 할 것 입니다.

• @ L3viathan 은 가장 짧은 OIL 답변에 +150 포인트 현상금을 수여합니다 . OIL에는 기본 부동 소수점 유형이 없으며 나눗셈도 없습니다.

• @Riley 는 가장 짧은 sed 답변에 +100 포인트 현상금을 수여합니다 .

• @EriktheOutgolfer 는 가장 짧은 Sesos 답변에 +100 포인트 현상금을 수여합니다 . Sesos와 같은 brainfuck 파생물에서의 나누기는 부동 소수점 나누기는 물론 매우 어렵습니다.

• 나는 ( @Mendeleev ) 가장 짧은 Retina 답변 에 +100 포인트 의 현상금을 수여합니다 .

답변을보기에 재미있을 것으로 생각되는 언어가 있고 담당자에게 비용을 지불 할 의향이있는 경우 자유롭게이 목록에 이름을 추가하십시오 (현금 금액별로 정렬).

리더 보드

다음은 언어 별 수상자 개요를 생성하는 스택 스 니펫입니다.

답변이 표시되도록하려면 다음 마크 다운 템플릿을 사용하여 헤드 라인으로 답변을 시작하십시오.

# 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 값 -)를 빼서 시작 합니다. 이것이 1이면 스택 상단에 0을 넣습니다. 그렇지 않으면 아무것도하지 않습니다. 그런 다음 프로그램 끝에서 내려 놓을 스택의 상단을 가져옵니다. 입력이 시작 되었지만 -여전히 그렇지 않은- 경우 우리가 배치 한 0을 선택하게됩니다.

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

이제 우리는 각 숫자의 ASCII 실현을 실제 값 (0-9)으로 변환해야합니다. .계산을 쉽게하기 위해 소수점을 제거 할 것입니다. 나중에 다시 삽입 할 때 소수점이 어디서 시작했는지 알아야 .하므로 오프 스택 에서 몇 자리 숫자가 있었는지 추적하기 위해 숫자를 저장합니다 .

코드가하는 방법은 다음과 같습니다.

.스택의 각 요소에서 46 (ASCII 값 )을 빼서 시작합니다 ( 모든 요소를 ​​오프 스택으로 동시에 이동). 이렇게하면 각 숫자가 두 자리 이상이어야하지만 .정확히 0이됩니다.

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

이제 우리는 0에 도달 할 때까지 모든 것을 왼쪽 스택으로 옮깁니다 (가는 동안 각 숫자에서 2를 빼기).

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

스택 높이를 기록합니다

([]<

다른 모든 것을 왼쪽 스택으로 옮깁니다 (다시 한 번 더 이동하면 모든 숫자에서 마지막 두 개를 뺍니다)

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

그리고 우리가 기록한 스택 높이를

>)

이제 숫자를 하나의 기본 10 숫자로 결합하려고합니다. 또한 계산에 사용하기 위해 숫자의 두 배로 10의 거듭 제곱을 만들고 싶습니다.

스택 상단에 1을 설정하여 10의 거듭 제곱을 만들고 스택 사용에서 스택 높이에서 1을 뺀 값을 루핑 사용으로 시작합니다.

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

이제 스택 높이에서 1을 뺀 루프를 반복합니다.

{
 ({}[()]<

우리는 맨 위 요소에 100을 곱하고 그 아래에 다음 요소에 10을 곱하여 아래 숫자에 더합니다.

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

우리는 우리의 루프를 종료

 >)
}{}

이제 설정이 완료되었으며 실제 계산을 시작할 수 있습니다.

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

그거였다...

우리는 10의 거듭 제곱을 위키 에서 찾은 0 's 정수 나누기 알고리즘을 사용하여 수정 된 버전의 입력으로 나눕니다. . 이것은 Brain-Flak이 방법을 아는 유일한 방법으로 입력에 의한 1의 나누기를 시뮬레이션합니다.

마지막으로 출력을 적절한 ASCII로 포맷해야합니다.

이제 우리는를 꺼내야한다는 것을 알았 ne습니다 e. 이를위한 첫 번째 단계는 자릿수 목록으로 변환하는 것입니다. 이 코드는 0 의 divmod 알고리즘 의 수정 된 버전입니다 .

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

이제 우리는 숫자를 가져 와서 소수점을 다시 추가합니다. 코드 의이 부분에 대해 생각하면 두통이 다시 발생하므로 지금은 독자가 그것이 어떻게 어떻게 작동하는지 알아내는 연습으로 남겨 두겠습니다.

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

음수 부호를 입력하거나 음수 부호가없는 경우 널 문자를 넣으십시오.

>)

파이썬 2 , 10 바이트

1..__div__

온라인으로 사용해보십시오!

망막 , 99 91 바이트

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

온라인으로 사용해보십시오!

우후, 서브 -100! 이것은 10 ⁷ 보다 큰 문자열을 생성하고 일치시키는 것을 고려할 때 놀랍도록 효율적입니다.한 번에 자를 입니다. 나는 그것이 아직 최적이 아니라고 확신하지만, 현재 점수에 매우 만족합니다.

절대 값이 1보다 작은 결과는 앞에 오는 0없이 인쇄됩니다 (예 : .123또는-.456 .

설명

기본 아이디어는 정수 나누기를 사용하는 것입니다 (정규식과 단항 산술에서는 상당히 쉽습니다). 충분한 유효 자릿수를 확보하기 위해 입력을 10 ⁷ 로 나눕니다 . 이렇게하면 최대 9999 까지 입력해도 4 자리 숫자가됩니다. 실제로, 결과에 10 ^7을 곱한다는 의미 이므로 나중에 소수점을 다시 삽입 할 때이를 추적해야합니다.

1`\.|$
8$*;

소수점이 없거나 세미콜론이 8 개인 문자열이 없으면 문자열의 끝을 바꾸는 것으로 시작합니다. 그들 중 첫 번째는 본질적으로 소수점 자체입니다 (그러나 세미콜론을 사용하고 있지는 않기 때문에 세미콜론을 사용하고 있습니다). 다른 7은 값에 10 ^7을 곱한 것을 나타냅니다 (아직 그렇지 않습니다, 그러나 우리는 나중에 그렇게 할 것임을 알고 있습니다).

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

먼저 입력을 정수로 바꿉니다. 소수점 뒤에 여전히 자릿수가있는 한, 한 자릿수를 앞으로 이동시키고 세미콜론 중 하나를 제거합니다. 소수점을 오른쪽으로 이동하면 입력에 10이 곱 해져서 결과를 10으로 나눕니다 . 입력 제한으로 인해이 문제는 최대 4 번 발생하므로 항상 세미콜론을 충분히 제거해야합니다.

\d+
$*1,10000000$*

이제 입력 값이 정수이므로,이를 단항으로 변환하고 10 ^7을 추가합니다 1(a로 구분 ,).

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

우리는 정수에 맞는 역 참조 횟수를 세어 정수를 10 ⁷ 로 나눕니다 $#2. 이것은 표준 단항 정수 나누기 a,b-> b/a입니다. 이제 소수점 위치를 수정하면됩니다.

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

이것은 기본적으로 두 번째 단계의 반대입니다. 여전히 세미콜론이 두 개 이상인 경우 결과를 10 으로 나눠야한다는 의미 입니다. 세미콜론을 왼쪽으로 한 위치 이동하고 숫자의 왼쪽 끝에 도달 할 때까지 하나의 세미콜론을 삭제하거나 하나의 세미콜론 (소수점 자체) 만 남습니다.

1`;
.

이제 첫 번째 (및 가능한 경우에만)를로 ;다시 전환하기에 좋은시기 .입니다.

;
0

여전히 세미콜론이 남아 있으면 숫자의 왼쪽 끝에 도달 했으므로 다시 10으로 나누면 소수점 뒤에 0이 삽입됩니다. 이것은 쉽게 나머지 각 대체하여 수행 ;로모그래퍼을 0그들은 어쨌든 소수점 직후에 있기 때문에.

yup , 5 바이트

|0~-e

온라인으로 사용해보십시오! 스택 맨 위에서 입력을 가져 와서 스택 맨 위에 출력을 남겨 둡니다. TIO 링크는 명령 행 인수에서 입력을 가져 오며 정수 입력 만 가능합니다.

설명

yup에는 소수의 연산자 만 있습니다. 이 답변에 사용 된 것은 ln (x) (로 표시 |), 0 () (정수, nilary 함수 반환 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

@devRicher 덕분에 7 바이트가 절약되었습니다!

다음과 같이 호출 할 수있는 함수 'r'을 정의합니다.

r 5.0

또는 다른 NUMBAR.

온라인으로 사용해보십시오!

sed , 575 + 1 ( -r플래그) = 723 718 594 588 576 바이트

s/$/\n0000000000/
tb
:b
s/^0+//
s/\.(.)(.*\n)/\1.\2/
tD
bF
:D
s/.*/&&&&&&&&&&/2m
tb
:F
s/\.//
h
s/\n.+//
s/-//
:
s/\b9/;8/
s/\b8/;7/
s/\b7/;6/
s/\b6/;5/
s/\b5/;4/
s/\b4/;3/
s/\b3/;2/
s/\b2/;1/
s/\b1/;0/
s/\b0//
/[^;]/s/;/&&&&&&&&&&/g
t
y/;/0/
x
G
s/[^-]+(\n0+)\n(0+)/\2\1/
s/\n0+/&&\n./
:a
s/^(-?)(0*)0\n0\2(.*)$/\10\2\n\30/
ta
s/.*/&&&&&&&&&&/2m
s/\n0(0*\n\..*)$/\n\1 x/
Td
s/x//
ta
:d
s/[^-]+\n//
s/-(.+)/\1-/
s/\n//
:x
s/^0{10}/0x/
s/(.)0{10}/0\1/
tx
s/00/2/g
s/22/4/g
y/0/1/
s/41/5/g
s/21/3/g
s/45/9/g
s/44/8/g
s/43/7/g
s/42/6/g
y/ /0/
s/([1-9])0/\1/g
y/x/0/
s/(.+)-/-\1/

온라인으로 사용해보십시오!

참고 : 절대 값이 1보다 작은 수레는 .5대신 0을 선행하지 않고 기록해야합니다 0.5. 또한 소수점 이하 자릿수는과 같습니다 . 여기서 n숫자의 소수점 이하 자릿수는 숫자입니다 (따라서 13.0입력으로 입력하면 입력으로 제공하는 것보다 더 많은 소수점 자리를 제공 13합니다)

이것은 PPCG에 대한 첫 번째 sed 제출입니다. 십진수에서 단항으로의 변환에 대한 아이디어는 이 놀라운 답변 에서 가져 왔습니다 . sed를 통해 나를 안내해 준 @seshoumara에게 감사합니다!

이 코드는 반복 된 긴 나누기를 수행하여 결과를 얻습니다. 나누기는 ~ 150 바이트 만 사용합니다. 단항 10 진수 변환은 최대 바이트를 사용하고 다른 몇 바이트는 음수 및 부동 소수점 입력을 지원합니다.

설명

TIO에 대한 설명

#Append 10 0's. This is the dividend, I think
s/$/\n0000000000/
tb

#This branch moves the decimal point 1 to the right
:b
#Remove leading 0's (such as from numbers like .05 => 0.5)
s/^0+//
#Move the decimal point 1 to the right
s/\.(.)(.*\n)/\1.\2/
#If the above has resulted in a successful substitution, go to branch D
tD
#else go to branch F
bF

#Multiply the dividend by 10; also keeps the mood positive
:D
s/.*/&&&&&&&&&&/2m
#Then go back to branch b
tb

:F
#Remove decimal point since it is all the way to the right now
s/\.//
h
#Remove "unnecessary" things
s/\n.+//
s/-//

#Convert to unary
:
s/\b9/;8/
s/\b8/;7/
s/\b7/;6/
s/\b6/;5/
s/\b5/;4/
s/\b4/;3/
s/\b3/;2/
s/\b2/;1/
s/\b1/;0/
s/\b0//
/[^;]/s/;/&&&&&&&&&&/g
t
y/;/0/

#Append the unary number to the pattern space
x
G
s/[^-]+(\n0+)\n(0+)/\2\1/

### END Decimal-to-Unary conversion
### BEGIN Division

#Performs Long Division
#Format looks something like this (can't remember): divisor\ndividend\ncount\nresult
#Count controls how many decimal places the answer should have; dp => 10^numDigits(n)
#Removes divisor from dividend and then add a 0 to result
#Once the dividend becomes too small, append a space to result and remove a zero from count
#Rinse and repeat
s/\n0+/&&\n./
:a
s/^(-?)(0*)0\n0\2(.*)$/\10\2\n\30/
ta
s/.*/&&&&&&&&&&/2m
s/\n0(0*\n\..*)$/\n\1 x/
Td
s/x//
ta

### END DIVISION
### BEGIN Unary-to-Decimal conversion

:d
s/[^-]+\n//
s/-(.+)/\1-/
s/\n//

#"carry over"-ing; .0000000000 => 0.
:x
s/^0{10}/0x/
s/(.)0{10}/0\1/
tx

#Convert each pair of unary 0s to their decimal counterparts
s/00/2/g
s/22/4/g
y/0/1/
s/41/5/g
s/21/3/g
s/45/9/g
s/44/8/g
s/43/7/g
s/42/6/g
y/ /0/
s/([1-9])0/\1/g
y/x/0/
s/(.+)-/-\1/

편집

• s:s/(.)/(.)/g:y/\1/\2/g:g 각 대체마다 1 바이트를 저장합니다 (총 5 개)
• "sed의 골프를위한 팁"에서 멋진 십진수-단항 변환기를 살펴보면서 많은 바이트를 절약했습니다.
• 나는 6 바이트를 절약하기 위해 빼기 기호를 돌보는 것에 대한 일부 대체를 바 꾸었습니다.
• 구분 기호 \n대신 사용 된 ;다음 "10을 곱하여"대체를 줄여 12 바이트를 절약 할 수있었습니다 (@Riley 및 @seshoumara 덕분에이를 보여줍니다)

JSFuck , 3320 바이트

JSFuck은 JavaScript의 원자 부분을 기반으로하는 난해하고 교육적인 프로그래밍 스타일입니다. 6 개의 문자 만 사용 ()[]+!하여 코드를 작성하고 실행합니다.

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

온라인으로 사용해보십시오!

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

오일 , 1428 1420 바이트

오 잘 나는 그것을 시도해 볼 수도 있다고 생각했고 결국 성공했습니다. 단점은 하나뿐입니다. 작성하는 데 걸리는 시간이 거의 걸립니다.

프로그램은 여러 개의 파일로 분리되어 있으며 모든 1 바이트 파일 이름을 가지고 있습니다 (그리고 바이트 계산에서 추가 바이트 하나를 계산합니다). 일부 파일은 OIL 언어의 예제 파일의 일부이지만, 일관되게 호출 할 수있는 실제 방법은 없습니다 (오일에는 아직 검색 경로 나 이와 유사한 경로가 없으므로 표준 라이브러리로 간주하지 않습니다). 또한 (게시 시점에서) 일부 파일은 필요한 것보다 더 장황하지만 일반적으로 몇 바이트 만 있음을 의미합니다.

계산은 4 자리 정밀도까지 정확하지만 간단한 역수 (예 : 입력)도 계산 3 ) 하는 데 시간이 오래 걸립니다 (5 분 이상). 테스트 목적으로, 나는 2 자리로 정확한 작은 변형을 만들었습니다. 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 (2 개의 주어진 문자열에 합류), 20 + 1 = 21 바이트 :

5
0
5
1
13
0
2
0
4
0

c (심볼이 주어지면 주어진 문자열을 처음에 나눕니다), 143 + 1 = 144 바이트 (이것은 여전히 ​​골프 가능합니다) :

5
0
5
83
12
83
83





10
84
0
21
17
8
13
6
12
1
13
1
1
5
2
14
i
45
1
1
83
1
1
45
2
14
i
57
1
9
45
13
84

1



8
13
1
13
56
13
13

2
4
1
11
4
2

d (문자열을 제공하고 처음 4자를 가져옵니다), 22 + 1 = 23 바이트 :

5
0
12
0
20
13
21
4

4

e (높은 수준의 나누기 (제로 나누기 위험이있는)), 138 + 1 = 139 바이트 :

5
0
5
1
.
.
1
1
6
14
j
0
0
1
0
4
10
11
1
58
21
14
b
4
4
1
1
15
14
k
0
15
1
6
1
14
j
0
0
1
0
5
14
b
4
4
9
8
10
8
11
58
53
10
11
1
58
25
4
4

f (점 4를 오른쪽으로 이동; 10000으로 "나누기"), 146 + 1 = 147 바이트 :

5
.
12
0
100
10
101
1
14
10
8
6
6
5
1
6
34
1
6
33
8
33
1
6
37
8
37
10
55
3
48
32
1
102
101
1
1
102
9
55
8
34
8
33
8
37
6
27
1
100
53
13
101


4

4

g (문자열이 주어진 문자로 시작하는지 확인), 113 + 1 = 114 바이트 :

5
0
5
1
12
0
100
12
1
200
1
6
2
1
9
3
8
2
8
3
9
100
9
200
1
2
31
1
3
32
10


39
35
4
38
3
N
10
100
5
44
16
4
46
Y

h (지정된 문자열의 첫 문자를 제외한 모든 것을 반환), 41 + 1 = 42 바이트 :

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

0
4
0

i (두 숫자 빼기), 34 + 1 = 35 바이트 :

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

j (모든 경우에 작동하지 않는 하위 수준 나누기), 134 + 1 = 135 바이트 :

5
0
5
2
10
2
19
52
9
1
2
3
10
23
2
28
17
10
23
0
35
22
9
0
9
2
6
12
8
1
1
3
2
6
17
10
23
2
46
40
9
2
9
3
6
35
4
1
11
4
3
3
4
19
11
4
0

k (곱셈), 158 + 1 = 159 바이트 :

5
0
5
1
8
0
9
0
8
1
9
1
1
5
2
12
0
68
10
69
66
23
29
8
7
14
l
0
0
12
1
68
10
69
66
37
43
8
7
14
l
1
1
10
0
5
56
48
9
0
14
m
2
1
6
43
10
7
3
61
63
4
66
4
2
3
-

l (절대 값 반환), 58 + 1 = 59 바이트 :

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

0
6
10

m (추가), 109 + 1 = 110 바이트 :

5
0
5
1
8
0
9
0
8
1
9
1
12
1
46
10
47
45
31
20
10
1
43
42
25
9
1
8
0
6
20
10
1
43
42
36
8
1
9
0
6
31
4
0
3
-

J, 1 바이트

%

%입력의 역수를주는 함수입니다. 이렇게 실행할 수 있습니다

   % 2
0.5

택시 , 467 바이트

Go to Starchild Numerology:w 1 l 2 r 1 l 1 l 2 l.1 is waiting at Starchild Numerology.Pickup a passenger going to Divide and Conquer.Go to Post Office:w 1 r 2 r 1 r 1 l.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:s 1 l 1 r.Pickup a passenger going to Divide and Conquer.Go to Divide and Conquer:e 4 l.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:e 1 r.Pickup a passenger going to Post Office.Go to Post Office:e 1 l 1 r.

온라인으로 사용해보십시오!

언 골프 드 :

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

Vim, 10 8 바이트 / 키 스트로크

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

V는 이전 버전과 호환 되므로 온라인으로 사용해 볼 수 있습니다!

x86_64 Linux 기계 언어, 5 바이트

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

이것을 테스트하기 위해 다음 C 프로그램을 컴파일하고 실행할 수 있습니다

#include<stdio.h>
#include<math.h>
const char f[]="\xf3\xf\x53\xc0\xc3";
int main(){
  for( float i = .1; i < 2; i+= .1 ) {
    printf( "%f %f\n", i, ((float(*)(float))f)(i) );
  }
}

온라인으로 사용해보십시오!

C, 15 12 바이트

#define f 1/

온라인으로 사용해보십시오!

정수 입력도 처리해야하는 경우 16 13 바이트 :

#define f 1./

따라서 f(3)대신에 호출 할 수 있습니다 f(3.0).

온라인으로 사용해보십시오!

3 바이트 골프를위한 @hvd에 감사합니다!

MATLAB / 옥타브, 4 바이트

@inv

(라는 함수 핸들 작성 ans에)를 내장 inv기능

온라인 데모

05AB1E , 1 바이트

z

온라인으로 사용해보십시오!

z # pop a  push 1 / a

GNU sed , 377362 + 1 (r 플래그) = 363 바이트

경고 : 프로그램은 실행하려고하는 모든 시스템 메모리를 소모하므로 기꺼이 기다릴 시간보다 더 많은 시간이 필요합니다! 설명과 빠르지 만 덜 정확한 버전은 아래를 참조하십시오.

s:\.|$:,,,,,,,,:;:i;s:,(,+)(\w):\2\1:;ti
h;:;s:\w::2g;y:9876543210:87654321\t :;/ /!s:,:@,:;/\s/!t;x;s:-?.::;x;G;s:,.*::m;s:\s::g;/\w/{s:@+:&&&&&&&&&&:;t}
/@,-?@/!{s:^:10000000,:;h;t}
:l;s:(@+)(,-?\1):\2;:;tl;s:,::;s:@+;?@+::
s:-?:&0:;:c;s:\b9+:0&:;s:.9*;:/&:;h;s:.*/::;y:0123456789:1234567890:;x;s:/.*::;G;s:\n::;s:;::;/;/tc
:f;s:(\w)(,+),:\2\1:;tf;s:,:.:;y:,:0:

이것은 Martin Ender 의 Retina 답변 을 기반으로합니다 . I 개수 \t리터럴 탭 (1 바이트)와 같은 라인 (2)로부터.

나의 주요 공헌은 십진법에서 일반 단항으로 변환하는 방법 (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).

자바 스크립트 ES6, 6 바이트

x=>1/x

온라인으로 사용해보십시오!

자바 스크립트는 기본적으로 부동 소수점 나누기로 설정됩니다.

APL, 1 바이트

÷

÷모나 딕 함수로 사용될 때 역수를 계산합니다. 온라인으로 사용해보십시오!

Dyalog Classic 문자 세트를 사용합니다.

체다 , 5 바이트

1&(/)

온라인으로 사용해보십시오!

이것은 &인수를 함수에 결합하는을 사용 합니다. 이 경우 1의 왼쪽에 바인딩 /우리를 제공, 1/x인수에 대해, x. 이것은 표준 x->1/x바이트 보다 1 바이트 짧습니다 .

또는 최신 버전에서 :

(1:/)

자바 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 개 :

(-1).__rpow__

14 바이트 당 1 개 :

1 .__truediv__

Mathematica, 4 바이트

1/#&

정확한 합리성을 제공하면 정확한 합리성을 제공하고 부동 소수점 결과를 제공하면 부동 소수점 결과를 제공합니다.

ZX 스펙트럼 기본, 13 바이트

1 INPUT A: PRINT SGN PI/A

노트:

• 각 줄은 줄 번호는 2 바이트, 줄 길이는 2 바이트, 줄 바꿈은 1 바이트입니다.
• 구문 분석시 숫자 리터럴이 2 진으로 변환되어 추가 6 바이트가 소요되므로 SGN PIliteral 대신 사용 됩니다 1.
• 키워드는 각각 1 바이트를 사용합니다.

17 바이트 용 ZX81 버전 :

1 INPUT A
2 PRINT SGN PI/A

하스켈 , 4 바이트

(1/)

온라인으로 사용해보십시오!

R, 8 바이트

1/scan()

꽤 직설적 인. 입력의 역수를 직접 출력합니다.

다른 1 바이트 더 긴 솔루션은 : scan()^-1또는 scan()**-1추가 바이트 일 수 있습니다 . 모두 ^와 **힘을 상징입니다.

TI 기본 (TI-84 Plus CE), 6 5 2 바이트

Ans⁻¹

Timtech 덕분에 -1 바이트 .

Григорий ПерельманAns 덕분에 -3 바이트 .

Ans하고 ⁻¹있는 1 바이트의 토큰 .

TI-Basic은 마지막으로 평가 된 마지막 값 ( Ans⁻¹)을 암시 적으로 반환합니다 .

젤리 , 1 바이트

İ

온라인으로 사용해보십시오!

C, 30 바이트

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