積み重ね可能なシーケンス

29

デッキから0から9のラベルが付いたカードを1つずつ配り、0から始まり1ずつカウントアップするスタックを形成します。

  • 0を配るとき、新しいスタックを開始するためにテーブルに置きます。
  • 他のカードを配るとき、あなたはそれをカバーする、ちょうど1つ価値の低いカードの上にそれをスタックします。そのようなカードがない場合、デッキはスタックできません。

デッキが与えられたら、与えられた順序で配られたときにスタックできるかどうかを判断します。同様に、数字のリストを指定して、それぞれの形式の互いに素なサブシーケンスに分割できるかどうかを決定します0,1,..,k

例

デッキを取り0012312425ます。最初の2枚のカードは0なので、テーブルに置かれます。

Stacks: 00

  Deck: 12312425

次に、を処理しますが1、これはに0関係なく、次のどれでも構いません。

        1
Stacks: 00

  Deck: 2312425

私たちは、その後、対処2だけ-置きの上1、及び3その上に。

        3
        2
        1
Stacks: 00

  Deck: 12425

次に1、2かつ配置された第1のスタックの上及び4第1の頂上。 

        4
        3
        22
        11
Stacks: 00

  Deck: 25

次に、を配置する必要がありますが、どちらのスタック2の1上にもありません。そのため、このデッキはスタッカブルではありませんでした。

入力：数字0-9の空でないリスト、またはそれらの文字列。常に0が入力に含まれると想定することはできません。

出力：2つの異なる一貫した値の1つ、1つはスタッカブルシーケンス用、もう1つは非スタッカブルシーケンス用

テストケース：

スタッカブル：

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
— ルイスメンドー

回答:

6

Haskell、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 1rm分割された部分に追加します。rが空でない場合はm+1、で始まる必要があり、で削除されdrop 1ます。
— オルジャン・ヨハンセン
ソース
逆に積み重ねるのは素晴らしいアイデアです！?再帰的に展開しようとしましたが、同じ長さでした。
— -xnor
54のバイトとData.List.delete
— H.PWiz
5

殻、9バイト

Λ¬ḞS:o-→ø

オンラインでお試しください！

1スタッカブルデッキとスタッカブル0以外のデッキを返します。

Haskellの回答の ØrjanJohansenがすでに同じアルゴリズムを考え出したように見えますが、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;
}
— orlp
ソース
plainの何が問題になっていreturn rますか？
— リーキー修道女
4

網膜、42バイト

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

オンラインでお試しください！

説明

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

これにより、同じ数字が以前に発生した頻度によって、数字が安定してソートされます。実際には、これはさまざまな候補サブシーケンスを一緒に照合します。結果の文字列には、最初に各数字が最初に出現し、次に各数字が2番目に出現するというように続きます。スタック可能な入力では、結果はのようなものになります0123...0123...0123...。これらの各部分文字列は、任意の時点で終了する場合があります。

入力にこの種のパターンがあるかどうかを単項で判断するのが最も簡単です。

.
$*1,

各数字nをnに 置き換え1、その後にコンマを続けて個々の数字を区切ります。

^(,|1\1)+$

最後に、前方参照を使用して、連続して増加する数字の連続に一致させます。単一のコンマ（新しい実行を開始する0を表す）を照合する1か、現在の数字が前の数字の後継である場合にのみ機能する、追加の前の前のものを一致させることにより、文字列全体を一致させようとします。

— マーティン・エンダー
ソース
3

TI-Basic（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

JavaScript（ES6）、61 45 40バイト

入力をリストとして受け取ります。

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

テストケース

コードスニペットを表示

どうやって？

各値0 ... 9について、前のカードが上にある使用可能なスタックの数を追跡します。これらのカウンタは、に格納されている[-9]に[0] 、[]元の入力アレイです。入力データと衝突する唯一のカウンターは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
— リーキー修道女
あなたは... 20分の距離となっている必要があります@LeakyNun;）
— アルノー
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

ニム、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ループ内の変数の可変性に対処するために、ファンキーなビジネスを引っ張らなければなりませんでした。

— クエルクレフ
ソース
1

Haskell、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削除もスタッカブルです。
— ライコニ
ソース
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;
}
— T.サリム
ソース
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.
— ジョナサン・アラン
ソース
あなたの移動：P：P
— 漏れ修道女
へぇ、よく私は私が（?!または10）11を倒すと睡眠を取得する必要があるだろう疑問：D
— ジョナサン・アラン
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.
— 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

Java 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
}
— トファントンセン
ソース
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.