गिनती की चाल 1D चलती है

31

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

उदाहरण के लिए, इस स्थिति से, 6 चाल संभव हैं:

.R..RRR.
  • पहला (सबसे बाईं ओर) रूक 1 स्थान को बाएं, या 1 या 2 स्थानों को दाएं (3 चालों) स्थानांतरित कर सकता है
  • अगला रूक केवल 1 या 2 रिक्त स्थान छोड़ सकता है (2 चालें)
  • तीसरा बदमाश बिलकुल नहीं चल सकता क्योंकि यह दो अन्य बदमाशों के बीच निचोड़ है (0 चाल)
  • अंतिम किश्ती केवल 1 स्थान दाएं चल सकती है (1 चाल)

ध्यान दें कि किसी भी स्थिति में कोई बदमाश नहीं हो सकता है, या कोई खाली स्थान नहीं हो सकता है।

इनपुट: बदमाशों और खाली स्थानों की एक गैर-रिक्त सूची (स्ट्रिंग, सरणी, आदि)। आप उन्हें True/ False, 1/ 0, 'R'/ '.', या अपनी पसंद के किसी भी दो लगातार अलग-अलग एकल-बाइट वर्ण या एक-अंकीय संख्या के रूप में दर्शा सकते हैं। यह आप पर निर्भर करता है कि किसका मतलब है रूक और जिसका मतलब है खाली जगह।

आउटपुट: एक गैर-नकारात्मक पूर्णांक। पूरे नंबर की झांकियां भी ठीक हैं।

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

आउटपुट बाईं ओर की संख्या है।

6 .R..RRR.
0 .
0 R
4 R..RR
3 ...R
8 ..R..R..
0 ......

अधिक परीक्षण मामलों के लिए, यहां लंबाई 5 तक सभी इनपुट हैं।

0 .
0 R
0 ..
1 .R
1 R.
0 RR
0 ...
2 ..R
2 .R.
1 .RR
2 R..
2 R.R
1 RR.
0 RRR
0 ....
3 ...R
3 ..R.
2 ..RR
3 .R..
3 .R.R
2 .RR.
1 .RRR
3 R...
4 R..R
3 R.R.
2 R.RR
2 RR..
2 RR.R
1 RRR.
0 RRRR
0 .....
4 ....R
4 ...R.
3 ...RR
4 ..R..
4 ..R.R
3 ..RR.
2 ..RRR
4 .R...
5 .R..R
4 .R.R.
3 .R.RR
3 .RR..
3 .RR.R
2 .RRR.
1 .RRRR
4 R....
6 R...R
5 R..R.
4 R..RR
4 R.R..
4 R.R.R
3 R.RR.
2 R.RRR
3 RR...
4 RR..R
3 RR.R.
2 RR.RR
2 RRR..
2 RRR.R
1 RRRR.
0 RRRRR
code-golf  counting  chess 
— XNOR
स्रोत

जवाबों:

9

रेटिना , 14 9 बाइट्स

w`_+R|R_+

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। _खाली जगह के लिए उपयोग करता है क्योंकि यह सबसे सुखद गैर-रेगेक्स चरित्र है। एक मान्य रूक चाल के अनुरूप सब्सट्रिंग की संख्या की गणना करके काम करता है। एक सबस्टेशन एक मान्य रूक चाल है यदि इसमें शुरुआत या अंत में कम से कम एक _प्लस एक है R।

— नील
स्रोत
ओह, आपने मूल रूप से यह पता लगा लिया था कि मैंने अपने उत्तर में जो उल्लेख किया है उसे कैसे करें। Idk क्यों मैं उस के बारे में नहीं सोचा था।
— mbomb007
9

पायथन 3 , 30 29 बाइट्स

lambda s:sum((s+s).strip())/9

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

-1 बाइट @JoKing की बदौलत

फ़ंक्शन इनपुट के रूप में पायथन बाइट स्ट्रिंग लेता है। प्रत्येक खाली स्थान को एक टैब के रूप में एन्कोड किया गया है और प्रत्येक रूक को बाइट b'\x00'मान के रूप में एन्कोड किया गया है 0।

lambda s:(s+s).strip().count(b'\t')कम बाइट की गिनती करते समय गणना बराबर होती है ।

— जोएल
स्रोत
6

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

5 बाइट्स @JoKing की बदौलत सहेजे गए

एक स्ट्रिंग के रूप में इनपुट लेता है। एक खाली वर्ग और किसी अन्य चरित्र के लिए एक स्थान की उम्मीद करता है।

s=>(s+s).trim().split` `.length-1

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

टिप्पणी की गई

s =>          // s = input, e.g. " R  RRR "
  (s + s)     // double -> " R  RRR  R  RRR "
  .trim()     // remove leading and trailing spaces -> "R  RRR  R  RRR"
  .split` `   // split on spaces -> [ 'R', '', 'RRR', '', 'R', '', 'RRR' ]
  .length - 1 // return the length - 1 -> 6

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

@Grimy के लिए 7 बाइट्स धन्यवाद सहेजे

lambda s:(s+s).strip().count(' ')

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

— Arnauld
स्रोत
1
पायथन संस्करण को countsplit
— ग्रिमी
@Grimy धन्यवाद। :)
— अरनुलड
3

रेटिना , 23 15 बाइट्स

बदमाशों के बीच रिक्त स्थान की संख्या को दोगुना करें, कम से कम एक बदमाश के साथ grep लाइनें, फिर रिक्त स्थान की संख्या की गणना करें।

R.+R
$0$0
G`R

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

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

मुझे उम्मीद थी कि मैं ओवरलैपिंग मैचों का उपयोग कर सकता हूं (?<=R.*) | (?=.*R), लेकिन ओवरलैप्स काफी आक्रामक नहीं हैं। उस पद्धति से सही परिणाम प्राप्त करने के लिए मैच को प्राप्त करने के सभी संभावित तरीकों को गिनना होगा।

— mbomb007
स्रोत
1
मदद .R.R.R.करने के लिए पहली पंक्ति को बदलने के लिए गलत परिणाम देने के लिए लगता है R.+R?
— नील
@Neil फिक्स्ड। धन्यवाद।
— mbomb007
2

जेली , 6 बाइट्स

t1;ḟẠS

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

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

व्याख्या

t1     | Trim 1s from end
  ;    | Concatenate to input
   ḟẠ  | Filter out 1s if all input were 1s, otherwise filter out 0s
     S | Sum
— निक केनेडी
स्रोत
2

जेली , 5 बाइट्स

ḲẈ+ƝS

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

-1 जोनाथन एलन को धन्यवाद ।

0एक किश्ती का 1प्रतिनिधित्व करते हैं , एक खाली जगह का प्रतिनिधित्व करते हैं।

— आउटगोल्फर को एरिक करें
स्रोत
1
यदि आप एक रूक के लिए एक स्पेस कैरेक्टर का उपयोग करते हैं और एक स्पेस के लिए दूसरा कैरेक्टर जो आप Ẉपांच पाने के लिए उपयोग कर सकते हैं :ḲẈ+ƝS
— जोनाथन एलन
@JonathanAllan LOL ने ऐसा नहीं सोचा था। और इससे पहले मैं इसके साथ प्रयोग कर रहा था Ẉलेकिन ṣ0इसके बजाय ...
— एरिक द आउटग्राफर
2

सी (क्लैंग) , 57 बाइट्स

i,r,o;g(*n,z){for(o=r=i=0;z--;i=-~i*!*n++)o+=*n?r=1,i:r;}

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

  • सहेजा गया 1 @ceilingcat को धन्यवाद

मुझे एहसास हुआ कि यह खाली सूचियों के लिए काम नहीं किया .. अब यह काम करता है! प्लस कुछ बाइट्स बचा लिया!

1 = किश्ती। 0 = अंतरिक्ष।

for (.. i + = n ++; - i: 1) // स्थान गिनता है या अतिरिक्त चालें रीसेट करता है => i = - ~ i ! * n ++ (@ceilingcat)

ओ + = * n r = 1, मैं: आर; // आउटपुट- (अतिरिक्त चालों) में जोड़ता है जब एक किश्ती को प्लस सेट -r- (रूक मेट) से मिला जाता है, -i- वेतन वृद्धि की सजा के लिए मंजूरी दे दी जाएगी।

हर जगह के लिए -r- (बदमाश की गारंटी से मुलाकात)

— AZTECCO
स्रोत
चट्टानों? क्या आपकी चट्टानें हिलती हैं?
— मस्त
1
@ मास्ट लोल सॉरी! संपादित
— AZTECCO
2

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

f s=sum$snd.span(>0)=<<[s,reverse s]

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

खाली जगह के लिए 1, किश्ती के लिए 0 का उपयोग करता है। 1 की संख्या को किसी के प्रारंभिक ब्लॉक में नहीं गिना जाता है, और उलटे हुए स्ट्रिंग के परिणाम में जोड़ देता है।

— XNOR
स्रोत
2

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

sum.(t.reverse<>t)
t=snd.span(>0)

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

बेनामी फ़ंक्शन जो 1s (रिक्त स्थान) और 0s (बदमाश) की सूची के रूप में इनपुट लेता है। यह सूची के प्रारंभ और अंत से रिक्त स्थान को विभाजित करता है, फिर सूची के दो संस्करणों को समाप्‍त करता है और उन्हें सम्‍मिलित करता है।

यह GHC 8.4.1 या बाद में <>इसे आयात किए बिना ऑपरेटर तक पहुँच प्राप्त करने के लिए उपयोग करता है।

— मजाक कर रहा है
स्रोत
1

जावा 11, 35 32 बाइट्स

s->(s+s).strip().chars().sum()/9

पोर्ट ऑफ @ जॉय का पायथन 3 उत्तर ।
-3 बाइट्स @ जोएल को भी धन्यवाद ।

रिक्त स्थान के \0लिए रूक और टैब ( \t) के लिए NULL- बाइट्स ( ) का उपयोग करता है ।

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

मैंने s->(s+s).trim().chars().sum()/9पहली बार 31-बटर के रूप में उपयोग करने की कोशिश की , लेकिन यह काम नहीं करता है क्योंकि String#trimबिलिन न केवल अग्रणी और अनुगामी रिक्त स्थान / टैब / न्यूलाइन्स को हटाता है, बल्कि अन्य सभी बाइट्स जो U+0020(यूनिकोड 32, एक स्थान) से छोटे या बराबर होते हैं ; , तो यह NULL-बाइट्स को भी हटा देगा .. मुझे नए जावा 11+ बिल्डिन (जो मैं भूल गया कि वे जोड़ा) के विकल्प के रूप में सिफारिश
करने के लिए जोएल को धन्यवाद । यह भी अनुगामी / अग्रणी भागों को हटाता है, लेकिन इस मामले में केवल व्हाट्सएप , इसलिए NULL-बाइट्स को बनाए रखा जाता है।String#strip

स्पष्टीकरण:

s->                              // Method with String as parameter & integer return-type
  (s+s)                          //  Concatenate the input to itself
       .strip()                  //  Then trim all leading and trailing tabs
               .chars().sum()    //  Sum the unicode values of the remaining characters
                             /9  //  And divide it by 9 to get the amount of remaining tabs
— केविन क्रूज़सेन
स्रोत
1
जावा 11+ String.strip()केवल व्हाट्सएप को हटाने की अनुमति देता है : 32 बाइट्स
— योएल
@ जोएल आह, उस एक के बारे में पूरी तरह से भूल गया! धन्यवाद। :)
— केविन क्रूज़सेन
1

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 27 बाइट्स

x=>(x+x).Trim().Sum(d=>d)/9

@Someone को बाइट धन्यवाद दिया

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

— अज्ञान का अवतार
स्रोत
1
Afaik आप एक बाइट (छोटा चारकोड) को बचाने के लिए टैब का उपयोग कर सकते हैं, लेकिन मैं एक फोन पर हूं।
— मेरा सर्वनाम
1

सी , 183 156 151 137 96 91 बाइट्स

91 बाइट्स के लिए सीलिंगकैट के लिए धन्यवाद।

c,e;char*z,b[9];main(d){for(gets(z=b);e=*z>81?c-=e*~!d,d=0:e+1,*++z;);printf("%i",d?:c+e);}

R एक किश्ती है, बाकी सब एक जगह है।

TIO

— girobuz
स्रोत
कुछ चीजें - एक फ़ंक्शन (एक पूर्ण कार्यक्रम के बजाय) की अनुमति है, आप अपरिभाषित व्यवहार (जैसे स्वचालित रूप से शून्यिंग) पर भरोसा कर सकते हैं जब तक कि आपका कार्यक्रम कम से कम एक कंपाइलर पर सही ढंग से काम करता है, यह 82इसके बजाय उपयोग करने के लिए छोटा है या 'R', यह छोटा है की e+e*dतुलना में e*(1+d), e=0,d=1;else e++; can be changed to ई = -1, डी = 1; ई ++; , and b [a] `और के b[++a]साथ बदला जा सकता है *bऔर*++b
— ASCII- केवल
0

x86-64 - 26 बाइट्स

इनपुट 32 बिट्स तक का एक सरणी है और एक पूर्णांक है जो वर्गों की संख्या का प्रतिनिधित्व करता है, 1 रोको का प्रतिनिधित्व करता है, 0 खाली का प्रतिनिधित्व करता है।

C4 E2 69 F7 C1       shlx        eax,ecx,edx
0B C1                or          eax,ecx  
F3 0F BC C8          tzcnt       ecx,eax  
D3 E8                shr         eax,cl  
F3 0F BD C8          lzcnt       ecx,eax  
F7 D0                not         eax  
F3 0F B8 C0          popcnt      eax,eax  
2B C1                sub         eax,ecx  
C3                   ret

बिट्स की प्रतिलिपि बनाता है ताकि इसे इसके बाईं ओर जोड़ा जाए और पीछे के शून्य बिट्स को हटा दिया जाए। फिर अग्रणी शून्य बिट्स की संख्या प्राप्त करता है और इसे शून्य बिट्स की कुल संख्या से घटाता है।

x86-64 मशीन कोड - 22 बाइट्स - नियमित लंबाई शतरंज रैंक केवल।

इनपुट एक 32-बिट पूर्णांक है जिसमें कम से कम महत्वपूर्ण बाइट है जो कि 8 बिट्स से बना है जो कि बदमाशों का प्रतिनिधित्व करता है। 1 एक बदमाश है, 0 खाली है।

8A E9                mov         ch,cl  
91                   xchg        eax,ecx
F3 0F BC C8          tzcnt       ecx,eax
D3 E8                shr         eax,cl 
F3 0F BD C8          lzcnt       ecx,eax
F7 D0                not         eax  
F3 0F B8 C0          popcnt      eax,eax
2B C1                sub         eax,ecx
C3                   ret

बिट्स को अगले महत्वपूर्ण बाइट में कॉपी करता है और पीछे के शून्य बिट्स को हटाता है। फिर अग्रणी शून्य बिट्स की संख्या प्राप्त करता है और इसे शून्य बिट्स की कुल संख्या से घटाता है।

— मुझे '
स्रोत
तो यह केवल लंबाई 8 की पंक्तियों के लिए काम करता है? यदि हां, तो यह चुनौती के लिए थोड़ा विशिष्ट है।
— ar4093
दुर्घटनावश यह माना गया कि वे नियमित रूप से बदमाश थे, जिन्हें अब ठीक कर लिया गया है।
— मुझे
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.