OEIS का विकास


56

इस चुनौती में, लक्ष्य एक बार में एक क्रम में इंटेगर सीक्वेंस के ऑन-लाइन विश्वकोश को फिर से बनाना है । हैलो वर्ल्ड के इवोल्यूशन के समान , प्रत्येक उत्तर पिछले उत्तर पर निर्भर करता है।

समय के साथ, यह चुनौती OEIS अनुक्रमों का "परिवार का पेड़" बनाएगी। इस पेड़ पर जोड़ना सरल है।

  1. पिछला उत्तर खोजें, जो पेड़ के किसी भी गहराई N पर हो सकता है।
  2. उस उत्तर के अनुक्रम द्वारा उत्पन्न पहले N संख्याओं का निर्धारण करें।
  3. OEIS में एक क्रम खोजें, जो उन्हीं नंबरों से शुरू होता है और जिनका पहले उपयोग नहीं किया गया है।
  4. इस नए अनुक्रम को बनाने के लिए एक प्रोग्राम लिखें जिसे आपने अभी पाया है।
  5. अपना उत्तर गहराई N + 1 के रूप में प्रस्तुत करें

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

उत्तर आवश्यकताएँ

अनुक्रम को आउटपुट करने के कुछ तरीके हैं।

पहला विकल्प एक प्रोग्राम या फ़ंक्शन लिखना है जो एक नंबर (STDIN या एक तर्क के रूप में) से इनपुट करता है और आपके चुने हुए क्रम में Nth नंबर देता है। आप यह मान सकते हैं कि अनुक्रम N के लिए परिभाषित किया जाएगा और यह कि N और S_N "यथोचित आकार" हैं (इसलिए यह अतिप्रवाह का कारण नहीं होगा)। आप किसी भी उचित अनुक्रमण का उपयोग कर सकते हैं, जैसे 0 अनुक्रमण, 1 अनुक्रमणिका, या अनुक्रम के OEIS पृष्ठ पर "ऑफ़सेट" के तहत सूचीबद्ध अनुक्रमण, जो कोई फर्क नहीं पड़ता। पहले इंडेक्स द्वारा निर्मित शब्द OEIS प्रविष्टि के पहले शब्द से मेल खाना चाहिए।

दूसरा विकल्प एक प्रोग्राम या फ़ंक्शन लिखना है जो एक नंबर पर इनपुट करता है और अनुक्रम के पहले एन शब्दों को वापस करता है। आउटपुट की पहली शर्तें OEIS प्रविष्टि की पहली शर्तें होनी चाहिए (आप पहले कुछ शब्दों को छोड़ नहीं सकते हैं)। गैर-वर्ण वर्णों के मनमाने तार द्वारा लगातार शब्दों को सीमांकित किया जाना चाहिए, इसलिए 0,1 1.2/3,5;8,11काम करता है लेकिन 011235811गिनती नहीं करता है।

तीसरा विकल्प एक प्रोग्राम बनाना है जो संख्याओं की एक सतत स्ट्रीम को आउटपुट करता है। दूसरे विकल्प के समान, लगातार शर्तों के बीच परिसीमन होना चाहिए।

आपके उत्तर में एक शीर्ष लेख होना चाहिए, जिसमें स्टैक स्निपेट पार्सिंग की सहायता की जा सकती है:

 # [language], [number] bytes, depth [number], A[new sequence] from A[old sequence] 

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

यदि आपकी पोस्ट एक गहराई 1 उत्तर है और इस प्रकार कोई पूर्वज नहीं है, तो आपको बस from A[number]अपने हेडर में छोड़ देना चाहिए ।

यहाँ एक उदाहरण का जवाब है:

# Perl, 26 bytes, depth 3, A026305 from A084912

    various code here
    and here

The next answer should match the following terms:

    1, 4, 20

This sequence is .... and does ....

चैनिंग आवश्यकताएँ

इस चुनौती को और अधिक उचित बनाने के लिए, ऐसे प्रतिबंध हैं जिन पर आप अपनी प्रतिक्रिया दे सकते हैं। ये नियम ज्यादातर किसी एक व्यक्ति को पेड़ की एक पूरी शाखा बनाने से रोकते हैं या बहुत सारे "रूट" नोड्स के मालिक हैं।

  • आप अपने आप को चेन नहीं कर सकते।
  • आप सीधे अपने पूर्वजों के दो उत्तरों की श्रृंखला नहीं बना सकते।
  • आप एक से अधिक "स्तर 1" उत्तर नहीं दे सकते।

इसके अलावा, यदि पूर्वज गहराई N का था, तो आपके पद की गहराई N + 1 होनी चाहिए, भले ही आवश्यक शर्तों से अधिक सहमत हों।

स्कोरिंग

एक उपयोगकर्ता के रूप में आपका स्कोर आपके सभी उत्तरों के अंकों का योग है। एकल उत्तर का स्कोर निम्नलिखित सूत्र द्वारा निर्धारित किया जाता है:

Answer Score = Sqrt(Depth) * 1024 / (Length + 256)

इस स्कोरिंग प्रणाली को उपयोगकर्ताओं को बड़ी संख्या में गहरे उत्तर प्रस्तुत करने के लिए प्रोत्साहित करना चाहिए। छोटे उत्तरों को लंबे उत्तरों की तुलना में अधिक पसंद किया जाता है, लेकिन गहराई का बहुत अधिक प्रभाव होता है।

नीचे एक स्टैक स्निपेट है जो लीडरबोर्ड के साथ-साथ सभी उत्तरों के ट्री आरेख उत्पन्न करता है। मैं मार्टिन बोउटनर और d3noob को इस कोड के बहुत सारे स्रोतों के लिए धन्यवाद देना चाहता हूं । पूर्ण परिणाम देखने के लिए आपको "पूर्ण स्क्रीन" पर क्लिक करना चाहिए।

function answersUrl(t){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+t+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(t){answers.push.apply(answers,t.items),t.has_more?getAnswers():process()}})}function shouldHaveHeading(t){var e=!1,r=t.body_markdown.split("\n");try{e|=/^#/.test(t.body_markdown),e|=["-","="].indexOf(r[1][0])>-1,e&=LANGUAGE_REG.test(t.body_markdown)}catch(a){}return e}function shouldHaveScore(t){var e=!1;try{e|=SIZE_REG.test(t.body_markdown.split("\n")[0])}catch(r){}return e}function getAuthorName(t){return t.owner.display_name}function decodeEntities(t){return $("<textarea>").html(t).text()}function process(){answers=answers.filter(shouldHaveScore).filter(shouldHaveHeading),answers.reverse();var t={},e=[],r=1,a=null,n=1,s=[];answers.forEach(function(t){var r=t.body_markdown.split("\n")[0],a=getAuthorName(t),n=r.match(SEQUENCE_REG)[0];n=n.trim();var o="from A000000";PARENT_REG.test(r)&&(o=r.match(PARENT_REG)[0]),o=o.substring(5).trim(),"A000000"==o&&(o="OEIS");var i="";SEQDATA_REG.test(t.body_markdown)&&(i=t.body_markdown.match(SEQDATA_REG)[1]);for(var u=!0,c=0;c<e.length;++c)u=u&&!(e[c]===n);for(var l=!0,c=0;c<e.length;++c)l=!(!l||e[c]===n||e[c]===n+a||e[c]===o+a);e.push(n),e.push(n+a),e.push(o+a),u&&data.push({name:n,parent:o,term:i+" : ",author:decodeEntities(a),URL:t.share_link}),l&&s.push(t)}),answers.sort(function(t,e){var r=t.body_markdown.split("\n")[0].match(SEQUENCE_REG),a=e.body_markdown.split("\n")[0].match(SEQUENCE_REG);return a>r?-1:r>a?1:void 0}),answers.forEach(function(e){var o=e.body_markdown.split("\n")[0],i=(o.match(NUMBER_REG)[0],(o.match(SIZE_REG)||[0])[0]),u=parseInt((o.match(DEPTH_REG)||[0])[0]).toString(),c=o.match(SEQUENCE_REG)[0],l="from A000000";PARENT_REG.test(o)&&(l=o.match(PARENT_REG)[0]),l=l.substring(5);var d=o.match(LANGUAGE_REG)[1];d.indexOf("]")>0&&(d=d.substring(1,d.indexOf("]")));for(var p=getAuthorName(e),E=!1,h=0;h<s.length;++h)E=E||s[h]===e;if(E){var f=jQuery("#answer-template").html();i!=a&&(n=r),a=i,++r;var m=1024*Math.pow(parseInt(u),.5)/(parseInt(i)+256);f=f.replace("{{SEQUENCE}}",c).replace("{{SEQUENCE}}",c).replace("{{NAME}}",p).replace("{{LANGUAGE}}",d).replace("{{SIZE}}",i).replace("{{DEPTH}}",u).replace("{{LINK}}",e.share_link),f=jQuery(f),jQuery("#answers").append(f),t[p]=t[p]||{lang:d,user:p,size:"0",numanswers:"0",link:e.share_link},t[p].size=(parseFloat(t[p].size)+m).toString(),t[p].numanswers=(parseInt(t[p].numanswers)+1).toString()}});var o=[];for(var i in t)t.hasOwnProperty(i)&&o.push(t[i]);o.sort(function(t,e){return parseFloat(t.size)>parseFloat(e.size)?-1:parseFloat(t.size)<parseFloat(e.size)?1:0});for(var u=0;u<o.length;++u){var c=jQuery("#language-template").html(),i=o[u];c=c.replace("{{RANK}}",u+1+".").replace("{{NAME}}",i.user).replace("{{NUMANSWERS}}",i.numanswers).replace("{{SIZE}}",i.size),c=jQuery(c),jQuery("#languages").append(c)}createTree()}function createTree(){function t(){var t=i.nodes(root).reverse(),e=i.links(t);t.forEach(function(t){t.y=180*t.depth});var r=c.selectAll("g.node").data(t,function(t){return t.id||(t.id=++o)}),a=r.enter().append("g").attr("class","node").attr("transform",function(t){return"translate("+t.y+","+t.x+")"});a.append("a").attr("xlink:href",function(t){return t.URL}).append("circle").attr("r",10).style("fill","#fff"),a.append("text").attr("x",function(){return 0}).attr("y",function(){return 20}).attr("dy",".35em").attr("text-anchor",function(){return"middle"}).text(function(t){return t.term+t.name}).style("fill-opacity",1),a.append("text").attr("x",function(){return 0}).attr("y",function(){return 35}).attr("dy",".35em").attr("text-anchor",function(){return"middle"}).text(function(t){return t.author}).style("fill-opacity",1);var n=c.selectAll("path.link").data(e,function(t){return t.target.id});n.enter().insert("path","g").attr("class","link").attr("d",u)}var e=data.reduce(function(t,e){return t[e.name]=e,t},{}),r=[];data.forEach(function(t){var a=e[t.parent];a?(a.children||(a.children=[])).push(t):r.push(t)});var a={top:20,right:120,bottom:20,left:120},n=3203-a.right-a.left,s=4003-a.top-a.bottom,o=0,i=d3.layout.tree().size([s,n]),u=d3.svg.diagonal().projection(function(t){return[t.y,t.x]}),c=d3.select("body").append("svg").attr("width",n+a.right+a.left).attr("height",s+a.top+a.bottom).append("g").attr("transform","translate("+a.left+","+a.top+")");root=r[0],t(root)}var QUESTION_ID=49223,ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",data=[{name:"OEIS",parent:"null",term:"",author:"",URL:"https://oeis.org/"}],answers=[],page=1;getAnswers();var SIZE_REG=/\d+(?=[^\d&]*(?:&lt;(?:s&gt;[^&]*&lt;\/s&gt;|[^&]+&gt;)[^\d&]*)*,)/,DEPTH_REG=/\d+, A/,NUMBER_REG=/\d+/,LANGUAGE_REG=/^#*\s*([^,]+)/,SEQUENCE_REG=/A\d+/,PARENT_REG=/from\s*A\d+/,SEQDATA_REG=/terms:\s*(?:(?:-)?\d+,\s*)*((?:-)?\d+)/;
body{text-align: left !important}#answer-list{padding: 10px; width: 550px; float: left;}#language-list{padding: 10px; width: 290px; float: left;}table thead{font-weight: bold;}table td{padding: 5px;}.node circle{fill: #fff; stroke: steelblue; stroke-width: 3px;}.node text{font: 12px sans-serif;}.link{fill: none; stroke: #ccc; stroke-width: 2px;}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><script src="http://d3js.org/d3.v3.min.js"></script><link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"><div id="answer-list"> <h2>Sequence List</h2> <table class="answer-list"> <thead> <tr> <td>Sequence</td><td>Author</td><td>Language</td><td>Size</td><td>Depth</td></tr></thead> <tbody id="answers"></tbody> </table></div><div id="language-list"> <h2>Leaderboard</h2> <table class="language-list"> <thead> <tr> <td>Rank</td><td>User</td><td>Answers</td><td>Score</td></tr></thead> <tbody id="languages"></tbody> </table></div><table style="display: none"> <tbody id="answer-template"> <tr> <td><a href="https://oeis.org/{{SEQUENCE}}">{{SEQUENCE}}</a></td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td>{{DEPTH}}</td><td><a href="{{LINK}}">Link</a> </td></tr></tbody></table><table style="display: none"> <tbody id="language-template"> <tr> <td>{{RANK}}</td><td>{{NAME}}</td><td>{{NUMANSWERS}}</td><td>{{SIZE}}</td></tr></tbody></table>


5
तुम्हें पता है, मुझे लगता है कि यह सिर्फ सबसे अच्छे codegolf.sx सवाल हो सकता है मैंने कभी पूछा है देखा है। यह सिर्फ शांत नहीं है, लेकिन वास्तव में एक संग्रह के रूप में उपयोगी है।
टोड लेहमैन

3
OEIS ऑनलाइन होने के कारण, खोज शब्द के रूप में एक अनुक्रम की N शब्द लेता है, और इसमें कई अनुक्रमों के लिए गणित या मेपल कोड होता है, यह एक मेटा-एंट्री लिखना संभव होगा, जिसने उस कोड के लिए सर्वश्रेष्ठ स्कोरिंग प्रविष्टि की खोज की हो OEIS में, जो यहां दी गई किसी भी प्रविष्टि का वंशज है और इसे पोस्ट किया है।
abligh

2
क्या मैं ग्राफ़ पर अंकन के कुछ तरीके सुझा सकता हूं स्निपेट उत्पन्न करता है कि एक नोड टर्मिनल है, यानी OEIS पर अधिक गहराई के अप्रयुक्त अनुक्रम उपलब्ध नहीं हैं?
क्लाउडीउ

1
मुझे लगता है कि इस चुनौती को जारी रखने का एकमात्र तरीका कुछ ऐसा प्रदान करना होगा जहां आप अपना उपयोगकर्ता नाम देते हैं, और यह ओईएस समस्याओं को सूचीबद्ध करता है जो आप कर सकते थे, उच्चतम गहराई से सबसे कम तक। अन्यथा पोस्ट को अगला अनुक्रम खोजने में बहुत लंबा समय लगता है।
क्लाउडीयू

1
एसवीजी थोड़ा संकीर्ण है।
कैलकुलेटर

जवाबों:


21

पेरेंटेटिक, 150 बाइट्स, गहराई 4, ए 1000290 से ए 2000292

((()()())(()()()())((()())((()(()())))((()(())())((()()(()))(()(()()))((()(()))(()(()()))((())()))((()(()))(()(()()))((())()())))((())()()()()()()))))

अगला उत्तर निम्नलिखित शब्दों से मेल खाना चाहिए:

0, 1, 4, 10

यह टेट्राहेड्रल संख्याओं का अनुक्रम है, त्रिकोणीय संख्याओं का 3 डी सामान्यीकरण। इसके लिए सूत्र है

T(n) = n*(n+1)*(n+2)/6

पेरेंटेटिक एक लिस्प जैसी भाषा है जो हर चीज को परिभाषित करने के लिए कोष्ठक का उपयोग करती है। ऊपर एक फ़ंक्शन है ()()()जो nआउटपुट और आउटपुट में लेता है T(n)। जैसे कॉल करें:

((()()()())((())()()()()()()()))

एनोटेट

(
  define
  (() ()())

  f [][][]
  (() ()()())

  (
    lambda
    (() ())

    (
      n [[][]]
      (() (()()))
    )

    (
      div
      (() (())())

      (
        *
        (() ()(()))

        n
        (() (()()))

        (
          +
          (() (()))

          n
          (() (()()))

          1
          ((()) ())
        )

        (
          +
          (() (()))

          n
          (() (()()))

          2
          ((()) ()())
        )
      )

      6
      ((()) ()()()()()())
    )
  )
)


Test call:

(
  f
  (() ()()())

  6
  ((()) ()()()()()())
)

19
दुनिया में यह भाषा क्या है? यह लिस्प के एक औसत संस्करण की तरह है।
एलेक्स ए।

10
@AlexA। यह एक लिस्प नहीं है! यह एक पूर्ण भाषण प्रभाव है!
सीजे डेनिस

18

पैनकेक स्टैक, 118 बाइट्स, गहराई 1, A000012

Put this kindercarnavalsoptochtvoorbereidingswerkzaamheden pancake on top!
Show me a pancake!
Eat all of the pancakes!

अगला उत्तर निम्नलिखित शब्दों से मेल खाना चाहिए:

1

यह सबसे छोटे भाजक को प्रिंट करता है nएसोलंग विकी पेज पर पायथन दुभाषिया के साथ परीक्षण किया गया । दुभाषिया ~कार्यक्रम के अंत को दर्शाने के बाद लाइन पर उम्मीद करता है , जिसके बाद एसटीडीआईएन इनपुट आता है (जो वैसे भी अनदेखा किया जाएगा)।

प्रासंगिक निर्देश:

Put this <blah> pancake on top!                # Push length of <blah> 
Show me a pancake!                             # Output top of stack as char
Eat all of the pancakes!                       # Terminate the program

पिछला उत्तर

Put this  pancake on top!
[]
Put this kindercarnavalsoptochtvoorbereidingswerkzaamheden pancake on top!
Show me a pancake!
Put this delectable pancake on top!
Show me a pancake!
If the pancake is tasty, go over to "".

यह एक अनंत लूप में प्रिंट करता है। अतिरिक्त निर्देश:

[<blah>]                                       # Define the label <blah>
If the pancake is tasty, go over to "<blah>".  # If top of stack nonzero, go to label

अन्य निर्देश भी हैं, लेकिन यहां तक ​​कि पैनकेक स्टैक सामान्य रूप से उपयोग करने के लिए बहुत ही बोझिल है, संख्यात्मक आउटपुट की कमी और स्टैक के केवल शीर्ष दो तत्वों तक पहुंच के लिए धन्यवाद।

दुर्भाग्य से, पायथन इंटरप्रेटर में लेबल के विषय में बग को रोकने के लिए इस कार्यक्रम की पहली पंक्ति आवश्यक लगती है।


17

पायथन, 31 बाइट्स, गहराई 4, A0145 से A010060

lambda n:sum(map(ord,bin(n)))%2

अगला उत्तर निम्नलिखित शब्दों से मेल खाना चाहिए:

0, 1, 1, 0

यह मेरा एक पसंदीदा है, और यह थु-मोर्स अनुक्रम है । इसकी कम से कम दो परिभाषाएँ हैं:

  • n(ऊपर प्रयुक्त) के द्विआधारी विस्तार में लोगों की समानता , और
  • अनुक्रम 0 से शुरू करके प्राप्त किया जाता है, फिर बार-बार अनुक्रम के बिटवाइज़ पूरक को जोड़ते हुए (यानी 0 -> 01 -> 0110 -> 01101001 -> ...)

इस क्रम के बारे में कई बेहतरीन चीजों में से एक है अगर हम एक कछुआ पकड़ें और करें:

import turtle

turtle.speed(0)
n = 12

# Calculate first 2^n of Thue-Morse
tm = map(lambda n:sum(map(ord,bin(n)))%2, range(2**n)) 

# Move to top left
turtle.penup()
turtle.setx(-300)
turtle.sety(300)
turtle.pendown()

# For each num, go forward a unit if 0, or turn left 120 degrees if 1
for m in tm:
    if m == 0:
        turtle.forward(1)

    elif m == 1:
        turtle.left(120)

turtle.hideturtle()
turtle.mainloop()

हमें यह मिलता है:

यहाँ छवि विवरण दर्ज करें

परिचित दिखता है?


15

मारियोलेन्, 265 बाइट्स, गहराई 3, A016957 A006370 से

                           <
         =================="
               (((+)< ))+(<
              ======" ===="
               >-))+!  >-(!
               "====#  "==#
          >-(>[!))   >[!(  !
          "====#=======#===#
;)++++++>[!))++++:
==========#=======

अगला उत्तर निम्नलिखित शब्दों से मेल खाना चाहिए:

4, 10, 16

अनुक्रम केवल अंकगणितीय प्रगति है 6n + 4

मारियोलैंग एक गूढ़ प्रोग्रामिंग भाषा है, जो सुपर मारियो पर आधारित है। गणना एक ब्रेनफैक -जैसे तरीके से की जाती है - कोशिकाओं का एक टेप होता है जिसे आप बढ़ा / घटा सकते हैं।

प्रासंगिक BF- जैसी कमांड यहां हैं:

+      Increment current memory cell
-      Decrement current memory cell
(      Move memory pointer left
)      Move memory pointer right
;      Numeric input
:      Numeric output
[      Skip next instruction is current cell is zero

तो मारियो कहाँ है? खैर मारियो आपका निर्देश सूचक है, और वह बाईं ओर (जहां ;है) शुरू होता है। मारियो =जब तक वह जमीन पर है , तब तक निर्देशों को निष्पादित करता रहता है , और जब वह गिरता है तो कार्यक्रम समाप्त हो जाता है।

इसके लिए प्रासंगिक निर्देश हैं:

=      Ground for Mario to stand on
<      Make Mario move leftward
>      Make Mario move rightward
!      Make Mario stop moving
#      Elevator start
"      Elevator end

सब सब में, कार्यक्रम यह करता है:

Put input (n) in cell 0
Increment cell 1 to 6
While cell 1 is not zero...
    Decrement cell 1
    Move n from cell 0 to cells 2, 3
    Move n from cell 2 to cell 0
Increment cell 3 by 4
Output as num

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


12

Brainfuck, 2 बाइट्स, गहराई 2, A0030 A001477 से

,.

A000030 गैर-नकारात्मक पूर्णांकों के प्रारंभिक अंकों का अनुक्रम है, इसलिए यह केवल पहले अंक चरित्र को पढ़ता है और इसे वापस लिखता है। अगला क्रम शर्तों के साथ शुरू होना चाहिए:

0, 1

12
यह अब तक का सबसे छोटा उपयोगी ब्रेनफक कार्यक्रम हो सकता है।
एलेक्स ए।

9

पीइट, 16 बाइट्स, गहराई 3, A000035 A000030 से

यहाँ छवि विवरण दर्ज करें

अगला उत्तर निम्नलिखित शब्दों से मेल खाना चाहिए:

0, 1, 0

यह पीट है, इसलिए "बाइट्स" वास्तव में कोडेल हैं। यहाँ यह एक बड़े कोडेल आकार में है:

यहाँ छवि विवरण दर्ज करें

कार्यक्रम बस में पढ़ता है nऔर nmodulo 2 आउटपुट ।


9

मारबेलस, 7 बाइट्स, गहराई 3, A012760 A000027 से

इस साइट को मारबुलस उत्तर देखने के बाद कुछ समय हो गया है !

}0
<D++

अगला उत्तर शर्तों के साथ शुरू होना चाहिए:

1, 2, 3

आप es1024 के स्टैक स्निपेट दुभाषिया में कोड आज़मा सकते हैं । पुट में कमांड-लाइन तर्क के माध्यम से दिया गया है, और आपको "दशमलव संख्या के रूप में प्रदर्शन आउटपुट" चुनना चाहिए। अन्यथा, परिणाम बाइट मान के रूप में आउटपुट होगा, जो तकनीकी रूप से भी ठीक है

अनुक्रम "संयुक्त राज्य अमेरिका में एलेवेटर बटन" का अनुक्रम है, अर्थात 13. को छोड़कर सभी सकारात्मक पूर्णांक। ध्यान दें कि मारबेलस 8-बिट संख्या तक सीमित है, लेकिन जहां तक ​​मुझे पता है कि 256 मंजिलों के पास कहीं भी कोई इमारत नहीं है। :)

मारबेलस एक 2 डी भाषा है जहां ग्रिड के नीचे गिरते हुए पत्थर (बाइट मान) के रूप में कोड के माध्यम से डेटा बहता है। }0पहले कमांड-लाइन तर्क के साथ प्रतिस्थापित हो जाता है। <Dएक स्विच है जो 13 से कम मार्बल्स ( Dबेस 36 में है) के लिए एक खाली सेल के रूप में कार्य करता है , जिससे कि इनपुट 1 से 12 अप्रभावित होकर गुजरता है। यदि संगमरमर 13 से अधिक या इसके बराबर है, तो संगमरमर को दाईं ओर विक्षेपित किया जाता है और ++जिसके माध्यम से मूल्य में वृद्धि होती है। 1. या तो मामले में संगमरमर तब बोर्ड से गिर जाता है, जो इसके मूल्य को प्रिंट करता है।


8

रेल , 56 बाइट्स, गहराई 4, A00378 से A033547

$'main'
 0/aima19-@
@------e<
  /()(!!)-@
@-()m5a()m3do#

अगला उत्तर निम्नलिखित शब्दों से मेल खाना चाहिए:

0, 2, 6, 14

कार्यक्रम nएसटीडीआईएन और आउटपुट से पढ़ता है n*(n^2+5)/3, जो कि 1940 के दशक से परमाणु शेल मॉडल के लिए जादुई संख्या का अनुमान था ।

रेल एक 2 डी भाषा है जो ट्रेन की पटरियों के आसपास स्थित है। उपर्युक्त कोड @परावर्तकों का उपयोग करके बनाया गया है जो नई दिशाओं को कम करने के लिए, ट्रेन की दिशा को उलट देता है। यहाँ यह अपुष्ट है:

$ 'main'
 \
  0
   \ /--aima19--\
    |           |
    \--e-------<
                \
                 \-(!n!)-(n)-(n)-m-5-a-(n)-m-3-d-o-#

ध्यान दें कि रेल शीर्ष बाईं ओर कैसे शुरू होती है और खड़ी नीचे-दाएं चलना शुरू करती है।

स्टैक हेरफेर कमांड का उपयोग किया जाता है:

0-9       Push 0-9 respectively
e         Push t (true) if EOF, else f (false)
i         Input char
o         Output
a         Add
m         Multiply
(!n!)     Store top of stack as variable n
(n)       Push variable n to stack
#         Halt program

जंक्शनों पर ट्रेन की शाखाएँ >v<^, दाएं मुड़ने पर , यदि स्टैक के शीर्ष सत्य है, अन्यथा झूठे होने पर छोड़ दिया जाता है।


8

स्टाररी, 22 बाइट्स, गहराई 4, A008642 A000142 से

      + + +*,  +   **.

अगला उत्तर निम्नलिखित शब्दों से मेल खाना चाहिए:

1, 1, 2, 2

अनुक्रम में दो बार दोहराए गए सकारात्मक पूर्णांक होते हैं। कार्यक्रम STDIN से एक संख्या में पढ़ता है और गणना करता है 1 + floor(n/2)

Starry रूबी में लागू की गई एक गूढ़ भाषा है जो रूबी में गूढ़ भाषा बनाने वाली ... पर एक किताब का हिस्सा थी। प्रत्येक निर्देश एक से पहले रिक्त स्थान की संख्या से निर्धारित होता है +*.,`'। अन्य सभी पात्रों को नजरअंदाज किया जाता है, इसलिए उपरोक्त बराबर है

      +
 + +*,
  +   *
*.

जो बहुत अधिक भूखे लग रहा है! (अनुगामी स्थानों पर ध्यान दें)

प्रासंगिक आदेश हैं:

Spaces     Final      Instruction
------     -----      -----------
n >= 5     +          Push n-5 to stack
1          +          Duplicate top of stack
0 mod 5    *          Add
0 mod 2    ,          Input num
2          +          Swap top 2
3 mod 5    *          Divide
0 mod 2    .          Output num

पिछला उत्तर, 53 बाइट्स

      +` +.               + + .  + +.  + .      +* +'

इसके बजाय अनुक्रम विज्ञापन इनफ़िनिटम उत्पन्न करता है। कुछ अतिरिक्त आदेश हैं:

Spaces     Final      Instruction
------     -----      -----------
1 mod 2    .          Output as ASCII char
n          `          Mark a label n
n          '          Pop and if nonzero, jump back to label n

7

गणितज्ञ, 20 बाइट्स, गहराई 6, A104631 से A037965

Binomial[2#-2,#-1]#&

यह एक अनाम फ़ंक्शन है जो केवल अनुक्रम की परिभाषा की गणना करता है। अगला क्रम शर्तों के साथ शुरू होना चाहिए:

0, 1, 4, 18, 80, 350

लीफ नोड (कोई अन्य अनुक्रम नहीं)
कैलकुलेटरफ़्लीन

7

CJam, 34 बाइट्स, गहराई 14, A238263 से A157271

qi_,_m*{~2@#3@#*}$<::+1f&_:+\1-,e>

अगला उत्तर शर्तों के साथ शुरू होना चाहिए:

1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7

लेकिन कोई भी ऐसा नहीं बचा है जो पहले से नहीं किया गया हो।

आज्ञा देना D(n)पहले n3-चिकनी संख्याओं का सेट करें : अर्थात, पूर्णांक जिनके प्रमुख कारक एक सबसेट हैं {2, 3}। आज्ञा S(n)देना सबसे बड़ा उपसमुच्चय है D(n)जिसमें स्वयं प्रपत्र का कोई उपसमुच्चय शामिल नहीं है {x, 2x}या {y, 3y}। फिर A157271 का आकार है S(n)


1
आह अच्छा है, मैं इसे देख रहा था, लेकिन यह बिल्कुल स्पष्ट नहीं था कि उनके स्पष्टीकरण का क्या मतलब है। तुम्हारा बहुत साफ है।
क्लाउडीउ

6

गोल्फस्क्रिप्ट, 3 बाइट्स, गहराई 3, A000290 A000030 से

~2?

अगला उत्तर निम्नलिखित शब्दों से मेल खाना चाहिए:

0, 1, 4

यह क्रम बस वर्ग संख्याएँ हैं, इसलिए कार्यक्रम एक संख्या लेता है और इसके वर्ग को आउटपुट करता है।


6

प्रस्तावना , 16 बाइट्स, गहराई 1, ए 1000211

3(v!  v)
4 ^+2-^

मैंने सोचा था कि मैं कम स्पष्ट प्रारंभिक संख्या के साथ एक पेड़ शुरू करूंगा। इस परिभाषा के साथ एक सामान्यीकृत फाइबोनैचि अनुक्रम है a(0) = 4, a(1) = 3, a(n) = a(n-1) + a(n-2) - 2। नतीजतन, यह ज्यादातर मेरे प्रस्तावना फाइबोनैचि समाधान का एक सरल अनुकूलन है । उपरोक्त एक कार्यक्रम है जो संख्याओं की एक अनंत धारा प्रिंट करता है। यह पायथन इंटरप्रेटर मानता है जो व्यक्तिगत पात्रों के बजाय संख्याओं को आउटपुट करता है।

अगला उत्तर शर्तों के साथ शुरू होना चाहिए:

4

6

क्लिप, 0 बाइट्स, गहराई 2, A000027 A000012 से

एक संख्या को देखते हुए n, nthक्रम में संख्या को प्रिंट करता है1, 2, 3, 4...

अगला उत्तर शर्तों के साथ शुरू होना चाहिए:

1, 2

5

J, 4 बाइट्स, गहराई 4, A001563 A000290 से

(*!)

अगला उत्तर निम्नलिखित शब्दों से मेल खाना चाहिए:

0, 1, 4, 18

यह क्रम अपने गुट द्वारा गुणा संख्या है। जे (fg)xमें f(x,g(x))यहाँ है x*factorial(x)


आप 2 बाइट्स के लिए कोष्ठक बाहर छोड़ सकता:*!
ɐɔıʇǝɥʇuʎs

@ toı aruʎs मैं किसी के साथ बहस करने नहीं जाऊंगा जो कहता है कि मैं उन्हें स्कोर के ~ 1/128 भाग के लिए नहीं छोड़ सकता। :)
बेतरतीब

5

गणितज्ञ, 48 बाइट्स, गहराई 5, A104631 A001563 से

SeriesCoefficient[((x^5-1)/(x-1))^#,{x,0,2#+1}]&

अगला उत्तर निम्नलिखित शब्दों से मेल खाना चाहिए:

0, 1, 4, 18, 80

लंबे समारोह के नामों को छोड़कर, इस चुनौती पर गणितज्ञ बिल्कुल चट्टानें। यह एक x^(2n+1)के विस्तार में बस गुणांक है

(1 + x + x^2 + x^3 + x^4)^n

5

तत्व , 13 बाइट्स, गहराई 3, A000045 A000030 से

1_'0[3:~2@+]`

A000045 फाइबोनैचि संख्याओं का प्रतिनिधित्व करता है। अनुक्रम में प्रत्येक पद पिछले दो शब्दों का योग है। यह उल्लेखनीय है क्योंकि लगातार शब्दों के बीच का अनुपात सुनहरे अनुपात तक पहुंचता है, जिसे फी के रूप में भी जाना जाता है। कुछ दिलचस्प बात यह है कि OEIS की एंट्री 0, 1आम के बजाय शुरू होती है 1, 1। अगला उत्तर शर्तों से मेल खाना चाहिए:

0, 1, 1

5

प्रस्तावना , 1 बाइट, गहराई 2, A004 A001477 से

!

अगला उत्तर निम्नलिखित शब्दों से मेल खाना चाहिए:

0, 0

यह कार्यक्रम nइनपुट के रूप में लेता है , इसे पूरी तरह से अनदेखा करता है, और शून्य स्थिर आउटपुट देता है। इसे NUMERIC_OUTPUT = Trueपायथन दुभाषिया की आवश्यकता होती है।

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


4

पर्ल, 10 बाइट्स, गहराई 1, ए 001477

चीजों को बंद करने के लिए, यहां एक सरल अनुक्रम है।

print$_=<>

यह गैर-ऋणात्मक संख्याओं का प्रतिनिधित्व करता है 0, 1, 2, 3, आदि। अगला क्रम शर्तों के साथ शुरू होना चाहिए:

0

4

गोल्फस्क्रिप्ट, 9 बाइट्स, गहराई 4, A002275 से A051682

~.9*7-*2/

अगला उत्तर निम्नलिखित शब्दों से मेल खाना चाहिए:

0, 1, 11, 30

यह केवल OEIS पृष्ठ पर पाए जाने वाले hendecagonal संख्याओं के सूत्र का उपयोग करता है।


4

डेडफिश, 4 बाइट्स, गहराई 2, A005577 A001477 से

isdo

इस अनुक्रम को इस रूप में परिभाषित किया गया है (n+1)^2-1, जो वास्तव में इस कार्यक्रम को करता है। चूंकि डेडफिश के पास कोई इनपुट नहीं है, इसलिए यह माना जाता है कि संचायक वांछित इनपुट नंबर पर है। अगला उत्तर शर्तों के साथ शुरू होना चाहिए:

0, 3

4

एपीएल, 13 बाइट्स, गहराई 4, ए 000142 से ए 000108

{(⍵!2×⍵)÷⍵+1}

कैटलन नंबर! इनके लिए इंडेक्सिंग शून्य से शुरू होती है। अगला उत्तर शर्तों के साथ शुरू होना चाहिए:

1, 1, 2, 5

4

गोल्फस्क्रिप्ट, 31 बाइट्स, गहराई 11, A242681 से A029030

~][11.(2]{:C;{{.C-.)0>}do;}%}/,

अगला उत्तर निम्नलिखित शब्दों से मेल खाना चाहिए:

1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 7

लेकिन यह करने में सक्षम नहीं होगा: यह पेड़ का एक पत्ता है। यह अनुक्रम मान 1, 2, 10 और 11 के सिक्कों के साथ परिवर्तन देने के तरीकों की संख्या है।


3
A258000: 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 7, 42 - कुछ अजीब अनुक्रम वे codegolf.stackexchange.com पर मांगे
schnaader

4

रेटिना , 1 बाइट, गहराई 3, A055642 A001333 से

.

अगला उत्तर शर्तों के साथ शुरू होना चाहिए:

1, 1, 1

मुझे लगता है कि यह पहली बार है जब मैंने रेटिना को रिप्लेसमेंट मोड के अलावा किसी और चीज़ में इस्तेमाल किया। यदि बिना किसी विकल्प के केवल एक फ़ाइल दी जाती है, तो रेटिना मैच मोड को मान लेता है, जो डिफ़ॉल्ट रूप से इनपुट में दिए गए रेगेक्स के मैचों की संख्या को गिनता है। यह रेगेक्स है .और किसी भी पात्र से मेल खाता है। इसलिए, यह प्रोग्राम इनपुट के अंकों की संख्या को लौटाता है जो A055642 है।


3

क्लिप , 24 बाइट्स, गहराई 4, A002275 से A049666

/F*5nx5[Fx?<x3O]+F(xF((x

अगला उत्तर निम्नलिखित शब्दों से मेल खाना चाहिए:

0, 1, 11, 122

अनुक्रम बस है Fibonacci(5n)/5। स्पष्टीकरण के लिए उदाहरण पृष्ठ देखें ।


3

क्लिप, 37 बाइट, गहराई 5, A227327 A000292 से

[t/m++#t4*2#t3*8#t2?%t2+*2t9]*8t]48]n

रोटेशन और प्रतिबिंबों को छोड़कर, साइड एन के त्रिकोणीय ग्रिड पर दो अंक चुनने के संभावित तरीके। उदाहरण दिया गया है: n = 3 के लिए, 4 तरीके हैं:

  X        X        X        .
 X .      . .      . .      X X
. . .    X . .    . X .    . . .

अगले क्रम को निम्नलिखित शब्दों से शुरू करना चाहिए:

0, 1, 4, 10, 22

3

APL, 24 बाइट्स, गहराई 6, A182712 से A025581

{¯1-⍵-2!1+⌊.5+.5*⍨2×1+⍵}

अनुक्रम A025581 का अनुक्रम है ... Im ईमानदार होना निश्चित नहीं है। उससे मुझे डर लगता है।

अनुक्रमण 0 से शुरू होता है और फ़ंक्शन केवल अनुक्रम को परिभाषा द्वारा गणना करता है।

अगला क्रम शर्तों के साथ शुरू होना चाहिए:

0, 1, 0, 2, 1, 0

घटते हुए पूर्णांक m से 0 तक घटने के बाद पूर्णांक m + 1 से 0, आदि में मदद मिल सकती है।
कैलक्यूलेटरफ्लेन

3

> <>, 25 बाइट्स, गहराई 2, A001333 A002522 से

301-v >rn;
*2@:<r^!?:-1r+

ये sqrt (2) में निरंतर भिन्न रूपांतरों के अंश हैं। कोड को उपयोगकर्ता को उस अभिसरण के सूचकांक के साथ स्टैक को पूर्वनिर्मित करने की आवश्यकता होती है जिसे लौटाया जाना चाहिए। अनुक्रमण शुरू होता है 1. अगला उत्तर शर्तों के साथ शुरू होना चाहिए:

1, 1

3

J, 44 बाइट्स, गहराई 10, A242681 A026233 से

f=.(,(<:*+)"0/~~.50,25,(,+:,3*])1+i.20)+/@:=]

अगला उत्तर शर्तों के साथ शुरू होना चाहिए:

1, 1, 2, 2, 3, 3, 4, 4, 5, 5

रोजमर्रा की जिंदगी के कुछ करीब: " nएक मानक डार्टबोर्ड पर दो डार्ट्स का उपयोग करके प्राप्त किए जा सकने वाले तरीकों की संख्या "। केवल अनियंत्रित स्कोर-जोड़ी मायने रखती है। ऑफसेट करना OEIS पृष्ठ के रूप में दो है। उपयोग:

f 2 => 1
f 72 => 12

3

आर, 20 बाइट्स, गहराई 11, A244981 से A194964

1+floor(scan()/5^.5)

अगला उत्तर निम्नलिखित शब्दों से मेल खाना चाहिए:

1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 5

अनुक्रम A194964 प्रत्येक n के लिए देता है 1+[n/sqrt(5)]जहां ["मंजिल" का अर्थ है। आर फ़ंक्शन स्टडिन के रूप में इनपुट लेता है।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.