Thử thách

Cho một số (dấu phẩy động / số thập phân), trả về đối ứng của nó, tức là 1 chia cho số đó. Đầu ra phải là số dấu phẩy động / số thập phân, không chỉ là số nguyên.

Chi tiết kĩ thuật

• Bạn phải nhận đầu vào dưới dạng số dấu phẩy động / số thập phân ...
  • ... có ít nhất 4 chữ số chính xác (nếu cần).
  • Nhiều hơn là tốt hơn, nhưng không được tính vào điểm số.
• Bạn phải xuất ra, với bất kỳ phương thức đầu ra nào được chấp nhận ...
  • ... đối ứng của số.
  • Điều này có thể được định nghĩa là 1 / x, x⁻¹.
  • Bạn phải xuất với ít nhất 4 chữ số chính xác (nếu cần).

Đầu vào sẽ dương hoặc âm, bao gồm giá trị tuyệt đối trong phạm vi [0,0001, 9999]. Bạn sẽ không bao giờ được cung cấp quá 4 chữ số qua dấu thập phân, cũng không quá 4 chữ số bắt đầu từ chữ số khác không đầu tiên. Đầu ra cần phải chính xác đến chữ số thứ 4 từ số không đầu tiên.

(Cảm ơn @MartinEnder)

Dưới đây là một số mẫu đầu vào:

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

Lưu ý rằng bạn sẽ không bao giờ được cung cấp đầu vào có độ chính xác trên 4 chữ số.

Đây là một hàm mẫu trong Ruby:

def reciprocal(i)
    return 1.0 / i
end

Quy tắc

• Tất cả các hình thức đầu ra được chấp nhận đều được cho phép
• Sơ hở tiêu chuẩn bị cấm
• Đây là môn đánh gôn , câu trả lời ngắn nhất bằng byte thắng, nhưng sẽ không được chọn.

Làm rõ

• Bạn sẽ không bao giờ nhận được đầu vào 0.

Tiền thưởng

Thách thức này rõ ràng là tầm thường trong hầu hết các ngôn ngữ, nhưng nó có thể đưa ra một thử thách thú vị bằng các ngôn ngữ bí truyền và bất thường hơn, vì vậy một số người dùng sẵn sàng trao điểm khi thực hiện điều này bằng các ngôn ngữ khó khác thường.

• @DJMcMayhem sẽ trao phần thưởng +150 điểm cho câu trả lời ngắn nhất về não, vì flak não rất khó đối với các số có dấu phẩy động

• @ L3viathan sẽ trao phần thưởng +150 điểm cho câu trả lời DẦU ngắn nhất . DẦU không có loại dấu phẩy động riêng, cũng không có phân chia.

• @Riley sẽ trao phần thưởng +100 điểm cho câu trả lời ngắn nhất.

• @EriktheOutgolfer sẽ trao phần thưởng +100 điểm cho câu trả lời ngắn nhất của Sesos. Phân chia trong các dẫn xuất brainfuck như Sesos là rất khó khăn, nói gì đến phân chia điểm nổi.

• Tôi ( @Mendeleev ) sẽ trao phần thưởng +100 điểm cho câu trả lời Retina ngắn nhất.

Nếu có một ngôn ngữ mà bạn nghĩ sẽ rất vui khi thấy câu trả lời và bạn sẵn sàng trả tiền cho đại diện, vui lòng thêm tên của bạn vào danh sách này (được sắp xếp theo số tiền thưởng)

Bảng xếp hạng

Dưới đây là một Đoạn trích để tạo tổng quan về người chiến thắng theo ngôn ngữ.

Để đảm bảo rằng câu trả lời của bạn hiển thị, vui lòng bắt đầu câu trả lời của bạn bằng một tiêu đề, sử dụng mẫu Markdown sau:

# Language Name, N bytes

nơi Nlà kích thước của trình của bạn. Nếu bạn cải thiện điểm số của mình, bạn có thể giữ điểm số cũ trong tiêu đề, bằng cách đánh bại chúng thông qua. Ví dụ:

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

Nếu bạn muốn bao gồm nhiều số trong tiêu đề của mình (ví dụ: vì điểm của bạn là tổng của hai tệp hoặc bạn muốn liệt kê riêng các hình phạt cờ của thông dịch viên), hãy đảm bảo rằng điểm thực tế là số cuối cùng trong tiêu đề:

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

Bạn cũng có thể đặt tên ngôn ngữ thành liên kết sau đó sẽ hiển thị trong đoạn trích bảng xếp hạng:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

var QUESTION_ID=114544,OVERRIDE_USER=62393;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={};e.forEach(function(e){var o=e.language;/<a/.test(o)&&(o=jQuery(o).text().toLowerCase()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link,uniq:o}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.uniq>s.uniq?1:e.uniq<s.uniq?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=617d0685f6f3"> <div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr></tbody> </table>

Brain-Flak , 772 536 530 482 480 + 1 = 481 byte

Vì Brain-Flak không hỗ trợ số dấu phẩy động nên tôi phải sử dụng -c cờ theo thứ tự đầu vào và đầu ra với các chuỗi, do đó là +1.

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

Hãy thử trực tuyến!

Giải trình

Điều đầu tiên chúng ta cần quan tâm là trường hợp tiêu cực. Vì đối ứng của một số âm luôn luôn âm, chúng ta chỉ cần giữ dấu âm cho đến hết. Chúng tôi bắt đầu bằng cách tạo một bản sao của đỉnh ngăn xếp và trừ 45 (giá trị ASCII của -) từ nó. Nếu đây là một cái chúng ta đặt số 0 lên trên cùng của ngăn xếp, nếu không chúng ta không làm gì cả. Sau đó, chúng tôi chọn đầu của ngăn xếp để được đặt xuống vào cuối chương trình. Nếu đầu vào bắt đầu bằng cái -này vẫn là một -tuy nhiên nếu không phải là chúng ta sẽ chọn số 0 mà chúng ta đã đặt.

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

Bây giờ, đó là cách chúng ta cần chuyển đổi việc thực hiện ASCII của từng chữ số thành giá trị thực (0-9). Chúng tôi cũng sẽ xóa dấu thập phân .để tính toán dễ dàng hơn. Vì chúng ta cần biết điểm thập phân bắt đầu từ đâu khi chúng ta xác nhận lại sau đó, chúng ta lưu trữ một số để theo dõi có bao nhiêu chữ số ở phía trước. offstack.

Đây là cách mã thực hiện điều đó:

Chúng tôi bắt đầu bằng cách trừ 46 (giá trị ASCII của .) từ mỗi phần tử trên ngăn xếp (đồng thời di chuyển tất cả chúng vào offstack). Điều này sẽ làm cho mỗi chữ số nhiều hơn hai chữ số nhưng sẽ làm cho .số không chính xác.

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

Bây giờ chúng tôi di chuyển mọi thứ vào ngăn xếp bên trái cho đến khi chúng tôi đạt đến số 0 (trừ hai từ mỗi chữ số trong khi chúng tôi đi):

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

Chúng tôi ghi lại chiều cao ngăn xếp

([]<

Di chuyển mọi thứ khác vào ngăn xếp bên trái (một lần nữa trừ hai số cuối khỏi mỗi chữ số khi chúng ta di chuyển chúng)

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

Và đặt chiều cao ngăn xếp chúng tôi ghi lại

>)

Bây giờ chúng tôi muốn kết hợp các chữ số thành một số 10 cơ sở duy nhất. Chúng tôi cũng muốn tạo ra lũy thừa 10 với hai chữ số là số đó để sử dụng trong tính toán.

Chúng tôi bắt đầu bằng cách thiết lập 1 trên đỉnh của ngăn xếp để tạo ra sức mạnh của 10 và đẩy chiều cao của ngăn xếp trừ đi một đến ngăn xếp trên để sử dụng vòng lặp.

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

Bây giờ chúng ta lặp lại chiều cao ngăn xếp trừ đi 1 lần,

{
 ({}[()]<

Mỗi lần chúng ta nhân phần tử trên cùng với 100 và bên dưới nó nhân phần tử tiếp theo với 10 và thêm phần tử đó vào số bên dưới.

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

Chúng tôi kết thúc vòng lặp của chúng tôi

 >)
}{}

Bây giờ chúng tôi cuối cùng đã hoàn thành việc thiết lập và có thể bắt đầu tính toán thực tế.

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

Điều đó là vậy đó...

Chúng tôi chia sức mạnh của 10 cho phiên bản sửa đổi của đầu vào bằng thuật toán chia số nguyên của 0 ' như được tìm thấy trên wiki . Điều này mô phỏng sự phân chia 1 theo đầu vào theo cách duy nhất Brain-Flak biết.

Cuối cùng, chúng ta phải định dạng đầu ra của mình thành ASCII thích hợp.

Bây giờ chúng tôi đã tìm thấy nechúng tôi cần phải đưa ra e. Bước đầu tiên để chuyển đổi nó thành một danh sách các chữ số. Mã này là một phiên bản sửa đổi của 0 ' 's thuật toán divmod .

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

Bây giờ chúng ta lấy số và thêm dấu thập phân trở lại vị trí của nó. Chỉ cần nghĩ về phần mã này sẽ khiến bạn đau đầu, vì vậy bây giờ tôi sẽ để nó như một bài tập để người đọc tìm ra cách thức và lý do tại sao nó hoạt động.

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

Đặt dấu âm xuống hoặc ký tự null nếu không có dấu âm.

>)

Python 2 , 10 byte

1..__div__

Hãy thử trực tuyến!

Võng mạc , 99 91 byte

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

Hãy thử trực tuyến!

Woohoo, phụ 100! Điều này là hiệu quả đáng ngạc nhiên, xem xét rằng nó tạo ra (và sau đó khớp với) một chuỗi có hơn 10 ⁷ ký tự tại một điểm. Tôi chắc chắn rằng nó chưa tối ưu, nhưng tôi khá hài lòng với điểm số vào lúc này.

Kết quả có giá trị tuyệt đối nhỏ hơn 1 sẽ được in mà không có số 0 đứng đầu, ví dụ .123hoặc-.456 .

Giải trình

Ý tưởng cơ bản là sử dụng phép chia số nguyên (vì điều đó khá dễ dàng với regex và số học đơn nguyên). Để đảm bảo rằng chúng tôi có đủ số chữ số có nghĩa, chúng tôi chia đầu vào thành 10 ⁷ . Bằng cách đó, bất kỳ đầu vào nào lên tới 9999 vẫn dẫn đến một số có 4 chữ số. Thực tế, điều đó có nghĩa là chúng ta nhân kết quả với 10 ⁷ vì vậy chúng ta cần theo dõi điều đó khi sau đó xác nhận lại dấu thập phân.

1`\.|$
8$*;

Chúng tôi bắt đầu bằng cách thay thế dấu thập phân hoặc kết thúc chuỗi nếu không có dấu thập phân bằng 8 dấu chấm phẩy. Cái đầu tiên trong số chúng thực chất là dấu thập phân (nhưng tôi đang sử dụng dấu chấm phẩy vì chúng không cần phải thoát), 7 cái còn lại chỉ ra rằng giá trị đã được nhân với 10 ⁷ (đây chưa phải là trường hợp, nhưng chúng tôi biết chúng tôi sẽ làm điều đó sau).

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

Đầu tiên chúng ta biến đầu vào thành một số nguyên. Miễn là vẫn còn các chữ số sau dấu thập phân, chúng ta di chuyển một chữ số ra phía trước và xóa một trong các dấu chấm phẩy. Điều này là do việc di chuyển dấu thập phân phải nhân số đầu vào lên 10 và do đó chia kết quả cho 10 . Do các hạn chế đầu vào, chúng tôi biết điều này sẽ xảy ra nhiều nhất bốn lần, do đó, luôn có đủ dấu chấm phẩy để xóa.

\d+
$*1,10000000$*

Bây giờ đầu vào là một số nguyên, chúng tôi chuyển đổi nó thành đơn nguyên và nối thêm 10 ⁷ 1 giây (cách nhau bởi a ,).

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

Chúng tôi chia số nguyên thành 10 ⁷ bằng cách đếm xem có bao nhiêu phản hồi cho nó phù hợp ( $#2). Đây là phân chia số nguyên tiêu chuẩn a,b-> b/a. Bây giờ chúng ta chỉ cần sửa vị trí của dấu thập phân.

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

Điều này về cơ bản là nghịch đảo của giai đoạn thứ hai. Nếu chúng ta vẫn có nhiều dấu chấm phẩy, điều đó có nghĩa là chúng ta vẫn cần chia kết quả cho 10 . Chúng tôi thực hiện điều này bằng cách di chuyển dấu chấm phẩy một vị trí sang trái và thả một dấu chấm phẩy cho đến khi chúng tôi đạt đến đầu bên trái của số hoặc chúng tôi chỉ còn lại một dấu chấm phẩy (chính là dấu thập phân).

1`;
.

Bây giờ là thời điểm tốt để biến đầu tiên (và có thể duy nhất) ;trở lại ..

;
0

Nếu vẫn còn dấu chấm phẩy, chúng ta đã chạm đến đầu bên trái của số, do đó, chia cho 10 lần nữa sẽ chèn các số 0 phía sau dấu thập phân. Điều này được thực hiện dễ dàng bằng cách thay thế từng phần còn lại ;bằng a 0, vì chúng ngay sau dấu thập phân.

yup , 5 byte

|0~-e

Hãy thử trực tuyến!Điều này lấy đầu vào từ đỉnh của ngăn xếp và để lại đầu ra trên đỉnh của ngăn xếp. Liên kết TIO lấy đầu vào từ các đối số dòng lệnh, chỉ có khả năng lấy đầu vào số nguyên.

Giải trình

yup chỉ có một vài toán tử. Những cái được sử dụng trong câu trả lời này là ln (x) (đại diện bởi |), 0 () (hằng số, hàm nilary trả về 0), - (trừ) và exp (x) (đại diện bởi e). ~chuyển đổi hai thành viên hàng đầu trên ngăn xếp.

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

Điều này sử dụng danh tính

ngụ ý rằng

LOLCODE , 63 , 56 byte

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

7 byte được lưu nhờ vào @devR Rich!

Điều này xác định một hàm 'r', có thể được gọi bằng:

r 5.0

Hay bất cứ thứ gì khác NUMBAR .

Hãy thử trực tuyến!

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

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

Hãy thử trực tuyến!

Lưu ý: các số float mà giá trị tuyệt đối nhỏ hơn 1 sẽ phải được viết mà không có số 0 giống như .5thay vì 0.5. Ngoài ra số lượng vị trí thập phân bằng , trong đó nsố lượng vị trí thập phân trong số (vì vậy, đưa ra 13.0làm đầu vào sẽ cho nhiều vị trí thập phân hơn so với cung cấp 13làm đầu vào)

Đây là lần gửi sed đầu tiên của tôi trên PPCG. Ý tưởng cho việc chuyển đổi thập phân sang đơn nhất được lấy từ câu trả lời tuyệt vời này . Cảm ơn @seshoumara đã hướng dẫn tôi qua sed!

Mã này thực hiện phân chia dài lặp đi lặp lại để có được kết quả. Việc phân chia chỉ mất ~ 150 byte. Các chuyển đổi thập phân đơn nguyên chiếm nhiều byte nhất và một vài byte khác chuyển sang hỗ trợ các số âm và đầu vào dấu phẩy động

Giải trình

Giải thích về 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/

Chỉnh sửa

• s:s/(.)/(.)/g:y/\1/\2/g:g để lưu 1 byte ở mỗi lần thay thế (tổng cộng 5)
• Đã tiết kiệm được một tấn byte bằng cách xem xét một công cụ chuyển đổi thập phân sang unary đẹp mắt trên "Mẹo chơi gôn trong sed"
• Tôi đã thay đổi xung quanh một số thay thế xoay quanh việc chăm sóc dấu trừ để lưu 6 byte.
• Được sử dụng \nthay vì ;dấu phân cách, sau đó tôi có thể rút ngắn "nhân với 10" để tiết kiệm 12 byte (cảm ơn @Riley và @seshoumara đã cho tôi thấy điều này)

JSFuck , 3320 byte

JSFuck là một phong cách lập trình bí truyền và giáo dục dựa trên các phần nguyên tử của JavaScript. Nó chỉ sử dụng sáu ký tự khác nhau ()[]+!để viết và thực thi mã.

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

Hãy thử trực tuyến!

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

DẦU , 1428 1420 byte

Ồ tốt Tôi nghĩ rằng tôi cũng có thể thử nó, và cuối cùng tôi đã thành công. Chỉ có một nhược điểm: Mất nhiều thời gian để viết.

Chương trình được tách thành nhiều tệp, có tất cả tên tệp 1 byte (và được tính cho một byte bổ sung trong tính toán byte của tôi). Một số tệp là một phần của các tệp mẫu của ngôn ngữ OIL, nhưng không có cách nào thực sự để gọi chúng một cách nhất quán (chưa có đường dẫn tìm kiếm hoặc bất cứ thứ gì tương tự trong OIL, vì vậy tôi không coi chúng là thư viện chuẩn), nhưng điều đó cũng có nghĩa là (tại thời điểm đăng) một số tệp dài hơn so với cần thiết, nhưng thường chỉ bằng một vài byte.

Các tính toán chính xác đến 4 chữ số chính xác, nhưng tính toán ngay cả một đối ứng đơn giản (chẳng hạn như đầu vào 3 ) phải mất một thời gian rất dài (hơn 5 phút) để hoàn thành. Để thử nghiệm, tôi cũng đã tạo một biến thể nhỏ chính xác đến 2 chữ số, chỉ mất vài giây để chạy, để chứng minh rằng nó hoạt động.

Tôi xin lỗi vì câu trả lời lớn, tôi ước tôi có thể sử dụng một số loại thẻ spoiler. Tôi cũng có thể đặt phần lớn của nó trên gist.github.com hoặc một cái gì đó tương tự, nếu muốn.

Ở đây chúng tôi đi : main, 217 byte (tên tệp không được tính cho byte):

5
1
1
4
-
14
a
5
Y
10
5
8
14
29
12
1
97
1
97
24
9
24
13
99

1
1
4
31
1
35

14
a
32
.
10
32
8
50
41
1
53
2
14
b
1
1
6
72
14
c
5
0000
14
d
6
6
10
74
5
63
68
1
6
1
6
72
14
b
1
5
1
77
0
14
e
1
0
14
f
1
1
1
31
0
14
b
0
0
4

a (kiểm tra xem một chuỗi đã cho có nằm trong một chuỗi đã cho không), 74 + 1 = 75 byte:

5
0
5
1
14
g
2
0
10
2
30
24
13
10
1
31
27
18
14
h
1
1
6
4
4
30
3
4
29
N
Y

b (nối hai chuỗi đã cho), 20 + 1 = 21 byte:

5
0
5
1
13
0
2
0
4
0

c (được cung cấp một ký hiệu, tách chuỗi đã cho ở lần xuất hiện đầu tiên), 143 + 1 = 144 byte (cái này rõ ràng vẫn có thể chơi được):

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 (được cung cấp một chuỗi, nhận 4 ký tự đầu tiên), 22 + 1 = 23 byte:

5
0
12
0
20
13
21
4

4

e (phân chia cấp cao (nhưng với mức độ nguy hiểm phân chia bằng 0)), 138 + 1 = 139 byte:

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

f (di chuyển một vị trí 4 chấm sang phải; "chia" cho 10000), 146 + 1 = 147 byte:

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


4

4

g (kiểm tra nếu một chuỗi bắt đầu bằng một ký tự đã cho), 113 + 1 = 114 byte:

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


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

h (trả về mọi thứ trừ ký tự đầu tiên của một chuỗi đã cho), 41 + 1 = 42 byte:

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

0
4
0

i (trừ hai số), 34 + 1 = 35 byte:

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

j (phân chia cấp thấp không hoạt động trong mọi trường hợp), 134 + 1 = 135 byte:

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

k (phép nhân), 158 + 1 = 159 byte:

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

l (trả về giá trị tuyệt đối), 58 + 1 = 59 byte:

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

0
6
10

m (ngoài ra), 109 + 1 = 110 byte:

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

J, 1 byte

%

%là một hàm cho đối ứng đầu vào của nó. Bạn có thể chạy nó như thế này

   % 2
0.5

Taxi , 467 byte

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

Hãy thử trực tuyến!

Ung dung:

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

Vim, 10 8 byte / tổ hợp phím

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

Vì V tương thích ngược, bạn có thể dùng thử trực tuyến!

x86_64 ngôn ngữ máy Linux, 5 byte

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

Để kiểm tra điều này, bạn có thể biên dịch và chạy chương trình C sau

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

Hãy thử trực tuyến!

C, 15 12 byte

#define f 1/

Hãy thử trực tuyến!

16 13 byte, nếu cần cũng xử lý đầu vào số nguyên:

#define f 1./

Vì vậy, bạn có thể gọi nó với f(3)thay vì f(3.0).

Hãy thử trực tuyến!

Cảm ơn @hvd vì đã chơi golf 3 byte!

MATLAB / Octave, 4 byte

@inv

Tạo một hàm xử lý (được đặt tên ans) cho invhàm tích hợp

Demo trực tuyến

05AB1E , 1 byte

z

Hãy thử trực tuyến!

z # pop a  push 1 / a

GNU sed , 377 362 + 1 (cờ r) = 363 byte

Cảnh báo: chương trình sẽ ăn tất cả bộ nhớ hệ thống đang cố chạy và cần nhiều thời gian để hoàn thành hơn là bạn sẵn sàng chờ đợi! Xem bên dưới để được giải thích và một phiên bản nhanh, nhưng ít chính xác hơn.

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:

Điều này dựa trên câu trả lời Retina của Martin Ender. Tôi đếm \ttừ dòng 2 dưới dạng tab bằng chữ (1 byte).

Đóng góp chính của tôi là phương thức chuyển đổi từ số thập phân sang đơn vị đơn giản (dòng 2) và ngược lại (dòng 5). Tôi đã quản lý để giảm đáng kể kích thước mã cần thiết để làm điều này (bằng ~ 40 byte kết hợp), so với các phương thức được hiển thị trong một mẹo trước đây . Tôi đã tạo ra một câu trả lời mẹo riêng với các chi tiết, nơi tôi cung cấp sẵn sàng để sử dụng đoạn trích. Vì 0 không được phép làm đầu vào, nên một vài byte đã được lưu.

Giải trình: để hiểu rõ hơn về thuật toán chia, hãy đọc câu trả lời Retina trước

Chương trình này đúng về mặt lý thuyết, lý do tại sao nó tiêu tốn quá nhiều tài nguyên tính toán là vì bước phân chia được chạy hàng trăm ngàn lần, nhiều hay ít tùy thuộc vào đầu vào và regex được sử dụng dẫn đến một cơn ác mộng quay ngược. Phiên bản nhanh làm giảm độ chính xác (do đó số bước phân chia) và thay đổi biểu thức chính quy để giảm quay lui.

Thật không may, sed không có phương pháp để tính trực tiếp số lần phản hồi phù hợp với một mẫu, như trong 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

Để có phiên bản nhanh và an toàn của chương trình, nhưng ít chính xác hơn, bạn có thể thử trực tuyến .

Japt , 2 byte

Giải pháp rõ ràng sẽ là

1/U

đó là, hoàn toàn theo nghĩa đen , 1 / input. Tuy nhiên, chúng ta có thể làm tốt hơn:

pJ

Điều này tương đương với input ** J, và Jđược đặt thành -1 theo mặc định.

Hãy thử trực tuyến!

Thực tế thú vị: như plà hàm năng lượng, qhàm gốc cũng vậy ( p2= **2, q2= **(1/2)); điều này có nghĩa là nó qJsẽ hoạt động tốt, kể từ đó -1 == 1/-1, và do đó x**(-1) == x**(1/-1).

Javascript ES6, 6 byte

x=>1/x

Hãy thử trực tuyến!

Javascript mặc định để phân chia điểm nổi.

APL, 1 byte

÷

÷Tính toán đối ứng khi được sử dụng như hàm đơn trị. Hãy thử trực tuyến!

Sử dụng bộ ký tự Dyalog Classic.

Cheddar , 5 byte

1&(/)

Hãy thử trực tuyến!

Điều này sử dụng &, liên kết một đối số cho một chức năng. Trong trường hợp này, 1bị ràng buộc ở phía bên trái của /, điều này cho chúng ta 1/x, cho một đối số x. Cái này ngắn hơn canonical x->1/x1 byte.

Ngoài ra, trong các phiên bản mới hơn:

(1:/)

Java 8, 6 byte

x->1/x

Gần giống như câu trả lời JavaScript .

MATL , 3 byte

l_^

Dùng thử tại MATL Online

Giải trình

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

Python, 12 byte

lambda x:1/x

Một cho 13 byte:

(-1).__rpow__

Một cho 14 byte:

1 .__truediv__

Toán học, 4 byte

1/#&

Cung cấp cho bạn một tỷ lệ hợp lý chính xác nếu bạn cung cấp cho nó một tỷ lệ hợp lý chính xác và với kết quả dấu phẩy động nếu bạn cho kết quả dấu phẩy động.

ZX Spectrum BASIC, 13 byte

1 INPUT A: PRINT SGN PI/A

Ghi chú:

• Mỗi dòng có giá 2 byte cho số dòng, 2 byte cho độ dài của dòng và 1 byte cho dòng mới
• Chữ số được chuyển đổi thành nhị phân tại thời điểm phân tích, chi phí thêm 6 byte, do đó sử dụng SGN PIthay vì bằng chữ 1.
• Từ khóa mất 1 byte mỗi.

Phiên bản ZX81 cho 17 byte:

1 INPUT A
2 PRINT SGN PI/A

Haskell , 4 byte

(1/)

Hãy thử trực tuyến!

R, 8 byte

1/scan()

Khá đơn giản. Trực tiếp đầu ra nghịch đảo của đầu vào.

Một giải pháp khác, nhưng dài hơn 1 byte có thể là : scan()^-1, hoặc thậm chí scan()**-1cho một byte bổ sung. Cả hai ^và **biểu tượng quyền lực.

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

Ans⁻¹

-1 byte nhờ Timtech .

-3 byte với Ansnhờ Григорий Перельман .

Ansvà ⁻¹là các mã thông báo một byte .

TI-Basic hoàn toàn trả về giá trị cuối cùng được đánh giá ( Ans⁻¹).

Thạch , 1 byte

İ

Hãy thử trực tuyến!

C, 30 byte

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