हुक लंबाई उत्पाद

Question

एक यंग आरेख बाईं-उचित पंक्तियों और शीर्ष-उचित स्तंभों में बक्से की व्यवस्था है। प्रत्येक बॉक्स के लिए, इसके ऊपर और इसके बाईं ओर के सभी रिक्त स्थान पर कब्जा कर लिया गया है।

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"। आप अपनी इच्छानुसार सूची को आरोही या अवरोही क्रमबद्ध कर सकते हैं। सूची गैर-रिक्त होगी और केवल सकारात्मक पूर्णांक होंगे।

आउटपुट: हुक लंबाई का उत्पाद, जो एक सकारात्मक पूर्णांक है। पूर्णांक या रनटाइम के बारे में चिंता न करें।

विशेष रूप से यंग आरेख या पूर्णांक विभाजन के साथ निर्मित-इंसर्ट करने की अनुमति नहीं है।

परीक्षण के मामलों:

[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

Answer 1

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

इसे यहाँ ऑनलाइन आज़माएँ

Comments

{ee::+W%}_q~%z%:+:*(19 बाइट्स) इनपुट प्रारूप:[[1][1 1 1][1 1 1][1 1 1 1 1]]

— डेनिस

@ डेनिस नीस (एब) के लिए एरिटी ऑर्डर का उपयोग %: पी

— ऑप्टिमाइज़र

Answer 2

जे, 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'

इसे यहाँ ऑनलाइन आज़माएँ।

Answer 3

पायथ - 21 बाइट्स

मैं ऊर्ध्वाधर गणना में बहुत सारे बाइट्स खो रहा हूं। गया कि गोल्फ पर ध्यान केंद्रित।

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

जैसे इनपुट लेता है [5, 3, 3, 1]।

इसे यहाँ ऑनलाइन प्रयास करें ।

Answer 4

पायथ, 18 बाइट्स

*Fsm.e+k-bdf>TdQeQ

आरोही क्रम में इनपुट लेता है, जैसे [1, 3, 3, 5]।

प्रदर्शन।

---

वैकल्पिक समाधान, 19 बाइट्स

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

Answer 5

पायथन 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 में हासिल किया।

एसटीडीआईएन से इनपुट को एक सूची के रूप में आरोही क्रम में लिया जाता है, जैसे [1, 3, 3, 5]।

Answer 6

हास्केल, 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गुणा करके ऊपर से नीचे तक स्कैन करें । fp

Answer 7

आर, 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)

Answer 8

पायथन 2, 135 128 बाइट्स

यह स्टड से अजगर प्रकार की सूची लेता है:

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 है) में संग्रहीत किया जाता है । फिर यह सभी बक्से पर पुनरावृत्त करता है, और हुक की लंबाई को गुणा करता है। प्रत्येक पंक्ति और स्तंभ में बक्सों की गणना करने के बाद हुक की लंबाई स्वयं तुच्छ होती है।

Comments

लगता है कि आप उपयोग नहीं कर रहे हैं m?

— xnor

शपथ ले सकता था कि मैंने इसे हटा दिया! मुझे याद है कि मैं केवल एक बार इसका उपयोग कर रहा था और एकमात्र उपयोग को प्रतिस्थापित कर रहा था। लेकिन तब मैं वास्तव में चर को हटाने के लिए याद किया होगा। :(

— रेटो कोराडी

Answer 9

जावास्क्रिप्ट ( ईएस 6 ) 69

एक फ़ंक्शन आरोही क्रम में पूर्णांकों की एक सरणी लेता है ।

परीक्षण करने के लिए स्निपेट चलाएं (केवल फ़ायरफ़ॉक्स)

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>

Answer 10

पायथन, 95 91 बाइट्स

यह निमि के हास्केल उत्तर का पायथन कार्यान्वयन है । गोल्फ सुझाव का स्वागत करते हैं।

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

Comments

पायथन गोल्फिंग में आपका स्वागत है! आप क्या कर सकते हैं z and _ or 1के रूप में z==[]or _जब zएक सूची है, तथ्य यह है कि का उपयोग कर True==1। पाइथन की फ़ंक्शन घोषणाएँ हास्केल की तुलना में शब्दकार हैं, इसलिए यह अक्सर एकल पुनरावर्ती फ़ंक्शन को परिभाषित करने के लिए एक अच्छा भुगतान देता है जो आंतरिक और बाहरी दोनों पुनरावर्ती छोरों को करता है, हालांकि मुझे नहीं पता कि यहां कितना संभव है।

— xnor

@xnor "पायथन गोल्फिंग में आपका स्वागत है"?

— शर्लक 9

ओह, क्षमा करें, आप पायथन में गोल्फ करते हैं। मैं आपको वास्तव में जोड़ता हूं।

— xnor

@ एक्सनोर लोंग, वास्तव में शुरू होने से बहुत पहले, मैं पायथन में गोल्फ कर रहा था। मैं थोड़ा याद कर रहा हूं कि आपको याद नहीं है: P

— Sherlock9

मैं xnor के लिए नहीं बोल सकता, लेकिन मैं उपयोगकर्ताओं को मुख्य रूप से उनके अवतार से पहचानता हूं।

— डेनिस