Steenrod cebiri, cebirsel topolojide ortaya çıkan önemli bir cebirdir. Steenrod cebiri "Steenrod kareleri" adı verilen operatörler tarafından üretilir, her pozitif tamsayı i için bir tane vardır. Kareleme işlemlerinde "kabul edilebilir monomiyallerden" oluşan Steenrod cebiri için bir temel vardır. Hedefimiz bu temeli oluşturmaktır.

Her tamsayı bir sonrakinin en az iki katı ise , pozitif tamsayı dizisine kabul edilebilir denir . Örneğin ve[7,2,1] olduğu için kabul edilebilir . Öte yandan, olduğu için kabul edilemez . (Topolojide sekans için yazarız ).$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]

Derecesi bir dizinin 's girişlerinin toplamıdır. Bu yüzden, örneğin, derecesi [7,2,1]olan . Fazla kabul edilebilir bir sekansın bu nedenle, birinci eleman eksi geri kalan elemanlarının toplamı olan aşırı sahip .$7 + 2 + 1 = 10$[7,2,1]$7 - 2 - 1 = 4$

Görev

Bir çift pozitif tamsayı alan (d,e)ve kabul edilebilir tüm derece dve daha fazla dizi dizisine eşit veya daha küçük bir çıktı veren bir program yazın e. Çıktı bir kümedir, bu nedenle kabul edilebilir dizilerin sırası önemli değildir.

Örnekler:

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

Burada toplam 3 ile kabul edilebilir diziler arıyoruz . İki seçenek vardır [3]ve [2,1]. ( [1,1,1]ve [1,2]toplam 3'e sahip ancak kabul edilemez). Fazlalığı [3]3 ve aşırı [2,1]olan . Böylece, fazla tek dizi olup .$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]])

Fazlalık her zaman dereceden daha az veya ona eşit olduğundan fazla koşulumuz yoktur. Böylece, sadece seçeneklerdir derece 6. tüm kabul edilebilir dizilerini bulmaya çalışıyorsanız [6], [5, 1]ve [4, 2]. (Bunlar fazla , ve .)$6$$5-1 = 4$$4-2=2$

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

Derece 10'un kabul edilebilir dizileri şunlardır:

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

Bunlar sırasıyla , , , , ve , bu nedenle son üçü çalışır.$10$$9-1 = 8$$8-2 = 6$$7-3 = 4$$7-2-1 = 4$$6-3-1=2$

puanlama

Bu kod golf: Bayt en kısa çözüm kazanır.

Test senaryoları:

Çıktının yeniden sıralanması eşit derecede iyidir, bu nedenle girdi (3, 3), çıktı [[3],[2,1]]veya [[2,1],[3]]eşit derecede kabul edilebilirdir (ancak [[1,2],[3]]değildir).

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 bayt

Grimy sayesinde 4 bayt kaydedildi

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

Çevrimiçi deneyin!

açıklama

Ŝ              # 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 Dili (Mathematica) , 67 62 bayt

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

Çevrimiçi deneyin!

-4 bayt by @attinat

• IntegerPartitions@d : İçin toplanan tamsayıların tüm listelerini alın d
• Cases[,...]: Aşağıdaki koşullara göre filtreleyin:
  • 2#& @@# - d <= e &&: İki kez ilk eleman eksi toplam daha azdır eve ...
  • Max@Ratios@#<=.5: Listenin birbirini takip eden unsurlarının oranı 1 / 2'den azdır.

Çünkü eaz .5 daha, biz zincirleme eşitsizlik içine bu açabilirsiniz.

Birkaç ekstra bayt için bu çok daha hızlıdır: Çevrimiçi deneyin!

Jöle ,  16  15 bayt

-1 Outgolfer Erik sayesinde (tek bir filtreye izin veren kontrolde akıllı bir ayarlama)

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

dSolda pozitif bir tamsayıyı eve sağda pozitif tamsayıların listesini veren pozitif bir tamsayıyı kabul eden ikili bir bağlantı .

Çevrimiçi deneyin! (altbilgi, Jelly'nin tam bir program olarak yaptığı örtük liste biçimlendirmesini listelemek için sonuçları biçimlendirir)

Nasıl?

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

Nimi sayesinde 1 bayt kaydedildi

Xnor sayesinde 4 bayt kaydedildi

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

Çevrimiçi deneyin!

JavaScript (V8) ,  88 87  81 bayt

Girişi alır (e)(d). Sekansları STDOUT'a yazdırır.

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)

Çevrimiçi deneyin!

Yorumlananlar

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 bayt

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

Çevrimiçi deneyin!

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 bayt

Dev liste kavrama. Büyük olasılıkla bunu yapmanın en iyi yolu değil, ancak if ifadelerini nasıl atlayacağımı anlayamıyorum

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 bayt

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

Çevrimiçi deneyin!

@Jonas Ausevicius tarafından yapılan düzenlemelere göre

Kömür , 42 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Açıklama:

Ｆθ⊞υ⟦⊕ι⟧

Önce listelerini bir liste oluşturun [1]..[d].

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

Her liste için, ilk kattaki ilk sayıya kadar olan tüm sayıların önüne ekleyerek yeni listeler oluşturun dve bu listeleri işlenecek listeler listesine ekleyin. Bu, daha büyük olmayan sayılar içeren tüm kabul edilebilir dizilerin dyaratılmasını sağlar.

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

Yalnızca derecesi dve fazlalığı büyük olmayan listelerin çıktısını alın e. (Derecenin ve fazlalığın toplamı, listenin ilk sayısının iki katına eşittir.)

Python 3 , 156 bayt

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,egirdi olarak alır ; tuples çıktı listesi

@OrangeCherries'e benzer ve yorumlardan gelen yardım; ancak daha fazla bayt kaydedildi

Çevrimiçi deneyin!

Jöle , 18 bayt

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

Çevrimiçi deneyin!

Ruby , 78 bayt

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

Çevrimiçi deneyin!