スティーンロッド代数は、代数トポロジーで現れる重要な代数です。スティーンロッド代数は、「スティーンロッド平方」と呼ばれる演算子によって生成されます。正整数iごとに1つ存在します。二乗演算の「許容可能な単項式」から成るスティーンロッド代数の基礎があります。この基盤を生成することが私たちの目標です。

各整数が次の整数の少なくとも2倍である場合、正の整数のシーケンスは許容可能と呼ばれます。したがって、たとえばおよび[7,2,1]ため、許容されます。一方、ため、許容できません。（トポロジーでは、シーケンスに対してを記述します）。$7 \geq 2*2$$2 \geq 2*1$[3,2]$3 < 2*2$$\mathrm{Sq}^7 \mathrm{Sq}^2\mathrm{Sq}^1$[7,2,1]

シーケンスの次数は、エントリの合計です。したがって、たとえば、次数[7,2,1]は$7 + 2 + 1 = 10$です。過剰許容シーケンスの最初の要素マイナス残りの元素の合計であるので、[7,2,1]過剰有する$7 - 2 - 1 = 4$。

仕事

正の整数のペアを取り、(d,e)次数dと超過の許容可能なすべてのシーケンスのセットを出力するプログラムを作成しeます。出力はセットなので、許容されるシーケンスの順序は関係ありません。

例：

 Input: 3,1
 Output: [[2,1]]

ここでは、合計3の許容シーケンスを探しています。2つのオプションが[3]あり[2,1]ます。（[1,1,1]および[1,2]合計は3ですが、許容されません）。の過剰[3]は3で、過剰[2,1]は$2-1 = 1$です。従って、過剰の配列のみ$\leq1$[2,1]。

Input: 6, 6
Output: [[6], [5, 1], [4, 2]] (or any reordering, e.g., [[5,1],[4,2],[6]])

過剰は常に次数以下であるため、過剰条件はありません。このように、私達はちょうどのオプションがある度6のすべての許容シーケンスを見つけるためにしようとしている[6]、[5, 1]と[4, 2]。（これらは、過剰有する$6$、$5-1 = 4$、及び$4-2=2$）。

Input: 10, 5
Output: [[7,3], [7,2,1], [6,3,1]]

次数10の許容されるシーケンスは次のとおりです。

[[10], [9,1], [8,2], [7,3], [7,2,1], [6,3,1]]

これらは、過剰持っ$10$、$9-1 = 8$、$8-2 = 6$、$7-3 = 4$、$7-2-1 = 4$、及び$6-3-1=2$それぞれので、最後の三つすべての作業。

得点

これはコードゴルフです。バイト単位の最短ソリューションが勝ちです。

テストケース：

出力の並べ替えも同様に適切であるため、入力(3, 3)、出力、[[3],[2,1]]または[[2,1],[3]]同等に許容されます（ただし許容され[[1,2],[3]]ません）。

Input: 1, 1
Output: [[1]]

Input: 3, 3
Output: [[2,1], [3]]

Input: 3, 1
Output: [[2,1]]

Input: 6, 6
Output: [[6], [5, 1], [4, 2]]

Input: 6, 4
Output: [[5,1], [4,2]]

Input: 6, 1
Output: []

Input: 7, 7
Output: [[7], [6,1], [4,2,1], [5,2]]

Input: 7,1
Output: [[4,2,1]]

Input: 10, 10
Output: [[10], [9,1], [7,2,1], [6,3,1], [8,2], [7,3]]

Input: 10, 5
Output: [[7,3], [7,2,1], [6,3,1]]

Input: 26, 4
Output: [15, 7, 3, 1]

Input: 26, 6
Output: [[16, 7, 2, 1], [16, 6, 3, 1], [15, 7, 3, 1], [16, 8, 2], [16, 7, 3]]

05AB1E、16 12バイト

Grimyのおかげで4バイト節約

Åœíʒx¦@P}ʒÆ@

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

説明

Ŝ              # integer partitions
  í             # reverse each
   ʒ    }       # filter, keep only elements true under:
    x           # each element doubled
     ¦          # remove the first element in the doubled list
      @         # compare with greater than or equal with the non-doubled
       P        # product
         ʒ      # filter, keep only elements true under:
          Æ     # reduce by subtraction
           @    # compare with greater than or equal to second input

Wolfram言語（Mathematica）、67 62バイト

Cases[IntegerPartitions@#,a_/;2a[[1]]-#<=#2>Max@Ratios@a<=.5]&

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

@attinatによる-4バイト

• IntegerPartitions@d ：合計する整数のリストをすべて取得する d
• Cases[,...]：次の条件でフィルタリングします。
  • 2#& @@# - d <= e &&：最初の要素から合計を引いた値が2回未満であるe、そして...
  • Max@Ratios@#<=.5：リストの連続する要素の比率はすべて1/2未満です。

eが0.5より小さいため、これを連鎖不平等に変えることができます。

数バイト余分に、これは非常に高速です：オンラインで試してみてください！

ゼリー、 16  15 バイト

-1アウトゴルファーのエリックに感謝（単一のフィルターを許可するチェックのスマートな調整）

:Ɲ;_/>¥’Ạ
ŒṗUçƇ

d左側に正の整数を受け入れe、右側に正の整数を受け入れるダイアディックリンクは、正の整数のリストのリストを生成します。

オンラインでお試しください！（フッターは、Jellyが完全なプログラムとして行う暗黙的なリスト形式をリストすることを避けるために、結果をフォーマットします）

どうやって？

:Ɲ;_/>¥’Ạ - Link 1: admissible and within excess limit? descending list, L; excess limit, e
 Ɲ        - neighbour-wise:
:         -   integer division  -- admissible if all these are >1
      ¥   - last two links as a dyad - i.e. f(L,e):
    /     -   reduce (L) by:
   _      -     subtraction
     >    -   greater than (e)? (vectorises)  -- within excess if all these are ==0
  ;       - concatenate
       ’  - decrement (vectorises)
        Ạ - all (non-zero)?

ŒṗUçƇ - Main link: integer, d; integer, e
Œṗ    - partitions (of d)
  U   - reverse each
    Ƈ - filter keep those (v in that) for which:
   ç  -   call last Link (1) as a dyad - i.e. f(v, e)

Haskell、59 58 54バイト

nimiのおかげで1バイト節約

xnorのおかげで4バイト節約

0#_=[[]]
d#m=do i<-[1..div(m+d)2];(i:)<$>(d-i)#(2*i-d)

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

JavaScript（V8）、 88 87  81バイト

入力をとして受け取ります(e)(d)。シーケンスをSTDOUTに出力します。

e=>g=(d,s=x=d,a=[])=>s>0?d&&g(d-1,s,a,g(d>>1,s-d,[...a,d])):a[s]*2-x<=e&&print(a)

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

コメント済み

e =>                  // e = maximum excess
  g = (               // g is a recursive function taking:
    d,                //   d   = expected degree; actually used as the next candidate
                      //         term of the sequence in the code below
    s =               //   s   = current sum, initialized to d; we want it to be equal
                      //         to 0 when a sequence is complete
    x = d,            //   x   = copy of the expected degree
    a = []            //   a[] = current sequence
  ) =>                //
    s > 0 ?           // if s is positive:
      d &&            //   if d is not equal to 0:
        g(            //     outer recursive call:
          d - 1,      //       decrement d
          s,          //       leave s unchanged
          a,          //       leave a[] unchanged
          g(          //       inner recursive call:
            d >> 1,   //         update d to floor(d / 2)
            s - d,    //         subtract d from s
            [...a, d] //         append d to a[]
          )           //       end of inner recursive call
        )             //     end of outer recursive call
    :                 //   else:
      a[s] * 2 - x    //     s if either 0 (success) or negative (failure)
                      //     if s is negative, a[s] is undefined and this expression
                      //     evaluates to NaN, forcing the test to fail
      <= e            //     otherwise, we test whether the excess is valid
      && print(a)     //     and we print a[] if it is

Pyth、23バイト

f!>-FTvzf!<#2/MCtBT_M./

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

f!>-FTvzf!<#2/MCtBT_M./Q   Implicit: Q=input 1, vz=input 2
                           Trailing Q inferred
                     ./Q   Generate partitions of Q (ordered lists of integers which sum to Q)
                   _M      Reverse each
        f                  Filter keep elements of the above, as T, where:
               CtBT          Pair the set with itself without the first element and transpose
                             This yields all adjacent pairs of values
             /M              Integer divide each pair
           #                 Filter keep elements...
          < 2                ... less than 2
                             For admissible sequences this will be empty
         !                   Logical NOT - maps [] to true, populated lists to false
                           Result of filter are all admissible sequences
f                          Filter keep the above, as T, where:
   -FT                       Reduce T by subtraction to get degree
 !>   vz                     Is the above not greater than vz?
                           Implicit print

Pythonの3、213のバイト

巨大なリストの理解。ほとんどの場合、これを行う最善の方法ではありませんが、ifステートメントをスキップする方法がわかりません

import itertools as z
f=lambda d,e:[c for c in [[b for b in list(z.permutations(range(1,d+1),i)) if sum(b)==d and b[0]-sum(b[1:i])<=e and all([b[i]>=b[i+1]*2 for i in range(len(b)-1)])] for i in range(1,5)] if c]

Python 3、172バイト

from itertools import*
r=range
f=lambda d,e:filter(len,[[b for b in permutations(r(1,d+1),i)if d==sum(b)and~e<d-2*b[0]and all(i>=j*2for i,j in zip(b,b[1:]))]for i in r(5)])

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

@Jonas Auseviciusによる編集によると

炭、42バイト

Ｆθ⊞υ⟦⊕ι⟧ＦυＦ…·⊗§ι⁰θ⊞υ⁺⟦κ⟧ιＩΦυ›⁼Σιθ‹η⁻⊗§ι⁰Σι

オンラインでお試しください！リンクは、コードの詳細バージョンです。説明：

Ｆθ⊞υ⟦⊕ι⟧

最初にリストのリストを作成します[1]..[d]。

ＦυＦ…·⊗§ι⁰θ⊞υ⁺⟦κ⟧ι

リストごとに、最初の2倍の数字からすべての数字を接頭辞として新しいリストを作成しd、それらのリストを処理するリストのリストに追加します。これにより、最大数以下の数値を含むすべての許容シーケンスdが作成されます。

ＩΦυ›⁼Σιθ‹η⁻⊗§ι⁰Σι

次数がでdあり、超過がを超えないリストのみを出力しますe。（次数と過剰の合計は、リストの最初の数の2倍になります。）

Python 3、156バイト

lambda d,e:[x for y in range(5)for x in permutations(range(1,d+1),y)if all(i>=j*2for i,j in zip(x,x[1:]))and d==sum(x)and~e<d-2*x[0]]
from itertools import*

かかるd,e入力として、タプルのリストを出力します

@OrangeCherriesの回答とコメントのヘルプに似ています。しかし、より多くのバイトが保存されました

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

ゼリー、18バイト

ŒṗU:Ɲ’ẠƊƇUṪ_SƊ’<ʋƇ

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

ルビー、78バイト

g=->(d,e,m=1){d<m ?[]:g[d-m,e+m,m*2].map{|q|q+[m]}+g[d,e,m+1]|(d>e ?[]:[[d]])}

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