क्या मेरा 4-नोट वाला संगीत बॉक्स उस गाने को बजा सकता है?

51

मेरे पास एक क्रैंक-संचालित संगीत बॉक्स है जो चार नोटों की एक श्रृंखला खेल सकता है। जब मैं क्रैंक को चालू करता हूं, तो यह क्रैंक की स्थिति और मोड़ की दिशा के आधार पर, चार तारों में से एक को प्लक करता है। जब क्रैंक को उत्तर की ओर मोड़ दिया जाता है, तो बॉक्स (इसके तार 4 के माध्यम से गिने जाते हैं) इस तरह दिखता है:

1  |  2
   |
   O   

4     3

वहाँ से, मैं क्रैंक क्लॉकवाइज़ को # 2 स्ट्रिंग प्लक कर सकता हूँ और क्रैंक ईस्ट को इंगित कर सकता हूँ:

1     2

   O---   

4     3

वैकल्पिक रूप से, मैं # 1 स्ट्रिंग खेलने के लिए उत्तर से क्रैंक वामावर्त भी मुड़ सकता था और क्रैंकिंग पश्चिम के साथ समाप्त हो सकता है:

1     2

---O   

4     3

किसी भी समय, फिर, बॉक्स दो में से एक नोट खेल सकता है: अगला नोट क्लॉकवाइज दिशा में उपलब्ध है या काउंटरक्लॉकवाइज दिशा में अगला नोट।

चुनौती

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

कुछ नोट:

  • इनपुट आरंभिक स्थिति के बारे में कोई धारणा नहीं बनाता है। इनपुट्स 214(पूर्व की ओर और सख्ती से वामावर्त की ओर बढ़ते हुए) और 234(उत्तर की ओर से और कड़ाई से दक्षिणावर्त घूमते हुए) और दोनों वैध।

  • क्रैंक प्रत्येक नोट के बाद किसी भी दिशा में स्वतंत्र रूप से आगे बढ़ सकता है। एक ही नोट के 33333आगे और पीछे एक स्ट्रिंग द्वारा एक ही नोट की एक श्रृंखला संभव है (जैसे )। श्रृंखला 1221441पूरी तरह से खेलने योग्य है (पश्चिम से शुरू होकर, दक्षिणावर्त दो कदम, फिर वामावर्त तीन चरण, फिर दक्षिणावर्त दो चरण)।

नमूने

कुछ trueमामले:

1
1234
1221
3333
143332
22234
2234
22214
1221441
41233

कुछ falseमामले:

13     (note 3 is never available after note 1)
1224   (after `122`, the crank must be north, so 4 is not playable)
121    (after `12` the crank is east; 1 is not playable)
12221  (as above, after `1222` the crank is east)
43221
code-golf  decision-problem  graph-theory 
— apsillers
स्रोत
क्या इनपुट उद्धरण सहित स्ट्रिंग हो सकता है?
— लुइस मेंडो
@LuisMendo ज़रूर, मैं इसे अनुमति दूंगा - मुझे आपके एल्गोरिथ्म में दिलचस्पी है, इनपुट प्राप्त करने के लिए आपको हुप्स से कूदने की ज़रूरत नहीं है। वैसे भी, अनौपचारिक सामुदायिक आम सहमति है कि यह आम तौर पर ठीक है: स्ट्रिंग इनपुट "या" के बिना?
— अप्सिलर्स
1
मुझे नहीं पता था। लिंक के लिए धन्यवाद!
— लुइस मेंडो
1
@AJMansfield नहीं, समाधानों को मनमाने ढंग से कई चक्रों के लिए अनुमति देनी चाहिए। बेशक, अगर कुछ इनपुट आपके कोड को आपकी भाषा के दुभाषिया या आपके कंप्यूटर की मेमोरी में एक सीमा से अधिक होने का कारण बनाते हैं, तो यह ठीक है (क्योंकि यह केवल शारीरिक रूप से आपके पास या आपकी दुभाषिया की अनुमति देता है, लेकिन आपके समाधान में अतिरिक्त सीमाएं नहीं लादनी चाहिए) कितनी दूर या कितनी बार क्रैंक चलता है।
— अप्सिलर्स
1
इस चुनौती ने बेस्ट ऑफ पीपीसीजी 2016 में कैटगरी की तरह सरल नहीं जीता । दुर्भाग्य से, हम चुनौतियों को इनाम नहीं दे सकते हैं, लेकिन ज़गारब ने आपके सम्मान में एक चुनौती लिखी है । बधाई हो!
— मार्टिन एंडर

जवाबों:

9

पायथ, 30 27 बाइट्स

f!-aVJ.u%-ysYN8zTtJ,1 7cR2T

यहाँ विचार है:

 1.5  1  0.5

  2       0

 2.5  3  3.5

क्रैंक हमेशा आधे-पूर्णांक स्थिति पर होता है c। प्रत्येक चरण में, हम nसेटिंग द्वारा पूर्णांक स्थिति नोट पर इसे दर्शाते हैं c = 2*n-c। यदि nमान्य है, cतो 8. 1 mod 8. से परिवर्तन होता है। यदि nअमान्य है, तो cWe 3 mod से बदलता है। हम सभी मूल्यों को एकत्र करने के लिए इनपुट पर संचयी रूप से कम करते हैं c, और फिर देखें कि क्या सभी नोट मान्य थे। हम ऐसा हर शुरुआती मूल्य के लिए करते हैं c, क्योंकि यह पहले नोट से सटे लोगों की जाँच करने से कम है।

प्रारूपित:

f
  ! -
      aV J .u
              % -
                  y s Y
                  N
                8
              z
              T
         t J
      ,
        1 
        7
  cR2 T

टेस्ट सूट ।

— lirtosiast
स्रोत
18

CJam, 34 31 बाइट्स

8,q{~2*f{_@-_zF8b&,@@+8,=*}0-}/

मेरे फोन पर ऐसा किया था, इसलिए मुझे बाद में स्पष्टीकरण देना होगा। आउटपुट nonfpty iff सच्चाई है।

इसे ऑनलाइन आज़माएं | परीक्षण सूट

व्याख्या

नया कोड लेआउट को थोड़ा बदलता है:

2    3    4

1    .    5

0/8  7    6

यहां तक ​​कि संख्याएं स्ट्रिंग पदों के अनुरूप हैं और विषम संख्या क्रैंक पदों के अनुरूप हैं।

यहाँ क्या होता है:

8,           Create the range [0 1 .. 7] of possible starting positions
             We can leave the string positions [0 2 4 6] in since it doesn't matter
q{ ... }/    For each character in the input...
  ~2*          Evaluate as integer and double, mapping "1234" -> [2 4 6 8]
  f{ ... }     Map over our possible current crank positions with the string
               position as an extra parameter
    _@-          Calculate (string - crank), giving some number in [-7 ... 7]
    _z           Duplicate and absolute value
    F8b          Push 15 base 8, or [1 7]
    &,           Setwise intersection and get length. If (string - crank) was in
                 [-7 -1 1 7] then the move was valid and this evaluates to 1, otherwise 0
    @@+          Calculate ((string - crank) + string)
    8,=          Take modulo 8, giving the new crank position. x%y in Java matches the
                 sign of x, so we need to do ,= (range + index) to get a number in [0 .. 7]
    *            Multiply the new crank position by our previous 0 or 1
  0-           Remove all 0s, which correspond to invalid positions

स्टैक तब अंत में स्वचालित रूप से मुद्रित होता है। कोई भी संभावित अंतिम स्थिति आउटपुट में होगी, उदाहरण के लिए इनपुट 1आउटपुट के लिए है 31, जिसका अर्थ है कि क्रैंक या तो बाएं या ऊपर का सामना कर सकता है।

यदि केवल CJam में अतिरिक्त पैरामीटर के साथ फ़िल्टर होता ...

संपादित करें: अस्थायी रूप से वापस रोल करते समय मैं खुद को समझाता हूं कि यह 29-बाइट काम करता है:

8,q{~2*f{_@-_7b1#@@+8,=|}W-}/
— Sp3000
स्रोत
37
हर बार जब कोई व्यक्ति किसी कठिन भाषा जैसे cjam का जवाब देता है और कहता है "ऐसा मैंने अपने फोन पर किया है" मैं थोड़ा अंदर मर जाता हूं
— डेनिस वैन गिल्स
2
उनका शायद मतलब था कि एक फोन का उपयोग करके टेक्स्ट को आउटपुट किया गया था, लेकिन यह उसके सिर में किया गया था।
— नेल्सन
7

हास्केल, 93 88 87 बाइट्स

any(all(\(a,b:c)->1>mod(a!!1-b)4).(zip=<<tail)).mapM((\a->[[a,a+1],[a+1,a]]).read.pure)

यह एक अनाम फ़ंक्शन का मूल्यांकन करता है जो एक स्ट्रिंग लेता है और एक बूलियन देता है। यहां टेस्ट सूट।

व्याख्या

यह विचार है कि लैम्ब्डा सही नक्शे पर एक नंबर aपर [[a,a+1],[a+1,a]], दो संभव "चालें" जो निम्न आरेख के अनुसार, उस नंबर पर क्रैंक लेता है:

  1 (2) 2

(1/5)  (3)

  4 (4) 3

मुख्य अनाम फ़ंक्शन में, हम पहले करते हैं mapM((...).read.pure), जो प्रत्येक वर्ण को एक पूर्णांक में परिवर्तित करता है, उपरोक्त लैम्बडा को उस पर लागू करता है, और दो चालों में से एक को चुनता है, सभी परिणामी चाल अनुक्रमों की सूची को लौटाता है। फिर, हम जांचते हैं कि क्या इनमें से किसी भी अनुक्रम में संपत्ति है कि प्रत्येक चाल की दूसरी संख्या अगले मॉड्यूल 4 की पहली संख्या के बराबर है, जिसका अर्थ है कि यह शारीरिक रूप से संभव अनुक्रम है। ऐसा करने के लिए, हम zipप्रत्येक के साथ अनुक्रम को स्थानांतरित tailकरते हैं all, जोड़े के लिए स्थिति की जांच करते हैं , और देखते हैं कि क्या anyअनुक्रम मूल्यांकन करता है True।

— Zgarb
स्रोत
6

रेटिना , 127 109 बाइट्स

^((1|2)|(2|3)|(3|4)|(4|1))((?<2-5>1)|(?<5-2>1)|(?<3-2>2)|(?<2-3>2)|(?<4-3>3)|(?<3-4>3)|(?<5-4>4)|(?<4-5>4))*$

यह प्रिंट 0या 1, तदनुसार।

इसे ऑनलाइन आज़माएं! (यह थोड़ा संशोधित संस्करण है जो मुद्रण के बजाय इनपुट में सभी मिलानों को चिह्नित करता है 0या 1)

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

हालांकि, मैं किसी चीज़ के बारे में जानने की कोशिश करता हूं, अगर कोई भी यह पता लगाना चाहता है कि यह कैसे काम करता है, तो यहां कुछ अधिक पढ़ने योग्य संस्करण है:

^
(
    (?<a>1|2)
  | (?<b>2|3)
  | (?<c>3|4)
  | (?<d>4|1)
)
(
    (?<a-d>1) | (?<d-a>1)
  | (?<b-a>2) | (?<a-b>2)
  | (?<c-b>3) | (?<b-c>3)
  | (?<d-c>4) | (?<c-d>4)
)*
$

और यहाँ एक संकेत है:

1  a  2

d  O  b

4  c  3
— मार्टिन एंडर
स्रोत
6

MATL , 57 55 बाइट्स

1t_hjnZ^!t1tL3$)2_/wvG1)UGnl2$Ov+Ys.5tv3X53$Y+4X\G!U=Aa

यह वर्तमान रिलीज़ (10.2.1) का उपयोग करता है , जो इस चुनौती से पहले है।

संपादित करें (17 जनवरी, 2017): भाषा में परिवर्तन के कारण,v की जरूरत है द्वारा प्रतिस्थापित किया जा करने के लिए &v, और tL3$)से Y)(इसके अलावा, कुछ अन्य सुधार सकता है किया जाना)। निम्नलिखित लिंक में वे दो संशोधन शामिल हैं

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

व्याख्या

यह कोड गोल्फ के लिए मेरे दो पसंदीदा उपकरणों पर आधारित है: जानवर बल और दृढ़ संकल्प ।

कोड निर्देशांक के संदर्भ में क्रैंक द्वारा पीछा किए गए मार्ग को परिभाषित करता है 0.5, 1.5आदि प्रत्येक संख्या नोटों के बीच क्रैंक की स्थिति बताती है। कोड पहले सभी संभावित पथों के साथ एक पथ सरणी बनाता है जो इनपुट स्ट्रिंग के पहले नोट से शुरू होता है। प्रत्येक पथ इस सरणी में एक स्तंभ है। यह जानवर बल घटक है।

इस पथ सरणी से, एक नोट सरणी प्राप्त की जाती है, जहां प्रत्येक कॉलम खेला गया नोटों का एक वास्तविक अनुक्रम होता है। उदाहरण के लिए, नोट बनाने के 0.5लिए स्थिति से आवाजाही । यह पदों के बीच औसत लेने और फिर एक मॉडुलो 4 ऑपरेशन को लागू करने में शामिल है। प्रत्येक कॉलम के साथ रनिंग एवरेज को 2D कनवल्शन के साथ किया जाता है ।1.51

अंत में, प्रोग्राम यह जांचता है कि क्या नोट सरणी का कोई कॉलम इनपुट के साथ मेल खाता है।

1t_h        % row array [1, -1]
j           % input string
nZ^!        % Cartesian power of [1, -1] raised to N, where "N" is length of string
t           % duplicate
1tL3$)      % extract first row
2_/         % divide by -2
wv          % attach that modified row to the top of Cartesian power array
G1)U        % first character of input string converted to number, "x"
Gnl2$O      % column array of N-1 zeros, where N is length of input
v           % concat vertically into column array [x;0;0...;0]
+           % add with singleton expansion
Ys          % cumulative sum along each column. Each column if this array is a path
.5tv        % column array [.5;.5]
3X5         % predefined string 'same' (for convolution)
3$Y+        % 2D convolution of path array with [.5;.5]
4X\         % modified modulo operation. This gives note array with values 1,2,3,4
G!U         % column array of input string characters converted to numbers
=Aa         % true if any column of the note array equals this
— लुइस मेंडो
स्रोत
5

पायथ, ४३

Km-R2sMdc`M%R4-VJjQTtJ`0|Fm!s-VKdCm_B^_1dlK

परीक्षण सूट

यह शायद बहुत गोल्फ है, और गोल्फ के लिए इष्टतम एल्गोरिथ्म भी नहीं है (मुझे उम्मीद है कि सभी रास्तों को कम करने की उम्मीद होगी?) ... वैसे भी, अगर आपको एल्गोरिथ्म के साथ कोई त्रुटि मिलती है तो कृपया मुझे बताएं, मुझे लगता है कि यह काम करना चाहिए लेकिन मुझे लगता है कि पहले गलत हो गया है!

मैं उदाहरण के इनपुट का उपयोग करके अपने एल्गोरिथ्म की व्याख्या करूँगा 1221। यह कार्यक्रम सबसे पहले अपने उत्तराधिकारियों के खिलाफ अंकों को मैप करता है, जैसे [[1,2],[2,2],[2,1]]:। तब उन्हें अपने अंतर मॉड 4मिलते हैं (पायथ को वह परिणाम मिलता है जो सही तर्क के संकेत से मेल खाता है %, इसलिए यह हमेशा सकारात्मक होता है) [3,0,1]:। फिर परिणाम विभाजित होते हैं 0और उनमें 2से प्रत्येक से घटाया जाता है [[1],[-1]]:।

अब जब सेटअप किया जाता है, तो हम पहले से परिणामी सरणी के समान लंबाई [-1,1,-1...]और उसकी नकार [1,-1,...]दोनों की सूची बनाते हैं । फिर, इन सूचियों में से प्रत्येक के लिए, सूची के तत्वों और पहले चरण में उत्पन्न सूची के बीच समुचित घटाव का प्रदर्शन करें। फिर, यदि परिणामों में से किसी में भी केवल खाली सूची होती है, तो हम सही उत्पादन करते हैं।

— FryAmTheEggman
स्रोत
"परिणाम 0 पर विभाजित हैं" से आपका क्या मतलब है? विशेष रूप से, आपको क्या मिलेगा 1221221और 1221441?
— नील
1
@ नील 1221221गलत है और 1221441समग्र रूप से सही है, लेकिन अगर मुझे समझ में आ रहा है कि एल्गोरिथ्म में उस कदम के बाद आप परिणाम चाहते हैं? से: अगर ऐसी बात यह देता है [3, 0, 1, 3, 0, 1]करने के लिए [[3], [1, 3], [1]]और [3, 0, 1, 1, 0, 3]करने के लिए [[3], [1, 1], [3]]। मुझे बताएं कि क्या आप चाहते हैं कि कुछ और समझाया जाए :)
— FryAmTheEggman
मुझे लगता है कि मैं पहले की तुलना में अधिक भ्रमित हूं, इसलिए क्या आप यह समझने के लिए कि (सही) परिणाम प्राप्त किए गए हैं, कृपया उन दो उदाहरणों को समाप्त कर सकते हैं?
— नील
1
@ निल श्योर, नो प्रॉब्लम :) वहाँ से, हम प्राप्त करने के लिए घटाव करते हैं: [[1], [-1, 1], [-1]]और [[1], [-1, -1], [1]]यहाँ से, आप देख सकते हैं कि पहले वाले के पास सूचियाँ नहीं हैं, जबकि दूसरी सूची के बीच -1और 1दूसरी सूची में अंतिम परिणाम देते हैं। एल्गोरिथ्म थोड़ा सा ऑब्सट्यूज़ है, लेकिन यह मूल रूप से मैपिंग दिशा बदल जाता है 0और दिशा बदल जाती है +/-1, फिर जाँच करता है कि कोई छलांग नहीं लगाई गई है और दिशाएं समझ में आती हैं।
— FryAmTheEggman 22
ओह, इसलिए बिट मुझे याद आ रहा था कि प्रत्येक विभाजन सूची में समान मूल्य होना चाहिए, और उन मूल्यों को वैकल्पिक होना चाहिए। धन्यवाद!
— नील
4

मतलाब, 279 180 बाइट्स

o=eye(4);a=input('')-'0';M=[o,o(:,[4,1:3]);o(:,[2:4,1:4,1])];x=2;for p=[a(1),mod(a(1),4)+1];for k=a;i=find(M*[o(:,k);o(:,p)]>1);if i;p=mod(i-1,4)+1;else;x=x-1;break;end;end;end;x>0

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

विस्तारित और समझाया गया स्रोत:

o=eye(4);
a=input('')-'0';

% encoding of plucker/notes
%      1
%   1     2
%4           2
%   4     3
%      3
%

M=[...
%12 3 4 1 2 3 4 <
1,0,0,0,0,1,0,0; %1  k = current note
0,1,0,0,0,0,1,0; %2  
0,0,1,0,0,0,0,1; %3  
0,0,0,1,1,0,0,0; %4  
0,0,0,1,0,0,0,1; %1  p = current position of plucker
1,0,0,0,1,0,0,0; %2
0,1,0,0,0,1,0,0; %3
0,0,1,0,0,0,1,0];%4
% the vector we multiply with this matrix has following structure,
% the k-th and the p+4 th entries are 1, the rest 0
% when we multiply this vecotr with this matrix, we get a vector with an
% entry of value 2 IF this is a valid move ( mod(positionOfThe2 -1,4)+1 is
% the position of the plucker now)
% or only entries less than 2 it is impossible
x=2;  %number of "chances" to get it right
for p=[a(1),mod(a(1),4)+1] %check both starting values;
    for k=a;                %loop throu the notes
        size(M);

        c = M * [o(:,k);o(:,p)];
        i=find(c>1);               %did we find a 2?
        if i;
           p=mod(i-1,4)+1;         %if yes, valid move
        else;
            x=x-1;                 %if no, invalid, 
            break;
        end 
    end
end
x=x>0 %if we failed more than once, it is not possible
— flawr
स्रोत
4

ईएस 6, 104 100 बाइट्स

s=>!/13|24|31|42|3[24]{2}1|4[13]{2}2|1[24]{2}3|2[13]{2}4|(.).\1/.test(s.replace(/(.)(\1\1)+/g,"$1"))

संपादित करें: @DigitalTrauma के लिए धन्यवाद 4 बाइट्स सहेजे गए।

यह एक पूर्ण पुनर्लेखन है क्योंकि मेरा पिछला दृष्टिकोण त्रुटिपूर्ण था।

मैं अंकों के सभी रन को 1 या 2 तक कम करके शुरू करता हूं जो इस बात पर निर्भर करता है कि रन में कोई विषम या समान संख्या थी। मैं तब सभी अवैध संयोजनों की तलाश में हूं:

  • 13|24|31|42 (विपरीत दिशाए)
  • 3[24]{2}1के रूप में 3221और 3441अवैध हैं
  • इसी तरह के लिए 4xx2, 1xx3और 2xx4जहां xलापता अंकों में से एक है
  • (.).\1जैसे कि चीजें 121अवैध हैं ( 111पहले से कम हो गई हैं 1)

यदि कोई अवैध जोड़े या "ट्रिपल" नहीं हैं, तो पूरी स्ट्रिंग कानूनी है (प्रेरण द्वारा प्रमाण एक अभ्यास के रूप में छोड़ दिया जाता है क्योंकि यह देर रात होता है)।

मैंने 3[24]{2}1|1[24]{2}3एक नकारात्मक रूपांतर परख का उपयोग करके सरल बनाने की कोशिश की लेकिन यह उस तरह से लंबा हो गया।

— नील
स्रोत
f("1122") => true@ डिजीटलत्रुमा
— कॉनर ओ'ब्रायन
@ C @O'Bʀɪᴇɴ मैं इसके साथ कुछ भी गलत नहीं देखता। दूसरी ओर मैंने महसूस किया है कि f("1221221")गलत उत्तर का उत्पादन होता है, इसलिए मुझे पुनर्विचार करना होगा।
— नील
टेस्ट सूट को शामिल करना अच्छा है, '43221' विफल: jsbin.com/vafitotequ/1/edit?js,console
— Pavlo
@ पाब्लो व्हाट्स, मैं गॉल्फ [24][24]कर (2|4)\1रहा था, लेकिन मैंने पर्याप्त रूप से परीक्षण नहीं किया था। उसके लिए माफ़ करना।
— नील
आप गोल्फ कर सकते हैं [24][24]करने के लिए [24]{2}?
— डिजिटल ट्रॉमा
2

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

s=>[r=0,1,2,3].map(i=>[...s].map(n=>n-1-i%4?n%4-i%4?v=0:i+=3:i++,v=1)|v?r=1:0)|r

व्याख्या

i%4 वर्तमान क्रैंक स्थिति है:

    1 (i%4 == 1) 2   

(i%4 == 0) (i%4 == 2)

    4 (i%4 == 3) 3

इंडेंट किया और टिप्पणी की

s=>
  [r=0,1,2,3].map(i=> // i = crank position, test for i starting at 0 to 3, r = result
    [...s].map(n=>    // for each note n
      n-1-i%4?        // if n is not at the position after i
        n%4-i%4?      // if n is not at the position before i
          v=0         // set the result of this test to invalid
        :i+=3         // else i-- (+3 used because i%4 would break for negative values)
      :i++,           // else i++
      v=1             // v = result of test, initialise to 1 (valid)
    )
    |v?r=1:0          // if the test returned true, set the result to true
  )
  |r                  // return the result

परीक्षा

var solution = s=>[r=0,1,2,3].map(i=>[...s].map(n=>n-1-i%4?n%4-i%4?v=0:i+=3:i++,v=1)|v?r=1:0)|r
<input type="text" value="1221441" oninput="result.textContent=solution(this.value)" />
<pre id="result"></pre>
स्निपेट का विस्तार करें

— user81655
स्रोत
अच्छी तरह से किया। क्या आप बताएंगे कि |इस मामले में कैसे काम करता है?
— पावलो
1
@ पावलो धन्यवाद। यह लिखने का एक छोटा तरीका है (x.map(...),v)। यह काम करता है क्योंकि वह सरणी जो mapरिटर्न देता है 0और 0|v == v।
— user81655
2

लुआ , 146 142 108 162 159 149 144 135 132 118 113 बाइट्स

z,q,s=0,0,io.read()for i in s:gmatch'.'do t=i-z if 2==math.abs(t)or t==q then return''end q=-t z=i end return 2>1

सही और गलत दिए गए 1 और 4 के बीच संख्याओं की एक स्ट्रिंग दी गई है (कोई डेटा नहीं या श्रेणी संख्या से बाहर नहीं है।

बस ट्रैक करता है कि अंतिम आंदोलन क्या था और यह जांचता है कि क्या यह आंदोलन पिछले आंदोलन (आईई, 121 या 12221) का उलटा है या यदि दूरी बढ़ाना संभव से अधिक है।

संपादित करें 1 :

बची 6 बाइट। मैं भूल गया कि if (int) thenअगर इंट्री नॉन जीरो है तो सच है

इस प्रकार:

if t~=0 then

में परिवर्तन:

if t then

पुनर्गठन करके कुछ बाइट्स भी बचाए।

संपादित करें 2 :

मैं धीरे-धीरे यह पता लगा रहा हूं। मैं यहाँ दस्तावेज़ीकरण पढ़ रहा हूँ: http://www.lua.org/pil/ और गोल्फ के लिए अधिक उपयोगी पृष्ठों में से एक http://www.lua.org/pil/3.3.html है

विशेष रूप से, यह बहुत मददगार है:

नियंत्रण संरचनाओं की तरह, सभी तार्किक ऑपरेटर झूठे और शून्य को गलत मानते हैं और कुछ भी सच।

मेरे लिए इसका मतलब यह है कि मैं आगे जा सकता हूं और क्यू के लिए अपनी घोषणा को हटा सकता हूं ( जो शुरू में 0 पर सेट था ) क्योंकि इसे सेट होने तक "झूठा" माना जाएगा। इसलिए मैं इसके माध्यम से कुछ और बाइट्स बचाता हूं।

एक और बात ध्यान देने योग्य है, हालांकि मैं इसका उपयोग नहीं करता हूं, अगर आप लुआ में मूल्यों को स्वैप करना चाहते हैं, तो आप बस a,b=b,a एक अस्थायी चर की आवश्यकता के बिना कर सकते हैं ।

EDIT 3

इसलिए, कुछ चतुर पुनर्निर्माण के साथ-साथ एक नए कार्य के माध्यम से, मैंने बाइट को 9 और नीचे गिना है।

इनपुट प्राप्त करने के लिए सर्वश्रेष्ठ मोड

यदि आपको संख्याओं की सूची में पढ़ने और एक बार में उन पर संचालन करने की आवश्यकता है, तो आप उपयोग कर सकते हैं:

for x in string:gmatch('.') do
    print(x) --This is our number
end

स्ट्रिंग का उपयोग करके अपने विकल्प की तुलना करने पर: उप, आप गोल्फ (या सामान्य उपयोग) के लिए मूल्य देख सकते हैं:

for x=1,string:len() do
    print(string:sub(x,x)) --This is our number
end

पुनर्गठन कार्य या स्ट्रिंग्स

दूसरी बात, यदि आपके पास एक पंक्ति में कई घोषणाएँ हैं और मूल्यों में से एक एक फ़ंक्शन है या आपकी एक शर्त है जिसमें आप किसी संख्या की तुलना इन जैसे फ़ंक्शन के परिणाम से करते हैं:

x,y,z=io.read(),0,0 print('test')

if math.abs(x)==2 then

इसे पुनर्गठन करके ताकि समापन कोष्ठक स्थिति या घोषणा में अंतिम चरित्र हो, आप एक चरित्र को काट सकते हैं जैसे:

y,z,x=0,0,io.read()print('test') --Notice no space

if 2==math.abs(x)then --If we put the '2' first in the conditional statement, we can now remove a space character

रिटर्न की शर्तें जो 'ट्रू' या 'गलत' के बजाय ट्रू या फाल्स के बराबर होती हैं

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

उदाहरण के लिए, तुलना करें:

return true
return false

सेवा:

return 2>1
return 1>2
— Skyl3r
स्रोत
121झूठा उत्पादन करना चाहिए।
— २०
आह बुरा न मानें। समझा। जल्द ही ठीक हो जाएगा
— Skyl3r
यदि आप उन्हें पहले से ही वहाँ सूचीबद्ध नहीं देखते हैं, तो आप Lua में गोल्फिंग के लिए उन Lua सुझावों में से कुछ को जोड़ने में रुचि हो सकती है ।
— अप्सिलर्स
2

MATL, 49 बाइट्स (गैर-प्रतिस्पर्धात्मक 1 )

1. उत्तर (ab) MATL के नए संस्करणों के कम सख्त अनुक्रमण का उपयोग करता है, और इस चुनौती को पोस्ट किए जाने के समय काम नहीं किया होगा।

dt~aX`tt~f1)q:)w3MQJh)_ht~a]tT-3hX|n2=wT_3hX|n2=+

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

मैंने बेस्ट ऑफ़ पीपीसीजी 2016 में इस चुनौती को देखा , और लगा कि यह मेरे पसंदीदा ऑपरेटर का उपयोग कर सकता है :

d

या, diffMATLAB / ऑक्टेव में (मैं अपने स्पष्टीकरण में MATLAB / ऑक्टेव शब्दावली का स्वतंत्र रूप से उपयोग करूंगा, क्योंकि यह मनुष्यों के लिए पढ़ना आसान है)। यह कमांड एक वेक्टर में तत्व-वार अंतर की गणना करता है या, इस मामले में, एक वर्ण सरणी में।

इस समस्या के लिए, मतभेद एक दिलचस्प पैटर्न प्रदर्शित करते हैं। ध्यान दें कि

दिशा में परिवर्तन का मतलब यह होना चाहिए कि एक नोट दो बार खेला जाता है ।

अंतर पैटर्न के लिए ( 1-4अब के लिए संक्रमण की अनदेखी ), इसका मतलब है कि

साइन इन करने के लिए बीच में शून्य की diff(input)एक विषम संख्या होनी चाहिए । इसके विपरीत, साइन को शून्य संख्या के बाद भी बदलने की अनुमति नहीं है ।

मैंने इसे पहले प्रत्येक शून्य के लिए, प्रत्येक सरणी के लिए लागू किया। मैं शून्य को ट्रिम करता हूं, और इसके बाद सभी तत्वों को गुणा करता हूं -1। अंतिम परिणाम के लिए, इसका मतलब है कि सभी तत्वों का एक ही संकेत होना चाहिए । बेशक, -3बराबरी का छोटा मुद्दा है +1, और 2सामान्य रूप से अस्वीकृत किया जा रहा है। मैंने इसे परिणाम के सेट यूनियन के साथ ले जाकर हल किया [1 -3], और जांच की कि क्या यह आकार 2 का है (यानी, कोई भी अस्वीकृत तत्व 'संघ के माध्यम से सेट में प्रवेश नहीं किया है')। के लिए दोहराएं [-1 3], और जांचें कि या तो (या दोनों, 1-लंबाई इनपुट के मामले में) सत्य है।

d                                % Difference of input
 t~a                             % Check if any element equals 0
    X`                     t~a]  % Start while loop, ending in the same check
       t~                           % Get a new vector, logical negated to find zeroes.
          f1)                       % Find the position of the first zero. 
      t         q:)                 % Decrement by 1, to index all elements before that zero.
                   w3MQJh)          % Push the result of 'find', but increment to get all elements after.
                         _h         % Multiply the second half by -1, and concatenate horizontally.

  T-3hX|n2=                      % Check if set union with [1 -3] is size 2
 t        wT_3hX|n2=             % Check if set union with [-1 3] is size 2
                    +            % Logical OR.
— Sanchises
स्रोत
@LuisMendo धन्यवाद। मुझे वास्तव में पढ़ने की जरूरत है M, पिछली बार जब मैंने इसकी कोशिश की थी, तो यह उम्मीद से अलग काम किया था इसलिए मैंने इसे समय के लिए नजरअंदाज कर दिया। क्या यह कहना सही है कि इसे करने की आवश्यकता है 3Mक्योंकि तब मुझे इनपुट नहीं मिलता है ), :लेकिन नहीं q(स्किप करना wक्योंकि यह एक सामान्य फ़ंक्शन नहीं है )?
— 1919
हाँ बिल्कुल। wछोड़ दिया जाता है क्योंकि यह एक सामान्य कार्य नहीं है। सामान्य कार्य जो कोई इनपुट नहीं लेते हैं उन्हें भी छोड़ दिया जाएगा
— लुइस मेंडो
2

पायथन (3.5) 160 151 150 बाइट्स

एक पुनरावर्ती समाधान

def f(s):g=lambda s,c:s==''or g(s[1:],(c[:4]*2)[(s[0]==c[0])*2+1:])if s==''or s[0]in c[:2]else 0;return any([g(s,"1234123"[i:])for i in range(4)])

लंबोदर के बिना अधूरा

def f(s):
    def g(s,c):
        if s=='' or s[0] in c[:2] :
            return s=='' or g(s[1:],(c[:4]*2)[(s[0]==c[0])*2+1:])
        else:
            return False
    return any([g(s,"1234123"[i:]) for i in range(4)])

मैं क्रैंक के बजाय सभी बॉक्स को घुमाता हूं। क्रैंक स्थिति सी स्ट्रिंग के पहले और दूसरे चरित्र के बीच है। मुझे क्रैंक की सभी शुरुआती स्थिति का परीक्षण करने की आवश्यकता है।

स्ट्रिंग को घुमाने के लिए ट्रिक का उपयोग

अजगर ( s[i:]+s[:i]) में एक स्ट्रिंग को घुमाने का सामान्य तरीका भी सूचकांक और स्ट्रिंग दोनों को दोहराने की आवश्यकता है। इस मामले में मैं स्ट्रिंग और फसल पहले पात्रों की नकल।

(c*2)                        # duplicate the string
     [(s[0]==c[0])*2+1       # test that return 1 if firsts characters match 3 instead 
                      :]     
                        [:4] # crop again to have a 4 characters string

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

[f(i) for i in ["1", "1234", "1221", "3333", "143332", "22234", "2234", "22214", "1221441", "41233", "13", "1224", "121", "12221", "43221"]]
[True, True, True, True, True, True, True, True, True, True, False, False, False, False, False]
— एर्वान
स्रोत
1
आप पर स्थान हटा सकते हैं 3"[i:]) for।
— आउटगोल्फर
@EriktheOutgolfer धन्यवाद मैं इसे हटा देता हूं।
— इरवान २
1

जावास्क्रिप्ट (ES2015), 110 95

p=(s,d)=>(h=s[0],t=s.slice(1),g=t[0],!g||(d?g==h?p(t,-d):g%4==(h-d)%4&&p(t,d):p(s,1)||p(s,-1)))

नील द्वारा बचाया गया 15 बाइट्स! मूल संस्करण ungolfed:

p = (s, d) => {
  h = s[0]
  t = s.substr(1)

  if (!t[0]) return true
  if (!d) return p(s, 1) || p(s, -1)
  if (t[0] == h) return p(t, d*-1)
  if (t[0] == (h-d > 4 ? 1 : h-d || 4)) return p(t, d)

  return false
}

टेस्ट: https://jsbin.com/cuqicajuko/1/edit?js,console

— पाव्लो
स्रोत
1
आपको 17 बाइट्स बचाए:(s,d)=>(h=s[0],t=s.slice(1),g=t[0],!g||(d?g==h?p(t,-d):g%4==(h-d)%4&&p(t,d):p(s,1)||p(s,-1)))
— नील
हालांकि अभी भी @ user81655 के उत्तर के रूप में छोटा नहीं है।
— नील
1

ट्यूरिंग मशीन कोड, 395 बाइट्स

0 1 _ r a
0 2 _ r b
0 3 _ r c
0 4 _ r d
a 1 _ r a
a 2 _ r E
a 3 _ r h
a 4 _ r S
b 1 _ r W
b 2 _ r b
b 3 _ r S
b 4 _ r h
c 1 _ r h
c 2 _ r N
c 3 _ r c
c 4 _ r W
d 1 _ r N
d 2 _ r h
d 3 _ r E
d 4 _ r d
N 1 _ r W
N 2 _ r E
N _ _ r r
N * _ r h
E 2 _ r N
E 3 _ r S
E _ _ r r
E * _ r h
S 3 _ r E
S 4 _ r W
S _ _ r r
S * _ r h
W 4 _ r S
W 1 _ r N
W _ _ r r
W * _ r h
h _ 0 r halt
h * _ r h
r _ 1 r halt

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

यह मूल रूप से एक राज्य-आधारित दृष्टिकोण है:

  • प्रारंभिक अवस्था 0 है।
  • a, b, c, और d"दुविधा में पड़ा हुआ राज्यों" है कि केवल शुरुआत में पाए जाते हैं
  • N, E, S, और W"का फैसला राज्यों", जाहिर है के लिए खड़े हैं Nत्तर, East, South, और Wअनु।
— लीक नन
स्रोत
1

थू, 203 बाइट्स

मैं इस बारे में नहीं सोच सकता कि यह कैसे आगे बढ़े।

0::=:::
>11::=>1
>22::=>2
>33::=>3
>44::=>4
>12::=b
>21::=d
>14::=c
>41::=a
>23::=c
>32::=a
>34::=d
>43::=b
a1::=d
a2::=b
b2::=a
b3::=c
c3::=b
c4::=d
d4::=c
d1::=a
a<::=~n
b<::=~e
c<::=~s
d<::=~w
::=
>0<

यदि नोट अनुक्रम संभव है, तो आउटपुट समाप्ति दिशा होगी, अन्यथा आउटपुट खाली हो जाएगा।

— MegaTom
स्रोत
1

प्रोलोग (एसडब्ल्यूआई) , 117 बाइट्स

a(N,P):-P=N;N=1,P=4,!;P is N-1.
m([A,B|C],[X,Y|Z]):-a(A,X),a(B,X),a(B,Y),X\=Y,m([B|C],[Y|Z]).
m([_],_).
p(N):-m(N,_).

एक विधेय को परिभाषित करता है pजो खेलने योग्य आदानों (पूर्णांक की सूची के रूप में दिया गया) पर सफल होता है और अचूक लोगों पर विफल होता है। इसे ऑनलाइन आज़माएं!

व्याख्या

aनोट Nऔर क्रैंक स्थिति के बीच एक आसन्न संबंध को परिभाषित करता है P। हम स्थिति को परिभाषित पी नोट्स के बीच होने का पी और पी + 1 । इस प्रकार, एक स्थिति Nइफ नोट करने के लिए आसन्न है

  • यह बराबर है N( P=N); या
  • नोट 1 है और स्थिति 4 है ( N=1,P=4); या
  • उपरोक्त मामला सत्य नहीं है ( !) और स्थिति बराबर है N-1( P is N-1)।

mनोटों की एक सूची लेता है और उन पदों की सूची बनाने की कोशिश करता है जो उन नोटों को खेलेंगे। Aक्या नोट सिर्फ बजाया जाता है, Bक्या बजाया जाने वाला नोट है; Xवर्तमान क्रैंक स्थिति Yहै, अगली क्रैंक स्थिति है। एक कदम iff मान्य है

  • नोट जो अभी खेला गया है वह वर्तमान क्रैंक स्थिति ( a(A,X)) के निकट है ;
  • खेला जाने वाला नोट वर्तमान क्रैंक स्थिति ( a(B,X)) के निकट है ;
  • खेला जाने वाला नोट अगले क्रैंक स्थिति ( a(B,Y)) के निकट है ; तथा
  • दो क्रैंक स्थिति समान नहीं हैं ( X\=Y)।

यदि ये सभी धारण करते हैं, तो पुनरावृत्ति करते हैं। यदि हम सफलतापूर्वक किसी एक नोट ( m([_],_)) के लिए नीचे आते हैं , तो नोटों का अनुक्रम खेलने योग्य है।

इस सवाल के लिए, हम केवल इस बात की परवाह करते हैं कि चालों का एक क्रम मौजूद है, इसलिए हम क्रैंक पदों की उत्पन्न सूची pको कॉल करने mऔर छोड़ने के लिए परिभाषित करते हैं।

एक ungolfed संस्करण देखें और सभी परीक्षण मामलों को यहां सत्यापित करें ।

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