ท้าทาย

รับตัวเลข (ทศนิยม - ทศนิยม /) กลับตอบแทนซึ่งกันและกันเช่น 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

กฎระเบียบ

• อนุญาตรูปแบบเอาต์พุตทั้งหมดที่ยอมรับได้
• ช่องโหว่มาตรฐานถูกแบน
• นี่คือcode-golfคำตอบที่สั้นที่สุดในหน่วยไบต์ชนะ แต่จะไม่ถูกเลือก

ชี้แจง

• 0คุณจะไม่ได้รับการป้อนข้อมูล

โปรดปราน

เห็นได้ชัดว่าความท้าทายนี้เป็นเรื่องเล็กน้อยในภาษาส่วนใหญ่ แต่มันสามารถนำเสนอความท้าทายที่สนุกสนานในภาษาที่ลึกลับและผิดปกติมากขึ้นดังนั้นผู้ใช้บางคนยินดีที่จะให้คะแนนสำหรับการทำเช่นนี้ในภาษาที่ยากผิดปกติ

• @DJMcMayhemจะได้รับรางวัล150 คะแนนให้กับคำตอบที่สะกิดใจสมองที่สั้นที่สุดเนื่องจากการสะกิดของสมองนั้นยากสำหรับการรู้จำเลขทศนิยม

• @ L3viathanจะมอบรางวัล150 คะแนนให้กับคำตอบOIL ที่สั้นที่สุด OIL ไม่มีประเภทจุดลอยตัวแบบดั้งเดิมและไม่มีการหาร

• @Rileyจะมอบรางวัลให้100 คะแนนกับคำตอบที่สั้นที่สุด

• @EriktheOutgolferจะมอบรางวัล+100 คะแนนให้กับคำตอบของ Sesos ที่สั้นที่สุด การหารอนุพันธ์ของ brainfuck เช่น Sesos นั้นยากมาก

• ฉัน ( @Mendeleev ) จะมอบรางวัลจำนวน+100 คะแนนให้กับคำตอบของ Retina ที่สั้นที่สุด

หากมีภาษาที่คุณคิดว่าจะสนุกที่จะเห็นคำตอบและคุณยินดีที่จะจ่ายค่าตัวแทนรู้สึกฟรีเพื่อเพิ่มชื่อของคุณลงในรายการนี้ (เรียงตามจำนวนเงินที่โปรดปราน)

ลีดเดอร์บอร์ด

นี่คือตัวอย่างข้อมูลเพื่อสร้างภาพรวมของผู้ชนะตามภาษา

เพื่อให้แน่ใจว่าคำตอบของคุณปรากฏขึ้นโปรดเริ่มคำตอบด้วยหัวข้อโดยใช้เทมเพลต Markdown ต่อไปนี้:

# Language Name, N bytes

ที่Nมีขนาดของส่งของคุณ หากคุณปรับปรุงคะแนนของคุณคุณสามารถเก็บคะแนนเก่าไว้ในพาดหัวโดยการตีพวกเขาผ่าน ตัวอย่างเช่น

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

หากคุณต้องการรวมหลายตัวเลขไว้ในส่วนหัวของคุณ (เช่นเนื่องจากคะแนนของคุณคือผลรวมของสองไฟล์หรือคุณต้องการแสดงรายการการลงโทษการตั้งค่าสถานะของล่ามแยกต่างหาก) ตรวจสอบให้แน่ใจว่าคะแนนจริงเป็นตัวเลขสุดท้ายในส่วนหัว:

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

นอกจากนี้คุณยังสามารถตั้งชื่อภาษาให้เป็นลิงค์ซึ่งจะปรากฏในตัวอย่างกระดานแต้มนำ:

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

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

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

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

Brain-Flak , 772 536 530 482 480 + 1 = 481 ไบต์

เนื่องจาก Brain-Flak ไม่รองรับจำนวนจุดลอยตัวดังนั้นฉันจึงต้องใช้-cแฟล็กเพื่อเรียงลำดับอินพุตและเอาต์พุตด้วยสตริงดังนั้น +1

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

ลองออนไลน์!

คำอธิบาย

สิ่งแรกที่เราต้องดูแลคือกรณีลบ เนื่องจากส่วนกลับของจำนวนลบเป็นลบเสมอเราก็สามารถทำเครื่องหมายลบได้จนกว่าจะสิ้นสุด เราเริ่มต้นด้วยการทำสำเนาด้านบนของสแต็กและลบ 45 (ค่า ASCII ของ-) จากมัน ถ้านี่คืออันที่เราวางศูนย์ไว้ด้านบนของสแต็กถ้าไม่ใช่เราไม่ทำอะไรเลย จากนั้นเราก็เลือกด้านบนของสแต็กเพื่อวางลงที่ส่วนท้ายของโปรแกรม หากอินพุตเริ่มต้นด้วยสิ่ง-นี้จะยังคงเป็น-เช่นนั้นหากไม่ใช่เราจะเลือกศูนย์ที่เราวางไว้

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

ตอนนี้มันเป็นวิธีที่เราจำเป็นต้องแปลงการรับรู้ ASCII ของแต่ละหลักให้เป็นค่าจริง (0-9) เรากำลังจะลบจุดทศนิยม.เพื่อทำให้การคำนวณง่ายขึ้น เนื่องจากเราจำเป็นต้องรู้ว่าจุดเริ่มต้นของทศนิยมเมื่อเราใส่เข้าไปใหม่ในภายหลังเราจะเก็บตัวเลขไว้เพื่อติดตามว่ามีกี่หลักที่อยู่ข้างหน้าในออฟที่.อยู่ข้างนอก

นี่คือวิธีการที่รหัสทำ:

เราเริ่มต้นด้วยการลบ 46 (ค่า ASCII ของ.) จากแต่ละองค์ประกอบในสแต็ก (พร้อมกันย้ายพวกมันทั้งหมดลงบน offstack) สิ่งนี้จะทำให้แต่ละหลักสองมากกว่าที่ควรจะเป็น แต่จะทำให้.เป็นศูนย์

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

ตอนนี้เราย้ายทุกอย่างไปที่สแต็กซ้ายจนกว่าเราจะตีศูนย์ (ลบสองหลักจากแต่ละหลักในขณะที่เราไป):

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

เราบันทึกความสูงของสแต็ก

([]<

ย้ายทุกอย่างไปยังสแต็กซ้าย (ลบอีกสองครั้งสุดท้ายออกจากทุกหลักเมื่อเราย้ายพวกมัน)

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

และใส่ความสูงของสแต็คที่เราบันทึกไว้

>)

ตอนนี้เราต้องการรวมตัวเลขเป็นเลขฐานเดียว 10 ตัว นอกจากนี้เรายังต้องการที่จะทำให้พลังงานของ 10 ด้วยตัวเลขสองหลักเป็นตัวเลขนั้นเพื่อใช้ในการคำนวณ

เราเริ่มต้นด้วยการตั้งค่า 1 ด้านบนของสแต็กเพื่อให้ได้กำลัง 10 และผลักความสูงของสแต็กลบหนึ่งไปยังสแต็กสำหรับการใช้การวนซ้ำ

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

ทีนี้เราวนความสูงของสแต็คลบ 1 ครั้ง

{
 ({}[()]<

แต่ละครั้งที่เราคูณองค์ประกอบด้านบนด้วย 100 และภายใต้องค์ประกอบนั้นจะคูณองค์ประกอบถัดไปด้วย 10 และเพิ่มเข้าไปในหมายเลขด้านล่าง

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

เราจบลูปของเรา

 >)
}{}

ในที่สุดเราก็เสร็จสิ้นการตั้งค่าและสามารถเริ่มการคำนวณจริงได้

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

นั่นมัน ...

เราแบ่งอำนาจของ 10 โดยรุ่นที่แก้ไขของการป้อนข้อมูลโดยใช้0 ' 's ขั้นตอนวิธีการแบ่งจำนวนเต็มเท่าที่พบในวิกิพีเดีย นี่เป็นการจำลองการหารของ 1 โดยอินพุตวิธีเดียวที่ Brain-Flak รู้

สุดท้ายเราต้องจัดรูปแบบผลลัพธ์ของเราเป็น ASCII ที่เหมาะสม

ตอนนี้ที่เราได้พบเราจำเป็นที่จะออกจากne eขั้นตอนแรกในการดำเนินการนี้คือการแปลงเป็นรายการตัวเลข รหัสนี้เป็นรุ่นที่แก้ไขของ0 ' 's divmod อัลกอริทึม

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

ตอนนี้เรารับจำนวนและเพิ่มจุดทศนิยมกลับไปที่ตำแหน่งนั้น แค่คิดเกี่ยวกับส่วนนี้ของรหัสจะทำให้ปวดหัวดังนั้นตอนนี้ฉันจะปล่อยให้มันเป็นแบบฝึกหัดสำหรับผู้อ่านที่จะคิดออกว่ามันทำงานอย่างไรและทำไม

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

วางเครื่องหมายลบหรืออักขระว่างถ้าไม่มีเครื่องหมายลบ

>)

Python 2 , 10 ไบต์

1..__div__

ลองออนไลน์!

เรติน่า , 99 91 ไบต์

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

ลองออนไลน์!

Woohoo, sub-100! สิ่งนี้มีประสิทธิภาพอย่างน่าประหลาดใจเมื่อพิจารณาว่าสร้าง (และจับคู่กับ) สตริงที่มีอักขระมากกว่า 10 ⁷ตัวในแต่ละจุด ฉันแน่ใจว่ามันยังไม่เหมาะสม แต่ฉันมีความสุขมากกับคะแนนในขณะนี้

ผลการค้นหาที่มีค่าสัมบูรณ์น้อยกว่า 1 จะถูกพิมพ์โดยไม่มีศูนย์นำเช่นหรือ.123-.456

คำอธิบาย

แนวคิดพื้นฐานคือการใช้การหารจำนวนเต็ม (เพราะค่อนข้างง่ายกับ regex และเลขคณิต unary) เพื่อให้แน่ใจว่าเราได้รับเป็นจำนวนที่เพียงพอของตัวเลขที่สำคัญเราแบ่งการป้อนข้อมูลลงใน10 7 ด้วยวิธีการป้อนข้อมูลใด ๆ ถึง9999ยังคงส่งผลให้ตัวเลข 4 หลัก อย่างมีประสิทธิภาพนั่นหมายความว่าเราคูณผลลัพธ์ด้วย10 ⁷ดังนั้นเราต้องติดตามสิ่งนั้นเมื่อใส่จุดทศนิยมอีกครั้งในภายหลัง

1`\.|$
8$*;

เราเริ่มต้นด้วยการแทนที่จุดทศนิยมหรือจุดสิ้นสุดของสตริงถ้าไม่มีจุดทศนิยมด้วย 8 เครื่องหมายอัฒภาค อันแรกของพวกมันคือจุดทศนิยมด้วยตัวเอง (แต่ฉันใช้เซมิโคลอนเพราะพวกมันไม่จำเป็นต้องหลบหนี) ส่วนอีก 7 บ่งบอกว่าค่าคูณด้วย10 ⁷ (ยังไม่เป็นเช่นนั้น แต่เรารู้ว่าเราจะทำในภายหลัง)

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

ก่อนอื่นเราจะเปลี่ยนอินพุตให้เป็นจำนวนเต็ม ตราบใดที่ยังมีตัวเลขหลังจุดทศนิยมเราย้ายหนึ่งหลักไปข้างหน้าและลบเครื่องหมายอัฒภาคหนึ่งรายการ เพราะนี่คือการย้ายจุดทศนิยมคูณขวาป้อนข้อมูลโดย10และดังนั้นจึงแบ่งผลโดย10 เนื่องจากข้อ จำกัด ในการป้อนข้อมูลเรารู้ว่าจะเกิดขึ้นมากที่สุดสี่ครั้งดังนั้นจึงมีการลบเครื่องหมายอัฒภาคเสมอ

\d+
$*1,10000000$*

ตอนนี้อินพุตเป็นจำนวนเต็มเราแปลงเป็น unary และผนวก10 ⁷ 1วินาที (คั่นด้วย a ,)

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

เราแบ่งจำนวนเต็มเป็น10 ⁷โดยนับจำนวนการตอบกลับที่เหมาะสม ( $#2) นี่คือมาตรฐานแบ่งจำนวนเต็มเอก->a,b b/aตอนนี้เราแค่ต้องแก้ไขตำแหน่งของจุดทศนิยม

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

นี่เป็นสิ่งที่ตรงกันข้ามกับขั้นตอนที่สอง ถ้าเรายังคงมีมากกว่าหนึ่งอัฒภาคนั่นหมายความว่าเรายังคงต้องแบ่งผลโดย10 เราทำสิ่งนี้โดยการย้ายเครื่องหมายอัฒภาคหนึ่งตำแหน่งไปทางซ้ายและวางเครื่องหมายอัฒภาคหนึ่งจนกว่าเราจะไปทางซ้ายสุดของตัวเลขหรือเราเหลือเพียงหนึ่งอัฒภาค (ซึ่งก็คือจุดทศนิยม)

1`;
.

ตอนนี้เป็นเวลาที่ดีที่จะเปิดเป็นครั้งแรก (และอาจจะเท่านั้น) กลับเข้ามา;.

;
0

หากยังมีเครื่องหมายอัฒภาคเหลืออยู่เราได้มาถึงจุดสิ้นสุดด้านซ้ายของตัวเลขดังนั้นการหารด้วย 10 อีกครั้งจะเป็นการแทรกค่าศูนย์หลังจุดทศนิยม วิธีนี้ทำได้ง่ายด้วยการแทนที่;a ที่เหลือด้วย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

บันทึกแล้ว 7 ไบต์ด้วย @devRicher!

สิ่งนี้จะกำหนดฟังก์ชั่น 'r' ซึ่งสามารถเรียกได้ด้วย:

r 5.0

NUMBARหรืออื่น ๆ

ลองออนไลน์!

sed , 575 + 1 ( -rแฟล็ก) = 723 718 594 588 576 ไบต์

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

ลองออนไลน์!

หมายเหตุ: ลอยซึ่งค่าสัมบูรณ์น้อยกว่า 1 จะต้องมีการเขียนโดยไม่ต้องนำ 0 เช่นแทน.5 0.5นอกจากนี้จำนวนตำแหน่งทศนิยมจะเท่ากับโดยที่nจำนวนตำแหน่งทศนิยมในจำนวนนั้น (ดังนั้นการ13.0ป้อนข้อมูลจะให้ตำแหน่งทศนิยมมากกว่าการ13ป้อนข้อมูลด้วย)

นี่คือการส่งครั้งแรกของฉันใน PPCG แนวคิดสำหรับการแปลงทศนิยมเป็น unary นั้นมาจากคำตอบที่น่าอัศจรรย์นี้ ขอบคุณ @seshoumara ที่นำพาฉันผ่านความเศร้าโศก!

รหัสนี้ทำการแบ่งส่วนยาวซ้ำ ๆ เพื่อรับผลลัพธ์ การหารใช้เวลาเพียง 150 ไบต์ การแปลงทศนิยมแบบ unary จะใช้จำนวนไบต์มากที่สุดและอีกสองสามไบต์จะสนับสนุนจำนวนลบและอินพุตทศนิยม

คำอธิบาย

คำอธิบายเกี่ยวกับ TIO

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

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

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

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

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

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

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

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

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

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

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

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

การแก้ไข

• s:s/(.)/(.)/g:y/\1/\2/g:g เพื่อบันทึก 1 ไบต์ที่การทดแทนแต่ละครั้ง (รวม 5 ครั้ง)
• บันทึกข้อมูลเป็นตันโดยดูที่ตัวแปลงทศนิยมเป็นแบบดีที่ "เคล็ดลับสำหรับการตีกอล์ฟในรุ่น"
• ฉันเปลี่ยนรอบการทดแทนบางอย่างที่โคจรรอบการดูแลเครื่องหมายลบเพื่อบันทึก 6 ไบต์
• ใช้\nแทนการ;เป็นตัวคั่นจากนั้นฉันสามารถย่อ "แทนที่ทวีคูณ 10" แทนการบันทึก 12 ไบต์ (ขอบคุณ @Riley และ @seshoumara เพื่อแสดงสิ่งนี้ให้ฉัน)

JSFuck , 3320 ไบต์

JSFuck เป็นสไตล์การเขียนโปรแกรมลึกลับและการศึกษาขึ้นอยู่กับส่วนอะตอมของ JavaScript มันใช้เพียงหกตัวละครที่แตกต่างกัน()[]+!ในการเขียนและรันโค้ด

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

ลองออนไลน์!

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

OIL , 1428 1420 bytes

โอ้ดี ฉันคิดว่าฉันอาจจะลองและฉันก็ประสบความสำเร็จในท้ายที่สุด มีข้อเสียเพียงข้อเดียว: มันใช้เวลานานเกือบจะนานเท่าที่จะเขียน

โปรแกรมถูกแบ่งออกเป็นหลายไฟล์ซึ่งมีชื่อไฟล์ 1 ไบต์ทั้งหมด (และนับเป็นหนึ่งไบต์เพิ่มเติมในการคำนวณไบต์ของฉัน) ไฟล์บางไฟล์เป็นส่วนหนึ่งของไฟล์ตัวอย่างของภาษา OIL แต่ไม่มีวิธีการเรียกพวกเขาอย่างสม่ำเสมอ (ไม่มีเส้นทางการค้นหาหรืออะไรอย่างนั้นใน OIL ดังนั้นฉันจึงไม่ถือว่าเป็นไลบรารีมาตรฐาน) แต่ นั่นหมายความว่า (ในขณะที่ทำการโพสต์) ไฟล์บางไฟล์นั้นมีความละเอียดมากกว่าจำเป็น แต่โดยทั่วไปจะมีเพียงไม่กี่ไบต์เท่านั้น

การคำนวณมีความแม่นยำถึง 4 หลักของความแม่นยำ แต่การคำนวณแม้แต่ส่วนกลับอย่างง่าย (เช่นอินพุต3) ใช้เวลานานมาก (มากกว่า 5 นาที) เพื่อให้เสร็จสมบูรณ์ สำหรับวัตถุประสงค์ในการทดสอบฉันยังได้สร้างตัวแปรย่อยที่แม่นยำถึง 2 หลักซึ่งใช้เวลาเพียงไม่กี่วินาทีในการเรียกใช้เพื่อพิสูจน์ว่ามันใช้งานได้

ฉันขอโทษสำหรับคำตอบขนาดใหญ่ฉันหวังว่าฉันจะสามารถใช้แท็กสปอยเลอร์บางประเภท ฉันสามารถใส่จำนวนมากลงใน gist.github.com หรือสิ่งที่คล้ายกันได้หากต้องการ

ไปเลย: main217 ไบต์ (ชื่อไฟล์ไม่นับเป็นไบต์):

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

1
1
4
31
1
35

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

a (ตรวจสอบว่าสตริงที่กำหนดอยู่ในสตริงอื่นที่กำหนด), 74 + 1 = 75 ไบต์:

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

b (รวมสองสตริงที่กำหนด), 20 + 1 = 21 ไบต์:

5
0
5
1
13
0
2
0
4
0

c (ได้รับสัญลักษณ์ให้แยกสตริงที่กำหนดในการเกิดครั้งแรก), 143 + 1 = 144 ไบต์ (อันนี้ยังคงสามารถเล่นได้):

5
0
5
83
12
83
83





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

1



8
13
1
13
56
13
13

2
4
1
11
4
2

d (รับสตริงรับ 4 อักขระแรก), 22 + 1 = 23 ไบต์:

5
0
12
0
20
13
21
4

4

e (การแบ่งระดับสูง (แต่มีอันตรายจากการหารศูนย์)), 138 + 1 = 139 ไบต์:

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

f (เลื่อนตำแหน่งเป็นจุด 4 ไปทางขวา; "หาร" ด้วย 10000), 146 + 1 = 147 ไบต์:

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


4

4

g (ตรวจสอบว่าสตริงเริ่มต้นด้วยอักขระที่กำหนด), 113 + 1 = 114 ไบต์:

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


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

h (คืนค่าทุกอย่างยกเว้นอักขระตัวแรกของสตริงที่กำหนด), 41 + 1 = 42 ไบต์:

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

0
4
0

i (ลบตัวเลขสองตัว), 34 + 1 = 35 ไบต์:

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

j (ส่วนระดับต่ำที่ไม่สามารถใช้งานได้ในทุกกรณี), 134 + 1 = 135 ไบต์:

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

k (การคูณ), 158 + 1 = 159 ไบต์:

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

l (คืนค่าสัมบูรณ์), 58 + 1 = 59 ไบต์:

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

0
6
10

m (นอกจากนี้), 109 + 1 = 110 ไบต์:

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

J, 1 ไบต์

%

%เป็นฟังก์ชั่นที่ให้ส่วนกลับของอินพุต คุณสามารถเรียกใช้เช่นนี้

   % 2
0.5

แท๊กซี่ 467 ไบต์

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

ลองออนไลน์!

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.

เป็นกลุ่ม10 8 ไบต์ / การกดแป้น

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

เนื่องจาก V เข้ากันได้ย้อนหลังคุณอาจลองออนไลน์!

x86_64 ภาษาเครื่อง Linux, 5 ไบต์

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

เพื่อทดสอบสิ่งนี้คุณสามารถคอมไพล์และรันโปรแกรม C ต่อไปนี้

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

ลองออนไลน์!

C, 15 12 ไบต์

#define f 1/

ลองออนไลน์!

16 13 ไบต์หากจำเป็นต้องจัดการอินพุตจำนวนเต็มด้วย:

#define f 1./

ดังนั้นคุณสามารถเรียกมันด้วยแทนf(3)f(3.0)

ลองออนไลน์!

ขอบคุณ @hvd สำหรับการเล่นกอล์ฟ 3 ไบต์!

MATLAB / Octave, 4 ไบต์

@inv

สร้างการจัดการฟังก์ชั่น (ชื่อans) กับinvฟังก์ชั่นในตัว

การสาธิตออนไลน์

05AB1E , 1 ไบต์

z

ลองออนไลน์!

z # pop a  push 1 / a

GNU sed , 377 362 + 1 (แฟล็ก r) = 363 ไบต์

คำเตือน:โปรแกรมจะกินหน่วยความจำของระบบทั้งหมดที่พยายามเรียกใช้และต้องใช้เวลามากกว่าที่จะเสร็จสิ้นกว่าที่คุณเต็มใจจะรอ! ดูคำอธิบายด้านล่างและรุ่นที่รวดเร็ว แต่แม่นยำน้อยกว่า

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

ซึ่งเป็นไปตามคำตอบของ Retina Ender โดย Martin Ender ฉันนับ\tจากบรรทัด 2 เป็นแท็บตัวอักษร (1 ไบต์)

การสนับสนุนหลักของฉันคือวิธีการแปลงจากทศนิยมเป็น unary ธรรมดา (บรรทัดที่ 2) และในทางกลับกัน (บรรทัดที่ 5) ฉันจัดการเพื่อลดขนาดของรหัสที่จำเป็นในการทำเช่นนี้ (โดย ~ 40 ไบต์รวม) เทียบกับวิธีการที่แสดงในก่อนหน้านี้ปลาย ฉันสร้างคำตอบเคล็ดลับแยกต่างหากพร้อมรายละเอียดซึ่งฉันเตรียมไว้ให้พร้อมใช้ตัวอย่าง เนื่องจากไม่อนุญาตให้ 0 เป็นอินพุตจึงมีการบันทึกอีกสองสามไบต์

คำอธิบาย:เพื่อให้เข้าใจอัลกอริทึมการหารดียิ่งขึ้นอ่านคำตอบ Retina ก่อน

โปรแกรมนั้นถูกต้องตามหลักเหตุผลเหตุผลที่ทำให้สิ้นเปลืองทรัพยากรในการคำนวณมากมายนั่นคือขั้นตอนการหารนั้นดำเนินการหลายร้อยหลายพันครั้งมากหรือน้อยขึ้นอยู่กับอินพุตและ regex ที่ใช้ก่อให้เกิดฝันร้ายย้อนรอย รุ่นที่รวดเร็วลดความแม่นยำ (ดังนั้นจำนวนขั้นตอนการหาร) และเปลี่ยน regex เพื่อลดการย้อนรอย

น่าเสียดายที่ sed ไม่มีวิธีการนับโดยตรงว่า backreference นั้นเหมาะกับแพทเทิร์นแบบไหนเช่นใน 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

สำหรับเวอร์ชันที่รวดเร็วและปลอดภัยของโปรแกรม แต่แม่นยำน้อยกว่าคุณสามารถลองออนไลน์ได้

Japtap , 2 ไบต์

ทางออกที่ชัดเจนก็คือ

1/U

ซึ่งก็คือตัวอักษร, 1 / input. อย่างไรก็ตามเราสามารถทำได้ดีกว่า:

pJ

สิ่งนี้เทียบเท่ากับinput ** JและJตั้งค่าเป็น -1 โดยค่าเริ่มต้น

ลองออนไลน์!

สนุกกับข้อเท็จจริง: เช่นเดียวpกับฟังก์ชั่นเพาเวอร์ดังนั้นqฟังก์ชั่นรูท ( p2= **2, q2= **(1/2)); ที่นี้หมายถึงว่าqJจะทำงานได้ดีตั้งแต่และดังนั้นจึง-1 == 1/-1x**(-1) == x**(1/-1)

Javascript ES6, 6 ไบต์

x=>1/x

ลองออนไลน์!

จาวาสคริปต์เริ่มต้นที่การแบ่งจุดลอยตัว

APL, 1 ไบต์

÷

÷คำนวณส่วนกลับเมื่อใช้เป็นฟังก์ชัน monadic ลองออนไลน์!

ใช้ชุดอักขระ Dyalog Classic

Cheddar , 5 ไบต์

1&(/)

ลองออนไลน์!

สิ่งนี้ใช้&ซึ่งเชื่อมโยงอาร์กิวเมนต์กับฟังก์ชัน ในกรณีนี้1ถูกผูกไว้กับทางด้านซ้ายมือของ/ซึ่งจะช่วยให้เราสำหรับการโต้แย้ง1/x xสิ่งนี้สั้นกว่าแบบบัญญัติx->1/xเท่ากับ 1 ไบต์

หรืออีกทางเลือกหนึ่งในเวอร์ชันที่ใหม่กว่า:

(1:/)

Java 8, 6 ไบต์

x->1/x

เกือบจะเป็นเช่นเดียวกับคำตอบ JavaScript

MATL , 3 ไบต์

l_^

ลองใช้ที่MATL Online

คำอธิบาย

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

Python ขนาด 12 ไบต์

lambda x:1/x

หนึ่งไบต์สำหรับ 13 ไบต์:

(-1).__rpow__

หนึ่งไบต์สำหรับ 14 ไบต์:

1 .__truediv__

Mathematica, 4 ไบต์

1/#&

ให้เหตุผลที่แน่นอนแก่คุณหากคุณให้เหตุผลที่แน่นอนและให้ผลลัพธ์ที่เป็นทศนิยมหากคุณให้ผลลัพธ์ที่เป็นทศนิยม

ZX Spectrum BASIC ขนาด 13 ไบต์

1 INPUT A: PRINT SGN PI/A

หมายเหตุ:

• แต่ละบรรทัดมีราคา 2 ไบต์สำหรับหมายเลขบรรทัด 2 ไบต์สำหรับความยาวของบรรทัดและ 1 ไบต์สำหรับบรรทัดใหม่
• ตัวอักษรตัวเลขจะถูกแปลงเป็นเลขฐานสองในเวลาแจงต้นทุนเพิ่ม 6 ไบต์จึงใช้แทนตัวอักษรSGN PI1
• คำหลักใช้เวลา 1 ไบต์

รุ่น ZX81 ขนาด 17 ไบต์:

1 INPUT A
2 PRINT SGN PI/A

Haskell , 4 ไบต์

(1/)

ลองออนไลน์!

R, 8 ไบต์

1/scan()

ตรงไปตรงมาสวย เอาท์พุทผกผันของอินพุตโดยตรง

วิธีแก้ปัญหาอื่นที่ยาวกว่า 1 ไบต์อาจเป็น: scan()^-1หรือแม้แต่scan()**-1สำหรับไบต์เพิ่มเติม ทั้งสอง^และ**สัญลักษณ์อำนาจ

TI-Basic (TI-84 Plus CE), 6 5 2 ไบต์

Ans⁻¹

-1 ขอบคุณไบต์Timtech

-3 ไบต์ด้วยAnsต้องขอบคุณГригорийПерельман

Ansและ⁻¹เป็นโทเค็นไบต์เดียว

TI-Basic ส่งคืนค่าสุดท้ายที่ประเมิน ( Ans⁻¹) โดยปริยาย

เยลลี่ 1 ไบต์

İ

ลองออนไลน์!

C, 30 ไบต์

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