Діаграма Юнга є розташуванням ящиків в лівому вирівнюванні рядків і топ вирівнюванням стовпців. У кожному ящику зайняті всі пробіли над ним та зліва від нього.

XXXXX
XXX
XXX
X

Довжина гачка коробки - це кількість ящиків праворуч у її ряду, а під ним у стовпчику, також рахуючи себе один раз. Наприклад, другий ящик має довжину гачка 6:

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

Ось усі довжини гачка:

86521
532
421
1

Ваша мета - тут обчислити добуток довжин гака 8*6*5*2*1*5*3*2*4*2*1*1 = 115200.

(Прочитайте формулу довжини гачка, якщо вас цікавить, чому це вираження має значення.)

Введення: Колекція розмірів рядків у вигляді чисел, таких як [5,3,3,1]або як повторний одинарний символ, як [[1,1,1,1,1], [1,1,1], [1,1,1], [1]]або "XXXXX XXX XXX X". Ви можете розраховувати, що список буде відсортований за зростанням чи за спаданням за вашим бажанням. Список буде не порожнім і міститиме лише додатні цілі числа.

Вихід: Добуток довжини гака, який є додатним цілим числом. Не хвилюйтеся з приводу цілих переливів чи часу виконання.

Вбудовані модулі, що стосуються діаграм Young або цілих розділів, заборонені.

Тестові приклади:

[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 байт

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

Це приймає урядовий список у стилі CJam у порядку зростання. Наприклад:

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

дає

115200

Як це працює

Ця версія надана Деннісом, і вона використовує той факт, що Block ArrayList %все ще працює в 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.

Це оригінальна версія в 20 байт

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

Це включає список стилів CJam розмірів рядків у порядку зростання. Наприклад:

[1 3 3 5]

дає

115200

Як це працює

Якщо ми подивимось на це, довжина гачка кожного блоку на блок-схемі Янг - це сума індексу цього блоку в його рядку та стовпці, рахуючи назад. тобто Почніть індекс у кожному рядку з правого боку та запустіть індекс у кожному стовпці знизу.

Ми приймаємо вхід у порядку зростання розміру рядків, щоб легко запустити індекс знизу в кожному стовпці. Спочатку отримуємо індекс на рядок і повертаємо його назад. Потім переносимо. Оскільки початковий порядок рядків був перетворений, то індекс у цій транспонованій діаграмі безпосередньо дасть індекс знизу до верхнього.

Розширення коду

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

Спробуйте його онлайн тут

J, 24 байти

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

25 байт (з поясненням):

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

Вводиться в якості списку висхідних списків одинарних цифр, аналогічних прикладу [[1], [1,1,1], [1,1,1], [1,1,1,1,1]].

Використання:

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

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

Метод

• Створіть бінарну матрицю із вхідних даних
• Обчисліть ходові різниці в обох вимірах.
• Для кожної комірки додайте два результати, віднімайте 1, приймайте абсолютне значення (для відображення спочатку нульових комірок до 1)
• Розірвіть матрицю і візьміть добуток чисел.

Проміжні результати, показані на вході 1 1 1 1 1;1 1 1;1 1 1;1 (5,3,3,1 in unary)( це для попередньої версії зі зменшенням довжини, але з використанням того ж методу ):

   ]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

Явна версія однакової довжини:

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

Спробуйте його онлайн тут.

Pyth - 21 байт

Я втрачаю багато байт при вертикальному обчисленні. Зосередимось на тому, щоб грати в гольф.

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

Приймає вхід як [5, 3, 3, 1].

Спробуйте це онлайн .

Піт, 18 байт

*Fsm.e+k-bdf>TdQeQ

Приймає введення у порядку зростання, як [1, 3, 3, 5].

Демонстрація.

Черговий розчин, 19 байт

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

Python 2, 89 88 байт

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

(Завдяки @xnor за один божевільний байт збереження, комбінуючи pта j)

d.getВиглядає трохи підозріло до мене, але в іншому я щодо задоволений цим. Я спробував деякі інші підходи, такі як рекурсія та блискавка, але це єдиний, кому мені вдалося потрапити під 100.

Приймає дані зі STDIN як список у порядку зростання, наприклад [1, 3, 3, 5].

Хаскелл, 68 байт

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

Приклад використання: p [5,4,3,2,1]->4465125

fсканування зліва направо шляхом множення довжини крайнього гака з рекурсивним викликом до себе, де кожен елемент вхідного списку зменшується 1(опускаючи його при досягненні 0). pсканування зверху вниз шляхом множення fвсього списку pна хвіст.

R, 174 байти

Отже ... Це рішення є досить довгим і, ймовірно, може бути більше гольфу. Я буду думати про це !

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

Безголівки:

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 байт

Для цього потрібен список типів Python від 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

Це дуже канонічна реалізація, але я поки що не придумав нічого набагато розумнішого. У мене є відчуття, що навіть із "справжніми" мовами програмування будуть набагато коротші рішення.

Ми отримуємо кількість полів у кожному рядку як вхідні дані. Це рішення спочатку підраховує кількість полів у кожному стовпчику, в якому зберігається c(фактично це число мінус 1 для спрощення його використання в подальшому обчисленні). Потім він повторюється по всіх ящиках і помножує довжину гачка. Сама довжина гачка є тривіальною для обчислення, коли у вас буде кількість полів у кожному рядку та стовпці.

JavaScript ( ES6 ) 69

Функція, що приймає масив цілих чисел у порядку зростання .

Запустіть фрагмент для тестування (лише 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>

Пітон, 95 91 байт

Це реалізація Python на відповідь Haskell Німі . Пропозиції з гольфу вітаються.

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