L'algebra di Steenrod è un'importante algebra che emerge dalla topologia algebrica. L'algebra di Steenrod è generata da operatori chiamati "quadrati di Steenrod", ne esiste uno per ogni numero intero i. C'è una base per l'algebra di Steenrod che consiste in "monomi ammissibili" nelle operazioni di squadratura. Il nostro obiettivo è generare questa base.

Una sequenza di numeri interi positivi viene definita ammissibile se ogni numero intero è almeno il doppio di quello successivo. Ad esempio, [7,2,1]è ammissibile perché e . D'altra parte, non è ammissibile perché . (In topologia dovremmo scrivere per la sequenza ).$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]

Il grado di una sequenza è il totale delle sue voci. Ad esempio, il grado di [7,2,1]è . L' eccesso di una sequenza ammissibile è il primo elemento meno il totale degli elementi rimanenti, quindi ha un eccesso di .$7 + 2 + 1 = 10$[7,2,1]$7 - 2 - 1 = 4$

Compito

Scrivi un programma che accetta una coppia di numeri interi positivi (d,e)e genera l'insieme di tutte le sequenze ammissibili di grado de eccesso inferiore o uguale a e. L'output è un set quindi l'ordine delle sequenze ammissibili non ha importanza.

Esempi:

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

Qui stiamo cercando sequenze ammissibili per un totale di 3. Esistono due opzioni [3]e [2,1]. ( [1,1,1]e [1,2]hanno la somma 3 ma non sono ammessi). L'eccesso di [3]è 3 e l'eccesso di [2,1]è . Pertanto, l'unica sequenza con eccesso di è .$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]])

Poiché l'eccesso è sempre inferiore o uguale al grado, non abbiamo alcuna condizione in eccesso. Così, stiamo solo cercando di trovare tutte le sequenze ammissibili di grado 6. Le opzioni sono [6], [5, 1]e [4, 2]. (Questi hanno un eccesso di , e )$6$$5-1 = 4$$4-2=2$

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

Le sequenze ammissibili di grado 10 sono:

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

Questi hanno un eccesso di , , , , e rispettivamente, quindi gli ultimi tre funzionano tutti.$10$$9-1 = 8$$8-2 = 6$$7-3 = 4$$7-2-1 = 4$$6-3-1=2$

punteggio

Questo è il codice golf: vince la soluzione più breve in byte.

Casi test:

Qualsiasi riordino dell'uscita è ugualmente buono, quindi per input (3, 3), output [[3],[2,1]]o [[2,1],[3]]sono ugualmente accettabili (comunque [[1,2],[3]]non lo è).

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

Salvato 4 byte grazie a Grimy

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

Provalo online!

Spiegazione

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

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

Provalo online!

-4 byte di @attinat

• IntegerPartitions@d : Visualizza tutti gli elenchi di numeri interi che sommano d
• Cases[,...]: Filtra per la seguente condizione:
  • 2#& @@# - d <= e &&: Due volte il primo elemento meno la somma è inferiore a e, e ...
  • Max@Ratios@#<=.5: I rapporti degli elementi successivi dell'elenco sono tutti inferiori a 1/2.

Poiché eè inferiore a 0,5, possiamo trasformarlo in una disuguaglianza incatenata.

Per qualche byte in più, questo è molto più veloce: provalo online!

Gelatina ,  16  15 byte

-1 grazie a Erik the Outgolfer (una regolazione intelligente del controllo che consente un singolo filtro)

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

Un collegamento diadico che accetta un numero intero positivo d, a sinistra e un numero intero positivo e, a destra che produce un elenco di elenchi di numeri interi positivi.

Provalo online! (il piè di pagina formatta i risultati per evitare di elencare la formattazione dell'elenco implicito che Jelly esegue come programma completo)

Come?

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

1 byte salvato grazie a nimi

4 byte salvati grazie a xnor

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

Provalo online!

JavaScript (V8) ,  88 87  81 byte

Accetta input come (e)(d). Stampa le sequenze su 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)

Provalo online!

Commentate

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 byte

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

Provalo online!

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

Comprensione dell'elenco gigante. Molto probabilmente non è il modo migliore per farlo, ma non riesco a capire come saltare le dichiarazioni 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)])

Provalo online!

Secondo le modifiche di @Jonas Ausevicius

Carbone , 42 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

Ｆθ⊞υ⟦⊕ι⟧

Innanzitutto creare un elenco di elenchi da [1]..[d].

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

Per ogni elenco creare nuovi elenchi prefissando tutti i numeri dal primo numero raddoppiato fino a de aggiungendo tali elenchi all'elenco di elenchi da elaborare. Ciò garantisce che dvengano create tutte le sequenze ammissibili contenenti numeri non superiori a .

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

Produce solo quegli elenchi il cui grado è de l'eccesso non è maggiore di e. (La somma del grado e dell'eccedenza è pari al doppio del primo numero dell'elenco.)

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*

accetta d,ecome input; elenca le tuple in output

Simile alla risposta @OrangeCherries e aiuto dai commenti; ma più byte salvati

Provalo online!

Gelatina , 18 byte

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

Provalo online!

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

Provalo online!