Một sơ đồ trẻ là một sự sắp xếp của các hộp trong hàng trái lý và cột hàng đầu hợp lý. Đối với mỗi hộp, tất cả các khoảng trắng phía trên nó và bên trái của nó đều bị chiếm dụng.

XXXXX
XXX
XXX
X

Độ dài móc của hộp là số hộp ở bên phải trong hàng của nó và bên dưới cột trong cột của nó, cũng tự đếm một lần. Ví dụ: hộp thứ hai có chiều dài móc là 6:

X****
X*X
X*X
X

Dưới đây là tất cả các độ dài móc:

86521
532
421
1

Mục tiêu của bạn là tính toán sản phẩm của độ dài móc, ở đây 8*6*5*2*1*5*3*2*4*2*1*1 = 115200.

(Đọc về công thức độ dài móc nếu bạn quan tâm đến lý do tại sao biểu thức này quan trọng.)

Đầu vào: Tập hợp các kích thước hàng dưới dạng số như [5,3,3,1]hoặc dưới dạng ký hiệu đơn nguyên lặp lại như [[1,1,1,1,1], [1,1,1], [1,1,1], [1]]hoặc "XXXXX XXX XXX X". Bạn có thể mong đợi danh sách được sắp xếp tăng dần hoặc giảm dần, như bạn muốn. Danh sách sẽ không trống và chỉ chứa các số nguyên dương.

Đầu ra: Sản phẩm có độ dài móc, là số nguyên dương. Đừng lo lắng về số nguyên tràn hoặc thời gian chạy.

Không được phép tích hợp cụ thể với sơ đồ Young hoặc phân vùng số nguyên.

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

[1] 1
[2] 2
[1, 1] 2
[5] 120
[2, 1] 3
[5, 4, 3, 2, 1] 4465125
[5, 3, 3, 1] 115200
[10, 5] 798336000

CJam, 20 19 byte

{ee::+W%}_q~%z%:+:*

Điều này có trong danh sách unary phong cách CJam theo thứ tự tăng dần. Ví dụ:

[[1] [1 1 1] [1 1 1] [1 1 1 1 1]]

cho

115200

Làm thế nào nó hoạt động

Phiên bản này được cung cấp bởi Dennis và nó sử dụng thực tế là Block ArrayList %vẫn hoạt động trong CJam: D

{       }_             e# Put this block on stack and make a copy
          q~           e# Read the input and evaluate it to put the array of arrays on stack
            %          e# Use the copy of the block and map the array using that block
 ee                    e# Here we are mapping over each unary array in the input. ee converts
                       e# the array to [index value] pair.
   ::+                 e# Add up each index value pair. Now we have the horizontal half of
                       e# hook length for each row
      W%               e# Reverse the array to make sure the count is for blocks to the right
             z%        e# Transpose and do the same mapping for columns
               :+      e# Now we have all the hook lengths. Flatten the array
                 :*    e# Get the product of all hook lengths.

Đây là phiên bản 20 byte gốc

1q~:,Wf%z:ee{:+)*}f/

Điều này có trong một danh sách kiểu kích thước hàng của CJam theo thứ tự tăng dần. Ví dụ:

[1 3 3 5]

cho

115200

Làm thế nào nó hoạt động

Nếu chúng ta nhìn vào nó, độ dài móc của mỗi khối trong sơ đồ khối Trẻ là tổng chỉ số của khối đó trong hàng và cột của nó, tính ngược lại. tức là bắt đầu chỉ mục ở mỗi hàng từ bên phải và bắt đầu chỉ mục ở mỗi cột từ dưới lên.

Chúng tôi lấy đầu vào theo thứ tự tăng dần của kích thước hàng để dễ dàng bắt đầu chỉ mục từ dưới cùng trong mỗi cột. Đầu tiên, chúng tôi nhận được chỉ số trên mỗi hàng và đảo ngược nó. Sau đó, chúng tôi chuyển đổi. Vì thứ tự hàng ban đầu đã được đảo ngược, lấy chỉ số trong sơ đồ chuyển đổi này sẽ trực tiếp đưa ra chỉ số từ dưới lên trên.

Mở rộng mã

1                       e# This serves as the initial term for product of hook lengths
 q~                     e# Read the input and eval it to put an array on stack
   :,                   e# For each row-size (N), get an array of [0..N-1]
     Wf%                e# Reverse each row so that each row becomes [N-1..0]
        z               e# Transpose for the calculation of blocks below each block
         :ee            e# Enumerate each row. Convert it into array of [index value] pairs
            {    }f/    e# Apply this mapping block to each cell of each row
             :+         e# Add the index value pair. Here, index is the blocks below the
                        e# block and value is the blocks to the right of it in the Young diag
               )        e# Increment the sum by 1 to account for the block itself
                *       e# Multiply it with the current holding product, starting with 1

Dùng thử trực tuyến tại đây

J, 24 byte

*/@,@(1|@-+/\."1++/\)@:>

25 byte (có giải thích):

*/@,@(+/\."1|@<:@++/\)@:>

Lấy đầu vào là danh sách các danh sách tăng dần của các chữ số unary tương tự như ví dụ [[1], [1,1,1], [1,1,1], [1,1,1,1,1]].

Sử dụng:

   f=.*/@,@(+/\."1|@<:@++/\)@:>

   f 1;1 1 1;1 1 1;1 1 1 1 1
115200

phương pháp

• Tạo ma trận nhị phân từ đầu vào
• Tính toán sự khác biệt chạy trong cả hai chiều.
• Đối với mỗi ô, thêm hai kết quả, trừ 1, lấy giá trị tuyệt đối (để ánh xạ các ô 0 ban đầu thành 1)
• Ravel ma trận và lấy tích của các số.

Kết quả trung gian hiển thị trên đầu vào 1 1 1 1 1;1 1 1;1 1 1;1 (5,3,3,1 in unary)( đây là phiên bản trước có độ dài giảm dần nhưng sử dụng cùng một phương pháp ):

   ]c=.1 1 1 1 1;1 1 1;1 1 1;1
┌─────────┬─────┬─────┬─┐
│1 1 1 1 1│1 1 1│1 1 1│1│
└─────────┴─────┴─────┴─┘

   (>)  c
1 1 1 1 1
1 1 1 0 0
1 1 1 0 0
1 0 0 0 0

   (+/\.@:>)  c
4 3 3 1 1
3 2 2 0 0
2 1 1 0 0
1 0 0 0 0

   (+/\."1@:>)  c
5 4 3 2 1
3 2 1 0 0
3 2 1 0 0
1 0 0 0 0

   ((+/\."1++/\.)@:>)  c
9 7 6 3 2
6 4 3 0 0
5 3 2 0 0
2 0 0 0 0

   ((+/\."1<:@++/\.)@:>)  c
8  6  5  2  1
5  3  2 _1 _1
4  2  1 _1 _1
1 _1 _1 _1 _1

   ((+/\."1|@<:@++/\.)@:>)  c
8 6 5 2 1
5 3 2 1 1
4 2 1 1 1
1 1 1 1 1

   (,@(+/\."1|@<:@++/\.)@:>)  c
8 6 5 2 1 5 3 2 1 1 4 2 1 1 1 1 1 1 1 1

   (*/@,@(+/\."1|@<:@++/\.)@:>)  c
115200

Phiên bản rõ ràng cùng chiều dài:

3 :'*/,|<:(+/\."1++/\)>y'

Hãy thử trực tuyến tại đây.

Pyth - 21 byte

Tôi đang mất rất nhiều byte trong tính toán dọc. Gonna tập trung vào việc chơi golf đó.

*Fs.em+lf>Td>Qkt-bdbQ

Đưa đầu vào như thế nào [5, 3, 3, 1].

Hãy thử nó ở đây trực tuyến .

Bình thường, 18 byte

*Fsm.e+k-bdf>TdQeQ

Đưa đầu vào theo thứ tự tăng dần, như [1, 3, 3, 5].

Trình diễn.

Giải pháp thay thế, 19 byte

*Fs.em+s>Rd<Qk-bdbQ

Python 2, 89 88 byte

p=j=-1;d={}
for n in input():j+=1;i=0;exec"a=d[i]=d.get(i,j);p*=n-i+j-a;i+=1;"*n
print-p

(Cảm ơn @xnor vì đã lưu một byte điên rồ bằng cách kết hợp pvà j)

Có d.getvẻ hơi nghi ngờ đối với tôi, nhưng nếu không thì tôi tương đối hài lòng với điều này. Tôi đã thử một số cách tiếp cận khác, như đệ quy và nén, nhưng đây là cách duy nhất tôi quản lý để có được dưới 100.

Lấy đầu vào từ STDIN làm danh sách theo thứ tự tăng dần, vd [1, 3, 3, 5].

Haskell, 68 byte

f[]=1
f g@(h:t)=(h+length t)*f[x-1|x<-g,x>1]
p[]=1
p g@(_:t)=f g*p t

Ví dụ sử dụng: p [5,4,3,2,1]->4465125

fquét từ trái sang phải bằng cách nhân độ dài của móc ngoài cùng với lệnh gọi đệ quy đến chính nó trong đó từng phần tử của danh sách đầu vào được giảm bằng cách 1(thả nó khi đạt 0). pquét từ trên xuống dưới bằng cách nhân ftoàn bộ danh sách với pđuôi.

R, 174 byte

Vì vậy, ... Giải pháp này khá dài và có thể được chơi nhiều hơn. Tôi sẽ nghĩ về nó !

v=c();d=length;m=matrix(-1,l<-d(a<-scan()),M<-max(a));for(i in 1:l)m[i,(1:a[i])]=c(a[i]:1);for(j in 1:M)m[,j]=m[,j]+c((((p=d(which(m[,j]>0)))-1)):0,rep(0,(l-p)));abs(prod(m))

Ung dung:

v=c()          #Empty vector
d=length       #Alias

m=matrix(-1,l<-d(a<-scan()),M<-max(a)) #Builds a matrix full of `-1`

for(i in 1:l)
    m[i,(1:a[i])]=c(a[i]:1) #Replaces each row of the matrix by `n` to 1, `n` being the 
                            #corresponding input : each number is the number of non-empty
                            #cells at its left + itself

for(j in 1:M)
    m[,j]=m[,j]+c((((p=d(which(m[,j]>0)))-1)):0,rep(0,(l-p)))

    #This part calculates the number of "non-empty" (i.e. without `-1` in a column), -1,
    #because the count for the cell itself is already done.
    # Then, it creates a vector of those count, appending 0's at the end if necessary 
    #(this avoids recycling)

abs(prod(m)) #Outputs the absolute value of the product (because of the `-1`'s)

Python 2, 135 128 byte

Cái này lấy danh sách kiểu Python từ stdin:

r=input()
c=[-1]*r[0]
for a in r:
 for b in range(a):c[b]+=1
s=1
y=0
for a in r:
 for x in range(a):s*=a-x+c[x]-y
 y+=1
print s

Đây là một triển khai rất kinh điển, nhưng cho đến nay tôi chưa nghĩ ra thứ gì thông minh hơn nhiều. Tôi có cảm giác rằng sẽ có nhiều giải pháp ngắn hơn ngay cả với các ngôn ngữ lập trình "thực".

Chúng tôi nhận được số lượng hộp trong mỗi hàng làm đầu vào. Giải pháp này trước tiên đếm số lượng hộp trong mỗi cột, được lưu trữ trong cđó (thực tế là số đếm trừ 1 để đơn giản hóa việc sử dụng nó trong tính toán sau). Sau đó, nó lặp đi lặp lại trên tất cả các hộp và nhân chiều dài móc. Độ dài móc tự nó là tầm thường để tính toán khi bạn có số lượng hộp trong mỗi hàng và cột.

JavaScript ( ES6 ) 69

Một hàm lấy một mảng các số nguyên theo thứ tự tăng dần .

Chạy đoạn mã để kiểm tra (chỉ dành cho Firefox)

F=x=>x.map(r=>{for(i=-1;++i<r;p[i]=-~p[i])t*=r-i+~~p[i]},p=[],t=1)&&t

// TEST
out=x=>O.innerHTML += x + '\n';

test=[
 {y:[1], h: 1}
,{y:[2], h: 2}
,{y:[1, 1], h: 2}
,{y:[5], h: 120}
,{y:[2, 1], h: 3}
,{y:[5, 4, 3, 2, 1], h: 4465125}
,{y:[5, 3, 3, 1], h: 115200}
,{y:[10, 5], h: 798336000}
]

test.forEach(t=>{ 
  t.y.reverse(); // put in ascending order
  r=F(t.y);
  out((r==t.h? 'Ok':'Fail')+' Y: ['+t.y+'] Result:'+r+' Check:'+t.h)
})  

<pre id=O></pre>

Python, 95 91 byte

Đây là một triển khai Python của câu trả lời Haskell của nimi . Gợi ý chơi golf chào mừng.

f=lambda z:z==[]or(z[0]+len(z)-1)*f([i-1for i in z if~-i])
p=lambda z:z==[]or f(z)*p(z[1:])