ইয়াহটজি ছোট সোজা সনাক্তকরণ


34

ইয়াহটজি গেমটিতে খেলোয়াড়রা পাঁচটি ছয় পক্ষের ডাইস রোল করে এবং পয়েন্ট স্কোর করার জন্য কয়েকটি হাত তৈরি করার চেষ্টা করে। এই জাতীয় একটি হাত একটি ছোট সোজা : একটানা চারটি সংখ্যা, ক্রম হিসাবে প্রয়োজন হয় না। তিনটি সম্ভাব্য ছোট স্ট্রেইট হয় 1, 2, 3, 4, 2, 3, 4, 5এবং 3, 4, 5, 6

উদাহরণস্বরূপ, [3, 5, 6, 1, 4]ছোট সোজা থাকে [3, 4, 5, 6]

ইনপুট

ইয়াহটজি হাতের প্রতিনিধিত্ব করে পাঁচটি সংখ্যার অন্তর্ভুক্ত পাঁচটি সংখ্যার সমন্বিত তালিকা list

আউটপুট

যদি হাতে একটি ছোট সোজা এবং অন্যথায় মিথ্যা মান থাকে তবে একটি সত্যবাদী মান।

পরীক্ষার মামলা

Truthy:

[[1, 2, 3, 3, 4], [1, 2, 3, 4, 5], [3, 5, 6, 1, 4], [1, 5, 3, 4, 6], [4, 5, 2, 3, 5], [1, 4, 3, 2, 2], [5, 4, 3, 6, 3], [5, 3, 5, 4, 6], [2, 4, 5, 1, 3], [3, 6, 4, 5, 3], [5, 6, 4, 3, 5], [4, 5, 3, 6, 3], [4, 5, 5, 3, 2], [4, 5, 2, 3, 5], [4, 6, 5, 3, 6], [4, 2, 3, 1, 5], [3, 6, 4, 6, 5], [5, 2, 1, 3, 4], [4, 4, 1, 2, 3], [4, 1, 4, 2, 3], [5, 1, 4, 3, 6], [5, 2, 2, 3, 4], [4, 4, 6, 5, 3], [2, 4, 3, 5, 1], [5, 4, 2, 5, 3], [2, 3, 5, 5, 4], [1, 6, 3, 4, 5], [4, 5, 3, 3, 6], [6, 4, 3, 6, 5], [4, 6, 6, 5, 3], [4, 3, 5, 2, 2], [2, 3, 2, 1, 4], [4, 2, 6, 1, 3], [4, 4, 5, 3, 6], [4, 5, 6, 3, 6]]

Falsy:

[[1, 2, 3, 5, 6], [5, 1, 1, 6, 6], [4, 6, 4, 1, 1], [6, 4, 1, 6, 4], [4, 6, 3, 6, 6], [2, 1, 4, 6, 4], [2, 6, 1, 5, 6], [2, 6, 1, 5, 6], [3, 6, 5, 3, 2], [3, 2, 3, 5, 3], [5, 5, 6, 2, 3], [3, 4, 6, 4, 3], [1, 4, 5, 5, 1], [1, 4, 4, 4, 1], [1, 6, 5, 1, 4], [6, 6, 4, 5, 4], [5, 3, 3, 3, 2], [5, 2, 1, 5, 3], [3, 5, 1, 6, 2], [6, 4, 2, 1, 2], [1, 3, 1, 3, 2], [3, 1, 3, 4, 3], [4, 3, 1, 6, 3], [4, 6, 3, 3, 6], [3, 6, 3, 6, 4], [1, 1, 3, 1, 3], [5, 5, 1, 3, 2], [3, 4, 2, 6, 6], [5, 4, 2, 6, 1], [2, 4, 4, 5, 4], [3, 6, 2, 5, 5], [2, 5, 3, 5, 1], [3, 2, 2, 3, 4], [5, 2, 2, 6, 2], [5, 6, 2, 5, 6]]

দ্বারা অনুপ্রাণিত এই

তালিকা

var QUESTION_ID=74997;var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";var COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk";var OVERRIDE_USER=30525;var answers=[],answers_hash,answer_ids,answer_page=1,more_answers=true,comment_page;function answersUrl(index){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+index+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(index,answers){return"http://api.stackexchange.com/2.2/answers/"+answers.join(';')+"/comments?page="+index+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:true,success:function(data){answers.push.apply(answers,data.items);answers_hash=[];answer_ids=[];data.items.forEach(function(a){a.comments=[];var id=+a.share_link.match(/\d+/);answer_ids.push(id);answers_hash[id]=a});if(!data.has_more)more_answers=false;comment_page=1;getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:true,success:function(data){data.items.forEach(function(c){if(c.owner.user_id===OVERRIDE_USER)answers_hash[c.post_id].comments.push(c)});if(data.has_more)getComments();else if(more_answers)getAnswers();else process()}})}getAnswers();var SCORE_REG=/<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;var OVERRIDE_REG=/^Override\s*header:\s*/i;function getAuthorName(a){return a.owner.display_name}function process(){var valid=[];answers.forEach(function(a){var body=a.body;a.comments.forEach(function(c){if(OVERRIDE_REG.test(c.body))body='<h1>'+c.body.replace(OVERRIDE_REG,'')+'</h1>'});var match=body.match(SCORE_REG);if(match)valid.push({user:getAuthorName(a),size:+match[2],language:match[1],link:a.share_link,});else console.log(body)});valid.sort(function(a,b){var aB=a.size,bB=b.size;return aB-bB});var languages={};var place=1;var lastSize=null;var lastPlace=1;valid.forEach(function(a){if(a.size!=lastSize)lastPlace=place;lastSize=a.size;++place;var answer=jQuery("#answer-template").html();answer=answer.replace("{{PLACE}}",lastPlace+".").replace("{{NAME}}",a.user).replace("{{LANGUAGE}}",a.language).replace("{{SIZE}}",a.size).replace("{{LINK}}",a.link);answer=jQuery(answer);jQuery("#answers").append(answer);var lang=a.language;lang=jQuery('<a>'+lang+'</a>').text();languages[lang]=languages[lang]||{lang:a.language,lang_raw:lang.toLowerCase(),user:a.user,size:a.size,link:a.link}});var langs=[];for(var lang in languages)if(languages.hasOwnProperty(lang))langs.push(languages[lang]);langs.sort(function(a,b){if(a.lang_raw>b.lang_raw)return 1;if(a.lang_raw<b.lang_raw)return-1;return 0});for(var i=0;i<langs.length;++i){var language=jQuery("#language-template").html();var lang=langs[i];language=language.replace("{{LANGUAGE}}",lang.lang).replace("{{NAME}}",lang.user).replace("{{SIZE}}",lang.size).replace("{{LINK}}",lang.link);language=jQuery(language);jQuery("#languages").append(language)}}
body{text-align:left!important}#answer-list{padding:10px;width:290px;float:left}#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=83c949450c8b"> <div id="language-list"> <h2>Shortest Solution 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> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table>


সত্যবাদী মানটি কি সামঞ্জস্যপূর্ণ হতে হবে? সত্যবাদী ফলাফলের জন্য আমি কিছু (ধ্রুবক) ইতিবাচক পূর্ণসংখ্যার এবং মিথ্যা ফলাফলের জন্য 0 আউটপুট দিতে পারি?
মার্টিন এন্ডার

@ মার্টিনব্যাটনার এটি সামঞ্জস্যপূর্ণ হওয়ার দরকার নেই।
lirtosiast

9
এটি কাজ করে কিনা তা পরীক্ষা করে দেখুন [1,2,3,3,4]। অনেক উত্তর এর কারণে মারা যায়।
ক্যালকুলেটরফলাইন

আমি কি ধরে নিতে পারি যে অ্যারেটি শূন্য দ্বারা প্যাড করা আছে?
ক্যালকুলেটরফলাইন

5
@ ক্যাটস আরেফ্লুফি "ডাই"
ডাস্টিন রাসেনার

উত্তর:


28

এমএটিএল , 7 12 11 9 8 6 বাইট

2 বাইট অপসারণ করার জন্য @lirtosiast কে অনেক ধন্যবাদ

ud7BXf

সত্যবাদী হ'ল ননজারো মানগুলির একটি অ্যারে। মিথ্যা খালি অ্যারে (আউটপুট প্রদর্শিত হবে না)।

16.2.0 রিলিজ হিসাবে, uডিফল্টরূপে স্থিতিশীল। সুতরাং Sআউটপুটটি বাছাই করতে কোডটির একটি অতিরিক্ত প্রয়োজন : uSd7BXf( 7 বাইট )। লিঙ্কটিতে এই পরিবর্তন রয়েছে।

এটি অনলাইন চেষ্টা করুন!

u     % input array implicitly. Transform into array of unique elements sorted
d     % array of differences between consecutive elements
7B    % push arrray [1 1 1] (number 7 converted to binary)
Xf    % indices of occurrences of the second array within the first

4
6 বাইট ?! এটা অবিশ্বাস্য!
আদনান

3
@ অ্যান্ডএন / ও / \ ও / \ ও /
লুইস মেন্ডো

8
আপনি যদি অন্য ব্যবহারকারীদের মতো বাইট গণনা ইতিহাস রাখেন তবে আমি এটি পছন্দ করব। এটি অগ্রগতি দেখায়।
mbomb007

1
কমপক্ষে 8 থেকে 6 এর অগ্রগতিটি সঠিক ছিল ...
কনর ও'ব্রায়ান

5
@ ডোনমুসলি এফডাব্লুআইডাব্লু আমি আপনার সাথে একমত এবং এমবিম্ব ২০০00 এর সাথে একমত নই। যে সংস্করণগুলি কাজ করছিল না সেগুলি অর্থহীন এবং ইতিহাসে অন্তর্ভুক্ত করা উচিত নয়। আমি সাধারণত কাজের সংস্করণগুলির কেবলমাত্র বাইট গণনা অন্তর্ভুক্ত করি, সুতরাং এটি অবশ্যই কঠোরভাবে হ্রাস করার অনুক্রম।
মার্টিন ইন্ডার

12

পাইথন, 44 বাইট

lambda l:any({i+1,i+2,i+3}<set(l)for i in l)

উন্নতি সহ 9 মাস পরে ফিরে আসুন। iজাগার্বের ধারণাগুলি সেটে কেবলমাত্র মানগুলি শুরু করার পরীক্ষা করার সাথে আমাদের সেটে আছে কিনা তা খতিয়ে দেখার দরকার নেই। আমরা এখন <কঠোর সাবসেটগুলির জন্যও ব্যবহার করতে পারি কারণ iঅবশ্যই এতে অন্তর্ভুক্ত থাকতে হবে।


47 বাইট:

lambda l:any({i,i+1,i+2,i+3}<=set(l)for i in l)

কোনও ডাই রোলগুলি একটি ছোট সোজা সেটটির শুরু কিনা তা পরীক্ষা করে। জগারবকে ধন্যবাদ কেবলমাত্র তালিকার শুরু মানগুলি পরীক্ষা করে 5 বাইট সংরক্ষণ করার ধারণার জন্য।

পাইথন 3.5 এর 45 বাইটের জন্য সংক্ষিপ্ত সেট রূপান্তর রয়েছে

lambda l:any({i,i+1,i+2,i+3}<={*l}for i in l)

এটা করতে একই দৈর্ঘ্য এর {*range(i,i+4)}হিসাবে {i,i+1,i+2,i+3}


10

ভোল্টেজ, 41 বাইট

=|?30
0 _ }:/2
3 1  { "!
({(  &{/
} )
+:"

@ মার্টিনব্যাটনার এর সাথে একটি কোলাব উত্তর। আমি মনে করি আমরা এটি আমার প্রাথমিক প্রত্যাশার চেয়ে অনেক দূরে ফেলেছি।

আউটপুট 1সত্যের জন্য, মিথ্যা জন্য খালি। এটি অনলাইন চেষ্টা করুন!

দ্রুত ব্যাখ্যা

প্রতিটি সংখ্যা nবাইনারি পূর্ণসংখ্যায় রূপান্তর করুন 1 এরপরে n+1শূন্যগুলি, অর্থাৎ 2^(n+1)। বিটওয়্যার বা ফলাফল এবং পরীক্ষা করে 1111(বাইনারি)। এক্সফেনসিটিশনটি ম্যানুয়ালি ল্যাবথ্রে প্রয়োগ করা দরকার।

বিস্তারিত ব্যাখ্যা

সাধারণ প্রাইমার:

  • ল্যাবরেথ একটি স্ট্যাক-ভিত্তিক 2D প্রোগ্রামিং ভাষা। স্মৃতিশক্তি জন্য একটি প্রধান স্ট্যাক এবং একটি সহায়ক স্ট্যাক আছে, এবং একটি খালি স্ট্যাক থেকে পপিং একটি ত্রুটির পরিবর্তে 0 উত্পাদন করে।
  • প্রতিটি সংযোগে, যেখানে নির্দেশিকা পয়েন্টার দুটি বা ততোধিক সম্ভাব্য পাথগুলিতে সরে যেতে পারে, সেখানে স্ট্যাকের শীর্ষে কোথায় যেতে হবে তা নির্ধারণ করার জন্য পরীক্ষা করা হয়। নেতিবাচক বাম, শূন্য এগিয়ে, ধনাত্মক ডান।
  • ল্যাবরেথের অঙ্কগুলি স্ট্যাকের সাথে সম্পর্কিত অঙ্কটি চাপায় না - বরং তারা পপ করে nএবং চাপ দেয় n*10 + <digit>। নতুন নম্বর শুরু করতে _শূন্যকে ঠেলে দেয়।

সেটআপ

ডান দিকের নির্দেশিকা নির্দেশকের মুখোমুখি হয়ে এক্সিকিউশনটি শীর্ষ-বামে শুরু হয়। আমরা কার্যকর করি:

=        Swap tops of main and auxiliary stacks
|        Bitwise OR

কার্যকরভাবে জিরোকে ঠেলে দেওয়া ছাড়াও, এই নির্দেশাবলী স্ট্যাকটি পরিবর্তন করে না।

বাম লুপ: ক্ষতচিহ্ন এবং বিটওয়াইজ OR

ল্যাবরেথের ক্ষয়ক্ষতি নেই, সুতরাং আমাদের এটি ম্যানুয়ালি প্রয়োগ করা দরকার। প্রথমে আমরা একটি পূর্ণসংখ্যার সাথে পড়ি ?এবং এটি ইতিবাচক হওয়ার গ্যারান্টিযুক্ত হওয়ায় আমরা ডানদিকে ঘুরলাম। _11 টি ধাক্কা দেয় এবং আমরা ভিতরের লুপটি প্রবেশ করি।

অভ্যন্তরীণ লুপটি নিম্নলিখিতটি করে:

(       Decrement. For the first iteration this turns 1 into 0 so we move straight ahead
        downwards; for other iterations when we're coming from the left this turns 2^k into
        2^k-1 > 0, making us turn right (also downwards)
)       Increment again
"       No-op
:+      Duplicate and add, i.e. double
}       Move result to aux
(       Decrement input n. Since this is at a junction, we turn right and continue the
        loop if n is still positive, else we exit the loop by going forwards if n is 0
{       Move result from aux to main

যেহেতু এটি একটি করণীয় লুপ, ইনপুট জন্য nএটি গণনা করে 2^(n+1)। আমরা স্ট্যাকের শূন্যযুক্ত ইনপুট দিয়ে শেষ করি এবং এই শূন্যটিকে 3030 এ পরিণত করি then আমরা সেটআপ থেকে একই নির্দেশাবলী পালন করি তবে এবার তারা আসলে কার্যকর।

=       Swap tops of main and aux, moving 30 to aux and 2^(n+1) to main
|       Bitwise OR (for the first input, this is bitwise OR with an implicit zero at
        the bottom of the stack)

এই লুপটি ইনপুটটিতে প্রতিটি সংখ্যার জন্য ইওএফ হওয়া পর্যন্ত অবিরত থাকে, যখন ?0 ফিরে আসে This এটি আমাদেরকে বাঁক পরিবর্তে সামনের দিকে এগিয়ে নিয়ে যায়, যার দিকে ...

ব্রিজ: কিছু অতিরিক্ত সেটআপ

এর 30পরে ?0টি ইওএফ থেকে 30 এ পরিণত হয়, যা সহায়তাকারীর স্ট্যাকের মাধ্যমে এগিয়ে যায় }। তাত্পর্যপূর্ণ বিষয়টি হ'ল প্রতিটি ইনপুট সংখ্যার জন্য আমরা 30 টি সহায়ক স্ট্যাকের দিকে ঠেলে দিয়েছি, তাই এখন সহায়ক স্ট্যাকটিতে 5 + 1 = 630 নম্বরটির অনুলিপি রয়েছে

এদিকে, প্রধান স্ট্যাকটিতে 2^(n+1)প্রতিটি ইনপুটটির জন্য বিটওয়াইড ওআর থাকে n। আসুন একে বিটওয়্যারটিকে OR বলুন b, যেহেতু এটি ডান লুপে সংশোধিত হয়।

ডান লুপ: পরীক্ষার ফলাফল এবং আউটপুট

ডান হাতের লুপে যা ঘটেছিল তা এখানে:

:     Duplicate top of stack. This makes us turn right for the first iteration, since
      b is positive. For later iterations, when we're coming in from the
      right, we usually take the same turn (but see below)
{&    Bitwise AND with a 30 pulled from aux
{/    Integer division by a 30 pulled from aux. This returns 1 or 0 depending on whether
      we have found a small straight.
"     No-op at a junction. Turn right if small straight, else go forward.

[If small straight found]
!     Output the previous 1. This is at a dead end, so we turn around.
"     No-op at junction. Turn right since top of stack is positive.
      (stuff happens - see below)

[If small straight not found]
2     Turn 0 into 2
/     Divide b by said 2
      (continue loop)

এখন, এই প্রোগ্রামটির সাথে সমাপ্তি কিছুটা জটিল। প্রোগ্রামটি বন্ধ করার সম্ভাব্য উপায়গুলি এখানে:

  • ডান লুপটির 3 পুনরাবৃত্তির পরে এবং bএখনও ইতিবাচক: মনে রাখবেন কীভাবে আমরা সহায়ক স্ট্যাকের মধ্যে ছয় 30 টি রেখেছি? যেহেতু আমরা তাদের মধ্যে দুটি পুনরুক্তি ব্যবহার করি, চতুর্থ পুনরাবৃত্তির সময় আমরা সহায়ক স্ট্যাকের নীচ থেকে জিরোগুলি টানতে শুরু করি। এটি যখন আমরা করি তখন শূন্য দ্বারা বিভাজন ঘটায় {/এবং প্রোগ্রামটি সমাপ্ত হয়।

  • একটি ছোট সোজা জন্য একটি 1 আউটপুট দেওয়ার পরে : সুতরাং আমরা মৃত্যুদন্ড কার্যকর করেছি !তারপর নো-অপশন "জংশনে ডানদিকে ঘুরিয়ে । এরপরে আমরা আবার বাম আধে ক্রল করা শুরু করার সাথে সাথে রোলারকোস্টারের জন্য রয়েছি:

2     Pops b, pushes 10*b + 2
/}    Divide bottom zero by b, giving zero, pushing to aux
03    Zero at bottom of stack becomes 3
?     Push 0 due to EOF, main stack [3 0]. Go straight.
|=    Bitwise OR then swap tops of main and aux
03    Zero at bottom of stack becomes 3, stacks [3 | 3]
({(   Dec, shift dec. Stacks [2 2 | ], and we're in the exponentiator again.

ক্ষতিকারকটিতে কয়েকটি ট্রিপের পরে, স্ট্যাকটি দেখতে এমন কিছু দেখাচ্ছে [12 | 30 30]যা ডান লুপে আরও দুটি পুনরাবৃত্তির পরে শূন্য দ্বারা বিভাজনে ত্রুটি ঘটেছে।

  • খ এক পর্যায়ে শূন্য হয়ে যাওয়ার পরে : এখানে মূল কীটি :ডান লুপের একটি জংশনে রয়েছে। যদি ইনপুট ছিল, বলুন, 1 1 1 1 1তারপর, bহবে 4, তারপর 2, তারপর 1, তারপর 0তৃতীয় পুনরাবৃত্তির পর। এটিকে পরিবর্তিত করার পরিবর্তে :, আইপি এখন সরাসরি এগিয়ে চলেছে, এবং পূর্ববর্তী কেসের মতো কিছু ঘটতে শেষ অবসান ঘটায়।

সব মিলিয়ে প্রোগ্রামটি কীভাবে শেষ হয় তা এক গোলমাল, তবে আরে এই কয়েকটা বাইট সংরক্ষণ করার মতো কিছু!


7

গণিত, 39 43 44 31 39 44 বাইট

Differences@Union@#~MatchQ~{___,1,1,1,___} &

15
ওয়েল, আউট 44 অতিক্রম করবেন হয় এখনো 44 ...
Rɪᴋᴇʀ

7

হাস্কেল, 39 34 বাইট

f x=any(\y->all(`elem`x)[y..y+3])x

ব্যবহারের উদাহরণ: f [1,2,3,3,4]-> True

অনুরূপ @ xnor এর উত্তর , অর্থাৎ চেক ছোট স্ট্রেইট কোন ইনপুট তালিকার মধ্যে উল্লিখিত সংখ্যার পারেন। প্রকৃতপক্ষে আমি সমস্ত "ছোট স্ট্রেইটস" (অর্থাত্ 4 টি সংখ্যক) ইনপুট তালিকা থেকে যে কোনও সংখ্যার সাথে শুরু allকরে anyপরীক্ষা করছি, তাদের মধ্যে কয়েকটি অবৈধ এবং তাই সর্বদা পরীক্ষায় ব্যর্থ হয় এবং পরীক্ষাকে বিকৃত করে না , যেমন [5,6,7,8]

সম্পাদনা করুন: @ জগারব 5 টি বাইট সংরক্ষণ করেছেন ধন্যবাদ!



5

জাভাস্ক্রিপ্ট (ES6), 55 53 বাইট

a=>(z=[0,1,2,3]).some(b=>z.every(c=>a.includes(c+b)))

আয় truetruthy এবং falsefalsy জন্য।

কিভাবে এটা কাজ করে

[0, 1, 2, 3] এর কিছু মান শর্ত পূরণ করলে ফিরে আসুন যে [0, 1, 2, 3] এর প্রতিটি মানের জন্য এই দুটি মানের যোগফল ইনপুট অ্যারেতে থাকে।

সুতরাং, [0, 1, 2, 3] (অসম্ভব), [1, 2, 3, 4], [2, 3, 4, 5], বা [3, 4, 5 এ অ্যারের প্রতিটি মান থাকলে ফিরে আসুন , 6]।


5

রুবি, ৩১

প্রথম রুবির উত্তরের মতো স্মার্ট হওয়ার চেষ্টা করার পরিবর্তে এটি কেবল পূর্ণসংখ্যার অ্যারের মধ্য দিয়ে যায় এবং প্রতিটি পূর্ণসংখ্যার জন্য দেখে the যে পূর্ণসংখ্যা দিয়ে শুরু হওয়া ইনপুটটিতে কোনও ছোট সোজা আছে কিনা। সম্ভাব্য মান বা স্বতন্ত্রতা নিয়ে চিন্তা করবেন না।

এটি শার্লকের উত্তরের মতো একই অ্যালগরিদম ব্যবহার করছে বলে মনে হচ্ছে ।

->x{x.any?{|d|[*d..d+3]-x==[]}}

5

রুবি, 58 55 50 47 43 33 বাইট

আমি এখনই দেখলাম যে পৌলের রুবি উত্তর দিয়ে আমাকে ঘুষি মারছে । তবে আমি হতাশ হই না কারণ আমি মনে করি এটি আরও কিছু গল্ফের সাথে একটি উত্তম উত্তর হতে পারে। এক্সনরের পাইথন উত্তরের উপর ভিত্তি করে কিছুটা অংশ ।

সম্পাদনা করুন: টেরিনারি শর্তাধীন কিছু গল্ফিং এবং সংশোধন করছে।

সম্পাদনা: আমি এখন ব্যবহার .any?মত নয় যে চার্লস তাদের রুবি উত্তর নেই কিন্তু সরানোর একমাত্র কারণ আমি একটি সহজ উপায় প্রয়োজন aএবং শুধুমাত্র একটি truthy এবং সঙ্গে একটি falsey ফিরে যাওয়ার !([*i..i+3]-l)[0]পর থেকে .mapএকটি অ্যারের ফিরে আসবে trueএবং false

->l{l.any?{|i|!([*i..i+3]-l)[0]}}

হয় হয় trueবা false

Ungolfed:

def f(l)
  a = p
  l.any? do |i|
    if ( (i..i+3).to_a - l )[0]     # if (i..i+3) in l
      a = false                     # a[0] is equivalent to !a.empty?
    else
      a = true
    end
  end
  puts a
end

গুরুত্বপূর্ণ নোট: যারা ব্যবহার করতে চান তার (a2 - a1).empty?কিনা তা নির্ধারণ করতে সমস্ত উপাদান কোড a2আছে a1, নোট আপনি যে, উদাহরণস্বরূপ, নিশ্চিত করুন করতে চান তাহলে [2,1,2]হয় [1,2,3,3]উপাদানের সংখ্যাধিক্য জন্য, আপনাকে অন্য কোড প্রয়োজন। এখানে এই সমস্যা সম্পর্কিত প্রাসঙ্গিক আলোচনা


আপনি ব্যবহারকারীর পরিবর্তে উত্তরের সাথে লিঙ্ক করতে পারেন?
কনর ও'ব্রায়ান

@ CᴏɴᴏʀO'Bʀɪᴇɴ স্থির।
শার্লক

আমি মনে করি দুর্ঘটনাক্রমে আপনার মতো একই অ্যালগরিদম ব্যবহার করেছি। দুঃখিত! codegolf.stackexchange.com/a/75273 আমি পোস্ট করার আগে যদি আমি এটি পোস্ট করার আগে খেয়াল করি না।
চার্লস

@ নোটহাট চার্লস ওয়েল, আপনার উত্তর আমার চেয়ে ভাল ছিল, তাই আমি আপনাকে একটি উচ্চারণ দিয়েছি।
শার্লক

এছাড়াও, একটি নোট হিসাবে, যেহেতু 0রুবিতে সত্যবাদী, আমি আপনার উত্তরটি অবৈধ বলে মনে করি। pএকটি এক-চরিত্রের মিথ্যা মান।
চার্লস

4

জাপট, 13 12 বাইট

Uá4 d@7o ¬fX

এটি অনলাইন পরীক্ষা! বা সমস্ত পরীক্ষার কেস যাচাই করুন

কিভাবে এটা কাজ করে

       // Implicit: U = input array
Uá4    // Take all permutations of U of length 4.
d@     // Return whether any item X returns truthily to this function:
7o ¬   //  Take the range [0..7) and join. Produces "0123456".
fX     //  Match X in this string.
       //  This returns null if X is not a subset of [0..7), and a (truthy) array otherwise.
       // Implicit output

3
চমৎকার পন্থা !!
লুইস মেন্ডো 21

4

পার্ল, 47 43 42 39 37 29 বাইট

এর জন্য +1 অন্তর্ভুক্ত -p

STDIN এ সিকোয়েন্স সহ চালনা করুন, যেমন

perl -p smallstraight.pl <<< "1 2 3 3 4"

smallstraight.pl:

s//$_|=1x$'.w/reg;$_=/.w{4}/

ব্যাখ্যা

s//          / eg             Each possible postfix string (including the
                              empty string) is assigned to $' in turn
                              So each input digit will be the start of $'
                              at least once
       1x$'.w                 Put a w at position $'.
                              e.g. digit 4 becomes 1111w
   $_|=                       Or into existing $_.
                                w        is binary 0111 0111
                                space    is binary 0010 0000
                                digit<=7 is binary 0011 0xxx
                              So an "or" with "w" is always w again:
                                                   0111 0111
                              And no other way can you get a w since w is the
                              only thing that can set the high bits. So the
                              already existing string in $_ has no effect on
                              the number of w's in the result
              r               The $_ that has been "or"ed several times is
                              exfiltrated out of the substitution. It will
                              have a w in every position that the original
                              string had a digit with an extra w at position
                              0 since the s///g will also have matched the
                              empty string at the end
                              So e.g. "1 2 3 5 6" will become "wwww3ww 6"
                  $_=/.w{4}/  We have a small straight if there were 4
                              consecutive numbers, now 4 consecutive w's. But
                              the w we always get at the start of the string
                              doesn't count. Notice that the string cannot 
                              have a newline since bit "0010 0000" is always
                              set. So "." to skip one character is safe

3

সিজেম, 16 15 12 বাইট

7,4ewl~f&3f>

সত্যবাদী পরীক্ষার কেসগুলির জন্য একটি খালি-খালি স্ট্রিং এবং মিথ্যা বিষয়গুলির জন্য একটি খালি স্ট্রিং সরবরাহ করে।

পরীক্ষা স্যুট.

ব্যাখ্যা

7,      e# Push [0 1 2 3 4 5 6].
4ew     e# Get all length-4 sublists. This gives:
        e#   [[0 1 2 3]
        e#    [1 2 3 4]
        e#    [2 3 4 5]
        e#    [3 4 5 6]]
        e# i.e. all possible small straights (and an impossible one).
l~      e# Read and evaluate input.
f&      e# Set intersection of each small straight with the full list.
        e# If any small straight is contained in the list, all 4 of its
        e# elements will be retained.
3f>     e# Discard the first three elements of each intersection. If a 
        e# small straight was not in the list, this will give an empty 
        e# list. Otherwise, one element will remain.

প্রোগ্রামের শেষে, এই তালিকাটি একটি একক স্ট্রিংয়ে সমতল করা হয় এবং STDOUT এ মুদ্রিত হয়। যদি কোনও ছোট স্ট্রেট পাওয়া যায় তবে তাদের অবশিষ্ট উপাদানগুলি স্ট্রিংয়ে থাকবে। অন্যথায় সমস্ত তালিকা খালি ছিল, এবং সুতরাং স্ট্রিংটিও খালি।


@ mbomb007 "অর্থাত্ সম্ভব সমস্ত ছোট ছোট স্ট্রাইট (এবং একটি অসম্ভব)" " ইনপুটটিতে কখনই শূন্য থাকে না, যাতে ছোট সোজা কখনও পাওয়া যায় না এবং ফলস্বরূপ প্রভাবিত করে না।
মার্টিন ইন্ডার

@ mbomb007 হ্যাঁ, এ থেকে মুক্তি পেতে [0 1 2 3]ব্যয় করতে হবে 2 বাইট।
মার্টিন ইন্ডার

3

05 এ বি 1 ই , 9 8 10 বাইট

সত্যে আউটপুটে একটি অ্যারে থাকে, মিথ্যা হয় যখন কোনও আউটপুট উত্পাদিত হয় না। কোড:

œvy¦¥1QPiy

ব্যাখ্যা পুরানো :

œ          # Compute all permutations
 vy        # Map over each permutation
   ¦       # Head, leaves [1:]
    ¥      # Delta, computes the differences between the elements
     P     # Product, which computes the product of the array
      iy   # If equal to 1, push the array again
           # Implicit, if there is a match, an array will be displayed.

এটি অনলাইন চেষ্টা করুন!

ব্যবহার সিপি-1252 এনকোডিং।


3

জাভাস্ক্রিপ্ট ES6 47 বাইট

q=>/12+3+4|23+4+5|34+5+6/.test(q.sort().join``)

জাভাস্ক্রিপ্ট ES6 52 বাইট

q=>/1,+1,+1/.test(q.sort().map((a,i)=>a-q[i-1]||``))

//sort the array
//map each element to the difference from the last element
//Look for three 'increment by ones' (ignore increment by 0s)


পুরানো উত্তর

জাভাস্ক্রিপ্ট ES6 64 বাইট

বেশ কয়েকটি বাইট সংরক্ষণে সহায়তা করার জন্য ইটিএইচ প্রডাকশনসকে ধন্যবাদ

q=>q.sort().map(o=>(o-s?o-s<2?t++:t=t>3?t:1:0,s=o),t=1,s=-1)|t>3

q=>              //take an input
q.sort()         //sort it
.map(            //for each number
  o=>
    s=           //set current value = 
      !(o-s) ?   //if it's a duplicate
        o :      //just keep the current state (set s to s again)
        (  
         o-s < 2 ?  //if the current values is one more than the next one
           t++ :    //increment the total
           t=t>4?t:1 //otherwise, set the total back to 1, unless we've hit 4 total already
         )&&o  //set the current value to the current token
   ,t=1,s=-1)  //init the total, and the current value (set it to -1 since we won't hit that anyways

|t>3 //return total > 3 (so 1 if we get a run of 4 or 5)

পরীক্ষামূলক

//true and false test cases from OP
tr = [[1, 2, 3, 3, 4], [1, 2, 3, 4, 5], [3, 5, 6, 1, 4], [1, 5, 3, 4, 6], [4, 5, 2, 3, 5], [1, 4, 3, 2, 2], [5, 4, 3, 6, 3], [5, 3, 5, 4, 6], [2, 4, 5, 1, 3], [3, 6, 4, 5, 3], [5, 6, 4, 3, 5], [4, 5, 3, 6, 3], [4, 5, 5, 3, 2], [4, 5, 2, 3, 5], [4, 6, 5, 3, 6], [4, 2, 3, 1, 5], [3, 6, 4, 6, 5], [5, 2, 1, 3, 4], [4, 4, 1, 2, 3], [4, 1, 4, 2, 3], [5, 1, 4, 3, 6], [5, 2, 2, 3, 4], [4, 4, 6, 5, 3], [2, 4, 3, 5, 1], [5, 4, 2, 5, 3], [2, 3, 5, 5, 4], [1, 6, 3, 4, 5], [4, 5, 3, 3, 6], [6, 4, 3, 6, 5], [4, 6, 6, 5, 3], [4, 3, 5, 2, 2], [2, 3, 2, 1, 4], [4, 2, 6, 1, 3], [4, 4, 5, 3, 6], [4, 5, 6, 3, 6]]

fa = [[1, 2, 3, 5, 6], [5, 1, 1, 6, 6], [4, 6, 4, 1, 1], [6, 4, 1, 6, 4], [4, 6, 3, 6, 6], [2, 1, 4, 6, 4], [2, 6, 1, 5, 6], [2, 6, 1, 5, 6], [3, 6, 5, 3, 2], [3, 2, 3, 5, 3], [5, 5, 6, 2, 3], [3, 4, 6, 4, 3], [1, 4, 5, 5, 1], [1, 4, 4, 4, 1], [1, 6, 5, 1, 4], [6, 6, 4, 5, 4], [5, 3, 3, 3, 2], [5, 2, 1, 5, 3], [3, 5, 1, 6, 2], [6, 4, 2, 1, 2], [1, 3, 1, 3, 2], [3, 1, 3, 4, 3], [4, 3, 1, 6, 3], [4, 6, 3, 3, 6], [3, 6, 3, 6, 4], [1, 1, 3, 1, 3], [5, 5, 1, 3, 2], [3, 4, 2, 6, 6], [5, 4, 2, 6, 1], [2, 4, 4, 5, 4], [3, 6, 2, 5, 5], [2, 5, 3, 5, 1], [3, 2, 2, 3, 4], [5, 2, 2, 6, 2], [5, 6, 2, 5, 6]]

f=q=>q.sort().map(o=>(o-s?o-s<2?t++:t=t>3?t:1:0,s=o),t=1,s=-1)|t>3


tr.map(f)   //just look to make sure every value is true
fa.map(f)  //just look to make sure every value is false

1
আমি বিশ্বাস করি যে বন্ধনীগুলি এখান থেকে সরানো যেতে পারে t=(t>4)?t:1
ইটিএইচ প্রডাকশনগুলি

এখানে আরও কয়েকটি ছোটখাটো উন্নতি হয়েছে: q=>q.sort().map(o=>(o-s?o-s<2?t++:t=t>4?t:1:0,s=o),t=1,s=9)|t>3এই সংস্করণটি 1সত্যবাদী এবং মিথ্যাচারের জন্য ফিরে আসে 0
ETH প্রোডাকশনগুলি

3

সি #, 156 151 150 131 121 93 92 90 বাইট

int l;bool f(int[]a){foreach(var v in a)l|=1<<v-1;return(l&15)>14||(l&30)>29||(l&60)>59;}

বা: (একই সংখ্যা বাইট)

int l;bool f(int[]a){foreach(var v in a)l|=1<<v;return(l&30)>29||(l&60)>59||(l&120)>119;}

Ungolfed:

int l;
bool f(int[] a)
{
    foreach (var v in a)
        l |= 1 << v - 1;
    return (l & 15) > 14 ||   //Bits 1-4 are set OR
           (l & 30) > 29 ||   //Bits 2-5 are set OR
           (l & 60) > 59;     //Bits 3-6 are set
}

বড় সম্পাদনা: ঠিক বুঝেছি আমার কেবল একটি প্রোগ্রাম পোস্ট করা দরকার, পুরো প্রোগ্রাম নয়। এটি পুরো অনেকটা সাশ্রয় করে। কোনও বয়লারপ্লেট নেই, স্ট্রিং ইনপুটটিকে সংখ্যায় রূপান্তর করতে হবে না ইত্যাদি Now


3 টি বাইট সংরক্ষণ করার জন্য বিলটি ফেরত দিন।
টিম্বো

@ টিম্বো - হ্যাঁ, আমি গতকাল বাসায় যাওয়ার পরে, এটি ঠিক করেছি about এটি পুরো প্রোগ্রাম হওয়ার থেকে বাঁচলো ( mainসি # তে অবশ্যই ফিরতে হবে voidবা int)) দুর্ভাগ্যক্রমে, আমি 2 বাইটও অর্জন করেছি কারণ আমি 1-6 এর পরিবর্তে 0-5 আশা করছিলাম। সুতরাং যাইহোক 1 বাইট নেট ক্ষতি।
ড্যারেল হফম্যান

3

রুবি - 80 -> 79 -> 76 -> 54 -> 48 -> 40 বাইট

পঞ্চম চেষ্টা (40 বাইট):

->x{/1234|2345|3456/===x.uniq.sort.join}

ফাংশনটি সংজ্ঞায়িত করতে ল্যাম্বদা সিনট্যাক্স ব্যবহার করে। (এই ধারণার জন্য রুবি গল্ফার @ শার্লক 9 প্রতিযোগিতা করার জন্য ধন্যবাদ।)

ল্যাম্বদা কল ব্যবহার করে পরীক্ষা করতে:

s = ->x{/1234|2345|3456/===x.uniq.sort.join}
s.call([1,3,5,4,4])
s.call([1,3,5,4,2])

চতুর্থ চেষ্টা:

def s?(x)/1234|2345|3456/===x.uniq.sort.join end

প্রতিস্থাপন শূন্য? এবং === অপারেটরের সাথে প্রত্যাখ্যান।

তৃতীয় চেষ্টা করুন:

def s?(x)!(/1234|2345|3456/=~x.uniq.sort.join).nil?end

নিয়মিত ভাব প্রকাশ করে Uses

দ্বিতীয় চেষ্টা:

def s?(x)[1234,2345,3456].select{|a|x.uniq.sort.join.include?a.to_s}.any?end

নতুন পদ্ধতির ডেডআপ (ইউনিক) ব্যবহার করে, সাজানো এবং যোগদান করা, এবং আরও অন্তর্ভুক্ত? একটি স্ট্রিং হিসাবে রেন্ডার ইনপুট যে কোনও সমাধানের মিল খুঁজে পেতে।

প্রথম চেষ্টা করুন: by৯ বাইট

def s?(x)[[1,2,3,4],[2,3,4,5],[3,4,5,6]].select{|a|(a&x.uniq).length>3}.any?end

পরীক্ষক:

x = [1,4,3,3,6]
s?(x)

x = [2,4,5,1,3]
s?(x)

কোনও ভাল সিকোয়েন্স প্রদত্ত অনুক্রমের সাথে মেলে কিনা তা পরীক্ষা করতে ডিডুপিং (ইউনিক ফাংশন) প্লাস সেট ছেদ ((অপারেটর) ব্যবহার করে। কোন বাছাইয়ের প্রয়োজন।


3

Pyth, 13 11

@.PQ4.:S6 4

2 বাইট জাকুবে ধন্যবাদ!

মিথ্যাচারের জন্য সত্য, খালি তালিকার জন্য একটি খালি নয় খালি তালিকা প্রদান করে।

এটি অনলাইনে ব্যবহার করে দেখুন বা টেস্ট স্যুটটি চালান (পঠনযোগ্যতার জন্য সিনট্যাক্স ত্রুটির দ্বারা বিভক্ত)।


.PQ4পরিবর্তে.:{SQ4
জাকুবে

2

পিএইচপি, 95 বাইট

function s($d){$a=array_diff;$r=range;return!($a($r(1,4),$d)&&$a($r(2,5),$d)&&$a($r(3,6),$d));}
বিস্তারিত দেখুন
function s($d){
  $a = array_diff;
  $r = range;
  return !($a($r(1,4),$d)
        && $a($r(2,5),$d)
        && $a($r(3,6),$d));
}
ইনপুট / ফাংশন কল
s(Array[int, int, int, int, int]);
আউটপুট
bool

2

সিরিয়াসলি, 21 বাইট

3R`;4+@x`M4,╨╗`╜íu`MΣ

এটি অনলাইন চেষ্টা করুন!

সত্যের জন্য একটি ধনাত্মক মান এবং মিথ্যাটির জন্য 0 দেয়।

ব্যাখ্যা:

3R`;4+@x`M4,╨╗`╜íu`MΣ
3R`;4+@x`M             push [[1,2,3,4], [2,3,4,5], [3,4,5,6]
          4,╨╗         push all 4-length permutations of input to register 0
              `   `M   map:
               ╜íu       push 1-based index of list in permutations, 0 if not found
                    Σ  sum

2

প্যারি / জিপি , by১ বাইট

এটি সম্ভবত আরও গল্ফ করা যেতে পারে তবে শুরু হিসাবে:

s=setminus;v->t=s([1..6],Set(v));!#s(t,[1,2])+!#s(t,[5,6])+!#s(t,[1,6])

আমি আরও স্থান ব্যবহার না করে সদৃশ হ্রাস করার উপায় দেখছি না; এই সংস্করণটি 75 বাইট:

s=setminus;v->t=s([1..6],Set(v));z=(u->!#s(t,u));z([1,2])+z([5,6])+z([1,6])

2

রেটিনা , 70 54 বাইট

ইনপুট হল পূর্ণসংখ্যার একক স্ট্রিং 13342। আউটপুট 1যদি পাওয়া যায় তবে এটি একটি বা 0যদি না পাওয়া যায় ।

.                       # Replace integer digits with unary
$*x,
+`(x+(x+,))\2           # Sorts the list by repeated swapping
$2$1
(x+,)\1                 # Removes adjacent duplicates
$1
(x+,)x\1xx\1xxx\1       # Matches a small straight

নোট করুন যে সদৃশ অপসারণ কেবল একবারেই হওয়া দরকার, যেহেতু কেবল পাঁচটি সংখ্যা রয়েছে। একাধিক সংখ্যা অপসারণের প্রয়োজনের অর্থ হ'ল যাইহোক কোনও ছোট সোজা নেই।

এটি অনলাইনে চেষ্টা করুন

ক্যাপচার গ্রুপগুলির মধ্যে কমাগুলি স্থানান্তরিত করার জন্য মার্টিনকে ধন্যবাদ, পুরো 16 বাইট সংরক্ষণ করা tes


এটা কিভাবে কাজ করে?
ক্যালকুলেটরফলাইন

. $*x Replace numbers with n x's, where n is the number. +` Repeat the following until the string stabilizes (x+(x+,))\2 $2$1 Replace n*xm*x,m*x, with m*x,n*xm*x (x+,)\1 $1 Replace x*n,x*n, with x*n, (x+,)x\1xx\1xxx\1 Match n*x,xn*x,xxn*x,xxxn*xআপডেট হয়েছে
ক্যালকুলেটরফলাইন

@ ক্যাটস আরেফ্ল্ফী আমি এটি বিবরণ হিসাবে ব্যবহার করছি না। মাত্র একটি এফওয়াইআই যে কেউ একবারে রেটিনা গিথুব পৃষ্ঠাটি একবার পড়েছে সে তা পাওয়া উচিত। যা করা হচ্ছে সে সম্পর্কে মন্তব্যগুলি (যেমন বাছাই করা, ডুপ্লিকেট অপসারণ করা) প্রত্যেকটি প্রতিস্থাপন বলে বর্ণনা করার চেয়ে গুরুত্বপূর্ণ।
mbomb007

2

পাইথ, 11 বাইট

f!-TQ.:S6 4

পরীক্ষা স্যুট

[১. 4.] এর দৈর্ঘ্য ৪ টি সাবস্ট্রিং তৈরি করুন, তারপরে ইনপুটটির উপাদানগুলি সরানো হবে না এমন কোনও উপাদানগুলিতে এগুলি ফিল্টার করুন।


2

জেলি, 9 বাইট

একটি 8-বাইট সমাধান থাকতে হবে, অনুসন্ধান চালিয়ে যাবে ... কোড:

Œ!Ḋ€Iµ7Be

এটি আমার মত একই 05AB1E সমাধানের মতো

ব্যাখ্যা:

Œ!         # Compute all permutations
  Ḋ€       # Dequeue each, leaving [1:]
    I      # Delta function
     µ     # Start a new monadic chain
      7B   # 7 in binary, which is [1, 1, 1]
        e  # Return 1 if this array exists

এটি অনলাইন চেষ্টা করুন!


আরেকটি, বিকল্প 9: Œ!I=1ZS3e...
ফ্রাইআম দ্য এজিগম্যান

[1, 2, 1, 2, 1]দুর্ভাগ্যক্রমে আপনার জন্য অন্য কোনও উত্তর দেয় না for আমার বিকল্পটি কাজ করে বলে মনে হচ্ছে (তবে আমি আগে ভুল হয়ে গিয়েছিলাম ... এটিও পরীক্ষা করুন :)), এটি নির্দ্বিধায় ব্যবহার করুন।
FryAmTheEggman

2

জেলি, 8 বাইট

6Rṡ4ḟ€ċ“

এটি অনলাইন চেষ্টা করুন! বা যাচাই truthy পরীক্ষার বিষয় এবং falsy পরীক্ষার বিষয়

কিভাবে এটা কাজ করে

6Rṡ4ḟ€ċ“  Main link. Argument: A (list)

6R        Yield [1, 2, 3, 4, 5, 6].
  ṡ4      Split it into overlapping slices of length 4, yielding
          [[1, 2, 3, 4], [2, 3, 4, 5], [3, 4, 5, 6]].
    ḟ€    Remove all occurrences of A's elements from each slice.
      ċ“  Count the resulting number of empty list.
          This returns the number of distinct small straights in A (0, 1 or 2).

2

স্কালা, 76 70 61 60 বাইট

(s:Seq[Int])=>(1 to 6)sliding(4)exists(t=>(s diff t).size<2)

পরীক্ষক:

val f = <code here>
val truthy = Seq(Seq(1, 2, 3, 3, 4), Seq(1, 2, 3, 4, 5), Seq(3, 5, 6, 1, 4), Seq(1, 5, 3, 4, 6), Seq(4, 5, 2, 3, 5), Seq(1, 4, 3, 2, 2), Seq(5, 4, 3, 6, 3), Seq(5, 3, 5, 4, 6), Seq(2, 4, 5, 1, 3), Seq(3, 6, 4, 5, 3), Seq(5, 6, 4, 3, 5), Seq(4, 5, 3, 6, 3), Seq(4, 5, 5, 3, 2), Seq(4, 5, 2, 3, 5), Seq(4, 6, 5, 3, 6), Seq(4, 2, 3, 1, 5), Seq(3, 6, 4, 6, 5), Seq(5, 2, 1, 3, 4), Seq(4, 4, 1, 2, 3), Seq(4, 1, 4, 2, 3), Seq(5, 1, 4, 3, 6), Seq(5, 2, 2, 3, 4), Seq(4, 4, 6, 5, 3), Seq(2, 4, 3, 5, 1), Seq(5, 4, 2, 5, 3), Seq(2, 3, 5, 5, 4), Seq(1, 6, 3, 4, 5), Seq(4, 5, 3, 3, 6), Seq(6, 4, 3, 6, 5), Seq(4, 6, 6, 5, 3), Seq(4, 3, 5, 2, 2), Seq(2, 3, 2, 1, 4), Seq(4, 2, 6, 1, 3), Seq(4, 4, 5, 3, 6), Seq(4, 5, 6, 3, 6))
val falsy = Seq(Seq(1, 2, 3, 5, 6), Seq(5, 1, 1, 6, 6), Seq(4, 6, 4, 1, 1), Seq(6, 4, 1, 6, 4), Seq(4, 6, 3, 6, 6), Seq(2, 1, 4, 6, 4), Seq(2, 6, 1, 5, 6), Seq(2, 6, 1, 5, 6), Seq(3, 6, 5, 3, 2), Seq(3, 2, 3, 5, 3), Seq(5, 5, 6, 2, 3), Seq(3, 4, 6, 4, 3), Seq(1, 4, 5, 5, 1), Seq(1, 4, 4, 4, 1), Seq(1, 6, 5, 1, 4), Seq(6, 6, 4, 5, 4), Seq(5, 3, 3, 3, 2), Seq(5, 2, 1, 5, 3), Seq(3, 5, 1, 6, 2), Seq(6, 4, 2, 1, 2), Seq(1, 3, 1, 3, 2), Seq(3, 1, 3, 4, 3), Seq(4, 3, 1, 6, 3), Seq(4, 6, 3, 3, 6), Seq(3, 6, 3, 6, 4), Seq(1, 1, 3, 1, 3), Seq(5, 5, 1, 3, 2), Seq(3, 4, 2, 6, 6), Seq(5, 4, 2, 6, 1), Seq(2, 4, 4, 5, 4), Seq(3, 6, 2, 5, 5), Seq(2, 5, 3, 5, 1), Seq(3, 2, 2, 3, 4), Seq(5, 2, 2, 6, 2), Seq(5, 6, 2, 5, 6))
println("Failed truthy: " + truthy.filterNot(f))
println("Failed falsy: " + falsy.filter(f))

2

জাভাস্ক্রিপ্ট ES6 43 বাইট

q=>/1,1,1,1/.test(q.map(a=>l[a]=1,l=[])&&l)


// এটি বেশ কার্যকরভাবে পেতে পারে নি: /

q=>q.map(a=>l&=~(1<<a),l=62)&&l<7||l==32

এটি 62 নম্বর (বাইনারি 111110) লাগে ইনপুট অ্যারের প্রতিটি সংখ্যার জন্য এটি বিটটি সরিয়ে দেয়

ফলাফল সংখ্যাটি হয় হওয়া উচিত

100000 or
000000 or
000010 or
000110 or
000100

সুতরাং আমি ফলাফলটি 7 (0000111) এর চেয়ে কম কিনা বা এটি 32 (100000) এর সমান কিনা তা পরীক্ষা করে দেখছি


2,3,4,5,2 এর মতো একটি তালিকা সহ এটি 34 হতে পারে না?
lirtosiast

এটি এখনও এই সত্যটি পরিবর্তন করে না যে এটি কাজ করে না [3, 4, 5, 4, 3]। আমি মনে করি আপনার 62 এর পরিবর্তে 126 ব্যবহার করা দরকার ...
Sp3000

2

টিআই-বেসিক, 25 বাইট

not(min(fPart(prod(Ans+36)/(65{703,779,287

একটি সমতুল্য (অবারিত) পাইথন এক্সপ্রেশন যা আপনি পরীক্ষা করতে পারেন :

def has_small_straight(l):
    product = reduce(lambda x,y: x*y, [x + 36 for x in l], 1)
    numbers = [37*19*13*5, 19*13*5*41, 13*5*41*7]
    return not(all([product%x for x in numbers]))

এর পিছনে ধারণাটি বিভাজ্যতা। কিনা পরীক্ষা করার জন্য 1, 2, 3, 4, 2, 3, 4, 5অথবা3, 4, 5, 6 ঘটে, আমরা সংখ্যার 1-6 37-42 থেকে সংখ্যাবৃদ্ধি সঠিক সংখ্যা একসঙ্গে ম্যাপ করতে পারেন, এবং তারপর।

[37,42] এর প্রতিটি সংখ্যার একটি প্রধান উপাদান রয়েছে যা অন্য সংখ্যার অভাবের।

n             |  1 |  2 |  3 |  4 |  5 |  6 |
n + 36        | 37 | 38 | 39 | 40 | 41 | 42 |
Factor        | 37 | 19 | 13 |  5 | 41 |  7 |

সুতরাং, পাঁচটি সংখ্যার গুণফল যদি 37 দ্বারা বিভাজ্য হয় তবে মূল তালিকায় একটি 1 রয়েছে। যদি 19 দ্বারা, এটিতে 2 থাকে; ইত্যাদি যদি তা না হয় বিভাজ্য দ্বারা 37*19*13*5= 65*703, এটা রয়েছে 1, 2, 3, এবং4 এবং একইভাবে অন্য দুটি সংখ্যার জন্য।

এই সমাধানে একটি উন্নতি হয় এক যে @Weregoose 2009 সালে পোস্ট করা হয়েছে।


ইহা অসাধারণ!
চার্লস

2

মাম্পস, 113 78 বাইট

আমি যে মাম্পস ব্যবহার করছি তার সংস্করণ হ'ল ইন্টারসিস্টেম ক্যাশে।

আমি এই কৌশলটি কোনও সংক্ষিপ্তভাবে গল্ফ করার উপায় সম্পর্কে ভাবতে পারি না; ভিন্ন কৌশল দিয়ে এটি সম্ভব হতে পারে তবে আপাতত এটি করবে এবং কমপক্ষে এটি সি ++ এর চেয়ে কম ... তবে বেশি নয়। যাই হোক ...

ঠিক আছে, এখানে একটি ছোট উপায়। সংক্ষিপ্ত রানের জন্য 3 পৃথক ভেরিয়েবল পরিবর্তে সমস্ত 6 'ডাইস' এর জন্য একটি একক ভেরিয়েবল ব্যবহার করুন এবং পরে অংশগুলি বের করুন:

R R S Y=111111 F F=1:1:5{S $E(Y,$E(R,F))=0} W '$E(Y,1,4)!'$E(Y,2,5)!'$E(Y,3,6)

আমার পক্ষে একই কৌশলটি দিয়ে আরও ভাল উপায় খুঁজে পাচ্ছি না ... লাফানোর আগে আমার উচিত দেখা উচিত, তাই না? ;-)

আমি নীচে আমার মূল উত্তরটি historicalতিহাসিক উদ্দেশ্যে ছেড়ে দেব ...



R R S (G,H,I)=1111 F F=1:1:5{S Q=$E(R,F) S:1234[Q $E(G,Q)=0 S:2345[Q $E(H,Q-1)=0 S:3456[Q $E(I,Q-2)=0} W 'G!'H!'I

এবং কোডটি দিয়ে কী চলছে তার ব্যাখ্যা এখানে রয়েছে:

R R                   ; read from STDIN to variable R
S (G,H,I)=1111        ; set our 3 possible short straights
F F=1:1:5{            ; For loop from 1 to 5
S Q=$E(R,F)           ; get each digit from the input and save in Q
S:1234[Q $E(G,Q)=0    ; If Q is either 1,2,3 or 4, zero out that position in G.
S:2345[Q $E(H,Q-1)=0  ; if Q is either 2,3,4 or 5, zero out that position (-1) in H.
S:3456[Q $E(I,Q-2)=0  ; if Q is either 3,4,5 or 6, zero out that position (-2) in I.
}                     ; and end the loop.
W 'G!'H!'I            ; If G,H, or I are all zeroes (indicating a full straight),
                      ; taking the not of each will make (at least one) of the
                      ; values true. OR-ing all three values will let us know if
                      ; at least one short straight was complete.
                      ; Output is 1 for truthy, 0 for falsy.

আমি প্রত্যেকটি সত্যবাদী এবং মিথ্যা ইনপুট পরীক্ষা করে দেখি নি involved তবে আমি প্রায় প্রতিটি প্রথমার্ধের পরীক্ষা করেছি, যাচাই করা দীর্ঘ স্ট্রেইট এখনও সত্য দেখায় এবং বেশ কয়েকটি রান অপরিহার্যভাবে সঠিকভাবে কাজ না করার জন্য উল্লিখিত হয় ([4,2,5,3,4], [1,2,3,3 , 4] ইত্যাদি) এবং সঠিকভাবে কাজ করছে বলে মনে হচ্ছে।


2

ডায়ালগ এপিএল , 15 বাইট

{∨/∧/⍵∊⍨⍵∘.+⍳4}

ব্যবহারসমূহ ⎕IO=0

⍳4 হয় 0 1 2 3

⍵∘.+⍳4 5 × 4 এর প্রতিটি দ্বারা বাড়ানো প্রতিটি ডাইয়ের ম্যাট্রিক্স ⍳4

⍵∊⍨ ম্যাট্রিক্সের উপাদানগুলি হাতে রয়েছে কিনা তা পরীক্ষা করে দেখুন, ফলাফলটি একটি বুলিয়ান (0-বা -1) ম্যাট্রিক্স, আমাদের সমস্ত 1s এর সারি সন্ধান করতে হবে

∧/ সারিগুলির দ্বারা এবং হ্রাস, ফলাফলটি বুলিয়ান ভেক্টর

∨/ সেই ভেক্টরের বা হ্রাস


1

জেলি, 11

QṢṡ4ðfø6Rṡ4

এটি অনলাইন চেষ্টা করুন!

এটি আমার পাইথ উত্তরের একটি অনুলিপি, কেবল কীভাবে স্টাফ তৈরি করা যায় তা নির্ধারণের চেষ্টা করা। মনে হয় এটি গল্ফযোগ্য হওয়া উচিত।

সম্প্রসারণ:

QṢṡ4ðfø6Rṡ4  ##  1, 2, 0 chain, 1 argument from command line
QṢṡ4         ##  first chain, uniQue and Sort the input, then
             ##  get overlapping lists of length 4 (ṡ)
    ð        ##  separator
     f       ##  filter left argument on being a member of right argument
      ø      ##  separator
       6Rṡ4  ##  all overlapping lists of length 4, from 1-indexed range of 6
             ##  generates [1,2,3,4],[2,3,4,5],[3,4,5,6]

যদি আপনি কোনও শক্ত প্রশ্ন জিজ্ঞাসা করতে চান, যেমন বিভাজনকারীরা আলাদা কেন, তবে আপনার আমার উত্তরটি হ'ল: "আমি 6-8 সপ্তাহের মধ্যে উত্তর দেব": পি (আরও গুরুতরভাবে, আমি মনে করি এটি প্যাটার্নটি মিলেছে, মোনাড-ডায়াড বনাম নীলাদ-দিয়াদ, তবে আমি জানি না এবং ভুল তথ্য ছড়াতে চাই না))


ব্যাখ্যা:Q Unique elements Ṣ sort the list ṡ4 all slices of length 4 ðf filter by { 6R range form 1 to 6 ṡ4 all slices of length 4 from that
ক্যালকুলেটরফ্লাইন

কোনও কারণে Qডকুমেন্টেশনে বড় হাতের ওভারডট অপারেটরদের সাথে রয়েছে। এটা কি একবার ওভারডট হয়ে গেল?
ক্যালকুলেটরফলাইন

@ ক্যাটস আরেফ্লুফি আমার কোনও ধারণা নেই, আমি কোড পৃষ্ঠা থেকে একটিটি ব্যবহার করেছি পরমাণু পৃষ্ঠার
ফ্রাইআম TheEggman
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.