10

ठीक है, मैं हाल ही में यहाँ एक और एक त्रिकोण किक के एक बिट पर किया गया है।

क्लार्क का त्रिभुज एक ऐसा त्रिभुज होता है जहाँ प्रत्येक पंक्ति की बाईं प्रविष्टि 1 होती है और सबसे दाहिनी प्रविष्टियाँ 6 के गुणकों से बनी होती हैं जो पंक्ति संख्या बढ़ने पर बढ़ती हैं। यहाँ एक दृश्य है

     1 6
    1 . 12
   1 . . 18
  1 . . . 24
 1 . . . . 30
1 . . . . . 36

पास्कल की त्रिभुज की तरह ही अन्य सभी प्रविष्टियां उनके ऊपरी दाएं और ऊपरी बाएं की संख्या का योग हैं।

यहां पहले कुछ पंक्तियों को भरा गया है

          1   6
        1   7  12
      1   8  19  18
    1   9  27  37  24
  1  10  36  64  61  30
1  11  46  100 125 91  36

कार्य

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

यह कोड-गोल्फ है , लक्ष्य आपके समाधान में बाइट्स की संख्या को कम करना है।

OEIS A046902

code-golf math number

— एड हॉक गार्फ हंटर
स्रोत

1

क्या हम पहली पंक्ति में शून्य के साथ एक समाधान बना सकते हैं? OEIS अनुक्रम में पसंद है

— Jörg Hülsermann

1

@ JörgHülsermann चूँकि यहाँ परिभाषित त्रिकोण के लिए सीमा से बाहर है, आप जो चाहें कर सकते हैं।

— तदर्थ गार्फ हंटर

7

MATL , 15 बाइट्स

[lBB]i:"TTY+]i)

पहला इनपुट 0-आधारित पंक्ति है; दूसरा 1-आधारित स्तंभ है।

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

व्याख्या

[lBB]   % Push [1 6 6]
i       % Input: row number (0-based)
:"      % Repeat that many times
  TT    %   Push [1 1]
  Y+    %   Convolution, increasing size. This computes the sum of overlapping
        %   pairs, including the endpoints. So for example [1 6 6] becomes
        %   [1 7 12 6], which will later become [1 8 19 18 6], ...
]       % End
i       % Input: column number (1-based)
)       % Use as index. Implicit display

— लुइस मेंडो
स्रोत

6

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

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

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

1 अनुक्रमित।

— Uriel
स्रोत

पास्कल का त्रिकोण!

— हेनरी

5

सीजाम , 22 18 बाइट्स

मार्टिन बायर को धन्यवाद

X6_]ri{0X$+.+}*ri=

इनपुट है (0-based row) (0-based column)

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

व्याख्या

X6_]  e# Push the list [1 6 6]. This is the first row, but each row will have an extra 6 at
      e# the end, which is out of bounds.
ri    e# Push the first input as an integer.
{     e# The following block calculates the next row given a row on top of the stack:
 0X$+ e#  Copy the top list on the stack and prepend 0.
 .+   e#  Element-wise addition with the list before prepending 0. This adds each element of
      e#  with the one to its left, except the initial 1 gets added to 0 and the final number
      e#  gets added to the out-of-bounds 6. The out-of-bounds 6 is unchanged since one list
      e#  is longer.
}*    e# Run this block (row index) times.
ri=   e# Get the (column index)th item of the final list.

— बिजनेस कैट
स्रोत

जोड़ीदार सूम्स प्राप्त करने के लिए एक अलग तकनीक एक कॉपी को बाईं ओर स्थानांतरित करना और उपयोग करना है .+। आम तौर पर यह समस्या होती है कि यह बिना किसी सारांश के अनुगामी तत्व को बनाए रखता है (जिसे निकालने के लिए बाइट्स की लागत होती है), लेकिन इस मामले में जो वास्तव में बाइट्स बचाता है क्योंकि तब आपको 6प्रत्येक पुनरावृत्ति को जोड़ने की आवश्यकता नहीं होती है । आप और भी बाइट्स बचा सकते हैं क्योंकि बाईं ओर शिफ्टिंग निशुल्क है यदि आप केवल 0एक प्रति के लिए प्रस्तुत करते हैं:X6_]ri{0X$+.+}*ri=

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

_0\+के बजाय 0X$+एक ही बाइट गिनती है अगर आप पसंद करते हैं।

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

@MartinEnder ओह, मैं देखता हूं, आपको प्रत्येक पंक्ति के अंत में एक अतिरिक्त 6 मिलता है जो सीमा से बाहर है इसलिए यह कोई फर्क नहीं पड़ता। चतुर, धन्यवाद।

— बिजनेस कैट

4

सी #, 157 बाइट्स

using System.Linq;(b,c)=>{var f=new[]{1,6};for(;c>0;c--){int s=f.Length;f=new int[s+1].Select((e,i)=>i<1?1:i==s?f[s-1]+6:f[i-1]+f[i]).ToArray();}return f[b];

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

— LiefdeWen
स्रोत

3

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

a,b=input()
x=[1,6]
exec"x=map(sum,zip([0]+x,x+[6]));"*a
print x[b]

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

जानवर-बल दृष्टिकोण, aवें पंक्ति की गणना करें और फिर bवें नंबर को प्रिंट करें , दोनों इनपुट 0-आधारित हैं

— छड़ी
स्रोत

3

पायथन 3 , 64 60 52 बाइट्स

f=lambda r,c:c<2or c>r and r*6or f(r-1,c-1)+f(r-1,c)

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

1-अनुक्रमण का उपयोग करके पुनरावर्ती समाधान। गोल्फिंग के लिए 1 के बजाय "ट्रू" आउटपुट।

करने के लिए धन्यवाद:

4 बाइट बचाने के लिए @totallyhuman!
@ बाइट बचाने के लिए @Rod!

— चेस वोगेली
स्रोत

2

60 बाइट्स

— जुबान

2

52 बाइट्स की जगह यदि बूलियन ऑपरेटरों के साथ / और अधिक लचीले आउटपुट के साथ

— रॉड

@Rod, यह एक शानदार समाधान है। मैं अभी भी अपने सिर को लपेटने की कोशिश कर रहा हूं कि यह क्यों काम करता है। मैं अभी भी यहां काफी नया हूं (यह साइट पर मेरा दूसरा जवाब है), इसलिए मैं प्रोटोकॉल पर अनिश्चित हूं: क्या मुझे अपने जवाब में अपने संशोधन को शामिल करना चाहिए, भले ही आप पायथन 3 से 2 पर स्विच किए हों?

— चोगे Vogeli

3

@icosahedron पायथन संस्करण उस मामले में अपूरणीय है, इसलिए आपको इसे समझने की ज़रूरत नहीं है। आम तौर पर, सुविधाओं का फायदा उठाने के लिए अजगर संस्करणों के बीच स्विच करना ठीक माना जाता है।

— उरेल

@ युरील ने स्पष्टीकरण के लिए धन्यवाद दिया।

— चोगे वोगेली जूल

2

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

n#1=1
n#m|m>n=6*n
n#m=(n-1)#(m-1)+(n-1)#m

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

इसका उपयोग करके कॉल n # mजहां nपंक्ति संख्या है और mस्तंभ संख्या, दोनों 1 अनुक्रमित है।

— जूलियन वुल्फ
स्रोत

1

गणितज्ञ, 32 बाइट्स

b=Binomial;b[#,#2-1]6+b[#-1,#2]&

इनपुट

[पंक्ति, स्तंभ]
[१-अनुक्रमित, ०-अनुक्रमित]

— J42161217
स्रोत

1

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

f=(r,c)=>c?r>c?f(--r,c)+f(r,--c):r*6:1

नकारात्मक कॉलम के लिए क्रैश, और नकारात्मक पंक्तियों या ओवरलेग कॉलम के लिए छह के गुणक।

— नील
स्रोत

1

सी # (.NET कोर) , 44 बाइट्स

f=(c,r)=>c<=1?1:c>r?6*r:f(c-1,r-1)+f(c,r-1);

स्तंभ को पंक्ति में ले जाता है, दोनों 1-अनुक्रमित। इनपुट्स स्वैप करके पंक्ति को स्तंभ पर ले जा सकते हैं (r,c):। row * 6दाएं (यानी column > row + 1) पर सीमा के बाहर निर्देशांक के लिए वापस आ जाएगा , और 1बाईं तरफ सीमा के बाहर निर्देशांक के लिए (यानी column < 1)।

— कामिल दकरी
स्रोत

1

PHP , 64 बाइट्स

पुनरावर्ती कार्य

पंक्तियों 1-अनुक्रमण स्तंभों 0-अनुक्रमण

पंक्ति के लिए आउटपुट = 0 और स्तंभ = 0 0 OEIS अनुक्रम की तरह है

function f($r,$c){return$c-$r?$c?f($r-=1,$c-1)+f($r,$c):1:$r*6;}

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

PHP , 126 बाइट्स

पंक्तियों 1-अनुक्रमण स्तंभों 0-अनुक्रमण

पंक्ति के लिए आउटपुट = 0 और स्तंभ = 0 0 OEIS अनुक्रम की तरह है

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

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

— जार्ग हुल्सरमन
स्रोत

0

आर , 77 बाइट्स

Reduce(function(x,y)zoo::rollsum(c(0,x,6),2),double(scan()-1),c(1,6))[scan()]

zooपुस्तकालय की आवश्यकता है ; स्टडिन (दो न्यूलाइन द्वारा अलग किए गए इनपुट) से पढ़ता है और NAसीमा चयन से बाहर के साथ, मूल्य वापस करता है ।

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

— ग्यूसेप
स्रोत

0

जेली , 13 बाइट्स

,"’U0¦c/x6,1S

[row, entry]मूल्य को वापस करते हुए ( एक प्रविष्टि के लिए 0-इंडेक्सिंग, प्रविष्टियों के लिए 1-इंडेक्सिंग) की एक मोनडिक लिंक ।

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

कैसे?

,"’U0¦c/x6,1S - Link: list of numbers, [row, entry]
  ’           - decrement     -> [row-1, entry-1]
 "            - zip with:
,             -   pair        -> [[row, row-1], [entry, entry-1]]
     ¦        - sparse application of:
   U          -   upend
    0         - for indexes: 0 -> [[row, row-1], [entry-1, entry]]
       /      - reduce by:
      c       -   choose       -> [(row choose entry-1), (row-1 choose entry)]
         6,1  - 6 paired with 1 = [6,1]
        x     - times        i.e. [a, a, a, a, a, a, a, b]
            S - sum            -> 6*(row choose entry-1) + (row-1 choose entry)

— जोनाथन एलन
स्रोत