पास्कल की ब्रैड उत्पन्न करें

32

यह पास्कल की चोटी है:

 1 4  15  56   209   780    2911    10864     40545      151316      564719
1 3 11  41  153   571   2131    7953     29681     110771      413403      1542841
 1 4  15  56   209   780    2911    10864     40545      151316      564719

मैंने पूरी तरह से बना दिया है। Blaise पास्कल में एक चोटी नहीं थी जहां तक ​​मैं बता सकता हूं, और अगर उसने ऐसा किया तो शायद संख्या के बजाय बालों से बना था।

इसे इस तरह परिभाषित किया गया है:

  1. पहले कॉलम में 1बीच में एक सिंगल है।
  2. दूसरे कॉलम 1में सबसे ऊपर और सबसे नीचे एक कॉलम है ।
  3. अब हम एक नंबर को बीच में या एक नंबर की दो प्रतियों को ऊपर और नीचे रखने के बीच वैकल्पिक करते हैं।
  4. यदि संख्या ऊपर या नीचे जाती है, तो यह दो आसन्न संख्याओं (जैसे 56 = 15 + 41) का योग होगा । यदि आप अपने सिर को थोड़ा झुकाते हैं, तो यह पास्कल के त्रिकोण में एक कदम की तरह है।
  5. यदि संख्या बीच में जाती है, तो यह तीनों समीपवर्ती संख्याओं (जैसे 41 = 15 + 11 + 15) का योग होगा ।

आपका काम इस चोटी को (कुछ हिस्सा) प्रिंट करना होगा।

इनपुट

आपको एक प्रोग्राम या फ़ंक्शन लिखना चाहिए, जो एक ही पूर्णांक प्राप्त करता है, जो nअंतिम कॉलम के सूचकांक को आउटपुट देता है।

आप चुन सकते हैं कि पहला कॉलम ( 1मध्य रेखा पर केवल एक ही मुद्रण ) से मेल खाती है n = 0या नहीं n = 1। यह सभी संभावित आदानों में एक सुसंगत विकल्प होना चाहिए।

उत्पादन

आउटपुट पास्कल की ब्रैड nवें कॉलम तक। व्हॉट्सएप को ऊपर दिए गए उदाहरण के लेआउट से मेल खाना है, सिवाय इसके कि आप रिक्त स्थान के साथ छोटी लाइन (एस) को लंबी लाइन (एस) तक पैड कर सकते हैं और आप वैकल्पिक रूप से एकल ट्रेलिंग लाइनफीड का उत्पादन कर सकते हैं।

दूसरे शब्दों में, प्रत्येक स्तंभ उस स्तंभ में संख्या (या समान संख्याओं के जोड़े) के समान विस्तृत होना चाहिए, क्रमिक स्तंभों में संख्याएं ओवरलैप नहीं होनी चाहिए और स्तंभों के बीच कोई रिक्त स्थान नहीं होना चाहिए।

आप या तो परिणाम को STDOUT (या निकटतम विकल्प) में प्रिंट कर सकते हैं, या यदि आप एक फ़ंक्शन लिखते हैं तो आप या तो एक स्ट्रिंग के साथ एक ही सामग्री या तीन तार की सूची (प्रत्येक पंक्ति के लिए एक) वापस कर सकते हैं।

आगे की जानकारी

आप मान सकते हैं कि nयह पहले कॉलम के इंडेक्स से कम नहीं होगा (इसलिए आपके इंडेक्सिंग के आधार पर इससे कम 0या अधिक नहीं 1)। आप यह भी मान सकते हैं कि ब्रैड में अंतिम संख्या 256 से कम है या आपकी भाषा के मूल पूर्णांक प्रकार द्वारा प्रतिनिधित्व करने योग्य सबसे बड़ी संख्या, जो भी अधिक है । इसलिए यदि आपका मूल पूर्णांक प्रकार केवल बाइट्स को स्टोर कर सकता है, तो आप मान सकते हैं कि सबसे बड़ा nहै 9या 10(आप 0- या 1-आधारित का उपयोग करते हैं) पर निर्भर करता है nऔर यदि यह हस्ताक्षर किए गए 32-बिट पूर्णांक को स्टोर कर सकता है, तो यह nसबसे अधिक होगा 33या 34।

मानक कोड-गोल्फ नियम लागू होते हैं। सबसे छोटा कोड जीतता है।

OEIS

यहाँ कुछ प्रासंगिक OEIS लिंक दिए गए हैं। बेशक, इनमें ब्रैड में संख्या उत्पन्न करने के विभिन्न तरीकों के लिए स्पॉइलर होते हैं:

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

ये परीक्षण मामले 1-आधार अनुक्रमण का उपयोग करते हैं। प्रत्येक परीक्षण का मामला चार लाइनें है, जिसमें पहला इनपुट है और शेष तीन आउटपुट हैं।

1

1

---
2
 1
1
 1
---
3
 1
1 3
 1
---
5
 1 4
1 3 11
 1 4
---
10
 1 4  15  56   209
1 3 11  41  153
 1 4  15  56   209
---
15
 1 4  15  56   209   780    2911
1 3 11  41  153   571   2131    7953
 1 4  15  56   209   780    2911
---
24
 1 4  15  56   209   780    2911    10864     40545      151316      564719       2107560
1 3 11  41  153   571   2131    7953     29681     110771      413403      1542841
 1 4  15  56   209   780    2911    10864     40545      151316      564719       2107560
code-golf  ascii-art  number  sequence  arithmetic 
— मार्टिन एंडर
स्रोत
प्रारूप मुझे थोड़ा गिरगिट की तरह लगता है।
— लीकी नून
3
@LeakyNun मैंने सैंडबॉक्स में रहते हुए इस चुनौती की कोशिश की थी, और मैंने ब्रैड को प्रिंट करने के लिए इसकी गणना करने पर लगभग आधे बाइट्स खर्च किए। यह एक असीसी-कला चुनौती के लिए मेरे लिए एक उत्कृष्ट संतुलन की तरह लगता है ।
— FryAmTheEggman
4
@LeakyNun मुझे उम्मीद थी कि अनुक्रम पीढ़ी और ASCII कला दोनों चुनौती के महत्वपूर्ण घटक हैं, क्योंकि अधिकांश भाषाएं शायद उन दो में से एक पर बेहतर होंगी, इसलिए मुझे लगा कि उन्हें मिश्रण करना दिलचस्प होगा। और यह एक अतिरिक्त घटक का परिचय देता है जहां यह स्पष्ट नहीं है कि क्या अलग से ऊपर / नीचे और मध्य को उत्पन्न करना या पूरी चीज़ को उत्पन्न करना बेहतर है और फिर बाइसेक्शन को अलग करना।
— मार्टिन एंडर
— लुइस मेंडो जूल
पास्कल में अभी तक किसी ने समाधान नहीं लिखा है। ये मुझे दुखी करता है।
— डायनामाइटेड

जवाबों:

5

जेली , 31 30 29 बाइट्स

Q;S⁹o_
3ḶḂç@⁸СIµa"Ṿ€o⁶z⁶Zµ€Z

यह एक अद्वैत कड़ी है; यह 0-आधारित कॉलम इंडेक्स को तर्क के रूप में स्वीकार करता है और स्ट्रिंग की एक सूची देता है।

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

यह काम किस प्रकार करता है

Q;S⁹o_                  Helper link.
                        Arguments: [k, 0, k] and [0, m, 0] (any order)

Q                       Unique; deduplicate the left argument.
 ;                      Concatenate the result with the right argument.
  S                     Take the sum of the resulting array.
   ⁹o                   Logical OR with the right argument; replaces zeroes in the
                        right argument with the sum.
     _                  Subtract; take the difference with the right argument to
                        remove its values.
                        This maps [k, 0, k], [0, m, 0] to [0, k + m, 0] and
                        [0, m, 0], [k, 0, k] to [m + 2k, 0, m + 2k].


3ḶḂç@⁸СIµa"Ṿ€o⁶z⁶Zµ€Z  Monadic link. Argument: A (array of column indices)

3Ḷ                      Yield [0, 1, 2].
  Ḃ                     Bit; yield [0, 1, 0].
        I               Increments of n; yield [].
      С                Apply...
   ç@                       the helper link with swapped arguments...
     ⁸                      n times, updating the left argument with the return
                            value, and the right argument with the previous value
                            of the left one. Collect all intermediate values of
                            the left argument in an array.
         µ         µ€   Map the chain in between over the intermediate values.
            Ṿ€          Uneval each; turn all integers into strings.
          a"            Vectorized logical AND; replace non-zero integers with
                        their string representation.
              o⁶        Logical OR with space; replace zeroes with spaces.
                z⁶      Zip with fill value space; transpose the resulting 2D
                        array after inserting spaces to make it rectangular.
                  Z     Zip; transpose the result to restore the original shape.
                     Z  Zip; transpose the resulting 3D array.
— डेनिस
स्रोत
12

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

संख्या पीढ़ी में 20 बाइट्स हुए, और फॉर्मेटिंग में 24 बाइट्स हुए।

jsMC+Led.e.<bkC,J<s.u+B+hNyeNeNQ,1 1Qm*;l`dJ

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

jsMC+Led.e.<bkC,J<s.u+B+hNyeNeNQ,1 1Qm*;l`dJ   input as Q
                   .u          Q,1 1           repeat Q times, starting with [1,1],
                                               collecting all intermediate results,
                                               current value as N:
                                               (this will generate
                                                more than enough terms)
                       +hNyeN                  temp <- N[0] + 2*N[-1]
                     +B      eN                temp <- [temp+N[-1], temp]

now, we would have generated [[1, 1], [3, 4], [11, 15], [41, 56], ...]

jsMC+Led.e.<bkC,J<s                 Qm*;l`dJ
                  s                            flatten
                 <                  Q          first Q items
                J                              store in J
                                     m    dJ   for each item in J:
                                         `     convert to string
                                        l      length
                                      *;       repeat " " that many times

jsMC+Led.e.<bkC,
              C,     transpose, yielding:
[[1, ' '], [1, ' '], [3, ' '], [4, ' '], [11, '  '], ...]
(each element with as many spaces as its length.)
        .e            for each sub-array (index as k, sub-array as b):
          .<bk            rotate b as many times as k

[[1, ' '], [' ', 1], [3, ' '], [' ', 4], [11, '  '], ...]

jsMC+Led
    +Led              add to each sub-array on the left, the end of each sub-array
   C                  transpose
 sM                   sum of each sub-array (reduced concatenation)
j                     join by new-lines
— लीक नन
स्रोत
7
यह सबसे बड़ा पायथ कार्यक्रम है जिसे मैंने कभी देखा है।
— 21
7

MATL , 38 बाइट्स

1ti:"yy@oQ*+]vG:)!"@Vt~oX@o?w]&v]&hZ}y

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

एक सरणी को अद्वितीय (अद्वितीय) संख्याओं के साथ गणना करने पर पहले 17 बाइट्स लगते हैं। स्वरूपण शेष 21 बाइट्स लेता है।

व्याख्या

भाग 1: संख्याएँ उत्पन्न करें

यह बढ़ते क्रम में पहली और दूसरी पंक्तियों से संख्याओं के साथ एक सरणी उत्पन्न करता है [1; 1; 3; 4; 11; 15; ...]:। यह साथ शुरू होता है 1, 1। प्रत्येक नई संख्या पूर्ववर्ती दो से क्रमिक रूप से प्राप्त की जाती है। उनमें से, दूसरे को गुणा 1या 2पुनरावृत्ति सूचकांक के आधार पर किया जाता है, और फिर नए नंबर का उत्पादन करने के लिए पहले को अभिव्यक्त किया जाता है।

पुनरावृत्तियों की संख्या इनपुट के बराबर है n। इसका मतलब है कि n+2संख्याएं उत्पन्न होती हैं। एक बार उत्पन्न होने के बाद, सरणी को छंटनी की आवश्यकता होती है, इसलिए केवल पहली nप्रविष्टियां रखी जाती हैं।

1t      % Push 1 twice
i:      % Take input n. Generage array [1 2 ... n]
"       % For each
  yy    %   Duplicate the two most recent numbers
  @o    %   Parity of the iteration index (0 or 1)
  Q     %   Add 1: gives 1 for even iteration index, 2 for odd
  *+    %   Multiply this 1 or 2 by the most recent number in the sequence, and add
       %    to the second most recent. This produces a new number in the sequence
]       % End for each
v       % Concatenate all numbers in a vertical array
G:)     % Keep only the first n entries

भाग 2: आउटपुट स्वरूपित करें

प्राप्त सरणी में प्रत्येक संख्या के लिए, यह दो तार उत्पन्न करता है: संख्या का स्ट्रिंग प्रतिनिधित्व, और समान 0 की लंबाई वाली एक स्ट्रिंग जिसमें वर्ण 0 होता है (वर्ण 0 MATL में एक स्थान के रूप में प्रदर्शित होता है)। यहां तक ​​कि पुनरावृत्तियों के लिए, इन दो तारों की अदला-बदली की जाती है।

फिर दो तारों को लंबवत रूप से समतल किया जाता है। तो n2 डी चार सरणियों का उत्पादन निम्नानुसार किया जाता है ( ·चरित्र 0 का प्रतिनिधित्व करने के लिए)

·
1

1
·

· 
3

4
·

·· 
11

15
··

इन सरणियों को फिर उत्पादन के लिए क्षैतिज रूप से समतल किया जाता है

·1·4··15
1·3·11··

अंत में, इस 2D वर्ण सरणी को इसकी दो पंक्तियों में विभाजित किया गया है, और पहले को स्टैक के शीर्ष पर दोहराया गया है। तीन तार क्रम में प्रदर्शित होते हैं, प्रत्येक एक अलग लाइन पर, वांछित आउटपुट का उत्पादन करता है

!       % Transpose into a horizontal array [1 1 3 4 11 15 ...]
"       % For each
  @V    %   Push current number and convert to string
  t~o   %   Duplicate, negate, convert to double: string of the same length consisting 
        %   of character 0 repeated
  X@o   %   Parity of the iteration index (1 or 0)
  ?     %   If index is odd
    w   %     Swap
  ]     %   End if
  &v    %   Concatenate the two strings vertically. Gives a 2D char array representing
        %   a "numeric column" of the output (actually several columns of characters)
]       % End for
&h      % Concatenate all 2D char arrays horizontally. Gives a 2D char array with the
        % top two rows of the output
Z}      % Split this array into its two rows
y       % Push a copy of the first row. Implicitly display
— लुइस मेंडो
स्रोत
6

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

a=1:1:t
t=3:4:zipWith((-).(4*))t a
g(i,x)=min(cycle" 9"!!i)<$>show x
f n=[zip[y..y+n]a>>=g|y<-[0..2]]

एक फ़ंक्शन को परिभाषित करता है f :: Int → [String]।

  • माइकल क्लेन ने याद दिलाया कि मुझे unlinesपरिणाम पर कॉल करने की आवश्यकता नहीं थी , जिससे 7 बाइट्स बचती थीं। धन्यवाद!

  • मैं बदल कर एक बाइट बचाया " 9"!!mod i 2साथ cycle" 9"!!i।

  • उपयोग करने के बजाय दो corecursive सूचियों को लिखकर तीन और बाइट्स drop।

  • मेरी प्रेमिका ने कहा कि मैं 0इसके बजाय अपने जवाब शुरू करके दो और बाइट्स बचा सकता हूं 1।

— लिन
स्रोत
3

सी, 183 177 176 बाइट्स

#define F for(i=0;i<c;i++)
int i,c,a[35],t[9];p(r){F printf("%*s",sprintf(t,"%d",a[i]),r-i&1?t:" ");putchar(10);}b(n){c=n;F a[i]=i<2?1:a[i-2]+a[i-1]*(i&1?1:2);p(0);p(1);p(0);}

व्याख्या

सी कभी भी उच्च स्तर की भाषा के खिलाफ संक्षिप्तता के लिए कोई पुरस्कार जीतने वाला नहीं है, लेकिन अभ्यास दिलचस्प और अच्छा अभ्यास है।

पठनीयता की कीमत पर मैक्रो एफ छह बाइट्स को बंद कर देता है। कई घोषणाओं से बचने के लिए चर विश्व स्तर पर घोषित किए जाते हैं। मुझे स्प्रिंटफ के लिए एक चरित्र बफर की आवश्यकता थी, लेकिन चूंकि कश्मीर एंड आर टाइप चेकिंग के साथ ढीली है, स्प्रिंटफ और प्रिंटफ टी [9] को 36-बाइट बफर के सूचक के रूप में व्याख्या कर सकते हैं। यह एक अलग घोषणा बचाता है।

#define F for(i=0;i<c;i++)
int i,c,a[35],t[9];

सुंदर मुद्रण समारोह, जहां आर पंक्ति संख्या है। स्प्रिंटफ़ ने कॉलम की संख्या को प्रारूपित किया और गणना की। अंतरिक्ष को बचाने के लिए हम इसे तीन बार कॉल करते हैं, आउटपुट की प्रत्येक पंक्ति के लिए एक; अभिव्यक्ति री और 1 फिल्टर क्या मुद्रित हो जाता है।

p(r) {
    F
        printf("%*s", sprintf(t, "%d", a[i]), r-i&1 ? t
                                                    : " ");
    putchar(10);
}

प्रवेश बिंदु फ़ंक्शन, तर्क स्तंभों की संख्या है। कंप्यूटर्स में एक कॉलम मानों की सरणी होती है [], फिर आउटपुट की प्रत्येक पंक्ति के लिए एक बार प्रिंटिंग फंक्शन पी को कॉल करता है।

b(n) {
    c=n;
    F
        a[i] = i<2 ? 1
                   : a[i-2] + a[i-1]*(i&1 ? 1
                                          : 2);
    p(0);
    p(1);
    p(0);
}

नमूना मंगलाचरण (उत्तर और बाइट गिनती में शामिल नहीं):

main(c,v) char**v;
{
    b(atoi(v[1]));
}

अपडेट किया गया

Tomsmeding से इनलाइन स्प्रिंटफ सुझाव शामिल करें। इससे गिनती 183 से घटकर 177 वर्ण हो गई। यह प्रिंटफ (स्प्रिंटफ ()) ब्लॉक के आसपास के ब्रेसिज़ को हटाने की अनुमति देता है क्योंकि यह अब केवल एक स्टेटमेंट है, लेकिन यह केवल एक कैरेक्टर को बचाता है क्योंकि इसे अभी भी सीमांकक के रूप में स्थान की आवश्यकता है। तो नीचे 176 पर।

— maharvey67
स्रोत
क्या आप इसकी परिभाषा को इनलाइन नहीं कर सकते wकि इसका उपयोग कहाँ किया गया है? आप इसे केवल एक बार उपयोग करने लगते हैं।
— tomsmeding
आप उपयोग नहीं कर सकते itoa स्प्रिंट के बजाय ?
— जियाकोमो गारबेलो
मैंने इटोआ पर विचार किया, लेकिन यह मेरे सिस्टम पर मौजूद नहीं है, और मैं क्षेत्र की चौड़ाई निर्धारित करने के लिए स्प्रिंटफ के रिटर्न मूल्य का उपयोग कर रहा हूं।
— maharvey67
2

PowerShell v2 +, 133 बाइट्स

param($n)$a=1,1;1..$n|%{$a+=$a[$_-1]+$a[$_]*($_%2+1)};$a[0..$n]|%{$z=" "*$l+$_;if($i++%2){$x+=$z}else{$y+=$z}$l="$_".Length};$x;$y;$x

मूल्यों की गणना करने के लिए 44 बाइट्स, ASCII तैयार करने के लिए 70 बाइट्स

$nशून्य-अनुक्रमित स्तंभ के रूप में इनपुट लेता है । हमारे अनुक्रम सरणी की शुरुआत सेट करता है $a=1,1। फिर हम सरणी का निर्माण करने $nके 1..$n|%{...}लिए लूप अप करते हैं। प्रत्येक पुनरावृत्ति, हम (दो तत्वों से पहले) + (पिछले तत्व) * (चाहे हम विषम या अन्य सूचकांक हों) के योग पर सहमति करते हैं। यह उत्पन्न होगा $a=1,1,3,4,11...करने के लिए $n+2।

तो, हमें $aकेवल पहले 0..$nतत्वों को लेने के लिए स्लाइस करना होगा , और दूसरे लूप के माध्यम से पाइप करना होगा |%{...}। प्रत्येक पुनरावृत्ति हम सहायक $zको कई रिक्त स्थान और स्ट्रिंग के रूप में वर्तमान तत्व के बराबर सेट करते हैं। फिर, हम यह पता लगा रहे हैं कि क्या यह $x(ऊपर और नीचे की पंक्तियों पर) या $y(बीच की पंक्ति) एक सरल विषम-सम if/ से समतल हो जाता है else। फिर, हम $lवर्तमान संख्या को बढ़ाते हुए, इसे कड़ाई से लेते हुए और इसके लिए स्थान की संख्या की गणना करते हैं .Length।

अंत में, हम कर दिया $x, $yऔर $xपाइपलाइन पर फिर से, और उत्पादन निहित है। चूंकि .ToString()एक सरणी के लिए डिफ़ॉल्ट विभाजक जब STDOUT पर छपाई एक नई रेखा है , तो हमें वह मुफ्त में मिलती है।

उदाहरण

PS C:\Tools\Scripts\golfing> .\pascal-braid.ps1 27
 1 4  15  56   209   780    2911    10864     40545      151316      564719       2107560       7865521        29354524
1 3 11  41  153   571   2131    7953     29681     110771      413403      1542841       5757961       21489003
 1 4  15  56   209   780    2911    10864     40545      151316      564719       2107560       7865521        29354524
— AdmBorkBork
स्रोत
0

PHP 265 बाइट्स

<?php $i=$argv[1];$i=$i?$i:1;$a=[[],[]];$s=['',''];$p='';for($j=0;$j<$i;$j++){$y=($j+1)%2;$x=floor($j/2);$v=$x?$y?2*$a[0][$x-1]+$a[1][$x-1]:$a[0][$x-1]+$a[1][$x]:1;$s[$y].=$p.$v;$a[$y][$x]=$v;$p=str_pad('',strlen($v),' ');}printf("%s\n%s\n%s\n",$s[0],$s[1],$s[0]);

संयुक्त राष्ट्र के golfed:

$a = [[],[]];
$s = ['',''];

$p = '';

$i=$argv[1];
$i=$i?$i:1;
for($j=0; $j<$i; $j++) {
    $y = ($j+1) % 2;
    $x = floor($j/2);

    if( $x == 0 ) {
        $v = 1;
    } else {
        if( $y ) {
            $v = 2 * $a[0][$x-1] + $a[1][$x-1];
        } else {
            $v = $a[0][$x-1] + $a[1][$x];
        }
    }
    $s[$y] .= $p . $v;
    $a[$y][$x] = $v;
    $p = str_pad('', strlen($v), ' ');
}

printf("%s\n%s\n%s\n", $s[0], $s[1], $s[0]);

पायथन 278 बाइट्स

import sys,math;a=[[],[]];s=['',''];p='';i=int(sys.argv[1]);i=1 if i<1 else i;j=0
while j<i:y=(j+1)%2;x=int(math.floor(j/2));v=(2*a[0][x-1]+a[1][x-1] if y else a[0][x-1]+a[1][x]) if x else 1;s[y]+=p+str(v);a[y].append(v);p=' '*len(str(v));j+=1
print ("%s\n"*3)%(s[0],s[1],s[0])
— Sammitch
स्रोत
0

मतलाब, 223 अक्षर, 226 बाइट्स

function[]=p(n)
r=[1;1];e={(' 1 ')',('1 1')'}
for i=3:n;r(i)=sum((mod(i,2)+1)*r(i-1)+r(i-2));s=num2str(r(i));b=blanks(floor(log10(r(i)))+1);if mod(i,2);e{i}=[b;s;b];else e{i}=[s;b;s];end;end
reshape(sprintf('%s',e{:}),3,[])

असंबद्ध और टिप्पणी:

function[]=p(n) 
r=[1;1];                                    % start with first two 
e={(' 1 ')',('1 1')'}                       % initialize string output as columns of blank, 1, blank and 1, blank, 1.
for i=3:n;                                  % for n=3 and up! 
    r(i)=sum((mod(i,2)+1)*r(i-1)+r(i-2));   % get the next number by 1 if even, 2 if odd times previous plus two steps back
    s=num2str(r(i));                        % define that number as a string
    b=blanks(floor(log10(r(i)))+1);         % get a number of space characters for that number of digits
    if mod(i,2);                            % for odds
        e{i}=[b;s;b];                       % spaces, number, spaces
    else                                    % for evens
        e{i}=[s;b;s];                       % number, spaces, number
    end;
end
reshape(sprintf('%s',e{:}),3,[])            % print the cell array of strings and reshape it so it's 3 lines high
— sintax
स्रोत
0

PHP, 135 124 123 120 बाइट्स

<?while($i<$argv[1]){${s.$x=!$x}.=${v.$x}=$a=$i++<2?:$v1+$v+$x*$v;${s.!$x}.=str_repeat(' ',strlen($a));}echo"$s
$s1
$s";

अंतर्निहित टाइपकास्ट और चर चर का लाभ उठाते
हुए कोड का एक तिहाई (37 बाइट) रिक्त स्थान में चला जाता है, 64 बाइट पूरी तरह से आउटपुट के लिए उपयोग किया जाता है

टूट - फूट

$i=0; $x=false; $v=$v1=1; $s=$s1='';    // unnecessary variable initializations
for($i=0;$i<$argv[1];$i++)  // $i is column number -1
{
    $x=!$x; // $x = current row: true (1) for inner, false (empty string or 0) for outer
    // calculate value
    $a=
        $i<2?               // first or second column: value 1
        :$v1+(1+$x)*$v      // inner-val + (inner row: 1+1=2, outer row: 1+0=1)*outer-val
    ;
    ${s.$x}.=${v.$x}=$a;    // replace target value, append to current row
    ${s.!$x}.=str_repeat(' ',strlen($a));    // append spaces to other row
}
// output
echo "$s\n$s1\n$s";
— टाइटस
स्रोत
0

बैच, 250 बाइट्स

@echo off
set s=
set d=
set/ai=n=0,j=m=1
:l
set/ai+=1,j^^=3,l=m+n*j,m=n,n=l
set t=%s%%l%
for /l %%j in (0,1,9)do call set l=%%l:%%j= %%
set s=%d%%l%
set d=%t%
if not %i%==%1 goto l
if %j%==1 echo %d%
echo %s%
echo %d%
if %j%==2 echo %s%

चूंकि पहली और तीसरी पंक्तियाँ समान हैं, इसलिए हमें केवल दो तारों का निर्माण करना होगा। यहां dअंतिम प्रविष्टि के sसाथ समाप्त होने वाले स्ट्रिंग का प्रतिनिधित्व करता है और रिक्त स्थान के साथ समाप्त होने वाले स्ट्रिंग का प्रतिनिधित्व करता है; अंतिम चार पंक्तियाँ यह सुनिश्चित करती हैं कि वे उचित क्रम में मुद्रित हैं। iबस लूप काउंटर है (यह नीचे से गिनती करने की तुलना में थोड़ा सस्ता है %1)। jअगली संख्या प्राप्त करने के लिए वर्तमान संख्या में जोड़ने से पहले पिछली संख्या को दोगुना करने के बीच टॉगल है। mऔर nउन संख्याओं को समाहित करें। l, साथ ही साथ अगले नंबर की गणना करने के लिए एक अस्थायी के रूप में इस्तेमाल किया जा रहा है, इसके अंक भी पैड को बाहर करने के लिए रिक्त स्थान के साथ बदल दिए जाते हैं s; sऔर dमध्यवर्ती चर के माध्यम से हर बार आदान-प्रदान किया जाता है t।

— नील
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.