Steenrod 대수학은 대수 토폴로지에서 나타나는 중요한 대수학입니다. Steenrod 대수는 "Steenrod squares"라고하는 연산자에 의해 생성되며, 각 양의 정수 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 입니다.$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]]

이것들은 각각 , , , , , 초과 하므로 마지막 3 모두 작동합니다.$10$$9-1 = 8$$8-2 = 6$$7-3 = 4$$7-2-1 = 4$$6-3-1=2$

채점

이것은 코드 골프입니다 : 바이트 단위의 최단 솔루션이 승리합니다.

테스트 사례 :

출력의 재정렬은 똑같이 좋으므로 input (3, 3), outputs [[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 Language (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보다 작습니다.

e0.5보다 작기 때문에 이를 연쇄 불평등으로 바꿀 수 있습니다.

여분의 바이트가 몇 개인 경우 훨씬 빠릅니다. 온라인으로 사용해보십시오!

젤리 ,  16  15 바이트

Outgolfer Erik 덕분에 -1 (단일 필터를 허용하는 점검에 대한 스마트 조정)

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

d왼쪽에 양의 정수 () e, 오른쪽 에 양의 정수 ()를 허용하는 양수 링크는 양의 정수 목록을 생성합니다.

온라인으로 사용해보십시오! (바닥 글은 젤리가 전체 프로그램으로 수행하는 암시 적 목록 형식을 피하기 위해 결과의 형식을 지정합니다)

어떻게?

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

하스켈 , 59 58 54 바이트

nimi 덕분에 1 바이트 절약

xnor 덕분에 4 바이트 절약

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

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

자바 스크립트 (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

파이썬 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]

파이썬 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. 정도와 초과의 합은 목록의 첫 번째 숫자의 두 배와 같습니다.

파이썬 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]])}

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