चुनौती

(फ़्लोटिंग-पॉइंट / दशमलव) संख्या को देखते हुए, अपने पारस्परिक, यानी 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 अंकों से ऊपर हों।

यहाँ रूबी में एक नमूना समारोह है:

def reciprocal(i)
    return 1.0 / i
end

नियम

आउटपुट के सभी स्वीकृत रूपों की अनुमति है
मानक खामियों पर रोक लगाई
यह कोड-गोल्फ है , बाइट्स जीत में सबसे छोटा जवाब है, लेकिन इसका चयन नहीं किया जाएगा।

स्पष्टीकरण

आपको इनपुट कभी नहीं मिलेगा 0।

bounties

यह चुनौती स्पष्ट रूप से अधिकांश भाषाओं में तुच्छ है, लेकिन यह अधिक गूढ़ और असामान्य भाषाओं में एक मजेदार चुनौती पेश कर सकती है, इसलिए कुछ उपयोगकर्ता असामान्य रूप से कठिन भाषाओं में ऐसा करने के लिए अंक देने के लिए तैयार हैं।

@DJMcMayhem कम से कम मस्तिष्क-फ्लैक उत्तर के लिए +150 अंक पुरस्कार देगा , क्योंकि फ्लोटिंग-पॉइंट संख्याओं के लिए मस्तिष्क-फ्लैक कुख्यात है
@ L3viathan एक अवार्ड होगा 150 अंक कम से कम करने के लिए इनाम तेल जवाब। OIL का कोई मूल फ़्लोटिंग पॉइंट प्रकार नहीं है, और न ही इसमें विभाजन है।
@ रिले कम से कम जवाब देने के लिए इनाम +100 अंक पुरस्कार देगा ।
@EriktheOutgolfer एक अवार्ड होगा 100 अंक कम से कम Sesos जवाब देने के लिए इनाम। सेसोस जैसे ब्रेनफक डेरिवेटिव्स में डिवीजन बहुत मुश्किल है, अकेले फ्लोटिंग-पॉइंट डिवीजन दें।
~~मैं ( @ मेन्डेलेव ) सबसे कम रेटिना उत्तर के लिए +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>

Expand snippet

code-golf number arithmetic

— dkudriavtsev
स्रोत

23

कृपया तुच्छ उत्तर देना बंद

— क्रिति लिथोस

14

@KritiiLithos लोग फिट होते हुए देख सकते हैं। इस चुनौती की सरलता को देखते हुए, अधिकांश , यदि सभी उत्तर कुछ पसंद नहीं हैं 1/x।

— NoOneIsHere

9

यह उद्देश्य सटीकता और सटीकता पर बहुत स्पष्ट विवरण के बिना निर्दिष्ट नहीं है।

— पीटर टेलर

6

सटीकता के बारे में क्या? संभवत: आप सटीकता के 4 sf भी चाहते हैं, लेकिन फिर गोलाई का मुद्दा है । फ़्लोटिंग पॉइंट प्रश्न सही और बहुत लायक सैंडबॉक्सिंग के लिए कठिन हैं ।

— पीटर टेलर

10

-1, यह एक खराब चुनौती है क्योंकि एक बिलिन का उपयोग करना ही इसका एकमात्र तरीका है और आपको पता है कि आपने "विनिर्देशन" को पूरा किया है। यदि आपके पास एक मानक फ़्लोटिंग पॉइंट कार्यान्वयन है, तो आप इसका उपयोग कर सकते हैं और अपने आप को बता सकते हैं कि यह फ़्लोटिंग फ़्लोटिंग पॉइंट है, यह ठीक होना चाहिए। यदि आपको इसे स्वयं लागू करना है, तो कोई विनिर्देश नहीं है, इसलिए आप इसे समझ नहीं सकते।

— feersum

58

ब्रेन-फ्लैक , 772 536 530 482 480 + 1 = 481 बाइट्स

चूंकि ब्रेन-फ्लैक फ्लोटिंग पॉइंट नंबरों का समर्थन नहीं करता है -c, इसलिए मुझे स्ट्रिंग्स के साथ ऑर्डर इनपुट और आउटपुट में ध्वज का उपयोग करना पड़ा , इसलिए +1।

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

इसे ऑनलाइन आज़माएं!

व्याख्या

पहली बात जो हमें ध्यान रखने की जरूरत है, वह है नकारात्मक मामला। चूंकि एक ऋणात्मक संख्या का पारस्परिक हमेशा ऋणात्मक होता है इसलिए हम अंत तक केवल नकारात्मक चिन्ह को पकड़ सकते हैं। हम स्टैक के शीर्ष की एक प्रतिलिपि बनाने और -उसमें से 45 (ASCII मूल्य ) को घटाकर शुरू करते हैं। यदि यह एक है तो हम ढेर के शीर्ष पर एक शून्य डालते हैं, यदि हम कुछ नहीं करते हैं। फिर हम कार्यक्रम के अंत में नीचे रखी जाने वाली स्टैक के शीर्ष को उठाते हैं। यदि इस के साथ शुरू किया गया इनपुट -अभी भी है, -लेकिन अगर हम अंत में उस शून्य को नहीं उठाते हैं जो हमने रखा है।

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

अब जो कि प्रत्येक अंक के ASCII वास्तविकताओं को वास्तविक मूल्यों (0-9) में बदलने के लिए आवश्यक है। हम .कम्प्यूटेशन को आसान बनाने के लिए दशमलव बिंदु को हटाने जा रहे हैं । चूँकि हमें यह जानना चाहिए कि दशमलव बिंदु की शुरुआत कहाँ से हुई जब हम इसे फिर से शुरू करते हैं, बाद में हम इस बात पर नज़र रखने के लिए एक नंबर को स्टोर .करते हैं कि ऑफ़स्टैक पर कितने अंक थे ।

यहां बताया गया है कि कोड कैसे होता है:

हम .स्टैक पर प्रत्येक तत्व से 46 (एएससीआईआई मूल्य ) घटाकर शुरू करते हैं (एक साथ उन सभी को ऑफस्टैक पर ले जाते हुए)। इससे प्रत्येक अंक को दो से अधिक होना चाहिए, लेकिन .बिल्कुल शून्य बना देगा ।

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

अब जब तक हम शून्य पर नहीं चले जाते, तब तक हम सब कुछ छोड़ देते हैं: (जब हम जाते हैं, तो प्रत्येक अंक में से दो घटाते हैं):

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

हम स्टैक ऊंचाई को रिकॉर्ड करते हैं

([]<

बाएं स्टैक पर और सब कुछ ले जाएं (एक बार फिर हर अंक से अंतिम दो को घटाते हुए जैसे ही हम उन्हें स्थानांतरित करते हैं)

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

और स्टैक की ऊँचाई को हमने नीचे दर्ज किया

>)

अब हम अंकों को एक आधार 10 संख्या में जोड़ना चाहते हैं। हम गणना में उपयोग के लिए उस संख्या के रूप में दो अंकों के साथ 10 की शक्ति बनाना चाहते हैं।

हम 10 की शक्ति बनाने के लिए स्टैक के शीर्ष पर 1 सेट करके शुरू करते हैं और स्टैक की ऊंचाई माइनस एक को लूपिंग के उपयोग के लिए स्टैक पर धकेलते हैं।

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

अब हम स्टैक ऊंचाई माइनस 1 बार लूप करते हैं,

{
 ({}[()]<

हर बार हम शीर्ष तत्व को 100 से गुणा करते हैं और उसके नीचे अगले तत्व को 10 से गुणा करते हैं और नीचे दी गई संख्या में जोड़ते हैं।

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

हम अपना पाश समाप्त करते हैं

 >)
}{}

अब हम अंततः सेट अप के साथ कर रहे हैं और वास्तविक गणना शुरू कर सकते हैं।

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

वह यह था...

विकी पर पाए गए 0 के पूर्णांक विभाजन एल्गोरिथ्म का उपयोग करते हुए इनपुट के संशोधित संस्करण द्वारा हम 10 की शक्ति को विभाजित करते हैं । यह इनपुट द्वारा 1 के विभाजन को अनुकरण करता है जिस तरह से ब्रेन-फ्लैक जानता है कि कैसे।

अन्त में हमें अपने उत्पादन को उपयुक्त ASCII में प्रारूपित करना होगा।

अब जब हमने पाया है कि हमें इसे neबाहर निकालने की आवश्यकता है e। इसका पहला चरण इसे अंकों की सूची में परिवर्तित करना है। यह कोड 0 's divmod एल्गोरिथ्म का संशोधित संस्करण है ।

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

अब हम संख्या लेते हैं और दशमलव बिंदु को वापस जोड़ते हैं जहां यह है। कोड के इस हिस्से के बारे में सोचने से अभी तक सिरदर्द वापस आता है, इसलिए मैं इसे पाठक के लिए एक अभ्यास के रूप में छोड़ दूंगा कि यह कैसे और क्यों काम करता है।

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

यदि नकारात्मक संकेत नहीं है, तो नकारात्मक साइन डाउन या अशक्त चरित्र डालें।

>)

— गेहूं का जादूगर
स्रोत

18

+1, मैं प्यार करता हूँ इस व्याख्या का कितना हैI don't know what this does or why I need it, but I promise it's important.

— DJMcMayhem

यह इनपुट के लिए काम नहीं करता है 1.0या10

— Poke

3

क्या कोई और इस कोड को पढ़ सकता है? क्या ब्रेन-फ्लैक का मतलब केवल लिखना है?

— एरिक डुमिनील

1

@EricDuminil ब्रेन-फ्लैक एक गूढ़ भाषा है इसलिए इसे एक नज़र में पढ़ना बहुत कठिन है। जो लोग ब्रेन-फ्लैक से अच्छी तरह वाकिफ हैं, वे इसे कुछ हद तक धाराप्रवाह पढ़ सकते हैं। लेकिन अविश्वसनीय रूप से जटिल और ब्रेन-फ्लैक में यह कार्य वास्तव में पठनीयता को ध्यान में रखकर नहीं बनाया गया है।

— गेहूं जादूगर

@ThisGuy इसमें -cध्वज को ASCII के साथ और बाहर चलाया जाना आवश्यक है। चूंकि ब्रेन-फ्लैक फ्लोटिंग नंबरों का समर्थन नहीं करता है, इसलिए मुझे आईओ को एक स्ट्रिंग के रूप में लेने की आवश्यकता है।

— गेहूं जादूगर

47

पायथन 2 , 10 बाइट्स

1..__div__

इसे ऑनलाइन आज़माएं!

— डेनिस
स्रोत

5

डॉट। डॉट। डिव। +1 :)

— केयर्ड सिक्काहेरिंगहिंग

37

रेटिना , 99 91 बाइट्स

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

इसे ऑनलाइन आज़माएं!

वाहू, उप -100! यह आश्चर्यजनक रूप से कुशल है, यह देखते हुए कि यह एक बिंदु पर 10 ⁷ से अधिक वर्णों के साथ एक स्ट्रिंग बनाता है (और फिर मैच करता है) । मुझे यकीन है कि यह अभी तक इष्टतम नहीं है, लेकिन मैं इस समय स्कोर से काफी खुश हूं।

1 से कम पूर्ण मूल्य वाले परिणाम प्रमुख शून्य, जैसे .123या के बिना मुद्रित किए जाएंगे -.456।

व्याख्या

मूल विचार पूर्णांक विभाजन का उपयोग करना है (क्योंकि यह रेगेक्स और यूरी अंकगणित के साथ काफी आसान है)। यह सुनिश्चित करने के लिए कि हमें पर्याप्त संख्या में महत्वपूर्ण अंक मिले, हम इनपुट को 10 ⁷ में विभाजित करते हैं । इस तरह, 9999 तक के किसी भी इनपुट का परिणाम 4 अंकों की संख्या में होता है। प्रभावी रूप से, इसका मतलब है कि हम परिणाम को 10 ^{7 से} गुणा कर रहे हैं, इसलिए हमें उस बिंदु पर नज़र रखने की आवश्यकता है जब बाद में दशमलव बिंदु को पुन: स्थापित करें।

1`\.|$
8$*;

हम दशमलव बिंदु या स्ट्रिंग के अंत की जगह लेते हैं यदि 8 अर्धविराम के साथ कोई दशमलव बिंदु नहीं है। उनमें से पहला अनिवार्य रूप से दशमलव बिंदु ही है (लेकिन मैं अर्धविराम का उपयोग कर रहा हूं क्योंकि उन्हें बचने की आवश्यकता नहीं है), अन्य 7 संकेत देते हैं कि मूल्य 10 ⁷ से गुणा किया गया है (यह मामला अभी तक नहीं है, लेकिन हम जानते हैं कि हम बाद में ऐसा करेंगे)।

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

हम पहले इनपुट को पूर्णांक में बदलते हैं। जब तक दशमलव बिंदु के बाद भी अंक होते हैं, तब तक हम एक अंक को आगे बढ़ाते हैं और एक अर्धविराम को निकालते हैं। ऐसा इसलिए है क्योंकि दशमलव बिंदु दाएं घूमने से इनपुट 10 गुणा हो जाता है , और इसलिए परिणाम को 10 से विभाजित करता है । इनपुट प्रतिबंधों के कारण, हम जानते हैं कि यह अधिकतम चार बार होगा, इसलिए हमेशा पर्याप्त अर्धविराम हटाए जाने चाहिए।

\d+
$*1,10000000$*

अब चूंकि इनपुट एक पूर्णांक है, हम इसे एकरी में परिवर्तित करते हैं और 10 ⁷ 1 एस (अलग से ,) जोड़ते हैं ।

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

हम पूर्णांक को 10 ⁷ में विभाजित करते हैं, यह गिनकर कि वह कितने फिट बैठता है ( $#2)। यह मानक यूनियरी पूर्णांक विभाजन है a,b-> b/a। अब हमें बस दशमलव बिंदु की स्थिति को ठीक करने की आवश्यकता है।

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

यह मूल रूप से दूसरे चरण का विलोम है। यदि हमारे पास अभी भी एक से अधिक अर्धविराम हैं, तो इसका मतलब है कि हमें अभी भी परिणाम को 10 से विभाजित करने की आवश्यकता है । हम अर्धविराम को एक स्थिति को बाईं ओर ले जाकर करते हैं और एक अर्धविराम को छोड़ते हैं जब तक कि हम या तो संख्या के बाएं छोर तक नहीं पहुंच जाते हैं, या हम केवल एक अर्धविराम (जो दशमलव बिंदु ही है) के साथ छोड़ दिए जाते हैं।

1`;
.

अब पहले (और संभवतः केवल) को ;वापस चालू करने का एक अच्छा समय है .।

;
0

यदि अभी भी अर्धविराम शेष हैं, तो हम संख्या के बाएँ छोर पर पहुँच गए हैं, इसलिए 10 से भाग देने पर फिर से दशमलव बिंदु के पीछे शून्य डाला जाएगा। यह आसानी से प्रत्येक के स्थान पर शेष के ;साथ किया जाता है 0, क्योंकि वे दशमलव बिंदु के तुरंत बाद वैसे भी हैं।

— मार्टिन एंडर
स्रोत

एक बहुत ही छोटा एल्गोरिथ्म, +1। मुझे यकीन है कि सेड अनुवाद सबसे छोटा होगा। आप की जगह ले सकता \B;साथ ^;1 बाइट को बचाने के लिए?

— शेषमारा

@seshoumara नकारात्मक इनपुटों के कारण नहीं, जहां एक -सामने है ;।

— मार्टिन एंडर

31

हाँ , 5 बाइट्स

|0~-e

इसे ऑनलाइन आज़माएं! यह स्टैक के शीर्ष से इनपुट लेता है और स्टैक के शीर्ष पर आउटपुट छोड़ देता है। TIO लिंक कमांड लाइन तर्कों से इनपुट लेता है, जो केवल पूर्णांक इनपुट लेने में सक्षम है।

व्याख्या

हाँ, केवल कुछ ही ऑपरेटर हैं। इस उत्तर में इस्तेमाल किए गए हैं ln (x) (द्वारा दर्शाया गया है |), 0 () (स्थिर, शून्य फ़ंक्शन पर लौटना 0), - (घटाव), और exp (x) (द्वारा दर्शाया गया e)। ~स्टैक पर शीर्ष दो सदस्यों को स्विच करता है।

|0~-e     top of the stack: n    stack: [n]
|         pop n, push ln(n)      stack: [ln(n)]
 0        push 0                 stack: [ln(n), 0]
  ~       swap                   stack: [0, ln(n)]
   -      subtract               stack: [-ln(n)]
    e     exp                    stack: [exp(-ln(n))]

यह पहचान का उपयोग करता है

जिसका तात्पर्य है

— कोनोर ओ ब्रायन
स्रोत

3

मुझे अपनी सामग्री में सुधार करना अच्छा लगता है, इसलिए यदि आप अपने डाउनवोट को समझाते हैं, तो यह वास्तव में मदद करेगा और मैं इसकी सराहना करूंगा :)

— कॉनर ओ'ब्रायन

20

LOLCODE , 63 , 56 बाइट्स

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

7 बाइट्स @devRicher की बदौलत बच गए!

यह एक फ़ंक्शन 'r' को परिभाषित करता है, जिसे इसके साथ बुलाया जा सकता है:

r 5.0

या कोई अन्य NUMBAR।

इसे ऑनलाइन आज़माएं!

— DJMcMayhem
स्रोत

मुझे लगता है कि आप ITZ A NUMBARअसाइनमेंट में उपयोग कर सकते हैं I?

— cjjbgames

1

HOW DUZ I r YR n VISIBLE QUOSHUNT OF 1 AN n IF U SAY SO(नई-पंक्तियों को जोड़ने) में कुछ बाइट्स कम है और साथ कहा जा सकता है r d, जहां dकिसी भी है NUMBAR।

— devRicher

आप दुभाषिया नियम IZके DUZकारण उपयोग कर सकते हैं

— OldBunny2800

17

sed , 575 + 1 ( `-r`ध्वज) = 723 718 594 588 576 बाइट्स

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

इसे ऑनलाइन आज़माएं!

नोट: तैरता है जिसके लिए निरपेक्ष मान 1 से कम है, को बिना किसी अग्रणी 0 के बिना .5लिखना होगा 0.5। दशमलव स्थानों की संख्या भी बराबर है , जहाँ nसंख्या में दशमलव स्थानों की संख्या है (इसलिए 13.0इनपुट के रूप में इनपुट के रूप में देने से अधिक दशमलव स्थान दिए जाएंगे 13)

पीपीसीजी पर यह मेरा पहला सेड सबमिशन है। दशमलव-से-एकात्मक रूपांतरण के लिए विचार इस अद्भुत उत्तर से लिए गए थे । मुझे sed के माध्यम से मार्गदर्शन करने के लिए @seshoumara को धन्यवाद!

यह कोड परिणाम प्राप्त करने के लिए बार-बार लंबा विभाजन करता है। विभाजन केवल ~ 150 बाइट्स लेता है। अनार्य-दशमलव रूपांतरण सबसे अधिक बाइट्स लेते हैं, और कुछ अन्य बाइट्स नकारात्मक संख्या और फ्लोटिंग-पॉइंट इनपुट का समर्थन करने के लिए जाते हैं

व्याख्या

TIO पर स्पष्टीकरण

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

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

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

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

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

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

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

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

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

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

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

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

संपादित करता

s:s/(.)/(.)/g:y/\1/\2/g:g प्रत्येक प्रतिस्थापन पर 1 बाइट को बचाने के लिए (कुल में 5)
"सीड में गोल्फिंग के लिए टिप्स" पर एक अच्छा दशमलव-से-एकात्मक कनवर्टर देखकर बाइट्स का एक टन बचाया।
मैं 6 बाइट्स को बचाने के लिए माइनस साइन की देखभाल करने के लिए कुछ प्रतिस्थापन के आसपास बदल गया।
विभाजक \nके ;रूप में उपयोग किया जाता है, तब मैं 12 बाइट्स को बचाने के लिए "10 से गुणा" प्रतिस्थापन को छोटा करने में सक्षम था (मुझे दिखाने के लिए @Riley और @seshoumara को धन्यवाद)

— क्रिकटी लिथोस
स्रोत

तुमने कर दिखाया! +1

— शीशमारा

16

JSFuck , 3320 बाइट्स

JSFuck जावास्क्रिप्ट के परमाणु भागों पर आधारित एक गूढ़ और शैक्षिक प्रोग्रामिंग शैली है। यह ()[]+!कोड लिखने और निष्पादित करने के लिए केवल छह अलग-अलग वर्णों का उपयोग करता है ।

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

इसे ऑनलाइन आज़माएं!

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

स्निपेट का विस्तार करें

— powelles
स्रोत

1

यह भाषा-उपखंड हाथ से गोल्फ के लिए कठिन है लेकिन स्वचालित रूप से आसान है (साधारण जावास्क्रिप्ट से रूपांतरण के रूप में)।

— wizzwizz4

यह सच है, लेकिन स्रोत की वर्ण गणना सीधे आउटपुट लंबाई से संबंधित नहीं है।

— पॉवेल्स

4

मैं यह बताने की कोशिश कर रहा था कि अगर आपके पास कोई स्रोत है, तो गोल्फ रूपांतरण को स्वचालित करना आसान है, जैसे हाथ से गोल्फ संस्करण।

— wizzwizz4 20

4

@ wizzwizz4 यहां तक कि जब यह स्वचालित है, तो यह पता लगाना भी मुश्किल है कि कौन सा "कोर" जावास्क्रिप्ट कोड वास्तव में सबसे छोटा प्रोग्राम बनाता है। इस विशेष मामले में, की return 1/thisतुलना में लगभग 76 बाइट्स लंबा होगा return+1/this।

— ETHproductions

[].fill.constructor('alert(1/prompt())')2929 बाइट्स पेस्ट ।ubuntu.com()

— p

16

OIL , 1428 1420 बाइट्स

ओह अच्छा। मैंने सोचा कि मैं भी इसे आज़मा सकता हूँ, और मैं अंत में सफल हुआ। बस एक नकारात्मक पहलू है: इसे लिखने में जितना समय लगता है, उसे लगभग उतना ही समय लगता है।

कार्यक्रम को कई फाइलों में विभाजित किया गया है, जिसमें सभी 1-बाइट-फाइलनाम हैं (और मेरी अतिरिक्त गणना में एक अतिरिक्त बाइट के लिए गणना करें)। कुछ फाइलें ओआईएल भाषा की उदाहरण फाइलों का हिस्सा हैं, लेकिन उन्हें लगातार कॉल करने का कोई वास्तविक तरीका नहीं है (ओआईएल में अभी तक ऐसा कोई खोज पथ या ऐसा कुछ भी नहीं है, इसलिए मैं उन्हें एक मानक पुस्तकालय नहीं मानता), लेकिन इसका मतलब यह भी है कि (पोस्टिंग के समय) कुछ फाइलें नेक्सन की तुलना में अधिक क्रियाशील होती हैं, लेकिन आमतौर पर केवल कुछ बाइट्स द्वारा।

गणना सटीकता के 4 अंकों के लिए सटीक हैं, लेकिन एक सरल पारस्परिक (जैसे इनपुट) की गणना भी कर सकते हैं 3 ) को पूरा करने में वास्तव में लंबा समय (5 मिनट से अधिक) लगता है। परीक्षण के प्रयोजनों के लिए, मैंने एक मामूली संस्करण भी बनाया है जो 2 अंकों के लिए सटीक है, जिसे चलाने में केवल कुछ सेकंड लगते हैं, ताकि यह साबित हो सके कि यह काम करता है।

मुझे भारी जवाब के लिए खेद है, काश मैं किसी तरह के स्पॉइलर टैग का उपयोग कर सकता। अगर मैं चाहूं तो इसे gist.github.com या कुछ इसी तरह से रख सकता हूं।

ये रहा: main 217 बाइट्स (फ़ाइल का नाम बाइट्स के लिए नहीं गिना जाता है):

a (जाँच करता है कि क्या एक दी गई स्ट्रिंग किसी अन्य स्ट्रिंग में है), 74 + 1 = 75 बाइट्स:

b (दो दिए गए तार जुड़ते हैं), 20 + 1 = 21 बाइट्स:

c (एक प्रतीक दिया, अपनी पहली घटना में दिए गए तार को विभाजित करता है), 143 + 1 = 144 बाइट्स (यह एक स्पष्ट रूप से अभी भी गोल्फ है):

d (एक तार दिया, पहले 4 अक्षर मिलते हैं), 22 + 1 = 23 बाइट्स:

e (उच्च-स्तरीय विभाजन (लेकिन शून्य विभाजन खतरे के साथ)), 138 + 1 = 139 बाइट्स:

f (दाईं ओर एक 4 बिंदु रखता है; "10000 से विभाजित"), 146 + 1 = 147 बाइट्स:

g (जाँच करता है कि क्या एक स्ट्रिंग किसी दिए गए वर्ण से शुरू होता है), 113 + 1 = 114 बाइट्स:

h (सब कुछ लौटाता है लेकिन किसी दिए गए तार का पहला वर्ण), 41 + 1 = 42 बाइट्स:

i (दो संख्या घटाना), 34 + 1 = 35 बाइट्स:

j (निम्न-स्तरीय विभाजन जो सभी मामलों में काम नहीं करता है), 134 + 1 = 135 बाइट्स:

k (गुणन), 158 + 1 = 159 बाइट्स:

l (पूर्ण मान लौटाएं), 58 + 1 = 59 बाइट्स:

m (जोड़), 109 + 1 = 110 बाइट्स:

— L3viathan
स्रोत

15

जे, 1 बाइट

%एक ऐसा कार्य है जो इसके इनपुट के पारस्परिक देता है। आप इसे इस तरह चला सकते हैं

   % 2
0.5

— Loovjo
स्रोत

15

टैक्सी , 467 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Ungolfed:

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

— आउटगोल्फर को एरिक करें
स्रोत

क्या आप आसानी से पठनीयता के लिए गैर-गोल्फ संस्करण को जोड़ना चाहेंगे?

— केविन क्रूज़सेन

@ केविनक्रूजसेन श्योर, यह सिर्फ इतना है कि जब मैंने इसका उत्तर दिया तो यह देर रात था।

— को आउटगोल्फर

15

विम, 10 8 बाइट्स / कीस्ट्रोक्स

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

चूंकि V पीछे की ओर संगत है, आप इसे ऑनलाइन आज़मा सकते हैं!

— DJMcMayhem
स्रोत

@ नॉनलाइनयर भर्ती, नहीं, यह नहीं था। पता चला, मैं इसे उखाड़ फेंक रहा था, और समर्थन करना वास्तव में कम बाइट्स है, अधिक नहीं। धन्यवाद!

— DJMcMayhem

यह वाकई दिलचस्प है। मुझे आश्चर्य है कि अगर यह प्रयोग किए बिना एक ही काम करना संभव है =। अन्य मैक्रों पर पूरी तरह भरोसा करते हुए, मेमोरी को होल्ड करने और डेटा को नेविगेट और संशोधित करने के लिए कुंजियाँ। बहुत अधिक जटिल होगा, लेकिन मुझे लगता है कि यह बहुत अच्छा होगा! मुझे लगता है कि fसशर्त परीक्षण के रूप में एक बड़ी भूमिका होगी।

— स्टेफान अलेक्सिएक

यदि इनपुट 6431 है, तो आउटपुट 0.0001554, या अधिक सटीक होना चाहिए, लेकिन 0.

— शेषमारा नहीं

1

@ शीशमौरा मुझे लगता है कि आपको इनपुट की आवश्यकता है 6431.0इसलिए इसे एक फ्लोटिंग पॉइंट नंबर माना जाता है

— पोक

@ प्रोक मैंने इसकी कोशिश की और यह काम करता है, लेकिन आउटपुट वैज्ञानिक संकेतन में है। क्या इसकी अनुमति है?

— शीशमारा

11

x86_64 लिनक्स मशीन भाषा, 5 बाइट्स

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

इसका परीक्षण करने के लिए, आप निम्नलिखित C प्रोग्राम को संकलित और चला सकते हैं

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

इसे ऑनलाइन आज़माएं!

— ceilingcat
स्रोत

1

हम जोड़ना चाह सकते हैं कि rcpssकेवल एक अनुमानित पारस्परिक (लगभग 12 बिट परिशुद्धता) की गणना करता है। +1

— क्रिस्टोफ़

11

सी, 15 12 बाइट्स

#define f 1/

इसे ऑनलाइन आज़माएं!

16 13 बाइट्स, अगर इसे पूर्णांक इनपुट को भी संभालना है:

#define f 1./

तो आप इसके साथ कॉल कर सकते हैं f(3) इसके बजाय हैं f(3.0)।

इसे ऑनलाइन आज़माएं!

3 बाइट गोल्फिंग के लिए @hvd को धन्यवाद!

— Steadybox
स्रोत

2

क्या आप भाषा का नाम "C प्रीप्रोसेसर" में बदल सकते हैं?

— ckjbgames

4

बहुत picky होने के नाते, यह मूल्य की "गणना" नहीं करता है; यह सिर्फ के f(x)साथ बदल देता है 1/x। जब "फ़ंक्शन" निष्पादित किया जाता है, जो रनटाइम जितनी देर हो सकती है या जितनी जल्दी आपके कंपाइलर को लगता है (और सही साबित हो सकता है), तकनीकी रूप से प्रीप्रोसेसर कदम नहीं है।

— CAD97

1

@Steadybox मैं सचमुच चुनौती विवरण में नमूना इनपुट अनुभाग से उद्धृत कर रहा हूं । आपका कोड मिल जाएगा2 और -5इनपुट के रूप में। दोनों 2और -5दशमलव, करने के लिए 9. रेंज 0 में अंकों युक्त हैं

— पाइप

2

फ़ंक्शन-जैसे मैक्रो की आवश्यकता नहीं है: #define f 1./काम भी करता है।

— hvd

2

"बहुत अशिष्ट होने के नाते, यह मूल्य को" गणना "नहीं करता है; यह सिर्फ 1 / x के साथ f (x) को प्रतिस्थापित करता है।" मुझे लगता है कि picky हूँ। यह पूरी तरह से सी प्रीप्रोसेसर का उपयोग करना संभव है, लेकिन किसी को सी प्रीप्रोसेसर में कुछ करने का दावा नहीं करना चाहिए अगर किसी को वास्तव में ऐसा करने के लिए सी या सी ++ की आवश्यकता होती है।

— एच वाल्टर्स

10

MATLAB / ऑक्टेव, 4 बाइट्स

@inv

बनाता है एक समारोह हैंडल (नामित ansकरने के लिए) में निर्मित invसमारोह

ऑनलाइन डेमो

— Suever
स्रोत

8

05AB1E , 1 बाइट

इसे ऑनलाइन आज़माएं!

z # pop a  push 1 / a

— रिले
स्रोत

8

GNU सेड , 377 362 + 1 (आर झंडा) = 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:

यह मार्टिन एंडर के रेटिना जवाब पर आधारित है । मैं गणना करता हूं\t पंक्ति 2 से शाब्दिक टैब (1 बाइट) के रूप में ।

मेरा मुख्य योगदान दशमलव से सादे यूनरी (पंक्ति 2) में रूपांतरण विधि है, और इसके विपरीत (पंक्ति 5)। मैं पिछले टिप में दिखाए गए तरीकों की तुलना में ऐसा करने के लिए आवश्यक कोड के आकार को कम करने के लिए (~ 40 बाइट्स संयुक्त) करने में कामयाब रहा । मैंने एक अलग टिप जवाब बनाया विवरण के साथ , जहां मैं स्निपेट्स का उपयोग करने के लिए तैयार हूं। क्योंकि इनपुट के रूप में 0 की अनुमति नहीं है, कुछ और बाइट्स बचाए गए थे।

स्पष्टीकरण: विभाजन एल्गोरिथ्म को बेहतर ढंग से समझने के लिए, पहले रेटिना जवाब पढ़ें

कार्यक्रम सैद्धांतिक रूप से सही है, इसका कारण यह है कि यह इतने कम्प्यूटेशनल संसाधनों का उपभोग करता है कि विभाजन कदम इनपुट के आधार पर सौ गुना कम या ज्यादा होता है, और इस्तेमाल किया गया रेगेक्स एक बुरे सपने को जन्म देता है। तेजी से संस्करण सटीक (इसलिए विभाजन चरणों की संख्या) को कम कर देता है, और रीग्रैक्स को बैकट्रैकिंग को कम करने के लिए बदल देता है।

दुर्भाग्य से, सीड के पास यह रेट करने का तरीका नहीं है कि रेटिना में एक पैटर्न में कितनी बार एक बैकरेस्ट फिट होता है।

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

प्रोग्राम के तेज़ और सुरक्षित संस्करण के लिए, लेकिन कम सटीक, आप इसे ऑनलाइन आज़मा सकते हैं ।

— seshoumara
स्रोत

7

Japt , 2 बाइट्स

स्पष्ट समाधान होगा

1/U

जो है, काफी का शाब्दिक 1 / input। हालांकि, हम एक बेहतर कर सकते हैं:

pJ

इस के बराबर है input ** J, और Jडिफ़ॉल्ट रूप से करने के लिए -1 सेट है।

इसे ऑनलाइन आज़माएं!

मजेदार तथ्य: जैसा pकि शक्ति फ़ंक्शन है, इसलिए qरूट फ़ंक्शन ( p2= **2, q2= **(1/2)) है; इसका मतलब है कि qJकाम करेगा, क्योंकि -1 == 1/-1, और इसलिए x**(-1) == x**(1/-1)।

— ETHproductions
स्रोत

7

जावास्क्रिप्ट ईएस 6, 6 बाइट्स

x=>1/x

इसे ऑनलाइन आज़माएं!

जावास्क्रिप्ट फ्लोटिंग पॉइंट डिवीजन को डिफॉल्ट करता है।

— fənɛtɪk
स्रोत

मैं आपके बनाए और f () कहे जाने के तरीके से अपरिचित हूं। क्या आप समझा सकते हैं कि थोड़ा, या एक संदर्भ का सुझाव दें?

— TecBrat

@TecBrat यह एक अनाम फ़ंक्शन है। कोशिश में इसे ऑनलाइन लिंक मैं अनाम फ़ंक्शन को असाइन करने के लिए शीर्ष लेख में f = है ताकि इसे कहा जा सके। पाद लेख में मेरे पास

— कंसोल

क्या आपके कुल 8 बाइट्स नहीं होने चाहिए?

— टेकब्रैट

@TecBrat अनाम फ़ंक्शन इसे असाइन किए बिना एक उत्तर है।

— fɛn 14:tɪk

1

@TecBrat फ़ंक्शन x => 1 / x है, जो फ़ंक्शन (x) {रिटर्न 1 / x} के बराबर है। जैसा कि मेटा में इस उत्तर के अनुसार , जो इस आम सहमति का संदर्भ दे रहा है , अनाम कार्य जो अनुरोध किए गए कार्य करेंगे, चुनौती के लिए एक मान्य उत्तर हैं।

— fɛn 14:tɪk

7

एपीएल, 1 बाइट

÷

÷जब मोनैडिक फ़ंक्शन के रूप में उपयोग किया जाता है तो पारस्परिक गणना करता है। इसे ऑनलाइन आज़माएं!

Dyalog क्लासिक वर्ण सेट का उपयोग करता है।

— Uriel
स्रोत

एन्कोडिंग ।

— आदम

6

चेडर , 5 बाइट्स

1&(/)

इसे ऑनलाइन आज़माएं!

यह उपयोग करता है & , जो एक फ़ंक्शन के लिए एक तर्क को बांड करता है। इस मामले में, एक तर्क के लिए , जो हमें देता है , 1बाएं हाथ की ओर से बंधा है । यह 1 बाइट की तुलना में विहित है।/1/xxx->1/x

वैकल्पिक रूप से, नए संस्करणों में:

(1:/)

— कोनोर ओ ब्रायन
स्रोत

नया संस्करण इसे (1:/)उसी बाइट काउंट के लिए बनने देता है

— डाउनगोट

4

जावा 8, 6 बाइट्स

x->1/x

लगभग जावास्क्रिप्ट के उत्तर के समान ।

— Loovjo
स्रोत

क्या यह पूर्णांक विभाजन के साथ किसी समस्या का सामना करेगा?

— kamoroso94

4

MATL , 3 बाइट्स

l_^

इसे MATL ऑनलाइन पर आज़माएं

व्याख्या

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

— Suever
स्रोत

4

अजगर, 12 बाइट्स

lambda x:1/x

13 बाइट्स के लिए एक:

(-1).__rpow__

14 बाइट्स के लिए एक:

1 .__truediv__

— Loovjo
स्रोत

4

गणितज्ञ, 4 बाइट्स

1/#&

यदि आप इसे सटीक तर्क देते हैं, और फ़्लोटिंग-पॉइंट परिणाम के साथ यदि आप इसे फ़्लोटिंग-पॉइंट परिणाम देते हैं, तो आपको एक सटीक तर्कसंगत प्रदान करता है।

— मार्टिन एंडर
स्रोत

4

जेडएक्स स्पेक्ट्रम बेसिक, 13 बाइट्स

1 INPUT A: PRINT SGN PI/A

टिप्पणियाँ:

प्रत्येक पंक्ति में पंक्ति संख्या के लिए 2 बाइट्स, पंक्ति की लंबाई के लिए 2 बाइट्स और न्यूलाइन के लिए 1 बाइट होती है
न्यूमेरिक शाब्दिक को अतिरिक्त 6 बाइट की लागत से बाइनरी में परिवर्तित किया जाता है, इस प्रकार SGN PIशाब्दिक के बजाय इसका उपयोग होता है1 ।
कीवर्ड प्रत्येक 1 बाइट लेते हैं।

17 बाइट्स के लिए ZX81 संस्करण:

1 INPUT A
2 PRINT SGN PI/A

— नील
स्रोत

1

मुझे ZX स्पेक्ट्रम बेसिक स्कोर करने के बारे में अधिक विशिष्ट जानकारी कहां मिल सकती है?

— लुइस मेन्डो

@LuisMendo आप विकिपीडिया पर वर्ण सेट (कीवर्ड सहित) पा सकते हैं, लेकिन इसके अलावा मुझे नहीं पता कि जेडएक्स बेसिक को स्कोर करने पर सहमति है या नहीं। (उदाहरण के लिए, ZX81 संस्करण एक पूर्ण कार्यक्रम होना चाहिए, लेकिन ZX स्पेक्ट्रम एक तत्काल आदेश के रूप में INPUT का समर्थन करता है।)

— नील

ZX81 पर प्रोग्राम लिस्टिंग बाइट्स को बचाने के लिए, आप कर सकते हैं LET A=17और अपने आवेदन को एक पंक्ति में रीफ़्रैक्टर कर सकते हैं 1 PRINT SGN PI/A, आपको हर बार जब आप अपना प्रोग्राम चलाना चाहते हैं, तब अधिक टाइपिंग के साथ A का मान बदलना होगा।

— शॉन बेबर्स

4

हास्केल , 4 बाइट्स

(1/)

इसे ऑनलाइन आज़माएं!

— flawr
स्रोत

4

आर, 8 बाइट्स

1/scan()

बहुत सीधा। सीधे इनपुट के व्युत्क्रम को आउटपुट करता है।

एक और, लेकिन 1 बाइट लंबा समाधान हो सकता है: scan()^-1या scan()**-1एक अतिरिक्त बाइट के लिए भी । दोनों ^और **शक्ति प्रतीक।

— फ़्रेडरिक
स्रोत

4

टीआई-बेसिक (TI-84 Plus CE), 6 5 2 बाइट्स

Ans⁻¹

टिमटेक को -1 धन्यवाद ।

Григорий Перельман केAns लिए धन्यवाद के साथ -3 बाइट्स ।

Ansऔर ⁻¹कर रहे हैं एक-बाइट टोकन ।

टीआई-बेसिक का अनुमानित रूप से मूल्यांकन किया गया अंतिम मूल्य ( Ans⁻¹) है।

— pizzapants184
स्रोत

इनपुट भी स्पष्ट रूप से एक्स और वाई में समन्वयित इनपुट प्राप्त करता है, लेकिन आप इसका उपयोग नहीं कर सकते हैं क्योंकि आपको फ्लोटिंग पॉइंट संख्या स्वीकार करने में सक्षम होने की आवश्यकता है। याद रखें कि X ^ -1 केवल दो बाइट्स हैं ताकि आप वहां एक को बचा सकें।

— टिमटेक

TI-मूल से इनपुट लेने के लिए अनुमति दी है Ansताकि आप के साथ इस जगह ले सकता है,Ans⁻¹

— पावेल

3

जेली , 1 बाइट

İ

इसे ऑनलाइन आज़माएं!

— डेनिस
स्रोत

यह वास्तव में 2 बाइट्स है।

— कोडर -256

UTF-8 में, सुनिश्चित करें। डिफ़ॉल्ट रूप से, जेली हालांकि एक कस्टम SBCS का उपयोग करता है ।

— डेनिस

@ आप जिस विकि से जुड़े हैं, उसे कहते हैं Jelly programs consist of up to 257 different Unicode characters।

— खालिद। के।

@ Khaled.K हाँ, यह भी कहता है कि चरित्र ¶और लाइनफीड चरित्र को परस्पर उपयोग किया जा सकता है , इसलिए जबकि यूनिकोड मोड 257 विभिन्न वर्णों को समझता है, वे 256 टोकन के लिए मैप करते हैं।

— डेनिस

3

सी, 30 बाइट्स

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

— dkudriavtsev
स्रोत

आप 0एक बाइट को बचाने के लिए ट्रेलिंग को हटा सकते हैं । इसके साथ 1.यह अभी भी एक डबल के रूप में संकलित किया जाएगा।

— पैट्रिक रॉबर्ट्स

@PatrickRoberts मेरे परीक्षण में नहीं। 1.अभी भी पूर्णांक की तरह व्यवहार किया जाता है।

— dkudriavtsev

मेरे लिए echo -e "#include <stdio.h>\nfloat f(x){return 1./x;}main(){printf(\"%f\\\\n\",f(5));}" | gcc -o test -xc -आउटपुट का उपयोग कर काम करता ./testहै0.200000

— पैट्रिक रॉबर्ट्स

1

क्या यह फ्लोट के बजाय पूर्णांक के रूप में इनपुट नहीं लेता है? यह फ्लोट्स के लिए काम नहीं करता है, कम से कम gcc पर। float f(float x){return 1/x;}सही ढंग से काम करेगा।

— स्टेडीबॉक्स

2

अनुगामी की कोई आवश्यकता नहीं है .- C प्रकार के कारण खुशी से रूपांतरित (int)1हो जाएगा । (float)1x

— शराबी

एक संख्या का पारस्परिक (1 / x)

चुनौती

विस्तृत विवरण

नियम

स्पष्टीकरण

bounties

लीडरबोर्ड

ब्रेन-फ्लैक , 772 536 530 482 480 + 1 = 481 बाइट्स

व्याख्या

पायथन 2 , 10 बाइट्स

रेटिना , 99 91 बाइट्स

व्याख्या

हाँ , 5 बाइट्स

व्याख्या

LOLCODE , 63 , 56 बाइट्स

sed , 575 + 1 ( -rध्वज) = 723 718 594 588 576 बाइट्स

व्याख्या

संपादित करता

JSFuck , 3320 बाइट्स

इसे ऑनलाइन आज़माएं!

OIL , 1428 1420 बाइट्स

जे, 1 बाइट

टैक्सी , 467 बाइट्स

विम, 10 8 बाइट्स / कीस्ट्रोक्स

x86_64 लिनक्स मशीन भाषा, 5 बाइट्स

सी, 15 12 बाइट्स

MATLAB / ऑक्टेव, 4 बाइट्स

05AB1E , 1 बाइट

GNU सेड , 377 362 + 1 (आर झंडा) = 363 बाइट्स

Japt , 2 बाइट्स

जावास्क्रिप्ट ईएस 6, 6 बाइट्स

एपीएल, 1 बाइट

चेडर , 5 बाइट्स

जावा 8, 6 बाइट्स

MATL , 3 बाइट्स

अजगर, 12 बाइट्स

गणितज्ञ, 4 बाइट्स

जेडएक्स स्पेक्ट्रम बेसिक, 13 बाइट्स

हास्केल , 4 बाइट्स

आर, 8 बाइट्स

टीआई-बेसिक (TI-84 Plus CE), 6 5 2 बाइट्स

जेली , 1 बाइट

सी, 30 बाइट्स

sed , 575 + 1 ( `-r`ध्वज) = 723 718 594 588 576 बाइट्स