फाइबोनैचि-शैली मैट्रिक्स विस्तार

Question

मैट्रिक्स की प्रत्येक पंक्ति और फिर स्तंभ के लिए, हम उस पंक्ति या स्तंभ में अंतिम दो प्रविष्टियों के योग के साथ एक अतिरिक्त प्रविष्टि जोड़ सकते हैं। निम्नलिखित इनपुट मैट्रिक्स के साथ उदाहरण के लिए:

[ 1 1 1 ]
[ 2 3 4 ]

परिणामी मैट्रिक्स होगा:

[ 1 1 1 2 ]
[ 2 3 4 7 ]
[ 3 4 5 9 ]

पूर्णांक N और [X, Y] आकार के मैट्रिक्स का इनपुट कम से कम 2x2 को देखते हुए, उपरोक्त विस्तार N समय पर करें और परिणाम को आउटपुट करें। परिणामस्वरूप मैट्रिक्स हमेशा आकार [X + N, Y + N] का होगा।

उदाहरण:

Input:                     Output:

2, [ 0 0 ]                 [ 0 0 0 0 ]
   [ 0 0 ]                 [ 0 0 0 0 ]
                           [ 0 0 0 0 ]
                           [ 0 0 0 0 ]


3, [ 1 1 1 ]               [ 1  1  1  2  3  5 ]
   [ 2 3 4 ]               [ 2  3  4  7 11 18 ]
                           [ 3  4  5  9 14 23 ]
                           [ 5  7  9 16 25 41 ]
                           [ 8 11 14 25 39 64 ]

Answer 1

MATL , 13 14 15 16 20 21 बाइट्स

2*:"!tP2:Y)sv

1 बाइट निकालने के लिए @Zgarb को धन्यवाद!

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

2*         % implicitly input number N and multiply by 2
:          % create vector [1,2,...,2*N]
"          % for loop: do this 2*N times
  !        %   transpose. Implicitly input matrix in the first iteration
  tP       %   duplicate and flip vertically
  2:       %   vector [1,2]
  Y)       %   pick submatrix formed by the first two rows
  s        %   sum of each column
  v        %   append as a new row
           % end for
           % implicit display

Comments

मैं MATL नहीं जानता, लेकिन क्या यह 2Nदो Nबार लूप की तुलना में दो बार लूप से छोटा नहीं होगा ?

— जर्ग्ब

@Zgarb बेशक! मुझसे यह चूक कैसे हुई? धन्यवाद!!

— लुइस मेंडो

क्या MATL में किसी संख्या को दोगुना करने के लिए अंतर्निहित है?

— ज़र्गब

@Zgarb नहीं। आप की जरूरत है 2*( उपसर्ग संकेतन)। हो सकता है कि इसमें एक-चरित्र का अंतर्निहित होना चाहिए, इसका उपयोग अक्सर किया जाता है। इसके अलावा 2^(वर्ग)। लेकिन मैं कोड स्थान से बाहर चल रहा हूं :-)

— लुइस मेंडो

Answer 2

जे, 19 बाइट्स

(v"1@v=.,[+&{:}:)^:

यह एक क्रिया विशेषण को परिभाषित करता है, जो संख्या को बाईं ओर ले जाता है, और एक मैट्रिक्स को अपने दाईं ओर ले जाता है। दूसरे उदाहरण के लिए, यह देता है

  3 ((v"1@v=.,[+&{:}:)^:) 2 3 $ 1 1 1 2 3 4
1  1  1  2  3  5
2  3  4  7 11 18
3  4  5  9 14 23
5  7  9 16 25 41
8 11 14 25 39 64

व्याख्या

(v"1@v=.,[+&{:}:)^:  Left argument x, right argument y
(               )^:  Repeat x times:
     v=.               Bind the following verb to v, and apply to y:
         [    }:         y and y-without-last-item
          +&{:           Sum of their last items
        ,                Append that to y
                       (v automatically threads to rows)
 v"1@                  then apply v to columns

Answer 3

के, 23 बाइट्स

{x(2({x,+/-2#x}'+)/)/y}

कार्रवाई में:

  {x(2({x,+/-2#x}'+)/)/y}[3;(1 1 1;2 3 4)]
(1 1 1 2 3 5
 2 3 4 7 11 18
 3 4 5 9 14 23
 5 7 9 16 25 41
 8 11 14 25 39 64)

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

Comments

यदि आप अग्रणी {xऔर अनुगामी को निकालते हैं तो यह अभी भी काम करता हैy}

— ngn करें

Answer 4

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

-1 बाइट @ डेनिस द्वारा

ṫ-S;@"Z
ÇḤ}¡

@ लुइसमेन्डो के MATL उत्तर की तरह, यह एक अक्ष के साथ परिवर्तन करने से पहले सरणी को स्थानांतरित करता है। इसलिए, हमें फ़ंक्शन को 2 * n बार कॉल करने की आवश्यकता है।

ṫ-S;@"Z       Helper link. Input: x (2D array)
 -              Numeric literal: -1
ṫ               Get x[-1:], i.e. last two rows in x
  S             Sum
   ;@"          Append each to x. " is 'zipWith'; @ switches argument order.
      Z         Transpose the array.
ÇḤ}¡          Main link. Input: a, n
Ç               Call the last link on a
 Ḥ}             2n
   ¡            times.

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

Answer 5

ईएस 6, 134 बाइट्स

(n,a)=>[...a.map(b=>[...b,...Array(n)].map(c=>(c<1/0?0:c=a+d,d=a,a=c))),...Array(n)].map(b=>(b?0:b=[...a].map((c,j)=>c+d[j]),d=a,a=b))

स्पष्टीकरण:

(n,a)=> // arguments n is number to expand, a is original array
    [...
        a.map(b=> // for each row in a
            [...b,...Array(n)] // append n elements to the row
            .map(c=>(c<1/0?0:c=a+d,d=a,a=c))) // scan the elements and fill the new ones by summing the previous two
        ,...Array(n)] // append n rows
    .map(b=>(b?0:b=[...a].map((c,j)=>c+d[j]),d=a,a=b)) // scan the rows and fill the new rows by summing the previous two rows

Answer 6

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

o%m=m++[o(+)(last m)$last$init m]
(!!).iterate(map(id%).(zipWith%))

उपयोग उदाहरण:

*Main> ( (!!).iterate(map(id%).(zipWith%)) ) [[1,1,1],[2,3,4]] 3
[[1,1,1,2,3,5],[2,3,4,7,11,18],[3,4,5,9,14,23],[5,7,9,16,25,41],[8,11,14,25,39,64]]

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

(!!).iterate(    ...         )  -- repeatedly apply ... to the first agrument and
                                -- pick the iteration defined by the second arg
                   (zipWith%)   -- for one iteration add a new row and
          map(id%)              -- then a new element at the end of each each row

o%m                             -- add row or element at the end of a row resp.
                                -- argument o is a "modify function"
                                --          m the whole matrix or a row
 m++[    (last m)(last$init m)] -- take m and append the result of combining the
                                -- last and 2nd last element of m
     o(+)                       -- with a modified version of (+)
                                -- modification is none (aka. id) when adding an
                                -- element to the end of a row and
                                -- zipping elementwise (zipWith) when adding a row

Comments

मैं एक हैवेल नौसिखिया हूँ। मैं जहाँ तक गया हूं sudo apt-get install haskell-platformऔर ghciआरईपीएल चला रहा हूं जो मुझे एक Prelude> संकेत देता है । जब मैं अंदर o%m=m++[o(+)(last m)$last$init m]मिलता हूं <interactive>:2:4: parse error on input '='। क्या आप मुझे स्रोत फ़ाइल या REPL से इसे चलाने के लिए थोड़ा प्राइमर दे सकते हैं?

— डिजिटल ट्रामा 16

@DigitalTrauma: या तो o%m=...लाइन (और केवल इस लाइन) को एक फाइल में डाल दिया , जिसे कहते हैं fib-matrix.hs। फिर आप परिभाषाओं को लोड करने के लिए :l fib-matrix.hsकमांड का उपयोग कर सकते हैं ghciऔर मेरे उपयोग उदाहरण में वर्णित मुख्य फ़ंक्शन को कॉल कर सकते हैं । - या उपयोग करें let o%m=... in ( (!!). ... ) [[1,1,1]...] 3।

— निमि

@DigitalTrauma: ओह, एक 3 तरीका है: मुख्य फ़ंक्शन को एक नाम दें, जैसे f=कि दूसरी पंक्ति के सामने एक जोड़ दें : f=(!!).iterate...दोनों पंक्तियों को एक फ़ाइल में सहेजें और इसके माध्यम से लोड करें l: <filename.hs>। फिर आप कॉल कर सकते हैं f [[1,1,1],[2,3,4]] 3, आदि

— nimi

मुझे यकीन नहीं है कि मैं इसे वैध हैस्केल के रूप में स्वीकार करूंगा, शीर्ष पंक्ति एक फ़ंक्शन परिभाषा है और आरईपीएल में उपयोग के लिए संशोधन की आवश्यकता है, लेकिन दूसरी पंक्ति का उपयोग केवल आरईपीएल में किया जा सकता है।

— डैनियल हिल

@ डैनियलहिल: मेटा पर एक विषय है जो अज्ञात कार्यों को अनुमति देता है जो वैश्विक सहायक कार्यों पर निर्भर करता है।

— nimi

Answer 7

CJam, 17 16 बाइट्स

q~2*{~_2$.+]z}*p

इनपुट प्रारूप पहले मैट्रिक्स है (एक सीजेएम-शैली 2 डी सरणी के रूप में) और बाद में पुनरावृत्तियों की संख्या।

इसका परीक्षण यहां करें।

व्याख्या

बाहर मुड़ता है यह एक ही समाधान के रूप में हर किसी का है:

q~      e# Read and evaluate input.
2*      e# Double the iteration count.
{       e# Run this block that many times...
  ~     e#   Dump all rows on the stack.
  _     e#   Copy the last row.
  2$    e#   Copy the penultimate row.
  .+    e#   Vectorised addition.
  ]     e#   Wrap all rows in a new array.
  z     e#   Transpose such that the next iteration processes the other dimension.
}*
p       e#   Pretty-print.

Answer 8

गंभीरता से, 20 बाइट्स

,,τ"┬`;d@d@X+@q`M"£n

मैट्रिक्स को इनपुट करता है (2 डी सूची के रूप में), फिर N। एक 2 डी सूची आउटपुट।

यह संस्करण किसी कारण के लिए ऑनलाइन दुभाषिया पर काम नहीं करता है, लेकिन इस पूर्व-चुनौती के साथ काम करता है ।

एक संस्करण जो 23 बाइट्स के लिए ऑनलाइन काम करता है:

,τ",┬`;d@d@X+@q`M"nkΣ£ƒ

विपरीत क्रम में इनपुट लेता है ( N, फिर मैट्रिक्स)।

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

थोड़ी देर सोने के बाद मैं एक स्पष्टीकरण जोड़ूंगा। दुभाषिया बग के आसपास काम करना कभी मजेदार नहीं होता है।

Answer 9

पायथ, 13 12 बाइट्स

u+Rs>2dCGyEQ

इसे ऑनलाइन आज़माएं। परीक्षण सूट।

अधिकांश उत्तरों के लिए समान एल्गोरिथ्म का उपयोग करता है। पहली लाइन nपर और दूसरी लाइन पर 2 डी सरणी के रूप में मैट्रिक्स को इनपुट के रूप में लेता है ।

व्याख्या

u        yEQ     do 2*N times, starting with input matrix:
       CG          transpose
 +R                append to each row:
   s                 sum of
    >2d              last 2 elements of row

Answer 10

मतलाब, 60 बाइट्स

मैं पहले मैटलैब के फैंसी इंडेक्सिंग तरीकों (यानी A(end+1,:)=sum...) के साथ खिलवाड़ कर रहा था, इससे पहले कि मुझे लगा कि इस दुर्लभ मामले में, वास्तव में मैटलैब में सरल अवतरण सस्ता है। बहुत बुरा मुझे इसे एक वास्तविक फ़ंक्शन में बदलना पड़ा। साथ ही ऑक्टेव के साथ काम करना चाहिए।

function A=f(A,n)
for i=1:2*n
A=[A;sum(A(end-1:end,:))]';end

मुझे लगता है कि यह एक प्रमुख उदाहरण है कि एल्गोरिदम कैसे नहीं बनाया जाए। A = 2x2, n = 1000 के लिए यह एल्गोरिथम पहले से ही मेरे लैपटॉप पर 5 सेकंड लेता है, n = 2000 यह लगभग 50 सेकंड है! (या लगभग 30s अगर A gpuArrayमेरे भरोसेमंद Quadro 1000M के लिए धन्यवाद है)

Comments

मेरे पास मतलूब की प्रति नहीं है। क्या मैं इसे GNU ऑक्टेव के तहत चला सकता हूं? यदि ऐसा है तो क्या आप निर्देश दे सकते हैं?

— डिजिटल ट्रामा

हां, मैंने इसे माटलैब कहा क्योंकि यह किसी भी ऑक्टेव विशिष्ट कार्यों का उपयोग नहीं करता है। बस इसे fm नामक फ़ाइल में रखें और जैसेf([0,1;2,3],1000)

— Sanchises

समझा। 1) के रूप में सहेजें f.m। 2) शुरू करो octave। 3) load f.m; f([1,1,1;2,3,4],3)REPL प्रॉम्प्ट में पेस्ट करें - मेरे लिए काम करता है।

— डिजिटल ट्रामा

अगर तुम कहते हो तो! मैं केवल ऑक्टेव ऑनलाइन वेबसाइट का उपयोग करता हूं इसलिए यह पता नहीं है कि इसे कैसे काम करना चाहिए। मैं देखूंगा कि क्या मैं वहां से

— पर्मलिंक

Answer 11

जावा, 2179 बाइट्स

जस्ट वर्क आउट इट: - यह कोड जावा लैंग्वेज पर है।

import java.util.Scanner;

public class FebonnaciMatrix {
        static Scanner scan=new Scanner(System.in);

        public static void main(String[] args) {

        int x,y;
        System.out.println("For the Array to Work Upon:- ");

        System.out.println("Enter the Row:- ");
        int row=scan.nextInt();
        System.out.println("Enter the Column:- ");
        int col=scan.nextInt();

        int inpArr[][]=new int[row][col];

        System.out.println("Enter the values");
        inpArr=inpValues(row,col);

        System.out.println("The Input Array is:- ");
        display(inpArr,row,col);

        System.out.println("Input the Array size of Febonacci Array ");

        System.out.println("Enter the Row");
        int frow=scan.nextInt();
        System.out.println("Enter the Column");
        int fcol=scan.nextInt();

        int febArr[][]=new int[frow][fcol];
        febArr=copyValue(inpArr,febArr,row,col);

        for(x=0;x<row;x++)
        {
            for(y=col;y<fcol;y++)
                febArr[x][y]=febArr[x][y-2]+febArr[x][y-1];
        }

        for(x=row;x<frow;x++)
        {
            for(y=0;y<fcol;y++)
                febArr[x][y]=febArr[x-2][y]+febArr[x-1][y];
        }

        System.out.println();
        System.out.println("The Febonacci Array:-");
        display(febArr,frow,fcol);
    }

    static void display(int[][] arr,int row,int col)
    {
        int x,y;
        for(x=0;x<row;x++)
        {
            for(y=0;y<col;y++)
                System.out.print(arr[x][y]+"\t");
            System.out.println();
        }
    }

    static int[][] inpValues(int row,int col)
    {
        int arr[][]=new int[row][col];
        int x,y;
        for(x=0;x<row;x++)
        {
            for(y=0;y<col;y++)
            {
                System.out.print("Enter the value:- ");
                arr[x][y]=scan.nextInt();
            }
        }
        return arr;
    }

    static int[][] copyValue(int[][] old, int[][] ne, int row,int col)
    {
        int x,y;    
        for(x=0;x<row;x++)
        {
            for(y=0;y<col;y++)
                ne[x][y]=old[x][y];

        }
        return ne;
    }

}

Comments

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! प्रश्न को कोड-गोल्फ टैग किया गया है जिसका अर्थ है कि उत्तर संभव है कि कोड की कम से कम मात्रा में लिखा जाए (बाइट्स में)। आपका उत्तर अच्छी तरह से समस्या को हल कर सकता है, लेकिन मुझे कोड को "गोल्फ" करने का बहुत कम प्रयास दिखाई देता है (यानी इसे जितना संभव हो उतना कम करें)। आपके कोड के साथ ऐसा करने के लिए बहुत सारे तुच्छ अवसर हैं, जैसे 1-चर नामों के साथ चर, और अनावश्यक व्हाट्सएप को हटाना। परे कि आप इन युक्तियों

— डिजिटल ट्रॉमा

... क्या कोड-गोल्फ के लिए टैग-विकी पर एक नज़र है , खासकर मुझे कोड गोल्फ का जवाब कैसे देना चाहिए? कोई संकेत? अनुभाग। यह भी ध्यान दें कि जावा कई अन्य भाषाओं की तुलना में शॉर्ट कोड के लिए गोल्फ के लिए कुख्यात है। हालांकि यह आपको निराश नहीं करना चाहिए - यदि आपके पास एक अच्छी तरह से गोल्फ जावा का जवाब है, तो यह काफी लोकप्रिय होने की संभावना है, भले ही यह अन्य सभी उत्तरों की तुलना में लंबा हो। सभी मन-मुटाव वाले लघु एसोलैंग उत्तरों से दूर न रहें - यह समुदाय भाषा के अवरोधों को ध्यान में रखते हुए अच्छा होता है।

— डिजिटल ट्रामा

@ DigitalTrauma- धन्यवाद ... मुझे इस के लिए एक newbee के रूप में मदद करने के लिए ... मैं निश्चित रूप से लिंक के माध्यम से जाऊँगा और एक नया कोड लेकर आऊँगा ...

— ध्रुव गोविला

चूंकि आप एक नए उपयोगकर्ता हैं, इसलिए मैंने बेहतर प्रारूपण के लिए आपके उत्तर को संपादित करने की स्वतंत्रता ली। विशेष रूप से) भाषा का स्पष्ट शीर्षक और बाइट्स की संख्या, बी) आपके कोड का कोड स्वरूपण। सभी स्टेक्सएक्सचेंज साइटों पर, कोड स्वरूपण आसान है - बस 4 स्थानों के साथ अपने सभी कोड लाइनों को उपसर्ग करें। वास्तव में और भी आसान है - संपादन बॉक्स में, अपना कोड चुनें, फिर {}संपादन बॉक्स के शीर्ष पर क्लिक करें - यह स्वचालित रूप से यह उपसर्ग कर देगा।

— डिजिटल ट्रॉमा

ठीक है ... मैं अभी इसकी जाँच करूंगा ...

— ध्रुव गोविला

Answer 12

पायथन, 103 105 बाइट्स

f=lambda n,L:f(n-1,[l+[sum(l[-2:])]for l in L])if n else L
lambda n,L:zip(*f(n,map(list,zip(*f(n,L)))))

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

बकरिउ को धन्यवाद दो बाइट्स बचाए

Comments

n>0बस हो सकता है n, क्योंकि आप एक सकारात्मक के साथ शुरू करते हैं nऔर जब आप 0इसके मूल्य पर पहुंचते हैं तो यह गलत है।

— बाकुरि

Answer 13

एपीएल (डायलॉग क्लासिक) , 17 बाइट्स

{⍉⍵,⊢/2+/⍵}⍣2⍣⎕⊢⎕

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

Answer 14

पर्ल 6 ,  87 73  71 बाइट्स

->\c,\m{for ^c {.[+*]=[+] .[*X-1,2]for m;m.push: [map {[+] m[*X-1,2;$_]},m[0].keys]};m}
->\c,\m{for ^c {.[+*]=[+] .[*X-1,2]for m;m[+*]=[m[*-2;*] »+«m[*-1]]};m}
->\c,\m{for ^c {.[+*]=[+] .[*X-1,2]for m;m[+*]=[m[*-2;*]Z+m[*-1;*]]};m}

-> \c, \m {
  for ^c { # 0 ..^ c

    # each row
    .[+*]                            # new column at the end of row ($_)
          = [+] .[ * X- 1,2 ]        # add up the last two entries in row ($_)
                              for m; # for every row

    # too bad this was longer than the above code
    # m[*;+*]=map *+*,m[*;*-2,*-1]

    # each column
    m[ +* ]                 # add new row
            = [             # make it an Array rather than a List
                m[ *-2; * ] # the second to last row
                »+«         # added columnwise with
                m[ *-1 ]    # the last row
              ]
  };

  m # return the result
}

उपयोग:

use v6.c;
# give it a lexical name
my &code = ->\c,\m{ … }

my @return = code 3,[[1,1,1],[2,3,4]];

put '[ ', $_».fmt('%2d'), ' ]' for @return;

put '';

put @return.perl ~~ {S:g/' '//};

[  1  1  1  2  3  5 ]
[  2  3  4  7 11 18 ]
[  3  4  5  9 14 23 ]
[  5  7  9 16 25 41 ]
[  8 11 14 25 39 64 ]

[[1,1,1,2,3,5],[2,3,4,7,11,18],[3,4,5,9,14,23],[5,7,9,16,25,41],[8,11,14,25,39,64]]

Comments

इसमें पेस्ट करने से perl6 मुझे कुछ त्रुटियां होती हैं । मैं एक perl नौसिखिया हूँ - मैं क्या गलत कर रहा हूँ?

— डिजिटल ट्रामा

@DigitalTrauma मुझे खेद है कि मुझे my &code = ->\c,\m{ … }यह स्पष्ट करने के लिए उपयोग लिखना चाहिए था कि ->\c,\m{ … }ऊपर दिए गए कोड के साथ प्रतिस्थापित किया जाना चाहिए। मैं आमतौर पर एक अंतर्निहित $_या @_स्पष्ट प्लेसहोल्डर मापदंडों का उपयोग करता हूं $^aक्योंकि वे छोटे होते हैं। मैंने अभी इसके बारे में नहीं सोचा था। यह भी सुनिश्चित करें कि आप एक नए पर्याप्त संस्करण ( $*PERL.compiler.version !before 2015.12) का उपयोग कर रहे हैं

— ब्रैड गिल्बर्ट b2gills 22

@DigitalTrauma आप freenode.net पर # perl6 चैनल पर भी जा सकते हैं और कोडेलिया (इस तरह) का उपयोग कोड चलाने के लिए m: कर सकते हैं (पूर्ववर्ती पंक्तियों और एक स्थान के साथ) आप सीधे संदेश

— कैमलिया