Đại số Steenrod là một đại số quan trọng xuất hiện trong cấu trúc liên kết đại số. Đại số Steenrod được tạo bởi các toán tử gọi là "bình phương Steenrod", một tồn tại cho mỗi số nguyên dương i. Có một cơ sở cho đại số Steenrod bao gồm "các đơn thức đáng ngưỡng mộ" trong các phép toán bình phương. Mục tiêu của chúng tôi là tạo ra cơ sở này.

Một chuỗi các số nguyên dương được gọi là chấp nhận nếu mỗi số nguyên ít nhất gấp đôi số nguyên tiếp theo. Vì vậy, ví dụ [7,2,1]là có thể chấp nhận vì $7 \geq 2*2$ và $2 \geq 2*1$ . Mặt khác, [3,2]không phải là có thể chấp nhận vì $3 < 2*2$ . (Trong cấu trúc liên kết, chúng tôi sẽ viết $\mathrm{Sq}^7 \mathrm{Sq}^2\mathrm{Sq}^1$ cho chuỗi [7,2,1]).

Mức độ của một chuỗi là tổng số mục của nó. Vì vậy, ví dụ, mức độ [7,2,1]là $7 + 2 + 1 = 10$ . Phần thừa của một chuỗi được chấp nhận là phần tử đầu tiên trừ tổng các phần tử còn lại, do đó [7,2,1]có phần thừa $7 - 2 - 1 = 4$ .

Bài tập

Viết chương trình lấy một cặp số nguyên dương (d,e)và đưa ra tập hợp tất cả các chuỗi mức độ được chấp nhận dvà vượt quá nhỏ hơn hoặc bằng e. Đầu ra là một tập hợp nên thứ tự của các chuỗi được chấp nhận không thành vấn đề.

Ví dụ:

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

Ở đây chúng tôi đang tìm kiếm các chuỗi được chấp nhận với tổng số 3. Có hai tùy chọn [3]và [2,1]. ( [1,1,1]và [1,2]có tổng 3 nhưng không được chấp nhận). Phần thừa [3]là 3 và phần thừa [2,1]là $2-1 = 1$ . Do đó, dãy duy nhất có thừa $\leq1$ là [2,1].

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

Vì vượt quá luôn luôn nhỏ hơn hoặc bằng độ, chúng tôi không có điều kiện vượt quá. Do đó, chúng tôi chỉ cố gắng để tìm thấy tất cả các chuỗi có thể chấp nhận mức độ 6. Các tùy chọn là [6], [5, 1], và [4, 2]. (Những cái này có thừa $6$ , $5-1 = 4$ và $4-2=2$ )

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

Trình tự được chấp nhận của mức 10 là:

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

Những cái này có thừa $10$ , $9-1 = 8$ , $8-2 = 6$ , $7-3 = 4$ , $7-2-1 = 4$ và $6-3-1=2$ , vì vậy ba cái cuối cùng đều hoạt động.

Chấm điểm

Đây là mã golf: Giải pháp ngắn nhất trong byte thắng.

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

Bất kỳ sự sắp xếp lại nào của đầu ra đều tốt như nhau, vì vậy đối với đầu vào (3, 3), đầu ra [[3],[2,1]]hoặc [[2,1],[3]]đều được chấp nhận như nhau (tuy nhiên [[1,2],[3]]không phải vậy).

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 byte

Đã lưu 4 byte nhờ Grimy

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

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

Giải trình

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

Ngôn ngữ Wolfram (Mathicala) , 67 62 byte

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

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

-4 byte bởi @attinat

• IntegerPartitions@d : Nhận tất cả danh sách các số nguyên tổng hợp tới d
• Cases[,...]: Lọc theo điều kiện sau:
  • 2#& @@# - d <= e &&: Hai lần phần tử đầu tiên trừ đi tổng nhỏ hơn evà ...
  • Max@Ratios@#<=.5: Tỷ lệ các yếu tố liên tiếp của danh sách đều nhỏ hơn 1/2.

Vì enhỏ hơn 0,5, chúng ta có thể biến điều này thành bất đẳng thức chuỗi.

Đối với một vài byte bổ sung, điều này nhanh hơn đáng kể: Hãy thử trực tuyến!

Thạch ,  16  15 byte

-1 nhờ Erik Outgolfer (một điều chỉnh thông minh để kiểm tra cho phép một bộ lọc duy nhất)

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

Một liên kết dyadic chấp nhận một số nguyên dương, dở bên trái và một số nguyên dương e, ở bên phải, đưa ra một danh sách các danh sách các số nguyên dương.

Hãy thử trực tuyến! (chân trang định dạng kết quả để tránh liệt kê định dạng danh sách ẩn Jelly thực hiện dưới dạng một chương trình đầy đủ)

Làm sao?

:Ɲ;_/>¥’Ạ - 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 byte

Lưu 1 byte nhờ nimi

4 byte được lưu nhờ xnor

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

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

JavaScript (V8) ,  88 87  81 byte

Đưa đầu vào là (e)(d). In các trình tự để 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)

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

Đã bình luận

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

Bình thường , 23 byte

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

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

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 byte

Danh sách khổng lồ hiểu. Rất có thể không phải là cách tốt nhất để làm điều này, nhưng tôi không thể tìm ra cách bỏ qua các câu lệnh 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 byte

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

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

Theo chỉnh sửa của @Jonas Ausevicius

Than , 42 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

Ｆθ⊞υ⟦⊕ι⟧

Đầu tiên tạo một danh sách các danh sách từ [1]..[d].

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

Đối với mỗi danh sách, hãy tạo các danh sách mới bằng cách thêm tiền tố vào tất cả các số từ số đầu tiên được nhân đôi lên dvà nối các danh sách đó vào danh sách các danh sách sẽ được xử lý. Điều này đảm bảo rằng tất cả các chuỗi được chấp nhận có chứa số không lớn hơn dđược tạo.

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

Chỉ xuất ra những danh sách có mức độ dvà mức dư thừa không lớn hơn e. (Tổng của mức độ và vượt quá bằng hai lần số đầu tiên của danh sách.)

Python 3 , 156 byte

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*

lấy d,elàm đầu vào; danh sách đầu ra của bộ dữ liệu

Tương tự như @OrangeCherries trả lời và trợ giúp từ các bình luận; nhưng lưu nhiều byte hơn

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

Thạch , 18 byte

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

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

Ruby , 78 byte

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

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