Steenrod代数是在代数拓扑中出现的重要代数。Steenrod代数由称为“ Steenrod平方”的算子生成，每个正整数i存在一个。Steenrod代数在平方运算中有一个由“可允许的单项式”组成的基础。建立这个基础是我们的目标。

正整数的序列被称为受理如果每个整数是至少下一个的两倍。因此，例如[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的可允许序列。有两个选项，[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$分别，所以最后三个所有的工作。

计分

这就是代码高尔夫：最短的解决方案以字节为单位。

测试用例：

输出的任何重新排序都同样好，因此对于input (3, 3)，output [[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 &&：第一个元素减去总和的两倍小于e，并且...
  • Max@Ratios@#<=.5：列表中连续元素的比率均小于1/2。

因为e小于.5，所以我们可以将其变成连锁不平等。

对于一些额外的字节，这要快得多：在线尝试！

果冻， 16  15 字节

-1多亏了Erik the Outgolfer（对检查进行了智能调整，允许使用单个过滤器）

:Ɲ;_/>¥’Ạ
Œṗ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]。

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

对于每个列表，请在从第一个加倍的数字到所有数字之间添加前缀，以创建新列表d，并将这些列表附加到要处理的列表中。这样可以确保d创建的所有允许序列均包含不大于的数字。

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

仅输出那些度数d大于等于不大于的列表e。（度和超额之和等于列表第一个数字的两倍。）

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]])}

在线尝试！