स्टैकेबल सीक्वेंस

29

आप एक समय में एक डेक से 0 से 9 तक लेबल वाले कार्ड बनाते हैं, जो 0 से शुरू होने वाले स्टैक बनाते हैं और 1 से गिनते हैं।

  • जब आप एक 0 सौदा करते हैं, तो आप एक नया स्टैक शुरू करने के लिए इसे टेबल पर रख देते हैं।
  • जब आप किसी अन्य कार्ड का सौदा करते हैं, तो आप इसे एक कार्ड के ऊपर रख देते हैं जो इसे कवर करते हुए मूल्य में बिल्कुल कम होता है। यदि ऐसा कोई कार्ड नहीं है, तो डेक स्टैकेबल नहीं है।

किसी डेक को देखते हुए, यह निर्धारित करें कि दिए गए क्रम में निपटाए जाने पर इसे स्टैक किया जा सकता है या नहीं। समान रूप से, अंकों की एक सूची दी गई है, यह तय करें कि क्या यह प्रपत्र के प्रत्येक बाद के विभाजन में विभाजित किया जा सकता है0,1,..,k

उदाहरण

डेक ले लो 0012312425। पहले दो कार्ड हैं 0, इसलिए वे टेबल पर जाते हैं:

Stacks: 00

  Deck: 12312425

अगला, हम एक सौदा करते हैं 1, जो एक पर जाता है, जो 0मायने नहीं रखता है:

        1
Stacks: 00

  Deck: 2312425

हम तो 2बस एक रखा सौदा 1, और इसके 3शीर्ष पर।

        3
        2
        1
Stacks: 00

  Deck: 12425

इसके बाद, पहले स्टैक के ऊपर 1, 2रखा गया और 4दूसरे को ऊपर रखा गया । 

        4
        3
        22
        11
Stacks: 00

  Deck: 25

अब, हम एक जगह की जरूरत है 2, लेकिन वहाँ कोई 1भी या तो ढेर है। इसलिए, यह डेक स्टैकेबल नहीं था।

इनपुट: अंकों की एक गैर-रिक्त सूची 0-9, या उनमें से एक स्ट्रिंग। आप यह नहीं मान सकते कि 0 हमेशा इनपुट में रहेगा।

आउटपुट : दो अलग-अलग संगत मूल्यों में से एक, स्टैकेबल अनुक्रमों के लिए एक और गैर-स्टैकेबल लोगों के लिए एक

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

stackable:

0
01
01234
00011122234567890
012031
0120304511627328390

ढेर लगाने लायक नहीं:

1
021
0001111
0012312425
012301210
000112223

सूची के लिए, सुविधा के लिए:

[0]
[0, 1]
[0, 1, 2, 3, 4]
[0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 4, 5, 6, 7, 8, 9, 0]
[0, 1, 2, 0, 3, 1]
[0, 1, 2, 0, 3, 0, 4, 5, 1, 1, 6, 2, 7, 3, 2, 8, 3, 9, 0]

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

समूहीकृत:

[[0], [0, 1], [0, 1, 2, 3, 4], [0, 0, 0, 1, 1, 1, 2, 2, 2, 3], [0, 1, 2, 0, 3, 1], [0, 1, 2, 0, 3, 0, 4, 5, 1, 1, 6, 2, 7, 3, 2, 8, 3, 9, 0]]
[[1], [0, 2, 1], [0, 0, 0, 1, 1, 1, 1], [0, 0, 1, 2, 3, 1, 2, 4, 2, 5]]

लीडरबोर्ड:

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

code-golf  sequence  decision-problem  subsequence 
— XNOR
स्रोत
क्या हम सूची की लंबाई पर एक सीमा मान सकते हैं?
— ऑरलैप
@orlp कोई स्पष्ट सीमा नहीं।
— 22
@xnor वह शायद int a[99]
— लीक
@LuisMendo आप कह सकते हैं, मैं "गैर-रिक्त" हूं।
— xnor
@ xnor आह, क्षमा करें, मैंने ऐसा नहीं देखा। क्या सरणी 1-आधारित हो सकती है? यही कारण है, नंबरों से 1करने के लिए10
— लुइस Mendo

जवाबों:

6

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

एक अनाम फ़ंक्शन पूर्णांक की सूची ले रहा है और एक लौटा रहा है Bool।

उपयोग: (all(<1).foldr(?)[]) [0,1,2,3,4]।

all(<1).foldr(?)[]
m?l|(p,r)<-span(/=m+1)l=m:p++drop 1r

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

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

  • foldr(?)[]?खाली सूची के साथ शुरू करके , अपने सूची तर्क को दाएँ से बाएँ का उपयोग करके मोड़ता है। परिणाम सूची में संख्याओं की सूची है जो पिछली संख्या के शीर्ष पर फिट नहीं थी।
  • all(<1) परीक्षण यदि केवल संख्या पिछले संख्या के शीर्ष पर फिटिंग नहीं है तो शून्य हैं।
  • m?lगैर-फिटिंग संख्याओं की mसूची lके लिए एक संख्या को प्रस्तुत करता है । यदि m+1पहले से सूची में है, तो अब इसे हटाया जा सकता है क्योंकि यह शीर्ष पर फिट बैठता है m।
    • (p,r)<-span(/=m+1)lसूची lको दो भागों में विभाजित करता है pऔर rसंख्या के पहले उदाहरण में m+1। यदि कोई नहीं है, तो दाहिना भाग rखाली होगा।
    • m:p++drop 1rपहले जोड़ता mविभाजित भागों के लिए। यदि rगैर-रिक्त है, तो इसके साथ शुरू करना चाहिए m+1, जिसे हटा दिया जाता है drop 1।
— अर्जन जोहान्सन
स्रोत
रिवर्स में स्टैकिंग करते महान विचार! मैंने आपके ?पुनरावर्ती रूप से विस्तार की कोशिश की , लेकिन समान लंबाई मिली ।
— xnor
54 बाइट्स के साथData.List.delete
— H.PWiz
5

भूसी , 9 बाइट्स

Λ¬ḞS:o-→ø

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

1स्टैकेबल डेक के लिए और 0गैर-स्टैकेबल डेक के लिए रिटर्न ।

ऐसा लगता है कि अर्जन जोहानसन अपने हास्केल जवाब में पहले से ही एक ही एल्गोरिदम के साथ आए थे, लेकिन हस्क में यह स्पष्ट रूप से बहुत अधिक संक्षिप्त है।

व्याख्या

हम दूसरी तरफ से समस्या को हल करते हैं: डेक को फ्लिप करें और अवरोही ढेर करें। यदि सभी डेक के माध्यम से जाने के बाद सभी बवासीर शीर्ष पर 0 है, डेक खड़ी है।

Λ¬ḞS:(-→)ø
         ø    Starting with the empty list (each element of this list will be the top card
              of a stack)
  ḞS          Traverse the input from right to left. For each card:
      -→        Remove the successor of this card from our list (if present)
    :           Add this card to our list
Λ¬            At the end, check if all the cards in our list are zeroes (falsy)
— सिंह
स्रोत
4

सी (जीसीसी), 74 73 बाइट्स

f(int*l){int s[10]={},r=1;for(;~*l;s[*l++]++)r*=!*l||s[*l-1]--;return r;}

अंत के साथ -1 को चिह्नित करने के लिए इनपुट सरणी की आवश्यकता होती है। उदाहरण का उपयोग:

int main(int argc, char** argv) {
    int a[] = {0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 4, 5, 6, 7, 8, 9, 0, -1};
    printf("%d\n",  f(a));
    return 0;
}
— orlp
स्रोत
क्या गलत है सादा return r?
— लीक नून
4

रेटिना , 42 बाइट्स

O$#`(.)(?<=(\1.*?)*)
$#2
.
$*1,
^(,|1\1)+$

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

व्याख्या

O$#`(.)(?<=(\1.*?)*)
$#2

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

यह निर्धारित करना सबसे आसान है कि इनपुट में इस तरह का पैटर्न है या नहीं।

.
$*1,

हम प्रत्येक अंक n को n 1 s से प्रतिस्थापित करते हैं , उसके बाद अलग-अलग अंकों को अल्पविराम से अलग करते हैं।

^(,|1\1)+$

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

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

टीआई-बेसिक (83 श्रृंखला), 25 बाइट्स (49 अक्षर)

:min(seq(min(cumSum(Ans=I)≤cumSum(Ans=I-1)),I,1,9

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

में एक सूची के रूप में इनपुट लेता है Ans। 1स्टैकेबल इनपुट के लिए आउटपुट , 0अन्यथा।

प्रत्येक के लिए I, cumSum(Ans=I)गणना करता है कि Iप्रत्येक प्रारंभिक खंड में कितनी बार संख्या हुई है, इसलिए min(cumSum(Ans=I)≤cumSum(Ans=I-1))केवल 1 है यदि, प्रत्येक स्थिति में, हमने I-1कम से कम कई बार देखा है I। समग्र अभिव्यक्ति 1जब भी यह प्रत्येक के लिए रखती है I।

— मिशा लावरोव
स्रोत
3

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

सूची के रूप में इनपुट लेता है।

a=>a.every(k=>a[~k]=!k|a[-k]--&&-~a[~k])

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

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

कैसे?

प्रत्येक मान 0 ... 9 के लिए , हम पूर्ववर्ती कार्ड के साथ उपलब्ध ढेर की संख्या का ट्रैक रखते हैं। ये काउंटर में जमा हो जाती एक [-9] के लिए एक [0] , जहां एक [] मूल इनपुट सरणी है। एकमात्र काउंटर जो इनपुट डेटा से टकराता है , [0] , लेकिन हम वास्तव में इस बारे में परवाह नहीं करते हैं क्योंकि 1) 0 लेबल वाले कार्ड को हमेशा अनुमति दी जाती है और उन्हें अलग से संसाधित किया जाना चाहिए और 2) इनपुट मान [0] ] को अपडेट होने का मौका मिलने से पहले संसाधित किया जाता है।

a => a.every(k =>  // given the input array a, for each card k in a:
  a[~k] =          // the card is valid if:
    !k |           //   - it's a 0 or
    a[-k]-- &&     //   - there's at least one stack with the card k-1 atop
    -~a[~k]        // in which case we allow a new card k+1 and go on with the next card
)                  // otherwise, every() fails immediately
— Arnauld
स्रोत
तुम मुझसे ज्यादा तेज हो: o
— लीकी नून
@LeakyNun आप 20 मिनट के लिए दूर हो गए होंगे ...;)
— अरनौल्ड
2

MATL , 16 बाइट्स

0*GQ"@yQy=f1)(]a

इनपुट संख्या की एक सरणी है।

1STDOUT में कोड आउटपुट अगर इनपुट स्टैकेबल है, या इनपुट स्टैकेबल नहीं है, तो STDOUT में एक त्रुटि और खाली आउटपुट के साथ बाहर निकलता है।

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

— लुइस मेंडो
स्रोत
2

आर , 88 बाइट्स

function(d){s={}
for(e in d)if(!e)s=c(s,0)else{k=match(e,s+1)
if(is.na(k))T=F
s[k]=e}
T}

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

एक आर सदिश लेने वाला कार्य; रिटर्न TRUEstackable के लिए और FALSEunstackable के लिए।

स्पष्टीकरण:

function(d){
 s <- {}              # initialize the stacks as empty
 for(e in d){         # iterate over the deck
  if(!e)              # if e is zero
   s <- c(s,0)        # start a new stack
  else {              # otherwise
   k <- match(e,s+1)  # find where e should go in s, NA if not there
   if(is.na(k))       # if no match (unstackable)
    T <- F            # set T to F (False)
   s[k] <- e          # set s[k] to e
  }
 T                    # return the value of T, which is TRUE by default and only gets changed in the loop to F.
}
— ग्यूसेप
स्रोत
2

निम, 133 बाइट्स

proc s(d:seq[int]):int=
 var
  t= @[0]
  r=1
 for c in d:(t.add(0);var f=0;for i,s in t.pairs:(if s==c:(t[i]=c+1;f=1;break));r*=f)
 r

1अगर यह काम करता है; 0अगर यह नहीं है।

फॉर-लूप्स में वेरिएबल्स की परस्परता से निपटने के लिए कुछ फंकी बिज़नेस खींचना था, ओह वेल।

— Quelklef
स्रोत
1

हास्केल , 77 75 बाइट्स

import Data.List
g[]=1<3
g(x:r)|s<-r\\[x-1]=g r&&(x<1||s/=r&&g s)
g.reverse

इसे ऑनलाइन आज़माएं! उपयोग: g.reverse $ [0,1,2]। Trueस्टैकेबल इनपुट के लिए रिटर्न और Falseअन्यथा।

यह एक पुनरावर्ती समाधान है जो किसी दी गई सूची को पीछे से सामने की ओर ट्रेस करता है। यह अवलोकन को लागू करता है

  • खाली सूची स्टैकेबल है।
  • उपसर्ग rऔर अंतिम तत्व के साथ एक गैर-रिक्त सूची xस्टैकेबल है यदि rस्टैकेबल है और या तो xशून्य है या दोनों में x-1दिखाई देता है rऔर हटाए जाने के rसाथ x-1भी स्टैकेबल है।
— Laikoni
स्रोत
1

जावा 8, 168 150 142 बाइट्स

a->{int x[]=new int[a.length],s=0,i;a:for(int n:a){if(n<1){s++;continue;}for(i=0;i<s;i++)if(x[i]==n-1){x[i]=n;continue a;}return 0;}return 1;}

रिटर्न 0/ 1यह सही ढंग से स्टैकेबल है या नहीं।

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

a->{                         // Method with integer-array parameter and integer return-type
  int x[]=new int[a.length], //  Array for the stacks, (max) size equal to input-size
      s=0,                   //  Amount of stacks, starting at 0
      i;                     //  Index integer
  a:for(int n:a){            //  Loop (1) over the input
    if(n<1){                 //   If the current item is a zero:
      s++;                   //    Increase amount of stacks `s` by 1
      continue;}             //    And go to the next iteration
    for(i=0;i<s;i++)         //   Inner loop (2) over the stacks
      if(x[i]==n-1){         //    If a top item of a stack equals the current item - 1:
        x[i]=n;              //     Set this item in the stacks-array
        continue a;}         //     And go to the next iteration of loop (1)
    return 0;                //   If we haven't encountered a `continue`, return 0
  }                          //  End of loop (1)
  return 1;                  //  Return 1 if we were able to correctly stack everything
}                            // End of method
— केविन क्रूज़सेन
स्रोत
1

सी, 248 बाइट्स

नोट: रिटर्न स्टेटस प्रिंट करने के लिए, टर्मिनल में "इको $ स्टेटस" टाइप करें

वापसी की स्थिति 0: स्टैकेबल नहीं

वापसी की स्थिति 1: स्टैकेबल

स्पष्टीकरण: स्टैक में वर्तमान-सबसे अधिक अंकों के बराबर सूचकांक के साथ वृद्धि सरणी तत्व। फिर, यह जाँचता है कि क्या यह अभी-वृद्धि हुई सरणी तत्व तत्व से पहले के तत्व से बड़ा है। यदि ऐसा है, तो रिटर्न 0. यदि प्रोग्राम सरणी रिटर्न के अंत में बनाता है तो 1।

 main(int argc, char ** argv)
{
    static int stack[10];

    while ( *++argv != 0x0 )
    {
        stack[**argv - 0x30]++;

        if ( **argv - 0x30 > 0 )
        {
            if ( stack[**argv - 0x30] > stack[**argv - 0x30 - 1] )
            {
                return 0;
            }

        }

    }   

    return 1;
}
— टी। सलीम
स्रोत
3
कोड गोल्फ में आपका स्वागत है! आपका कोड और आपका बायटेकाउंट मेल खाना चाहिए, इसलिए अपने कोड का पूरी तरह से गोल्फ संस्करण प्रदान करना सुनिश्चित करें। अनलॉक्ड संस्करण वैकल्पिक एक है।
— स्टीफन
0

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

œp@ŒQẎµ0rṀ⁼Qµ¿Ẹ

एक ऋणात्मक लिंक गैर-नकारात्मक पूर्णांकों की सूची ले रहा है और 0यदि स्टैकेबल या 1यदि गैर-स्टैकेबल है तो वापस लौट रहा है ।

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

कैसे?

œp@ŒQẎµ0rṀ⁼Qµ¿Ẹ - Link: list
             ¿  - while loop:
      µ     µ   - ...condition chain:
       0        -      literal zero
         Ṁ      -      maximum of current list
        r       -      inclusive range = [0,1,2,...,max(list)]
           Q    -      de-duplicate list (unique values in order of appearance)
          ⁼     -      equal?
                - ...do:
   ŒQ           -      distinct sieve (1s at first occurrences 0s elsewhere)
  @             -      use swapped arguments:
œp              -        partition (the list) at truthy values (of the distinct sieve)
     Ẏ          -      tighten (makes the list flat again ready for the next loop)
              Ẹ - any truthy? 1 if the resulting list has any non-zero integers remaining
                -           - effectively isNotEmpty for our purposes since a list of only
                -             zeros gets reduced to an empty list via the loop.
— जोनाथन एलन
स्रोत
आपकी चाल: पी: पी
— लीकी नून
हे, अच्छी तरह से मुझे संदेह है कि मैं 11 (या 10 ?!) को हरा
— जोनाथन एलन
0

जाप , 16 बाइट्स

£=k_¥T©°T}T=0ÃUd

इसे ऑनलाइन टेस्ट करें! स्टैकेबल के falseलिए आउटपुट , trueनॉन-स्टैकेबल के लिए।

व्याख्या

 £   = k_  ¥ T© ° T}T=0Ã Ud
UmX{U=UkZ{Z==T&&++T}T=0} Ud    Ungolfed
                               Implicit: U = input array
UmX{                   }       For each item X in the array:
                    T=0          Set T to 0.
      UkZ{         }             Remove the items Z where
          Z==T&&++T              Z == T (and if so, increment T).
                                 This has the effect of removing the largest stack.
    U=                           Reset U to the result.
                               This process is repeated U.length times, which is
                               evidently enough to handle any U.
                         Ud    Return whether there are any truthy items in U.
                               Any items not part of a stack are non-zero/truthy,
                               so this works for every possible case.
— ETHproductions
स्रोत
0

05AB1E , 25 बाइट्स

ηε[DõQ#ZƒDNåiNõ.;Dëˆ#]¯OĀ

चुनौती सभी मुश्किल नहीं दिखती है, लेकिन यह 05AB1E में काफी कठिन है (मेरे लिए कम से कम ..)

0यदि स्टैकेबल है, और 1स्टैकेबल नहीं है तो आउटपुट ।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

η             # Prefixes of the (implicit) input
              #  i.e. '012031' → ['0','01','012','0120','01203','012031']
              #  i.e. `021` → ['0','02','021']
 ε            # Map each to:
  [           # Start an infinite inner loop
   D          # Duplicate the current value
    õQ#       # If it's an empty String, stop the infinite loop
   Z          # Get the maximum (without popping)
              #  i.e. '01203' → 3
              #  i.e. '02' → 2
    ƒ         # Inner loop `N` in the range [0,max]
     D        # Duplicate the current value
      Nåi     # If it contains the current digit `N`
              #  i.e. '01203' and 1 → 1 (truthy)
              #  i.e. '02' and 1 → 0 (falsey)
         Nõ.; # Remove the first one (by replacing the first `N` with an empty string)
              #  i.e. '1203' and 1 → '203'
         D    # And duplicate it again for the next iteration of the inner loop
      ë       # Else (does not contain the digit `N`):
       ˆ      # Push `N` to the global stack
        #     # And break the infinite loop
 ]            # Close the if-else, inner loop, infinite loop, and mapping (short for `}}}}`)
  ¯           # Push the global stack
   O          # Take the sum
              #  i.e. [] → 0
              #  i.e. ['2'] → 2
    Ā         # And get the trutified value of that (which we implicitly output as result)
              #  i.e. 0 → 0
              #  i.e. 2 → 1
— केविन क्रूज़सेन
स्रोत
0

जावा 8, 87 बाइट्स

स्टैक के निर्माण के बजाय मैं सिर्फ गणना करता हूं कि क्या कोई तत्व पिछले तत्वों पर अस्थिर नहीं है, और जब कोई अपरिवर्तनीय तत्व का सामना होता है तो 0 लौटाता है। यदि मैं अंत तक पहुँचता हूँ, तो पूरी स्ट्रिंग स्टैकेबल है और 1 वापस आ गया है:

s->{int l[]=new int[10];for(int n:s)if(n!=0&&l[n]>=l[n-1]||l[n]++<0)return 0;return 1;}

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

स्पष्टीकरण:

s->{
  int l[]=new int[10];                # initialise the counts of each digit encountered prefix of element, all initialised to 0
  for(int n:s)                        # Iterate over all entries in input
    if(n!=0&&l[n]>=l[n-1]||++l[n]<0)  # Check if the element is stackable on the previous elements. Last check is always evaluated and false, but the sideeffect is to add the element to the handled, prefixed element og the next element.  
      return 0;                       # Unstackable
  return 1;                           # No unstackable elements, so the result is stackable
}
— tfantonsen
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.