행렬의 각 행과 열에 대해 해당 행이나 열의 마지막 두 항목의 합으로 추가 항목을 추가 할 수 있습니다. 예를 들어 다음 입력 매트릭스를 사용하십시오.

[ 1 1 1 ]
[ 2 3 4 ]

결과 행렬은 다음과 같습니다.

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

정수 N의 입력과 크기가 2x2 이상인 [X, Y] 행렬이 주어지면 위의 확장 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 ]

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

J, 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

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

여기에서 시도 하십시오 .

젤리, 15 13 12 바이트

@Dennis에 의해 -1 바이트

ṫ-S;@"Z
ÇḤ}¡

@LuisMendo의 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.

여기에서 시도 하십시오 .

ES6, 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

하스켈, 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

CJam, 17 16 바이트

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

입력 형식은 먼저 행렬 (CJam 스타일 2D 배열)이며 이후 반복 횟수입니다.

여기에서 테스트하십시오.

설명

이것은 다른 사람들과 동일한 솔루션으로 밝혀졌습니다.

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.

정말 20 바이트

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

행렬을 2D 목록으로 입력 한 다음 N . 2D리스트를 출력합니다.

이 버전은 어떤 이유로 온라인 인터프리터에서는 작동하지 않지만 이 사전 도전 커밋 에서는 작동합니다. 합니다.

23 바이트 동안 온라인에서 작동하는 버전 :

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

반대 순서로 입력을 취합니다 ( N, 행렬).

온라인으로 사용해보십시오!

잠시 잠을 잔 후에 설명을 추가하겠습니다. 통역사 버그를 해결하는 것은 결코 재미가 없습니다.

Pyth, 13 12 바이트

u+Rs>2dCGyEQ

온라인으로 사용해보십시오. 테스트 스위트.

대부분의 답변에 동일한 알고리즘을 사용합니다. 첫 번째 줄에서 행렬을 2D 배열로 입력하고n 두 번째 줄 받습니다.

설명

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 바이트

A(end+1,:)=sum...이 희귀 한 경우에 간단한 연결이 실제로 Matlab에서 더 저렴하다는 것을 알기 전에 Matlab의 멋진 색인 방법 (즉, ) 을 처음으로 엉망 으로 만들었습니다. 너무 나빠서 이것을 실제 함수로 변환해야했습니다. 옥타브에서도 작동합니다.

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 초입니다! (또는 A가 gpuArray신뢰할 수있는 Quadro 1000M 덕분에 약 30 초 )

자바, 2179 바이트

방금 해결 :-이 코드는 Java 언어입니다.

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

}

파이썬, (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다시 전달 된 다음 두 번째 이동의 출력이 다시 바뀝니다. 출력은 튜플 목록입니다

bakuriu 덕분에 2 바이트 절약

APL (Dyalog Classic) , 17 바이트

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

온라인으로 사용해보십시오!

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