पास्कल का रोम्बस

Question

पास्कल का रोम्बस (जो वास्तव में एक त्रिकोण है) पैटर्न में जोड़कर प्राप्त किया जाता है:

  *
 ***
  x

के बजाय

* *
 x

इसका मतलब यह है कि प्रत्येक कोशिका इसके ऊपर की पंक्ति पर तीन कोशिकाओं का योग है और इसके ऊपर पंक्ति 2 पर एक सेल है। पास्कल के त्रिकोण की तरह ही ज़ीरोथ पंक्ति इस पर एक एकल है 1जो त्रिकोण उत्पन्न करती है।

यहाँ पास्कल के रॉम्बस की पंक्तियों की पहली जोड़ी है

      1
    1 1 1
  1 2 4 2 1
1 3 8 9 8 3 1

कार्य

एक पंक्ति संख्या (ऊपर से शुरू) और एक स्तंभ संख्या (उस पंक्ति पर पहले गैर-शून्य आइटम से शुरू) को देखते हुए उस विशेष सेल में मूल्य का उत्पादन होता है। दोनों इनपुट 1 या 0 अनुक्रमित हो सकते हैं (यदि आप चाहें तो मिश्रण और मिलान कर सकते हैं)।

यह कोड-गोल्फ है इसलिए आपको अपने स्रोत कोड की फ़ाइल का आकार यथासंभव छोटा बनाने का लक्ष्य रखना चाहिए।

OEIS A059317

Comments

पास्कल के त्रिकोण के साथ, रंबल की समता अच्छी और भग्न पैटर्न बनाती है ।

— मार्टिन एंडर

यदि आप अपने कोड को कमांड-लाइन तर्क के रूप में डालते हैं, तो आपको अपने स्रोत कोड का फ़ाइल आकार यथासंभव छोटा बनाने का लक्ष्य रखना चाहिए ? : पी

— एरिक आउटगॉल्फ

शॉर्टकट्स और जाहिरा तौर पर arxiv.org/abs/1504.04404 के लिए जा रहे हैं, परिणाम की गणना सीधे कोड गोल्फ के लिए अनुपयोगी है।

— 15

Answer 1

हास्केल , 59 55 बाइट्स

पास्कल का रोम्बस? Haskell के Rhombus की तरह! क्या मैं सही हू?

4 बाइट्स ने अर्जन जोहान्सन को धन्यवाद दिया

मैंने सोचा कि मैं अपनी समस्या पर जाऊंगा और अपने हास्केल का अभ्यास करूंगा। उम्मीद है कि यह अधिक लोगों को इसका जवाब देने के लिए प्रेरित करेगा।

1!1=1
n!k=sum[(n-2)!(k-2)+sum(map((n-1)!)[k-2..k])|n>1]

इसे ऑनलाइन आज़माएं!

व्याख्या

यह नवीनतम गोल्फ के साथ थोड़ा पुराना है

हिसाब लगाने के बजाय

  *
 ***
  x

हम हिसाब लगाते हैं

*
***
  x

यह हमारा पूरा त्रिकोण बन जाता है

1
1 1 1
1 2 4 2 1
1 3 8 9 8 3 1

यह हमारी सभी पंक्तियों को किसी भी स्तंभ के nth आइटम को अनुक्रमित करना आसान बनाता है। हम फिर अपने आधार मामलों को परिभाषित करते हैं।

शून्य पंक्ति तो सभी शून्य है

0!_=0

1स्थिति में एक ही है 1,1इसलिए हम इसे परिभाषित करते हैं

1!1=1

और हम बाकी की पहली पंक्ति को शून्य के रूप में अच्छी तरह से परिभाषित करते हैं

1!_=0

फिर हम ऊपर वर्णित पैटर्न का उपयोग करके सामान्य मामले को फिर से परिभाषित करते हैं:

n!k=(n-2)!(k-2)+(sum$map((n-1)!)[k-2..k])

Comments

मुझे इससे हराएं! यह भी मेरी तुलना में बहुत अधिक क्लीनर है।

— जूलियन वुल्फ

@JulianWolf उस बारे में क्षमा करें, जब मैंने यह पोस्ट किया तो ऐसा लग रहा था कि जोर्ग के अलावा कोई और समस्या नहीं कर रहा है। मैं अब भी आपका समाधान देखना चाहूंगा।

— गेहूं जादूगर

आप के साथ चार बाइट्स बचा सकते हैं n!k=sum[(n-2)!(k-2)+sum(map((n-1)!)[k-2..k])|n>1]।

— अर्जन जोहान्सन

Answer 2

पास्कल , 122 बाइट्स

खैर, यह पास्कल का रोम्बस है।

_{37 बाइट्स @manatwork की बदौलत बच गईं}

function f(n,k:integer):integer;begin f:=1-Ord((k<0)or(k>n*2));if n>0then f:=f(n-1,k-2)+f(n-1,k-1)+f(n-1,k)+f(n-2,k-2)end;

इसे ऑनलाइन आज़माएं!

Comments

पूरी ifस्थिति के आसपास कोष्ठक व्यर्थ हैं। (1 पर ifआप 2 वर्णों को बचाते हैं, 2 if1 वर्ण पर thenखोजशब्द और पूर्ववर्ती अंक के बीच कोई स्थान नहीं छोड़ते हैं ।) ओह, और चर आर पूरी तरह से अनावश्यक है।

— मैनटवर्क

अजीब जानवर है कि Ideone पर पास्कल। पहले कभी किसी पास्कल वैरिएंट में डबल कोटेड सीमांकित तार नहीं देखे गए। एक और चीज जिसे आप हटा सकते हैं: 'एस' ;से पहले । functionend

— मैनटवर्क

@manatwork yea, अब जब आपने इसका उल्लेख किया, तो अन्य सभी ऑनलाइन संपादकों ने इसके बारे में शिकायत की

— Uriel

@manatwork मुझे यकीन नहीं है कि मैं समझ गया हूँ कि सिर्फ कोड के साथ लंबा नहीं होगा >= <=? मैं अभी भी संरक्षण की जरूरतif n=0

— ऊरीएल

क्षमा करें @ यूरेल, मेरे पास अब वह संस्करण नहीं है। वर्तमान में मैं पर हूँfunction f(n,k:integer):integer;begin f:=1-Ord((k<0)or(k>n*2));if n>0then f:=f(n-1,k-2)+f(n-1,k-1)+f(n-1,k)+f(n-2,k-2)end;

— manatwork

Answer 3

PHP , 86 बाइट्स

पुनरावर्ती तरीका केवल फ़ंक्शन पंक्ति और कॉलम 0-अनुक्रमित

function f($r,$c){return$r|$c?$r<0?0:f($r-=1,$c)+f($r,$c-1)+f($r,$c-=2)+f($r-1,$c):1;}

इसे ऑनलाइन आज़माएं!

PHP , 114 बाइट्स

पुनरावर्ती रास्ता पूर्ण कार्यक्रम पंक्ति और कॉलम 0-अनुक्रमित

<?=f(...$_GET);function f($r,$c){return$r|$c?$r<0|$c<0|$c>2*$r?0:f($r-=1,$c)+f($r,$c-1)+f($r,$c-=2)+f($r-1,$c):1;}

इसे ऑनलाइन आज़माएं!

PHP , 129 बाइट्स

पंक्ति और कॉलम 0-अनुक्रमित

for(;$r<=$argv[1];$l=$t[+$r++])for($c=~0;$c++<$r*2;)$t[+$r][$c]=$r|$c?$t[$r-2][$c-2]+$l[$c]+$l[$c-1]+$l[$c-2]:1;echo$l[$argv[2]];

इसे ऑनलाइन आज़माएं!

Comments

और वास्तव में यह सुधार लाने :) के लिए +1

— ऊरीएल

Answer 4

जेली , 22 20 19 बाइट्स

3ḶṚp@Ḣḣ4
Ḟ_ЀÇ߀ȯ¬S

कमांड-लाइन तर्क के रूप में 0-आधारित इंडेक्स जोड़ी लेता है।

इसे ऑनलाइन आज़माएं!

Answer 5

MATL , 22 20 19 बाइट्स

Ti:"2Y6Y+FT_Y)]!i_)

दोनों इनपुट 0-आधारित हैं।

इसे ऑनलाइन आज़माएं!

व्याख्या

चलो rऔर cदो आदानों, क्रमशः निर्दिष्ट करने 0-आधारित पंक्ति और स्तंभ को दर्शाते हैं।

पास्कल के रोम्बस में प्रत्येक नई पंक्ति को कर्नेल के साथ सजाकर[1 1 1; 0 1 0] और परिणाम की अंतिम दो पंक्तियों को स्वैप करके मैट्रिक्स से पिछली दो पंक्तियों से बनाया जा सकता है । यह rबार किया जाता है, मैट्रिक्स से शुरू होता है 1।

यह कर्नेल का उपयोग करने के लिए छोटा हो जाता है [0 1 0; 1 1 1; 0 1 0], जो एक पूर्वनिर्धारित शाब्दिक है। यह एक अतिरिक्त पंक्ति उत्पन्न करता है, जिसे छोड़ दिया जाएगा।

उदाहरण के लिए विचार करें r = 3, इसलिए 3पुनरावृत्तियाँ हैं।

1. से शुरू

   1
   

   साथ घुमाव [0 1 0; 1 1 1; 0 1 0]देता है

   0 1 0
   1 1 1
   0 1 0
   

   अंतिम दो पंक्तियों (पूरे मैट्रिक्स, इस मामले में) को रखना और उन्हें स्वैप करना

   0 1 0
   1 1 1
   

2. के साथ ऊपर की बातचीत [0 1 0; 1 1 1; 0 1 0]देता है

   0 0 1 0 0
   0 1 1 1 0
   1 2 4 2 1
   0 1 1 1 0
   

   अंतिम दो पंक्तियों द्वारा निर्मित मैट्रिक्स अदला-बदली है

   0 1 1 1 0
   1 2 4 2 1
   

   इसमें सबसे नीचे नई पंक्ति है, और पूर्ववर्ती शून्य के साथ विस्तारित है।

3. फिर से उपज देना

   0 0 1 1 1 0 0
   0 1 2 3 2 1 0
   1 3 8 9 8 3 1
   0 1 2 4 2 1 0
   

   अंतिम दो पंक्तियों की अदला-बदली कर देता है

   0 1 2 4 2 1 0
   1 3 8 9 8 3 1
   

rपुनरावृत्तियों के होने के बाद , आउटपुट अंतिम मैट्रिक्स की अंतिम पंक्ति में समाहित है। उदाहरण के लिए, c = 2(0-आधारित) परिणाम होगा 8। अंतिम पंक्ति और वांछित कॉलम को इंडेक्स करने के बजाय, एक ट्रिक का उपयोग किया जा सकता है जो प्रत्येक पंक्ति की समरूपता का शोषण करता है : अंतिम मैट्रिक्स को ट्रांसपोज़ किया जाता है

0 1
1 3
2 8
4 9
2 8
1 3
0 1

और इसका -cतत्त्व लिया गया है। यह रैखिक अनुक्रमण का उपयोग करता है, अर्थात, मैट्रिक्स को स्तंभ-प्रमुख क्रम में एकल सूचकांक द्वारा अनुक्रमित किया जाता है । चूंकि इंडेक्सिंग मॉड्यूलर है , -entry निचला-दायां कोना (मान ) है और -th प्रविष्टि दो चरणों से ऊपर (मान ) है।01-28

T       % Push true
i       % Input row number
:"      % Do the following that many times
  2Y6   %   Push predefined literal [0 1 0; 1 1 1; 0 1 0]
  Y+    %   2D convolution, increasing size
  FT_   %   Push [0 -1]
  Y)    %   Matrix with rows 0 (last) and -1 (second-last), in that order
]       % End
!       % Transpose
i       % Input: colun number
_       % Negate
)       % Entry with that index. Implicitly display

Answer 6

परी / जीपी , 60 बाइट्स

i->j->polcoeff(Vec(1/(1-x*(1+y+y^2+x*y^2))+O(x^i++))[i],j,y)

इसे ऑनलाइन आज़माएं!

Answer 7

हास्केल , 74 बाइट्स

0#0=1
n#m|m<=2*n&&m>=0=sum[(n-a)#(m-b)|(a,b)<-zip[2,1,1,1]$2:[0..2]]
n#m=0

इसे ऑनलाइन आज़माएं!

कॉल करें n # m, जहां nपंक्ति है और mस्तंभ है।

Comments

m<=2*n&&m>=0बस हो सकता है n>0।

— अर्जन जोहान्सन

Answer 8

मैथेमेटिका, 56 बाइट्स

If[#<1,Boole[##==0],Sum[#0[#-i,#2-j],{i,2},{j,2i-2,2}]]&

शुद्ध कार्य दो पूर्णांक तर्क (पंक्ति पहले, स्तंभ दूसरे) और एक पूर्णांक लौटाता है। नकारात्मक पूर्णांक तर्कों के लिए भी काम करता है, लौट रहा है 0। एक बहुत सीधी पुनरावर्ती संरचना: If[#<1,Boole[##==0],...]0-पंक्ति (और ऊपर) के लिए बेस-केस व्यवहार को परिभाषित करता है, जबकि Sum[#0[#-i,#2-j],{i,2},{j,2i-2,2}]पुनरावर्ती परिभाषा को लागू करता है।

Answer 9

पायथन 2 , 70 66 65 बाइट्स

f=lambda n,k:(k==0)|sum(f(n+~j/3,k-j+j/3)for j in range(4)[:3*n])

इसे ऑनलाइन आज़माएं!

Answer 10

जावास्क्रिप्ट (ईएस 6), 68 बाइट्स

f=(y,x)=>x<0|x>y+y?0:x>0&x<y+y?f(--y,x)+f(y,--x)+f(y,--x)+f(--y,x):1

Answer 11

मैथेमेटिका, 53 बाइट्स

D[1/(1-x(1+y+y^2(1+x))),{x,#},{y,#2}]/#!/#2!/.x|y->0&

उत्पादक फ़ंक्शन का उपयोग करना।

Answer 12

पायथन 3 , 82 84 बाइट्स

यह 1-अनुक्रमित पंक्तियों और स्तंभों के साथ एक पुनरावर्ती कार्यान्वयन है। (तकनीकी रूप f=से सामने एक की जरूरत है , कोई मुझे बताए कि क्या मुझे इसे 84 बाइट्स में बदलना चाहिए। फिर भी नए और नियमों का 100% यकीन नहीं है।)

यह OEIS पृष्ठ पर पाए गए पुनरावर्ती सूत्र का उपयोग करता है , लेकिन ठीक से पंक्तिबद्धk करने के लिए एक को बाईं ओर स्थानांतरित कर दिया जाता है। संयोग से, के रूप sum(f(n-1,k-i)for i in(0,1,2))में एक ही आकार है f(n-1,k)+f(n-1,k-1)+f(n-1,k-2)। पूरा कार्य पायथन and orचाल है, जहां पहली शर्त यह जांचती है कि क्या कश्मीर त्रिकोण के अंदर है और सीमा पर नहीं है, इस स्थिति में पुनरावर्ती सूत्र का उपयोग किया जाता है। यदि नहीं है, तो orलौटाए जाने के बाद का हिस्सा , जो जाँचता है कि kक्या है (1, 2*n-1), यानी सीमा पर, लौटकर Trueऔर False। k+1in(2,2*n)एक बाइट से छोटा है k in(1,2*n-1)। कोष्ठक में लपेटकर और +सामने रखकर पूर्णांक में परिवर्तित होता है, जो कि आवश्यक है।

f=lambda n,k:2*n-1>k>1and sum(f(n-1,k-i)for i in(0,1,2))+f(n-2,k-2)or+(k+1in(2,2*n))

इसे ऑनलाइन आज़माएं!

Comments

पुनरावर्ती कार्यों की आवश्यकता है f=।

— गेहूं जादूगर

जबकि मैं व्यक्तिगत रूप से इसके अनुसार असहमत हूं इस पर कुछ हद तक दफन मेटा आम सहमति, आप उत्पादन हो सकता है Trueके बजाय 1, क्योंकि यह की तरह बर्ताव करता 1अजगर करने के लिए। यह आपको +(...)अंत में हटाने की अनुमति देता है । मैं समझता हूं कि यदि आप ऐसा नहीं करना चाहते हैं, क्योंकि यह आउटपुट को थोड़ा अजीब लगेगा, यह एक विकल्प है।

— गेहूं जादूगर

@WheatWizard वाह बहुत दिलचस्प है। पारितोषिक के लिए धन्यवाद।

— सी। मैकएवॉय

Answer 13

जावा (ओपनजेडके 8) , 87 बाइट्स

int f(int r,int c){return c<0|2*r<c?0:0<c&c<2*r?f(--r,c)+f(r,--c)+f(r,--c)+f(--r,c):1;}

इसे ऑनलाइन आज़माएं!

सबसे पहले, मैं अपने 160 बाइट्स पुनरावृत्ति विधि से खुश था ... हम्मम ... चलो इसके बारे में भूल जाते हैं, ठीक है?

Answer 14

पायथन 3 , 75 बाइट्स

यह एक पुनरावर्ती लैम्ब्डा है जो स्तंभ और पंक्ति को 0-अनुक्रमित पूर्णांक के रूप में लेता है।

p=lambda r,c:(r<0 or((c==0)|p(r-1,c-2)+p(r-1,c)+p(r-1,c-1)+p(r-2,c-2))+1)-1

यहाँ मुद्रण कार्य के साथ (थोड़ा) अधिक पठनीय संस्करण है:

p = lambda r,c:(r<0 or ((c==0) | p(r-1,c-2)+p(r-1,c)+p(r-1,c-1)+p(r-2,c-2))+1)-1

def pp(r):
    ml = len(str(p(r,r)))+1
    for i in range(0, r):
            a=" "*ml*(r-i)
            for j in range(0,i*2 + 1):
                    a+=str(p(i,j))+(" "*(ml-len(str(p(i,j)))))
            print(a)