Każdorazowo rozdajesz karty oznaczone od 0 do 9 kartami, tworząc stosy, które zaczynają się od 0 i liczą 1.

• Kiedy rozdajesz 0, umieszczasz je na stole, aby rozpocząć nowy stos.
• Kiedy rozdajesz dowolną inną kartę, układasz ją na karcie, która ma dokładnie jedną wartość niższą, pokrywając ją. Jeśli nie ma takiej karty, talii nie można układać w stosy.

Biorąc pod uwagę talię, określ, czy można ją kłaść w stosie w podanej kolejności. Odpowiednio, biorąc pod uwagę listę cyfr, zdecyduj, czy można ją podzielić na rozłączne podsekwencje każdej formy0,1,..,k

Przykład

Weź pokład 0012312425. Pierwsze dwie karty są 0, więc idą na stół:

Stacks: 00

  Deck: 12312425

Następnie zajmujemy się 1, co dalej 0, nie ma znaczenia, które:

        1
Stacks: 00

  Deck: 2312425

Następnie układamy na 2szczycie właśnie umieszczonego 1i 3na wierzchu.

        3
        2
        1
Stacks: 00

  Deck: 12425

Następnie 1, 2i umieszczony na szczycie pierwszego stosu i 4na szczycie drugiej.

        4
        3
        22
        11
Stacks: 00

  Deck: 25

Teraz musimy umieścić 2, ale nie ma 1żadnego stosu. Tak więc tej talii nie można było ustawiać jeden na drugim.

Dane wejściowe: niepusta lista cyfr 0–9 lub ich ciąg. Nie możesz założyć, że 0 zawsze będzie na wejściu.

Dane wyjściowe : Jedna z dwóch wyraźnych spójnych wartości, jedna dla sekwencji, które można ustawiać jedna na drugiej, a druga dla sekwencji, których nie można ustawiać jedna na drugiej

Przypadki testowe:

Możliwość ustawiania w stos:

0
01
01234
00011122234567890
012031
0120304511627328390

Nie można ustawiać jeden na drugim:

1
021
0001111
0012312425
012301210
000112223

Dla wygody, jak listy:

[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]

Zgrupowane:

[[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]]

Tabela liderów:

var QUESTION_ID=144201,OVERRIDE_USER=20260;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/144201/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#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="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><div id="language-list"> <h2>Winners 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><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>

Python 2 , 45 43 bajtów

-2 bajty dzięki @TFeld

s=[]
for c in input():s+=c,-1;s.remove(c-1)

Wypróbuj online!

Haskell , 55 bajtów

Anonimowa funkcja pobierająca listę liczb całkowitych i zwracająca a Bool.

Zastosowanie: (all(<1).foldr(?)[]) [0,1,2,3,4].

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

Wypróbuj online!

Jak to działa

• foldr(?)[]zwija swój argument listy od prawej do lewej za pomocą ?, zaczynając od pustej listy. Wynikiem jest lista liczb na liście, które nie pasowały do ​​poprzedniej liczby.
• all(<1) sprawdza, czy jedynymi liczbami, które nie pasują do poprzedniej liczby, są zera.
• m?ldodaje liczbę mdo listy lniepasujących numerów. Jeśli m+1jest już na liście, można go teraz usunąć, ponieważ pasuje do niego m.
  • (p,r)<-span(/=m+1)ldzieli listę lna dwie części pi rprzy pierwszym wystąpieniu liczby m+1. Jeśli nie ma, odpowiednia część rbędzie pusta.
  • m:p++drop 1rprzygotowuje msię do podzielonych części. Jeśli rjest niepusty, to musi zaczynać się od m+1, który jest usuwany przez drop 1.

Łuska , 9 bajtów

Λ¬ḞS:o-→ø

Wypróbuj online!

Zwroty 1za talie, które można ustawiać jeden na drugim, i 0za talie, których nie można układać jeden na drugim.

Wygląda na to, że Ørjan Johansen w swojej odpowiedzi Haskella wymyślił już ten sam algorytm, ale w Husk jest to oczywiście o wiele bardziej zwięzłe.

Wyjaśnienie

Problem przejmujemy z innej strony: odwróć pokład i ułóż stosy w dół. Jeśli po przejściu przez całą talię wszystkie stosy mają 0 na górze, talię można układać w stosy.

Λ¬Ḟ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)

Galaretka , 15 11 bajtów

‘Ṭ€+\I>0FS¬

Wypróbuj online!

C (gcc), 74 73 bajty

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

Wymaga tablicy wejściowej do oznaczenia końca -1. Przykładowe użycie:

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;
}

Siatkówka , 42 bajty

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

Wypróbuj online!

Wyjaśnienie

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

To porządkuje cyfry, stabilnie, według częstotliwości występowania tej samej cyfry wcześniej. W efekcie zestawia to różne potencjalne podsekwencje razem. Wynikowy ciąg znaków będzie miał najpierw pierwsze wystąpienie każdej cyfry, a następnie drugie wystąpienie każdej cyfry i tak dalej. W przypadku danych wejściowych, które można ustawiać jeden na drugim, wynik będzie wyglądał 0123...0123...0123...mniej więcej tak , że każdy z tych podciągów może zakończyć się w dowolnym momencie.

Najłatwiej jest ustalić, czy na wejściu występuje tego rodzaju wzorzec jednoargumentowy.

.
$*1,

Zamieniamy każda cyfra n przez n 1 s, a po nim przecinek aby oddzielić poszczególne cyfry.

^(,|1\1)+$

Wreszcie wykorzystujemy referencję do przodu, aby dopasować kolejno rosnące liczby cyfr. Próbujemy dopasować cały ciąg albo przez dopasowanie pojedynczego przecinka (reprezentującego 0 , co rozpoczyna nowy przebieg) lub przez dopasowanie poprzedniej rzeczy poprzedzonej dodatkowym 1, co działa tylko wtedy, gdy bieżąca cyfra jest następcą poprzedniej.

TI-Basic (seria 83), 25 bajtów (49 znaków)

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

Jak to działa

Pobiera dane wejściowe jako listę w Ans. Wyjścia 1dla danych wejściowych, które można ustawiać jeden na drugim, w 0przeciwnym razie.

Dla każdego I, cumSum(Ans=I)wylicza listę tego, ile razy Iwystąpiła w każdym początkowego segmentu, więc min(cumSum(Ans=I)≤cumSum(Ans=I-1))jest tylko 1, jeżeli w każdej pozycji, widzieliśmy I-1co najmniej tyle razy, ile I. Ogólne wyrażenie występuje, 1gdy dotyczy to każdego z nich I.

JavaScript (ES6), 61 45 40 bajtów

Pobiera dane wejściowe jako listę.

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

Przypadki testowe

let f =

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

console.log('[Truthy]');
console.log(f([0]))
console.log(f([0,1]))
console.log(f([0,1,2,3,4]))
console.log(f([0,0,0,1,1,1,2,2,2,3,4,5,6,7,8,9,0]))
console.log(f([0,1,2,0,3,1]))
console.log(f([0,1,2,0,3,0,4,5,1,1,6,2,7,3,2,8,3,9,0]))

console.log('[Falsy]');
console.log(f([1]))
console.log(f([0,2,1]))
console.log(f([0,0,0,1,1,1,1]))
console.log(f([0,0,1,2,3,1,2,4,2,5]))
console.log(f([0,1,2,3,0,1,2,1,0]))
console.log(f([0,0,0,1,1,2,2,2,3]))

W jaki sposób?

Dla każdej wartości 0 ... 9 śledzimy liczbę dostępnych stosów z poprzednią kartą na szczycie. Liczniki te są przechowywane w [-9] na [0] , gdzie [] jest oryginalną tablicą wejściową. Jedynym licznikiem, który koliduje z danymi wejściowymi, jest [0] , ale tak naprawdę nie przejmujemy się tym, ponieważ 1) karty oznaczone jako 0 są zawsze dozwolone i muszą być przetwarzane osobno i 2) wartość wejściowa a [0 ] jest przetwarzany, zanim będzie można go zaktualizować.

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

MATL , 16 bajtów

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

Dane wejściowe to tablica liczb.

Kod wysyła 1w STDOUT, jeśli dane wejściowe można ustawiać jeden na drugim, lub kończy się z błędem, a puste wyjście w STDOUT, jeśli dane wejściowe nie mogą być ustawiane w stosy.

Wypróbuj online!

Siatkówka , 110 bajtów

+`0((.*?)1((.*?)2((.*?)3((.*?)4((.*?)5((.*?)6((.*?)7((.*?)8((.*?)9)?)?)?)?)?)?)?)?)?
$2$4$6$8$10$12$14$16$+
^$

Wypróbuj online! Link zawiera przypadki testowe. Często nie używam $16...

Mathematica, 80 bajtów

Catch[Fold[#~Join~{-1}/.{{p___,#2-1,q___}:>{p,#2,q},-1:>Throw[1<0]}&,{},#];1>0]&

Python 2 , 69 61 55 47 46 bajtów

s=[]
for c in input():s+=-1,;s[s.index(c-1)]=c

Wypróbuj online!

Dane wyjściowe to error/ no error.

R , 88 bajtów

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}

Wypróbuj online!

Funkcja, która przyjmuje wektor R; zwraca TRUEza sztaplowanie i FALSEdla sztaplowania.

Wyjaśnienie:

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.
}

Nim, 133 bajty

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

1Jeśli działa; 0jeśli nie.

Musiałem wyciągnąć trochę funky, żeby poradzić sobie ze zmiennością zmiennych w pętlach forów, no cóż.

Haskell , 77 75 bajtów

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

Wypróbuj online! Zastosowanie: g.reverse $ [0,1,2]. Zwraca Truedla wejściowych elementów iFalse inne.

Jest to rozwiązanie rekurencyjne, które przegląda daną listę od tyłu do przodu. Realizuje to obserwację

• pustą listę można ustawiać jeden na drugim.
• niepustą listę z prefiksem ri ostatnim elementem xmożna ustawiać jeden na drugim, jeśli rmożna go ustawiać jeden na drugim, albo xzero, albo oba x-1pojawiają się w, ra rpo x-1usunięciu można również ustawiać jeden na drugim.

Java 8, 168 150 142 bajtów

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;}

Zwroty 0/1 czy można prawidłowo ustawiać w stosy, czy nie.

Wyjaśnienie:

Wypróbuj tutaj.

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

C, 248 bajtów

Uwaga: Aby wydrukować status zwrotu, wpisz „echo $ status” w terminalu

Status powrotu 0: Nie można ustawiać jeden na drugim

Status zwrotu 1: Można ustawiać jeden na drugim

Objaśnienie: Zwiększa element tablicy o indeksie odpowiadającym najbardziej bieżącej cyfrze na stosie. Następnie program sprawdza, czy ten właśnie zwiększony element tablicy jest większy niż element poprzedzający go. Jeśli tak, zwraca 0. W przeciwnym razie, jeśli program dotrze do końca tablicy, zwraca 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;
}

Galaretka , 15 bajtów

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

Monadyczny link pobierający listę nieujemnych liczb całkowitych i zwracający, 0jeśli można je układać w stosy lub 1jeśli nie można ich układać w stosy.

Wypróbuj online!

W jaki sposób?

œ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.

Japt , 16 bajtów

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

Przetestuj online! Wyjścia falsedo układania w stosy, truedo układania w stosy.

Wyjaśnienie

 £   = 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.

05AB1E , 25 bajtów

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

Wyzwanie nie wygląda wcale na takie trudne, ale jest dość trudne w 05AB1E (przynajmniej dla mnie ..)

Wyjścia 0 jeśli można je ustawiać jeden na drugim, a 1jeśli nie można ich ustawiać jeden na drugim.

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie:

η             # 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

Java 8, 87 bajtów

Zamiast budować stosy, po prostu obliczam, czy elementu nie można ustawiać w stosy na poprzednich elementach, i zwracam 0, gdy napotkasz element, którego nie można ustawiać w stosy. Jeśli dojdę do końca, cały ciąg można ustawiać jeden na drugim, a 1 jest zwracany:

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;}

Wypróbuj online!

Wyjaśnienie:

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
}