스택 가능 시퀀스

29

한 번에 한 덱에서 0에서 9까지 레이블이 붙은 카드를 처리하여 0에서 시작하여 1까지 카운트하는 스택을 만듭니다.

  • 0을 다룰 때 새 스택을 시작하기 위해 테이블에 놓습니다.
  • 다른 카드를 다룰 때는 그 가치가 정확히 1보다 낮은 카드 위에 카드를 쌓아 두십시오. 그러한 카드가 없으면 덱을 쌓을 수 없습니다.

데크가 주어지면 주어진 순서대로 처리 할 때 쌓을 수 있는지 여부를 결정하십시오. 마찬가지로, 자릿수 목록이 주어지면 각 형식의 분리 된 하위 시퀀스로 분할 할 수 있는지 여부를 결정하십시오.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이 항상 입력에 있다고 가정 할 수는 없습니다.

출력 : 두 개의 서로 다른 일관성있는 값 중 하나, 스택 가능 시퀀스 및 스택 불가능 값

테스트 사례 :

쌓을 수있는 :

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
@orlp 명시적인 제한이 없습니다.
— xnor
@xnor 그는 아마 글을 정당화하기 위해 묻는 데요 int a[99]C에서
— 새는 수녀
@LuisMendo "빈"이라고 말할 수 있습니다.
— xnor
@ xnor 아 죄송합니다, 나는 그것을 보지 못했습니다. 어레이가 1 기반 일 수 있습니까? 즉, 1~ 에서 숫자10
— Luis 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) 이전 숫자 위에 맞지 않는 숫자가 0인지 테스트합니다.
  • m?l적합하지 않은 숫자 m목록 앞에 숫자 를 추가 l합니다. 경우 m+1목록에 이미 그것의 상단에 맞는, 그것은 이제 제거 할 수 있습니다 m.
    • (p,r)<-span(/=m+1)l목록 분할 l두 부분으로 p하고 r번호의 첫 번째 인스턴스에서를 m+1. 없는 경우 오른쪽 부분 r이 비어 있습니다.
    • m:p++drop 1rm분할 된 부분 앞에 붙 습니다. 경우 r하늘이 아닌 함께, 그것은 시작해야합니다 m+1에 의해 제거된다, drop 1.
— 외잔 요한센
소스
스택을 반대로하는 것이 좋습니다. 나는 당신의 ?재귀 적으로 확장하려고 시도했지만 같은 길이를 얻었습니다 .
— xnor
54 바이트 와Data.List.delete
— H.PWiz
5

껍질 , 9 바이트

Λ¬ḞS:o-→ø

온라인으로 사용해보십시오!

1쌓을 수있는 데크 및 쌓을 수없는 데크에 대해 반환 합니다 0.

Haskell의 답변 에서 Ørjan Johansen은 이미 동일한 알고리즘을 생각해 냈지만 Husk에서는 이것이 훨씬 간결합니다.

설명

우리는 다른 쪽에서 문제를 해결합니다. 갑판을 뒤집고 내림차순 더미를 만듭니다. 모든 데크를 통과 한 후 모든 더미의 상단에 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

C (gcc), 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;
}
— 오르프
소스
평범한 문제는 무엇입니까 return r?
— Leaky Nun
4

레티 나 , 42 바이트

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

온라인으로 사용해보십시오!

설명

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

이것은 이전에 같은 숫자가 얼마나 자주 발생했는지에 따라 숫자를 안정적으로 정렬합니다. 실제로, 이것은 다양한 후보 서브 시퀀스를 함께 조합합니다. 결과 문자열은 먼저 각 숫자의 첫 번째 항목을 찾은 다음 각 숫자의 두 번째 항목 등을 갖습니다. 스택 가능한 입력에서 결과는 다음과 같이 보일 것 0123...0123...0123...입니다.이 부분 문자열 각각은 언제라도 종료 될 수 있습니다.

입력에 이러한 종류의 패턴이 단항인지 여부를 확인하는 것이 가장 쉽습니다.

.
$*1,

각 숫자 n 을 n 1 s로 바꾸고 쉼표를 사용하여 개별 숫자를 구분합니다.

^(,|1\1)+$

마지막으로 연속적으로 증가하는 자릿수를 일치시키기 위해 정방향 참조를 사용합니다. 단일 쉼표 ( 새 실행을 시작 하는 0을 나타냄 )를 일치 시키거나 이전 항목과 추가를 선행 하여 전체 문자열을 일치 시키려고 시도합니다 1.

— 마틴 엔더
소스
3

TI 기본 (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

자바 스크립트 (ES6), 61 45 40 바이트

입력을 목록으로 취합니다.

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

테스트 사례

코드 스 니펫 표시

방법?

각 값 0 ... 9 에 대해 앞의 카드가 맨 위에있는 사용 가능한 스택 수를 추적합니다. 이 카운터는 a [-9] ~ a [0]에 저장 되며 여기서 a [] 는 원래 입력 배열입니다. 입력 데이터와 충돌하는 유일한 카운터는 a [0] 이지만 1) 0 으로 표시된 카드 는 항상 허용되며 어쨌든 별도로 처리해야하며 2) 입력 값 a [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
— 아르나 울드
소스
당신은 나보다 빠릅니다 : o
— Leaky Nun
@LeakyNun 당신은 ... 20 분 거리에 틀림)
— Arnauld
2

MATL , 16 바이트

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

입력은 숫자의 배열입니다.

1입력이 스택 가능하면 코드 가 STDOUT으로 출력 되거나, 입력 가능 스택 가능하지 않으면 오류가 발생하고 STDOUT에서 빈 출력으로 종료됩니다.

온라인으로 사용해보십시오!

— 루이스 멘도
소스
2

망막 , 110 바이트

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

온라인으로 사용해보십시오! 링크에는 테스트 사례가 포함됩니다. 자주 사용하지 않습니다 $16...

— 닐
소스
2

Mathematica, 80 바이트

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

R , 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}

온라인으로 사용해보십시오!

R 벡터를 취하는 함수; TRUE스택 가능 및 스택 FALSE불가능을 반환 합니다 .

설명:

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 바이트

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그렇지 않다면.

for-loops에서 변수의 가변성을 다루기 위해 펑키 한 비즈니스를 이끌어 냈습니다.

— 케클 러프
소스
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스택과 중 x0이거나 모두 x-1에서 나타납니다 r와 r와 x-1제거도 쌓을 수있다.
— 라이 코니
소스
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

C, 248 바이트

참고 : 반품 상태를 인쇄하려면 터미널에 "echo $ status"를 입력하십시오.

반환 상태 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
Code Golf에 오신 것을 환영합니다! 코드와 바이트 수가 일치해야하므로 완전히 골프화 된 코드 버전을 제공해야합니다. ungolfed 버전은 선택 사항입니다.
— 스티븐
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.
— 조나단 앨런
소스
당신의 움직임 : P : P
— Leaky Nun
허, 글쎄, 나는 내가 11 (또는 10?)을 이길 것을 의심하고 잠을 자야한다 : D
— Jonathan Allan
0

Japt , 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.
— ETH 프로덕션
소스
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
소스
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.