Untuk setiap baris dan kemudian kolom dari sebuah matriks, kita dapat menambahkan entri tambahan dengan jumlah dari dua entri terakhir di baris atau kolom itu. Misalnya dengan matriks input berikut:

[ 1 1 1 ]
[ 2 3 4 ]

Matriks yang dihasilkan adalah:

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

Diberikan input integer N dan [X, Y] matriks ukuran setidaknya 2x2, lakukan ekspansi N kali di atas dan hasilkan hasilnya. Matriks yang dihasilkan akan selalu berukuran [X + N, Y + N].

Contoh:

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 ]

MATL , 13 14 15 16 20 21 byte

2*:"!tP2:Y)sv

Terima kasih @Zgarb karena menghapus 1 byte!

Cobalah online!

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

J, 19 byte

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

Ini mendefinisikan kata keterangan, yang mengambil angka di sebelah kiri, dan menghasilkan kata kerja mengambil matriks di sebelah kanannya. Untuk contoh kedua, ini memberi

  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

Penjelasan

(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

K, 23 byte

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

Beraksi:

  {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)

Coba di sini .

Jelly, 15 13 12 byte

-1 byte oleh @Dennis

ṫ-S;@"Z
ÇḤ}¡

Seperti jawaban @ LuisMendo, MATL, transpos array sebelum melakukan transformasi sepanjang satu sumbu. Karena itu, kita perlu memanggil fungsi 2 * n kali.

ṫ-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.

Coba di sini .

ES6, 134 byte

(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))

Penjelasan:

(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

Haskell, 67 byte

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

Contoh penggunaan:

*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]]

Bagaimana itu bekerja:

(!!).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

CJam, 17 16 byte

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

Format input adalah matriks pertama (sebagai array 2D gaya-CJam) dan jumlah iterasi sesudahnya.

Uji di sini.

Penjelasan

Ternyata ini adalah solusi yang sama dengan solusi orang lain:

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.

Serius, 20 byte

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

Mengambil input matriks (sebagai daftar 2D), lalu N. Menghasilkan daftar 2D.

Versi ini tidak bekerja pada penerjemah online untuk beberapa alasan, tetapi bekerja dengan komit pra-tantangan ini .

Versi yang berfungsi online, selama 23 byte:

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

Mengambil input dalam urutan yang berlawanan (N , lalu matriks).

Cobalah online!

Saya akan menambahkan penjelasan setelah saya tidur sebentar. Mengatasi bug juru bahasa tidak pernah menyenangkan.

Pyth, 13 12 byte

u+Rs>2dCGyEQ

Cobalah online. Suite uji.

Menggunakan algoritma yang sama untuk sebagian besar jawaban. Dibawa sebagai input matriks sebagai array 2D pada baris pertama dann di baris kedua.

Penjelasan

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

Matlab, 60 byte

Saya pertama kali mengacaukan dengan metode pengindeksan mewah Matlab (yaitu, A(end+1,:)=sum...) sebelum saya menemukan bahwa dalam kasus yang jarang terjadi ini, penggabungan sederhana sebenarnya lebih murah di Matlab. Sayang sekali saya harus mengubah ini menjadi fungsi yang sebenarnya. Harus bekerja dengan Oktaf juga.

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

Saya kira ini adalah contoh utama bagaimana tidak membuat algoritma. Untuk A = 2x2, n = 1000 algoritma ini sudah membutuhkan 5 detik pada laptop saya, n = 2000 hampir 50 detik! (atau sekitar 30-an jika A adalah gpuArrayterima kasih kepada Quadro 1000M terpercaya saya)

Java, 2179 byte

Hanya Berhasil: - Kode ini pada Bahasa Jawa.

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;
    }

}

Python, 103 105 byte

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

Fungsi anonim mengambil daftar daftar dan beralih ke fungsi rekursif f. Output ditransposisikan dan kemudian diteruskan ke flagi, kemudian output go kedua ditransposisikan ulang. Output adalah daftar tupel

Disimpan dua byte berkat bakuriu

APL (Dyalog Classic) , 17 byte

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

Cobalah online!

Perl 6 ,  87 73  71 byte

->\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
}

Pemakaian:

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