Khi nhân các đơn thức trong cơ sở Milnor cho đại số Steenrod, một phần của thuật toán bao gồm việc liệt kê một số "ma trận cho phép" nhất định.

Cho hai danh sách các số nguyên không âm r ₁ , ..., r _m và s ₁ , ..., s _n , một ma trận các số nguyên không âm X

được phép nếu

1. Tổng của cột thứ j nhỏ hơn hoặc bằng s _j :

   

2. Tổng của hàng thứ i có trọng số bằng 2 là nhỏ hơn hoặc bằng r _i :

   

Bài tập

Viết chương trình lấy một cặp danh sách r ₁ , ..., r _m và s ₁ , s ₁ , ..., s _n và tính số lượng ma trận cho phép cho các danh sách này. Chương trình của bạn có thể tùy chọn lấy m và n làm đối số bổ sung nếu cần.

• Những con số này có thể được nhập vào ở bất kỳ định dạng nào mà một lượt thích, ví dụ được nhóm thành danh sách hoặc được mã hóa dưới dạng unary hoặc bất cứ thứ gì khác.

• Đầu ra phải là số nguyên dương

• Tiêu chuẩn áp dụng.

Chấm điểm

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

Ví dụ:

Cho [2]và [1], có hai ma trận cho phép:

Cho [4]và [1,1]có ba ma trận cho phép:

Cho [2,4]và [1,1]có năm ma trận cho phép:

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

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

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

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

   Input: [2,4], [1,1]   
   Output: 5      

   Input: [3,5,7], [1,2]
   Output: 14

   Input: [7, 10], [1, 1, 1]
   Output: 15       

   Input: [3, 6, 16, 33], [0, 1, 1, 1, 1]
   Output: 38      

   Input: [7, 8], [3, 3, 1]
   Output: 44

   Input: [2, 6, 15, 18], [1, 1, 1, 1, 1]
   Output: 90       

   Input: [2, 6, 7, 16], [1, 3, 2]
   Output: 128

   Input: [2, 7, 16], [3, 3, 1, 1]
   Output: 175

JavaScript (ES7), 163 byte

f=([R,...x],s)=>1/R?[...Array(R**s.length)].reduce((k,_,n)=>(a=s.map((_,i)=>n/R**i%R|0)).some(c=>(p+=c<<++j)>R,p=j=0)?k:k+f(x,s.map((v,i)=>v-a[i])),0):!/-/.test(s)

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

Lưu ý : Tôi đã xóa hai trường hợp thử nghiệm tốn nhiều thời gian nhất khỏi đoạn mã này, nhưng chúng cũng sẽ vượt qua.

f=([R,...x],s)=>1/R?[...Array(R**s.length)].reduce((k,_,n)=>(a=s.map((_,i)=>n/R**i%R|0)).some(c=>(p+=c<<++j)>R,p=j=0)?k:k+f(x,s.map((v,i)=>v-a[i])),0):!/-/.test(s)

console.log(f([1],[2]))            // 1
console.log(f([2],[1]))            // 2
console.log(f([4],[1,1]))          // 3
console.log(f([2,4],[1,1]   ))     // 5      
console.log(f([3,5,7],[1,2]))      // 14
console.log(f([7,10],[1,1,1]))     // 15       
console.log(f([7,8],[3,3,1]))      // 44
console.log(f([2,6,7,16],[1,3,2])) // 128
console.log(f([2,7,16],[3,3,1,1])) // 175

Đã bình luận

f = (                               // f = recursive function taking:
  [R,                               //   - the input array r[] splitted into:
      ...x],                        //     R = next element / x = remaining elements
  s                                 //   - the input array s[]
) =>                                //
  1 / R ?                           // if R is defined:
    [...Array(R**s.length)]         //   for each n in [0, ..., R**s.length - 1],
    .reduce((k, _, n) =>            //   using k as an accumulator:
      (a =                          //     build the next combination a[] of
        s.map((_, i) =>             //     N elements in [0, ..., R - 1]
          n / R**i % R | 0          //     where N is the length of s[]
        )                           //
      ).some(c =>                   //     for each element c in a[]:
        (p += c << ++j)             //       increment j; add c * (2**j) to p
        > R,                        //       exit with a truthy value if p > R
        p = j = 0                   //       start with p = j = 0
      ) ?                           //     end of some(); if truthy:
        k                           //       just return k unchanged
      :                             //     else:
        k +                         //       add to k the result of
        f(                          //       a recursive call to f() with:
          x,                        //         the remaining elements of r[]
          s.map((v, i) => v - a[i]) //         s[] updated by subtracting the values of a[]
        ),                          //       end of recursive call
      0                             //     initial value of the accumulator k
    )                               //   end of reduce()
  :                                 // else:
    !/-/.test(s)                    //   return true if there's no negative value in s[]

Thạch , 26 byte

UḄ€Ḥ>⁴
0rŒpṗ⁴L¤µS>³;ÇẸµÐḟL

Một chương trình đầy đủ lấy S , R in số đếm

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

Làm sao?

UḄ€Ḥ>⁴ - Link 1, row-wise comparisons: list of lists, M
U      - upend (reverse each)
 Ḅ€    - convert €ach from binary (note bit-domain is unrestricted, e.g. [3,4,5] -> 12+8+5)
   Ḥ   - double (vectorises) (equivalent to the required pre-bit-shift by one)
     ⁴ - program's 2nd input, R
    >  - greater than? (vectorises)

0rŒpṗ⁴L¤µS>³;ÇẸµÐḟL - Main link: list S, list R
0r                  - inclusive range from 0 to s for s in S
  Œp                - Cartesian product of those lists
       ¤            - nilad followed by link(s) as a nilad:
     ⁴              -   program's 2nd input, R
      L             -   length
    ṗ               - Cartesian power = all M with len(R) rows & column values in [0,s]
        µ      µÐḟ  - filter discard if:
         S          -   sum (vectorises) = column sums
           ³        -   program's 1st input, S
          >         -   greater than? (vectorises) = column sum > s for s in S
             Ç      -   call the last link (1) as a monad = sum(2^j × row) > r for r in R
            ;       -   concatenate
              Ẹ     -   any truthy?
                  L - length

Ngôn ngữ Wolfram (Mathicala) , 101 byte

Hãy để Mathicala giải nó như một hệ bất đẳng thức so với các số nguyên. Tôi thiết lập một mảng tượng trưng trong fvà xâu chuỗi qua ba bộ bất đẳng thức. Join@@chỉ làm phẳng danh sách cho Solve.

Length@Solve[Join@@Thread/@{Tr/@(t=f~Array~{q=(l=Length)@#2,l@#})<=#2,2^Range@q.t<=#,t>=0},Integers]&

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

Toán học 139 byte

Tr@Boole[k=Length[a=#]+1;AllTrue[a-Rest[##+0],#>=0&]&@@@Tuples[BinCounts[#,{2r~Prepend~0}]&/@IntegerPartitions[#,All,r=2^Range@k/2]&/@#2]]&

Dùng thử trực tuyến

Giải thích: Phân vùng mỗi r _i vào quyền hạn của 2 và sau đó làm cho tất cả bộ dữ liệu với một phân hủy vào quyền hạn của hai đối với mỗi số nguyên, trừ đi tổng số cột từ danh sách các s _i . Đếm số lượng bộ dữ liệu làm cho tất cả các mục còn lại là dương.