Trình tự xếp chồng


29

Bạn giao dịch các thẻ được gắn nhãn 0 đến 9 từ một cỗ bài một lần, tạo thành các ngăn xếp bắt đầu từ 0 và đếm lên 1.

  • Khi bạn giải quyết 0, bạn đặt nó lên bàn để bắt đầu một ngăn xếp mới.
  • Khi bạn giao dịch với bất kỳ thẻ nào khác, bạn xếp chồng nó lên trên một thẻ có giá trị chính xác thấp hơn một thẻ, bao phủ nó. Nếu không có thẻ như vậy, bộ bài không thể xếp chồng lên nhau.

Đưa ra một cỗ bài, xác định xem nó có thể được xếp chồng lên nhau khi xử lý theo thứ tự đã cho hay không. Tương tự, được đưa ra một danh sách các chữ số, quyết định xem nó có thể được phân chia thành các chuỗi khác nhau sau mỗi biểu mẫu không0,1,..,k

Thí dụ

Đi bộ 0012312425. Hai thẻ đầu tiên là 0, vì vậy chúng đi trên bàn:

Stacks: 00

  Deck: 12312425

Tiếp theo, chúng ta giải quyết một 1, tiếp tục 0, không quan trọng:

        1
Stacks: 00

  Deck: 2312425

Sau đó, chúng tôi giải quyết 2trên đỉnh của vị trí vừa đặt 1, và 3trên đầu trang của nó.

        3
        2
        1
Stacks: 00

  Deck: 12425

Tiếp theo, các 1, 2và được đặt trên đỉnh của ngăn xếp đầu tiên và 4trên đỉnh một giây.

        4
        3
        22
        11
Stacks: 00

  Deck: 25

Bây giờ, chúng ta cần đặt một 2, nhưng không 1có chồng trên đỉnh. Vì vậy, bộ bài này không thể xếp chồng lên nhau.

Dữ liệu vào: Một danh sách không có các chữ số 0-9 hoặc một chuỗi chúng. Bạn không thể cho rằng 0 sẽ luôn ở trong đầu vào.

Đầu ra : Một trong hai giá trị nhất quán riêng biệt, một cho các chuỗi có thể xếp chồng và một cho các giá trị không thể xếp chồng

Các trường hợp thử nghiệm:

Có thể xếp chồng:

0
01
01234
00011122234567890
012031
0120304511627328390

Không có vận tải:

1
021
0001111
0012312425
012301210
000112223

Để thuận tiện, như danh sách:

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

Được nhóm lại

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

Bảng xếp hạng:


Chúng ta có thể giả sử một giới hạn về độ dài danh sách?
orlp

@orlp Không giới hạn rõ ràng.
xnor

@xnor có lẽ anh ta yêu cầu biện minh cho việc viết bằng int a[99]C
Leaky Nun

@LuisMendo Bạn có thể, tôi nói "nonempty".
xnor

@xnor Ah, xin lỗi, tôi không thấy điều đó. Mảng có thể dựa trên 1 không? Đó là, các số từ 1đến10
Luis Mendo

Câu trả lời:



6

Haskell , 55 byte

Hàm ẩn danh lấy danh sách số nguyên và trả về a Bool.

Cách sử dụng : (all(<1).foldr(?)[]) [0,1,2,3,4].

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

  • foldr(?)[]gấp đối số danh sách của nó từ phải sang trái bằng cách sử dụng ?, bắt đầu với một danh sách trống. Kết quả là danh sách các số trong danh sách không khớp với số trước đó.
  • all(<1) kiểm tra nếu các số duy nhất không khớp trên đầu số trước là số không.
  • m?lchuẩn bị một số mvào danh sách lcác số không phù hợp. Nếu m+1đã có trong danh sách, bây giờ nó có thể được gỡ bỏ vì nó phù hợp với đầu trang m.
    • (p,r)<-span(/=m+1)lchia danh sách lthành hai phần prtại trường hợp đầu tiên của số m+1. Nếu không có, phần bên phải rsẽ trống.
    • m:p++drop 1rchuẩn bị mcho các phần tách. Nếu rkhông trống, thì nó phải bắt đầu bằng m+1, được loại bỏ bởi drop 1.

Ý tưởng tuyệt vời làm việc xếp chồng ngược lại! Tôi đã cố gắng mở rộng ?đệ quy của bạn , nhưng có cùng độ dài .
xnor

54 byte vớiData.List.delete
H.PWiz

5

Husk , 9 byte

Λ¬ḞS:o-→ø

Hãy thử trực tuyến!

Trả về 1cho các sàn có thể xếp chồng và 0cho các sàn không thể xếp chồng lên nhau.

Có vẻ như Ørjan Johansen trong câu trả lời Haskell của anh ta đã đưa ra thuật toán tương tự, nhưng trong Husk điều này rõ ràng ngắn gọn hơn nhiều.

Giải trình

Chúng tôi giải quyết vấn đề từ một khía cạnh khác: lật boong tàu và đóng cọc giảm dần. Nếu sau khi đi qua tất cả các sàn thì tất cả các cọc đều có 0 trên đỉnh, sàn có thể xếp chồng lên nhau.

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

C (gcc), 74 73 byte

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

Yêu cầu mảng đầu vào để đánh dấu kết thúc bằng -1. Ví dụ sử dụng:

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

Có gì sai với đồng bằng return r?
Leaky Nun

4

Võng mạc , 42 byte

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

Hãy thử trực tuyến!

Giải trình

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

Điều này sắp xếp các chữ số, ổn định, theo tần suất mà cùng một chữ số đã xảy ra trước đó. Trong thực tế, điều này đối chiếu các ứng cử viên khác nhau với nhau. Chuỗi kết quả đầu tiên sẽ có lần xuất hiện đầu tiên của mỗi chữ số, và sau đó là lần xuất hiện thứ hai của mỗi chữ số, v.v. Trong một đầu vào có thể xếp chồng lên nhau, kết quả sẽ trông giống như thế 0123...0123...0123..., trong đó mỗi chuỗi con này có thể kết thúc tại bất kỳ điểm nào.

Dễ dàng nhất để xác định xem liệu đầu vào có loại mẫu này trong unary hay không.

.
$*1,

Chúng tôi thay thế mỗi chữ số n bằng n 1 s, theo sau là dấu phẩy để tách các chữ số riêng lẻ.

^(,|1\1)+$

Cuối cùng, chúng tôi sử dụng một tham chiếu chuyển tiếp để phù hợp với việc chạy liên tục các chữ số. Chúng tôi cố gắng khớp toàn bộ chuỗi bằng cách khớp một dấu phẩy (đại diện cho 0 , bắt đầu một lần chạy mới) hoặc bằng cách khớp với điều trước đó trước một bổ sung 1, chỉ hoạt động nếu chữ số hiện tại là thành công của chữ số trước.


3

TI-Basic (sê-ri 83), 25 byte (49 ký tự)

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

Làm thế nào nó hoạt động

Đưa đầu vào như một danh sách trong Ans. Đầu ra 1cho đầu vào có thể xếp chồng, 0nếu không.

Đối với mỗi I, cumSum(Ans=I)tính toán một danh sách số lần Iđã xảy ra trong mỗi phân đoạn ban đầu, do đó, min(cumSum(Ans=I)≤cumSum(Ans=I-1))chỉ có 1 nếu ở mỗi vị trí, chúng tôi đã thấy I-1ít nhất là nhiều lần I. Biểu thức tổng thể là 1bất cứ khi nào điều này giữ cho mỗi I.


3

JavaScript (ES6), 61 45 40 byte

Lấy đầu vào như một danh sách.

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

Các trường hợp thử nghiệm

Làm sao?

Đối với mỗi giá trị 0 ... 9 , chúng tôi theo dõi số lượng ngăn xếp có sẵn với thẻ trước trên đỉnh. Các bộ đếm này được lưu trữ trong [-9] đến [0] , trong đó [] là mảng đầu vào ban đầu. Bộ đếm duy nhất va chạm với dữ liệu đầu vào là [0] , nhưng chúng tôi không thực sự quan tâm đến cái này vì 1) thẻ có nhãn 0 luôn được phép và dù sao cũng phải được xử lý riêng và 2) giá trị đầu vào a [0 ] được xử lý trước khi có cơ hội được cập nhật.

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

Bạn nhanh hơn tôi: o
Leaky Nun

@LeakyNun Bạn phải đi xa trong 20 phút ...;)
Arnauld

2

MATL , 16 byte

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

Đầu vào là một dãy số.

Mã đầu ra 1trong STDOUT nếu đầu vào có thể xếp chồng hoặc thoát ra có lỗi và đầu ra trống trong STDOUT nếu đầu vào không thể xếp chồng lên nhau.

Hãy thử trực tuyến!


2

Võng mạc , 110 byte

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Tôi không thường xuyên sử dụng $16...


2

Toán học, 80 byte

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


2

R , 88 byte

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}

Hãy thử trực tuyến!

Hàm lấy vectơ R; trả về TRUEcho stackable và FALSEcho unstackable.

Giải trình:

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

Nim, 133 byte

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

1nếu nó hoạt động; 0nếu nó không

Phải kéo một số doanh nghiệp sôi nổi để đối phó với sự biến đổi của các biến trong vòng lặp for, ồ tốt.


1

Haskell , 77 75 byte

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

Hãy thử trực tuyến! Cách sử dụng : g.reverse $ [0,1,2]. Trả về Truecho đầu vào có thể xếp chồng và Falsecách khác.

Đây là một giải pháp đệ quy đi qua một danh sách nhất định từ sau ra trước. Nó thực hiện quan sát rằng

  • danh sách trống có thể xếp chồng lên nhau.
  • một danh sách không có sản phẩm nào với tiền tố rvà yếu tố cuối cùng xlà stackable nếu rlà stackable và hoặc xlà zero hoặc cả hai x-1xuất hiện trong rrvới x-1loại bỏ cũng là xếp lớp.

1

Java 8, 168 150 142 byte

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

Trả về 0/ 1cho dù nó có thể xếp chồng chính xác hay không.

Giải trình:

Hãy thử nó ở đây.

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

C, 248 byte

Lưu ý: Để in trạng thái trả về, nhập "echo $ status" vào thiết bị đầu cuối

Trạng thái trả về 0: Không thể xếp chồng

Trạng thái trả về 1: Có thể xếp chồng

Giải thích: Tăng phần tử mảng với chỉ số tương đương với chữ số hiện tại nhất trong ngăn xếp. Sau đó, chương trình kiểm tra xem phần tử mảng vừa tăng này có lớn hơn phần tử trước nó không. Nếu vậy, trả về 0. Khác nếu chương trình làm cho đến cuối mảng trả về 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
Chào mừng bạn đến với Code Golf! Mã của bạn và mã byte của bạn phải khớp nhau, vì vậy hãy đảm bảo cung cấp phiên bản đầy đủ của mã của bạn. Phiên bản không có bản quyền là tùy chọn.
Stephen

0

Thạch , 15 byte

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

Một liên kết đơn âm lấy một danh sách các số nguyên không âm và trả về 0nếu có thể xếp chồng hoặc 1nếu không thể xếp chồng.

Hãy thử trực tuyến!

Làm sao?

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

Di chuyển của bạn: P: P
Leaky Nun

Heh, tôi nghi ngờ tôi đã đánh bại 11 (hoặc 10?!) Và phải đi ngủ: D
Jonathan Allan

0

Japt , 16 byte

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

Kiểm tra nó trực tuyến! Đầu ra falsecho stackable, truecho không stackable.

Giải trình

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

0

05AB1E , 25 byte

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

Thử thách không quá khó khăn, nhưng khá khó khăn trong 05AB1E (đối với tôi ít nhất là ..)

Đầu ra 0nếu stackable, và 1nếu không stackable.

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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

Java 8, 87 byte

Thay vì xây dựng các ngăn xếp, tôi chỉ tính toán nếu một phần tử không thể đóng gói trên các phần tử trước đó và trả về 0 khi gặp một phần tử không thể đóng gói. Nếu tôi đến cuối, toàn bộ chuỗi có thể xếp chồng lên nhau và 1 được trả về:

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

Hãy thử trực tuyến!

Giải trình:

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
}
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.