İstiflenebilir diziler

29

Her defasında 0 ile 9 arasında etiketlenmiş kartlar dağıtır, 0 ile başlayan ve 1 ile sayılan istifler oluşturur.

  • 0 yaptığınızda, yeni bir yığın başlatmak için onu masaya yerleştirirsiniz.
  • Başka bir kartla uğraşırken, tam olarak bir değeri düşük olan ve üstünü örten bir karta yığarsınız. Böyle bir kart yoksa, destenin istiflenemez.

Bir güverte verilen, verilen sırada ele alındığında istiflenebilir olup olmadığını belirleyin. Aynı şekilde, bir basamak listesi verildiğinde, formların her birinin ayrık alt dizgilere ayrılıp ayrılmayacağına karar verin.0,1,..,k

Örnek

Güverte al 0012312425. İlk iki kart 0, masaya çıkıyorlar:

Stacks: 00

  Deck: 12312425

Ardından, 1devam eden bir olanla uğraştık, hangisi olduğu 0önemli değil:

        1
Stacks: 00

  Deck: 2312425

Sonra bir anlaşma 2sadece yerleştirilmiş üstünde 1ve 3bunun üzerine.

        3
        2
        1
Stacks: 00

  Deck: 12425

Daha sonra 1, 2ve birinci yığının 4üstüne ve ikincisinin üstüne yerleştirilir . 

        4
        3
        22
        11
Stacks: 00

  Deck: 25

Şimdi, bir yere yerleştirmemiz gerekiyor 2, ama 1her iki yığında da yok . Yani, bu güverte istiflenebilir değildi.

Giriş: 0-9 basamaklı boş bir liste veya bunlardan oluşan bir dize. 0'ın her zaman girişte olacağını varsayamazsınız.

Çıktı : İstiflenebilir diziler için biri istiflenebilir olmayanlar için iki ayrı tutarlı değerden biri

Test durumları:

İstif:

0
01
01234
00011122234567890
012031
0120304511627328390

İstiflenebilir değil:

1
021
0001111
0012312425
012301210
000112223

Kolaylık sağlamak için liste halinde:

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

gruplanmış:

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

Liderler Sıralaması:

Kod pasajını göster

code-golf  sequence  decision-problem  subsequence 
— XNOR
kaynak
Liste uzunluğu için bir sınır alabilir miyiz?
— orlp
@orlp Açık bir sınır yok.
— xnor
@xnor muhtemelen int a[99]C
— Leaky Nun
@ LouisMendo Sen "boş" diyebilirim.
— xnor
@ xnor Ah, üzgünüm, bunu görmedim. Dizi 1 tabanlı olabilir mi? Yani sayılar gelen olup 1etmek10
— Luis Mendo

Yanıtlar:

6

Haskell , 55 bayt

Tamsayıların listesini alarak ve dönen anonim bir işlev a Bool.

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

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

Çevrimiçi deneyin!

Nasıl çalışır

  • foldr(?)[]?boş bir listeden başlayarak liste argümanını sağdan sola katlar . Sonuç, listedeki önceki numaraya uymayan numaraların listesidir.
  • all(<1) önceki sayının üstüne uymayan tek sayıların sıfır olup olmadığını test eder.
  • m?luymayan numaraların mlistesine bir sayı hazırlar l. m+1Zaten listede varsa , listeye sığdığı anda kaldırılabilir m.
    • (p,r)<-span(/=m+1)lListeyi liki parçaya pve rsayının ilk örneğine böler m+1. Eğer yoksa, sağ kısım rboş kalacaktır.
    • m:p++drop 1rmbölünmüş parçalara hazırlar . rBoş değilse , o zaman başından m+1kaldırılmalı drop 1.
— Ørjan Johansen
kaynak
İstifleme tersini yaparken harika bir fikir! ?Özyinelemeli olarak genişletmeye çalıştım , ama aynı boyda .
— xnor
54 byte ileData.List.delete
— H.PWiz
5

Kabuğu , 9 bayt

Λ¬ḞS:o-→ø

Çevrimiçi deneyin!

İade 1istiflenebilir güverte ve 0olmayan istiflenebilir deste için.

Haskell'in cevabında Ørjan Johansen'in cevabı zaten aynı algoritmayla geldi ama Husk'ta bu açıkça çok daha kısa.

açıklama

Sorunu başka bir taraftan ele alıyoruz: desteyi çevirin ve inen kazıkları yapın. Tüm güverte geçtikten sonra, tüm kazıkların üstünde 0 varsa, üst üste istiflenebilir.

Λ¬Ḟ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)
— Aslan burcu
kaynak
4

C (gcc), 74 73 bayt

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

Sonunu -1 ile işaretlemek için giriş dizisini gerektirir. Örnek kullanım:

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
kaynak
Ovada yanlış olan ne return r?
— Leaky Nun
4

Retina , 42 bayt

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

Çevrimiçi deneyin!

açıklama

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

Bu, rakamları, aynı rakamın daha önce ne sıklıkta gerçekleştiğine göre, kararlı bir şekilde sıralar. Aslında bu, çeşitli aday alt gruplarını bir araya getirir. Sonuçta ortaya çıkan dizgede ilk önce her bir basamağın ilk oluşumu ve daha sonra her basamağın ikinci oluşumu vb. Olacaktır. İstiflenebilir bir girişte, sonuç 0123...0123...0123..., bu alt dizilerin her birinin herhangi bir noktada son bulabileceği bir şeye benzeyecektir .

Girdide unary türünde bu tür bir patern olup olmadığını belirlemek en kolay yoldur.

.
$*1,

Her basamak yerine n ile n, 1 bağımsız basamak ayırmak için virgül ardından s.

^(,|1\1)+$

Sonunda, art arda artan sayıdaki basamakları eşleştirmek için ileri bir referansı kullanırız. Biz (bir temsil eden bir tek virgül eşleştirerek ya tüm dizeyle eşleşen deneyin 0 yeni koşmak başlar) veya ek öncesinde önceki şeyi eşleştirerek 1cari haneli bir öncekinin halefi ise çalışır, hangi.

— Martin Ender
kaynak
3

TI-Basic (83 serisi), 25 bayt (49 karakter)

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

Nasıl çalışır

Girişi liste halinde alır Ans. Aksi takdirde 1istiflenebilir girişler için çıkışlar 0.

Her biri için I, her bir ilk segmentte gerçekleşen cumSum(Ans=I)zamanların bir listesini hesaplar I; bu nedenle min(cumSum(Ans=I)≤cumSum(Ans=I-1)), yalnızca her pozisyonda, I-1en azından olduğu kadar çok görmüşsek 1 olur I. Genel ifade, 1her biri için bunun geçerli olduğu zamandır I.

— Misha Lavrov
kaynak
3

JavaScript (ES6), 61 45 40 bayt

Girişi liste halinde alır.

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

Test durumları

Kod pasajını göster

Nasıl?

Her değer 0 ... 9 için , önceki kartın üstünde mevcut olan yığınların sayısını takip ederiz. Bu sayıcılar [-9] ' da [0]' da saklanır , burada [] orijinal giriş dizisidir. Giriş verileriyle çarpışan tek sayaç [0] ' dır , ancak bunu umursamıyoruz çünkü 1) 0 etiketli kartlara her zaman izin veriliyor ve yine de ayrı olarak işlenmesi gerekiyor ve 2) giriş değeri a [0 ] güncellenme şansı olmadan işlenir.

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
kaynak
Benden daha
— hızlısın
@LeakyNun 20 dakikadır uzakta olmalısın ...;)
— Arnauld
2

MATL , 16 bayt

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

Giriş bir sayılar dizisidir.

1Girdi istiflenebilirse kod STDOUT'da çıkar veya giriş istiflenebilir değilse STDOUT'da bir hata ve boş çıktıyla çıkar.

Çevrimiçi deneyin!

— Luis Mendo
kaynak
2

Retina , 110 bayt

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

Çevrimiçi deneyin! Link, test durumlarını içerir. Sık sık kullanmıyorum $16...

— Neil
kaynak
2

Mathematica, 80 bayt

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

R , 88 bayt

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}

Çevrimiçi deneyin!

R vektörü alan fonksiyon; döner TRUEistiflenebilir ve FALSEunstackable için.

Açıklama:

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.
}
— Giuseppe
kaynak
2

Nim, 133 bayt

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çalışırsa; 0eğer değilse.

For-döngülerindeki değişkenlerin değişkenliği ile başa çıkmak için biraz korkak bir iş yapmak zorunda kaldı.

— Quelklef
kaynak
1

Haskell , 77 75 bayt

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

Çevrimiçi deneyin! Kullanımı: g.reverse $ [0,1,2]. İade Trueistiflenebilir girişler için ve Falseaksi.

Bu, belirli bir listeyi arkadan öne geçiren özyinelemeli bir çözümdür. Bu gözlem uygular

  • boş liste istiflenebilir.
  • önekiyle boş olmayan bir listesi rve son öğe xhalinde istiflenebilir ristiflenebilir ve ya xsıfırdır ya da her ikisi x-1de görünür rve rbirlikte x-1çıkarılan de istiflenebilir.
— Laikoni
kaynak
1

Java 8, 168 150 142 bayt

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

İade 0/1Doğru istiflenebilir olup olmadığını .

Açıklama:

Burada dene.

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
— Kevin Cruijssen
kaynak
1

C, 248 bayt

Not: Dönüş durumunu yazdırmak için terminale "echo $ status" yazın

Dönüş durumu 0: İstiflenemez

İade durumu 1: İstiflenebilir

Açıklama: Dizi öğesini, dizideki yığındaki en güncel basamağa eşdeğer olan artışlarla yükseltir. Ardından, program, şimdi yeni artımlı bu dizi öğesinin kendisinden önceki öğeden daha büyük olup olmadığını denetler. Eğer öyleyse, 0 döndürür. Program dizinin sonuna çıkarsa başka döndürür 1 döndürür.

 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;
}
— T. Salim
kaynak
3
Code Golf'a Hoşgeldiniz! Kodunuz ve bytecount'unuz birbiriyle eşleşmelidir, bu nedenle kodunuzun tamamen golf versiyonunu girdiğinizden emin olun. Ungolfed versiyonu isteğe bağlı olanıdır.
— Stephen,
0

Jöle , 15 bayt

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

Negatif olmayan tamsayıların listesini alan ve 0istiflenebilirse veya istiflenemezse dönen bir monadik link 1.

Çevrimiçi deneyin!

Nasıl?

œ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.
— Jonathan Allan
kaynak
Sizin hamlenin: P: P
— Sızdıran Rahibe
Heh, peki ben 11'i (ya da 10 ?!) yeneceğimden ve uyumak zorunda kalacağımdan şüpheliyim: D
— Jonathan Allan
0

Japt , 16 bayt

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

Çevrimiçi test edin! falseİstiflenebilir çıkışlar için istiflenebilir çıkışlar true.

açıklama

 £   = 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
kaynak
0

05AB1E , 25 bayt

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

Zorluk o kadar zor görünmüyor, ancak 05AB1E'de oldukça zor (benim için en azından ..)

0İstiflenebilir ve istiflenebilir değilse çıkışlar 1.

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Açıklama:

η             # 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
— Kevin Cruijssen
kaynak
0

Java 8, 87 bayt

Yığınları oluşturmak yerine, önceki öğelerde bir öğenin istiflenemez olup olmadığını hesaplarım ve istiflenemeyen bir öğeyle karşılaşıldığında 0 değerini döndürürüm. Sona ulaşırsam, dizenin tamamı istiflenebilir ve 1 döndürülür:

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

Çevrimiçi deneyin!

Açıklama:

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
kaynak
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.