येहत्ज़ी स्माल स्ट्रेट डिटेक्शन


34

याहत्ज़ी के खेल में , खिलाड़ी पांच छह-पक्षीय पासा चलाते हैं, और अंक हासिल करने के लिए कुछ खास हाथ बनाने का प्रयास करते हैं। ऐसा एक हाथ एक छोटा सा सीधा है : लगातार चार नंबर, जरूरी नहीं कि क्रम में हो। तीन संभावित छोटे सीधे हैं 1, 2, 3, 4, 2, 3, 4, 5, और 3, 4, 5, 6

उदाहरण के लिए, [3, 5, 6, 1, 4]छोटे सीधे शामिल हैं [3, 4, 5, 6]

इनपुट

पाँच पूर्णांकों की एक अनसुलझी सूची, प्रत्येक के बीच 1 और 6 समावेशी, एक यात्ज़ी हाथ का प्रतिनिधित्व करते हैं।

उत्पादन

एक सत्य मूल्य अगर हाथ में एक छोटा सा सीधा और एक मिथ्या मूल्य है अन्यथा।

परीक्षण के मामलों

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 आउटपुट कर सकता था?
मार्टिन एंडर

@ MartinBüttner इसके अनुरूप होने की आवश्यकता नहीं है।
lirtosiast

9
अगर यह काम करता है, तो यह सुनिश्चित कर लें [1,2,3,3,4]। इसके कारण कई उत्तर मर जाते हैं।
कैलक्यूलेटरफलाइन

क्या मैं मान सकता हूं कि सरणी शून्य द्वारा गद्देदार है?
कैलक्यूलेटरफिलीन

5
@CatsAreFluffy "डाई"
डस्टिन रासनर

जवाबों:


28

MATL , 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
@AandN \ o / \ o / \ o /
लुइस मेंडो

8
अगर आप अन्य उपयोगकर्ताओं की तरह बाइट काउंट हिस्ट्री को रखना चाहते हैं तो मुझे यह पसंद आएगा। यह प्रगति को दर्शाता है।
mbomb007

1
कम से कम 8 से 6 की प्रगति सही थी ...
कॉनर ओ'ब्रायन

5
@DonMuesli FWIW मैं आपसे सहमत हूं और mbomb007 से असहमत हूं। जो संस्करण काम नहीं कर रहे थे वे अर्थहीन हैं और उन्हें इतिहास में शामिल नहीं किया जाना चाहिए। मैं आमतौर पर काम करने वाले संस्करणों के केवल बाइट काउंट को शामिल करता हूं, इसलिए यह निश्चित रूप से एक सख्ती से घटता क्रम है।
मार्टिन एंडर

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)। हम स्टैक पर 30शून्य इनपुट के साथ समाप्त होते हैं, और इस शून्य को 30 में बदल देते हैं। फिर हम सेटअप से एक ही निर्देश करते हैं, लेकिन इस बार वे वास्तव में उपयोगी हैं।

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

यह लूप EOF तक इनपुट में प्रत्येक नंबर के लिए जारी रहता है, जब ?रिटर्न 0. यह मुड़ने के बजाय हमें आगे की ओर ले जाता है, जिससे ...

ब्रिज: कुछ अतिरिक्त सेटअप

30के बाद ?बदल जाता है 30 में EOF से 0, जो के माध्यम से सहायक ढेर को धक्का दे }। महत्व का तथ्य यह है कि हमने प्रत्येक इनपुट संख्या के लिए 30 को सहायक स्टैक में धकेल दिया है, इसलिए अब सहायक स्टैक में 5 + 1 = 6संख्या 30 की प्रतियां हैं

इस बीच, मुख्य स्टैक में 2^(n+1)प्रत्येक इनपुट के लिए बिटवाइज़ OR है n। चलो इस बिटवाइज़ को कॉल करें या 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]

संपादित करें: @Zgarb ने 5 बाइट्स बचाए। धन्यवाद!



5

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

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

trueसत्य के लिए और मिथ्या के लिए लौटता है false

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

यदि कुछ मान [0, 1, 2, 3] में लौटाते हैं तो यह शर्त पूरी करते हैं कि [0, 1, 2, 3] में हर मान के लिए इन दोनों मानों का योग इनपुट ऐरे में है।

इसलिए, यदि सरणी का मान [0, 1, 2, 3] (असंभव), [1, 2, 3, 4], [2, 3, 4, 5], या [3, 4, 5 में है , ६]।


5

रूबी, ३१

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

यह शर्लक के उत्तर के समान एल्गोरिथ्म का उपयोग करता प्रतीत होता है ।

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

5

रूबी, 58 55 50 47 43 33 बाइट्स

मैंने अभी देखा कि मुझे पॉल के रूबी के जवाब से मुक्का मारा गया है । हालांकि मुझे नहीं लगता कि मैं कुछ और गोल्फ के साथ अभी भी एक अच्छा जवाब हो सकता है। भाग में, xnor के पायथन उत्तर के आधार पर ।

संपादित करें: कुछ गोल्फिंग और टर्नरी कंडिशन में मिक्स-अप को सही करना।

संपादित करें: मैं अब का उपयोग .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
अच्छा तरीका !!
लुइस मेन्डो

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

CJam, 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

05AB1E , 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.

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

CP-1252 एन्कोडिंग का उपयोग करता है ।


3

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

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

जावास्क्रिप्ट ईएस 6 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)


पुराना उत्तर

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

कई बाइट को बचाने में मदद करने के लिए ETHproductions का धन्यवाद

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
20

यहां कुछ और छोटे सुधार किए गए हैं: 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
ETHproductions

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
}

बिग एडिट: बस एहसास हुआ कि मुझे केवल एक फ़ंक्शन पोस्ट करने की आवश्यकता है, न कि एक संपूर्ण कार्यक्रम। जो पूरी तरह से बचाता है। कोई बॉयलरप्लेट, स्ट्रिंग इनपुट को संख्याओं में बदलने की आवश्यकता नहीं है, आदि अब हम वास्तव में एक सम्मानजनक संख्या में बाइट्स के लिए आ रहे हैं (किसी भी तरह गैर-गोल्फिंग भाषा के लिए)।


3 बाइट बचाने के लिए बूल वापस करें।
टिम्बो

@ टिम्बो - हाँ, मैंने इस बारे में सोचा था कि कल घर जाने के बाद मैंने इसे ठीक किया। यह एक पूर्ण कार्यक्रम होने से बचा हुआ था ( 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

नियमित अभिव्यक्ति का उपयोग करता है।

दूसरा प्रयास:

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

नए दृष्टिकोण में डिडअप (यूनीक), सॉर्ट और जॉइन, प्लस शामिल हैं? स्ट्रिंग के रूप में प्रदान किए गए इनपुट में किसी भी समाधान के मैच की खोज करना।

पहला प्रयास: 79 बाइट्स

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 1 1

@.PQ4.:S6 4

2 बाइट्स Jakube के लिए धन्यवाद!

सच्चाई के लिए एक गैर-खाली सूची देता है, झूठी सूची के लिए खाली सूची।

इसे ऑनलाइन आज़माएं या टेस्ट सूट चलाएं (पठनीयता ™ के लिए एक सिंटैक्स त्रुटि द्वारा विभाजित)।


.PQ4इसके बजाय.:{SQ4
जकुबे

2

PHP, 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

PARI / GP , 71 बाइट्स

यह शायद आगे गोल्फ हो सकता है, लेकिन शुरुआत के रूप में:

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 बाइट्स की बचत।


यह कैसे काम करता है?
कैलक्यूलेटरफलाइन

. $*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अपडेट किया गया
कैलक्यूलेटरफेलीन

@CatsAreFluffy मैं उस विवरण के रूप में उपयोग नहीं कर रहा हूं। सिर्फ एक FYI करें। जो भी कभी एक बार रेटिना गिथब पृष्ठ को पढ़ता है, उसे वह प्राप्त करना चाहिए। जो पूरा किया जा रहा है उसके बारे में टिप्पणियाँ (जैसे छंटनी, डुप्लिकेट निकालना) यह बताने से अधिक महत्वपूर्ण हैं कि प्रत्येक एक प्रतिस्थापन है।
mbomb007

2

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

f!-TQ.:S6 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...
FryAmTheEggman

के लिए काम नहीं करता है [1, 2, 1, 2, 1], और न ही अपने अन्य दुर्भाग्य से जवाब देता है। मेरा विकल्प काम करने लगता है (लेकिन मैं पहले भी गलत रहा हूँ ... इसे भी परखें :)), बेझिझक इसका इस्तेमाल करें।
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

जावास्क्रिप्ट ईएस 6 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 का उपयोग करने की आवश्यकता है ...
16:

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 को गुणा सही संख्या एक साथ मैप कर सकते हैं, और उसके बाद।

[३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 बाइट्स

मेरे द्वारा उपयोग किए जाने वाले मम्प्स का संस्करण इंटरसिस्टम कैश है।

मैं इस तकनीक को किसी भी छोटे से गोल्फ के तरीके के बारे में नहीं सोच सकता; एक अलग तकनीक के साथ यह संभव हो सकता है, लेकिन अभी के लिए यह करूँगा और कम से कम यह C ++ से कम है ... लेकिन बहुत ज्यादा नहीं। वैसे भी ...

ठीक है, यहाँ एक छोटा रास्ता है। छोटे रन के लिए 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)

मेरे लिए एक ही तकनीक के साथ एक बेहतर तरीका नहीं मिल रहा है ... मुझे छलांग लगाने से पहले देखना चाहिए, एह? ;-)

मैं ऐतिहासिक उद्देश्यों के लिए अपना मूल उत्तर नीचे छोड़ दूँगा ...



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.

मैंने हर एक सत्य और झूठे इनपुट का परीक्षण नहीं किया, क्योंकि इसमें मैन्युअल रूप से उन सभी को टाइप करना शामिल था; लेकिन मैंने लगभग प्रत्येक की पहली छमाही का परीक्षण किया, लंबी पट्टियाँ सत्यापित कीं फिर भी सच्चाई दिखाते हैं और कई रनों को सही ढंग से काम नहीं करने के लिए नोट किया गया ([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-or-1) मैट्रिक्स है, हमें सभी 1s की एक पंक्ति खोजने की आवश्यकता है

∧/ पंक्तियों द्वारा कमी की जाती है, परिणाम एक बूलियन वेक्टर है

∨/ उस वेक्टर की या-कटौती है


1

जेली, ११

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लिए प्रलेखन में अपरकेस ओवरडॉट ऑपरेटरों के साथ है। शायद यह एक बार एक ओवरडोट था?
कैलकुलेटरफैनलाइन

@CatsAreFluffy मुझे कोई पता नहीं है, मैंने कोड पृष्ठ से परमाणुओं पृष्ठ में एक का उपयोग किया है ।
FryAmTheEggman
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.