एक प्रेस की गणना करने में मदद करें

28

pannenkoek2012 का लक्ष्य सुपर मारियो 64 को ए बटन के जितना संभव हो उतना कम प्रेस के साथ पूरा करना है , जिससे मारियो कूदता है। प्रत्येक "ए प्रेस" में तीन भाग होते हैं:

  • बटन दबा रहा है
  • किसी भी लम्बाई के लिए इसे धारण करना
  • इसे जारी करना

Pannenkoek2012 द्वारा एक प्रेस के कुछ हिस्सों, वीडियो से

एक महान स्पष्टीकरण के लिए इस वीडियो (1:15 - 3:23) को देखें जिसमें उपरोक्त छवि शामिल है। (हालांकि, यह चुनौती आधा-ए-प्रेस शब्दावली का उपयोग नहीं करेगी और उन बाधाओं को प्रस्तुत करेगी जिन्हें ए जारी करने की आवश्यकता है)

कार्य:

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

औपचारिक रूप से कहा गया है: वर्णों का एक स्ट्रिंग S दिया PHRजाता है, (PH*R)*उस स्ट्रिंग के रूप पर विचार करें जिसमें S बाद में हो, और Pऐसी स्ट्रिंग में सबसे छोटी संख्या संभव है । या, वैकल्पिक रूप से, उस रूप की सबसे छोटी संख्या ज्ञात करें P?H*R?जिसे S में विभाजित किया जा सकता है।

उदाहरण

आइए इनपुट को देखें RHRPHHHR। ए बटन शुरू नहीं होता है, इसलिए प्रारंभिक बाधा पर काबू पाने के Rलिए बटन को दबाया जाना चाहिए और फिर जारी किया जाना चाहिए (# 1 दबाएं)। अगला हमें बटन पकड़ना होगा H, जिसके लिए फिर से पहले इसे दबाया जाना चाहिए (# 2 दबाएं)। फिर, इसके Rबाद इसे संतुष्ट करने के लिए बाद में जारी किया जा सकता है। अंत में, शेष PHHHRको एक प्रेस (प्रेस # 3) द्वारा संतुष्ट किया जा सकता है , उसके बाद पकड़े HHHऔर जारी किया जा सकता है R। तो, आउटपुट काउंट 3 है।

इसे देखने का दूसरा तरीका यह है कि हम इनपुट स्ट्रिंग को प्रपत्र के 3 भागों में विभाजित कर सकते हैं PHH..HHRजहाँ अक्षरों को छोड़ा जा सकता है।

R
HR
PHHHR

इनपुट प्रारूप

इनपुट आपकी पसंद के रूप में प्रेस, होल्ड और रिलीज़ करने वाले तत्वों की एक सूची या स्ट्रिंग होगी:

  • P, H, R
  • p, h, r
  • 1, 2, 3
  • 0, 1, 2

दिए गए क्रम में मिलान किया गया। इनपुट खाली नहीं होगा।

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

P 1
H 1
R 1
HP 2
RHP 3
HHR 1
PHRH 2
RHRPHHHR 3
HHHHHH 1
PPRRHHPP 6
HPPRHRPRHPPRHPPHRP 12
PRHRHPHHPRRRHPPRHHPPRRRHRHPRPHPRPRHHRPPPRHPRP 28

लीडरबोर्ड:

कोड स्निपेट दिखाएं

code-golf  sequence  subsequence 
— XNOR
स्रोत
1
ए बटन को आयोजित नहीं करने के लिए आवश्यक बाधाओं के बारे में क्या? ग्राफ में चार बटन स्टेट्स हैं (मुझे लगता है कि ये वास्तव में गेम में भी मौजूद हो सकते हैं)
— रैंडम 832
3
वास्तव में, 3 राज्य हैं: प्रेस, हेल्ड और नॉट-आयोजित। किसी भी राज्य को A बटन रिलीज़ की आवश्यकता नहीं है। वास्तविकता की तुलना में चुनौती थोड़ी गलत है।
— user202729
1
@ 11684 "रिलीज के लिए, ठीक है, वर्तमान में ऐसा कोई मामला नहीं है जहां यह उपयोगी या महत्वपूर्ण हो, ताकि उस हिस्से के बारे में चिंता न करें।" (1:48 - 1:52)
— user202729
3
MIPS विधानसभा में कोई भी ऐसा करना चाहता है? (भाषा सुपर मारियो 64 का उपयोग करती थी)
— user202729
1
@ user202729 वाह, यह एक पूरी तरह से पैनकेक है। धन्यवाद!
— 15:68 पर 11684

जवाबों:

3

पायथ , 13 बाइट्स

tl:z"P?H*R?"3

यहाँ कोशिश करो! या सभी परीक्षण मामलों को सत्यापित करें।

ध्यान दें कि के 1स्थान पर भी काम करता है 3।

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

tl: z "P? H * R?" 3 | पूरा कार्यक्रम। STDIN से इनपुट लेता है, STDOUT को आउटपुट देता है।

  : z 3 | के मिलान पर इनपुट स्ट्रिंग को विभाजित करें ...
    'पी? एच * आर? " | नियमित अभिव्यक्ति "पी? एच * आर?"।
 एल | लंबाई प्राप्त करें।
टी | घटाव (क्योंकि बंटवारे में खाली स्ट्रिंग शामिल है)।

रेगेक्स के बारे में अधिक जानकारी:

पी? | पी - शाब्दिक चरित्र पी, मामला संवेदनशील।
       | ? - मात्रात्मक। पिछले चरित्र से एक या शून्य बार मेल खाता है।
  एच * | एच - शाब्दिक चरित्र एच, मामला संवेदनशील।
       | * - परिमाणक। पिछले चरित्र की घटनाओं की किसी भी संख्या से मेल खाता है।
    आर? | आर - शाब्दिक चरित्र आर, मामला संवेदनशील।
       | ? - मात्रात्मक। पिछले चरित्र से एक या शून्य बार मेल खाता है।
— श्री Xcoder
स्रोत
आह, फेक, तुम मुझे इसे हरा!
— झबरा
अच्छा! Regexp वर्णन में दूसरी से अंतिम पंक्ति को "शाब्दिक चरित्र आर" कहना चाहिए, है ना?
— vidstige
@vidstige हाँ, धन्यवाद। फिक्स्ड
— श्री Xcoder
2

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

o5ḄƝ%⁵>4S‘

एक सूची ( P,H,R : 0,1,2विकल्प) लेने और एक पूर्णांक, गिनती वापस लेने वाली एक मौद्रिक श्रृंखला ।

इसे ऑनलाइन आज़माएं! या परीक्षण-सूट देखें

कैसे?

(प्रभावी रूप से सभी आसन्न जोड़े तो किसी भी है कि "निरंतरता जोड़े" नहीं हैं गिनती हो रही द्वारा काम करता है PR, PH, HR, या HH) और एक जोड़ने।

o5ḄƝ%⁵>4S‘ - Link: list of integers (in [0,1,2])  e.g.: [0,0,1,0,2,1,1,2,2,0] (representing PPHPRHHRRP)
o5         - logical OR with 5                          [5,5,1,5,2,1,1,2,2,5]
   Ɲ       - for all adjacent pairs:              i.e.: [5,5],[5,1],[1,5],[5,2],[2,1],[1,1],[1,2],[2,2],[2,5]
  Ḅ        -   convert from binary                      [ 15 ,  11 ,  7  ,  12 ,  5  ,  3  ,  4  ,  6  ,  9 ]
     ⁵     - literal ten
    %      - modulo                                     [  5 ,   1 ,  7  ,   2,   5  ,  3  ,  4  ,  6  ,  9 ]
      >4   - greater than four?                         [  1 ,   0 ,  1  ,   0,   1  ,  0  ,  0  ,  1  ,  1 ]
        S  - sum                                        5
         ‘ - increment                                  6

पिछला 11 बाइट समाधान:

ḅ3Ɲạ3ḟ1,2L‘

इसे ऑनलाइन आज़माएं! या परीक्षण-सूट देखें

कैसे?

ऊपर की तरह काम करता है, लेकिन बिल्कुल अलग तरीके से ...

ḅ3Ɲạ3ḟ1,2L‘ - Link: list of integers (in [0,1,2])  e.g.: [0,0,1,0,2,1,1,2,2,0] (representing PPHPRHHRRP)
  Ɲ         - for all adjacent pairs:              i.e.: [0,0],[0,1],[1,0],[0,2],[2,1],[1,1],[1,2],[2,2],[2,0]
ḅ3          -   convert from base three                  [ 0  ,  1  ,  3  ,  2  ,  7  ,  4  ,  5  ,  8  ,  6 ]
   ạ3       - absolute difference with three             [ 3  ,  2  ,  0  ,  1  ,  4  ,  1  ,  2  ,  5  ,  3 ]
     ḟ1,2   - filter discard if in [1,2]                 [ 3        ,  0        ,  4              ,  5  ,  3 ]
         L  - length                                     5
          ‘ - increment                                  6

और दूसरा, फिर से काफी अलग:

+19*Ɲ%13ḂS‘

(प्रत्येक में 19 जोड़ें, फिर आसन्न जोड़े के लिए प्रतिपादक प्रदर्शन करते हैं, 13 से modulo, 2 से modulo, योग और एक जोड़ते हैं)।

— जोनाथन एलन
स्रोत
नई जेली जल्दी!
— user202729
2

बैच, 69 बाइट्स

@set/ab=2,n=0
@for %%b in (%*)do @set/an+=b/2^|!%%b,b=%%b
@echo %n%

इनपुट को 0-अनुक्रमित कमांड-लाइन मापदंडों की सूची के रूप में लेता है, लेकिन p, h, rयदि आप set /a p=0, h=1, r=2पहले टाइप करते हैं तो आप ऊपरी या निचले मामले में अक्षरों की एक सूची का उपयोग कर सकते हैं । स्पष्टीकरण: bअंतिम इनपुट ( 2जारी करने के लिए डिफ़ॉल्ट ) और nप्रेस की गिनती को बनाए रखता है । प्रत्येक इनपुट एक प्रेस जोड़ता है यदि अंतिम इनपुट एक रिलीज था या वर्तमान इनपुट एक प्रेस है।

— नील
स्रोत
ओह, setएक साथ कई चर सेट कर सकते हैं? जानने के लिए उपयोगी।
— user202729
1
@ user202729 set /aअंकगणितीय मूल्यांकन है, इसलिए जब तक आपके द्वारा सेट किए जाने वाले सभी चर संख्यात्मक होते हैं, आप असाइनमेंट अभिव्यक्तियों को संक्षिप्त करने के लिए बस अल्पविराम ऑपरेटर का उपयोग कर सकते हैं।
— नील
2

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

P-> 1 H-> 2 R-> 3 का उपयोग करता है

lambda a:sum(1/y|x/3for x,y in zip([3]+a,a))
— feersum
स्रोत
1

भूसी , 6 5 बाइट्स

Lġo&ε

इसे ऑनलाइन आज़माएं! इनपुट एक सूची है 0,1,2(TIO लिंक परीक्षण मामलों की आसान कॉपी-पेस्टिंग के लिए अक्षरों का उपयोग करता है)।

व्याख्या

मैं जोनाथन एलन के जेली उत्तर के रूप में एक ही सामान्य विचार का उपयोग करता हूं : "असंगत जोड़े" पीपी, एचपी, आरएच, आरआर और आरपी की घटनाओं पर विभाजित करें और परिणामी ब्लॉकों की गणना करें। 0,1,2 एन्कोडिंग में, ये जोड़े ठीक वही हैं जिनके बाएं तत्व 2 या सही तत्व 0 है।

Lġo&ε  Input is a list.
 ġ     Split between pairs that do not satisfy:
    ε  the left element is at most 1
  o&   and the right element is truthy.
L      Length.
— Zgarb
स्रोत
1

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

Pn1></µƝS‘

इसे ऑनलाइन आज़माएं! या टेस्ट सूट! ( चोरी जोनाथन से उधार ली गई।)

वैकल्पिक:

P=1=</µƝS‘

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

Pn1></µƝS‘ | Monadic chain.

      µƝ   | Map over each pair of "neighbours" (x, y) in the list.
P          | And check whether their product...
 n1        | ... 1 if it doesn't equal 1, 0 otherwise...
   >       | Is higher than?
    </     | The pair reduced by "Smaller than?". 1 if x < y, else 0.
        S  | Sum.
         ‘ | Add 1.

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

सेर्ड सिक्काहेयरिंग की मदद से 1 बाइट को बचाया।

ḅ3Ɲf⁽vḲD¤L‘

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

— श्री Xcoder
स्रोत
Aww, मैं पड़ोसियों को जल्दी इस्तेमाल करने का मौका चूक गया :(
— caird coinheringaahing
आप निकाल सकते हैं μसे तीसरे एक
— Caird coinheringaahing
1

कोटलिन , 36 बाइट्स

Regex("P?H*R?").findAll(i).count()-1

सजा हुआ

Regex("P?H*R?").findAll(i).count()-1

परीक्षा

fun f(i:String) =
Regex("P?H*R?").findAll(i).count()-1
data class Test(val input: String, val output: Int)

val TESTS = listOf(
        Test("P", 1),
        Test("H", 1),
        Test("R", 1),
        Test("HP", 2),
        Test("RHP", 3),
        Test("HHR", 1),
        Test("PHRH", 2),
        Test("RHRPHHHR", 3),
        Test("HHHHHH", 1),
        Test("PPRRHHPP", 6),
        Test("HPPRHRPRHPPRHPPHRP", 12),
        Test("PRHRHPHHPRRRHPPRHHPPRRRHRHPRPHPRPRHHRPPPRHPRP", 28)
)

fun main(args: Array<String>) {
    for ((input, expectded) in TESTS) {
        val actual = f(input)
        if (actual != expectded) {
            throw AssertionError("$input $expectded $actual")
        }
    }
}

TIO

TryItOnline

— jrtapsell
स्रोत
0

जे , 18 17 बाइट्स

-1 @FrownyFrog को धन्यवाद

1+1#.}:(<+:1=*)}.

के रूप में इनपुट लेता है 0,1,2। टीआईओ पर सहायक कार्य परीक्षण मामलों को इस रूप में परिवर्तित करता है।

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

तुलनाओं का तर्क अभी भी गोल्फ हो सकता है। मैं अपने मस्तिष्क को गांठों में घुमा रहा हूं ताकि अधिक समतुल्य और छोटे बयानों के बारे में सोचा जा सके।

स्पष्टीकरण (पिछले समाधान)

1+1#.2(</+:1=*/)\]

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

1 + 1 #. 2 (</ +: 1 = */)\ ]
         2               \ ]  On infixes of 2 on the input
                  1 = */        Is the infix 1 1 (two holds)?
            </                  Is the infix x y such that x < y?
               +:               These results NORed
    1 #.                       Add all of the results together (debase to base 1)
1 +                            Add one

यह एक बहुत क्लीनर होगा अगर दो धारणों ने कुछ नहीं किया। कोड दो के infixes लेता है और जाँचता है कि क्या वे आरोही नहीं हैं और दो नहीं हैं। यदि यह मामला है, तो हम अपनी अंतिम गणना में एक जोड़ते हैं। हमें 1 से अंत तक जोड़ना है क्योंकि हम एक-दूसरे से अलग हैं (या आप _2 से अधिक मूल्य का या कोई भी मूल्य रोक सकते हैं )।

जिस तरह से यह जांचता है कि क्या इनफ़िक्स दो होल्ड है, दो मानों को एक साथ गुणा करके और यह देखने के लिए कि क्या यह एक है (दो होल्ड हैं 1 1)।

— गोभी
स्रोत
1
1+1#.}:(<+:1=*)}.एक छोटा है
— फ्रॉन्फ्रॉग में
@FrownyFrog चतुर, मैं उस में संपादित करेंगे।
— कोल
1
14:1+1#.0=}.*2-}:
— फ्रॉन्फ्रोग में
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.