Bir küçük diyagramı sola yaslanmış satır ve üst yanaşık sütunlardaki kutuları bir düzenlemedir. Her kutu için, üstündeki ve solundaki tüm boşluklar doludur.

XXXXX
XXX
XXX
X

Kanca uzunluğu bir kutu satırdaki onun sağ kutularının sayısı, ve, altında sütununda, de kendini sayma. Örneğin, ikinci kutunun 6 uzunluğunda bir kanca uzunluğu vardır:

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

İşte tüm kanca uzunlukları:

86521
532
421
1

Amacınız , burada kanca uzunluklarının ürününü hesaplamak 8*6*5*2*1*5*3*2*4*2*1*1 = 115200.

( Bu ifadenin neden önemli olduğunu düşünüyorsanız , kanca uzunluğu formülünü okuyun .)

Girdi: gibi numaraları gibi satır boyutları koleksiyonu [5,3,3,1]ya da benzeri bir tekrarlanan tek terimli sembolü olarak [[1,1,1,1,1], [1,1,1], [1,1,1], [1]]ya "XXXXX XXX XXX X". Listenin istediğiniz gibi yükselmesini veya alçalmasını bekleyebilirsiniz. Liste boş olmayacak ve yalnızca pozitif tamsayılar içerecektir.

Çıktı: Olumlu bir tamsayı olan kanca uzunluklarının ürünü. Tamsayı taşması veya çalışma zamanı hakkında endişelenmeyin.

Özellikle Young diyagramları veya tamsayı bölümleri ile ilgilenen yerleşiklere izin verilmez.

Test durumları:

[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 bayt

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

Bu artan sırada CJam tarzı unary listesini alır. Örneğin:

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

verir

115200

Nasıl çalışır

Bu sürüm Dennis tarafından sağlanmıştır ve Block ArrayList %hala bir CJam: D'de çalışmaktadır.

{       }_             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.

Bu orijinal 20 byte versiyonudur

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

Bu, artan bir sırayla satır boyutlarının CJam stilinde alınmasını sağlar. Örneğin:

[1 3 3 5]

verir

115200

Nasıl çalışır

Buna bakarsak, Genç blok şemasındaki her bloğun kanca uzunluğu, geriye doğru sayarak, o satırın satırında ve sütununda bulunan dizinin toplamıdır. yani Her satırdaki dizini sağ taraftan başlatın ve her sütundaki dizini alttan başlatın.

Dizini her sütunda alttan kolayca başlatmak için girdiyi artan sıra boyutunda alıyoruz. Öncelikle, satır başına dizini alıp tersine çeviririz. O zaman devrediyoruz. Orijinal sıra sırası tersine çevrildiği için, bu aktarılan şemada indeks alınması, doğrudan aşağıdan yukarıya doğru dizini verecektir.

Kod genişletme

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

Burada çevrimiçi deneyin

J, 24 bayt

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

25 bayt (açıklama ile):

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

Girdiyi, örneğe benzer şekilde artan basamak sayı listelerinin listesi olarak alır [[1], [1,1,1], [1,1,1], [1,1,1,1,1]].

Kullanımı:

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

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

Yöntem

• Girişten bir ikili matris oluşturma
• Her iki boyutta çalışan farkları hesaplayın.
• Her hücre için iki sonuç ekleyin, 1 çıkarın, mutlak değeri alın (başlangıçta sıfır hücreleri 1 ile eşleştirmek için)
• Matrisi Ravel ve sayıların çarpımını alın.

Girişte gösterilen orta düzey sonuçlar 1 1 1 1 1;1 1 1;1 1 1;1 (5,3,3,1 in unary)( bu, azalan uzunluklara sahip ancak aynı yöntemi kullanan önceki sürüm içindir ):

   ]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

Aynı uzunluktaki açık sürüm:

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

Burada çevrimiçi deneyin.

Pyth - 21 bayt

Dikey hesaplamada çok fazla bayt kaybediyorum. Bunu golf oynamaya odaklanacağım.

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

Gibi girdi alır [5, 3, 3, 1].

Burada çevrimiçi deneyin .

Pyth, 18 bayt

*Fsm.e+k-bdf>TdQeQ

Gibi artan sırada girdi alır [1, 3, 3, 5].

Gösteri.

Alternatif çözüm, 19 bayt

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

Python 2, 89 88 bayt

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

(Bir deliye bayt için @xnor sayesinde birleştirerek tasarruf edin p ve j)

d.getBana biraz şüpheli görünüyor, ama aksi takdirde bu nispeten mutluyum. Özyineleme ve sıkıştırma gibi başka yaklaşımlar da denedim, ancak 100'ün altına girmeyi başardığım tek şey bu.

STDIN'den girişi artan sırada bir liste halinde alır, örn [1, 3, 3, 5].

Haskell, 68 bayt

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

Kullanım örneği: p [5,4,3,2,1]->4465125

ftekrarlayan bir çağrı ile en dıştaki kanca uzunluğunu giriş listesindeki her bir elemanın azaltıldığı yerde 1(ulaşırken bırakarak 0) çarparak soldan sağa tarar . Tüm listeyi kuyruğuyla pçarparak yukarıdan aşağıya doğru tarar . fp

R, 174 bayt

Yani ... Bu çözüm oldukça uzun ve muhtemelen daha fazla golf oynayabilir. Bunun üzerinde düşüneceğim !

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

Ungolfed:

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 bayt

Bu stdin'den bir Python tipi listesi alır:

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

Bu çok kanonik bir uygulama ama şimdiye kadar daha akıllıca bir şey bulamadım. "Gerçek" programlama dilleri ile bile çok daha kısa çözümler olacağını hissediyorum.

Her satırdaki kutu sayısını girdi olarak alıyoruz. Bu çözüm ilk olarak, her bir sütundaki depolanan kutu sayısını sayar c(aslında sonraki hesaplamalardaki kullanımını basitleştirmek için 1 eksi sayısıdır). Sonra tüm kutular üzerinde yinelenir ve kanca uzunluklarını çoğaltır. Kanca uzunluğu, her satırda ve sütunda kutu sayısını aldıktan sonra hesaplamak için çok önemlidir.

JavaScript ( ES6 ) 69

Artan bir tamsayı dizisi alan işlev düzende .

Test edilecek pasajı çalıştırın (yalnızca 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 bayt

Bu, Nimi'nin Haskell cevabının Python uygulamasıdır . Golf önerileri kabul edilir.

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